diff --git a/.clang-format b/.clang-format
new file mode 100644
index 0000000000..73dc2aeb8f
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,27 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you 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.
+---
+BasedOnStyle:  Google
+DerivePointerAlignment: false
+ColumnLimit: 120
+IndentWidth: 4
+AccessModifierOffset: -3
+AlwaysBreakAfterReturnType: All
+AllowShortBlocksOnASingleLine: false
+AllowShortFunctionsOnASingleLine: false
+AllowShortIfStatementsOnASingleLine: false
+AlignTrailingComments: true
diff --git a/.clang-tidy b/.clang-tidy
new file mode 100644
index 0000000000..1695fa6685
--- /dev/null
+++ b/.clang-tidy
@@ -0,0 +1,33 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you 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.
+---
+Checks:          'clang-diagnostic-*,clang-analyzer-*,-clang-analyzer-alpha*,google-*,modernize-*,readability-*'
+# produce HeaderFilterRegex from cpp/build-support/lint_exclusions.txt with:
+# echo -n '^('; sed -e 's/*/\.*/g' cpp/build-support/lint_exclusions.txt | tr '\n' '|'; echo ')$'
+HeaderFilterRegex: '^(.*cmake-build-debug.*|.*cmake-build-release.*|.*cmake_build.*|.*src/core/thirdparty.*|.*thirdparty.*|.*easylogging++.*|.*SqliteMetaImpl.cpp|.*src/grpc.*|.*src/core.*|.*src/wrapper.*)$'
+AnalyzeTemporaryDtors: true
+ChainedConditionalReturn: 1
+ChainedConditionalAssignment: 1
+CheckOptions:
+  - key:             google-readability-braces-around-statements.ShortStatementLines
+    value:           '1'
+  - key:             google-readability-function-size.StatementThreshold
+    value:           '800'
+  - key:             google-readability-namespace-comments.ShortNamespaceLines
+    value:           '10'
+  - key:             google-readability-namespace-comments.SpacesBeforeComments
+    value:           '2'
diff --git a/.clang-tidy-ignore b/.clang-tidy-ignore
new file mode 100644
index 0000000000..d0a78df219
--- /dev/null
+++ b/.clang-tidy-ignore
@@ -0,0 +1,17 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you 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.
+#
diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md
index 8d2a7cbfc4..d3a9f247d6 100644
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@@ -1,5 +1,5 @@
 ---
-name: Bug report
+name: "\U0001F41B Bug report"
 about: Create a bug report to help us improve Milvus
 title: "[BUG]"
 labels: ''
diff --git a/.github/ISSUE_TEMPLATE/documentation-request.md b/.github/ISSUE_TEMPLATE/documentation-request.md
index 91a17502ef..1e3193f9f3 100644
--- a/.github/ISSUE_TEMPLATE/documentation-request.md
+++ b/.github/ISSUE_TEMPLATE/documentation-request.md
@@ -1,5 +1,5 @@
 ---
-name: Documentation request
+name: "\U0001F4DD Documentation request"
 about: Report incorrect or needed documentation
 title: "[DOC]"
 labels: ''
diff --git a/.github/ISSUE_TEMPLATE/feature_request.md b/.github/ISSUE_TEMPLATE/feature_request.md
index d08948c4ed..24de651b12 100644
--- a/.github/ISSUE_TEMPLATE/feature_request.md
+++ b/.github/ISSUE_TEMPLATE/feature_request.md
@@ -1,5 +1,5 @@
 ---
-name: Feature request
+name: "\U0001F680 Feature request"
 about: Suggest an idea for Milvus
 title: "[FEATURE]"
 labels: ''
diff --git a/.github/ISSUE_TEMPLATE/general-question.md b/.github/ISSUE_TEMPLATE/general-question.md
index 8e59ee063a..32ce5dd701 100644
--- a/.github/ISSUE_TEMPLATE/general-question.md
+++ b/.github/ISSUE_TEMPLATE/general-question.md
@@ -1,5 +1,5 @@
 ---
-name: General question
+name: "\U0001F914 General question"
 about: Ask a general question about Milvus
 title: "[QUESTION]"
 labels: ''
diff --git a/.gitignore b/.gitignore
index 259148fa18..6b2d6fc97b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,32 +1,28 @@
-# Prerequisites
-*.d
+# CLion generated files
+core/cmake-build-debug/
+core/cmake-build-release/
+core/cmake_build
+core/.idea/
+core/thirdparty/knowhere_build
 
-# Compiled Object files
-*.slo
-*.lo
-*.o
-*.obj
+.idea/
+.ycm_extra_conf.py
+__pycache__
 
-# Precompiled Headers
-*.gch
-*.pch
+# vscode generated files
+.vscode
 
-# Compiled Dynamic libraries
-*.so
-*.dylib
-*.dll
+.env
+build
+cmake-build-debug
+cmake-build-release
+cmake_build
 
-# Fortran module files
-*.mod
-*.smod
-
-# Compiled Static libraries
-*.lai
-*.la
+# Compiled source
 *.a
-*.lib
-
-# Executables
-*.exe
-*.out
-*.app
+*.so
+*.so.*
+*.o
+*.lo
+*.tar.gz
+*.log
diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000000..448c29af60
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,375 @@
+# Changelog
+
+Please mark all change in change log and use the ticket from JIRA.
+
+# Milvus 0.5.1 (TODO)
+
+## Bug
+## Improvement
+- \#64 - Improvement dump function in scheduler
+
+## Feature
+## Task
+
+# Milvus 0.5.0 (2019-10-21)
+
+## Bug
+- MS-568 - Fix gpuresource free error
+- MS-572 - Milvus crash when get SIGINT
+- MS-577 - Unittest Query randomly hung
+- MS-587 - Count get wrong result after adding vectors and index built immediately
+- MS-599 - Search wrong result when table created with metric_type: IP
+- MS-601 - Docker logs error caused by get CPUTemperature error
+- MS-605 - Server going down during searching vectors
+- MS-620 - Get table row counts display wrong error code
+- MS-622 - Delete vectors should be failed if date range is invalid
+- MS-624 - Search vectors failed if time ranges long enough
+- MS-637 - Out of memory when load too many tasks
+- MS-639 - SQ8H index created failed and server hang
+- MS-640 - Cache object size calculate incorrect
+- MS-641 - Segment fault(signal 11) in PickToLoad
+- MS-644 - Search crashed with index-type: flat
+- MS-647 - grafana display average cpu-temp
+- MS-652 - IVFSQH quantization double free
+- MS-650 - SQ8H index create issue
+- MS-653 - When config check fail, Milvus close without message
+- MS-654 - Describe index timeout when building index
+- MS-658 - Fix SQ8 Hybrid can't search
+- MS-665 - IVF_SQ8H search crash when no GPU resource in search_resources
+- \#9 - Change default gpu_cache_capacity to 4
+- \#20 - C++ sdk example get grpc error 
+- \#23 - Add unittest to improve code coverage
+- \#31 - make clang-format failed after run build.sh -l
+- \#39 - Create SQ8H index hang if using github server version
+- \#30 - Some troubleshoot messages in Milvus do not provide enough information
+- \#48 - Config unittest failed
+- \#59 - Topk result is incorrect for small dataset
+
+## Improvement
+- MS-552 - Add and change the easylogging library
+- MS-553 - Refine cache code
+- MS-555 - Remove old scheduler
+- MS-556 - Add Job Definition in Scheduler
+- MS-557 - Merge Log.h
+- MS-558 - Refine status code
+- MS-562 - Add JobMgr and TaskCreator in Scheduler
+- MS-566 - Refactor cmake
+- MS-574 - Milvus configuration refactor
+- MS-578 - Make sure milvus5.0 don't crack 0.3.1 data
+- MS-585 - Update namespace in scheduler
+- MS-606 - Speed up result reduce
+- MS-608 - Update TODO names
+- MS-609 - Update task construct function
+- MS-611 - Add resources validity check in ResourceMgr
+- MS-619 - Add optimizer class in scheduler
+- MS-626 - Refactor DataObj to support cache any type data
+- MS-648 - Improve unittest
+- MS-655 - Upgrade SPTAG
+- \#42 - Put union of index_build_device and search resources to gpu_pool
+- \#67 - Avoid linking targets multiple times in cmake
+
+## Feature
+- MS-614 - Preload table at startup
+- MS-627 - Integrate new index: IVFSQHybrid
+- MS-631 - IVFSQ8H Index support
+- MS-636 - Add optimizer in scheduler for FAISS_IVFSQ8H
+
+## Task
+- MS-554 - Change license to Apache 2.0
+- MS-561 - Add contributing guidelines, code of conduct and README docs
+- MS-567 - Add NOTICE.md
+- MS-569 - Complete the NOTICE.md
+- MS-575 - Add Clang-format & Clang-tidy & Cpplint
+- MS-586 - Remove BUILD_FAISS_WITH_MKL option
+- MS-590 - Refine cmake code to support cpplint
+- MS-600 - Reconstruct unittest code
+- MS-602 - Remove zilliz namespace
+- MS-610 - Change error code base value from hex to decimal
+- MS-624 - Re-organize project directory for open-source
+- MS-635 - Add compile option to support customized faiss
+- MS-660 - add ubuntu_build_deps.sh
+- \#18 - Add all test cases
+	
+# Milvus 0.4.0 (2019-09-12)
+
+## Bug
+- MS-119 - The problem of combining the log files
+- MS-121 - The problem that user can't change the time zone
+- MS-411 - Fix metric unittest linking error
+- MS-412 - Fix gpu cache logical error
+- MS-416 - ExecutionEngineImpl::GpuCache has not return value cause crash
+- MS-417 - YAML sequence load disable cause scheduler startup failed
+- MS-413 - Create index failed and server exited
+- MS-427 - Describe index error after drop index
+- MS-432 - Search vectors params nprobe need to check max number
+- MS-431 - Search vectors params nprobe: 0/-1, expected result: raise exception
+- MS-331 - Crate Table : when table exists, error code is META_FAILED(code=15) rather than ILLEGAL TABLE NAME(code=9))
+- MS-430 - Search no result if index created with FLAT
+- MS-443 - Create index hang again
+- MS-436 - Delete vectors failed if index created with index_type: IVF_FLAT/IVF_SQ8
+- MS-449 - Add vectors twice success, once with ids, the other no ids
+- MS-450 - server hang after run stop_server.sh
+- MS-458 - Keep building index for one file when no gpu resource
+- MS-461 - Mysql meta unittest failed
+- MS-462 - Run milvus server twices, should display error
+- MS-463 - Search timeout
+- MS-467 - mysql db test failed
+- MS-470 - Drop index success, which table not created
+- MS-471 - code coverage run failed
+- MS-492 - Drop index failed if index have been created with index_type: FLAT
+- MS-493 - Knowhere unittest crash
+- MS-453 - GPU search error when nprobe set more than 1024
+- MS-474 - Create index hang if use branch-0.3.1 server config
+- MS-510 - unittest out of memory and crashed
+- MS-507 - Dataset 10m-512, index type sq8，performance in-normal when set CPU_CACHE to 16 or 64
+- MS-543 - SearchTask fail without exception
+- MS-582 - grafana displays changes frequently
+
+## Improvement
+- MS-327 - Clean code for milvus
+- MS-336 - Scheduler interface
+- MS-344 - Add TaskTable Test
+- MS-345 - Add Node Test
+- MS-346 - Add some implementation of scheduler to solve compile error
+- MS-348 - Add ResourceFactory Test
+- MS-350 - Remove knowhere submodule
+- MS-354 - Add task class and interface in scheduler
+- MS-355 - Add copy interface in ExcutionEngine
+- MS-357 - Add minimum schedule function
+- MS-359 - Add cost test in new scheduler
+- MS-361 - Add event in resource
+- MS-364 - Modify tasktableitem in tasktable
+- MS-365 - Use tasktableitemptr instead in event
+- MS-366 - Implement TaskTable
+- MS-368 - Implement cost.cpp
+- MS-371 - Add TaskTableUpdatedEvent
+- MS-373 - Add resource test
+- MS-374 - Add action definition
+- MS-375 - Add Dump implementation for Event
+- MS-376 - Add loader and executor enable flag in Resource avoid diskresource execute task
+- MS-377 - Improve process thread trigger in ResourceMgr, Scheduler and TaskTable
+- MS-378 - Debug and Update normal_test in scheduler unittest
+- MS-379 - Add Dump implementation in Resource
+- MS-380 - Update resource loader and executor, work util all finished
+- MS-383 - Modify condition variable usage in scheduler
+- MS-384 - Add global instance of ResourceMgr and Scheduler
+- MS-389 - Add clone interface in Task
+- MS-390 - Update resource construct function
+- MS-391 - Add PushTaskToNeighbourHasExecutor action
+- MS-394 - Update scheduler unittest
+- MS-400 - Add timestamp record in task state change function
+- MS-402 - Add dump implementation for TaskTableItem
+- MS-406 - Add table flag for meta
+- MS-403 - Add GpuCacheMgr
+- MS-404 - Release index after search task done avoid memory increment continues
+- MS-405 - Add delete task support
+- MS-407 - Reconstruct MetricsCollector
+- MS-408 - Add device_id in resource construct function
+- MS-409 - Using new scheduler
+- MS-413 - Remove thrift dependency
+- MS-410 - Add resource config comment
+- MS-414 - Add TaskType in Scheduler::Task
+- MS-415 - Add command tasktable to dump all tasktables
+- MS-418 - Update server_config.template file, set CPU compute only default
+- MS-419 - Move index_file_size from IndexParam to TableSchema
+- MS-421 - Add TaskLabel in scheduler
+- MS-422 - Support DeleteTask in Multi-GpuResource case
+- MS-428 - Add PushTaskByDataLocality in scheduler
+- MS-440 - Add DumpTaskTables in sdk
+- MS-442 - Merge Knowhere
+- MS-445 - Rename CopyCompleted to LoadCompleted
+- MS-451 - Update server_config.template file, set GPU compute default
+- MS-455 - Distribute tasks by minimal cost in scheduler
+- MS-460 - Put transport speed as weight when choosing neighbour to execute task
+- MS-459 - Add cache for pick function in tasktable
+- MS-476 - Improve search performance
+- MS-482 - Change search stream transport to unary in grpc
+- MS-487 - Define metric type in CreateTable
+- MS-488 - Improve code format in scheduler
+- MS-495 - cmake: integrated knowhere
+- MS-496 - Change the top_k limitation from 1024 to 2048
+- MS-502 - Update tasktable_test in scheduler
+- MS-504 - Update node_test in scheduler
+- MS-505 - Install core unit test and add to coverage
+- MS-508 - Update normal_test in scheduler
+- MS-532 - Add grpc server unittest
+- MS-511 - Update resource_test in scheduler
+- MS-517 - Update resource_mgr_test in scheduler
+- MS-518 - Add schedinst_test in scheduler
+- MS-519 - Add event_test in scheduler
+- MS-520 - Update resource_test in scheduler
+- MS-524 - Add some unittest in event_test and resource_test
+- MS-525 - Disable parallel reduce in SearchTask
+- MS-527 - Update scheduler_test and enable it
+- MS-528 - Hide some config used future
+- MS-530 - Add unittest for SearchTask->Load
+- MS-531 - Disable next version code
+- MS-533 - Update resource_test to cover dump function
+- MS-523 - Config file validation
+- MS-539 - Remove old task code
+- MS-546 - Add simple mode resource_config
+- MS-570 - Add prometheus docker-compose file
+- MS-576 - Scheduler refactor
+- MS-592 - Change showtables stream transport to unary
+
+## Feature
+- MS-343 - Implement ResourceMgr
+- MS-338 - NewAPI: refine code to support CreateIndex
+- MS-339 - NewAPI: refine code to support DropIndex
+- MS-340 - NewAPI: implement DescribeIndex
+
+## Task
+- MS-297 - disable mysql unit test
+
+# Milvus 0.3.1 (2019-07-10)
+
+## Bug
+
+- MS-148 - Disable cleanup if mode is read only
+- MS-149 - Fixed searching only one index file issue in distributed mode
+- MS-153 - Fix c_str error when connecting to MySQL
+- MS-157 - Fix changelog
+- MS-190 - Use env variable to switch mem manager and fix cmake
+- MS-217 - Fix SQ8 row count bug
+- MS-224 - Return AlreadyExist status in MySQLMetaImpl::CreateTable if table already exists
+- MS-232 - Add MySQLMetaImpl::UpdateTableFilesToIndex and set maximum_memory to default if config value = 0
+- MS-233 - Remove mem manager log
+- MS-230 - Change parameter name: Maximum_memory to insert_buffer_size
+- MS-234 - Some case cause background merge thread stop
+- MS-235 - Some test cases random fail
+- MS-236 - Add MySQLMetaImpl::HasNonIndexFiles
+- MS-257 - Update bzip2 download url
+- MS-288 - Update compile scripts
+- MS-330 - Stability test failed caused by server core dumped
+- MS-347 - Build index hangs again
+- MS-382 - fix MySQLMetaImpl::CleanUpFilesWithTTL unknown column bug
+
+## Improvement
+- MS-156 - Add unittest for merge result functions
+- MS-152 - Delete assert in MySQLMetaImpl and change MySQLConnectionPool impl
+- MS-204 - Support multi db_path
+- MS-206 - Support SQ8 index type
+- MS-208 - Add buildinde interface for C++ SDK
+- MS-212 - Support Inner product metric type
+- MS-241 - Build Faiss with MKL if using Intel CPU; else build with OpenBlas
+- MS-242 - Clean up cmake and change MAKE_BUILD_ARGS to be user defined variable
+- MS-245 - Improve search result transfer performance
+- MS-248 - Support AddVector/SearchVector profiling
+- MS-256 - Add more cache config
+- MS-260 - Refine log
+- MS-249 - Check machine hardware during initialize
+- MS-261 - Update faiss version to 1.5.3 and add BUILD_FAISS_WITH_MKL as an option
+- MS-266 - Improve topk reduce time by using multi-threads
+- MS-275 - Avoid sqlite logic error excetion
+- MS-278 - add IndexStatsHelper
+- MS-313 - add GRPC
+- MS-325 - add grpc status return for C++ sdk and modify some format
+- MS-278 - Add IndexStatsHelper
+- MS-312 - Set openmp thread number by config
+- MS-305 - Add CPU core percent metric
+- MS-310 - Add milvus CPU utilization ratio and CPU/GPU temperature metrics
+- MS-324 - Show error when there is not enough gpu memory to build index
+- MS-328 - Check metric type on server start
+- MS-332 - Set grpc and thrift server run concurrently
+- MS-352 - Add hybrid index
+
+## Feature
+- MS-180 - Add new mem manager
+- MS-195 - Add nlist and use_blas_threshold conf
+- MS-137 - Integrate knowhere
+
+## Task
+
+- MS-125 - Create 0.3.1 release branch
+- MS-306 - Optimize build efficiency
+
+# Milvus 0.3.0 (2019-06-30)
+
+## Bug
+- MS-104 - Fix unittest lcov execution error
+- MS-102 - Fix build script file condition error
+- MS-80 - Fix server hang issue
+- MS-89 - Fix compile failed, libgpufaiss.a link missing
+- MS-90 - Fix arch match incorrect on ARM
+- MS-99 - Fix compilation bug
+- MS-110 - Avoid huge file size
+
+## Improvement
+- MS-82 - Update server startup welcome message
+- MS-83 - Update vecwise to Milvus
+- MS-77 - Performance issue of post-search action
+- MS-22 - Enhancement for MemVector size control 
+- MS-92 - Unify behavior of debug and release build
+- MS-98 - Install all unit test to installation directory
+- MS-115 - Change is_startup of metric_config switch from true to on
+- MS-122 - Archive criteria config 
+- MS-124 - HasTable interface
+- MS-126 - Add more error code
+- MS-128 - Change default db path
+
+## Feature
+
+- MS-57 - Implement index load/search pipeline
+- MS-56 - Add version information when server is started
+- MS-64 - Different table can have different index type
+- MS-52 - Return search score
+- MS-66 - Support time range query
+- MS-68 - Remove rocksdb from third-party
+- MS-70 - cmake: remove redundant libs in src
+- MS-71 - cmake: fix faiss dependency
+- MS-72 - cmake: change prometheus source to git
+- MS-73 - cmake: delete civetweb
+- MS-65 - Implement GetTableRowCount interface
+- MS-45 - Implement DeleteTable interface
+- MS-75 - cmake: change faiss version to 1.5.2; add CUDA gencode
+- MS-81 - fix faiss ptx issue; change cuda gencode
+- MS-84 - cmake: add arrow, jemalloc and jsoncons third party; default build option OFF
+- MS-85 - add NetIO metric
+- MS-96 - add new query interface for specified files
+- MS-97 - Add S3 SDK for MinIO Storage
+- MS-105 - Add MySQL
+- MS-130 - Add prometheus_test
+- MS-144 - Add nprobe config
+- MS-147 - Enable IVF
+- MS-130 - Add prometheus_test
+
+## Task
+- MS-74 - Change README.md in cpp
+- MS-88 - Add support for arm architecture
+
+# Milvus 0.2.0 (2019-05-31)
+
+## Bug
+
+- MS-32 - Fix thrift error
+- MS-34 - Fix prometheus-cpp thirdparty
+- MS-67 - Fix license check bug
+- MS-76 - Fix pipeline crash bug
+- MS-100 - cmake: fix AWS build issue
+- MS-101 - change AWS build type to Release
+
+## Improvement
+
+- MS-20 - Clean Code Part 1
+
+## Feature
+
+- MS-5 - Implement Auto Archive Feature
+- MS-6 - Implement SDK interface part 1
+- MS-16 - Implement metrics without prometheus
+- MS-21 - Implement SDK interface part 2
+- MS-26 - cmake. Add thirdparty packages
+- MS-31 - cmake: add prometheus
+- MS-33 - cmake: add -j4 to make third party packages build faster
+- MS-27 - support gpu config and disable license build config in cmake
+- MS-47 - Add query vps metrics
+- MS-37 - Add query, cache usage, disk write speed and file data size metrics
+- MS-30 - Use faiss v1.5.2
+- MS-54 - cmake: Change Thrift third party URL to github.com
+- MS-69 - prometheus: add all proposed metrics
+
+## Task
+
+- MS-1 - Add CHANGELOG.md
+- MS-4 - Refactor the vecwise_engine code structure
+- MS-62 - Search range to all if no date specified
diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md
new file mode 100644
index 0000000000..ef3cc592c6
--- /dev/null
+++ b/CODE_OF_CONDUCT.md
@@ -0,0 +1,48 @@
+# Milvus Code of Conduct
+
+In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment include:
+
+- Using welcoming and inclusive language.
+- Being respectful of differing viewpoints and experiences.
+- Gracefully accepting constructive criticism.
+- Focusing on what is best for the community.
+- Showing empathy towards other community members.
+
+Examples of unacceptable behavior by participants include:
+
+- The use of sexualized language or imagery and unwelcome sexual attention or advances.
+- Trolling, insulting/derogatory comments, and personal or political attacks.
+- Public or private harassment.
+- Publishing others' private information, such as a physical or electronic address, without explicit permission.
+- Conduct which could reasonably be considered inappropriate for the forum in which it occurs.
+
+All Milvus forums and spaces are meant for professional interactions, and any behavior which could reasonably be considered inappropriate in a professional setting is unacceptable.
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies to all content on milvus.io, Milvus’s GitHub organization, or any other official Milvus web presence allowing for community interactions, as well as at all official Milvus events, whether offline or online.
+
+The Code of Conduct also applies within all project spaces and in public spaces whenever an individual is representing Milvus or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed or de facto representative at an online or offline event. Representation of Milvus may be further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at support@zilliz.com. All complaints will be reviewed and investigated and will result in a response that is deemed necessary and appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant](https://www.contributor-covenant.org/), version 1.4, available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
+
+For answers to common questions about this code of conduct, see https://www.contributor-covenant.org/faq
+
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 0000000000..475387c319
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,118 @@
+# Contributing to Milvus
+
+First of all, thanks for taking the time to contribute to Milvus! It's people like you that help Milvus come to fruition. :tada:
+
+The following are a set of guidelines for contributing to Milvus. Following these guidelines helps contributing to this project easy and transparent. These are mostly guideline, not rules. Use your best judgment, and feel free to propose changes to this document in a pull request.
+
+As for everything else in the project, the contributions to Milvus are governed by our [Code of Conduct](CODE_OF_CONDUCT.md).
+
+## Contribution Checklist
+
+Before you make any contributions, make sure you follow this list.
+
+- Read [Contributing to Milvus](CONTRIBUTING.md).
+- Check if the changes are consistent with the [coding style](CONTRIBUTING.md#coding-style), and format your code accordingly.
+- Run [unit tests](CONTRIBUTING.md#run-unit-test-with-code-coverage) and check your code coverage rate.
+
+## What contributions can I make?
+
+Contributions to Milvus fall into the following categories.
+
+1. To report a bug or a problem with documentation, please file an [issue](https://github.com/milvus-io/milvus/issues/new/choose) providing the details of the problem. If you believe the issue needs priority attention, please comment on the issue to notify the team.
+2. To propose a new feature, please file a new feature request [issue](https://github.com/milvus-io/milvus/issues/new/choose). Describe the intended feature and discuss the design and implementation with the team and community. Once the team agrees that the plan looks good, go ahead and implement it, following the [Contributing code](CONTRIBUTING.md#contributing-code).
+3. To implement a feature or bug-fix for an existing outstanding issue, follow the [Contributing code](CONTRIBUTING.md#contributing-code). If you need more context on a particular issue, comment on the issue to let people know.
+
+## How can I contribute?
+
+### Contributing code
+
+If you have improvements to Milvus, send us your pull requests! For those just getting started, see [GitHub workflow](#github-workflow).
+
+The Milvus team members will review your pull requests, and once it is accepted, it will be given a `ready to merge` label. This means we are working on submitting your pull request to the internal repository. After the change has been submitted internally, your pull request will be merged automatically on GitHub.
+
+### GitHub workflow
+
+Please create a new branch from an up-to-date master on your fork.
+
+1. Fork the repository on GitHub.
+2. Clone your fork to your local machine with `git clone git@github.com:<yourname>/milvus-io/milvus.git`.
+3. Create a branch with `git checkout -b my-topic-branch`.
+4. Make your changes, commit, then push to to GitHub with `git push --set-upstream origin my-topic-branch`.
+5. Visit GitHub and make your pull request.
+
+If you have an existing local repository, please update it before you start, to minimize the chance of merge conflicts.
+
+```shell
+git remote add upstream git@github.com:milvus-io/milvus.git
+git checkout master
+git pull upstream master
+git checkout -b my-topic-branch
+```
+
+### General guidelines
+
+Before sending your pull requests for review, make sure your changes are consistent with the guidelines and follow the Milvus coding style.
+
+- Include unit tests when you contribute new features, as they help to prove that your code works correctly, and also guard against future breaking changes to lower the maintenance cost.
+- Bug fixes also require unit tests, because the presence of bugs usually indicates insufficient test coverage.
+- Keep API compatibility in mind when you change code in Milvus. Reviewers of your pull request will comment on any API compatibility issues.
+- When you contribute a new feature to Milvus, the maintenance burden is (by default) transferred to the Milvus team. This means that the benefit of the contribution must be compared against the cost of maintaining the feature.
+
+
+## Coding Style
+The coding style used in Milvus generally follow [Google C++ Style Guide](https://google.github.io/styleguide/cppguide.html).
+And we made the following changes based on the guide:
+
+- 4 spaces for indentation
+- Adopt .cpp file extension instead of .cc extension
+- 120-character line length
+- Camel-Cased file names
+
+### Format code
+
+Install clang-format
+```shell
+$ sudo apt-get install clang-format
+$ rm cmake_build/CMakeCache.txt
+```
+Check code style
+```shell
+$ ./build.sh -l
+```
+To format the code
+```shell
+$ cd cmake_build
+$ make clang-format
+```
+
+## Run unit test with code coverage
+
+Before submitting your PR, make sure you have run unit test, and your code coverage rate is >= 90%.
+
+Install lcov
+```shell
+$ sudo apt-get install lcov
+```
+Run unit test and generate code for code coverage check
+```shell 
+$ ./build.sh -u -c
+```
+
+Run MySQL docker
+```shell 
+docker pull mysql:latest
+docker run -p 3306:3306 -e MYSQL_ROOT_PASSWORD=123456 -d mysql:latest
+```
+
+Run code coverage
+
+```shell  
+$ ./coverage.sh -u root -p 123456 -t 127.0.0.1
+```
+
+Or start your own MySQL server, and then run code coverage
+
+```shell
+$ ./coverage.sh -u ${MYSQL_USERNAME} -p ${MYSQL_PASSWORD} -t ${MYSQL_SERVER_IP}
+```
+
diff --git a/NOTICE.md b/NOTICE.md
new file mode 100644
index 0000000000..40ea77d3b7
--- /dev/null
+++ b/NOTICE.md
@@ -0,0 +1,30 @@
+
+
+
+
+
+
+| Name          | License                                                      |
+| ------------- | ------------------------------------------------------------ |
+| Apache Arrow  | [Apache License 2.0](https://github.com/apache/arrow/blob/master/LICENSE.txt)                                           |
+| Boost         | [Boost Software License](https://github.com/boostorg/boost/blob/master/LICENSE_1_0.txt)                                       |
+| BZip2         | [BZip2](http://www.bzip.org/)                                             |
+| FAISS         | [MIT](https://github.com/facebookresearch/faiss/blob/master/LICENSE)                                                          |
+| Gtest         | [BSD 3-Clause](https://github.com/google/googletest/blob/master/LICENSE)                                                 |
+| LAPACK        | [LAPACK](https://github.com/Reference-LAPACK/lapack/blob/master/LICENSE)                                                 |
+| LZ4           | [BSD 2-Clause](https://github.com/Blosc/c-blosc/blob/master/LICENSES/LZ4.txt) |
+| MySQLPP       | [LGPL 2.1](https://tangentsoft.com/mysqlpp/artifact/b128a66dab867923)                                                     |
+| OpenBLAS      | [BSD 3-Clause](https://github.com/xianyi/OpenBLAS/blob/develop/LICENSE)                                                 |
+| Prometheus    | [Apache License 2.0](https://github.com/prometheus/prometheus/blob/master/LICENSE)                                           |
+| Snappy        | [BSD](https://github.com/google/snappy/blob/master/COPYING) |
+| SQLite        | [Public Domain](https://www.sqlite.org/copyright.html)       |
+| SQLite-ORM    | [BSD 3-Clause](https://github.com/fnc12/sqlite_orm/blob/master/LICENSE)                                                 |
+| yaml-cpp      | [MIT](https://github.com/jbeder/yaml-cpp/blob/master/LICENSE)                                                          |
+| ZLIB          | [ZLIB](http://zlib.net/zlib_license.html)                    |
+| ZSTD          | [BSD](https://github.com/facebook/zstd/blob/dev/LICENSE)     |
+| libunwind     | [MIT](https://github.com/libunwind/libunwind/blob/master/LICENSE)                                                          |
+| gperftools    | [BSD 3-Clause](https://github.com/gperftools/gperftools/blob/master/COPYING)                                                 |
+| grpc          | [Apache 2.0](https://github.com/grpc/grpc/blob/master/LICENSE)                                                   |
+| EASYLOGGINGPP | [MIT](https://github.com/zuhd-org/easyloggingpp/blob/master/LICENSEhttps://github.com/zuhd-org/easyloggingpp/blob/master/LICENSE)                                                          |
+| Json          | [MIT](https://github.com/nlohmann/json/blob/develop/LICENSE.MIT)                                                          |
+
diff --git a/README.md b/README.md
index 13c7f1137c..4fd8bbae2e 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,207 @@
+
+![Milvuslogo](https://github.com/milvus-io/docs/blob/master/assets/milvus_logo.png)
+
+
+![LICENSE](https://img.shields.io/badge/license-Apache--2.0-brightgreen)
+![Language](https://img.shields.io/badge/language-C%2B%2B-blue)
+[![codebeat badge](https://codebeat.co/badges/e030a4f6-b126-4475-a938-4723d54ec3a7?style=plastic)](https://codebeat.co/projects/github-com-jinhai-cn-milvus-master)
+
+- [Slack Community](https://join.slack.com/t/milvusio/shared_invite/enQtNzY1OTQ0NDI3NjMzLWNmYmM1NmNjOTQ5MGI5NDhhYmRhMGU5M2NhNzhhMDMzY2MzNDdlYjM5ODQ5MmE3ODFlYzU3YjJkNmVlNDQ2ZTk)
+- [Twitter](https://twitter.com/milvusio)
+- [Facebook](https://www.facebook.com/io.milvus.5)
+- [Blog](https://www.milvus.io/blog/)
+- [CSDN](https://zilliz.blog.csdn.net/)
+- [中文官网](https://www.milvus.io/zh-CN/)
+
+
+# Welcome to Milvus
+
+## What is Milvus
+
+Milvus is an open source similarity search engine for massive feature vectors. Designed with heterogeneous computing architecture for the best cost efficiency. Searches over billion-scale vectors take only milliseconds with minimum computing resources.
+
+Milvus provides stable Python, Java and C++ APIs.
+
+Keep up-to-date with newest releases and latest updates by reading Milvus [release notes](https://milvus.io/docs/en/releases/v0.5.0/).
+
+- Heterogeneous computing
+
+  Milvus is designed with heterogeneous computing architecture for the best performance and cost efficiency. 
+
+- Multiple indexes
+
+  Milvus supports a variety of indexing types that employs quantization, tree-based, and graph indexing techniques. 
+
+- Intelligent resource management
+
+  Milvus automatically adapts search computation and index building processes based on your datasets and available resources.
+
+- Horizontal scalability
+
+  Milvus supports online / offline expansion to scale both storage and computation resources with simple commands.
+
+- High availability
+
+  Milvus is integrated with Kubernetes framework so that all single point of failures could be avoided.
+
+- High compatibility
+
+  Milvus is compatible with almost all deep learning models and major programming languages such as Python, Java and C++, etc.
+
+- Ease of use
+
+  Milvus can be easily installed in a few steps and enables you to exclusively focus on feature vectors. 
+
+- Visualized monitor
+
+  You can track system performance on Prometheus-based GUI monitor dashboards.
+
+## Architecture
+
+![Milvus_arch](https://github.com/milvus-io/docs/blob/master/assets/milvus_arch.png)
+
+## Get started
+
+### Hardware Requirements
+
+| Component | Recommended configuration           |
+| --------- | ----------------------------------- |
+| CPU       | Intel CPU Haswell or higher         |
+| GPU       | NVIDIA Pascal series or higher      |
+| Memory    | 8 GB or more (depends on data size) |
+| Storage   | SATA 3.0 SSD or higher              |
+
+### Install using docker
+
+Use Docker to install Milvus is a breeze. See the [Milvus install guide](https://milvus.io/docs/en/userguide/install_milvus/) for details.
+
+### Build from source
+
+#### Software requirements
+
+- Ubuntu 18.04 or higher
+- CMake 3.14 or higher
+- CUDA 10.0 or higher
+- NVIDIA driver 418 or higher
+
+#### Compilation
+
+##### Step 1 Install dependencies
+
+```shell
+$ cd [Milvus sourcecode path]/core
+./ubuntu_build_deps.sh
+```
+
+##### Step 2 Build
+
+```shell
+$ cd [Milvus sourcecode path]/core
+$ ./build.sh -t Debug
+or 
+$ ./build.sh -t Release
+```
+
+When the build is completed, all the stuff that you need in order to run Milvus will be installed under `[Milvus root path]/core/milvus`.
+
+#### Launch Milvus server
+
+```shell
+$ cd [Milvus root path]/core/milvus
+```
+
+Add `lib/` directory to `LD_LIBRARY_PATH`
+
+```
+$ export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/path/to/milvus/lib
+```
+
+Then start Milvus server:
+
+```
+$ cd scripts
+$ ./start_server.sh
+```
+
+To stop Milvus server, run:
+
+```shell
+$ ./stop_server.sh
+```
+
+To edit Milvus settings in `conf/server_config.yaml` and `conf/log_config.conf`, please read [Milvus Configuration](https://github.com/milvus-io/docs/blob/master/reference/milvus_config.md).
+
+### Try your first Milvus program
+
+#### Run Python example code
+
+Make sure [Python 3.5](https://www.python.org/downloads/) or higher is already installed and in use.
+
+Install Milvus Python SDK.
+
+```shell
+# Install Milvus Python SDK
+$ pip install pymilvus==0.2.3
+```
+
+Create a new file `example.py`, and add [Python example code](https://github.com/milvus-io/pymilvus/blob/master/examples/AdvancedExample.py) to it.
+
+Run the example code.
+
+```shell
+# Run Milvus Python example
+$ python3 example.py
+```
+
+#### Run C++ example code
+
+```shell
+ # Run Milvus C++ example
+ $ cd [Milvus root path]/core/milvus/bin
+ $ ./sdk_simple
+```
+
+#### Run Java example code
+Make sure Java 8 or higher is already installed.
+
+Refer to [this link](https://github.com/milvus-io/milvus-sdk-java/tree/master/examples) for the example code.
+
+## Contribution guidelines
+
+Contributions are welcomed and greatly appreciated. If you want to contribute to Milvus, please read our [contribution guidelines](CONTRIBUTING.md). This project adheres to the [code of conduct](CODE_OF_CONDUCT.md) of Milvus. By participating, you are expected to uphold this code.
+
+We use [GitHub issues](https://github.com/milvus-io/milvus/issues/new/choose) to track issues and bugs. For general questions and public discussions, please join our community.
+
+## Join the Milvus community
+
+To connect with other users and contributors, welcome to join our [slack channel](https://join.slack.com/t/milvusio/shared_invite/enQtNzY1OTQ0NDI3NjMzLWNmYmM1NmNjOTQ5MGI5NDhhYmRhMGU5M2NhNzhhMDMzY2MzNDdlYjM5ODQ5MmE3ODFlYzU3YjJkNmVlNDQ2ZTk). 
+
+## Milvus Roadmap
+
+Please read our [roadmap](https://milvus.io/docs/en/roadmap/) to learn about upcoming features.
+
+## Resources
+
+[Milvus official website](https://www.milvus.io)
+
+[Milvus docs](https://www.milvus.io/docs/en/userguide/install_milvus/)
+
+[Milvus bootcamp](https://github.com/milvus-io/bootcamp)
+
+[Milvus blog](https://www.milvus.io/blog/)
+
+[Milvus CSDN](https://zilliz.blog.csdn.net/)
+
+[Milvus roadmap](https://milvus.io/docs/en/roadmap/)
+
+
+## License
+
+[Apache 2.0 license](LICENSE)
+
+=======
 ![LICENSE](https://img.shields.io/badge/license-Apache--2.0-brightgreen.svg)
 ![Language](https://img.shields.io/badge/language-C%2B%2B-blue.svg)
 ![Release](https://img.shields.io/badge/Release-v0.5.0-orange.svg)
 ![Release date](https://img.shields.io/badge/release__date-October-yellowgreen)
 
-# Milvus is coming soon!
diff --git a/ci/function/file_transfer.groovy b/ci/function/file_transfer.groovy
new file mode 100644
index 0000000000..bebae14832
--- /dev/null
+++ b/ci/function/file_transfer.groovy
@@ -0,0 +1,10 @@
+def FileTransfer (sourceFiles, remoteDirectory, remoteIP, protocol = "ftp", makeEmptyDirs = true) {
+    if (protocol == "ftp") {
+        ftpPublisher masterNodeName: '', paramPublish: [parameterName: ''], alwaysPublishFromMaster: false, continueOnError: false, failOnError: true, publishers: [
+            [configName: "${remoteIP}", transfers: [
+                [asciiMode: false, cleanRemote: false, excludes: '', flatten: false, makeEmptyDirs: "${makeEmptyDirs}", noDefaultExcludes: false, patternSeparator: '[, ]+', remoteDirectory: "${remoteDirectory}", remoteDirectorySDF: false, removePrefix: '', sourceFiles: "${sourceFiles}"]], usePromotionTimestamp: true, useWorkspaceInPromotion: false, verbose: true
+                ]
+            ]
+    }
+}
+return this
diff --git a/ci/jenkins/Jenkinsfile b/ci/jenkins/Jenkinsfile
new file mode 100644
index 0000000000..fbdf3a3096
--- /dev/null
+++ b/ci/jenkins/Jenkinsfile
@@ -0,0 +1,152 @@
+pipeline {
+    agent none
+
+    options {
+        timestamps()
+    }
+
+    parameters{
+        choice choices: ['Release', 'Debug'], description: '', name: 'BUILD_TYPE'
+        string defaultValue: 'cf1434e7-5a4b-4d25-82e8-88d667aef9e5', description: 'GIT CREDENTIALS ID', name: 'GIT_CREDENTIALS_ID', trim: true
+        string defaultValue: 'registry.zilliz.com', description: 'DOCKER REGISTRY URL', name: 'DOKCER_REGISTRY_URL', trim: true
+        string defaultValue: 'ba070c98-c8cc-4f7c-b657-897715f359fc', description: 'DOCKER CREDENTIALS ID', name: 'DOCKER_CREDENTIALS_ID', trim: true
+        string defaultValue: 'http://192.168.1.202/artifactory/milvus', description: 'JFROG ARTFACTORY URL', name: 'JFROG_ARTFACTORY_URL', trim: true
+        string defaultValue: '1a527823-d2b7-44fd-834b-9844350baf14', description: 'JFROG CREDENTIALS ID', name: 'JFROG_CREDENTIALS_ID', trim: true
+    }
+
+    environment {
+        PROJECT_NAME = "milvus"
+        LOWER_BUILD_TYPE = params.BUILD_TYPE.toLowerCase()
+        SEMVER = "${BRANCH_NAME}"
+        JOBNAMES = env.JOB_NAME.split('/')
+        PIPELINE_NAME = "${JOBNAMES[0]}"
+    }
+
+    stages {
+        stage("Ubuntu 18.04") {
+            environment {
+                OS_NAME = "ubuntu18.04"
+                PACKAGE_VERSION = VersionNumber([
+                    versionNumberString : '${SEMVER}-${LOWER_BUILD_TYPE}-ubuntu18.04-x86_64-${BUILD_DATE_FORMATTED, "yyyyMMdd"}-${BUILDS_TODAY}'
+                ]);
+                DOCKER_VERSION = "${SEMVER}-${OS_NAME}-${LOWER_BUILD_TYPE}"
+            }
+
+            stages {
+                stage("Run Build") {
+                    agent {
+                        kubernetes {
+                            label 'build'
+                            defaultContainer 'jnlp'
+                            yamlFile 'ci/jenkins/pod/milvus-build-env-pod.yaml'
+                        }
+                    }
+
+                    stages {
+                        stage('Build') {
+                            steps {
+                                container('milvus-build-env') {
+                                    script {
+                                        load "${env.WORKSPACE}/ci/jenkins/jenkinsfile/build.groovy"
+                                    }
+                                }
+                            }
+                        }
+                        stage('Code Coverage') {
+                            steps {
+                                container('milvus-build-env') {
+                                    script {
+                                        load "${env.WORKSPACE}/ci/jenkins/jenkinsfile/coverage.groovy"
+                                    }
+                                }
+                            }
+                        }
+                        stage('Upload Package') {
+                            steps {
+                                container('milvus-build-env') {
+                                    script {
+                                        load "${env.WORKSPACE}/ci/jenkins/jenkinsfile/package.groovy"
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+
+                stage("Publish docker images") {
+                    agent {
+                        kubernetes {
+                            label 'publish'
+                            defaultContainer 'jnlp'
+                            yamlFile 'ci/jenkins/pod/docker-pod.yaml'
+                        }
+                    }
+
+                    stages {
+                        stage('Publish') {
+                            steps {
+                                container('publish-images'){
+                                    script {
+                                        load "${env.WORKSPACE}/ci/jenkins/jenkinsfile/publishImages.groovy"
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+
+                stage("Deploy to Development") {
+                    agent {
+                        kubernetes {
+                            label 'dev-test'
+                            defaultContainer 'jnlp'
+                            yamlFile 'ci/jenkins/pod/testEnvironment.yaml'
+                        }
+                    }
+
+                    stages {
+                        stage("Deploy to Dev") {
+                            steps {
+                                container('milvus-test-env') {
+                                    script {
+                                        load "${env.WORKSPACE}/ci/jenkins/jenkinsfile/deploySingle2Dev.groovy"
+                                    }
+                                }
+                            }
+                        }
+
+                        stage("Dev Test") {
+                            steps {
+                                container('milvus-test-env') {
+                                    script {
+                                        load "${env.WORKSPACE}/ci/jenkins/jenkinsfile/singleDevTest.groovy"
+                                    }
+                                }
+                            }
+                        }
+
+                        stage ("Cleanup Dev") {
+                            steps {
+                                container('milvus-test-env') {
+                                    script {
+                                        load "${env.WORKSPACE}/ci/jenkins/jenkinsfile/cleanupSingleDev.groovy"
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    post {
+                        unsuccessful {
+                            container('milvus-test-env') {
+                                script {
+                                    load "${env.WORKSPACE}/ci/jenkins/jenkinsfile/cleanupSingleDev.groovy"
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
diff --git a/ci/jenkins/jenkinsfile/build.groovy b/ci/jenkins/jenkinsfile/build.groovy
new file mode 100644
index 0000000000..14d0414f4f
--- /dev/null
+++ b/ci/jenkins/jenkinsfile/build.groovy
@@ -0,0 +1,9 @@
+timeout(time: 60, unit: 'MINUTES') {
+    dir ("ci/jenkins/scripts") {
+        sh "./build.sh -l"
+        withCredentials([usernamePassword(credentialsId: "${params.JFROG_CREDENTIALS_ID}", usernameVariable: 'USERNAME', passwordVariable: 'PASSWORD')]) {
+            sh "export JFROG_ARTFACTORY_URL='${params.JFROG_ARTFACTORY_URL}' && export JFROG_USER_NAME='${USERNAME}' && export JFROG_PASSWORD='${PASSWORD}' && ./build.sh -t ${params.BUILD_TYPE} -o /opt/milvus -d /opt/milvus -j -u -c"
+        }
+    }
+}
+
diff --git a/ci/jenkins/jenkinsfile/cleanupSingleDev.groovy b/ci/jenkins/jenkinsfile/cleanupSingleDev.groovy
new file mode 100644
index 0000000000..6e85a678be
--- /dev/null
+++ b/ci/jenkins/jenkinsfile/cleanupSingleDev.groovy
@@ -0,0 +1,9 @@
+try {
+    sh "helm del --purge ${env.PIPELINE_NAME}-${env.BUILD_NUMBER}-single-gpu"
+} catch (exc) {
+    def helmResult = sh script: "helm status ${env.PIPELINE_NAME}-${env.BUILD_NUMBER}-single-gpu", returnStatus: true
+    if (!helmResult) {
+        sh "helm del --purge ${env.PIPELINE_NAME}-${env.BUILD_NUMBER}-single-gpu"
+    }
+    throw exc
+}
diff --git a/ci/jenkins/jenkinsfile/coverage.groovy b/ci/jenkins/jenkinsfile/coverage.groovy
new file mode 100644
index 0000000000..7c3b16c029
--- /dev/null
+++ b/ci/jenkins/jenkinsfile/coverage.groovy
@@ -0,0 +1,10 @@
+timeout(time: 60, unit: 'MINUTES') {
+    dir ("ci/jenkins/scripts") {
+        sh "./coverage.sh -o /opt/milvus -u root -p 123456 -t \$POD_IP"
+        // Set some env variables so codecov detection script works correctly
+        withCredentials([[$class: 'StringBinding', credentialsId: "${env.PIPELINE_NAME}-codecov-token", variable: 'CODECOV_TOKEN']]) {
+            sh 'curl -s https://codecov.io/bash | bash -s - -f output_new.info || echo "Codecov did not collect coverage reports"'
+        }
+    }
+}
+
diff --git a/ci/jenkins/jenkinsfile/deploySingle2Dev.groovy b/ci/jenkins/jenkinsfile/deploySingle2Dev.groovy
new file mode 100644
index 0000000000..2ab13486a6
--- /dev/null
+++ b/ci/jenkins/jenkinsfile/deploySingle2Dev.groovy
@@ -0,0 +1,14 @@
+try {
+    sh 'helm init --client-only --skip-refresh --stable-repo-url https://kubernetes.oss-cn-hangzhou.aliyuncs.com/charts'
+    sh 'helm repo update'
+    dir ('milvus-helm') {
+        checkout([$class: 'GitSCM', branches: [[name: "0.5.0"]], doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [], userRemoteConfigs: [[credentialsId: "${params.GIT_CREDENTIALS_ID}", url: "https://github.com/milvus-io/milvus-helm.git", name: 'origin', refspec: "+refs/heads/0.5.0:refs/remotes/origin/0.5.0"]]])
+        dir ("milvus-gpu") {
+            sh "helm install --wait --timeout 300 --set engine.image.tag=${DOCKER_VERSION} --set expose.type=clusterIP --name ${env.PIPELINE_NAME}-${env.BUILD_NUMBER}-single-gpu -f ci/values.yaml --namespace milvus ."
+        }
+    }
+} catch (exc) {
+    echo 'Helm running failed!'
+    sh "helm del --purge ${env.PIPELINE_NAME}-${env.BUILD_NUMBER}-single-gpu"
+    throw exc
+}
diff --git a/ci/jenkins/jenkinsfile/package.groovy b/ci/jenkins/jenkinsfile/package.groovy
new file mode 100644
index 0000000000..edd6ce88da
--- /dev/null
+++ b/ci/jenkins/jenkinsfile/package.groovy
@@ -0,0 +1,9 @@
+timeout(time: 5, unit: 'MINUTES') {
+    sh "tar -zcvf ./${PROJECT_NAME}-${PACKAGE_VERSION}.tar.gz -C /opt/ milvus"
+    withCredentials([usernamePassword(credentialsId: "${params.JFROG_CREDENTIALS_ID}", usernameVariable: 'JFROG_USERNAME', passwordVariable: 'JFROG_PASSWORD')]) {
+        def uploadStatus = sh(returnStatus: true, script: "curl -u${JFROG_USERNAME}:${JFROG_PASSWORD} -T ./${PROJECT_NAME}-${PACKAGE_VERSION}.tar.gz ${params.JFROG_ARTFACTORY_URL}/milvus/package/${PROJECT_NAME}-${PACKAGE_VERSION}.tar.gz")
+        if (uploadStatus != 0) {
+            error("\" ${PROJECT_NAME}-${PACKAGE_VERSION}.tar.gz \" upload to \" ${params.JFROG_ARTFACTORY_URL}/milvus/package/${PROJECT_NAME}-${PACKAGE_VERSION}.tar.gz \" failed!")
+        }
+    }
+}
diff --git a/ci/jenkins/jenkinsfile/publishImages.groovy b/ci/jenkins/jenkinsfile/publishImages.groovy
new file mode 100644
index 0000000000..62df0c73bf
--- /dev/null
+++ b/ci/jenkins/jenkinsfile/publishImages.groovy
@@ -0,0 +1,47 @@
+container('publish-images') {
+    timeout(time: 15, unit: 'MINUTES') {
+        dir ("docker/deploy/${OS_NAME}") {
+            def binaryPackage = "${PROJECT_NAME}-${PACKAGE_VERSION}.tar.gz"
+
+            withCredentials([usernamePassword(credentialsId: "${params.JFROG_CREDENTIALS_ID}", usernameVariable: 'JFROG_USERNAME', passwordVariable: 'JFROG_PASSWORD')]) {
+                def downloadStatus = sh(returnStatus: true, script: "curl -u${JFROG_USERNAME}:${JFROG_PASSWORD} -O ${params.JFROG_ARTFACTORY_URL}/milvus/package/${binaryPackage}")
+
+                if (downloadStatus != 0) {
+                    error("\" Download \" ${params.JFROG_ARTFACTORY_URL}/milvus/package/${binaryPackage} \" failed!")
+                }
+            }
+            sh "tar zxvf ${binaryPackage}"
+            def imageName = "${PROJECT_NAME}/engine:${DOCKER_VERSION}"
+
+            try {
+                def isExistSourceImage = sh(returnStatus: true, script: "docker inspect --type=image ${imageName} 2>&1 > /dev/null")
+                if (isExistSourceImage == 0) {
+                    def removeSourceImageStatus = sh(returnStatus: true, script: "docker rmi ${imageName}")
+                }
+
+                def customImage = docker.build("${imageName}")
+
+                def isExistTargeImage = sh(returnStatus: true, script: "docker inspect --type=image ${params.DOKCER_REGISTRY_URL}/${imageName} 2>&1 > /dev/null")
+                if (isExistTargeImage == 0) {
+                    def removeTargeImageStatus = sh(returnStatus: true, script: "docker rmi ${params.DOKCER_REGISTRY_URL}/${imageName}")
+                }
+
+                docker.withRegistry("https://${params.DOKCER_REGISTRY_URL}", "${params.DOCKER_CREDENTIALS_ID}") {
+                    customImage.push()
+                }
+            } catch (exc) {
+                throw exc
+            } finally {
+                def isExistSourceImage = sh(returnStatus: true, script: "docker inspect --type=image ${imageName} 2>&1 > /dev/null")
+                if (isExistSourceImage == 0) {
+                    def removeSourceImageStatus = sh(returnStatus: true, script: "docker rmi ${imageName}")
+                }
+
+                def isExistTargeImage = sh(returnStatus: true, script: "docker inspect --type=image ${params.DOKCER_REGISTRY_URL}/${imageName} 2>&1 > /dev/null")
+                if (isExistTargeImage == 0) {
+                    def removeTargeImageStatus = sh(returnStatus: true, script: "docker rmi ${params.DOKCER_REGISTRY_URL}/${imageName}")
+                }
+            }
+        } 
+    }
+}
diff --git a/ci/jenkins/jenkinsfile/singleDevTest.groovy b/ci/jenkins/jenkinsfile/singleDevTest.groovy
new file mode 100644
index 0000000000..ae57ffd42b
--- /dev/null
+++ b/ci/jenkins/jenkinsfile/singleDevTest.groovy
@@ -0,0 +1,22 @@
+timeout(time: 30, unit: 'MINUTES') {
+    dir ("tests/milvus_python_test") {
+        sh 'python3 -m pip install -r requirements.txt'
+        sh "pytest . --alluredir=\"test_out/dev/single/sqlite\" --level=1 --ip ${env.PIPELINE_NAME}-${env.BUILD_NUMBER}-single-gpu-milvus-gpu-engine.milvus.svc.cluster.local"
+    }
+    // mysql database backend test
+    load "${env.WORKSPACE}/ci/jenkins/jenkinsfile/cleanupSingleDev.groovy"
+
+    if (!fileExists('milvus-helm')) {
+        dir ("milvus-helm") {
+            checkout([$class: 'GitSCM', branches: [[name: "0.5.0"]], doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [], userRemoteConfigs: [[credentialsId: "${params.GIT_CREDENTIALS_ID}", url: "https://github.com/milvus-io/milvus-helm.git", name: 'origin', refspec: "+refs/heads/0.5.0:refs/remotes/origin/0.5.0"]]])
+        }
+    }
+    dir ("milvus-helm") {
+        dir ("milvus-gpu") {
+            sh "helm install --wait --timeout 300 --set engine.image.tag=${DOCKER_VERSION} --set expose.type=clusterIP --name ${env.PIPELINE_NAME}-${env.BUILD_NUMBER}-single-gpu -f ci/db_backend/mysql_values.yaml --namespace milvus ."
+        }
+    }
+    dir ("tests/milvus_python_test") {
+        sh "pytest . --alluredir=\"test_out/dev/single/mysql\" --level=1 --ip ${env.PIPELINE_NAME}-${env.BUILD_NUMBER}-single-gpu-milvus-gpu-engine.milvus.svc.cluster.local"
+    }
+}
diff --git a/ci/jenkins/pod/docker-pod.yaml b/ci/jenkins/pod/docker-pod.yaml
new file mode 100644
index 0000000000..a4fed0bcad
--- /dev/null
+++ b/ci/jenkins/pod/docker-pod.yaml
@@ -0,0 +1,23 @@
+apiVersion: v1
+kind: Pod
+metadata:
+  labels:
+    app: publish
+    componet: docker
+spec:
+  containers:
+  - name: publish-images
+    image: registry.zilliz.com/library/docker:v1.0.0
+    securityContext:
+      privileged: true
+    command:
+    - cat
+    tty: true
+    volumeMounts:
+    - name: docker-sock
+      mountPath: /var/run/docker.sock
+  volumes:
+  - name: docker-sock
+    hostPath:
+      path: /var/run/docker.sock
+
diff --git a/ci/jenkins/pod/milvus-build-env-pod.yaml b/ci/jenkins/pod/milvus-build-env-pod.yaml
new file mode 100644
index 0000000000..bb4499711f
--- /dev/null
+++ b/ci/jenkins/pod/milvus-build-env-pod.yaml
@@ -0,0 +1,35 @@
+apiVersion: v1
+kind: Pod
+metadata:
+  name: milvus-build-env
+  labels:
+    app: milvus
+    componet: build-env
+spec:
+  containers:
+  - name: milvus-build-env
+    image: registry.zilliz.com/milvus/milvus-build-env:v0.5.0-ubuntu18.04
+    env:
+    - name: POD_IP
+      valueFrom:
+        fieldRef:
+          fieldPath: status.podIP
+    command:
+    - cat
+    tty: true
+    resources:
+      limits:
+        memory: "32Gi"
+        cpu: "8.0"
+        nvidia.com/gpu: 1
+      requests:
+        memory: "16Gi"
+        cpu: "4.0"
+  - name: milvus-mysql
+    image: mysql:5.6
+    env:
+    - name: MYSQL_ROOT_PASSWORD
+      value: 123456
+    ports:
+    - containerPort: 3306
+      name: mysql
diff --git a/ci/jenkins/pod/testEnvironment.yaml b/ci/jenkins/pod/testEnvironment.yaml
new file mode 100644
index 0000000000..174277dfcc
--- /dev/null
+++ b/ci/jenkins/pod/testEnvironment.yaml
@@ -0,0 +1,22 @@
+apiVersion: v1
+kind: Pod
+metadata:
+  labels:
+    app: milvus
+    componet: test-env
+spec:
+  containers:
+  - name: milvus-test-env
+    image: registry.zilliz.com/milvus/milvus-test-env:v0.1
+    command:
+    - cat
+    tty: true
+    volumeMounts:
+    - name: kubeconf
+      mountPath: /root/.kube/
+      readOnly: true
+  volumes:
+  - name: kubeconf
+    secret:
+      secretName: test-cluster-config
+
diff --git a/ci/jenkins/scripts/build.sh b/ci/jenkins/scripts/build.sh
new file mode 100755
index 0000000000..2ccdf4a618
--- /dev/null
+++ b/ci/jenkins/scripts/build.sh
@@ -0,0 +1,142 @@
+#!/bin/bash
+
+SOURCE="${BASH_SOURCE[0]}"
+while [ -h "$SOURCE" ]; do # resolve $SOURCE until the file is no longer a symlink
+  DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"
+  SOURCE="$(readlink "$SOURCE")"
+  [[ $SOURCE != /* ]] && SOURCE="$DIR/$SOURCE" # if $SOURCE was a relative symlink, we need to resolve it relative to the path where the symlink file was located
+done
+SCRIPTS_DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"
+
+CMAKE_BUILD_DIR="${SCRIPTS_DIR}/../../../core/cmake_build"
+BUILD_TYPE="Debug"
+BUILD_UNITTEST="OFF"
+INSTALL_PREFIX="/opt/milvus"
+BUILD_COVERAGE="OFF"
+DB_PATH="/opt/milvus"
+PROFILING="OFF"
+USE_JFROG_CACHE="OFF"
+RUN_CPPLINT="OFF"
+CUSTOMIZATION="OFF" # default use ori faiss
+CUDA_COMPILER=/usr/local/cuda/bin/nvcc
+
+CUSTOMIZED_FAISS_URL="${FAISS_URL:-NONE}"
+wget -q --method HEAD ${CUSTOMIZED_FAISS_URL}
+if [ $? -eq 0 ]; then
+  CUSTOMIZATION="ON"
+else
+  CUSTOMIZATION="OFF"
+fi
+
+while getopts "o:d:t:ulcgjhx" arg
+do
+        case $arg in
+             o)
+                INSTALL_PREFIX=$OPTARG
+                ;;
+             d)
+                DB_PATH=$OPTARG
+                ;;
+             t)
+                BUILD_TYPE=$OPTARG # BUILD_TYPE
+                ;;
+             u)
+                echo "Build and run unittest cases" ;
+                BUILD_UNITTEST="ON";
+                ;;
+             l)
+                RUN_CPPLINT="ON"
+                ;;
+             c)
+                BUILD_COVERAGE="ON"
+                ;;
+             g)
+                PROFILING="ON"
+                ;;
+             j)
+                USE_JFROG_CACHE="ON"
+                ;;
+             x)
+                CUSTOMIZATION="OFF" # force use ori faiss
+                ;;
+             h) # help
+                echo "
+
+parameter:
+-o: install prefix(default: /opt/milvus)
+-d: db data path(default: /opt/milvus)
+-t: build type(default: Debug)
+-u: building unit test options(default: OFF)
+-l: run cpplint, clang-format and clang-tidy(default: OFF)
+-c: code coverage(default: OFF)
+-g: profiling(default: OFF)
+-j: use jfrog cache build directory(default: OFF)
+-h: help
+
+usage:
+./build.sh -p \${INSTALL_PREFIX} -t \${BUILD_TYPE} [-u] [-l] [-r] [-c] [-g] [-j] [-h]
+                "
+                exit 0
+                ;;
+             ?)
+                echo "ERROR! unknown argument"
+        exit 1
+        ;;
+        esac
+done
+
+if [[ ! -d ${CMAKE_BUILD_DIR} ]]; then
+    mkdir ${CMAKE_BUILD_DIR}
+fi
+
+cd ${CMAKE_BUILD_DIR}
+
+# remove make cache since build.sh -l use default variables
+# force update the variables each time
+make rebuild_cache
+
+CMAKE_CMD="cmake \
+-DBUILD_UNIT_TEST=${BUILD_UNITTEST} \
+-DCMAKE_INSTALL_PREFIX=${INSTALL_PREFIX}
+-DCMAKE_BUILD_TYPE=${BUILD_TYPE} \
+-DCMAKE_CUDA_COMPILER=${CUDA_COMPILER} \
+-DBUILD_COVERAGE=${BUILD_COVERAGE} \
+-DMILVUS_DB_PATH=${DB_PATH} \
+-DMILVUS_ENABLE_PROFILING=${PROFILING} \
+-DUSE_JFROG_CACHE=${USE_JFROG_CACHE} \
+-DCUSTOMIZATION=${CUSTOMIZATION} \
+-DFAISS_URL=${CUSTOMIZED_FAISS_URL} \
+.."
+echo ${CMAKE_CMD}
+${CMAKE_CMD}
+
+if [[ ${RUN_CPPLINT} == "ON" ]]; then
+    # cpplint check
+    make lint
+    if [ $? -ne 0 ]; then
+        echo "ERROR! cpplint check failed"
+        exit 1
+    fi
+    echo "cpplint check passed!"
+
+    # clang-format check
+    make check-clang-format
+    if [ $? -ne 0 ]; then
+        echo "ERROR! clang-format check failed"
+        exit 1
+    fi
+    echo "clang-format check passed!"
+
+#    # clang-tidy check
+#    make check-clang-tidy
+#    if [ $? -ne 0 ]; then
+#        echo "ERROR! clang-tidy check failed"
+#        rm -f CMakeCache.txt
+#        exit 1
+#    fi
+#    echo "clang-tidy check passed!"
+else
+    # compile and build
+    make -j8 || exit 1
+    make install || exit 1
+fi
diff --git a/ci/jenkins/scripts/coverage.sh b/ci/jenkins/scripts/coverage.sh
new file mode 100755
index 0000000000..ecbb2dfbe9
--- /dev/null
+++ b/ci/jenkins/scripts/coverage.sh
@@ -0,0 +1,138 @@
+#!/bin/bash
+
+SOURCE="${BASH_SOURCE[0]}"
+while [ -h "$SOURCE" ]; do # resolve $SOURCE until the file is no longer a symlink
+  DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"
+  SOURCE="$(readlink "$SOURCE")"
+  [[ $SOURCE != /* ]] && SOURCE="$DIR/$SOURCE" # if $SOURCE was a relative symlink, we need to resolve it relative to the path where the symlink file was located
+done
+SCRIPTS_DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"
+
+INSTALL_PREFIX="/opt/milvus"
+CMAKE_BUILD_DIR="${SCRIPTS_DIR}/../../../core/cmake_build"
+MYSQL_USER_NAME=root
+MYSQL_PASSWORD=123456
+MYSQL_HOST='127.0.0.1'
+MYSQL_PORT='3306'
+
+while getopts "o:u:p:t:h" arg
+do
+        case $arg in
+             o)
+                INSTALL_PREFIX=$OPTARG
+                ;;
+             u)
+                MYSQL_USER_NAME=$OPTARG
+                ;;
+             p)
+                MYSQL_PASSWORD=$OPTARG
+                ;;
+             t)
+                MYSQL_HOST=$OPTARG
+                ;;
+             h) # help
+                echo "
+
+parameter:
+-o: milvus install prefix(default: /opt/milvus)
+-u: mysql account
+-p: mysql password
+-t: mysql host
+-h: help
+
+usage:
+./coverage.sh -o \${INSTALL_PREFIX} -u \${MYSQL_USER} -p \${MYSQL_PASSWORD} -t \${MYSQL_HOST} [-h]
+                "
+                exit 0
+                ;;
+             ?)
+                echo "ERROR! unknown argument"
+        exit 1
+        ;;
+        esac
+done
+
+export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:${INSTALL_PREFIX}/lib
+
+LCOV_CMD="lcov"
+# LCOV_GEN_CMD="genhtml"
+
+FILE_INFO_BASE="base.info"
+FILE_INFO_MILVUS="server.info"
+FILE_INFO_OUTPUT="output.info"
+FILE_INFO_OUTPUT_NEW="output_new.info"
+DIR_LCOV_OUTPUT="lcov_out"
+
+DIR_GCNO="${CMAKE_BUILD_DIR}"
+DIR_UNITTEST="${INSTALL_PREFIX}/unittest"
+
+# delete old code coverage info files
+rm -rf lcov_out
+rm -f FILE_INFO_BASE FILE_INFO_MILVUS FILE_INFO_OUTPUT FILE_INFO_OUTPUT_NEW
+
+MYSQL_DB_NAME=milvus_`date +%s%N`
+
+function mysql_exc()
+{
+    cmd=$1
+    mysql -h${MYSQL_HOST} -u${MYSQL_USER_NAME} -p${MYSQL_PASSWORD} -e "${cmd}"
+    if [ $? -ne 0 ]; then
+        echo "mysql $cmd run failed"
+    fi
+}
+
+mysql_exc "CREATE DATABASE IF NOT EXISTS ${MYSQL_DB_NAME};"
+mysql_exc "GRANT ALL PRIVILEGES ON ${MYSQL_DB_NAME}.* TO '${MYSQL_USER_NAME}'@'%';"
+mysql_exc "FLUSH PRIVILEGES;"
+mysql_exc "USE ${MYSQL_DB_NAME};"
+
+# get baseline
+${LCOV_CMD} -c -i -d ${DIR_GCNO} -o "${FILE_INFO_BASE}"
+if [ $? -ne 0 ]; then
+    echo "gen baseline coverage run failed"
+    exit -1
+fi
+
+for test in `ls ${DIR_UNITTEST}`; do
+    echo $test
+    case ${test} in
+        test_db)
+            # set run args for test_db
+            args="mysql://${MYSQL_USER_NAME}:${MYSQL_PASSWORD}@${MYSQL_HOST}:${MYSQL_PORT}/${MYSQL_DB_NAME}"
+            ;;
+        *test_*)
+            args=""
+            ;;
+    esac
+    # run unittest
+    ${DIR_UNITTEST}/${test} "${args}"
+    if [ $? -ne 0 ]; then
+        echo ${args}
+        echo ${DIR_UNITTEST}/${test} "run failed"
+    fi
+done
+
+mysql_exc "DROP DATABASE IF EXISTS ${MYSQL_DB_NAME};"
+
+# gen code coverage
+${LCOV_CMD} -d ${DIR_GCNO} -o "${FILE_INFO_MILVUS}" -c
+# merge coverage
+${LCOV_CMD} -a ${FILE_INFO_BASE} -a ${FILE_INFO_MILVUS} -o "${FILE_INFO_OUTPUT}"
+
+# remove third party from tracefiles
+${LCOV_CMD} -r "${FILE_INFO_OUTPUT}" -o "${FILE_INFO_OUTPUT_NEW}" \
+    "/usr/*" \
+    "*/boost/*" \
+    "*/cmake_build/*_ep-prefix/*" \
+    "*/src/index/cmake_build*" \
+    "*/src/index/thirdparty*" \
+    "*/src/grpc*" \
+    "*/src/metrics/MetricBase.h" \
+    "*/src/server/Server.cpp" \
+    "*/src/server/DBWrapper.cpp" \
+    "*/src/server/grpc_impl/GrpcServer.cpp" \
+    "*/src/utils/easylogging++.h" \
+    "*/src/utils/easylogging++.cc"
+
+# gen html report
+# ${LCOV_GEN_CMD} "${FILE_INFO_OUTPUT_NEW}" --output-directory ${DIR_LCOV_OUTPUT}/
diff --git a/ci/jenkinsfile/cleanup_dev.groovy b/ci/jenkinsfile/cleanup_dev.groovy
new file mode 100644
index 0000000000..2e9332fa6e
--- /dev/null
+++ b/ci/jenkinsfile/cleanup_dev.groovy
@@ -0,0 +1,13 @@
+try {
+    def result = sh script: "helm status ${env.JOB_NAME}-${env.BUILD_NUMBER}", returnStatus: true
+    if (!result) {
+        sh "helm del --purge ${env.JOB_NAME}-${env.BUILD_NUMBER}"
+    }
+} catch (exc) {
+    def result = sh script: "helm status ${env.JOB_NAME}-${env.BUILD_NUMBER}", returnStatus: true
+    if (!result) {
+        sh "helm del --purge ${env.JOB_NAME}-${env.BUILD_NUMBER}"
+    }
+    throw exc
+}
+
diff --git a/ci/jenkinsfile/cleanup_staging.groovy b/ci/jenkinsfile/cleanup_staging.groovy
new file mode 100644
index 0000000000..2e9332fa6e
--- /dev/null
+++ b/ci/jenkinsfile/cleanup_staging.groovy
@@ -0,0 +1,13 @@
+try {
+    def result = sh script: "helm status ${env.JOB_NAME}-${env.BUILD_NUMBER}", returnStatus: true
+    if (!result) {
+        sh "helm del --purge ${env.JOB_NAME}-${env.BUILD_NUMBER}"
+    }
+} catch (exc) {
+    def result = sh script: "helm status ${env.JOB_NAME}-${env.BUILD_NUMBER}", returnStatus: true
+    if (!result) {
+        sh "helm del --purge ${env.JOB_NAME}-${env.BUILD_NUMBER}"
+    }
+    throw exc
+}
+
diff --git a/ci/jenkinsfile/cluster_cleanup_dev.groovy b/ci/jenkinsfile/cluster_cleanup_dev.groovy
new file mode 100644
index 0000000000..e57988fefe
--- /dev/null
+++ b/ci/jenkinsfile/cluster_cleanup_dev.groovy
@@ -0,0 +1,13 @@
+try {
+    def result = sh script: "helm status ${env.JOB_NAME}-${env.BUILD_NUMBER}-cluster", returnStatus: true
+    if (!result) {
+        sh "helm del --purge ${env.JOB_NAME}-${env.BUILD_NUMBER}-cluster"
+    }
+} catch (exc) {
+    def result = sh script: "helm status ${env.JOB_NAME}-${env.BUILD_NUMBER}-cluster", returnStatus: true
+    if (!result) {
+        sh "helm del --purge ${env.JOB_NAME}-${env.BUILD_NUMBER}-cluster"
+    }
+    throw exc
+}
+
diff --git a/ci/jenkinsfile/cluster_deploy2dev.groovy b/ci/jenkinsfile/cluster_deploy2dev.groovy
new file mode 100644
index 0000000000..7f2a584256
--- /dev/null
+++ b/ci/jenkinsfile/cluster_deploy2dev.groovy
@@ -0,0 +1,24 @@
+try {
+    sh 'helm init --client-only --skip-refresh --stable-repo-url https://kubernetes.oss-cn-hangzhou.aliyuncs.com/charts'
+    sh 'helm repo add milvus https://registry.zilliz.com/chartrepo/milvus'
+    sh 'helm repo update'
+    dir ("milvus-helm") {
+        checkout([$class: 'GitSCM', branches: [[name: "${SEMVER}"]], doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [], userRemoteConfigs: [[credentialsId: "${params.GIT_USER}", url: "git@192.168.1.105:megasearch/milvus-helm.git", name: 'origin', refspec: "+refs/heads/${SEMVER}:refs/remotes/origin/${SEMVER}"]]])
+        dir ("milvus/milvus-cluster") {
+            sh "helm install --wait --timeout 300 --set roServers.image.tag=${DOCKER_VERSION} --set woServers.image.tag=${DOCKER_VERSION} --set expose.type=clusterIP -f ci/values.yaml --name ${env.JOB_NAME}-${env.BUILD_NUMBER}-cluster --namespace milvus-cluster --version 0.5.0 . "
+        }
+    }
+    /*
+    timeout(time: 2, unit: 'MINUTES') {
+        waitUntil {
+            def result = sh script: "nc -z -w 3 ${env.JOB_NAME}-${env.BUILD_NUMBER}-cluster-milvus-cluster-proxy.milvus-cluster.svc.cluster.local 19530", returnStatus: true
+            return !result
+        }
+    }
+    */
+} catch (exc) {
+    echo 'Helm running failed!'
+    sh "helm del --purge ${env.JOB_NAME}-${env.BUILD_NUMBER}-cluster"
+    throw exc
+}
+
diff --git a/ci/jenkinsfile/cluster_dev_test.groovy b/ci/jenkinsfile/cluster_dev_test.groovy
new file mode 100644
index 0000000000..4a15b926cf
--- /dev/null
+++ b/ci/jenkinsfile/cluster_dev_test.groovy
@@ -0,0 +1,12 @@
+timeout(time: 25, unit: 'MINUTES') {
+    try {
+        dir ("${PROJECT_NAME}_test") {
+            checkout([$class: 'GitSCM', branches: [[name: "${SEMVER}"]], doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [], userRemoteConfigs: [[credentialsId: "${params.GIT_USER}", url: "git@192.168.1.105:Test/milvus_test.git", name: 'origin', refspec: "+refs/heads/${SEMVER}:refs/remotes/origin/${SEMVER}"]]])
+            sh 'python3 -m pip install -r requirements_cluster.txt'
+            sh "pytest . --alluredir=cluster_test_out --ip ${env.JOB_NAME}-${env.BUILD_NUMBER}-cluster-milvus-cluster-proxy.milvus-cluster.svc.cluster.local"
+        }
+    } catch (exc) {
+        echo 'Milvus Cluster Test Failed !'
+        throw exc
+    }
+}
diff --git a/ci/jenkinsfile/deploy2dev.groovy b/ci/jenkinsfile/deploy2dev.groovy
new file mode 100644
index 0000000000..b00c8fa335
--- /dev/null
+++ b/ci/jenkinsfile/deploy2dev.groovy
@@ -0,0 +1,16 @@
+try {
+    sh 'helm init --client-only --skip-refresh --stable-repo-url https://kubernetes.oss-cn-hangzhou.aliyuncs.com/charts'
+    sh 'helm repo add milvus https://registry.zilliz.com/chartrepo/milvus'
+    sh 'helm repo update'
+    dir ("milvus-helm") {
+        checkout([$class: 'GitSCM', branches: [[name: "${SEMVER}"]], doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [], userRemoteConfigs: [[credentialsId: "${params.GIT_USER}", url: "git@192.168.1.105:megasearch/milvus-helm.git", name: 'origin', refspec: "+refs/heads/${SEMVER}:refs/remotes/origin/${SEMVER}"]]])
+        dir ("milvus/milvus-gpu") {
+            sh "helm install --wait --timeout 300 --set engine.image.tag=${DOCKER_VERSION} --set expose.type=clusterIP --name ${env.JOB_NAME}-${env.BUILD_NUMBER} -f ci/values.yaml --namespace milvus-1 --version 0.5.0 ."
+        }
+    }
+} catch (exc) {
+    echo 'Helm running failed!'
+    sh "helm del --purge ${env.JOB_NAME}-${env.BUILD_NUMBER}"
+    throw exc
+}
+
diff --git a/ci/jenkinsfile/deploy2staging.groovy b/ci/jenkinsfile/deploy2staging.groovy
new file mode 100644
index 0000000000..42ccfda71a
--- /dev/null
+++ b/ci/jenkinsfile/deploy2staging.groovy
@@ -0,0 +1,16 @@
+try {
+    sh 'helm init --client-only --skip-refresh --stable-repo-url https://kubernetes.oss-cn-hangzhou.aliyuncs.com/charts'
+    sh 'helm repo add milvus https://registry.zilliz.com/chartrepo/milvus'
+    sh 'helm repo update'
+    dir ("milvus-helm") {
+        checkout([$class: 'GitSCM', branches: [[name: "${SEMVER}"]], doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [], userRemoteConfigs: [[credentialsId: "${params.GIT_USER}", url: "git@192.168.1.105:megasearch/milvus-helm.git", name: 'origin', refspec: "+refs/heads/${SEMVER}:refs/remotes/origin/${SEMVER}"]]])
+        dir ("milvus/milvus-gpu") {
+            sh "helm install --wait --timeout 300 --set engine.image.repository=\"zilliz.azurecr.cn/milvus/engine\" --set engine.image.tag=${DOCKER_VERSION} --set expose.type=loadBalancer --name ${env.JOB_NAME}-${env.BUILD_NUMBER} -f ci/values.yaml --namespace milvus-1 --version 0.5.0 ."
+        }
+    }
+} catch (exc) {
+    echo 'Helm running failed!'
+    sh "helm del --purge ${env.JOB_NAME}-${env.BUILD_NUMBER}"
+    throw exc
+}
+
diff --git a/ci/jenkinsfile/dev_test.groovy b/ci/jenkinsfile/dev_test.groovy
new file mode 100644
index 0000000000..f9df9b4065
--- /dev/null
+++ b/ci/jenkinsfile/dev_test.groovy
@@ -0,0 +1,28 @@
+timeout(time: 30, unit: 'MINUTES') {
+    try {
+        dir ("${PROJECT_NAME}_test") {
+            checkout([$class: 'GitSCM', branches: [[name: "${SEMVER}"]], doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [], userRemoteConfigs: [[credentialsId: "${params.GIT_USER}", url: "git@192.168.1.105:Test/milvus_test.git", name: 'origin', refspec: "+refs/heads/${SEMVER}:refs/remotes/origin/${SEMVER}"]]])
+            sh 'python3 -m pip install -r requirements.txt -i http://pypi.douban.com/simple --trusted-host pypi.douban.com'
+            sh "pytest . --alluredir=\"test_out/dev/single/sqlite\" --level=1 --ip ${env.JOB_NAME}-${env.BUILD_NUMBER}-milvus-gpu-engine.milvus-1.svc.cluster.local"
+        }
+        // mysql database backend test
+        load "${env.WORKSPACE}/ci/jenkinsfile/cleanup_dev.groovy"
+
+        if (!fileExists('milvus-helm')) {
+            dir ("milvus-helm") {
+                checkout([$class: 'GitSCM', branches: [[name: "${SEMVER}"]], doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [], userRemoteConfigs: [[credentialsId: "${params.GIT_USER}", url: "git@192.168.1.105:megasearch/milvus-helm.git", name: 'origin', refspec: "+refs/heads/${SEMVER}:refs/remotes/origin/${SEMVER}"]]])
+            }
+        }
+        dir ("milvus-helm") {
+            dir ("milvus/milvus-gpu") {
+                sh "helm install --wait --timeout 300 --set engine.image.tag=${DOCKER_VERSION} --set expose.type=clusterIP --name ${env.JOB_NAME}-${env.BUILD_NUMBER} -f ci/db_backend/mysql_values.yaml --namespace milvus-2 --version 0.5.0 ."
+            }
+        }
+        dir ("${PROJECT_NAME}_test") {
+            sh "pytest . --alluredir=\"test_out/dev/single/mysql\" --level=1 --ip ${env.JOB_NAME}-${env.BUILD_NUMBER}-milvus-gpu-engine.milvus-2.svc.cluster.local"
+        }
+    } catch (exc) {
+        echo 'Milvus Test Failed !'
+        throw exc
+    }
+}
diff --git a/ci/jenkinsfile/dev_test_all.groovy b/ci/jenkinsfile/dev_test_all.groovy
new file mode 100644
index 0000000000..b11ea755b9
--- /dev/null
+++ b/ci/jenkinsfile/dev_test_all.groovy
@@ -0,0 +1,29 @@
+timeout(time: 60, unit: 'MINUTES') {
+    try {
+        dir ("${PROJECT_NAME}_test") {
+            checkout([$class: 'GitSCM', branches: [[name: "${SEMVER}"]], doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [], userRemoteConfigs: [[credentialsId: "${params.GIT_USER}", url: "git@192.168.1.105:Test/milvus_test.git", name: 'origin', refspec: "+refs/heads/${SEMVER}:refs/remotes/origin/${SEMVER}"]]])
+            sh 'python3 -m pip install -r requirements.txt -i http://pypi.douban.com/simple --trusted-host pypi.douban.com'
+            sh "pytest . --alluredir=\"test_out/dev/single/sqlite\" --ip ${env.JOB_NAME}-${env.BUILD_NUMBER}-milvus-gpu-engine.milvus-1.svc.cluster.local"
+        }
+
+        // mysql database backend test
+        load "${env.WORKSPACE}/ci/jenkinsfile/cleanup_dev.groovy"
+
+        if (!fileExists('milvus-helm')) {
+            dir ("milvus-helm") {
+                checkout([$class: 'GitSCM', branches: [[name: "${SEMVER}"]], doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [], userRemoteConfigs: [[credentialsId: "${params.GIT_USER}", url: "git@192.168.1.105:megasearch/milvus-helm.git", name: 'origin', refspec: "+refs/heads/${SEMVER}:refs/remotes/origin/${SEMVER}"]]])
+            }
+        }
+        dir ("milvus-helm") {
+            dir ("milvus/milvus-gpu") {
+                sh "helm install --wait --timeout 300 --set engine.image.tag=${DOCKER_VERSION} --set expose.type=clusterIP --name ${env.JOB_NAME}-${env.BUILD_NUMBER} -f ci/db_backend/mysql_values.yaml --namespace milvus-2 --version 0.4.0 ."
+            }
+        }
+        dir ("${PROJECT_NAME}_test") {
+            sh "pytest . --alluredir=\"test_out/dev/single/mysql\" --ip ${env.JOB_NAME}-${env.BUILD_NUMBER}-milvus-gpu-engine.milvus-2.svc.cluster.local"
+        }
+    } catch (exc) {
+        echo 'Milvus Test Failed !'
+        throw exc
+    }
+}
diff --git a/ci/jenkinsfile/milvus_build.groovy b/ci/jenkinsfile/milvus_build.groovy
new file mode 100644
index 0000000000..92fd364bb9
--- /dev/null
+++ b/ci/jenkinsfile/milvus_build.groovy
@@ -0,0 +1,30 @@
+container('milvus-build-env') {
+    timeout(time: 120, unit: 'MINUTES') {
+        gitlabCommitStatus(name: 'Build Engine') {
+            dir ("milvus_engine") {
+                try {
+                    checkout([$class: 'GitSCM', branches: [[name: "${SEMVER}"]], doGenerateSubmoduleConfigurations: false, extensions: [[$class: 'SubmoduleOption',disableSubmodules: false,parentCredentials: true,recursiveSubmodules: true,reference: '',trackingSubmodules: false]], submoduleCfg: [], userRemoteConfigs: [[credentialsId: "${params.GIT_USER}", url: "git@192.168.1.105:megasearch/milvus.git", name: 'origin', refspec: "+refs/heads/${SEMVER}:refs/remotes/origin/${SEMVER}"]]])
+
+                    dir ("core") {
+                        sh "git config --global user.email \"test@zilliz.com\""
+                        sh "git config --global user.name \"test\""
+                        withCredentials([usernamePassword(credentialsId: "${params.JFROG_USER}", usernameVariable: 'USERNAME', passwordVariable: 'PASSWORD')]) {
+                            sh "./build.sh -l"
+                            sh "rm -rf cmake_build"
+                            sh "export JFROG_ARTFACTORY_URL='${params.JFROG_ARTFACTORY_URL}' \
+                            && export JFROG_USER_NAME='${USERNAME}' \
+                            && export JFROG_PASSWORD='${PASSWORD}' \
+                            && export FAISS_URL='http://192.168.1.105:6060/jinhai/faiss/-/archive/branch-0.2.1/faiss-branch-0.2.1.tar.gz' \
+                            && ./build.sh -t ${params.BUILD_TYPE} -d /opt/milvus -j -u -c"
+
+                            sh "./coverage.sh -u root -p 123456 -t \$POD_IP"
+                        }
+                    }
+                } catch (exc) {
+                    updateGitlabCommitStatus name: 'Build Engine', state: 'failed'
+                    throw exc
+                }
+            }
+        }
+    }
+}
diff --git a/ci/jenkinsfile/milvus_build_no_ut.groovy b/ci/jenkinsfile/milvus_build_no_ut.groovy
new file mode 100644
index 0000000000..1dd3361106
--- /dev/null
+++ b/ci/jenkinsfile/milvus_build_no_ut.groovy
@@ -0,0 +1,28 @@
+container('milvus-build-env') {
+    timeout(time: 120, unit: 'MINUTES') {
+        gitlabCommitStatus(name: 'Build Engine') {
+            dir ("milvus_engine") {
+                try {
+                    checkout([$class: 'GitSCM', branches: [[name: "${SEMVER}"]], doGenerateSubmoduleConfigurations: false, extensions: [[$class: 'SubmoduleOption',disableSubmodules: false,parentCredentials: true,recursiveSubmodules: true,reference: '',trackingSubmodules: false]], submoduleCfg: [], userRemoteConfigs: [[credentialsId: "${params.GIT_USER}", url: "git@192.168.1.105:megasearch/milvus.git", name: 'origin', refspec: "+refs/heads/${SEMVER}:refs/remotes/origin/${SEMVER}"]]])
+
+                    dir ("core") {
+                        sh "git config --global user.email \"test@zilliz.com\""
+                        sh "git config --global user.name \"test\""
+                        withCredentials([usernamePassword(credentialsId: "${params.JFROG_USER}", usernameVariable: 'USERNAME', passwordVariable: 'PASSWORD')]) {
+                            sh "./build.sh -l"
+                            sh "rm -rf cmake_build"
+                            sh "export JFROG_ARTFACTORY_URL='${params.JFROG_ARTFACTORY_URL}' \
+                            && export JFROG_USER_NAME='${USERNAME}' \
+                            && export JFROG_PASSWORD='${PASSWORD}' \
+                            && export FAISS_URL='http://192.168.1.105:6060/jinhai/faiss/-/archive/branch-0.2.1/faiss-branch-0.2.1.tar.gz' \
+                            && ./build.sh -t ${params.BUILD_TYPE} -j -d /opt/milvus"
+                        }
+                    }
+                } catch (exc) {
+                    updateGitlabCommitStatus name: 'Build Engine', state: 'failed'
+                    throw exc
+                }
+            }
+        }
+    }
+}
diff --git a/ci/jenkinsfile/nightly_publish_docker.groovy b/ci/jenkinsfile/nightly_publish_docker.groovy
new file mode 100644
index 0000000000..8c6121bec8
--- /dev/null
+++ b/ci/jenkinsfile/nightly_publish_docker.groovy
@@ -0,0 +1,38 @@
+container('publish-docker') {
+    timeout(time: 15, unit: 'MINUTES') {
+        gitlabCommitStatus(name: 'Publish Engine Docker') {
+            try {
+                dir ("${PROJECT_NAME}_build") {
+                    checkout([$class: 'GitSCM', branches: [[name: "${SEMVER}"]], doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [], userRemoteConfigs: [[credentialsId: "${params.GIT_USER}", url: "git@192.168.1.105:build/milvus_build.git", name: 'origin', refspec: "+refs/heads/${SEMVER}:refs/remotes/origin/${SEMVER}"]]])
+                    dir ("docker/deploy/ubuntu16.04/free_version") {
+                        sh "curl -O -u anonymous: ftp://192.168.1.126/data/${PROJECT_NAME}/engine/${JOB_NAME}-${BUILD_ID}/${PROJECT_NAME}-engine-${PACKAGE_VERSION}.tar.gz"
+                        sh "tar zxvf ${PROJECT_NAME}-engine-${PACKAGE_VERSION}.tar.gz"
+                        try {
+                            def customImage = docker.build("${PROJECT_NAME}/engine:${DOCKER_VERSION}")
+                            docker.withRegistry('https://registry.zilliz.com', "${params.DOCKER_PUBLISH_USER}") {
+                                customImage.push()
+                            }
+                            docker.withRegistry('https://zilliz.azurecr.cn', "${params.AZURE_DOCKER_PUBLISH_USER}") {
+                                customImage.push()
+                            }
+                            if (currentBuild.resultIsBetterOrEqualTo('SUCCESS')) {
+                                updateGitlabCommitStatus name: 'Publish Engine Docker', state: 'success'
+                                echo "Docker Pull Command: docker pull registry.zilliz.com/${PROJECT_NAME}/engine:${DOCKER_VERSION}"
+                            }
+                        } catch (exc) {
+                            updateGitlabCommitStatus name: 'Publish Engine Docker', state: 'canceled'
+                            throw exc
+                        } finally {
+                            sh "docker rmi ${PROJECT_NAME}/engine:${DOCKER_VERSION}"
+                        }
+                    }
+                }
+            } catch (exc) {
+                updateGitlabCommitStatus name: 'Publish Engine Docker', state: 'failed'
+                echo 'Publish docker failed!'
+                throw exc
+            }
+        }
+    }
+}
+
diff --git a/ci/jenkinsfile/notify.groovy b/ci/jenkinsfile/notify.groovy
new file mode 100644
index 0000000000..0a257b8cd8
--- /dev/null
+++ b/ci/jenkinsfile/notify.groovy
@@ -0,0 +1,15 @@
+def notify() {
+    if (!currentBuild.resultIsBetterOrEqualTo('SUCCESS')) {
+        // Send an email only if the build status has changed from green/unstable to red
+        emailext subject: '$DEFAULT_SUBJECT',
+        body: '$DEFAULT_CONTENT',
+        recipientProviders: [
+            [$class: 'DevelopersRecipientProvider'],
+            [$class: 'RequesterRecipientProvider']
+        ], 
+        replyTo: '$DEFAULT_REPLYTO',
+        to: '$DEFAULT_RECIPIENTS'
+    }
+}
+return this
+
diff --git a/ci/jenkinsfile/packaged_milvus.groovy b/ci/jenkinsfile/packaged_milvus.groovy
new file mode 100644
index 0000000000..1d30e21910
--- /dev/null
+++ b/ci/jenkinsfile/packaged_milvus.groovy
@@ -0,0 +1,44 @@
+container('milvus-build-env') {
+    timeout(time: 5, unit: 'MINUTES') {
+        dir ("milvus_engine") {
+            dir ("core") {
+                gitlabCommitStatus(name: 'Packaged Engine') {
+                    if (fileExists('milvus')) {
+                        try {
+                            sh "tar -zcvf ./${PROJECT_NAME}-engine-${PACKAGE_VERSION}.tar.gz ./milvus"
+                            def fileTransfer = load "${env.WORKSPACE}/ci/function/file_transfer.groovy"
+                            fileTransfer.FileTransfer("${PROJECT_NAME}-engine-${PACKAGE_VERSION}.tar.gz", "${PROJECT_NAME}/engine/${JOB_NAME}-${BUILD_ID}", 'nas storage')
+                            if (currentBuild.resultIsBetterOrEqualTo('SUCCESS')) {
+                                echo "Download Milvus Engine Binary Viewer \"http://192.168.1.126:8080/${PROJECT_NAME}/engine/${JOB_NAME}-${BUILD_ID}/${PROJECT_NAME}-engine-${PACKAGE_VERSION}.tar.gz\""
+                            }
+                        } catch (exc) {
+                            updateGitlabCommitStatus name: 'Packaged Engine', state: 'failed'
+                            throw exc
+                        }
+                    } else {
+                        updateGitlabCommitStatus name: 'Packaged Engine', state: 'failed'
+                        error("Milvus binary directory don't exists!")
+                    }
+                }
+
+                gitlabCommitStatus(name: 'Packaged Engine lcov') {
+                    if (fileExists('lcov_out')) {
+                        try {
+                            def fileTransfer = load "${env.WORKSPACE}/ci/function/file_transfer.groovy"
+                            fileTransfer.FileTransfer("lcov_out/", "${PROJECT_NAME}/lcov/${JOB_NAME}-${BUILD_ID}", 'nas storage')
+                            if (currentBuild.resultIsBetterOrEqualTo('SUCCESS')) {
+                                echo "Milvus lcov out Viewer \"http://192.168.1.126:8080/${PROJECT_NAME}/lcov/${JOB_NAME}-${BUILD_ID}/lcov_out/\""
+                            }
+                        } catch (exc) {
+                            updateGitlabCommitStatus name: 'Packaged Engine lcov', state: 'failed'
+                            throw exc
+                        }
+                    } else {
+                        updateGitlabCommitStatus name: 'Packaged Engine lcov', state: 'failed'
+                        error("Milvus lcov out directory don't exists!")
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/ci/jenkinsfile/packaged_milvus_no_ut.groovy b/ci/jenkinsfile/packaged_milvus_no_ut.groovy
new file mode 100644
index 0000000000..bc68be374a
--- /dev/null
+++ b/ci/jenkinsfile/packaged_milvus_no_ut.groovy
@@ -0,0 +1,26 @@
+container('milvus-build-env') {
+    timeout(time: 5, unit: 'MINUTES') {
+        dir ("milvus_engine") {
+            dir ("core") {
+                gitlabCommitStatus(name: 'Packaged Engine') {
+                    if (fileExists('milvus')) {
+                        try {
+                            sh "tar -zcvf ./${PROJECT_NAME}-engine-${PACKAGE_VERSION}.tar.gz ./milvus"
+                            def fileTransfer = load "${env.WORKSPACE}/ci/function/file_transfer.groovy"
+                            fileTransfer.FileTransfer("${PROJECT_NAME}-engine-${PACKAGE_VERSION}.tar.gz", "${PROJECT_NAME}/engine/${JOB_NAME}-${BUILD_ID}", 'nas storage')
+                            if (currentBuild.resultIsBetterOrEqualTo('SUCCESS')) {
+                                echo "Download Milvus Engine Binary Viewer \"http://192.168.1.126:8080/${PROJECT_NAME}/engine/${JOB_NAME}-${BUILD_ID}/${PROJECT_NAME}-engine-${PACKAGE_VERSION}.tar.gz\""
+                            }
+                        } catch (exc) {
+                            updateGitlabCommitStatus name: 'Packaged Engine', state: 'failed'
+                            throw exc
+                        }
+                    } else {
+                        updateGitlabCommitStatus name: 'Packaged Engine', state: 'failed'
+                        error("Milvus binary directory don't exists!")
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/ci/jenkinsfile/publish_docker.groovy b/ci/jenkinsfile/publish_docker.groovy
new file mode 100644
index 0000000000..ef31eba9a4
--- /dev/null
+++ b/ci/jenkinsfile/publish_docker.groovy
@@ -0,0 +1,35 @@
+container('publish-docker') {
+    timeout(time: 15, unit: 'MINUTES') {
+        gitlabCommitStatus(name: 'Publish Engine Docker') {
+            try {
+                dir ("${PROJECT_NAME}_build") {
+                    checkout([$class: 'GitSCM', branches: [[name: "${SEMVER}"]], doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [], userRemoteConfigs: [[credentialsId: "${params.GIT_USER}", url: "git@192.168.1.105:build/milvus_build.git", name: 'origin', refspec: "+refs/heads/${SEMVER}:refs/remotes/origin/${SEMVER}"]]])
+                    dir ("docker/deploy/ubuntu16.04/free_version") {
+                        sh "curl -O -u anonymous: ftp://192.168.1.126/data/${PROJECT_NAME}/engine/${JOB_NAME}-${BUILD_ID}/${PROJECT_NAME}-engine-${PACKAGE_VERSION}.tar.gz"
+                        sh "tar zxvf ${PROJECT_NAME}-engine-${PACKAGE_VERSION}.tar.gz"
+                        try {
+                            def customImage = docker.build("${PROJECT_NAME}/engine:${DOCKER_VERSION}")
+                            docker.withRegistry('https://registry.zilliz.com', "${params.DOCKER_PUBLISH_USER}") {
+                                customImage.push()
+                            }
+                            if (currentBuild.resultIsBetterOrEqualTo('SUCCESS')) {
+                                updateGitlabCommitStatus name: 'Publish Engine Docker', state: 'success'
+                                echo "Docker Pull Command: docker pull registry.zilliz.com/${PROJECT_NAME}/engine:${DOCKER_VERSION}"
+                            }
+                        } catch (exc) {
+                            updateGitlabCommitStatus name: 'Publish Engine Docker', state: 'canceled'
+                            throw exc
+                        } finally {
+                            sh "docker rmi ${PROJECT_NAME}/engine:${DOCKER_VERSION}"
+                        }
+                    }
+                }
+            } catch (exc) {
+                updateGitlabCommitStatus name: 'Publish Engine Docker', state: 'failed'
+                echo 'Publish docker failed!'
+                throw exc
+            }
+        }
+    }
+}
+
diff --git a/ci/jenkinsfile/staging_test.groovy b/ci/jenkinsfile/staging_test.groovy
new file mode 100644
index 0000000000..dcf1787103
--- /dev/null
+++ b/ci/jenkinsfile/staging_test.groovy
@@ -0,0 +1,31 @@
+timeout(time: 40, unit: 'MINUTES') {
+    try {
+        dir ("${PROJECT_NAME}_test") {
+            checkout([$class: 'GitSCM', branches: [[name: "${SEMVER}"]], doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [], userRemoteConfigs: [[credentialsId: "${params.GIT_USER}", url: "git@192.168.1.105:Test/milvus_test.git", name: 'origin', refspec: "+refs/heads/${SEMVER}:refs/remotes/origin/${SEMVER}"]]])
+            sh 'python3 -m pip install -r requirements.txt'
+            def service_ip = sh (script: "kubectl get svc --namespace milvus-1 ${env.JOB_NAME}-${env.BUILD_NUMBER}-milvus-gpu-engine --template \"{{range .status.loadBalancer.ingress}}{{.ip}}{{end}}\"",returnStdout: true).trim()
+            sh "pytest . --alluredir=\"test_out/staging/single/sqlite\" --ip ${service_ip}"
+        }
+
+        // mysql database backend test
+        load "${env.WORKSPACE}/ci/jenkinsfile/cleanup_staging.groovy"
+
+        if (!fileExists('milvus-helm')) {
+            dir ("milvus-helm") {
+                checkout([$class: 'GitSCM', branches: [[name: "${SEMVER}"]], doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [], userRemoteConfigs: [[credentialsId: "${params.GIT_USER}", url: "git@192.168.1.105:megasearch/milvus-helm.git", name: 'origin', refspec: "+refs/heads/${SEMVER}:refs/remotes/origin/${SEMVER}"]]])
+            }
+        }
+        dir ("milvus-helm") {
+            dir ("milvus/milvus-gpu") {
+                sh "helm install --wait --timeout 300 --set engine.image.repository=\"zilliz.azurecr.cn/milvus/engine\" --set engine.image.tag=${DOCKER_VERSION} --set expose.type=loadBalancer --name ${env.JOB_NAME}-${env.BUILD_NUMBER} -f ci/db_backend/mysql_values.yaml --namespace milvus-2 --version 0.5.0 ."
+            }
+        }
+        dir ("${PROJECT_NAME}_test") {
+            def service_ip = sh (script: "kubectl get svc --namespace milvus-2 ${env.JOB_NAME}-${env.BUILD_NUMBER}-milvus-gpu-engine --template \"{{range .status.loadBalancer.ingress}}{{.ip}}{{end}}\"",returnStdout: true).trim()
+            sh "pytest . --alluredir=\"test_out/staging/single/mysql\" --ip ${service_ip}"
+        }
+    } catch (exc) {
+        echo 'Milvus Test Failed !'
+        throw exc
+    }
+}
diff --git a/ci/jenkinsfile/upload_dev_cluster_test_out.groovy b/ci/jenkinsfile/upload_dev_cluster_test_out.groovy
new file mode 100644
index 0000000000..6bbd8a649f
--- /dev/null
+++ b/ci/jenkinsfile/upload_dev_cluster_test_out.groovy
@@ -0,0 +1,14 @@
+timeout(time: 5, unit: 'MINUTES') {
+    dir ("${PROJECT_NAME}_test") {
+        if (fileExists('cluster_test_out')) {
+            def fileTransfer = load "${env.WORKSPACE}/ci/function/file_transfer.groovy"
+            fileTransfer.FileTransfer("cluster_test_out/", "${PROJECT_NAME}/test/${JOB_NAME}-${BUILD_ID}", 'nas storage')
+            if (currentBuild.resultIsBetterOrEqualTo('SUCCESS')) {
+                echo "Milvus Dev Test Out Viewer \"ftp://192.168.1.126/data/${PROJECT_NAME}/test/${JOB_NAME}-${BUILD_ID}\""
+            }
+        } else {
+            error("Milvus Dev Test Out directory don't exists!")
+        }
+    }
+}
+
diff --git a/ci/jenkinsfile/upload_dev_test_out.groovy b/ci/jenkinsfile/upload_dev_test_out.groovy
new file mode 100644
index 0000000000..017b887334
--- /dev/null
+++ b/ci/jenkinsfile/upload_dev_test_out.groovy
@@ -0,0 +1,13 @@
+timeout(time: 5, unit: 'MINUTES') {
+    dir ("${PROJECT_NAME}_test") {
+        if (fileExists('test_out/dev')) {
+            def fileTransfer = load "${env.WORKSPACE}/ci/function/file_transfer.groovy"
+            fileTransfer.FileTransfer("test_out/dev/", "${PROJECT_NAME}/test/${JOB_NAME}-${BUILD_ID}", 'nas storage')
+            if (currentBuild.resultIsBetterOrEqualTo('SUCCESS')) {
+                echo "Milvus Dev Test Out Viewer \"ftp://192.168.1.126/data/${PROJECT_NAME}/test/${JOB_NAME}-${BUILD_ID}\""
+            }
+        } else {
+            error("Milvus Dev Test Out directory don't exists!")
+        }
+    }
+}
diff --git a/ci/jenkinsfile/upload_staging_test_out.groovy b/ci/jenkinsfile/upload_staging_test_out.groovy
new file mode 100644
index 0000000000..1f1e66ab1b
--- /dev/null
+++ b/ci/jenkinsfile/upload_staging_test_out.groovy
@@ -0,0 +1,13 @@
+timeout(time: 5, unit: 'MINUTES') {
+    dir ("${PROJECT_NAME}_test") {
+        if (fileExists('test_out/staging')) {
+            def fileTransfer = load "${env.WORKSPACE}/ci/function/file_transfer.groovy"
+            fileTransfer.FileTransfer("test_out/staging/", "${PROJECT_NAME}/test/${JOB_NAME}-${BUILD_ID}", 'nas storage')
+            if (currentBuild.resultIsBetterOrEqualTo('SUCCESS')) {
+                echo "Milvus Dev Test Out Viewer \"ftp://192.168.1.126/data/${PROJECT_NAME}/test/${JOB_NAME}-${BUILD_ID}\""
+            }
+        } else {
+            error("Milvus Dev Test Out directory don't exists!")
+        }
+    }
+}
diff --git a/ci/main_jenkinsfile b/ci/main_jenkinsfile
new file mode 100644
index 0000000000..0c3fc32e5b
--- /dev/null
+++ b/ci/main_jenkinsfile
@@ -0,0 +1,396 @@
+pipeline {
+    agent none
+
+    options {
+        timestamps()
+    }
+
+    environment {
+        PROJECT_NAME = "milvus"
+        LOWER_BUILD_TYPE = BUILD_TYPE.toLowerCase()
+        SEMVER = "${env.gitlabSourceBranch == null ? params.ENGINE_BRANCH.substring(params.ENGINE_BRANCH.lastIndexOf('/') + 1) : env.gitlabSourceBranch}"
+        GITLAB_AFTER_COMMIT = "${env.gitlabAfter == null ? null : env.gitlabAfter}"
+        SUFFIX_VERSION_NAME = "${env.gitlabAfter == null ? null : env.gitlabAfter.substring(0, 6)}"
+        DOCKER_VERSION_STR = "${env.gitlabAfter == null ? "${SEMVER}-${LOWER_BUILD_TYPE}" : "${SEMVER}-${LOWER_BUILD_TYPE}-${SUFFIX_VERSION_NAME}"}"
+    }
+
+    stages {
+        stage("Ubuntu 16.04") {
+            environment {
+                PACKAGE_VERSION = VersionNumber([
+                    versionNumberString : '${SEMVER}-${LOWER_BUILD_TYPE}-${BUILD_DATE_FORMATTED, "yyyyMMdd"}'
+                ]);
+
+                DOCKER_VERSION = VersionNumber([
+                    versionNumberString : '${DOCKER_VERSION_STR}'
+                ]);
+            }
+
+            stages {
+                stage("Run Build") {
+                    agent {
+                        kubernetes {
+                            cloud 'build-kubernetes'
+                            label 'build'
+                            defaultContainer 'jnlp'
+                            yaml """
+apiVersion: v1
+kind: Pod
+metadata:
+  name: milvus-build-env
+  labels:
+    app: milvus
+    componet: build-env
+spec:
+  containers:
+  - name: milvus-build-env
+    image: registry.zilliz.com/milvus/milvus-build-env:v0.13
+    env:
+    - name: POD_IP
+      valueFrom:
+        fieldRef:
+          fieldPath: status.podIP
+    command:
+    - cat
+    tty: true
+    resources:
+      limits:
+        memory: "28Gi"
+        cpu: "10.0"
+        nvidia.com/gpu: 1
+      requests:
+        memory: "14Gi"
+        cpu: "5.0"
+  - name: milvus-mysql
+    image: mysql:5.6
+    env:
+    - name: MYSQL_ROOT_PASSWORD
+      value: 123456
+    ports:
+    - containerPort: 3306
+      name: mysql
+"""
+                        }
+                    }
+                    stages {
+                        stage('Build') {
+                            steps {
+                                gitlabCommitStatus(name: 'Build') {
+                                    script {
+                                        load "${env.WORKSPACE}/ci/jenkinsfile/milvus_build.groovy"
+                                        load "${env.WORKSPACE}/ci/jenkinsfile/packaged_milvus.groovy"
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    post {
+                        aborted {
+                            script {
+                                updateGitlabCommitStatus name: 'Build', state: 'canceled'
+                                echo "Milvus Build aborted !"
+                            }
+                        }
+
+                        failure {
+                            script {
+                                updateGitlabCommitStatus name: 'Build', state: 'failed'
+                                echo "Milvus Build failure !"
+                            }
+                        }
+                    }
+                }
+
+                stage("Publish docker and helm") {
+                    agent {
+                        kubernetes {
+                            label 'publish'
+                            defaultContainer 'jnlp'
+                            yaml """
+apiVersion: v1
+kind: Pod
+metadata:
+  labels:
+    app: publish
+    componet: docker
+spec:
+  containers:
+  - name: publish-docker
+    image: registry.zilliz.com/library/zilliz_docker:v1.0.0
+    securityContext:
+      privileged: true
+    command:
+    - cat
+    tty: true
+    volumeMounts:
+    - name: docker-sock
+      mountPath: /var/run/docker.sock
+  volumes:
+  - name: docker-sock
+    hostPath:
+      path: /var/run/docker.sock
+"""
+                        }
+                    }
+                    stages {
+                        stage('Publish Docker') {
+                            steps {
+                                gitlabCommitStatus(name: 'Publish Docker') {
+                                    script {
+                                        load "${env.WORKSPACE}/ci/jenkinsfile/publish_docker.groovy"
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    post {
+                        aborted {
+                            script {
+                                updateGitlabCommitStatus name: 'Publish Docker', state: 'canceled'
+                                echo "Milvus Publish Docker aborted !"
+                            }
+                        }
+
+                        failure {
+                            script {
+                                updateGitlabCommitStatus name: 'Publish Docker', state: 'failed'
+                                echo "Milvus Publish Docker failure !"
+                            }
+                        }
+                    }
+                }
+
+                stage("Deploy to Development") {
+                    parallel {
+                        stage("Single Node") {
+                            agent {
+                                kubernetes {
+                                    label 'dev-test'
+                                    defaultContainer 'jnlp'
+                                    yaml """
+apiVersion: v1
+kind: Pod
+metadata:
+  labels:
+    app: milvus
+    componet: test
+spec:
+  containers:
+  - name: milvus-testframework
+    image: registry.zilliz.com/milvus/milvus-test:v0.2
+    command:
+    - cat
+    tty: true
+    volumeMounts:
+    - name: kubeconf
+      mountPath: /root/.kube/
+      readOnly: true
+  volumes:
+  - name: kubeconf
+    secret:
+      secretName: test-cluster-config
+"""
+                                }
+                            }
+
+                            stages {
+                                stage("Deploy to Dev") {
+                                    steps {
+                                        gitlabCommitStatus(name: 'Deloy to Dev') {
+                                            container('milvus-testframework') {
+                                                script {
+                                                    load "${env.WORKSPACE}/ci/jenkinsfile/deploy2dev.groovy"
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                                stage("Dev Test") {
+                                    steps {
+                                        gitlabCommitStatus(name: 'Deloy Test') {
+                                            container('milvus-testframework') {
+                                                script {
+                                                    load "${env.WORKSPACE}/ci/jenkinsfile/dev_test.groovy"
+                                                    load "${env.WORKSPACE}/ci/jenkinsfile/upload_dev_test_out.groovy"
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                                stage ("Cleanup Dev") {
+                                    steps {
+                                        gitlabCommitStatus(name: 'Cleanup Dev') {
+                                            container('milvus-testframework') {
+                                                script {
+                                                    load "${env.WORKSPACE}/ci/jenkinsfile/cleanup_dev.groovy"
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                            post {
+                                always {
+                                    container('milvus-testframework') {
+                                        script {
+                                            load "${env.WORKSPACE}/ci/jenkinsfile/cleanup_dev.groovy"
+                                        }
+                                    }
+                                }
+                                success {
+                                    script {
+                                        echo "Milvus Single Node CI/CD success !"
+                                    }
+                                }
+                                aborted {
+                                    script {
+                                        echo "Milvus Single Node CI/CD aborted !"
+                                    }
+                                }
+                                failure {
+                                    script {
+                                        echo "Milvus Single Node CI/CD failure !"
+                                    }
+                                }
+                            }
+                        }
+
+//                         stage("Cluster") {
+//                             agent {
+//                                 kubernetes {
+//                                     label 'dev-test'
+//                                     defaultContainer 'jnlp'
+//                                     yaml """
+// apiVersion: v1
+// kind: Pod
+// metadata:
+//   labels:
+//     app: milvus
+//     componet: test
+// spec:
+//   containers:
+//   - name: milvus-testframework
+//     image: registry.zilliz.com/milvus/milvus-test:v0.2
+//     command:
+//     - cat
+//     tty: true
+//     volumeMounts:
+//     - name: kubeconf
+//       mountPath: /root/.kube/
+//       readOnly: true
+//   volumes:
+//   - name: kubeconf
+//     secret:
+//       secretName: test-cluster-config
+// """
+//                                 }
+//                             }
+//                             stages {
+//                                 stage("Deploy to Dev") {
+//                                     steps {
+//                                         gitlabCommitStatus(name: 'Deloy to Dev') {
+//                                             container('milvus-testframework') {
+//                                                 script {
+//                                                     load "${env.WORKSPACE}/ci/jenkinsfile/cluster_deploy2dev.groovy"
+//                                                 }
+//                                             }
+//                                         }
+//                                     }
+//                                 }
+//                                 stage("Dev Test") {
+//                                     steps {
+//                                         gitlabCommitStatus(name: 'Deloy Test') {
+//                                             container('milvus-testframework') {
+//                                                 script {
+//                                                     load "${env.WORKSPACE}/ci/jenkinsfile/cluster_dev_test.groovy"
+//                                                     load "${env.WORKSPACE}/ci/jenkinsfile/upload_dev_cluster_test_out.groovy"
+//                                                 }
+//                                             }
+//                                         }
+//                                     }
+//                                 }
+//                                 stage ("Cleanup Dev") {
+//                                     steps {
+//                                         gitlabCommitStatus(name: 'Cleanup Dev') {
+//                                             container('milvus-testframework') {
+//                                                 script {
+//                                                     load "${env.WORKSPACE}/ci/jenkinsfile/cluster_cleanup_dev.groovy"
+//                                                 }
+//                                             }
+//                                         }
+//                                     }
+//                                 }
+//                             }
+//                             post {
+//                                 always {
+//                                     container('milvus-testframework') {
+//                                         script {
+//                                             load "${env.WORKSPACE}/ci/jenkinsfile/cluster_cleanup_dev.groovy"
+//                                         }
+//                                     }
+//                                 }
+//                                 success {
+//                                     script {
+//                                         echo "Milvus Cluster CI/CD success !"
+//                                     }
+//                                 }
+//                                 aborted {
+//                                     script {
+//                                         echo "Milvus Cluster CI/CD aborted !"
+//                                     }
+//                                 }
+//                                 failure {
+//                                     script {
+//                                         echo "Milvus Cluster CI/CD failure !"
+//                                     }
+//                                 }
+//                             }
+//                        }
+                    }
+                }
+            }
+        }
+    }
+
+    post {
+        always {
+            script {
+                if (env.gitlabAfter != null) {
+                    if (!currentBuild.resultIsBetterOrEqualTo('SUCCESS')) {
+                        // Send an email only if the build status has changed from green/unstable to red
+                        emailext subject: '$DEFAULT_SUBJECT',
+                        body: '$DEFAULT_CONTENT',
+                        recipientProviders: [
+                            [$class: 'DevelopersRecipientProvider'],
+                            [$class: 'RequesterRecipientProvider']
+                        ],
+                        replyTo: '$DEFAULT_REPLYTO',
+                        to: '$DEFAULT_RECIPIENTS'
+                    }
+                }
+            }
+        }
+
+        success {
+            script {
+                updateGitlabCommitStatus name: 'CI/CD', state: 'success'
+                echo "Milvus CI/CD success !"
+            }
+        }
+
+        aborted {
+            script {
+                updateGitlabCommitStatus name: 'CI/CD', state: 'canceled'
+                echo "Milvus CI/CD aborted !"
+            }
+        }
+
+        failure {
+            script {
+                updateGitlabCommitStatus name: 'CI/CD', state: 'failed'
+                echo "Milvus CI/CD failure !"
+            }
+        }
+    }
+}
+
diff --git a/ci/main_jenkinsfile_no_ut b/ci/main_jenkinsfile_no_ut
new file mode 100644
index 0000000000..e8d7dae75a
--- /dev/null
+++ b/ci/main_jenkinsfile_no_ut
@@ -0,0 +1,396 @@
+pipeline {
+    agent none
+
+    options {
+        timestamps()
+    }
+
+    environment {
+        PROJECT_NAME = "milvus"
+        LOWER_BUILD_TYPE = BUILD_TYPE.toLowerCase()
+        SEMVER = "${env.gitlabSourceBranch == null ? params.ENGINE_BRANCH.substring(params.ENGINE_BRANCH.lastIndexOf('/') + 1) : env.gitlabSourceBranch}"
+        GITLAB_AFTER_COMMIT = "${env.gitlabAfter == null ? null : env.gitlabAfter}"
+        SUFFIX_VERSION_NAME = "${env.gitlabAfter == null ? null : env.gitlabAfter.substring(0, 6)}"
+        DOCKER_VERSION_STR = "${env.gitlabAfter == null ? "${SEMVER}-${LOWER_BUILD_TYPE}" : "${SEMVER}-${LOWER_BUILD_TYPE}-${SUFFIX_VERSION_NAME}"}"
+    }
+
+    stages {
+        stage("Ubuntu 16.04") {
+            environment {
+                PACKAGE_VERSION = VersionNumber([
+                    versionNumberString : '${SEMVER}-${LOWER_BUILD_TYPE}-${BUILD_DATE_FORMATTED, "yyyyMMdd"}'
+                ]);
+
+                DOCKER_VERSION = VersionNumber([
+                    versionNumberString : '${DOCKER_VERSION_STR}'
+                ]);
+            }
+
+            stages {
+                stage("Run Build") {
+                    agent {
+                        kubernetes {
+                            cloud 'build-kubernetes'
+                            label 'build'
+                            defaultContainer 'jnlp'
+                            yaml """
+apiVersion: v1
+kind: Pod
+metadata:
+  name: milvus-build-env
+  labels:
+    app: milvus
+    componet: build-env
+spec:
+  containers:
+  - name: milvus-build-env
+    image: registry.zilliz.com/milvus/milvus-build-env:v0.13
+    env:
+    - name: POD_IP
+      valueFrom:
+        fieldRef:
+          fieldPath: status.podIP
+    command:
+    - cat
+    tty: true
+    resources:
+      limits:
+        memory: "28Gi"
+        cpu: "10.0"
+        nvidia.com/gpu: 1
+      requests:
+        memory: "14Gi"
+        cpu: "5.0"
+  - name: milvus-mysql
+    image: mysql:5.6
+    env:
+    - name: MYSQL_ROOT_PASSWORD
+      value: 123456
+    ports:
+    - containerPort: 3306
+      name: mysql
+"""
+                        }
+                    }
+                    stages {
+                        stage('Build') {
+                            steps {
+                                gitlabCommitStatus(name: 'Build') {
+                                    script {
+                                        load "${env.WORKSPACE}/ci/jenkinsfile/milvus_build_no_ut.groovy"
+                                        load "${env.WORKSPACE}/ci/jenkinsfile/packaged_milvus_no_ut.groovy"
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    post {
+                        aborted {
+                            script {
+                                updateGitlabCommitStatus name: 'Build', state: 'canceled'
+                                echo "Milvus Build aborted !"
+                            }
+                        }
+
+                        failure {
+                            script {
+                                updateGitlabCommitStatus name: 'Build', state: 'failed'
+                                echo "Milvus Build failure !"
+                            }
+                        }
+                    }
+                }
+
+                stage("Publish docker and helm") {
+                    agent {
+                        kubernetes {
+                            label 'publish'
+                            defaultContainer 'jnlp'
+                            yaml """
+apiVersion: v1
+kind: Pod
+metadata:
+  labels:
+    app: publish
+    componet: docker
+spec:
+  containers:
+  - name: publish-docker
+    image: registry.zilliz.com/library/zilliz_docker:v1.0.0
+    securityContext:
+      privileged: true
+    command:
+    - cat
+    tty: true
+    volumeMounts:
+    - name: docker-sock
+      mountPath: /var/run/docker.sock
+  volumes:
+  - name: docker-sock
+    hostPath:
+      path: /var/run/docker.sock
+"""
+                        }
+                    }
+                    stages {
+                        stage('Publish Docker') {
+                            steps {
+                                gitlabCommitStatus(name: 'Publish Docker') {
+                                    script {
+                                        load "${env.WORKSPACE}/ci/jenkinsfile/publish_docker.groovy"
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    post {
+                        aborted {
+                            script {
+                                updateGitlabCommitStatus name: 'Publish Docker', state: 'canceled'
+                                echo "Milvus Publish Docker aborted !"
+                            }
+                        }
+
+                        failure {
+                            script {
+                                updateGitlabCommitStatus name: 'Publish Docker', state: 'failed'
+                                echo "Milvus Publish Docker failure !"
+                            }
+                        }
+                    }
+                }
+
+                stage("Deploy to Development") {
+                    parallel {
+                        stage("Single Node") {
+                            agent {
+                                kubernetes {
+                                    label 'dev-test'
+                                    defaultContainer 'jnlp'
+                                    yaml """
+apiVersion: v1
+kind: Pod
+metadata:
+  labels:
+    app: milvus
+    componet: test
+spec:
+  containers:
+  - name: milvus-testframework
+    image: registry.zilliz.com/milvus/milvus-test:v0.2
+    command:
+    - cat
+    tty: true
+    volumeMounts:
+    - name: kubeconf
+      mountPath: /root/.kube/
+      readOnly: true
+  volumes:
+  - name: kubeconf
+    secret:
+      secretName: test-cluster-config
+"""
+                                }
+                            }
+
+                            stages {
+                                stage("Deploy to Dev") {
+                                    steps {
+                                        gitlabCommitStatus(name: 'Deloy to Dev') {
+                                            container('milvus-testframework') {
+                                                script {
+                                                    load "${env.WORKSPACE}/ci/jenkinsfile/deploy2dev.groovy"
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                                stage("Dev Test") {
+                                    steps {
+                                        gitlabCommitStatus(name: 'Deloy Test') {
+                                            container('milvus-testframework') {
+                                                script {
+                                                    load "${env.WORKSPACE}/ci/jenkinsfile/dev_test.groovy"
+                                                    load "${env.WORKSPACE}/ci/jenkinsfile/upload_dev_test_out.groovy"
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                                stage ("Cleanup Dev") {
+                                    steps {
+                                        gitlabCommitStatus(name: 'Cleanup Dev') {
+                                            container('milvus-testframework') {
+                                                script {
+                                                    load "${env.WORKSPACE}/ci/jenkinsfile/cleanup_dev.groovy"
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                            post {
+                                always {
+                                    container('milvus-testframework') {
+                                        script {
+                                            load "${env.WORKSPACE}/ci/jenkinsfile/cleanup_dev.groovy"
+                                        }
+                                    }
+                                }
+                                success {
+                                    script {
+                                        echo "Milvus Single Node CI/CD success !"
+                                    }
+                                }
+                                aborted {
+                                    script {
+                                        echo "Milvus Single Node CI/CD aborted !"
+                                    }
+                                }
+                                failure {
+                                    script {
+                                        echo "Milvus Single Node CI/CD failure !"
+                                    }
+                                }
+                            }
+                        }
+
+//                         stage("Cluster") {
+//                             agent {
+//                                 kubernetes {
+//                                     label 'dev-test'
+//                                     defaultContainer 'jnlp'
+//                                     yaml """
+// apiVersion: v1
+// kind: Pod
+// metadata:
+//   labels:
+//     app: milvus
+//     componet: test
+// spec:
+//   containers:
+//   - name: milvus-testframework
+//     image: registry.zilliz.com/milvus/milvus-test:v0.2
+//     command:
+//     - cat
+//     tty: true
+//     volumeMounts:
+//     - name: kubeconf
+//       mountPath: /root/.kube/
+//       readOnly: true
+//   volumes:
+//   - name: kubeconf
+//     secret:
+//       secretName: test-cluster-config
+// """
+//                                 }
+//                             }
+//                             stages {
+//                                 stage("Deploy to Dev") {
+//                                     steps {
+//                                         gitlabCommitStatus(name: 'Deloy to Dev') {
+//                                             container('milvus-testframework') {
+//                                                 script {
+//                                                     load "${env.WORKSPACE}/ci/jenkinsfile/cluster_deploy2dev.groovy"
+//                                                 }
+//                                             }
+//                                         }
+//                                     }
+//                                 }
+//                                 stage("Dev Test") {
+//                                     steps {
+//                                         gitlabCommitStatus(name: 'Deloy Test') {
+//                                             container('milvus-testframework') {
+//                                                 script {
+//                                                     load "${env.WORKSPACE}/ci/jenkinsfile/cluster_dev_test.groovy"
+//                                                     load "${env.WORKSPACE}/ci/jenkinsfile/upload_dev_cluster_test_out.groovy"
+//                                                 }
+//                                             }
+//                                         }
+//                                     }
+//                                 }
+//                                 stage ("Cleanup Dev") {
+//                                     steps {
+//                                         gitlabCommitStatus(name: 'Cleanup Dev') {
+//                                             container('milvus-testframework') {
+//                                                 script {
+//                                                     load "${env.WORKSPACE}/ci/jenkinsfile/cluster_cleanup_dev.groovy"
+//                                                 }
+//                                             }
+//                                         }
+//                                     }
+//                                 }
+//                             }
+//                             post {
+//                                 always {
+//                                     container('milvus-testframework') {
+//                                         script {
+//                                             load "${env.WORKSPACE}/ci/jenkinsfile/cluster_cleanup_dev.groovy"
+//                                         }
+//                                     }
+//                                 }
+//                                 success {
+//                                     script {
+//                                         echo "Milvus Cluster CI/CD success !"
+//                                     }
+//                                 }
+//                                 aborted {
+//                                     script {
+//                                         echo "Milvus Cluster CI/CD aborted !"
+//                                     }
+//                                 }
+//                                 failure {
+//                                     script {
+//                                         echo "Milvus Cluster CI/CD failure !"
+//                                     }
+//                                 }
+//                             }
+//                         }
+                    }
+                }
+            }
+        }
+    }
+
+    post {
+        always {
+            script {
+                if (env.gitlabAfter != null) {
+                    if (!currentBuild.resultIsBetterOrEqualTo('SUCCESS')) {
+                        // Send an email only if the build status has changed from green/unstable to red
+                        emailext subject: '$DEFAULT_SUBJECT',
+                        body: '$DEFAULT_CONTENT',
+                        recipientProviders: [
+                            [$class: 'DevelopersRecipientProvider'],
+                            [$class: 'RequesterRecipientProvider']
+                        ],
+                        replyTo: '$DEFAULT_REPLYTO',
+                        to: '$DEFAULT_RECIPIENTS'
+                    }
+                }
+            }
+        }
+
+        success {
+            script {
+                updateGitlabCommitStatus name: 'CI/CD', state: 'success'
+                echo "Milvus CI/CD success !"
+            }
+        }
+
+        aborted {
+            script {
+                updateGitlabCommitStatus name: 'CI/CD', state: 'canceled'
+                echo "Milvus CI/CD aborted !"
+            }
+        }
+
+        failure {
+            script {
+                updateGitlabCommitStatus name: 'CI/CD', state: 'failed'
+                echo "Milvus CI/CD failure !"
+            }
+        }
+    }
+}
+
diff --git a/ci/nightly_main_jenkinsfile b/ci/nightly_main_jenkinsfile
new file mode 100644
index 0000000000..add9e00fb4
--- /dev/null
+++ b/ci/nightly_main_jenkinsfile
@@ -0,0 +1,478 @@
+pipeline {
+    agent none
+
+    options {
+        timestamps()
+    }
+
+    environment {
+        PROJECT_NAME = "milvus"
+        LOWER_BUILD_TYPE = BUILD_TYPE.toLowerCase()
+        SEMVER = "${env.gitlabSourceBranch == null ? params.ENGINE_BRANCH.substring(params.ENGINE_BRANCH.lastIndexOf('/') + 1) : env.gitlabSourceBranch}"
+        GITLAB_AFTER_COMMIT = "${env.gitlabAfter == null ? null : env.gitlabAfter}"
+        SUFFIX_VERSION_NAME = "${env.gitlabAfter == null ? null : env.gitlabAfter.substring(0, 6)}"
+        DOCKER_VERSION_STR = "${env.gitlabAfter == null ? '${SEMVER}-${LOWER_BUILD_TYPE}-${BUILD_DATE_FORMATTED, \"yyyyMMdd\"}' : '${SEMVER}-${LOWER_BUILD_TYPE}-${SUFFIX_VERSION_NAME}'}"
+    }
+
+    stages {
+        stage("Ubuntu 16.04") {
+            environment {
+                PACKAGE_VERSION = VersionNumber([
+                    versionNumberString : '${SEMVER}-${LOWER_BUILD_TYPE}-${BUILD_DATE_FORMATTED, "yyyyMMdd"}'
+                ]);
+
+                DOCKER_VERSION = VersionNumber([
+                    versionNumberString : '${DOCKER_VERSION_STR}'
+                ]);
+            }
+
+            stages {
+                stage("Run Build") {
+                    agent {
+                        kubernetes {
+                            cloud 'build-kubernetes'
+                            label 'build'
+                            defaultContainer 'jnlp'
+                            yaml """
+apiVersion: v1
+kind: Pod
+metadata:
+  name: milvus-build-env
+  labels:
+    app: milvus
+    componet: build-env
+spec:
+  containers:
+  - name: milvus-build-env
+    image: registry.zilliz.com/milvus/milvus-build-env:v0.13
+    command:
+    - cat
+    tty: true
+    resources:
+      limits:
+        memory: "28Gi"
+        cpu: "10.0"
+        nvidia.com/gpu: 1
+      requests:
+        memory: "14Gi"
+        cpu: "5.0"
+"""
+                        }
+                    }
+                    stages {
+                        stage('Build') {
+                            steps {
+                                gitlabCommitStatus(name: 'Build') {
+                                    script {
+                                        load "${env.WORKSPACE}/ci/jenkinsfile/milvus_build.groovy"
+                                        load "${env.WORKSPACE}/ci/jenkinsfile/packaged_milvus.groovy"
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    post {
+                        aborted {
+                            script {
+                                updateGitlabCommitStatus name: 'Build', state: 'canceled'
+                                echo "Milvus Build aborted !"
+                            }
+                        }
+
+                        failure {
+                            script {
+                                updateGitlabCommitStatus name: 'Build', state: 'failed'
+                                echo "Milvus Build failure !"
+                            }
+                        }
+                    }
+                }
+
+                stage("Publish docker and helm") {
+                    agent {
+                        kubernetes {
+                            label 'publish'
+                            defaultContainer 'jnlp'
+                            yaml """
+apiVersion: v1
+kind: Pod
+metadata:
+  labels:
+    app: publish
+    componet: docker
+spec:
+  containers:
+  - name: publish-docker
+    image: registry.zilliz.com/library/zilliz_docker:v1.0.0
+    securityContext:
+      privileged: true
+    command:
+    - cat
+    tty: true
+    volumeMounts:
+    - name: docker-sock
+      mountPath: /var/run/docker.sock
+  volumes:
+  - name: docker-sock
+    hostPath:
+      path: /var/run/docker.sock
+"""
+                        }
+                    }
+                    stages {
+                        stage('Publish Docker') {
+                            steps {
+                                gitlabCommitStatus(name: 'Publish Docker') {
+                                    script {
+                                        load "${env.WORKSPACE}/ci/jenkinsfile/nightly_publish_docker.groovy"
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    post {
+                        aborted {
+                            script {
+                                updateGitlabCommitStatus name: 'Publish Docker', state: 'canceled'
+                                echo "Milvus Publish Docker aborted !"
+                            }
+                        }
+
+                        failure {
+                            script {
+                                updateGitlabCommitStatus name: 'Publish Docker', state: 'failed'
+                                echo "Milvus Publish Docker failure !"
+                            }
+                        }
+                    }
+                }
+
+                stage("Deploy to Development") {
+                    parallel {
+                        stage("Single Node") {
+                            agent {
+                                kubernetes {
+                                    label 'dev-test'
+                                    defaultContainer 'jnlp'
+                                    yaml """
+apiVersion: v1
+kind: Pod
+metadata:
+  labels:
+    app: milvus
+    componet: test
+spec:
+  containers:
+  - name: milvus-testframework
+    image: registry.zilliz.com/milvus/milvus-test:v0.2
+    command:
+    - cat
+    tty: true
+    volumeMounts:
+    - name: kubeconf
+      mountPath: /root/.kube/
+      readOnly: true
+  volumes:
+  - name: kubeconf
+    secret:
+      secretName: test-cluster-config
+"""
+                                }
+                            }
+
+                            stages {
+                                stage("Deploy to Dev") {
+                                    steps {
+                                        gitlabCommitStatus(name: 'Deloy to Dev') {
+                                            container('milvus-testframework') {
+                                                script {
+                                                    load "${env.WORKSPACE}/ci/jenkinsfile/deploy2dev.groovy"
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                                stage("Dev Test") {
+                                    steps {
+                                        gitlabCommitStatus(name: 'Deloy Test') {
+                                            container('milvus-testframework') {
+                                                script {
+                                                    load "${env.WORKSPACE}/ci/jenkinsfile/dev_test_all.groovy"
+                                                    load "${env.WORKSPACE}/ci/jenkinsfile/upload_dev_test_out.groovy"
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                                stage ("Cleanup Dev") {
+                                    steps {
+                                        gitlabCommitStatus(name: 'Cleanup Dev') {
+                                            container('milvus-testframework') {
+                                                script {
+                                                    load "${env.WORKSPACE}/ci/jenkinsfile/cleanup_dev.groovy"
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                            post {
+                                always {
+                                    container('milvus-testframework') {
+                                        script {
+                                            load "${env.WORKSPACE}/ci/jenkinsfile/cleanup_dev.groovy"
+                                        }
+                                    }
+                                }
+                                success {
+                                    script {
+                                        echo "Milvus Deploy to Dev Single Node CI/CD success !"
+                                    }
+                                }
+                                aborted {
+                                    script {
+                                        echo "Milvus Deploy to Dev Single Node CI/CD aborted !"
+                                    }
+                                }
+                                failure {
+                                    script {
+                                        echo "Milvus Deploy to Dev Single Node CI/CD failure !"
+                                    }
+                                }
+                            }
+                        }
+
+//                         stage("Cluster") {
+//                             agent {
+//                                 kubernetes {
+//                                     label 'dev-test'
+//                                     defaultContainer 'jnlp'
+//                                     yaml """
+// apiVersion: v1
+// kind: Pod
+// metadata:
+//   labels:
+//     app: milvus
+//     componet: test
+// spec:
+//   containers:
+//   - name: milvus-testframework
+//     image: registry.zilliz.com/milvus/milvus-test:v0.2
+//     command:
+//     - cat
+//     tty: true
+//     volumeMounts:
+//     - name: kubeconf
+//       mountPath: /root/.kube/
+//       readOnly: true
+//   volumes:
+//   - name: kubeconf
+//     secret:
+//       secretName: test-cluster-config
+// """
+//                                 }
+//                             }
+//                             stages {
+//                                 stage("Deploy to Dev") {
+//                                     steps {
+//                                         gitlabCommitStatus(name: 'Deloy to Dev') {
+//                                             container('milvus-testframework') {
+//                                                 script {
+//                                                     load "${env.WORKSPACE}/ci/jenkinsfile/cluster_deploy2dev.groovy"
+//                                                 }
+//                                             }
+//                                         }
+//                                     }
+//                                 }
+//                                 stage("Dev Test") {
+//                                     steps {
+//                                         gitlabCommitStatus(name: 'Deloy Test') {
+//                                             container('milvus-testframework') {
+//                                                 script {
+//                                                     load "${env.WORKSPACE}/ci/jenkinsfile/cluster_dev_test.groovy"
+//                                                     load "${env.WORKSPACE}/ci/jenkinsfile/upload_dev_cluster_test_out.groovy"
+//                                                 }
+//                                             }
+//                                         }
+//                                     }
+//                                 }
+//                                 stage ("Cleanup Dev") {
+//                                     steps {
+//                                         gitlabCommitStatus(name: 'Cleanup Dev') {
+//                                             container('milvus-testframework') {
+//                                                 script {
+//                                                     load "${env.WORKSPACE}/ci/jenkinsfile/cluster_cleanup_dev.groovy"
+//                                                 }
+//                                             }
+//                                         }
+//                                     }
+//                                 }
+//                             }
+//                             post {
+//                                 always {
+//                                     container('milvus-testframework') {
+//                                         script {
+//                                             load "${env.WORKSPACE}/ci/jenkinsfile/cluster_cleanup_dev.groovy"
+//                                         }
+//                                     }
+//                                 }
+//                                 success {
+//                                     script {
+//                                         echo "Milvus Deploy to Dev Cluster CI/CD success !"
+//                                     }
+//                                 }
+//                                 aborted {
+//                                     script {
+//                                         echo "Milvus Deploy to Dev Cluster CI/CD aborted !"
+//                                     }
+//                                 }
+//                                 failure {
+//                                     script {
+//                                         echo "Milvus Deploy to Dev Cluster CI/CD failure !"
+//                                     }
+//                                 }
+//                             }
+//                         }
+                    }
+                }
+
+                stage("Deploy to Staging") {
+                    parallel {
+                        stage("Single Node") {
+                            agent {
+                                kubernetes {
+                                    label 'dev-test'
+                                    defaultContainer 'jnlp'
+                                    yaml """
+apiVersion: v1
+kind: Pod
+metadata:
+  labels:
+    app: milvus
+    componet: test
+spec:
+  containers:
+  - name: milvus-testframework
+    image: registry.zilliz.com/milvus/milvus-test:v0.2
+    command:
+    - cat
+    tty: true
+    volumeMounts:
+    - name: kubeconf
+      mountPath: /root/.kube/
+      readOnly: true
+  volumes:
+  - name: kubeconf
+    secret:
+      secretName: aks-gpu-cluster-config
+"""
+                                }
+                            }
+
+                            stages {
+                                stage("Deploy to Staging") {
+                                    steps {
+                                        gitlabCommitStatus(name: 'Deloy to Staging') {
+                                            container('milvus-testframework') {
+                                                script {
+                                                    load "${env.WORKSPACE}/ci/jenkinsfile/deploy2staging.groovy"
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                                stage("Staging Test") {
+                                    steps {
+                                        gitlabCommitStatus(name: 'Staging Test') {
+                                            container('milvus-testframework') {
+                                                script {
+                                                    load "${env.WORKSPACE}/ci/jenkinsfile/staging_test.groovy"
+                                                    load "${env.WORKSPACE}/ci/jenkinsfile/upload_staging_test_out.groovy"
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                                stage ("Cleanup Staging") {
+                                    steps {
+                                        gitlabCommitStatus(name: 'Cleanup Staging') {
+                                            container('milvus-testframework') {
+                                                script {
+                                                    load "${env.WORKSPACE}/ci/jenkinsfile/cleanup_staging.groovy"
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                            post {
+                                always {
+                                    container('milvus-testframework') {
+                                        script {
+                                            load "${env.WORKSPACE}/ci/jenkinsfile/cleanup_staging.groovy"
+                                        }
+                                    }
+                                }
+                                success {
+                                    script {
+                                        echo "Milvus Deploy to Staging Single Node CI/CD success !"
+                                    }
+                                }
+                                aborted {
+                                    script {
+                                        echo "Milvus Deploy to Staging Single Node CI/CD aborted !"
+                                    }
+                                }
+                                failure {
+                                    script {
+                                        echo "Milvus Deploy to Staging Single Node CI/CD failure !"
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    post {
+        always {
+            script {
+                if (!currentBuild.resultIsBetterOrEqualTo('SUCCESS')) {
+                    // Send an email only if the build status has changed from green/unstable to red
+                    emailext subject: '$DEFAULT_SUBJECT',
+                    body: '$DEFAULT_CONTENT',
+                    recipientProviders: [
+                        [$class: 'DevelopersRecipientProvider'],
+                        [$class: 'RequesterRecipientProvider']
+                    ],
+                    replyTo: '$DEFAULT_REPLYTO',
+                    to: '$DEFAULT_RECIPIENTS'
+                }
+            }
+        }
+
+        success {
+            script {
+                updateGitlabCommitStatus name: 'CI/CD', state: 'success'
+                echo "Milvus CI/CD success !"
+            }
+        }
+
+        aborted {
+            script {
+                updateGitlabCommitStatus name: 'CI/CD', state: 'canceled'
+                echo "Milvus CI/CD aborted !"
+            }
+        }
+
+        failure {
+            script {
+                updateGitlabCommitStatus name: 'CI/CD', state: 'failed'
+                echo "Milvus CI/CD failure !"
+            }
+        }
+    }
+}
+
diff --git a/ci/pod_containers/milvus-engine-build.yaml b/ci/pod_containers/milvus-engine-build.yaml
new file mode 100644
index 0000000000..cd5352ffef
--- /dev/null
+++ b/ci/pod_containers/milvus-engine-build.yaml
@@ -0,0 +1,13 @@
+apiVersion: v1
+kind: Pod
+metadata:
+  labels:
+    app: milvus
+    componet: build-env
+spec:
+  containers:
+  - name: milvus-build-env
+    image: registry.zilliz.com/milvus/milvus-build-env:v0.9
+    command:
+    - cat
+    tty: true
diff --git a/ci/pod_containers/milvus-testframework.yaml b/ci/pod_containers/milvus-testframework.yaml
new file mode 100644
index 0000000000..7a98fbca8e
--- /dev/null
+++ b/ci/pod_containers/milvus-testframework.yaml
@@ -0,0 +1,13 @@
+apiVersion: v1
+kind: Pod
+metadata:
+  labels:
+    app: milvus
+    componet: testframework
+spec:
+  containers:
+  - name: milvus-testframework
+    image: registry.zilliz.com/milvus/milvus-test:v0.1
+    command:
+    - cat
+    tty: true
diff --git a/ci/pod_containers/publish-docker.yaml b/ci/pod_containers/publish-docker.yaml
new file mode 100644
index 0000000000..268afb1331
--- /dev/null
+++ b/ci/pod_containers/publish-docker.yaml
@@ -0,0 +1,22 @@
+apiVersion: v1
+kind: Pod
+metadata:
+  labels:
+    app: publish
+    componet: docker
+spec:
+  containers:
+  - name: publish-docker
+    image: registry.zilliz.com/library/zilliz_docker:v1.0.0
+    securityContext:
+      privileged: true
+    command:
+    - cat
+    tty: true
+    volumeMounts:
+    - name: docker-sock
+      mountPath: /var/run/docker.sock
+  volumes:
+  - name: docker-sock
+    hostPath:
+      path: /var/run/docker.sock
diff --git a/codecov.yaml b/codecov.yaml
new file mode 100644
index 0000000000..debe315ac0
--- /dev/null
+++ b/codecov.yaml
@@ -0,0 +1,14 @@
+#Configuration File for CodeCov
+coverage:
+  precision: 2
+  round: down
+  range: "70...100"
+
+  status:
+    project: on
+    patch: yes
+    changes: no
+
+comment:
+  layout: "header, diff, changes, tree"
+  behavior: default
diff --git a/core/.gitignore b/core/.gitignore
new file mode 100644
index 0000000000..9690a98051
--- /dev/null
+++ b/core/.gitignore
@@ -0,0 +1,10 @@
+milvus/
+conf/server_config.yaml
+conf/log_config.conf
+version.h
+lcov_out/
+base.info
+output.info
+output_new.info
+server.info
+*.pyc
diff --git a/core/CMakeLists.txt b/core/CMakeLists.txt
new file mode 100644
index 0000000000..5915006ca1
--- /dev/null
+++ b/core/CMakeLists.txt
@@ -0,0 +1,262 @@
+#-------------------------------------------------------------------------------
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you 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.
+#-------------------------------------------------------------------------------
+
+
+cmake_minimum_required(VERSION 3.14)
+message(STATUS "Building using CMake version: ${CMAKE_VERSION}")
+
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
+
+MACRO (GET_CURRENT_TIME CURRENT_TIME)
+    execute_process(COMMAND "date" +"%Y-%m-%d %H:%M.%S" OUTPUT_VARIABLE ${CURRENT_TIME})
+ENDMACRO (GET_CURRENT_TIME)
+
+GET_CURRENT_TIME(BUILD_TIME)
+string(REGEX REPLACE "\n" "" BUILD_TIME ${BUILD_TIME})
+message(STATUS "Build time = ${BUILD_TIME}")
+
+MACRO (GET_GIT_BRANCH_NAME GIT_BRANCH_NAME)
+    execute_process(COMMAND "git" symbolic-ref --short HEAD OUTPUT_VARIABLE ${GIT_BRANCH_NAME})
+ENDMACRO (GET_GIT_BRANCH_NAME)
+
+GET_GIT_BRANCH_NAME(GIT_BRANCH_NAME)
+if(NOT GIT_BRANCH_NAME STREQUAL "")
+    string(REGEX REPLACE "\n" "" GIT_BRANCH_NAME ${GIT_BRANCH_NAME})
+endif()
+
+set(MILVUS_VERSION "${GIT_BRANCH_NAME}")
+string(REGEX MATCH "[0-9]+\\.[0-9]+\\.[0-9]" MILVUS_VERSION "${MILVUS_VERSION}")
+
+find_package(ClangTools)
+set(BUILD_SUPPORT_DIR "${CMAKE_SOURCE_DIR}/build-support")
+
+if(CMAKE_BUILD_TYPE STREQUAL "Release")
+    set(BUILD_TYPE "Release")
+else()
+    set(BUILD_TYPE "Debug")
+endif()
+message(STATUS "Build type = ${BUILD_TYPE}")
+
+project(milvus VERSION "${MILVUS_VERSION}")
+project(milvus_engine LANGUAGES CUDA CXX)
+
+unset(CMAKE_EXPORT_COMPILE_COMMANDS CACHE)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+set(MILVUS_VERSION_MAJOR "${milvus_VERSION_MAJOR}")
+set(MILVUS_VERSION_MINOR "${milvus_VERSION_MINOR}")
+set(MILVUS_VERSION_PATCH "${milvus_VERSION_PATCH}")
+
+if(MILVUS_VERSION_MAJOR STREQUAL ""
+        OR MILVUS_VERSION_MINOR STREQUAL ""
+        OR MILVUS_VERSION_PATCH STREQUAL "")
+    message(WARNING "Failed to determine Milvus version from git branch name")
+    set(MILVUS_VERSION "0.5.0")
+endif()
+
+message(STATUS "Build version = ${MILVUS_VERSION}")
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/version.h.macro ${CMAKE_CURRENT_SOURCE_DIR}/version.h)
+
+message(STATUS "Milvus version: "
+        "${MILVUS_VERSION_MAJOR}.${MILVUS_VERSION_MINOR}.${MILVUS_VERSION_PATCH} "
+        "(full: '${MILVUS_VERSION}')")
+
+set(CMAKE_CXX_STANDARD 14)
+set(CMAKE_CXX_STANDARD_REQUIRED on)
+
+if(CMAKE_SYSTEM_PROCESSOR MATCHES "(x86)|(X86)|(amd64)|(AMD64)")
+    message(STATUS "Building milvus_engine on x86 architecture")
+    set(MILVUS_BUILD_ARCH x86_64)
+elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "(ppc)")
+    message(STATUS "Building milvus_engine on ppc architecture")
+    set(MILVUS_BUILD_ARCH ppc64le)
+else()
+    message(WARNING "Unknown processor type")
+    message(WARNING "CMAKE_SYSTEM_PROCESSOR=${CMAKE_SYSTEM_PROCESSOR}")
+    set(MILVUS_BUILD_ARCH unknown)
+endif()
+
+find_package (Python COMPONENTS Interpreter Development)
+
+find_package(CUDA)
+set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -Xcompiler -fPIC -std=c++11 -D_FORCE_INLINES --expt-extended-lambda")
+
+if(CMAKE_BUILD_TYPE STREQUAL "Release")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3 -fPIC -DELPP_THREAD_SAFE -fopenmp")
+    set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -O3")
+else()
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O0 -g -fPIC -DELPP_THREAD_SAFE -fopenmp")
+    set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -O0 -g")
+endif()
+
+# Ensure that a default make is set
+if("${MAKE}" STREQUAL "")
+    if(NOT MSVC)
+        find_program(MAKE make)
+    endif()
+endif()
+
+find_path(MYSQL_INCLUDE_DIR
+            NAMES "mysql.h"
+            PATH_SUFFIXES "mysql")
+if (${MYSQL_INCLUDE_DIR} STREQUAL "MYSQL_INCLUDE_DIR-NOTFOUND")
+    message(FATAL_ERROR "Could not found MySQL include directory")
+else()
+    include_directories(${MYSQL_INCLUDE_DIR})
+endif()
+
+set(MILVUS_SOURCE_DIR ${PROJECT_SOURCE_DIR})
+set(MILVUS_BINARY_DIR ${PROJECT_BINARY_DIR})
+set(MILVUS_ENGINE_SRC ${PROJECT_SOURCE_DIR}/src)
+
+include(ExternalProject)
+include(DefineOptions)
+include(BuildUtils)
+include(ThirdPartyPackages)
+
+config_summary()
+
+if (CUSTOMIZATION)
+    add_definitions(-DCUSTOMIZATION)
+endif (CUSTOMIZATION)
+
+add_subdirectory(src)
+
+if (BUILD_UNIT_TEST STREQUAL "ON")
+    if (BUILD_COVERAGE STREQUAL "ON")
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fprofile-arcs -ftest-coverage")
+    endif()
+    add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/unittest)
+endif()
+
+add_custom_target(Clean-All COMMAND ${CMAKE_BUILD_TOOL} clean)
+
+if("${MILVUS_DB_PATH}" STREQUAL "")
+    set(MILVUS_DB_PATH "/tmp/milvus")
+endif()
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/conf/server_config.template ${CMAKE_CURRENT_SOURCE_DIR}/conf/server_config.yaml)
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/conf/log_config.template ${CMAKE_CURRENT_SOURCE_DIR}/conf/log_config.conf)
+
+install(DIRECTORY scripts/
+        DESTINATION scripts
+        FILE_PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ
+        GROUP_EXECUTE GROUP_READ
+        WORLD_EXECUTE WORLD_READ
+        FILES_MATCHING PATTERN "*.sh")
+install(FILES
+        conf/server_config.yaml
+        conf/log_config.conf
+        DESTINATION
+        conf)
+
+
+#
+# "make lint" target
+#
+if(NOT MILVUS_VERBOSE_LINT)
+  set(MILVUS_LINT_QUIET "--quiet")
+endif()
+
+if(NOT LINT_EXCLUSIONS_FILE)
+  # source files matching a glob from a line in this file
+  # will be excluded from linting (cpplint, clang-tidy, clang-format)
+  set(LINT_EXCLUSIONS_FILE ${BUILD_SUPPORT_DIR}/lint_exclusions.txt)
+endif()
+
+find_program(CPPLINT_BIN NAMES cpplint cpplint.py HINTS ${BUILD_SUPPORT_DIR})
+message(STATUS "Found cpplint executable at ${CPPLINT_BIN}")
+
+#
+# "make lint" targets
+#
+add_custom_target(lint
+                  ${PYTHON_EXECUTABLE}
+                  ${BUILD_SUPPORT_DIR}/run_cpplint.py
+                  --cpplint_binary
+                  ${CPPLINT_BIN}
+                  --exclude_globs
+                  ${LINT_EXCLUSIONS_FILE}
+                  --source_dir
+                  ${CMAKE_CURRENT_SOURCE_DIR}
+                  ${MILVUS_LINT_QUIET})
+
+#
+# "make clang-format" and "make check-clang-format" targets
+#
+if(${CLANG_FORMAT_FOUND})
+  # runs clang format and updates files in place.
+  add_custom_target(clang-format
+                    ${PYTHON_EXECUTABLE}
+                    ${BUILD_SUPPORT_DIR}/run_clang_format.py
+                    --clang_format_binary
+                    ${CLANG_FORMAT_BIN}
+                    --exclude_globs
+                    ${LINT_EXCLUSIONS_FILE}
+                    --source_dir
+                    ${CMAKE_CURRENT_SOURCE_DIR}/src
+                    --fix
+                    ${MILVUS_LINT_QUIET})
+
+  # runs clang format and exits with a non-zero exit code if any files need to be reformatted
+  add_custom_target(check-clang-format
+                    ${PYTHON_EXECUTABLE}
+                    ${BUILD_SUPPORT_DIR}/run_clang_format.py
+                    --clang_format_binary
+                    ${CLANG_FORMAT_BIN}
+                    --exclude_globs
+                    ${LINT_EXCLUSIONS_FILE}
+                    --source_dir
+                    ${CMAKE_CURRENT_SOURCE_DIR}/src
+                    ${MILVUS_LINT_QUIET})
+endif()
+
+#
+# "make clang-tidy" and "make check-clang-tidy" targets
+#
+if(${CLANG_TIDY_FOUND})
+  # runs clang-tidy and attempts to fix any warning automatically
+  add_custom_target(clang-tidy
+                    ${PYTHON_EXECUTABLE}
+                    ${BUILD_SUPPORT_DIR}/run_clang_tidy.py
+                    --clang_tidy_binary
+                    ${CLANG_TIDY_BIN}
+                    --exclude_globs
+                    ${LINT_EXCLUSIONS_FILE}
+                    --compile_commands
+                    ${CMAKE_BINARY_DIR}/compile_commands.json
+                    --source_dir
+                    ${CMAKE_CURRENT_SOURCE_DIR}/src
+                    --fix
+                    ${MILVUS_LINT_QUIET})
+
+  # runs clang-tidy and exits with a non-zero exit code if any errors are found.
+  add_custom_target(check-clang-tidy
+                    ${PYTHON_EXECUTABLE}
+                    ${BUILD_SUPPORT_DIR}/run_clang_tidy.py
+                    --clang_tidy_binary
+                    ${CLANG_TIDY_BIN}
+                    --exclude_globs
+                    ${LINT_EXCLUSIONS_FILE}
+                    --compile_commands
+                    ${CMAKE_BINARY_DIR}/compile_commands.json
+                    --source_dir
+                    ${CMAKE_CURRENT_SOURCE_DIR}/src
+                    ${MILVUS_LINT_QUIET})
+endif()
+
diff --git a/core/build-support/code_style_clion.xml b/core/build-support/code_style_clion.xml
new file mode 100644
index 0000000000..f2edeec3b6
--- /dev/null
+++ b/core/build-support/code_style_clion.xml
@@ -0,0 +1,38 @@
+<code_scheme name="milvus" version="173">
+  <Objective-C>
+    <option name="INDENT_NAMESPACE_MEMBERS" value="0" />
+    <option name="INDENT_VISIBILITY_KEYWORDS" value="1" />
+    <option name="KEEP_STRUCTURES_IN_ONE_LINE" value="true" />
+    <option name="KEEP_CASE_EXPRESSIONS_IN_ONE_LINE" value="true" />
+    <option name="FUNCTION_NON_TOP_AFTER_RETURN_TYPE_WRAP" value="0" />
+    <option name="FUNCTION_TOP_AFTER_RETURN_TYPE_WRAP" value="2" />
+    <option name="FUNCTION_PARAMETERS_WRAP" value="5" />
+    <option name="FUNCTION_CALL_ARGUMENTS_WRAP" value="5" />
+    <option name="TEMPLATE_CALL_ARGUMENTS_WRAP" value="5" />
+    <option name="TEMPLATE_CALL_ARGUMENTS_ALIGN_MULTILINE" value="true" />
+    <option name="CLASS_CONSTRUCTOR_INIT_LIST_WRAP" value="5" />
+    <option name="ALIGN_INIT_LIST_IN_COLUMNS" value="false" />
+    <option name="SPACE_BEFORE_PROTOCOLS_BRACKETS" value="false" />
+    <option name="SPACE_BEFORE_POINTER_IN_DECLARATION" value="false" />
+    <option name="SPACE_AFTER_POINTER_IN_DECLARATION" value="true" />
+    <option name="SPACE_BEFORE_REFERENCE_IN_DECLARATION" value="false" />
+    <option name="SPACE_AFTER_REFERENCE_IN_DECLARATION" value="true" />
+    <option name="KEEP_BLANK_LINES_BEFORE_END" value="1" />
+  </Objective-C>
+  <codeStyleSettings language="ObjectiveC">
+    <option name="KEEP_BLANK_LINES_IN_DECLARATIONS" value="1" />
+    <option name="KEEP_BLANK_LINES_IN_CODE" value="1" />
+    <option name="KEEP_BLANK_LINES_BEFORE_RBRACE" value="1" />
+    <option name="BLANK_LINES_AROUND_CLASS" value="0" />
+    <option name="BLANK_LINES_AROUND_METHOD_IN_INTERFACE" value="0" />
+    <option name="BLANK_LINES_AFTER_CLASS_HEADER" value="1" />
+    <option name="SPACE_AFTER_TYPE_CAST" value="false" />
+    <option name="BINARY_OPERATION_SIGN_ON_NEXT_LINE" value="true" />
+    <option name="KEEP_SIMPLE_BLOCKS_IN_ONE_LINE" value="false" />
+    <option name="FOR_STATEMENT_WRAP" value="1" />
+    <option name="ASSIGNMENT_WRAP" value="1" />
+    <indentOptions>
+      <option name="CONTINUATION_INDENT_SIZE" value="4" />
+    </indentOptions>
+  </codeStyleSettings>
+</code_scheme>
\ No newline at end of file
diff --git a/core/build-support/cpplint.py b/core/build-support/cpplint.py
new file mode 100755
index 0000000000..8437d8cbaf
--- /dev/null
+++ b/core/build-support/cpplint.py
@@ -0,0 +1,6476 @@
+#!/usr/bin/env python
+#
+# Copyright (c) 2009 Google Inc. All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#    * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#    * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#    * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""Does google-lint on c++ files.
+
+The goal of this script is to identify places in the code that *may*
+be in non-compliance with google style.  It does not attempt to fix
+up these problems -- the point is to educate.  It does also not
+attempt to find all problems, or to ensure that everything it does
+find is legitimately a problem.
+
+In particular, we can get very confused by /* and // inside strings!
+We do a small hack, which is to ignore //'s with "'s after them on the
+same line, but it is far from perfect (in either direction).
+"""
+
+import codecs
+import copy
+import getopt
+import glob
+import itertools
+import math  # for log
+import os
+import re
+import sre_compile
+import string
+import sys
+import unicodedata
+import xml.etree.ElementTree
+
+# if empty, use defaults
+_header_extensions = set([])
+
+# if empty, use defaults
+_valid_extensions = set([])
+
+
+# Files with any of these extensions are considered to be
+# header files (and will undergo different style checks).
+# This set can be extended by using the --headers
+# option (also supported in CPPLINT.cfg)
+def GetHeaderExtensions():
+  if not _header_extensions:
+    return set(['h', 'hpp', 'hxx', 'h++', 'cuh'])
+  return _header_extensions
+
+# The allowed extensions for file names
+# This is set by --extensions flag
+def GetAllExtensions():
+  if not _valid_extensions:
+    return GetHeaderExtensions().union(set(['c', 'cc', 'cpp', 'cxx', 'c++', 'cu']))
+  return _valid_extensions
+
+def GetNonHeaderExtensions():
+  return GetAllExtensions().difference(GetHeaderExtensions())
+
+
+_USAGE = """
+Syntax: cpplint.py [--verbose=#] [--output=emacs|eclipse|vs7|junit]
+                   [--filter=-x,+y,...]
+                   [--counting=total|toplevel|detailed] [--repository=path]
+                   [--root=subdir] [--linelength=digits] [--recursive]
+                   [--exclude=path]
+                   [--headers=ext1,ext2]
+                   [--extensions=hpp,cpp,...]
+        <file> [file] ...
+
+  The style guidelines this tries to follow are those in
+    https://google.github.io/styleguide/cppguide.html
+
+  Every problem is given a confidence score from 1-5, with 5 meaning we are
+  certain of the problem, and 1 meaning it could be a legitimate construct.
+  This will miss some errors, and is not a substitute for a code review.
+
+  To suppress false-positive errors of a certain category, add a
+  'NOLINT(category)' comment to the line.  NOLINT or NOLINT(*)
+  suppresses errors of all categories on that line.
+
+  The files passed in will be linted; at least one file must be provided.
+  Default linted extensions are %s.
+  Other file types will be ignored.
+  Change the extensions with the --extensions flag.
+
+  Flags:
+
+    output=emacs|eclipse|vs7|junit
+      By default, the output is formatted to ease emacs parsing.  Output
+      compatible with eclipse (eclipse), Visual Studio (vs7), and JUnit
+      XML parsers such as those used in Jenkins and Bamboo may also be
+      used.  Other formats are unsupported.
+
+    verbose=#
+      Specify a number 0-5 to restrict errors to certain verbosity levels.
+      Errors with lower verbosity levels have lower confidence and are more
+      likely to be false positives.
+
+    quiet
+      Supress output other than linting errors, such as information about
+      which files have been processed and excluded.
+
+    filter=-x,+y,...
+      Specify a comma-separated list of category-filters to apply: only
+      error messages whose category names pass the filters will be printed.
+      (Category names are printed with the message and look like
+      "[whitespace/indent]".)  Filters are evaluated left to right.
+      "-FOO" and "FOO" means "do not print categories that start with FOO".
+      "+FOO" means "do print categories that start with FOO".
+
+      Examples: --filter=-whitespace,+whitespace/braces
+                --filter=whitespace,runtime/printf,+runtime/printf_format
+                --filter=-,+build/include_what_you_use
+
+      To see a list of all the categories used in cpplint, pass no arg:
+         --filter=
+
+    counting=total|toplevel|detailed
+      The total number of errors found is always printed. If
+      'toplevel' is provided, then the count of errors in each of
+      the top-level categories like 'build' and 'whitespace' will
+      also be printed. If 'detailed' is provided, then a count
+      is provided for each category like 'build/class'.
+
+    repository=path
+      The top level directory of the repository, used to derive the header
+      guard CPP variable. By default, this is determined by searching for a
+      path that contains .git, .hg, or .svn. When this flag is specified, the
+      given path is used instead. This option allows the header guard CPP
+      variable to remain consistent even if members of a team have different
+      repository root directories (such as when checking out a subdirectory
+      with SVN). In addition, users of non-mainstream version control systems
+      can use this flag to ensure readable header guard CPP variables.
+
+      Examples:
+        Assuming that Alice checks out ProjectName and Bob checks out
+        ProjectName/trunk and trunk contains src/chrome/ui/browser.h, then
+        with no --repository flag, the header guard CPP variable will be:
+
+        Alice => TRUNK_SRC_CHROME_BROWSER_UI_BROWSER_H_
+        Bob   => SRC_CHROME_BROWSER_UI_BROWSER_H_
+
+        If Alice uses the --repository=trunk flag and Bob omits the flag or
+        uses --repository=. then the header guard CPP variable will be:
+
+        Alice => SRC_CHROME_BROWSER_UI_BROWSER_H_
+        Bob   => SRC_CHROME_BROWSER_UI_BROWSER_H_
+
+    root=subdir
+      The root directory used for deriving header guard CPP variables. This
+      directory is relative to the top level directory of the repository which
+      by default is determined by searching for a directory that contains .git,
+      .hg, or .svn but can also be controlled with the --repository flag. If
+      the specified directory does not exist, this flag is ignored.
+
+      Examples:
+        Assuming that src is the top level directory of the repository, the
+        header guard CPP variables for src/chrome/browser/ui/browser.h are:
+
+        No flag => CHROME_BROWSER_UI_BROWSER_H_
+        --root=chrome => BROWSER_UI_BROWSER_H_
+        --root=chrome/browser => UI_BROWSER_H_
+
+    linelength=digits
+      This is the allowed line length for the project. The default value is
+      80 characters.
+
+      Examples:
+        --linelength=120
+
+    recursive
+      Search for files to lint recursively. Each directory given in the list
+      of files to be linted is replaced by all files that descend from that
+      directory. Files with extensions not in the valid extensions list are
+      excluded.
+
+    exclude=path
+      Exclude the given path from the list of files to be linted. Relative
+      paths are evaluated relative to the current directory and shell globbing
+      is performed. This flag can be provided multiple times to exclude
+      multiple files.
+
+      Examples:
+        --exclude=one.cc
+        --exclude=src/*.cc
+        --exclude=src/*.cc --exclude=test/*.cc
+
+    extensions=extension,extension,...
+      The allowed file extensions that cpplint will check
+
+      Examples:
+        --extensions=%s
+
+    headers=extension,extension,...
+      The allowed header extensions that cpplint will consider to be header files
+      (by default, only files with extensions %s
+      will be assumed to be headers)
+
+      Examples:
+        --headers=%s
+
+    cpplint.py supports per-directory configurations specified in CPPLINT.cfg
+    files. CPPLINT.cfg file can contain a number of key=value pairs.
+    Currently the following options are supported:
+
+      set noparent
+      filter=+filter1,-filter2,...
+      exclude_files=regex
+      linelength=80
+      root=subdir
+
+    "set noparent" option prevents cpplint from traversing directory tree
+    upwards looking for more .cfg files in parent directories. This option
+    is usually placed in the top-level project directory.
+
+    The "filter" option is similar in function to --filter flag. It specifies
+    message filters in addition to the |_DEFAULT_FILTERS| and those specified
+    through --filter command-line flag.
+
+    "exclude_files" allows to specify a regular expression to be matched against
+    a file name. If the expression matches, the file is skipped and not run
+    through the linter.
+
+    "linelength" specifies the allowed line length for the project.
+
+    The "root" option is similar in function to the --root flag (see example
+    above).
+
+    CPPLINT.cfg has an effect on files in the same directory and all
+    subdirectories, unless overridden by a nested configuration file.
+
+      Example file:
+        filter=-build/include_order,+build/include_alpha
+        exclude_files=.*\\.cc
+
+    The above example disables build/include_order warning and enables
+    build/include_alpha as well as excludes all .cc from being
+    processed by linter, in the current directory (where the .cfg
+    file is located) and all subdirectories.
+""" % (list(GetAllExtensions()),
+       ','.join(list(GetAllExtensions())),
+       GetHeaderExtensions(),
+       ','.join(GetHeaderExtensions()))
+
+# We categorize each error message we print.  Here are the categories.
+# We want an explicit list so we can list them all in cpplint --filter=.
+# If you add a new error message with a new category, add it to the list
+# here!  cpplint_unittest.py should tell you if you forget to do this.
+_ERROR_CATEGORIES = [
+    'build/class',
+    'build/c++11',
+    'build/c++14',
+    'build/c++tr1',
+    'build/deprecated',
+    'build/endif_comment',
+    'build/explicit_make_pair',
+    'build/forward_decl',
+    'build/header_guard',
+    'build/include',
+    'build/include_subdir',
+    'build/include_alpha',
+    'build/include_order',
+    'build/include_what_you_use',
+    'build/namespaces_literals',
+    'build/namespaces',
+    'build/printf_format',
+    'build/storage_class',
+    'legal/copyright',
+    'readability/alt_tokens',
+    'readability/braces',
+    'readability/casting',
+    'readability/check',
+    'readability/constructors',
+    'readability/fn_size',
+    'readability/inheritance',
+    'readability/multiline_comment',
+    'readability/multiline_string',
+    'readability/namespace',
+    'readability/nolint',
+    'readability/nul',
+    'readability/strings',
+    'readability/todo',
+    'readability/utf8',
+    'runtime/arrays',
+    'runtime/casting',
+    'runtime/explicit',
+    'runtime/int',
+    'runtime/init',
+    'runtime/invalid_increment',
+    'runtime/member_string_references',
+    'runtime/memset',
+    'runtime/indentation_namespace',
+    'runtime/operator',
+    'runtime/printf',
+    'runtime/printf_format',
+    'runtime/references',
+    'runtime/string',
+    'runtime/threadsafe_fn',
+    'runtime/vlog',
+    'whitespace/blank_line',
+    'whitespace/braces',
+    'whitespace/comma',
+    'whitespace/comments',
+    'whitespace/empty_conditional_body',
+    'whitespace/empty_if_body',
+    'whitespace/empty_loop_body',
+    'whitespace/end_of_line',
+    'whitespace/ending_newline',
+    'whitespace/forcolon',
+    'whitespace/indent',
+    'whitespace/line_length',
+    'whitespace/newline',
+    'whitespace/operators',
+    'whitespace/parens',
+    'whitespace/semicolon',
+    'whitespace/tab',
+    'whitespace/todo',
+    ]
+
+# These error categories are no longer enforced by cpplint, but for backwards-
+# compatibility they may still appear in NOLINT comments.
+_LEGACY_ERROR_CATEGORIES = [
+    'readability/streams',
+    'readability/function',
+    ]
+
+# The default state of the category filter. This is overridden by the --filter=
+# flag. By default all errors are on, so only add here categories that should be
+# off by default (i.e., categories that must be enabled by the --filter= flags).
+# All entries here should start with a '-' or '+', as in the --filter= flag.
+_DEFAULT_FILTERS = ['-build/include_alpha']
+
+# The default list of categories suppressed for C (not C++) files.
+_DEFAULT_C_SUPPRESSED_CATEGORIES = [
+    'readability/casting',
+    ]
+
+# The default list of categories suppressed for Linux Kernel files.
+_DEFAULT_KERNEL_SUPPRESSED_CATEGORIES = [
+    'whitespace/tab',
+    ]
+
+# We used to check for high-bit characters, but after much discussion we
+# decided those were OK, as long as they were in UTF-8 and didn't represent
+# hard-coded international strings, which belong in a separate i18n file.
+
+# C++ headers
+_CPP_HEADERS = frozenset([
+    # Legacy
+    'algobase.h',
+    'algo.h',
+    'alloc.h',
+    'builtinbuf.h',
+    'bvector.h',
+    'complex.h',
+    'defalloc.h',
+    'deque.h',
+    'editbuf.h',
+    'fstream.h',
+    'function.h',
+    'hash_map',
+    'hash_map.h',
+    'hash_set',
+    'hash_set.h',
+    'hashtable.h',
+    'heap.h',
+    'indstream.h',
+    'iomanip.h',
+    'iostream.h',
+    'istream.h',
+    'iterator.h',
+    'list.h',
+    'map.h',
+    'multimap.h',
+    'multiset.h',
+    'ostream.h',
+    'pair.h',
+    'parsestream.h',
+    'pfstream.h',
+    'procbuf.h',
+    'pthread_alloc',
+    'pthread_alloc.h',
+    'rope',
+    'rope.h',
+    'ropeimpl.h',
+    'set.h',
+    'slist',
+    'slist.h',
+    'stack.h',
+    'stdiostream.h',
+    'stl_alloc.h',
+    'stl_relops.h',
+    'streambuf.h',
+    'stream.h',
+    'strfile.h',
+    'strstream.h',
+    'tempbuf.h',
+    'tree.h',
+    'type_traits.h',
+    'vector.h',
+    # 17.6.1.2 C++ library headers
+    'algorithm',
+    'array',
+    'atomic',
+    'bitset',
+    'chrono',
+    'codecvt',
+    'complex',
+    'condition_variable',
+    'deque',
+    'exception',
+    'forward_list',
+    'fstream',
+    'functional',
+    'future',
+    'initializer_list',
+    'iomanip',
+    'ios',
+    'iosfwd',
+    'iostream',
+    'istream',
+    'iterator',
+    'limits',
+    'list',
+    'locale',
+    'map',
+    'memory',
+    'mutex',
+    'new',
+    'numeric',
+    'ostream',
+    'queue',
+    'random',
+    'ratio',
+    'regex',
+    'scoped_allocator',
+    'set',
+    'sstream',
+    'stack',
+    'stdexcept',
+    'streambuf',
+    'string',
+    'strstream',
+    'system_error',
+    'thread',
+    'tuple',
+    'typeindex',
+    'typeinfo',
+    'type_traits',
+    'unordered_map',
+    'unordered_set',
+    'utility',
+    'valarray',
+    'vector',
+    # 17.6.1.2 C++ headers for C library facilities
+    'cassert',
+    'ccomplex',
+    'cctype',
+    'cerrno',
+    'cfenv',
+    'cfloat',
+    'cinttypes',
+    'ciso646',
+    'climits',
+    'clocale',
+    'cmath',
+    'csetjmp',
+    'csignal',
+    'cstdalign',
+    'cstdarg',
+    'cstdbool',
+    'cstddef',
+    'cstdint',
+    'cstdio',
+    'cstdlib',
+    'cstring',
+    'ctgmath',
+    'ctime',
+    'cuchar',
+    'cwchar',
+    'cwctype',
+    ])
+
+# Type names
+_TYPES = re.compile(
+    r'^(?:'
+    # [dcl.type.simple]
+    r'(char(16_t|32_t)?)|wchar_t|'
+    r'bool|short|int|long|signed|unsigned|float|double|'
+    # [support.types]
+    r'(ptrdiff_t|size_t|max_align_t|nullptr_t)|'
+    # [cstdint.syn]
+    r'(u?int(_fast|_least)?(8|16|32|64)_t)|'
+    r'(u?int(max|ptr)_t)|'
+    r')$')
+
+
+# These headers are excluded from [build/include] and [build/include_order]
+# checks:
+# - Anything not following google file name conventions (containing an
+#   uppercase character, such as Python.h or nsStringAPI.h, for example).
+# - Lua headers.
+_THIRD_PARTY_HEADERS_PATTERN = re.compile(
+    r'^(?:[^/]*[A-Z][^/]*\.h|lua\.h|lauxlib\.h|lualib\.h)$')
+
+# Pattern for matching FileInfo.BaseName() against test file name
+_test_suffixes = ['_test', '_regtest', '_unittest']
+_TEST_FILE_SUFFIX = '(' + '|'.join(_test_suffixes) + r')$'
+
+# Pattern that matches only complete whitespace, possibly across multiple lines.
+_EMPTY_CONDITIONAL_BODY_PATTERN = re.compile(r'^\s*$', re.DOTALL)
+
+# Assertion macros.  These are defined in base/logging.h and
+# testing/base/public/gunit.h.
+_CHECK_MACROS = [
+    'DCHECK', 'CHECK',
+    'EXPECT_TRUE', 'ASSERT_TRUE',
+    'EXPECT_FALSE', 'ASSERT_FALSE',
+    ]
+
+# Replacement macros for CHECK/DCHECK/EXPECT_TRUE/EXPECT_FALSE
+_CHECK_REPLACEMENT = dict([(macro_var, {}) for macro_var in _CHECK_MACROS])
+
+for op, replacement in [('==', 'EQ'), ('!=', 'NE'),
+                        ('>=', 'GE'), ('>', 'GT'),
+                        ('<=', 'LE'), ('<', 'LT')]:
+  _CHECK_REPLACEMENT['DCHECK'][op] = 'DCHECK_%s' % replacement
+  _CHECK_REPLACEMENT['CHECK'][op] = 'CHECK_%s' % replacement
+  _CHECK_REPLACEMENT['EXPECT_TRUE'][op] = 'EXPECT_%s' % replacement
+  _CHECK_REPLACEMENT['ASSERT_TRUE'][op] = 'ASSERT_%s' % replacement
+
+for op, inv_replacement in [('==', 'NE'), ('!=', 'EQ'),
+                            ('>=', 'LT'), ('>', 'LE'),
+                            ('<=', 'GT'), ('<', 'GE')]:
+  _CHECK_REPLACEMENT['EXPECT_FALSE'][op] = 'EXPECT_%s' % inv_replacement
+  _CHECK_REPLACEMENT['ASSERT_FALSE'][op] = 'ASSERT_%s' % inv_replacement
+
+# Alternative tokens and their replacements.  For full list, see section 2.5
+# Alternative tokens [lex.digraph] in the C++ standard.
+#
+# Digraphs (such as '%:') are not included here since it's a mess to
+# match those on a word boundary.
+_ALT_TOKEN_REPLACEMENT = {
+    'and': '&&',
+    'bitor': '|',
+    'or': '||',
+    'xor': '^',
+    'compl': '~',
+    'bitand': '&',
+    'and_eq': '&=',
+    'or_eq': '|=',
+    'xor_eq': '^=',
+    'not': '!',
+    'not_eq': '!='
+    }
+
+# Compile regular expression that matches all the above keywords.  The "[ =()]"
+# bit is meant to avoid matching these keywords outside of boolean expressions.
+#
+# False positives include C-style multi-line comments and multi-line strings
+# but those have always been troublesome for cpplint.
+_ALT_TOKEN_REPLACEMENT_PATTERN = re.compile(
+    r'[ =()](' + ('|'.join(_ALT_TOKEN_REPLACEMENT.keys())) + r')(?=[ (]|$)')
+
+
+# These constants define types of headers for use with
+# _IncludeState.CheckNextIncludeOrder().
+_C_SYS_HEADER = 1
+_CPP_SYS_HEADER = 2
+_LIKELY_MY_HEADER = 3
+_POSSIBLE_MY_HEADER = 4
+_OTHER_HEADER = 5
+
+# These constants define the current inline assembly state
+_NO_ASM = 0       # Outside of inline assembly block
+_INSIDE_ASM = 1   # Inside inline assembly block
+_END_ASM = 2      # Last line of inline assembly block
+_BLOCK_ASM = 3    # The whole block is an inline assembly block
+
+# Match start of assembly blocks
+_MATCH_ASM = re.compile(r'^\s*(?:asm|_asm|__asm|__asm__)'
+                        r'(?:\s+(volatile|__volatile__))?'
+                        r'\s*[{(]')
+
+# Match strings that indicate we're working on a C (not C++) file.
+_SEARCH_C_FILE = re.compile(r'\b(?:LINT_C_FILE|'
+                            r'vim?:\s*.*(\s*|:)filetype=c(\s*|:|$))')
+
+# Match string that indicates we're working on a Linux Kernel file.
+_SEARCH_KERNEL_FILE = re.compile(r'\b(?:LINT_KERNEL_FILE)')
+
+_regexp_compile_cache = {}
+
+# {str, set(int)}: a map from error categories to sets of linenumbers
+# on which those errors are expected and should be suppressed.
+_error_suppressions = {}
+
+# The root directory used for deriving header guard CPP variable.
+# This is set by --root flag.
+_root = None
+
+# The top level repository directory. If set, _root is calculated relative to
+# this directory instead of the directory containing version control artifacts.
+# This is set by the --repository flag.
+_repository = None
+
+# Files to exclude from linting. This is set by the --exclude flag.
+_excludes = None
+
+# Whether to supress PrintInfo messages
+_quiet = False
+
+# The allowed line length of files.
+# This is set by --linelength flag.
+_line_length = 80
+
+try:
+  xrange(1, 0)
+except NameError:
+  #  -- pylint: disable=redefined-builtin
+  xrange = range
+
+try:
+  unicode
+except NameError:
+  #  -- pylint: disable=redefined-builtin
+  basestring = unicode = str
+
+try:
+  long(2)
+except NameError:
+  #  -- pylint: disable=redefined-builtin
+  long = int
+
+if sys.version_info < (3,):
+  #  -- pylint: disable=no-member
+  # BINARY_TYPE = str
+  itervalues = dict.itervalues
+  iteritems = dict.iteritems
+else:
+  # BINARY_TYPE = bytes
+  itervalues = dict.values
+  iteritems = dict.items
+
+def unicode_escape_decode(x):
+  if sys.version_info < (3,):
+    return codecs.unicode_escape_decode(x)[0]
+  else:
+    return x
+
+# {str, bool}: a map from error categories to booleans which indicate if the
+# category should be suppressed for every line.
+_global_error_suppressions = {}
+
+
+
+
+def ParseNolintSuppressions(filename, raw_line, linenum, error):
+  """Updates the global list of line error-suppressions.
+
+  Parses any NOLINT comments on the current line, updating the global
+  error_suppressions store.  Reports an error if the NOLINT comment
+  was malformed.
+
+  Args:
+    filename: str, the name of the input file.
+    raw_line: str, the line of input text, with comments.
+    linenum: int, the number of the current line.
+    error: function, an error handler.
+  """
+  matched = Search(r'\bNOLINT(NEXTLINE)?\b(\([^)]+\))?', raw_line)
+  if matched:
+    if matched.group(1):
+      suppressed_line = linenum + 1
+    else:
+      suppressed_line = linenum
+    category = matched.group(2)
+    if category in (None, '(*)'):  # => "suppress all"
+      _error_suppressions.setdefault(None, set()).add(suppressed_line)
+    else:
+      if category.startswith('(') and category.endswith(')'):
+        category = category[1:-1]
+        if category in _ERROR_CATEGORIES:
+          _error_suppressions.setdefault(category, set()).add(suppressed_line)
+        elif category not in _LEGACY_ERROR_CATEGORIES:
+          error(filename, linenum, 'readability/nolint', 5,
+                'Unknown NOLINT error category: %s' % category)
+
+
+def ProcessGlobalSuppresions(lines):
+  """Updates the list of global error suppressions.
+
+  Parses any lint directives in the file that have global effect.
+
+  Args:
+    lines: An array of strings, each representing a line of the file, with the
+           last element being empty if the file is terminated with a newline.
+  """
+  for line in lines:
+    if _SEARCH_C_FILE.search(line):
+      for category in _DEFAULT_C_SUPPRESSED_CATEGORIES:
+        _global_error_suppressions[category] = True
+    if _SEARCH_KERNEL_FILE.search(line):
+      for category in _DEFAULT_KERNEL_SUPPRESSED_CATEGORIES:
+        _global_error_suppressions[category] = True
+
+
+def ResetNolintSuppressions():
+  """Resets the set of NOLINT suppressions to empty."""
+  _error_suppressions.clear()
+  _global_error_suppressions.clear()
+
+
+def IsErrorSuppressedByNolint(category, linenum):
+  """Returns true if the specified error category is suppressed on this line.
+
+  Consults the global error_suppressions map populated by
+  ParseNolintSuppressions/ProcessGlobalSuppresions/ResetNolintSuppressions.
+
+  Args:
+    category: str, the category of the error.
+    linenum: int, the current line number.
+  Returns:
+    bool, True iff the error should be suppressed due to a NOLINT comment or
+    global suppression.
+  """
+  return (_global_error_suppressions.get(category, False) or
+          linenum in _error_suppressions.get(category, set()) or
+          linenum in _error_suppressions.get(None, set()))
+
+
+def Match(pattern, s):
+  """Matches the string with the pattern, caching the compiled regexp."""
+  # The regexp compilation caching is inlined in both Match and Search for
+  # performance reasons; factoring it out into a separate function turns out
+  # to be noticeably expensive.
+  if pattern not in _regexp_compile_cache:
+    _regexp_compile_cache[pattern] = sre_compile.compile(pattern)
+  return _regexp_compile_cache[pattern].match(s)
+
+
+def ReplaceAll(pattern, rep, s):
+  """Replaces instances of pattern in a string with a replacement.
+
+  The compiled regex is kept in a cache shared by Match and Search.
+
+  Args:
+    pattern: regex pattern
+    rep: replacement text
+    s: search string
+
+  Returns:
+    string with replacements made (or original string if no replacements)
+  """
+  if pattern not in _regexp_compile_cache:
+    _regexp_compile_cache[pattern] = sre_compile.compile(pattern)
+  return _regexp_compile_cache[pattern].sub(rep, s)
+
+
+def Search(pattern, s):
+  """Searches the string for the pattern, caching the compiled regexp."""
+  if pattern not in _regexp_compile_cache:
+    _regexp_compile_cache[pattern] = sre_compile.compile(pattern)
+  return _regexp_compile_cache[pattern].search(s)
+
+
+def _IsSourceExtension(s):
+  """File extension (excluding dot) matches a source file extension."""
+  return s in GetNonHeaderExtensions()
+
+
+class _IncludeState(object):
+  """Tracks line numbers for includes, and the order in which includes appear.
+
+  include_list contains list of lists of (header, line number) pairs.
+  It's a lists of lists rather than just one flat list to make it
+  easier to update across preprocessor boundaries.
+
+  Call CheckNextIncludeOrder() once for each header in the file, passing
+  in the type constants defined above. Calls in an illegal order will
+  raise an _IncludeError with an appropriate error message.
+
+  """
+  # self._section will move monotonically through this set. If it ever
+  # needs to move backwards, CheckNextIncludeOrder will raise an error.
+  _INITIAL_SECTION = 0
+  _MY_H_SECTION = 1
+  _C_SECTION = 2
+  _CPP_SECTION = 3
+  _OTHER_H_SECTION = 4
+
+  _TYPE_NAMES = {
+      _C_SYS_HEADER: 'C system header',
+      _CPP_SYS_HEADER: 'C++ system header',
+      _LIKELY_MY_HEADER: 'header this file implements',
+      _POSSIBLE_MY_HEADER: 'header this file may implement',
+      _OTHER_HEADER: 'other header',
+      }
+  _SECTION_NAMES = {
+      _INITIAL_SECTION: "... nothing. (This can't be an error.)",
+      _MY_H_SECTION: 'a header this file implements',
+      _C_SECTION: 'C system header',
+      _CPP_SECTION: 'C++ system header',
+      _OTHER_H_SECTION: 'other header',
+      }
+
+  def __init__(self):
+    self.include_list = [[]]
+    self._section = None
+    self._last_header = None
+    self.ResetSection('')
+
+  def FindHeader(self, header):
+    """Check if a header has already been included.
+
+    Args:
+      header: header to check.
+    Returns:
+      Line number of previous occurrence, or -1 if the header has not
+      been seen before.
+    """
+    for section_list in self.include_list:
+      for f in section_list:
+        if f[0] == header:
+          return f[1]
+    return -1
+
+  def ResetSection(self, directive):
+    """Reset section checking for preprocessor directive.
+
+    Args:
+      directive: preprocessor directive (e.g. "if", "else").
+    """
+    # The name of the current section.
+    self._section = self._INITIAL_SECTION
+    # The path of last found header.
+    self._last_header = ''
+
+    # Update list of includes.  Note that we never pop from the
+    # include list.
+    if directive in ('if', 'ifdef', 'ifndef'):
+      self.include_list.append([])
+    elif directive in ('else', 'elif'):
+      self.include_list[-1] = []
+
+  def SetLastHeader(self, header_path):
+    self._last_header = header_path
+
+  def CanonicalizeAlphabeticalOrder(self, header_path):
+    """Returns a path canonicalized for alphabetical comparison.
+
+    - replaces "-" with "_" so they both cmp the same.
+    - removes '-inl' since we don't require them to be after the main header.
+    - lowercase everything, just in case.
+
+    Args:
+      header_path: Path to be canonicalized.
+
+    Returns:
+      Canonicalized path.
+    """
+    return header_path.replace('-inl.h', '.h').replace('-', '_').lower()
+
+  def IsInAlphabeticalOrder(self, clean_lines, linenum, header_path):
+    """Check if a header is in alphabetical order with the previous header.
+
+    Args:
+      clean_lines: A CleansedLines instance containing the file.
+      linenum: The number of the line to check.
+      header_path: Canonicalized header to be checked.
+
+    Returns:
+      Returns true if the header is in alphabetical order.
+    """
+    # If previous section is different from current section, _last_header will
+    # be reset to empty string, so it's always less than current header.
+    #
+    # If previous line was a blank line, assume that the headers are
+    # intentionally sorted the way they are.
+    if (self._last_header > header_path and
+        Match(r'^\s*#\s*include\b', clean_lines.elided[linenum - 1])):
+      return False
+    return True
+
+  def CheckNextIncludeOrder(self, header_type):
+    """Returns a non-empty error message if the next header is out of order.
+
+    This function also updates the internal state to be ready to check
+    the next include.
+
+    Args:
+      header_type: One of the _XXX_HEADER constants defined above.
+
+    Returns:
+      The empty string if the header is in the right order, or an
+      error message describing what's wrong.
+
+    """
+    error_message = ('Found %s after %s' %
+                     (self._TYPE_NAMES[header_type],
+                      self._SECTION_NAMES[self._section]))
+
+    last_section = self._section
+
+    if header_type == _C_SYS_HEADER:
+      if self._section <= self._C_SECTION:
+        self._section = self._C_SECTION
+      else:
+        self._last_header = ''
+        return error_message
+    elif header_type == _CPP_SYS_HEADER:
+      if self._section <= self._CPP_SECTION:
+        self._section = self._CPP_SECTION
+      else:
+        self._last_header = ''
+        return error_message
+    elif header_type == _LIKELY_MY_HEADER:
+      if self._section <= self._MY_H_SECTION:
+        self._section = self._MY_H_SECTION
+      else:
+        self._section = self._OTHER_H_SECTION
+    elif header_type == _POSSIBLE_MY_HEADER:
+      if self._section <= self._MY_H_SECTION:
+        self._section = self._MY_H_SECTION
+      else:
+        # This will always be the fallback because we're not sure
+        # enough that the header is associated with this file.
+        self._section = self._OTHER_H_SECTION
+    else:
+      assert header_type == _OTHER_HEADER
+      self._section = self._OTHER_H_SECTION
+
+    if last_section != self._section:
+      self._last_header = ''
+
+    return ''
+
+
+class _CppLintState(object):
+  """Maintains module-wide state.."""
+
+  def __init__(self):
+    self.verbose_level = 1  # global setting.
+    self.error_count = 0    # global count of reported errors
+    # filters to apply when emitting error messages
+    self.filters = _DEFAULT_FILTERS[:]
+    # backup of filter list. Used to restore the state after each file.
+    self._filters_backup = self.filters[:]
+    self.counting = 'total'  # In what way are we counting errors?
+    self.errors_by_category = {}  # string to int dict storing error counts
+
+    # output format:
+    # "emacs" - format that emacs can parse (default)
+    # "eclipse" - format that eclipse can parse
+    # "vs7" - format that Microsoft Visual Studio 7 can parse
+    # "junit" - format that Jenkins, Bamboo, etc can parse
+    self.output_format = 'emacs'
+
+    # For JUnit output, save errors and failures until the end so that they
+    # can be written into the XML
+    self._junit_errors = []
+    self._junit_failures = []
+
+  def SetOutputFormat(self, output_format):
+    """Sets the output format for errors."""
+    self.output_format = output_format
+
+  def SetVerboseLevel(self, level):
+    """Sets the module's verbosity, and returns the previous setting."""
+    last_verbose_level = self.verbose_level
+    self.verbose_level = level
+    return last_verbose_level
+
+  def SetCountingStyle(self, counting_style):
+    """Sets the module's counting options."""
+    self.counting = counting_style
+
+  def SetFilters(self, filters):
+    """Sets the error-message filters.
+
+    These filters are applied when deciding whether to emit a given
+    error message.
+
+    Args:
+      filters: A string of comma-separated filters (eg "+whitespace/indent").
+               Each filter should start with + or -; else we die.
+
+    Raises:
+      ValueError: The comma-separated filters did not all start with '+' or '-'.
+                  E.g. "-,+whitespace,-whitespace/indent,whitespace/badfilter"
+    """
+    # Default filters always have less priority than the flag ones.
+    self.filters = _DEFAULT_FILTERS[:]
+    self.AddFilters(filters)
+
+  def AddFilters(self, filters):
+    """ Adds more filters to the existing list of error-message filters. """
+    for filt in filters.split(','):
+      clean_filt = filt.strip()
+      if clean_filt:
+        self.filters.append(clean_filt)
+    for filt in self.filters:
+      if not (filt.startswith('+') or filt.startswith('-')):
+        raise ValueError('Every filter in --filters must start with + or -'
+                         ' (%s does not)' % filt)
+
+  def BackupFilters(self):
+    """ Saves the current filter list to backup storage."""
+    self._filters_backup = self.filters[:]
+
+  def RestoreFilters(self):
+    """ Restores filters previously backed up."""
+    self.filters = self._filters_backup[:]
+
+  def ResetErrorCounts(self):
+    """Sets the module's error statistic back to zero."""
+    self.error_count = 0
+    self.errors_by_category = {}
+
+  def IncrementErrorCount(self, category):
+    """Bumps the module's error statistic."""
+    self.error_count += 1
+    if self.counting in ('toplevel', 'detailed'):
+      if self.counting != 'detailed':
+        category = category.split('/')[0]
+      if category not in self.errors_by_category:
+        self.errors_by_category[category] = 0
+      self.errors_by_category[category] += 1
+
+  def PrintErrorCounts(self):
+    """Print a summary of errors by category, and the total."""
+    for category, count in sorted(iteritems(self.errors_by_category)):
+      self.PrintInfo('Category \'%s\' errors found: %d\n' %
+                       (category, count))
+    if self.error_count > 0:
+      self.PrintInfo('Total errors found: %d\n' % self.error_count)
+
+  def PrintInfo(self, message):
+    if not _quiet and self.output_format != 'junit':
+      sys.stderr.write(message)
+
+  def PrintError(self, message):
+    if self.output_format == 'junit':
+      self._junit_errors.append(message)
+    else:
+      sys.stderr.write(message)
+
+  def AddJUnitFailure(self, filename, linenum, message, category, confidence):
+    self._junit_failures.append((filename, linenum, message, category,
+        confidence))
+
+  def FormatJUnitXML(self):
+    num_errors = len(self._junit_errors)
+    num_failures = len(self._junit_failures)
+
+    testsuite = xml.etree.ElementTree.Element('testsuite')
+    testsuite.attrib['name'] = 'cpplint'
+    testsuite.attrib['errors'] = str(num_errors)
+    testsuite.attrib['failures'] = str(num_failures)
+
+    if num_errors == 0 and num_failures == 0:
+      testsuite.attrib['tests'] = str(1)
+      xml.etree.ElementTree.SubElement(testsuite, 'testcase', name='passed')
+
+    else:
+      testsuite.attrib['tests'] = str(num_errors + num_failures)
+      if num_errors > 0:
+        testcase = xml.etree.ElementTree.SubElement(testsuite, 'testcase')
+        testcase.attrib['name'] = 'errors'
+        error = xml.etree.ElementTree.SubElement(testcase, 'error')
+        error.text = '\n'.join(self._junit_errors)
+      if num_failures > 0:
+        # Group failures by file
+        failed_file_order = []
+        failures_by_file = {}
+        for failure in self._junit_failures:
+          failed_file = failure[0]
+          if failed_file not in failed_file_order:
+            failed_file_order.append(failed_file)
+            failures_by_file[failed_file] = []
+          failures_by_file[failed_file].append(failure)
+        # Create a testcase for each file
+        for failed_file in failed_file_order:
+          failures = failures_by_file[failed_file]
+          testcase = xml.etree.ElementTree.SubElement(testsuite, 'testcase')
+          testcase.attrib['name'] = failed_file
+          failure = xml.etree.ElementTree.SubElement(testcase, 'failure')
+          template = '{0}: {1} [{2}] [{3}]'
+          texts = [template.format(f[1], f[2], f[3], f[4]) for f in failures]
+          failure.text = '\n'.join(texts)
+
+    xml_decl = '<?xml version="1.0" encoding="UTF-8" ?>\n'
+    return xml_decl + xml.etree.ElementTree.tostring(testsuite, 'utf-8').decode('utf-8')
+
+
+_cpplint_state = _CppLintState()
+
+
+def _OutputFormat():
+  """Gets the module's output format."""
+  return _cpplint_state.output_format
+
+
+def _SetOutputFormat(output_format):
+  """Sets the module's output format."""
+  _cpplint_state.SetOutputFormat(output_format)
+
+
+def _VerboseLevel():
+  """Returns the module's verbosity setting."""
+  return _cpplint_state.verbose_level
+
+
+def _SetVerboseLevel(level):
+  """Sets the module's verbosity, and returns the previous setting."""
+  return _cpplint_state.SetVerboseLevel(level)
+
+
+def _SetCountingStyle(level):
+  """Sets the module's counting options."""
+  _cpplint_state.SetCountingStyle(level)
+
+
+def _Filters():
+  """Returns the module's list of output filters, as a list."""
+  return _cpplint_state.filters
+
+
+def _SetFilters(filters):
+  """Sets the module's error-message filters.
+
+  These filters are applied when deciding whether to emit a given
+  error message.
+
+  Args:
+    filters: A string of comma-separated filters (eg "whitespace/indent").
+             Each filter should start with + or -; else we die.
+  """
+  _cpplint_state.SetFilters(filters)
+
+def _AddFilters(filters):
+  """Adds more filter overrides.
+
+  Unlike _SetFilters, this function does not reset the current list of filters
+  available.
+
+  Args:
+    filters: A string of comma-separated filters (eg "whitespace/indent").
+             Each filter should start with + or -; else we die.
+  """
+  _cpplint_state.AddFilters(filters)
+
+def _BackupFilters():
+  """ Saves the current filter list to backup storage."""
+  _cpplint_state.BackupFilters()
+
+def _RestoreFilters():
+  """ Restores filters previously backed up."""
+  _cpplint_state.RestoreFilters()
+
+class _FunctionState(object):
+  """Tracks current function name and the number of lines in its body."""
+
+  _NORMAL_TRIGGER = 250  # for --v=0, 500 for --v=1, etc.
+  _TEST_TRIGGER = 400    # about 50% more than _NORMAL_TRIGGER.
+
+  def __init__(self):
+    self.in_a_function = False
+    self.lines_in_function = 0
+    self.current_function = ''
+
+  def Begin(self, function_name):
+    """Start analyzing function body.
+
+    Args:
+      function_name: The name of the function being tracked.
+    """
+    self.in_a_function = True
+    self.lines_in_function = 0
+    self.current_function = function_name
+
+  def Count(self):
+    """Count line in current function body."""
+    if self.in_a_function:
+      self.lines_in_function += 1
+
+  def Check(self, error, filename, linenum):
+    """Report if too many lines in function body.
+
+    Args:
+      error: The function to call with any errors found.
+      filename: The name of the current file.
+      linenum: The number of the line to check.
+    """
+    if not self.in_a_function:
+      return
+
+    if Match(r'T(EST|est)', self.current_function):
+      base_trigger = self._TEST_TRIGGER
+    else:
+      base_trigger = self._NORMAL_TRIGGER
+    trigger = base_trigger * 2**_VerboseLevel()
+
+    if self.lines_in_function > trigger:
+      error_level = int(math.log(self.lines_in_function / base_trigger, 2))
+      # 50 => 0, 100 => 1, 200 => 2, 400 => 3, 800 => 4, 1600 => 5, ...
+      if error_level > 5:
+        error_level = 5
+      error(filename, linenum, 'readability/fn_size', error_level,
+            'Small and focused functions are preferred:'
+            ' %s has %d non-comment lines'
+            ' (error triggered by exceeding %d lines).'  % (
+                self.current_function, self.lines_in_function, trigger))
+
+  def End(self):
+    """Stop analyzing function body."""
+    self.in_a_function = False
+
+
+class _IncludeError(Exception):
+  """Indicates a problem with the include order in a file."""
+  pass
+
+
+class FileInfo(object):
+  """Provides utility functions for filenames.
+
+  FileInfo provides easy access to the components of a file's path
+  relative to the project root.
+  """
+
+  def __init__(self, filename):
+    self._filename = filename
+
+  def FullName(self):
+    """Make Windows paths like Unix."""
+    return os.path.abspath(self._filename).replace('\\', '/')
+
+  def RepositoryName(self):
+    r"""FullName after removing the local path to the repository.
+
+    If we have a real absolute path name here we can try to do something smart:
+    detecting the root of the checkout and truncating /path/to/checkout from
+    the name so that we get header guards that don't include things like
+    "C:\Documents and Settings\..." or "/home/username/..." in them and thus
+    people on different computers who have checked the source out to different
+    locations won't see bogus errors.
+    """
+    fullname = self.FullName()
+
+    if os.path.exists(fullname):
+      project_dir = os.path.dirname(fullname)
+
+      # If the user specified a repository path, it exists, and the file is
+      # contained in it, use the specified repository path
+      if _repository:
+        repo = FileInfo(_repository).FullName()
+        root_dir = project_dir
+        while os.path.exists(root_dir):
+          # allow case insensitive compare on Windows
+          if os.path.normcase(root_dir) == os.path.normcase(repo):
+            return os.path.relpath(fullname, root_dir).replace('\\', '/')
+          one_up_dir = os.path.dirname(root_dir)
+          if one_up_dir == root_dir:
+            break
+          root_dir = one_up_dir
+
+      if os.path.exists(os.path.join(project_dir, ".svn")):
+        # If there's a .svn file in the current directory, we recursively look
+        # up the directory tree for the top of the SVN checkout
+        root_dir = project_dir
+        one_up_dir = os.path.dirname(root_dir)
+        while os.path.exists(os.path.join(one_up_dir, ".svn")):
+          root_dir = os.path.dirname(root_dir)
+          one_up_dir = os.path.dirname(one_up_dir)
+
+        prefix = os.path.commonprefix([root_dir, project_dir])
+        return fullname[len(prefix) + 1:]
+
+      # Not SVN <= 1.6? Try to find a git, hg, or svn top level directory by
+      # searching up from the current path.
+      root_dir = current_dir = os.path.dirname(fullname)
+      while current_dir != os.path.dirname(current_dir):
+        if (os.path.exists(os.path.join(current_dir, ".git")) or
+            os.path.exists(os.path.join(current_dir, ".hg")) or
+            os.path.exists(os.path.join(current_dir, ".svn"))):
+          root_dir = current_dir
+        current_dir = os.path.dirname(current_dir)
+
+      if (os.path.exists(os.path.join(root_dir, ".git")) or
+          os.path.exists(os.path.join(root_dir, ".hg")) or
+          os.path.exists(os.path.join(root_dir, ".svn"))):
+        prefix = os.path.commonprefix([root_dir, project_dir])
+        return fullname[len(prefix) + 1:]
+
+    # Don't know what to do; header guard warnings may be wrong...
+    return fullname
+
+  def Split(self):
+    """Splits the file into the directory, basename, and extension.
+
+    For 'chrome/browser/browser.cc', Split() would
+    return ('chrome/browser', 'browser', '.cc')
+
+    Returns:
+      A tuple of (directory, basename, extension).
+    """
+
+    googlename = self.RepositoryName()
+    project, rest = os.path.split(googlename)
+    return (project,) + os.path.splitext(rest)
+
+  def BaseName(self):
+    """File base name - text after the final slash, before the final period."""
+    return self.Split()[1]
+
+  def Extension(self):
+    """File extension - text following the final period, includes that period."""
+    return self.Split()[2]
+
+  def NoExtension(self):
+    """File has no source file extension."""
+    return '/'.join(self.Split()[0:2])
+
+  def IsSource(self):
+    """File has a source file extension."""
+    return _IsSourceExtension(self.Extension()[1:])
+
+
+def _ShouldPrintError(category, confidence, linenum):
+  """If confidence >= verbose, category passes filter and is not suppressed."""
+
+  # There are three ways we might decide not to print an error message:
+  # a "NOLINT(category)" comment appears in the source,
+  # the verbosity level isn't high enough, or the filters filter it out.
+  if IsErrorSuppressedByNolint(category, linenum):
+    return False
+
+  if confidence < _cpplint_state.verbose_level:
+    return False
+
+  is_filtered = False
+  for one_filter in _Filters():
+    if one_filter.startswith('-'):
+      if category.startswith(one_filter[1:]):
+        is_filtered = True
+    elif one_filter.startswith('+'):
+      if category.startswith(one_filter[1:]):
+        is_filtered = False
+    else:
+      assert False  # should have been checked for in SetFilter.
+  if is_filtered:
+    return False
+
+  return True
+
+
+def Error(filename, linenum, category, confidence, message):
+  """Logs the fact we've found a lint error.
+
+  We log where the error was found, and also our confidence in the error,
+  that is, how certain we are this is a legitimate style regression, and
+  not a misidentification or a use that's sometimes justified.
+
+  False positives can be suppressed by the use of
+  "cpplint(category)"  comments on the offending line.  These are
+  parsed into _error_suppressions.
+
+  Args:
+    filename: The name of the file containing the error.
+    linenum: The number of the line containing the error.
+    category: A string used to describe the "category" this bug
+      falls under: "whitespace", say, or "runtime".  Categories
+      may have a hierarchy separated by slashes: "whitespace/indent".
+    confidence: A number from 1-5 representing a confidence score for
+      the error, with 5 meaning that we are certain of the problem,
+      and 1 meaning that it could be a legitimate construct.
+    message: The error message.
+  """
+  if _ShouldPrintError(category, confidence, linenum):
+    _cpplint_state.IncrementErrorCount(category)
+    if _cpplint_state.output_format == 'vs7':
+      _cpplint_state.PrintError('%s(%s): warning: %s  [%s] [%d]\n' % (
+          filename, linenum, message, category, confidence))
+    elif _cpplint_state.output_format == 'eclipse':
+      sys.stderr.write('%s:%s: warning: %s  [%s] [%d]\n' % (
+          filename, linenum, message, category, confidence))
+    elif _cpplint_state.output_format == 'junit':
+        _cpplint_state.AddJUnitFailure(filename, linenum, message, category,
+            confidence)
+    else:
+      final_message = '%s:%s:  %s  [%s] [%d]\n' % (
+          filename, linenum, message, category, confidence)
+      sys.stderr.write(final_message)
+
+# Matches standard C++ escape sequences per 2.13.2.3 of the C++ standard.
+_RE_PATTERN_CLEANSE_LINE_ESCAPES = re.compile(
+    r'\\([abfnrtv?"\\\']|\d+|x[0-9a-fA-F]+)')
+# Match a single C style comment on the same line.
+_RE_PATTERN_C_COMMENTS = r'/\*(?:[^*]|\*(?!/))*\*/'
+# Matches multi-line C style comments.
+# This RE is a little bit more complicated than one might expect, because we
+# have to take care of space removals tools so we can handle comments inside
+# statements better.
+# The current rule is: We only clear spaces from both sides when we're at the
+# end of the line. Otherwise, we try to remove spaces from the right side,
+# if this doesn't work we try on left side but only if there's a non-character
+# on the right.
+_RE_PATTERN_CLEANSE_LINE_C_COMMENTS = re.compile(
+    r'(\s*' + _RE_PATTERN_C_COMMENTS + r'\s*$|' +
+    _RE_PATTERN_C_COMMENTS + r'\s+|' +
+    r'\s+' + _RE_PATTERN_C_COMMENTS + r'(?=\W)|' +
+    _RE_PATTERN_C_COMMENTS + r')')
+
+
+def IsCppString(line):
+  """Does line terminate so, that the next symbol is in string constant.
+
+  This function does not consider single-line nor multi-line comments.
+
+  Args:
+    line: is a partial line of code starting from the 0..n.
+
+  Returns:
+    True, if next character appended to 'line' is inside a
+    string constant.
+  """
+
+  line = line.replace(r'\\', 'XX')  # after this, \\" does not match to \"
+  return ((line.count('"') - line.count(r'\"') - line.count("'\"'")) & 1) == 1
+
+
+def CleanseRawStrings(raw_lines):
+  """Removes C++11 raw strings from lines.
+
+    Before:
+      static const char kData[] = R"(
+          multi-line string
+          )";
+
+    After:
+      static const char kData[] = ""
+          (replaced by blank line)
+          "";
+
+  Args:
+    raw_lines: list of raw lines.
+
+  Returns:
+    list of lines with C++11 raw strings replaced by empty strings.
+  """
+
+  delimiter = None
+  lines_without_raw_strings = []
+  for line in raw_lines:
+    if delimiter:
+      # Inside a raw string, look for the end
+      end = line.find(delimiter)
+      if end >= 0:
+        # Found the end of the string, match leading space for this
+        # line and resume copying the original lines, and also insert
+        # a "" on the last line.
+        leading_space = Match(r'^(\s*)\S', line)
+        line = leading_space.group(1) + '""' + line[end + len(delimiter):]
+        delimiter = None
+      else:
+        # Haven't found the end yet, append a blank line.
+        line = '""'
+
+    # Look for beginning of a raw string, and replace them with
+    # empty strings.  This is done in a loop to handle multiple raw
+    # strings on the same line.
+    while delimiter is None:
+      # Look for beginning of a raw string.
+      # See 2.14.15 [lex.string] for syntax.
+      #
+      # Once we have matched a raw string, we check the prefix of the
+      # line to make sure that the line is not part of a single line
+      # comment.  It's done this way because we remove raw strings
+      # before removing comments as opposed to removing comments
+      # before removing raw strings.  This is because there are some
+      # cpplint checks that requires the comments to be preserved, but
+      # we don't want to check comments that are inside raw strings.
+      matched = Match(r'^(.*?)\b(?:R|u8R|uR|UR|LR)"([^\s\\()]*)\((.*)$', line)
+      if (matched and
+          not Match(r'^([^\'"]|\'(\\.|[^\'])*\'|"(\\.|[^"])*")*//',
+                    matched.group(1))):
+        delimiter = ')' + matched.group(2) + '"'
+
+        end = matched.group(3).find(delimiter)
+        if end >= 0:
+          # Raw string ended on same line
+          line = (matched.group(1) + '""' +
+                  matched.group(3)[end + len(delimiter):])
+          delimiter = None
+        else:
+          # Start of a multi-line raw string
+          line = matched.group(1) + '""'
+      else:
+        break
+
+    lines_without_raw_strings.append(line)
+
+  # TODO(unknown): if delimiter is not None here, we might want to
+  # emit a warning for unterminated string.
+  return lines_without_raw_strings
+
+
+def FindNextMultiLineCommentStart(lines, lineix):
+  """Find the beginning marker for a multiline comment."""
+  while lineix < len(lines):
+    if lines[lineix].strip().startswith('/*'):
+      # Only return this marker if the comment goes beyond this line
+      if lines[lineix].strip().find('*/', 2) < 0:
+        return lineix
+    lineix += 1
+  return len(lines)
+
+
+def FindNextMultiLineCommentEnd(lines, lineix):
+  """We are inside a comment, find the end marker."""
+  while lineix < len(lines):
+    if lines[lineix].strip().endswith('*/'):
+      return lineix
+    lineix += 1
+  return len(lines)
+
+
+def RemoveMultiLineCommentsFromRange(lines, begin, end):
+  """Clears a range of lines for multi-line comments."""
+  # Having // dummy comments makes the lines non-empty, so we will not get
+  # unnecessary blank line warnings later in the code.
+  for i in range(begin, end):
+    lines[i] = '/**/'
+
+
+def RemoveMultiLineComments(filename, lines, error):
+  """Removes multiline (c-style) comments from lines."""
+  lineix = 0
+  while lineix < len(lines):
+    lineix_begin = FindNextMultiLineCommentStart(lines, lineix)
+    if lineix_begin >= len(lines):
+      return
+    lineix_end = FindNextMultiLineCommentEnd(lines, lineix_begin)
+    if lineix_end >= len(lines):
+      error(filename, lineix_begin + 1, 'readability/multiline_comment', 5,
+            'Could not find end of multi-line comment')
+      return
+    RemoveMultiLineCommentsFromRange(lines, lineix_begin, lineix_end + 1)
+    lineix = lineix_end + 1
+
+
+def CleanseComments(line):
+  """Removes //-comments and single-line C-style /* */ comments.
+
+  Args:
+    line: A line of C++ source.
+
+  Returns:
+    The line with single-line comments removed.
+  """
+  commentpos = line.find('//')
+  if commentpos != -1 and not IsCppString(line[:commentpos]):
+    line = line[:commentpos].rstrip()
+  # get rid of /* ... */
+  return _RE_PATTERN_CLEANSE_LINE_C_COMMENTS.sub('', line)
+
+
+class CleansedLines(object):
+  """Holds 4 copies of all lines with different preprocessing applied to them.
+
+  1) elided member contains lines without strings and comments.
+  2) lines member contains lines without comments.
+  3) raw_lines member contains all the lines without processing.
+  4) lines_without_raw_strings member is same as raw_lines, but with C++11 raw
+     strings removed.
+  All these members are of <type 'list'>, and of the same length.
+  """
+
+  def __init__(self, lines):
+    self.elided = []
+    self.lines = []
+    self.raw_lines = lines
+    self.num_lines = len(lines)
+    self.lines_without_raw_strings = CleanseRawStrings(lines)
+    for linenum in range(len(self.lines_without_raw_strings)):
+      self.lines.append(CleanseComments(
+          self.lines_without_raw_strings[linenum]))
+      elided = self._CollapseStrings(self.lines_without_raw_strings[linenum])
+      self.elided.append(CleanseComments(elided))
+
+  def NumLines(self):
+    """Returns the number of lines represented."""
+    return self.num_lines
+
+  @staticmethod
+  def _CollapseStrings(elided):
+    """Collapses strings and chars on a line to simple "" or '' blocks.
+
+    We nix strings first so we're not fooled by text like '"http://"'
+
+    Args:
+      elided: The line being processed.
+
+    Returns:
+      The line with collapsed strings.
+    """
+    if _RE_PATTERN_INCLUDE.match(elided):
+      return elided
+
+    # Remove escaped characters first to make quote/single quote collapsing
+    # basic.  Things that look like escaped characters shouldn't occur
+    # outside of strings and chars.
+    elided = _RE_PATTERN_CLEANSE_LINE_ESCAPES.sub('', elided)
+
+    # Replace quoted strings and digit separators.  Both single quotes
+    # and double quotes are processed in the same loop, otherwise
+    # nested quotes wouldn't work.
+    collapsed = ''
+    while True:
+      # Find the first quote character
+      match = Match(r'^([^\'"]*)([\'"])(.*)$', elided)
+      if not match:
+        collapsed += elided
+        break
+      head, quote, tail = match.groups()
+
+      if quote == '"':
+        # Collapse double quoted strings
+        second_quote = tail.find('"')
+        if second_quote >= 0:
+          collapsed += head + '""'
+          elided = tail[second_quote + 1:]
+        else:
+          # Unmatched double quote, don't bother processing the rest
+          # of the line since this is probably a multiline string.
+          collapsed += elided
+          break
+      else:
+        # Found single quote, check nearby text to eliminate digit separators.
+        #
+        # There is no special handling for floating point here, because
+        # the integer/fractional/exponent parts would all be parsed
+        # correctly as long as there are digits on both sides of the
+        # separator.  So we are fine as long as we don't see something
+        # like "0.'3" (gcc 4.9.0 will not allow this literal).
+        if Search(r'\b(?:0[bBxX]?|[1-9])[0-9a-fA-F]*$', head):
+          match_literal = Match(r'^((?:\'?[0-9a-zA-Z_])*)(.*)$', "'" + tail)
+          collapsed += head + match_literal.group(1).replace("'", '')
+          elided = match_literal.group(2)
+        else:
+          second_quote = tail.find('\'')
+          if second_quote >= 0:
+            collapsed += head + "''"
+            elided = tail[second_quote + 1:]
+          else:
+            # Unmatched single quote
+            collapsed += elided
+            break
+
+    return collapsed
+
+
+def FindEndOfExpressionInLine(line, startpos, stack):
+  """Find the position just after the end of current parenthesized expression.
+
+  Args:
+    line: a CleansedLines line.
+    startpos: start searching at this position.
+    stack: nesting stack at startpos.
+
+  Returns:
+    On finding matching end: (index just after matching end, None)
+    On finding an unclosed expression: (-1, None)
+    Otherwise: (-1, new stack at end of this line)
+  """
+  for i in xrange(startpos, len(line)):
+    char = line[i]
+    if char in '([{':
+      # Found start of parenthesized expression, push to expression stack
+      stack.append(char)
+    elif char == '<':
+      # Found potential start of template argument list
+      if i > 0 and line[i - 1] == '<':
+        # Left shift operator
+        if stack and stack[-1] == '<':
+          stack.pop()
+          if not stack:
+            return (-1, None)
+      elif i > 0 and Search(r'\boperator\s*$', line[0:i]):
+        # operator<, don't add to stack
+        continue
+      else:
+        # Tentative start of template argument list
+        stack.append('<')
+    elif char in ')]}':
+      # Found end of parenthesized expression.
+      #
+      # If we are currently expecting a matching '>', the pending '<'
+      # must have been an operator.  Remove them from expression stack.
+      while stack and stack[-1] == '<':
+        stack.pop()
+      if not stack:
+        return (-1, None)
+      if ((stack[-1] == '(' and char == ')') or
+          (stack[-1] == '[' and char == ']') or
+          (stack[-1] == '{' and char == '}')):
+        stack.pop()
+        if not stack:
+          return (i + 1, None)
+      else:
+        # Mismatched parentheses
+        return (-1, None)
+    elif char == '>':
+      # Found potential end of template argument list.
+
+      # Ignore "->" and operator functions
+      if (i > 0 and
+          (line[i - 1] == '-' or Search(r'\boperator\s*$', line[0:i - 1]))):
+        continue
+
+      # Pop the stack if there is a matching '<'.  Otherwise, ignore
+      # this '>' since it must be an operator.
+      if stack:
+        if stack[-1] == '<':
+          stack.pop()
+          if not stack:
+            return (i + 1, None)
+    elif char == ';':
+      # Found something that look like end of statements.  If we are currently
+      # expecting a '>', the matching '<' must have been an operator, since
+      # template argument list should not contain statements.
+      while stack and stack[-1] == '<':
+        stack.pop()
+      if not stack:
+        return (-1, None)
+
+  # Did not find end of expression or unbalanced parentheses on this line
+  return (-1, stack)
+
+
+def CloseExpression(clean_lines, linenum, pos):
+  """If input points to ( or { or [ or <, finds the position that closes it.
+
+  If lines[linenum][pos] points to a '(' or '{' or '[' or '<', finds the
+  linenum/pos that correspond to the closing of the expression.
+
+  TODO(unknown): cpplint spends a fair bit of time matching parentheses.
+  Ideally we would want to index all opening and closing parentheses once
+  and have CloseExpression be just a simple lookup, but due to preprocessor
+  tricks, this is not so easy.
+
+  Args:
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    pos: A position on the line.
+
+  Returns:
+    A tuple (line, linenum, pos) pointer *past* the closing brace, or
+    (line, len(lines), -1) if we never find a close.  Note we ignore
+    strings and comments when matching; and the line we return is the
+    'cleansed' line at linenum.
+  """
+
+  line = clean_lines.elided[linenum]
+  if (line[pos] not in '({[<') or Match(r'<[<=]', line[pos:]):
+    return (line, clean_lines.NumLines(), -1)
+
+  # Check first line
+  (end_pos, stack) = FindEndOfExpressionInLine(line, pos, [])
+  if end_pos > -1:
+    return (line, linenum, end_pos)
+
+  # Continue scanning forward
+  while stack and linenum < clean_lines.NumLines() - 1:
+    linenum += 1
+    line = clean_lines.elided[linenum]
+    (end_pos, stack) = FindEndOfExpressionInLine(line, 0, stack)
+    if end_pos > -1:
+      return (line, linenum, end_pos)
+
+  # Did not find end of expression before end of file, give up
+  return (line, clean_lines.NumLines(), -1)
+
+
+def FindStartOfExpressionInLine(line, endpos, stack):
+  """Find position at the matching start of current expression.
+
+  This is almost the reverse of FindEndOfExpressionInLine, but note
+  that the input position and returned position differs by 1.
+
+  Args:
+    line: a CleansedLines line.
+    endpos: start searching at this position.
+    stack: nesting stack at endpos.
+
+  Returns:
+    On finding matching start: (index at matching start, None)
+    On finding an unclosed expression: (-1, None)
+    Otherwise: (-1, new stack at beginning of this line)
+  """
+  i = endpos
+  while i >= 0:
+    char = line[i]
+    if char in ')]}':
+      # Found end of expression, push to expression stack
+      stack.append(char)
+    elif char == '>':
+      # Found potential end of template argument list.
+      #
+      # Ignore it if it's a "->" or ">=" or "operator>"
+      if (i > 0 and
+          (line[i - 1] == '-' or
+           Match(r'\s>=\s', line[i - 1:]) or
+           Search(r'\boperator\s*$', line[0:i]))):
+        i -= 1
+      else:
+        stack.append('>')
+    elif char == '<':
+      # Found potential start of template argument list
+      if i > 0 and line[i - 1] == '<':
+        # Left shift operator
+        i -= 1
+      else:
+        # If there is a matching '>', we can pop the expression stack.
+        # Otherwise, ignore this '<' since it must be an operator.
+        if stack and stack[-1] == '>':
+          stack.pop()
+          if not stack:
+            return (i, None)
+    elif char in '([{':
+      # Found start of expression.
+      #
+      # If there are any unmatched '>' on the stack, they must be
+      # operators.  Remove those.
+      while stack and stack[-1] == '>':
+        stack.pop()
+      if not stack:
+        return (-1, None)
+      if ((char == '(' and stack[-1] == ')') or
+          (char == '[' and stack[-1] == ']') or
+          (char == '{' and stack[-1] == '}')):
+        stack.pop()
+        if not stack:
+          return (i, None)
+      else:
+        # Mismatched parentheses
+        return (-1, None)
+    elif char == ';':
+      # Found something that look like end of statements.  If we are currently
+      # expecting a '<', the matching '>' must have been an operator, since
+      # template argument list should not contain statements.
+      while stack and stack[-1] == '>':
+        stack.pop()
+      if not stack:
+        return (-1, None)
+
+    i -= 1
+
+  return (-1, stack)
+
+
+def ReverseCloseExpression(clean_lines, linenum, pos):
+  """If input points to ) or } or ] or >, finds the position that opens it.
+
+  If lines[linenum][pos] points to a ')' or '}' or ']' or '>', finds the
+  linenum/pos that correspond to the opening of the expression.
+
+  Args:
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    pos: A position on the line.
+
+  Returns:
+    A tuple (line, linenum, pos) pointer *at* the opening brace, or
+    (line, 0, -1) if we never find the matching opening brace.  Note
+    we ignore strings and comments when matching; and the line we
+    return is the 'cleansed' line at linenum.
+  """
+  line = clean_lines.elided[linenum]
+  if line[pos] not in ')}]>':
+    return (line, 0, -1)
+
+  # Check last line
+  (start_pos, stack) = FindStartOfExpressionInLine(line, pos, [])
+  if start_pos > -1:
+    return (line, linenum, start_pos)
+
+  # Continue scanning backward
+  while stack and linenum > 0:
+    linenum -= 1
+    line = clean_lines.elided[linenum]
+    (start_pos, stack) = FindStartOfExpressionInLine(line, len(line) - 1, stack)
+    if start_pos > -1:
+      return (line, linenum, start_pos)
+
+  # Did not find start of expression before beginning of file, give up
+  return (line, 0, -1)
+
+
+def CheckForCopyright(filename, lines, error):
+  """Logs an error if no Copyright message appears at the top of the file."""
+
+  # We'll say it should occur by line 10. Don't forget there's a
+  # dummy line at the front.
+  for line in range(1, min(len(lines), 11)):
+    if re.search(r'Copyright', lines[line], re.I): break
+  else:                       # means no copyright line was found
+    error(filename, 0, 'legal/copyright', 5,
+          'No copyright message found.  '
+          'You should have a line: "Copyright [year] <Copyright Owner>"')
+
+
+def GetIndentLevel(line):
+  """Return the number of leading spaces in line.
+
+  Args:
+    line: A string to check.
+
+  Returns:
+    An integer count of leading spaces, possibly zero.
+  """
+  indent = Match(r'^( *)\S', line)
+  if indent:
+    return len(indent.group(1))
+  else:
+    return 0
+
+
+def GetHeaderGuardCPPVariable(filename):
+  """Returns the CPP variable that should be used as a header guard.
+
+  Args:
+    filename: The name of a C++ header file.
+
+  Returns:
+    The CPP variable that should be used as a header guard in the
+    named file.
+
+  """
+
+  # Restores original filename in case that cpplint is invoked from Emacs's
+  # flymake.
+  filename = re.sub(r'_flymake\.h$', '.h', filename)
+  filename = re.sub(r'/\.flymake/([^/]*)$', r'/\1', filename)
+  # Replace 'c++' with 'cpp'.
+  filename = filename.replace('C++', 'cpp').replace('c++', 'cpp')
+
+  fileinfo = FileInfo(filename)
+  file_path_from_root = fileinfo.RepositoryName()
+  if _root:
+    suffix = os.sep
+    # On Windows using directory separator will leave us with
+    # "bogus escape error" unless we properly escape regex.
+    if suffix == '\\':
+      suffix += '\\'
+    file_path_from_root = re.sub('^' + _root + suffix, '', file_path_from_root)
+  return re.sub(r'[^a-zA-Z0-9]', '_', file_path_from_root).upper() + '_'
+
+
+def CheckForHeaderGuard(filename, clean_lines, error):
+  """Checks that the file contains a header guard.
+
+  Logs an error if no #ifndef header guard is present.  For other
+  headers, checks that the full pathname is used.
+
+  Args:
+    filename: The name of the C++ header file.
+    clean_lines: A CleansedLines instance containing the file.
+    error: The function to call with any errors found.
+  """
+
+  # Don't check for header guards if there are error suppression
+  # comments somewhere in this file.
+  #
+  # Because this is silencing a warning for a nonexistent line, we
+  # only support the very specific NOLINT(build/header_guard) syntax,
+  # and not the general NOLINT or NOLINT(*) syntax.
+  raw_lines = clean_lines.lines_without_raw_strings
+  for i in raw_lines:
+    if Search(r'//\s*NOLINT\(build/header_guard\)', i):
+      return
+
+  # Allow pragma once instead of header guards
+  for i in raw_lines:
+    if Search(r'^\s*#pragma\s+once', i):
+      return
+
+  cppvar = GetHeaderGuardCPPVariable(filename)
+
+  ifndef = ''
+  ifndef_linenum = 0
+  define = ''
+  endif = ''
+  endif_linenum = 0
+  for linenum, line in enumerate(raw_lines):
+    linesplit = line.split()
+    if len(linesplit) >= 2:
+      # find the first occurrence of #ifndef and #define, save arg
+      if not ifndef and linesplit[0] == '#ifndef':
+        # set ifndef to the header guard presented on the #ifndef line.
+        ifndef = linesplit[1]
+        ifndef_linenum = linenum
+      if not define and linesplit[0] == '#define':
+        define = linesplit[1]
+    # find the last occurrence of #endif, save entire line
+    if line.startswith('#endif'):
+      endif = line
+      endif_linenum = linenum
+
+  if not ifndef or not define or ifndef != define:
+    error(filename, 0, 'build/header_guard', 5,
+          'No #ifndef header guard found, suggested CPP variable is: %s' %
+          cppvar)
+    return
+
+  # The guard should be PATH_FILE_H_, but we also allow PATH_FILE_H__
+  # for backward compatibility.
+  if ifndef != cppvar:
+    error_level = 0
+    if ifndef != cppvar + '_':
+      error_level = 5
+
+    ParseNolintSuppressions(filename, raw_lines[ifndef_linenum], ifndef_linenum,
+                            error)
+    error(filename, ifndef_linenum, 'build/header_guard', error_level,
+          '#ifndef header guard has wrong style, please use: %s' % cppvar)
+
+  # Check for "//" comments on endif line.
+  ParseNolintSuppressions(filename, raw_lines[endif_linenum], endif_linenum,
+                          error)
+  match = Match(r'#endif\s*//\s*' + cppvar + r'(_)?\b', endif)
+  if match:
+    if match.group(1) == '_':
+      # Issue low severity warning for deprecated double trailing underscore
+      error(filename, endif_linenum, 'build/header_guard', 0,
+            '#endif line should be "#endif  // %s"' % cppvar)
+    return
+
+  # Didn't find the corresponding "//" comment.  If this file does not
+  # contain any "//" comments at all, it could be that the compiler
+  # only wants "/**/" comments, look for those instead.
+  no_single_line_comments = True
+  for i in xrange(1, len(raw_lines) - 1):
+    line = raw_lines[i]
+    if Match(r'^(?:(?:\'(?:\.|[^\'])*\')|(?:"(?:\.|[^"])*")|[^\'"])*//', line):
+      no_single_line_comments = False
+      break
+
+  if no_single_line_comments:
+    match = Match(r'#endif\s*/\*\s*' + cppvar + r'(_)?\s*\*/', endif)
+    if match:
+      if match.group(1) == '_':
+        # Low severity warning for double trailing underscore
+        error(filename, endif_linenum, 'build/header_guard', 0,
+              '#endif line should be "#endif  /* %s */"' % cppvar)
+      return
+
+  # Didn't find anything
+  error(filename, endif_linenum, 'build/header_guard', 5,
+        '#endif line should be "#endif  // %s"' % cppvar)
+
+
+def CheckHeaderFileIncluded(filename, include_state, error):
+  """Logs an error if a source file does not include its header."""
+
+  # Do not check test files
+  fileinfo = FileInfo(filename)
+  if Search(_TEST_FILE_SUFFIX, fileinfo.BaseName()):
+    return
+
+  for ext in GetHeaderExtensions():
+      basefilename = filename[0:len(filename) - len(fileinfo.Extension())]
+      headerfile = basefilename + '.' + ext
+      if not os.path.exists(headerfile):
+        continue
+      headername = FileInfo(headerfile).RepositoryName()
+      first_include = None
+      for section_list in include_state.include_list:
+        for f in section_list:
+          if headername in f[0] or f[0] in headername:
+            return
+          if not first_include:
+            first_include = f[1]
+
+      error(filename, first_include, 'build/include', 5,
+            '%s should include its header file %s' % (fileinfo.RepositoryName(),
+                                                      headername))
+
+
+def CheckForBadCharacters(filename, lines, error):
+  """Logs an error for each line containing bad characters.
+
+  Two kinds of bad characters:
+
+  1. Unicode replacement characters: These indicate that either the file
+  contained invalid UTF-8 (likely) or Unicode replacement characters (which
+  it shouldn't).  Note that it's possible for this to throw off line
+  numbering if the invalid UTF-8 occurred adjacent to a newline.
+
+  2. NUL bytes.  These are problematic for some tools.
+
+  Args:
+    filename: The name of the current file.
+    lines: An array of strings, each representing a line of the file.
+    error: The function to call with any errors found.
+  """
+  for linenum, line in enumerate(lines):
+    if unicode_escape_decode('\ufffd') in line:
+      error(filename, linenum, 'readability/utf8', 5,
+            'Line contains invalid UTF-8 (or Unicode replacement character).')
+    if '\0' in line:
+      error(filename, linenum, 'readability/nul', 5, 'Line contains NUL byte.')
+
+
+def CheckForNewlineAtEOF(filename, lines, error):
+  """Logs an error if there is no newline char at the end of the file.
+
+  Args:
+    filename: The name of the current file.
+    lines: An array of strings, each representing a line of the file.
+    error: The function to call with any errors found.
+  """
+
+  # The array lines() was created by adding two newlines to the
+  # original file (go figure), then splitting on \n.
+  # To verify that the file ends in \n, we just have to make sure the
+  # last-but-two element of lines() exists and is empty.
+  if len(lines) < 3 or lines[-2]:
+    error(filename, len(lines) - 2, 'whitespace/ending_newline', 5,
+          'Could not find a newline character at the end of the file.')
+
+
+def CheckForMultilineCommentsAndStrings(filename, clean_lines, linenum, error):
+  """Logs an error if we see /* ... */ or "..." that extend past one line.
+
+  /* ... */ comments are legit inside macros, for one line.
+  Otherwise, we prefer // comments, so it's ok to warn about the
+  other.  Likewise, it's ok for strings to extend across multiple
+  lines, as long as a line continuation character (backslash)
+  terminates each line. Although not currently prohibited by the C++
+  style guide, it's ugly and unnecessary. We don't do well with either
+  in this lint program, so we warn about both.
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    error: The function to call with any errors found.
+  """
+  line = clean_lines.elided[linenum]
+
+  # Remove all \\ (escaped backslashes) from the line. They are OK, and the
+  # second (escaped) slash may trigger later \" detection erroneously.
+  line = line.replace('\\\\', '')
+
+  if line.count('/*') > line.count('*/'):
+    error(filename, linenum, 'readability/multiline_comment', 5,
+          'Complex multi-line /*...*/-style comment found. '
+          'Lint may give bogus warnings.  '
+          'Consider replacing these with //-style comments, '
+          'with #if 0...#endif, '
+          'or with more clearly structured multi-line comments.')
+
+  if (line.count('"') - line.count('\\"')) % 2:
+    error(filename, linenum, 'readability/multiline_string', 5,
+          'Multi-line string ("...") found.  This lint script doesn\'t '
+          'do well with such strings, and may give bogus warnings.  '
+          'Use C++11 raw strings or concatenation instead.')
+
+
+# (non-threadsafe name, thread-safe alternative, validation pattern)
+#
+# The validation pattern is used to eliminate false positives such as:
+#  _rand();               // false positive due to substring match.
+#  ->rand();              // some member function rand().
+#  ACMRandom rand(seed);  // some variable named rand.
+#  ISAACRandom rand();    // another variable named rand.
+#
+# Basically we require the return value of these functions to be used
+# in some expression context on the same line by matching on some
+# operator before the function name.  This eliminates constructors and
+# member function calls.
+_UNSAFE_FUNC_PREFIX = r'(?:[-+*/=%^&|(<]\s*|>\s+)'
+_THREADING_LIST = (
+    ('asctime(', 'asctime_r(', _UNSAFE_FUNC_PREFIX + r'asctime\([^)]+\)'),
+    ('ctime(', 'ctime_r(', _UNSAFE_FUNC_PREFIX + r'ctime\([^)]+\)'),
+    ('getgrgid(', 'getgrgid_r(', _UNSAFE_FUNC_PREFIX + r'getgrgid\([^)]+\)'),
+    ('getgrnam(', 'getgrnam_r(', _UNSAFE_FUNC_PREFIX + r'getgrnam\([^)]+\)'),
+    ('getlogin(', 'getlogin_r(', _UNSAFE_FUNC_PREFIX + r'getlogin\(\)'),
+    ('getpwnam(', 'getpwnam_r(', _UNSAFE_FUNC_PREFIX + r'getpwnam\([^)]+\)'),
+    ('getpwuid(', 'getpwuid_r(', _UNSAFE_FUNC_PREFIX + r'getpwuid\([^)]+\)'),
+    ('gmtime(', 'gmtime_r(', _UNSAFE_FUNC_PREFIX + r'gmtime\([^)]+\)'),
+    ('localtime(', 'localtime_r(', _UNSAFE_FUNC_PREFIX + r'localtime\([^)]+\)'),
+    ('rand(', 'rand_r(', _UNSAFE_FUNC_PREFIX + r'rand\(\)'),
+    ('strtok(', 'strtok_r(',
+     _UNSAFE_FUNC_PREFIX + r'strtok\([^)]+\)'),
+    ('ttyname(', 'ttyname_r(', _UNSAFE_FUNC_PREFIX + r'ttyname\([^)]+\)'),
+    )
+
+
+def CheckPosixThreading(filename, clean_lines, linenum, error):
+  """Checks for calls to thread-unsafe functions.
+
+  Much code has been originally written without consideration of
+  multi-threading. Also, engineers are relying on their old experience;
+  they have learned posix before threading extensions were added. These
+  tests guide the engineers to use thread-safe functions (when using
+  posix directly).
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    error: The function to call with any errors found.
+  """
+  line = clean_lines.elided[linenum]
+  for single_thread_func, multithread_safe_func, pattern in _THREADING_LIST:
+    # Additional pattern matching check to confirm that this is the
+    # function we are looking for
+    if Search(pattern, line):
+      error(filename, linenum, 'runtime/threadsafe_fn', 2,
+            'Consider using ' + multithread_safe_func +
+            '...) instead of ' + single_thread_func +
+            '...) for improved thread safety.')
+
+
+def CheckVlogArguments(filename, clean_lines, linenum, error):
+  """Checks that VLOG() is only used for defining a logging level.
+
+  For example, VLOG(2) is correct. VLOG(INFO), VLOG(WARNING), VLOG(ERROR), and
+  VLOG(FATAL) are not.
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    error: The function to call with any errors found.
+  """
+  line = clean_lines.elided[linenum]
+  if Search(r'\bVLOG\((INFO|ERROR|WARNING|DFATAL|FATAL)\)', line):
+    error(filename, linenum, 'runtime/vlog', 5,
+          'VLOG() should be used with numeric verbosity level.  '
+          'Use LOG() if you want symbolic severity levels.')
+
+# Matches invalid increment: *count++, which moves pointer instead of
+# incrementing a value.
+_RE_PATTERN_INVALID_INCREMENT = re.compile(
+    r'^\s*\*\w+(\+\+|--);')
+
+
+def CheckInvalidIncrement(filename, clean_lines, linenum, error):
+  """Checks for invalid increment *count++.
+
+  For example following function:
+  void increment_counter(int* count) {
+    *count++;
+  }
+  is invalid, because it effectively does count++, moving pointer, and should
+  be replaced with ++*count, (*count)++ or *count += 1.
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    error: The function to call with any errors found.
+  """
+  line = clean_lines.elided[linenum]
+  if _RE_PATTERN_INVALID_INCREMENT.match(line):
+    error(filename, linenum, 'runtime/invalid_increment', 5,
+          'Changing pointer instead of value (or unused value of operator*).')
+
+
+def IsMacroDefinition(clean_lines, linenum):
+  if Search(r'^#define', clean_lines[linenum]):
+    return True
+
+  if linenum > 0 and Search(r'\\$', clean_lines[linenum - 1]):
+    return True
+
+  return False
+
+
+def IsForwardClassDeclaration(clean_lines, linenum):
+  return Match(r'^\s*(\btemplate\b)*.*class\s+\w+;\s*$', clean_lines[linenum])
+
+
+class _BlockInfo(object):
+  """Stores information about a generic block of code."""
+
+  def __init__(self, linenum, seen_open_brace):
+    self.starting_linenum = linenum
+    self.seen_open_brace = seen_open_brace
+    self.open_parentheses = 0
+    self.inline_asm = _NO_ASM
+    self.check_namespace_indentation = False
+
+  def CheckBegin(self, filename, clean_lines, linenum, error):
+    """Run checks that applies to text up to the opening brace.
+
+    This is mostly for checking the text after the class identifier
+    and the "{", usually where the base class is specified.  For other
+    blocks, there isn't much to check, so we always pass.
+
+    Args:
+      filename: The name of the current file.
+      clean_lines: A CleansedLines instance containing the file.
+      linenum: The number of the line to check.
+      error: The function to call with any errors found.
+    """
+    pass
+
+  def CheckEnd(self, filename, clean_lines, linenum, error):
+    """Run checks that applies to text after the closing brace.
+
+    This is mostly used for checking end of namespace comments.
+
+    Args:
+      filename: The name of the current file.
+      clean_lines: A CleansedLines instance containing the file.
+      linenum: The number of the line to check.
+      error: The function to call with any errors found.
+    """
+    pass
+
+  def IsBlockInfo(self):
+    """Returns true if this block is a _BlockInfo.
+
+    This is convenient for verifying that an object is an instance of
+    a _BlockInfo, but not an instance of any of the derived classes.
+
+    Returns:
+      True for this class, False for derived classes.
+    """
+    return self.__class__ == _BlockInfo
+
+
+class _ExternCInfo(_BlockInfo):
+  """Stores information about an 'extern "C"' block."""
+
+  def __init__(self, linenum):
+    _BlockInfo.__init__(self, linenum, True)
+
+
+class _ClassInfo(_BlockInfo):
+  """Stores information about a class."""
+
+  def __init__(self, name, class_or_struct, clean_lines, linenum):
+    _BlockInfo.__init__(self, linenum, False)
+    self.name = name
+    self.is_derived = False
+    self.check_namespace_indentation = True
+    if class_or_struct == 'struct':
+      self.access = 'public'
+      self.is_struct = True
+    else:
+      self.access = 'private'
+      self.is_struct = False
+
+    # Remember initial indentation level for this class.  Using raw_lines here
+    # instead of elided to account for leading comments.
+    self.class_indent = GetIndentLevel(clean_lines.raw_lines[linenum])
+
+    # Try to find the end of the class.  This will be confused by things like:
+    #   class A {
+    #   } *x = { ...
+    #
+    # But it's still good enough for CheckSectionSpacing.
+    self.last_line = 0
+    depth = 0
+    for i in range(linenum, clean_lines.NumLines()):
+      line = clean_lines.elided[i]
+      depth += line.count('{') - line.count('}')
+      if not depth:
+        self.last_line = i
+        break
+
+  def CheckBegin(self, filename, clean_lines, linenum, error):
+    # Look for a bare ':'
+    if Search('(^|[^:]):($|[^:])', clean_lines.elided[linenum]):
+      self.is_derived = True
+
+  def CheckEnd(self, filename, clean_lines, linenum, error):
+    # If there is a DISALLOW macro, it should appear near the end of
+    # the class.
+    seen_last_thing_in_class = False
+    for i in xrange(linenum - 1, self.starting_linenum, -1):
+      match = Search(
+          r'\b(DISALLOW_COPY_AND_ASSIGN|DISALLOW_IMPLICIT_CONSTRUCTORS)\(' +
+          self.name + r'\)',
+          clean_lines.elided[i])
+      if match:
+        if seen_last_thing_in_class:
+          error(filename, i, 'readability/constructors', 3,
+                match.group(1) + ' should be the last thing in the class')
+        break
+
+      if not Match(r'^\s*$', clean_lines.elided[i]):
+        seen_last_thing_in_class = True
+
+    # Check that closing brace is aligned with beginning of the class.
+    # Only do this if the closing brace is indented by only whitespaces.
+    # This means we will not check single-line class definitions.
+    indent = Match(r'^( *)\}', clean_lines.elided[linenum])
+    if indent and len(indent.group(1)) != self.class_indent:
+      if self.is_struct:
+        parent = 'struct ' + self.name
+      else:
+        parent = 'class ' + self.name
+      error(filename, linenum, 'whitespace/indent', 3,
+            'Closing brace should be aligned with beginning of %s' % parent)
+
+
+class _NamespaceInfo(_BlockInfo):
+  """Stores information about a namespace."""
+
+  def __init__(self, name, linenum):
+    _BlockInfo.__init__(self, linenum, False)
+    self.name = name or ''
+    self.check_namespace_indentation = True
+
+  def CheckEnd(self, filename, clean_lines, linenum, error):
+    """Check end of namespace comments."""
+    line = clean_lines.raw_lines[linenum]
+
+    # Check how many lines is enclosed in this namespace.  Don't issue
+    # warning for missing namespace comments if there aren't enough
+    # lines.  However, do apply checks if there is already an end of
+    # namespace comment and it's incorrect.
+    #
+    # TODO(unknown): We always want to check end of namespace comments
+    # if a namespace is large, but sometimes we also want to apply the
+    # check if a short namespace contained nontrivial things (something
+    # other than forward declarations).  There is currently no logic on
+    # deciding what these nontrivial things are, so this check is
+    # triggered by namespace size only, which works most of the time.
+    if (linenum - self.starting_linenum < 10
+        and not Match(r'^\s*};*\s*(//|/\*).*\bnamespace\b', line)):
+      return
+
+    # Look for matching comment at end of namespace.
+    #
+    # Note that we accept C style "/* */" comments for terminating
+    # namespaces, so that code that terminate namespaces inside
+    # preprocessor macros can be cpplint clean.
+    #
+    # We also accept stuff like "// end of namespace <name>." with the
+    # period at the end.
+    #
+    # Besides these, we don't accept anything else, otherwise we might
+    # get false negatives when existing comment is a substring of the
+    # expected namespace.
+    if self.name:
+      # Named namespace
+      if not Match((r'^\s*};*\s*(//|/\*).*\bnamespace\s+' +
+                    re.escape(self.name) + r'[\*/\.\\\s]*$'),
+                   line):
+        error(filename, linenum, 'readability/namespace', 5,
+              'Namespace should be terminated with "// namespace %s"' %
+              self.name)
+    else:
+      # Anonymous namespace
+      if not Match(r'^\s*};*\s*(//|/\*).*\bnamespace[\*/\.\\\s]*$', line):
+        # If "// namespace anonymous" or "// anonymous namespace (more text)",
+        # mention "// anonymous namespace" as an acceptable form
+        if Match(r'^\s*}.*\b(namespace anonymous|anonymous namespace)\b', line):
+          error(filename, linenum, 'readability/namespace', 5,
+                'Anonymous namespace should be terminated with "// namespace"'
+                ' or "// anonymous namespace"')
+        else:
+          error(filename, linenum, 'readability/namespace', 5,
+                'Anonymous namespace should be terminated with "// namespace"')
+
+
+class _PreprocessorInfo(object):
+  """Stores checkpoints of nesting stacks when #if/#else is seen."""
+
+  def __init__(self, stack_before_if):
+    # The entire nesting stack before #if
+    self.stack_before_if = stack_before_if
+
+    # The entire nesting stack up to #else
+    self.stack_before_else = []
+
+    # Whether we have already seen #else or #elif
+    self.seen_else = False
+
+
+class NestingState(object):
+  """Holds states related to parsing braces."""
+
+  def __init__(self):
+    # Stack for tracking all braces.  An object is pushed whenever we
+    # see a "{", and popped when we see a "}".  Only 3 types of
+    # objects are possible:
+    # - _ClassInfo: a class or struct.
+    # - _NamespaceInfo: a namespace.
+    # - _BlockInfo: some other type of block.
+    self.stack = []
+
+    # Top of the previous stack before each Update().
+    #
+    # Because the nesting_stack is updated at the end of each line, we
+    # had to do some convoluted checks to find out what is the current
+    # scope at the beginning of the line.  This check is simplified by
+    # saving the previous top of nesting stack.
+    #
+    # We could save the full stack, but we only need the top.  Copying
+    # the full nesting stack would slow down cpplint by ~10%.
+    self.previous_stack_top = []
+
+    # Stack of _PreprocessorInfo objects.
+    self.pp_stack = []
+
+  def SeenOpenBrace(self):
+    """Check if we have seen the opening brace for the innermost block.
+
+    Returns:
+      True if we have seen the opening brace, False if the innermost
+      block is still expecting an opening brace.
+    """
+    return (not self.stack) or self.stack[-1].seen_open_brace
+
+  def InNamespaceBody(self):
+    """Check if we are currently one level inside a namespace body.
+
+    Returns:
+      True if top of the stack is a namespace block, False otherwise.
+    """
+    return self.stack and isinstance(self.stack[-1], _NamespaceInfo)
+
+  def InExternC(self):
+    """Check if we are currently one level inside an 'extern "C"' block.
+
+    Returns:
+      True if top of the stack is an extern block, False otherwise.
+    """
+    return self.stack and isinstance(self.stack[-1], _ExternCInfo)
+
+  def InClassDeclaration(self):
+    """Check if we are currently one level inside a class or struct declaration.
+
+    Returns:
+      True if top of the stack is a class/struct, False otherwise.
+    """
+    return self.stack and isinstance(self.stack[-1], _ClassInfo)
+
+  def InAsmBlock(self):
+    """Check if we are currently one level inside an inline ASM block.
+
+    Returns:
+      True if the top of the stack is a block containing inline ASM.
+    """
+    return self.stack and self.stack[-1].inline_asm != _NO_ASM
+
+  def InTemplateArgumentList(self, clean_lines, linenum, pos):
+    """Check if current position is inside template argument list.
+
+    Args:
+      clean_lines: A CleansedLines instance containing the file.
+      linenum: The number of the line to check.
+      pos: position just after the suspected template argument.
+    Returns:
+      True if (linenum, pos) is inside template arguments.
+    """
+    while linenum < clean_lines.NumLines():
+      # Find the earliest character that might indicate a template argument
+      line = clean_lines.elided[linenum]
+      match = Match(r'^[^{};=\[\]\.<>]*(.)', line[pos:])
+      if not match:
+        linenum += 1
+        pos = 0
+        continue
+      token = match.group(1)
+      pos += len(match.group(0))
+
+      # These things do not look like template argument list:
+      #   class Suspect {
+      #   class Suspect x; }
+      if token in ('{', '}', ';'): return False
+
+      # These things look like template argument list:
+      #   template <class Suspect>
+      #   template <class Suspect = default_value>
+      #   template <class Suspect[]>
+      #   template <class Suspect...>
+      if token in ('>', '=', '[', ']', '.'): return True
+
+      # Check if token is an unmatched '<'.
+      # If not, move on to the next character.
+      if token != '<':
+        pos += 1
+        if pos >= len(line):
+          linenum += 1
+          pos = 0
+        continue
+
+      # We can't be sure if we just find a single '<', and need to
+      # find the matching '>'.
+      (_, end_line, end_pos) = CloseExpression(clean_lines, linenum, pos - 1)
+      if end_pos < 0:
+        # Not sure if template argument list or syntax error in file
+        return False
+      linenum = end_line
+      pos = end_pos
+    return False
+
+  def UpdatePreprocessor(self, line):
+    """Update preprocessor stack.
+
+    We need to handle preprocessors due to classes like this:
+      #ifdef SWIG
+      struct ResultDetailsPageElementExtensionPoint {
+      #else
+      struct ResultDetailsPageElementExtensionPoint : public Extension {
+      #endif
+
+    We make the following assumptions (good enough for most files):
+    - Preprocessor condition evaluates to true from #if up to first
+      #else/#elif/#endif.
+
+    - Preprocessor condition evaluates to false from #else/#elif up
+      to #endif.  We still perform lint checks on these lines, but
+      these do not affect nesting stack.
+
+    Args:
+      line: current line to check.
+    """
+    if Match(r'^\s*#\s*(if|ifdef|ifndef)\b', line):
+      # Beginning of #if block, save the nesting stack here.  The saved
+      # stack will allow us to restore the parsing state in the #else case.
+      self.pp_stack.append(_PreprocessorInfo(copy.deepcopy(self.stack)))
+    elif Match(r'^\s*#\s*(else|elif)\b', line):
+      # Beginning of #else block
+      if self.pp_stack:
+        if not self.pp_stack[-1].seen_else:
+          # This is the first #else or #elif block.  Remember the
+          # whole nesting stack up to this point.  This is what we
+          # keep after the #endif.
+          self.pp_stack[-1].seen_else = True
+          self.pp_stack[-1].stack_before_else = copy.deepcopy(self.stack)
+
+        # Restore the stack to how it was before the #if
+        self.stack = copy.deepcopy(self.pp_stack[-1].stack_before_if)
+      else:
+        # TODO(unknown): unexpected #else, issue warning?
+        pass
+    elif Match(r'^\s*#\s*endif\b', line):
+      # End of #if or #else blocks.
+      if self.pp_stack:
+        # If we saw an #else, we will need to restore the nesting
+        # stack to its former state before the #else, otherwise we
+        # will just continue from where we left off.
+        if self.pp_stack[-1].seen_else:
+          # Here we can just use a shallow copy since we are the last
+          # reference to it.
+          self.stack = self.pp_stack[-1].stack_before_else
+        # Drop the corresponding #if
+        self.pp_stack.pop()
+      else:
+        # TODO(unknown): unexpected #endif, issue warning?
+        pass
+
+  # TODO(unknown): Update() is too long, but we will refactor later.
+  def Update(self, filename, clean_lines, linenum, error):
+    """Update nesting state with current line.
+
+    Args:
+      filename: The name of the current file.
+      clean_lines: A CleansedLines instance containing the file.
+      linenum: The number of the line to check.
+      error: The function to call with any errors found.
+    """
+    line = clean_lines.elided[linenum]
+
+    # Remember top of the previous nesting stack.
+    #
+    # The stack is always pushed/popped and not modified in place, so
+    # we can just do a shallow copy instead of copy.deepcopy.  Using
+    # deepcopy would slow down cpplint by ~28%.
+    if self.stack:
+      self.previous_stack_top = self.stack[-1]
+    else:
+      self.previous_stack_top = None
+
+    # Update pp_stack
+    self.UpdatePreprocessor(line)
+
+    # Count parentheses.  This is to avoid adding struct arguments to
+    # the nesting stack.
+    if self.stack:
+      inner_block = self.stack[-1]
+      depth_change = line.count('(') - line.count(')')
+      inner_block.open_parentheses += depth_change
+
+      # Also check if we are starting or ending an inline assembly block.
+      if inner_block.inline_asm in (_NO_ASM, _END_ASM):
+        if (depth_change != 0 and
+            inner_block.open_parentheses == 1 and
+            _MATCH_ASM.match(line)):
+          # Enter assembly block
+          inner_block.inline_asm = _INSIDE_ASM
+        else:
+          # Not entering assembly block.  If previous line was _END_ASM,
+          # we will now shift to _NO_ASM state.
+          inner_block.inline_asm = _NO_ASM
+      elif (inner_block.inline_asm == _INSIDE_ASM and
+            inner_block.open_parentheses == 0):
+        # Exit assembly block
+        inner_block.inline_asm = _END_ASM
+
+    # Consume namespace declaration at the beginning of the line.  Do
+    # this in a loop so that we catch same line declarations like this:
+    #   namespace proto2 { namespace bridge { class MessageSet; } }
+    while True:
+      # Match start of namespace.  The "\b\s*" below catches namespace
+      # declarations even if it weren't followed by a whitespace, this
+      # is so that we don't confuse our namespace checker.  The
+      # missing spaces will be flagged by CheckSpacing.
+      namespace_decl_match = Match(r'^\s*namespace\b\s*([:\w]+)?(.*)$', line)
+      if not namespace_decl_match:
+        break
+
+      new_namespace = _NamespaceInfo(namespace_decl_match.group(1), linenum)
+      self.stack.append(new_namespace)
+
+      line = namespace_decl_match.group(2)
+      if line.find('{') != -1:
+        new_namespace.seen_open_brace = True
+        line = line[line.find('{') + 1:]
+
+    # Look for a class declaration in whatever is left of the line
+    # after parsing namespaces.  The regexp accounts for decorated classes
+    # such as in:
+    #   class LOCKABLE API Object {
+    #   };
+    class_decl_match = Match(
+        r'^(\s*(?:template\s*<[\w\s<>,:=]*>\s*)?'
+        r'(class|struct)\s+(?:[A-Z_]+\s+)*(\w+(?:::\w+)*))'
+        r'(.*)$', line)
+    if (class_decl_match and
+        (not self.stack or self.stack[-1].open_parentheses == 0)):
+      # We do not want to accept classes that are actually template arguments:
+      #   template <class Ignore1,
+      #             class Ignore2 = Default<Args>,
+      #             template <Args> class Ignore3>
+      #   void Function() {};
+      #
+      # To avoid template argument cases, we scan forward and look for
+      # an unmatched '>'.  If we see one, assume we are inside a
+      # template argument list.
+      end_declaration = len(class_decl_match.group(1))
+      if not self.InTemplateArgumentList(clean_lines, linenum, end_declaration):
+        self.stack.append(_ClassInfo(
+            class_decl_match.group(3), class_decl_match.group(2),
+            clean_lines, linenum))
+        line = class_decl_match.group(4)
+
+    # If we have not yet seen the opening brace for the innermost block,
+    # run checks here.
+    if not self.SeenOpenBrace():
+      self.stack[-1].CheckBegin(filename, clean_lines, linenum, error)
+
+    # Update access control if we are inside a class/struct
+    if self.stack and isinstance(self.stack[-1], _ClassInfo):
+      classinfo = self.stack[-1]
+      access_match = Match(
+          r'^(.*)\b(public|private|protected|signals)(\s+(?:slots\s*)?)?'
+          r':(?:[^:]|$)',
+          line)
+      if access_match:
+        classinfo.access = access_match.group(2)
+
+        # Check that access keywords are indented +1 space.  Skip this
+        # check if the keywords are not preceded by whitespaces.
+        indent = access_match.group(1)
+        if (len(indent) != classinfo.class_indent + 1 and
+            Match(r'^\s*$', indent)):
+          if classinfo.is_struct:
+            parent = 'struct ' + classinfo.name
+          else:
+            parent = 'class ' + classinfo.name
+          slots = ''
+          if access_match.group(3):
+            slots = access_match.group(3)
+          error(filename, linenum, 'whitespace/indent', 3,
+                '%s%s: should be indented +1 space inside %s' % (
+                    access_match.group(2), slots, parent))
+
+    # Consume braces or semicolons from what's left of the line
+    while True:
+      # Match first brace, semicolon, or closed parenthesis.
+      matched = Match(r'^[^{;)}]*([{;)}])(.*)$', line)
+      if not matched:
+        break
+
+      token = matched.group(1)
+      if token == '{':
+        # If namespace or class hasn't seen a opening brace yet, mark
+        # namespace/class head as complete.  Push a new block onto the
+        # stack otherwise.
+        if not self.SeenOpenBrace():
+          self.stack[-1].seen_open_brace = True
+        elif Match(r'^extern\s*"[^"]*"\s*\{', line):
+          self.stack.append(_ExternCInfo(linenum))
+        else:
+          self.stack.append(_BlockInfo(linenum, True))
+          if _MATCH_ASM.match(line):
+            self.stack[-1].inline_asm = _BLOCK_ASM
+
+      elif token == ';' or token == ')':
+        # If we haven't seen an opening brace yet, but we already saw
+        # a semicolon, this is probably a forward declaration.  Pop
+        # the stack for these.
+        #
+        # Similarly, if we haven't seen an opening brace yet, but we
+        # already saw a closing parenthesis, then these are probably
+        # function arguments with extra "class" or "struct" keywords.
+        # Also pop these stack for these.
+        if not self.SeenOpenBrace():
+          self.stack.pop()
+      else:  # token == '}'
+        # Perform end of block checks and pop the stack.
+        if self.stack:
+          self.stack[-1].CheckEnd(filename, clean_lines, linenum, error)
+          self.stack.pop()
+      line = matched.group(2)
+
+  def InnermostClass(self):
+    """Get class info on the top of the stack.
+
+    Returns:
+      A _ClassInfo object if we are inside a class, or None otherwise.
+    """
+    for i in range(len(self.stack), 0, -1):
+      classinfo = self.stack[i - 1]
+      if isinstance(classinfo, _ClassInfo):
+        return classinfo
+    return None
+
+  def CheckCompletedBlocks(self, filename, error):
+    """Checks that all classes and namespaces have been completely parsed.
+
+    Call this when all lines in a file have been processed.
+    Args:
+      filename: The name of the current file.
+      error: The function to call with any errors found.
+    """
+    # Note: This test can result in false positives if #ifdef constructs
+    # get in the way of brace matching. See the testBuildClass test in
+    # cpplint_unittest.py for an example of this.
+    for obj in self.stack:
+      if isinstance(obj, _ClassInfo):
+        error(filename, obj.starting_linenum, 'build/class', 5,
+              'Failed to find complete declaration of class %s' %
+              obj.name)
+      elif isinstance(obj, _NamespaceInfo):
+        error(filename, obj.starting_linenum, 'build/namespaces', 5,
+              'Failed to find complete declaration of namespace %s' %
+              obj.name)
+
+
+def CheckForNonStandardConstructs(filename, clean_lines, linenum,
+                                  nesting_state, error):
+  r"""Logs an error if we see certain non-ANSI constructs ignored by gcc-2.
+
+  Complain about several constructs which gcc-2 accepts, but which are
+  not standard C++.  Warning about these in lint is one way to ease the
+  transition to new compilers.
+  - put storage class first (e.g. "static const" instead of "const static").
+  - "%lld" instead of %qd" in printf-type functions.
+  - "%1$d" is non-standard in printf-type functions.
+  - "\%" is an undefined character escape sequence.
+  - text after #endif is not allowed.
+  - invalid inner-style forward declaration.
+  - >? and <? operators, and their >?= and <?= cousins.
+
+  Additionally, check for constructor/destructor style violations and reference
+  members, as it is very convenient to do so while checking for
+  gcc-2 compliance.
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    nesting_state: A NestingState instance which maintains information about
+                   the current stack of nested blocks being parsed.
+    error: A callable to which errors are reported, which takes 4 arguments:
+           filename, line number, error level, and message
+  """
+
+  # Remove comments from the line, but leave in strings for now.
+  line = clean_lines.lines[linenum]
+
+  if Search(r'printf\s*\(.*".*%[-+ ]?\d*q', line):
+    error(filename, linenum, 'runtime/printf_format', 3,
+          '%q in format strings is deprecated.  Use %ll instead.')
+
+  if Search(r'printf\s*\(.*".*%\d+\$', line):
+    error(filename, linenum, 'runtime/printf_format', 2,
+          '%N$ formats are unconventional.  Try rewriting to avoid them.')
+
+  # Remove escaped backslashes before looking for undefined escapes.
+  line = line.replace('\\\\', '')
+
+  if Search(r'("|\').*\\(%|\[|\(|{)', line):
+    error(filename, linenum, 'build/printf_format', 3,
+          '%, [, (, and { are undefined character escapes.  Unescape them.')
+
+  # For the rest, work with both comments and strings removed.
+  line = clean_lines.elided[linenum]
+
+  if Search(r'\b(const|volatile|void|char|short|int|long'
+            r'|float|double|signed|unsigned'
+            r'|schar|u?int8|u?int16|u?int32|u?int64)'
+            r'\s+(register|static|extern|typedef)\b',
+            line):
+    error(filename, linenum, 'build/storage_class', 5,
+          'Storage-class specifier (static, extern, typedef, etc) should be '
+          'at the beginning of the declaration.')
+
+  if Match(r'\s*#\s*endif\s*[^/\s]+', line):
+    error(filename, linenum, 'build/endif_comment', 5,
+          'Uncommented text after #endif is non-standard.  Use a comment.')
+
+  if Match(r'\s*class\s+(\w+\s*::\s*)+\w+\s*;', line):
+    error(filename, linenum, 'build/forward_decl', 5,
+          'Inner-style forward declarations are invalid.  Remove this line.')
+
+  if Search(r'(\w+|[+-]?\d+(\.\d*)?)\s*(<|>)\?=?\s*(\w+|[+-]?\d+)(\.\d*)?',
+            line):
+    error(filename, linenum, 'build/deprecated', 3,
+          '>? and <? (max and min) operators are non-standard and deprecated.')
+
+  if Search(r'^\s*const\s*string\s*&\s*\w+\s*;', line):
+    # TODO(unknown): Could it be expanded safely to arbitrary references,
+    # without triggering too many false positives? The first
+    # attempt triggered 5 warnings for mostly benign code in the regtest, hence
+    # the restriction.
+    # Here's the original regexp, for the reference:
+    # type_name = r'\w+((\s*::\s*\w+)|(\s*<\s*\w+?\s*>))?'
+    # r'\s*const\s*' + type_name + '\s*&\s*\w+\s*;'
+    error(filename, linenum, 'runtime/member_string_references', 2,
+          'const string& members are dangerous. It is much better to use '
+          'alternatives, such as pointers or simple constants.')
+
+  # Everything else in this function operates on class declarations.
+  # Return early if the top of the nesting stack is not a class, or if
+  # the class head is not completed yet.
+  classinfo = nesting_state.InnermostClass()
+  if not classinfo or not classinfo.seen_open_brace:
+    return
+
+  # The class may have been declared with namespace or classname qualifiers.
+  # The constructor and destructor will not have those qualifiers.
+  base_classname = classinfo.name.split('::')[-1]
+
+  # Look for single-argument constructors that aren't marked explicit.
+  # Technically a valid construct, but against style.
+  explicit_constructor_match = Match(
+      r'\s+(?:inline\s+)?(explicit\s+)?(?:inline\s+)?%s\s*'
+      r'\(((?:[^()]|\([^()]*\))*)\)'
+      % re.escape(base_classname),
+      line)
+
+  if explicit_constructor_match:
+    is_marked_explicit = explicit_constructor_match.group(1)
+
+    if not explicit_constructor_match.group(2):
+      constructor_args = []
+    else:
+      constructor_args = explicit_constructor_match.group(2).split(',')
+
+    # collapse arguments so that commas in template parameter lists and function
+    # argument parameter lists don't split arguments in two
+    i = 0
+    while i < len(constructor_args):
+      constructor_arg = constructor_args[i]
+      while (constructor_arg.count('<') > constructor_arg.count('>') or
+             constructor_arg.count('(') > constructor_arg.count(')')):
+        constructor_arg += ',' + constructor_args[i + 1]
+        del constructor_args[i + 1]
+      constructor_args[i] = constructor_arg
+      i += 1
+
+    variadic_args = [arg for arg in constructor_args if '&&...' in arg]
+    defaulted_args = [arg for arg in constructor_args if '=' in arg]
+    noarg_constructor = (not constructor_args or  # empty arg list
+                         # 'void' arg specifier
+                         (len(constructor_args) == 1 and
+                          constructor_args[0].strip() == 'void'))
+    onearg_constructor = ((len(constructor_args) == 1 and  # exactly one arg
+                           not noarg_constructor) or
+                          # all but at most one arg defaulted
+                          (len(constructor_args) >= 1 and
+                           not noarg_constructor and
+                           len(defaulted_args) >= len(constructor_args) - 1) or
+                          # variadic arguments with zero or one argument
+                          (len(constructor_args) <= 2 and
+                           len(variadic_args) >= 1))
+    initializer_list_constructor = bool(
+        onearg_constructor and
+        Search(r'\bstd\s*::\s*initializer_list\b', constructor_args[0]))
+    copy_constructor = bool(
+        onearg_constructor and
+        Match(r'(const\s+)?%s(\s*<[^>]*>)?(\s+const)?\s*(?:<\w+>\s*)?&'
+              % re.escape(base_classname), constructor_args[0].strip()))
+
+    if (not is_marked_explicit and
+        onearg_constructor and
+        not initializer_list_constructor and
+        not copy_constructor):
+      if defaulted_args or variadic_args:
+        error(filename, linenum, 'runtime/explicit', 5,
+              'Constructors callable with one argument '
+              'should be marked explicit.')
+      else:
+        error(filename, linenum, 'runtime/explicit', 5,
+              'Single-parameter constructors should be marked explicit.')
+    elif is_marked_explicit and not onearg_constructor:
+      if noarg_constructor:
+        error(filename, linenum, 'runtime/explicit', 5,
+              'Zero-parameter constructors should not be marked explicit.')
+
+
+def CheckSpacingForFunctionCall(filename, clean_lines, linenum, error):
+  """Checks for the correctness of various spacing around function calls.
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    error: The function to call with any errors found.
+  """
+  line = clean_lines.elided[linenum]
+
+  # Since function calls often occur inside if/for/while/switch
+  # expressions - which have their own, more liberal conventions - we
+  # first see if we should be looking inside such an expression for a
+  # function call, to which we can apply more strict standards.
+  fncall = line    # if there's no control flow construct, look at whole line
+  for pattern in (r'\bif\s*\((.*)\)\s*{',
+                  r'\bfor\s*\((.*)\)\s*{',
+                  r'\bwhile\s*\((.*)\)\s*[{;]',
+                  r'\bswitch\s*\((.*)\)\s*{'):
+    match = Search(pattern, line)
+    if match:
+      fncall = match.group(1)    # look inside the parens for function calls
+      break
+
+  # Except in if/for/while/switch, there should never be space
+  # immediately inside parens (eg "f( 3, 4 )").  We make an exception
+  # for nested parens ( (a+b) + c ).  Likewise, there should never be
+  # a space before a ( when it's a function argument.  I assume it's a
+  # function argument when the char before the whitespace is legal in
+  # a function name (alnum + _) and we're not starting a macro. Also ignore
+  # pointers and references to arrays and functions coz they're too tricky:
+  # we use a very simple way to recognize these:
+  # " (something)(maybe-something)" or
+  # " (something)(maybe-something," or
+  # " (something)[something]"
+  # Note that we assume the contents of [] to be short enough that
+  # they'll never need to wrap.
+  if (  # Ignore control structures.
+      not Search(r'\b(if|for|while|switch|return|new|delete|catch|sizeof)\b',
+                 fncall) and
+      # Ignore pointers/references to functions.
+      not Search(r' \([^)]+\)\([^)]*(\)|,$)', fncall) and
+      # Ignore pointers/references to arrays.
+      not Search(r' \([^)]+\)\[[^\]]+\]', fncall)):
+    if Search(r'\w\s*\(\s(?!\s*\\$)', fncall):      # a ( used for a fn call
+      error(filename, linenum, 'whitespace/parens', 4,
+            'Extra space after ( in function call')
+    elif Search(r'\(\s+(?!(\s*\\)|\()', fncall):
+      error(filename, linenum, 'whitespace/parens', 2,
+            'Extra space after (')
+    if (Search(r'\w\s+\(', fncall) and
+        not Search(r'_{0,2}asm_{0,2}\s+_{0,2}volatile_{0,2}\s+\(', fncall) and
+        not Search(r'#\s*define|typedef|using\s+\w+\s*=', fncall) and
+        not Search(r'\w\s+\((\w+::)*\*\w+\)\(', fncall) and
+        not Search(r'\bcase\s+\(', fncall)):
+      # TODO(unknown): Space after an operator function seem to be a common
+      # error, silence those for now by restricting them to highest verbosity.
+      if Search(r'\boperator_*\b', line):
+        error(filename, linenum, 'whitespace/parens', 0,
+              'Extra space before ( in function call')
+      else:
+        error(filename, linenum, 'whitespace/parens', 4,
+              'Extra space before ( in function call')
+    # If the ) is followed only by a newline or a { + newline, assume it's
+    # part of a control statement (if/while/etc), and don't complain
+    if Search(r'[^)]\s+\)\s*[^{\s]', fncall):
+      # If the closing parenthesis is preceded by only whitespaces,
+      # try to give a more descriptive error message.
+      if Search(r'^\s+\)', fncall):
+        error(filename, linenum, 'whitespace/parens', 2,
+              'Closing ) should be moved to the previous line')
+      else:
+        error(filename, linenum, 'whitespace/parens', 2,
+              'Extra space before )')
+
+
+def IsBlankLine(line):
+  """Returns true if the given line is blank.
+
+  We consider a line to be blank if the line is empty or consists of
+  only white spaces.
+
+  Args:
+    line: A line of a string.
+
+  Returns:
+    True, if the given line is blank.
+  """
+  return not line or line.isspace()
+
+
+def CheckForNamespaceIndentation(filename, nesting_state, clean_lines, line,
+                                 error):
+  is_namespace_indent_item = (
+      len(nesting_state.stack) > 1 and
+      nesting_state.stack[-1].check_namespace_indentation and
+      isinstance(nesting_state.previous_stack_top, _NamespaceInfo) and
+      nesting_state.previous_stack_top == nesting_state.stack[-2])
+
+  if ShouldCheckNamespaceIndentation(nesting_state, is_namespace_indent_item,
+                                     clean_lines.elided, line):
+    CheckItemIndentationInNamespace(filename, clean_lines.elided,
+                                    line, error)
+
+
+def CheckForFunctionLengths(filename, clean_lines, linenum,
+                            function_state, error):
+  """Reports for long function bodies.
+
+  For an overview why this is done, see:
+  https://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Write_Short_Functions
+
+  Uses a simplistic algorithm assuming other style guidelines
+  (especially spacing) are followed.
+  Only checks unindented functions, so class members are unchecked.
+  Trivial bodies are unchecked, so constructors with huge initializer lists
+  may be missed.
+  Blank/comment lines are not counted so as to avoid encouraging the removal
+  of vertical space and comments just to get through a lint check.
+  NOLINT *on the last line of a function* disables this check.
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    function_state: Current function name and lines in body so far.
+    error: The function to call with any errors found.
+  """
+  lines = clean_lines.lines
+  line = lines[linenum]
+  joined_line = ''
+
+  starting_func = False
+  regexp = r'(\w(\w|::|\*|\&|\s)*)\('  # decls * & space::name( ...
+  match_result = Match(regexp, line)
+  if match_result:
+    # If the name is all caps and underscores, figure it's a macro and
+    # ignore it, unless it's TEST or TEST_F.
+    function_name = match_result.group(1).split()[-1]
+    if function_name == 'TEST' or function_name == 'TEST_F' or (
+        not Match(r'[A-Z_]+$', function_name)):
+      starting_func = True
+
+  if starting_func:
+    body_found = False
+    for start_linenum in range(linenum, clean_lines.NumLines()):
+      start_line = lines[start_linenum]
+      joined_line += ' ' + start_line.lstrip()
+      if Search(r'(;|})', start_line):  # Declarations and trivial functions
+        body_found = True
+        break                              # ... ignore
+      elif Search(r'{', start_line):
+        body_found = True
+        function = Search(r'((\w|:)*)\(', line).group(1)
+        if Match(r'TEST', function):    # Handle TEST... macros
+          parameter_regexp = Search(r'(\(.*\))', joined_line)
+          if parameter_regexp:             # Ignore bad syntax
+            function += parameter_regexp.group(1)
+        else:
+          function += '()'
+        function_state.Begin(function)
+        break
+    if not body_found:
+      # No body for the function (or evidence of a non-function) was found.
+      error(filename, linenum, 'readability/fn_size', 5,
+            'Lint failed to find start of function body.')
+  elif Match(r'^\}\s*$', line):  # function end
+    function_state.Check(error, filename, linenum)
+    function_state.End()
+  elif not Match(r'^\s*$', line):
+    function_state.Count()  # Count non-blank/non-comment lines.
+
+
+_RE_PATTERN_TODO = re.compile(r'^//(\s*)TODO(\(.+?\))?:?(\s|$)?')
+
+
+def CheckComment(line, filename, linenum, next_line_start, error):
+  """Checks for common mistakes in comments.
+
+  Args:
+    line: The line in question.
+    filename: The name of the current file.
+    linenum: The number of the line to check.
+    next_line_start: The first non-whitespace column of the next line.
+    error: The function to call with any errors found.
+  """
+  commentpos = line.find('//')
+  if commentpos != -1:
+    # Check if the // may be in quotes.  If so, ignore it
+    if re.sub(r'\\.', '', line[0:commentpos]).count('"') % 2 == 0:
+      # Allow one space for new scopes, two spaces otherwise:
+      if (not (Match(r'^.*{ *//', line) and next_line_start == commentpos) and
+          ((commentpos >= 1 and
+            line[commentpos-1] not in string.whitespace) or
+           (commentpos >= 2 and
+            line[commentpos-2] not in string.whitespace))):
+        error(filename, linenum, 'whitespace/comments', 2,
+              'At least two spaces is best between code and comments')
+
+      # Checks for common mistakes in TODO comments.
+      comment = line[commentpos:]
+      match = _RE_PATTERN_TODO.match(comment)
+      if match:
+        # One whitespace is correct; zero whitespace is handled elsewhere.
+        leading_whitespace = match.group(1)
+        if len(leading_whitespace) > 1:
+          error(filename, linenum, 'whitespace/todo', 2,
+                'Too many spaces before TODO')
+
+        username = match.group(2)
+        if not username:
+          error(filename, linenum, 'readability/todo', 2,
+                'Missing username in TODO; it should look like '
+                '"// TODO(my_username): Stuff."')
+
+        middle_whitespace = match.group(3)
+        # Comparisons made explicit for correctness -- pylint: disable=g-explicit-bool-comparison
+        if middle_whitespace != ' ' and middle_whitespace != '':
+          error(filename, linenum, 'whitespace/todo', 2,
+                'TODO(my_username) should be followed by a space')
+
+      # If the comment contains an alphanumeric character, there
+      # should be a space somewhere between it and the // unless
+      # it's a /// or //! Doxygen comment.
+      if (Match(r'//[^ ]*\w', comment) and
+          not Match(r'(///|//\!)(\s+|$)', comment)):
+        error(filename, linenum, 'whitespace/comments', 4,
+              'Should have a space between // and comment')
+
+
+def CheckAccess(filename, clean_lines, linenum, nesting_state, error):
+  """Checks for improper use of DISALLOW* macros.
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    nesting_state: A NestingState instance which maintains information about
+                   the current stack of nested blocks being parsed.
+    error: The function to call with any errors found.
+  """
+  line = clean_lines.elided[linenum]  # get rid of comments and strings
+
+  matched = Match((r'\s*(DISALLOW_COPY_AND_ASSIGN|'
+                   r'DISALLOW_IMPLICIT_CONSTRUCTORS)'), line)
+  if not matched:
+    return
+  if nesting_state.stack and isinstance(nesting_state.stack[-1], _ClassInfo):
+    if nesting_state.stack[-1].access != 'private':
+      error(filename, linenum, 'readability/constructors', 3,
+            '%s must be in the private: section' % matched.group(1))
+
+  else:
+    # Found DISALLOW* macro outside a class declaration, or perhaps it
+    # was used inside a function when it should have been part of the
+    # class declaration.  We could issue a warning here, but it
+    # probably resulted in a compiler error already.
+    pass
+
+
+def CheckSpacing(filename, clean_lines, linenum, nesting_state, error):
+  """Checks for the correctness of various spacing issues in the code.
+
+  Things we check for: spaces around operators, spaces after
+  if/for/while/switch, no spaces around parens in function calls, two
+  spaces between code and comment, don't start a block with a blank
+  line, don't end a function with a blank line, don't add a blank line
+  after public/protected/private, don't have too many blank lines in a row.
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    nesting_state: A NestingState instance which maintains information about
+                   the current stack of nested blocks being parsed.
+    error: The function to call with any errors found.
+  """
+
+  # Don't use "elided" lines here, otherwise we can't check commented lines.
+  # Don't want to use "raw" either, because we don't want to check inside C++11
+  # raw strings,
+  raw = clean_lines.lines_without_raw_strings
+  line = raw[linenum]
+
+  # Before nixing comments, check if the line is blank for no good
+  # reason.  This includes the first line after a block is opened, and
+  # blank lines at the end of a function (ie, right before a line like '}'
+  #
+  # Skip all the blank line checks if we are immediately inside a
+  # namespace body.  In other words, don't issue blank line warnings
+  # for this block:
+  #   namespace {
+  #
+  #   }
+  #
+  # A warning about missing end of namespace comments will be issued instead.
+  #
+  # Also skip blank line checks for 'extern "C"' blocks, which are formatted
+  # like namespaces.
+  if (IsBlankLine(line) and
+      not nesting_state.InNamespaceBody() and
+      not nesting_state.InExternC()):
+    elided = clean_lines.elided
+    prev_line = elided[linenum - 1]
+    prevbrace = prev_line.rfind('{')
+    # TODO(unknown): Don't complain if line before blank line, and line after,
+    #                both start with alnums and are indented the same amount.
+    #                This ignores whitespace at the start of a namespace block
+    #                because those are not usually indented.
+    if prevbrace != -1 and prev_line[prevbrace:].find('}') == -1:
+      # OK, we have a blank line at the start of a code block.  Before we
+      # complain, we check if it is an exception to the rule: The previous
+      # non-empty line has the parameters of a function header that are indented
+      # 4 spaces (because they did not fit in a 80 column line when placed on
+      # the same line as the function name).  We also check for the case where
+      # the previous line is indented 6 spaces, which may happen when the
+      # initializers of a constructor do not fit into a 80 column line.
+      exception = False
+      if Match(r' {6}\w', prev_line):  # Initializer list?
+        # We are looking for the opening column of initializer list, which
+        # should be indented 4 spaces to cause 6 space indentation afterwards.
+        search_position = linenum-2
+        while (search_position >= 0
+               and Match(r' {6}\w', elided[search_position])):
+          search_position -= 1
+        exception = (search_position >= 0
+                     and elided[search_position][:5] == '    :')
+      else:
+        # Search for the function arguments or an initializer list.  We use a
+        # simple heuristic here: If the line is indented 4 spaces; and we have a
+        # closing paren, without the opening paren, followed by an opening brace
+        # or colon (for initializer lists) we assume that it is the last line of
+        # a function header.  If we have a colon indented 4 spaces, it is an
+        # initializer list.
+        exception = (Match(r' {4}\w[^\(]*\)\s*(const\s*)?(\{\s*$|:)',
+                           prev_line)
+                     or Match(r' {4}:', prev_line))
+
+      if not exception:
+        error(filename, linenum, 'whitespace/blank_line', 2,
+              'Redundant blank line at the start of a code block '
+              'should be deleted.')
+    # Ignore blank lines at the end of a block in a long if-else
+    # chain, like this:
+    #   if (condition1) {
+    #     // Something followed by a blank line
+    #
+    #   } else if (condition2) {
+    #     // Something else
+    #   }
+    if linenum + 1 < clean_lines.NumLines():
+      next_line = raw[linenum + 1]
+      if (next_line
+          and Match(r'\s*}', next_line)
+          and next_line.find('} else ') == -1):
+        error(filename, linenum, 'whitespace/blank_line', 3,
+              'Redundant blank line at the end of a code block '
+              'should be deleted.')
+
+    matched = Match(r'\s*(public|protected|private):', prev_line)
+    if matched:
+      error(filename, linenum, 'whitespace/blank_line', 3,
+            'Do not leave a blank line after "%s:"' % matched.group(1))
+
+  # Next, check comments
+  next_line_start = 0
+  if linenum + 1 < clean_lines.NumLines():
+    next_line = raw[linenum + 1]
+    next_line_start = len(next_line) - len(next_line.lstrip())
+  CheckComment(line, filename, linenum, next_line_start, error)
+
+  # get rid of comments and strings
+  line = clean_lines.elided[linenum]
+
+  # You shouldn't have spaces before your brackets, except maybe after
+  # 'delete []' or 'return []() {};'
+  if Search(r'\w\s+\[', line) and not Search(r'(?:delete|return)\s+\[', line):
+    error(filename, linenum, 'whitespace/braces', 5,
+          'Extra space before [')
+
+  # In range-based for, we wanted spaces before and after the colon, but
+  # not around "::" tokens that might appear.
+  if (Search(r'for *\(.*[^:]:[^: ]', line) or
+      Search(r'for *\(.*[^: ]:[^:]', line)):
+    error(filename, linenum, 'whitespace/forcolon', 2,
+          'Missing space around colon in range-based for loop')
+
+
+def CheckOperatorSpacing(filename, clean_lines, linenum, error):
+  """Checks for horizontal spacing around operators.
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    error: The function to call with any errors found.
+  """
+  line = clean_lines.elided[linenum]
+
+  # Don't try to do spacing checks for operator methods.  Do this by
+  # replacing the troublesome characters with something else,
+  # preserving column position for all other characters.
+  #
+  # The replacement is done repeatedly to avoid false positives from
+  # operators that call operators.
+  while True:
+    match = Match(r'^(.*\boperator\b)(\S+)(\s*\(.*)$', line)
+    if match:
+      line = match.group(1) + ('_' * len(match.group(2))) + match.group(3)
+    else:
+      break
+
+  # We allow no-spaces around = within an if: "if ( (a=Foo()) == 0 )".
+  # Otherwise not.  Note we only check for non-spaces on *both* sides;
+  # sometimes people put non-spaces on one side when aligning ='s among
+  # many lines (not that this is behavior that I approve of...)
+  if ((Search(r'[\w.]=', line) or
+       Search(r'=[\w.]', line))
+      and not Search(r'\b(if|while|for) ', line)
+      # Operators taken from [lex.operators] in C++11 standard.
+      and not Search(r'(>=|<=|==|!=|&=|\^=|\|=|\+=|\*=|\/=|\%=)', line)
+      and not Search(r'operator=', line)):
+    error(filename, linenum, 'whitespace/operators', 4,
+          'Missing spaces around =')
+
+  # It's ok not to have spaces around binary operators like + - * /, but if
+  # there's too little whitespace, we get concerned.  It's hard to tell,
+  # though, so we punt on this one for now.  TODO.
+
+  # You should always have whitespace around binary operators.
+  #
+  # Check <= and >= first to avoid false positives with < and >, then
+  # check non-include lines for spacing around < and >.
+  #
+  # If the operator is followed by a comma, assume it's be used in a
+  # macro context and don't do any checks.  This avoids false
+  # positives.
+  #
+  # Note that && is not included here.  This is because there are too
+  # many false positives due to RValue references.
+  match = Search(r'[^<>=!\s](==|!=|<=|>=|\|\|)[^<>=!\s,;\)]', line)
+  if match:
+    error(filename, linenum, 'whitespace/operators', 3,
+          'Missing spaces around %s' % match.group(1))
+  elif not Match(r'#.*include', line):
+    # Look for < that is not surrounded by spaces.  This is only
+    # triggered if both sides are missing spaces, even though
+    # technically should should flag if at least one side is missing a
+    # space.  This is done to avoid some false positives with shifts.
+    match = Match(r'^(.*[^\s<])<[^\s=<,]', line)
+    if match:
+      (_, _, end_pos) = CloseExpression(
+          clean_lines, linenum, len(match.group(1)))
+      if end_pos <= -1:
+        error(filename, linenum, 'whitespace/operators', 3,
+              'Missing spaces around <')
+
+    # Look for > that is not surrounded by spaces.  Similar to the
+    # above, we only trigger if both sides are missing spaces to avoid
+    # false positives with shifts.
+    match = Match(r'^(.*[^-\s>])>[^\s=>,]', line)
+    if match:
+      (_, _, start_pos) = ReverseCloseExpression(
+          clean_lines, linenum, len(match.group(1)))
+      if start_pos <= -1:
+        error(filename, linenum, 'whitespace/operators', 3,
+              'Missing spaces around >')
+
+  # We allow no-spaces around << when used like this: 10<<20, but
+  # not otherwise (particularly, not when used as streams)
+  #
+  # We also allow operators following an opening parenthesis, since
+  # those tend to be macros that deal with operators.
+  match = Search(r'(operator|[^\s(<])(?:L|UL|LL|ULL|l|ul|ll|ull)?<<([^\s,=<])', line)
+  if (match and not (match.group(1).isdigit() and match.group(2).isdigit()) and
+      not (match.group(1) == 'operator' and match.group(2) == ';')):
+    error(filename, linenum, 'whitespace/operators', 3,
+          'Missing spaces around <<')
+
+  # We allow no-spaces around >> for almost anything.  This is because
+  # C++11 allows ">>" to close nested templates, which accounts for
+  # most cases when ">>" is not followed by a space.
+  #
+  # We still warn on ">>" followed by alpha character, because that is
+  # likely due to ">>" being used for right shifts, e.g.:
+  #   value >> alpha
+  #
+  # When ">>" is used to close templates, the alphanumeric letter that
+  # follows would be part of an identifier, and there should still be
+  # a space separating the template type and the identifier.
+  #   type<type<type>> alpha
+  match = Search(r'>>[a-zA-Z_]', line)
+  if match:
+    error(filename, linenum, 'whitespace/operators', 3,
+          'Missing spaces around >>')
+
+  # There shouldn't be space around unary operators
+  match = Search(r'(!\s|~\s|[\s]--[\s;]|[\s]\+\+[\s;])', line)
+  if match:
+    error(filename, linenum, 'whitespace/operators', 4,
+          'Extra space for operator %s' % match.group(1))
+
+
+def CheckParenthesisSpacing(filename, clean_lines, linenum, error):
+  """Checks for horizontal spacing around parentheses.
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    error: The function to call with any errors found.
+  """
+  line = clean_lines.elided[linenum]
+
+  # No spaces after an if, while, switch, or for
+  match = Search(r' (if\(|for\(|while\(|switch\()', line)
+  if match:
+    error(filename, linenum, 'whitespace/parens', 5,
+          'Missing space before ( in %s' % match.group(1))
+
+  # For if/for/while/switch, the left and right parens should be
+  # consistent about how many spaces are inside the parens, and
+  # there should either be zero or one spaces inside the parens.
+  # We don't want: "if ( foo)" or "if ( foo   )".
+  # Exception: "for ( ; foo; bar)" and "for (foo; bar; )" are allowed.
+  match = Search(r'\b(if|for|while|switch)\s*'
+                 r'\(([ ]*)(.).*[^ ]+([ ]*)\)\s*{\s*$',
+                 line)
+  if match:
+    if len(match.group(2)) != len(match.group(4)):
+      if not (match.group(3) == ';' and
+              len(match.group(2)) == 1 + len(match.group(4)) or
+              not match.group(2) and Search(r'\bfor\s*\(.*; \)', line)):
+        error(filename, linenum, 'whitespace/parens', 5,
+              'Mismatching spaces inside () in %s' % match.group(1))
+    if len(match.group(2)) not in [0, 1]:
+      error(filename, linenum, 'whitespace/parens', 5,
+            'Should have zero or one spaces inside ( and ) in %s' %
+            match.group(1))
+
+
+def CheckCommaSpacing(filename, clean_lines, linenum, error):
+  """Checks for horizontal spacing near commas and semicolons.
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    error: The function to call with any errors found.
+  """
+  raw = clean_lines.lines_without_raw_strings
+  line = clean_lines.elided[linenum]
+
+  # You should always have a space after a comma (either as fn arg or operator)
+  #
+  # This does not apply when the non-space character following the
+  # comma is another comma, since the only time when that happens is
+  # for empty macro arguments.
+  #
+  # We run this check in two passes: first pass on elided lines to
+  # verify that lines contain missing whitespaces, second pass on raw
+  # lines to confirm that those missing whitespaces are not due to
+  # elided comments.
+  if (Search(r',[^,\s]', ReplaceAll(r'\boperator\s*,\s*\(', 'F(', line)) and
+      Search(r',[^,\s]', raw[linenum])):
+    error(filename, linenum, 'whitespace/comma', 3,
+          'Missing space after ,')
+
+  # You should always have a space after a semicolon
+  # except for few corner cases
+  # TODO(unknown): clarify if 'if (1) { return 1;}' is requires one more
+  # space after ;
+  if Search(r';[^\s};\\)/]', line):
+    error(filename, linenum, 'whitespace/semicolon', 3,
+          'Missing space after ;')
+
+
+def _IsType(clean_lines, nesting_state, expr):
+  """Check if expression looks like a type name, returns true if so.
+
+  Args:
+    clean_lines: A CleansedLines instance containing the file.
+    nesting_state: A NestingState instance which maintains information about
+                   the current stack of nested blocks being parsed.
+    expr: The expression to check.
+  Returns:
+    True, if token looks like a type.
+  """
+  # Keep only the last token in the expression
+  last_word = Match(r'^.*(\b\S+)$', expr)
+  if last_word:
+    token = last_word.group(1)
+  else:
+    token = expr
+
+  # Match native types and stdint types
+  if _TYPES.match(token):
+    return True
+
+  # Try a bit harder to match templated types.  Walk up the nesting
+  # stack until we find something that resembles a typename
+  # declaration for what we are looking for.
+  typename_pattern = (r'\b(?:typename|class|struct)\s+' + re.escape(token) +
+                      r'\b')
+  block_index = len(nesting_state.stack) - 1
+  while block_index >= 0:
+    if isinstance(nesting_state.stack[block_index], _NamespaceInfo):
+      return False
+
+    # Found where the opening brace is.  We want to scan from this
+    # line up to the beginning of the function, minus a few lines.
+    #   template <typename Type1,  // stop scanning here
+    #             ...>
+    #   class C
+    #     : public ... {  // start scanning here
+    last_line = nesting_state.stack[block_index].starting_linenum
+
+    next_block_start = 0
+    if block_index > 0:
+      next_block_start = nesting_state.stack[block_index - 1].starting_linenum
+    first_line = last_line
+    while first_line >= next_block_start:
+      if clean_lines.elided[first_line].find('template') >= 0:
+        break
+      first_line -= 1
+    if first_line < next_block_start:
+      # Didn't find any "template" keyword before reaching the next block,
+      # there are probably no template things to check for this block
+      block_index -= 1
+      continue
+
+    # Look for typename in the specified range
+    for i in xrange(first_line, last_line + 1, 1):
+      if Search(typename_pattern, clean_lines.elided[i]):
+        return True
+    block_index -= 1
+
+  return False
+
+
+def CheckBracesSpacing(filename, clean_lines, linenum, nesting_state, error):
+  """Checks for horizontal spacing near commas.
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    nesting_state: A NestingState instance which maintains information about
+                   the current stack of nested blocks being parsed.
+    error: The function to call with any errors found.
+  """
+  line = clean_lines.elided[linenum]
+
+  # Except after an opening paren, or after another opening brace (in case of
+  # an initializer list, for instance), you should have spaces before your
+  # braces when they are delimiting blocks, classes, namespaces etc.
+  # And since you should never have braces at the beginning of a line,
+  # this is an easy test.  Except that braces used for initialization don't
+  # follow the same rule; we often don't want spaces before those.
+  match = Match(r'^(.*[^ ({>]){', line)
+
+  if match:
+    # Try a bit harder to check for brace initialization.  This
+    # happens in one of the following forms:
+    #   Constructor() : initializer_list_{} { ... }
+    #   Constructor{}.MemberFunction()
+    #   Type variable{};
+    #   FunctionCall(type{}, ...);
+    #   LastArgument(..., type{});
+    #   LOG(INFO) << type{} << " ...";
+    #   map_of_type[{...}] = ...;
+    #   ternary = expr ? new type{} : nullptr;
+    #   OuterTemplate<InnerTemplateConstructor<Type>{}>
+    #
+    # We check for the character following the closing brace, and
+    # silence the warning if it's one of those listed above, i.e.
+    # "{.;,)<>]:".
+    #
+    # To account for nested initializer list, we allow any number of
+    # closing braces up to "{;,)<".  We can't simply silence the
+    # warning on first sight of closing brace, because that would
+    # cause false negatives for things that are not initializer lists.
+    #   Silence this:         But not this:
+    #     Outer{                if (...) {
+    #       Inner{...}            if (...){  // Missing space before {
+    #     };                    }
+    #
+    # There is a false negative with this approach if people inserted
+    # spurious semicolons, e.g. "if (cond){};", but we will catch the
+    # spurious semicolon with a separate check.
+    leading_text = match.group(1)
+    (endline, endlinenum, endpos) = CloseExpression(
+        clean_lines, linenum, len(match.group(1)))
+    trailing_text = ''
+    if endpos > -1:
+      trailing_text = endline[endpos:]
+    for offset in xrange(endlinenum + 1,
+                         min(endlinenum + 3, clean_lines.NumLines() - 1)):
+      trailing_text += clean_lines.elided[offset]
+    # We also suppress warnings for `uint64_t{expression}` etc., as the style
+    # guide recommends brace initialization for integral types to avoid
+    # overflow/truncation.
+    if (not Match(r'^[\s}]*[{.;,)<>\]:]', trailing_text)
+        and not _IsType(clean_lines, nesting_state, leading_text)):
+      error(filename, linenum, 'whitespace/braces', 5,
+            'Missing space before {')
+
+  # Make sure '} else {' has spaces.
+  if Search(r'}else', line):
+    error(filename, linenum, 'whitespace/braces', 5,
+          'Missing space before else')
+
+  # You shouldn't have a space before a semicolon at the end of the line.
+  # There's a special case for "for" since the style guide allows space before
+  # the semicolon there.
+  if Search(r':\s*;\s*$', line):
+    error(filename, linenum, 'whitespace/semicolon', 5,
+          'Semicolon defining empty statement. Use {} instead.')
+  elif Search(r'^\s*;\s*$', line):
+    error(filename, linenum, 'whitespace/semicolon', 5,
+          'Line contains only semicolon. If this should be an empty statement, '
+          'use {} instead.')
+  elif (Search(r'\s+;\s*$', line) and
+        not Search(r'\bfor\b', line)):
+    error(filename, linenum, 'whitespace/semicolon', 5,
+          'Extra space before last semicolon. If this should be an empty '
+          'statement, use {} instead.')
+
+
+def IsDecltype(clean_lines, linenum, column):
+  """Check if the token ending on (linenum, column) is decltype().
+
+  Args:
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: the number of the line to check.
+    column: end column of the token to check.
+  Returns:
+    True if this token is decltype() expression, False otherwise.
+  """
+  (text, _, start_col) = ReverseCloseExpression(clean_lines, linenum, column)
+  if start_col < 0:
+    return False
+  if Search(r'\bdecltype\s*$', text[0:start_col]):
+    return True
+  return False
+
+def CheckSectionSpacing(filename, clean_lines, class_info, linenum, error):
+  """Checks for additional blank line issues related to sections.
+
+  Currently the only thing checked here is blank line before protected/private.
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    class_info: A _ClassInfo objects.
+    linenum: The number of the line to check.
+    error: The function to call with any errors found.
+  """
+  # Skip checks if the class is small, where small means 25 lines or less.
+  # 25 lines seems like a good cutoff since that's the usual height of
+  # terminals, and any class that can't fit in one screen can't really
+  # be considered "small".
+  #
+  # Also skip checks if we are on the first line.  This accounts for
+  # classes that look like
+  #   class Foo { public: ... };
+  #
+  # If we didn't find the end of the class, last_line would be zero,
+  # and the check will be skipped by the first condition.
+  if (class_info.last_line - class_info.starting_linenum <= 24 or
+      linenum <= class_info.starting_linenum):
+    return
+
+  matched = Match(r'\s*(public|protected|private):', clean_lines.lines[linenum])
+  if matched:
+    # Issue warning if the line before public/protected/private was
+    # not a blank line, but don't do this if the previous line contains
+    # "class" or "struct".  This can happen two ways:
+    #  - We are at the beginning of the class.
+    #  - We are forward-declaring an inner class that is semantically
+    #    private, but needed to be public for implementation reasons.
+    # Also ignores cases where the previous line ends with a backslash as can be
+    # common when defining classes in C macros.
+    prev_line = clean_lines.lines[linenum - 1]
+    if (not IsBlankLine(prev_line) and
+        not Search(r'\b(class|struct)\b', prev_line) and
+        not Search(r'\\$', prev_line)):
+      # Try a bit harder to find the beginning of the class.  This is to
+      # account for multi-line base-specifier lists, e.g.:
+      #   class Derived
+      #       : public Base {
+      end_class_head = class_info.starting_linenum
+      for i in range(class_info.starting_linenum, linenum):
+        if Search(r'\{\s*$', clean_lines.lines[i]):
+          end_class_head = i
+          break
+      if end_class_head < linenum - 1:
+        error(filename, linenum, 'whitespace/blank_line', 3,
+              '"%s:" should be preceded by a blank line' % matched.group(1))
+
+
+def GetPreviousNonBlankLine(clean_lines, linenum):
+  """Return the most recent non-blank line and its line number.
+
+  Args:
+    clean_lines: A CleansedLines instance containing the file contents.
+    linenum: The number of the line to check.
+
+  Returns:
+    A tuple with two elements.  The first element is the contents of the last
+    non-blank line before the current line, or the empty string if this is the
+    first non-blank line.  The second is the line number of that line, or -1
+    if this is the first non-blank line.
+  """
+
+  prevlinenum = linenum - 1
+  while prevlinenum >= 0:
+    prevline = clean_lines.elided[prevlinenum]
+    if not IsBlankLine(prevline):     # if not a blank line...
+      return (prevline, prevlinenum)
+    prevlinenum -= 1
+  return ('', -1)
+
+
+def CheckBraces(filename, clean_lines, linenum, error):
+  """Looks for misplaced braces (e.g. at the end of line).
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    error: The function to call with any errors found.
+  """
+
+  line = clean_lines.elided[linenum]        # get rid of comments and strings
+
+  if Match(r'\s*{\s*$', line):
+    # We allow an open brace to start a line in the case where someone is using
+    # braces in a block to explicitly create a new scope, which is commonly used
+    # to control the lifetime of stack-allocated variables.  Braces are also
+    # used for brace initializers inside function calls.  We don't detect this
+    # perfectly: we just don't complain if the last non-whitespace character on
+    # the previous non-blank line is ',', ';', ':', '(', '{', or '}', or if the
+    # previous line starts a preprocessor block. We also allow a brace on the
+    # following line if it is part of an array initialization and would not fit
+    # within the 80 character limit of the preceding line.
+    prevline = GetPreviousNonBlankLine(clean_lines, linenum)[0]
+    if (not Search(r'[,;:}{(]\s*$', prevline) and
+        not Match(r'\s*#', prevline) and
+        not (GetLineWidth(prevline) > _line_length - 2 and '[]' in prevline)):
+      error(filename, linenum, 'whitespace/braces', 4,
+            '{ should almost always be at the end of the previous line')
+
+  # An else clause should be on the same line as the preceding closing brace.
+  if Match(r'\s*else\b\s*(?:if\b|\{|$)', line):
+    prevline = GetPreviousNonBlankLine(clean_lines, linenum)[0]
+    if Match(r'\s*}\s*$', prevline):
+      error(filename, linenum, 'whitespace/newline', 4,
+            'An else should appear on the same line as the preceding }')
+
+  # If braces come on one side of an else, they should be on both.
+  # However, we have to worry about "else if" that spans multiple lines!
+  if Search(r'else if\s*\(', line):       # could be multi-line if
+    brace_on_left = bool(Search(r'}\s*else if\s*\(', line))
+    # find the ( after the if
+    pos = line.find('else if')
+    pos = line.find('(', pos)
+    if pos > 0:
+      (endline, _, endpos) = CloseExpression(clean_lines, linenum, pos)
+      brace_on_right = endline[endpos:].find('{') != -1
+      if brace_on_left != brace_on_right:    # must be brace after if
+        error(filename, linenum, 'readability/braces', 5,
+              'If an else has a brace on one side, it should have it on both')
+  elif Search(r'}\s*else[^{]*$', line) or Match(r'[^}]*else\s*{', line):
+    error(filename, linenum, 'readability/braces', 5,
+          'If an else has a brace on one side, it should have it on both')
+
+  # Likewise, an else should never have the else clause on the same line
+  if Search(r'\belse [^\s{]', line) and not Search(r'\belse if\b', line):
+    error(filename, linenum, 'whitespace/newline', 4,
+          'Else clause should never be on same line as else (use 2 lines)')
+
+  # In the same way, a do/while should never be on one line
+  if Match(r'\s*do [^\s{]', line):
+    error(filename, linenum, 'whitespace/newline', 4,
+          'do/while clauses should not be on a single line')
+
+  # Check single-line if/else bodies. The style guide says 'curly braces are not
+  # required for single-line statements'. We additionally allow multi-line,
+  # single statements, but we reject anything with more than one semicolon in
+  # it. This means that the first semicolon after the if should be at the end of
+  # its line, and the line after that should have an indent level equal to or
+  # lower than the if. We also check for ambiguous if/else nesting without
+  # braces.
+  if_else_match = Search(r'\b(if\s*\(|else\b)', line)
+  if if_else_match and not Match(r'\s*#', line):
+    if_indent = GetIndentLevel(line)
+    endline, endlinenum, endpos = line, linenum, if_else_match.end()
+    if_match = Search(r'\bif\s*\(', line)
+    if if_match:
+      # This could be a multiline if condition, so find the end first.
+      pos = if_match.end() - 1
+      (endline, endlinenum, endpos) = CloseExpression(clean_lines, linenum, pos)
+    # Check for an opening brace, either directly after the if or on the next
+    # line. If found, this isn't a single-statement conditional.
+    if (not Match(r'\s*{', endline[endpos:])
+        and not (Match(r'\s*$', endline[endpos:])
+                 and endlinenum < (len(clean_lines.elided) - 1)
+                 and Match(r'\s*{', clean_lines.elided[endlinenum + 1]))):
+      while (endlinenum < len(clean_lines.elided)
+             and ';' not in clean_lines.elided[endlinenum][endpos:]):
+        endlinenum += 1
+        endpos = 0
+      if endlinenum < len(clean_lines.elided):
+        endline = clean_lines.elided[endlinenum]
+        # We allow a mix of whitespace and closing braces (e.g. for one-liner
+        # methods) and a single \ after the semicolon (for macros)
+        endpos = endline.find(';')
+        if not Match(r';[\s}]*(\\?)$', endline[endpos:]):
+          # Semicolon isn't the last character, there's something trailing.
+          # Output a warning if the semicolon is not contained inside
+          # a lambda expression.
+          if not Match(r'^[^{};]*\[[^\[\]]*\][^{}]*\{[^{}]*\}\s*\)*[;,]\s*$',
+                       endline):
+            error(filename, linenum, 'readability/braces', 4,
+                  'If/else bodies with multiple statements require braces')
+        elif endlinenum < len(clean_lines.elided) - 1:
+          # Make sure the next line is dedented
+          next_line = clean_lines.elided[endlinenum + 1]
+          next_indent = GetIndentLevel(next_line)
+          # With ambiguous nested if statements, this will error out on the
+          # if that *doesn't* match the else, regardless of whether it's the
+          # inner one or outer one.
+          if (if_match and Match(r'\s*else\b', next_line)
+              and next_indent != if_indent):
+            error(filename, linenum, 'readability/braces', 4,
+                  'Else clause should be indented at the same level as if. '
+                  'Ambiguous nested if/else chains require braces.')
+          elif next_indent > if_indent:
+            error(filename, linenum, 'readability/braces', 4,
+                  'If/else bodies with multiple statements require braces')
+
+
+def CheckTrailingSemicolon(filename, clean_lines, linenum, error):
+  """Looks for redundant trailing semicolon.
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    error: The function to call with any errors found.
+  """
+
+  line = clean_lines.elided[linenum]
+
+  # Block bodies should not be followed by a semicolon.  Due to C++11
+  # brace initialization, there are more places where semicolons are
+  # required than not, so we use a whitelist approach to check these
+  # rather than a blacklist.  These are the places where "};" should
+  # be replaced by just "}":
+  # 1. Some flavor of block following closing parenthesis:
+  #    for (;;) {};
+  #    while (...) {};
+  #    switch (...) {};
+  #    Function(...) {};
+  #    if (...) {};
+  #    if (...) else if (...) {};
+  #
+  # 2. else block:
+  #    if (...) else {};
+  #
+  # 3. const member function:
+  #    Function(...) const {};
+  #
+  # 4. Block following some statement:
+  #    x = 42;
+  #    {};
+  #
+  # 5. Block at the beginning of a function:
+  #    Function(...) {
+  #      {};
+  #    }
+  #
+  #    Note that naively checking for the preceding "{" will also match
+  #    braces inside multi-dimensional arrays, but this is fine since
+  #    that expression will not contain semicolons.
+  #
+  # 6. Block following another block:
+  #    while (true) {}
+  #    {};
+  #
+  # 7. End of namespaces:
+  #    namespace {};
+  #
+  #    These semicolons seems far more common than other kinds of
+  #    redundant semicolons, possibly due to people converting classes
+  #    to namespaces.  For now we do not warn for this case.
+  #
+  # Try matching case 1 first.
+  match = Match(r'^(.*\)\s*)\{', line)
+  if match:
+    # Matched closing parenthesis (case 1).  Check the token before the
+    # matching opening parenthesis, and don't warn if it looks like a
+    # macro.  This avoids these false positives:
+    #  - macro that defines a base class
+    #  - multi-line macro that defines a base class
+    #  - macro that defines the whole class-head
+    #
+    # But we still issue warnings for macros that we know are safe to
+    # warn, specifically:
+    #  - TEST, TEST_F, TEST_P, MATCHER, MATCHER_P
+    #  - TYPED_TEST
+    #  - INTERFACE_DEF
+    #  - EXCLUSIVE_LOCKS_REQUIRED, SHARED_LOCKS_REQUIRED, LOCKS_EXCLUDED:
+    #
+    # We implement a whitelist of safe macros instead of a blacklist of
+    # unsafe macros, even though the latter appears less frequently in
+    # google code and would have been easier to implement.  This is because
+    # the downside for getting the whitelist wrong means some extra
+    # semicolons, while the downside for getting the blacklist wrong
+    # would result in compile errors.
+    #
+    # In addition to macros, we also don't want to warn on
+    #  - Compound literals
+    #  - Lambdas
+    #  - alignas specifier with anonymous structs
+    #  - decltype
+    closing_brace_pos = match.group(1).rfind(')')
+    opening_parenthesis = ReverseCloseExpression(
+        clean_lines, linenum, closing_brace_pos)
+    if opening_parenthesis[2] > -1:
+      line_prefix = opening_parenthesis[0][0:opening_parenthesis[2]]
+      macro = Search(r'\b([A-Z_][A-Z0-9_]*)\s*$', line_prefix)
+      func = Match(r'^(.*\])\s*$', line_prefix)
+      if ((macro and
+           macro.group(1) not in (
+               'TEST', 'TEST_F', 'MATCHER', 'MATCHER_P', 'TYPED_TEST',
+               'EXCLUSIVE_LOCKS_REQUIRED', 'SHARED_LOCKS_REQUIRED',
+               'LOCKS_EXCLUDED', 'INTERFACE_DEF')) or
+          (func and not Search(r'\boperator\s*\[\s*\]', func.group(1))) or
+          Search(r'\b(?:struct|union)\s+alignas\s*$', line_prefix) or
+          Search(r'\bdecltype$', line_prefix) or
+          Search(r'\s+=\s*$', line_prefix)):
+        match = None
+    if (match and
+        opening_parenthesis[1] > 1 and
+        Search(r'\]\s*$', clean_lines.elided[opening_parenthesis[1] - 1])):
+      # Multi-line lambda-expression
+      match = None
+
+  else:
+    # Try matching cases 2-3.
+    match = Match(r'^(.*(?:else|\)\s*const)\s*)\{', line)
+    if not match:
+      # Try matching cases 4-6.  These are always matched on separate lines.
+      #
+      # Note that we can't simply concatenate the previous line to the
+      # current line and do a single match, otherwise we may output
+      # duplicate warnings for the blank line case:
+      #   if (cond) {
+      #     // blank line
+      #   }
+      prevline = GetPreviousNonBlankLine(clean_lines, linenum)[0]
+      if prevline and Search(r'[;{}]\s*$', prevline):
+        match = Match(r'^(\s*)\{', line)
+
+  # Check matching closing brace
+  if match:
+    (endline, endlinenum, endpos) = CloseExpression(
+        clean_lines, linenum, len(match.group(1)))
+    if endpos > -1 and Match(r'^\s*;', endline[endpos:]):
+      # Current {} pair is eligible for semicolon check, and we have found
+      # the redundant semicolon, output warning here.
+      #
+      # Note: because we are scanning forward for opening braces, and
+      # outputting warnings for the matching closing brace, if there are
+      # nested blocks with trailing semicolons, we will get the error
+      # messages in reversed order.
+
+      # We need to check the line forward for NOLINT
+      raw_lines = clean_lines.raw_lines
+      ParseNolintSuppressions(filename, raw_lines[endlinenum-1], endlinenum-1,
+                              error)
+      ParseNolintSuppressions(filename, raw_lines[endlinenum], endlinenum,
+                              error)
+
+      error(filename, endlinenum, 'readability/braces', 4,
+            "You don't need a ; after a }")
+
+
+def CheckEmptyBlockBody(filename, clean_lines, linenum, error):
+  """Look for empty loop/conditional body with only a single semicolon.
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    error: The function to call with any errors found.
+  """
+
+  # Search for loop keywords at the beginning of the line.  Because only
+  # whitespaces are allowed before the keywords, this will also ignore most
+  # do-while-loops, since those lines should start with closing brace.
+  #
+  # We also check "if" blocks here, since an empty conditional block
+  # is likely an error.
+  line = clean_lines.elided[linenum]
+  matched = Match(r'\s*(for|while|if)\s*\(', line)
+  if matched:
+    # Find the end of the conditional expression.
+    (end_line, end_linenum, end_pos) = CloseExpression(
+        clean_lines, linenum, line.find('('))
+
+    # Output warning if what follows the condition expression is a semicolon.
+    # No warning for all other cases, including whitespace or newline, since we
+    # have a separate check for semicolons preceded by whitespace.
+    if end_pos >= 0 and Match(r';', end_line[end_pos:]):
+      if matched.group(1) == 'if':
+        error(filename, end_linenum, 'whitespace/empty_conditional_body', 5,
+              'Empty conditional bodies should use {}')
+      else:
+        error(filename, end_linenum, 'whitespace/empty_loop_body', 5,
+              'Empty loop bodies should use {} or continue')
+
+    # Check for if statements that have completely empty bodies (no comments)
+    # and no else clauses.
+    if end_pos >= 0 and matched.group(1) == 'if':
+      # Find the position of the opening { for the if statement.
+      # Return without logging an error if it has no brackets.
+      opening_linenum = end_linenum
+      opening_line_fragment = end_line[end_pos:]
+      # Loop until EOF or find anything that's not whitespace or opening {.
+      while not Search(r'^\s*\{', opening_line_fragment):
+        if Search(r'^(?!\s*$)', opening_line_fragment):
+          # Conditional has no brackets.
+          return
+        opening_linenum += 1
+        if opening_linenum == len(clean_lines.elided):
+          # Couldn't find conditional's opening { or any code before EOF.
+          return
+        opening_line_fragment = clean_lines.elided[opening_linenum]
+      # Set opening_line (opening_line_fragment may not be entire opening line).
+      opening_line = clean_lines.elided[opening_linenum]
+
+      # Find the position of the closing }.
+      opening_pos = opening_line_fragment.find('{')
+      if opening_linenum == end_linenum:
+        # We need to make opening_pos relative to the start of the entire line.
+        opening_pos += end_pos
+      (closing_line, closing_linenum, closing_pos) = CloseExpression(
+          clean_lines, opening_linenum, opening_pos)
+      if closing_pos < 0:
+        return
+
+      # Now construct the body of the conditional. This consists of the portion
+      # of the opening line after the {, all lines until the closing line,
+      # and the portion of the closing line before the }.
+      if (clean_lines.raw_lines[opening_linenum] !=
+          CleanseComments(clean_lines.raw_lines[opening_linenum])):
+        # Opening line ends with a comment, so conditional isn't empty.
+        return
+      if closing_linenum > opening_linenum:
+        # Opening line after the {. Ignore comments here since we checked above.
+        bodylist = list(opening_line[opening_pos+1:])
+        # All lines until closing line, excluding closing line, with comments.
+        bodylist.extend(clean_lines.raw_lines[opening_linenum+1:closing_linenum])
+        # Closing line before the }. Won't (and can't) have comments.
+        bodylist.append(clean_lines.elided[closing_linenum][:closing_pos-1])
+        body = '\n'.join(bodylist)
+      else:
+        # If statement has brackets and fits on a single line.
+        body = opening_line[opening_pos+1:closing_pos-1]
+
+      # Check if the body is empty
+      if not _EMPTY_CONDITIONAL_BODY_PATTERN.search(body):
+        return
+      # The body is empty. Now make sure there's not an else clause.
+      current_linenum = closing_linenum
+      current_line_fragment = closing_line[closing_pos:]
+      # Loop until EOF or find anything that's not whitespace or else clause.
+      while Search(r'^\s*$|^(?=\s*else)', current_line_fragment):
+        if Search(r'^(?=\s*else)', current_line_fragment):
+          # Found an else clause, so don't log an error.
+          return
+        current_linenum += 1
+        if current_linenum == len(clean_lines.elided):
+          break
+        current_line_fragment = clean_lines.elided[current_linenum]
+
+      # The body is empty and there's no else clause until EOF or other code.
+      error(filename, end_linenum, 'whitespace/empty_if_body', 4,
+            ('If statement had no body and no else clause'))
+
+
+def FindCheckMacro(line):
+  """Find a replaceable CHECK-like macro.
+
+  Args:
+    line: line to search on.
+  Returns:
+    (macro name, start position), or (None, -1) if no replaceable
+    macro is found.
+  """
+  for macro in _CHECK_MACROS:
+    i = line.find(macro)
+    if i >= 0:
+      # Find opening parenthesis.  Do a regular expression match here
+      # to make sure that we are matching the expected CHECK macro, as
+      # opposed to some other macro that happens to contain the CHECK
+      # substring.
+      matched = Match(r'^(.*\b' + macro + r'\s*)\(', line)
+      if not matched:
+        continue
+      return (macro, len(matched.group(1)))
+  return (None, -1)
+
+
+def CheckCheck(filename, clean_lines, linenum, error):
+  """Checks the use of CHECK and EXPECT macros.
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    error: The function to call with any errors found.
+  """
+
+  # Decide the set of replacement macros that should be suggested
+  lines = clean_lines.elided
+  (check_macro, start_pos) = FindCheckMacro(lines[linenum])
+  if not check_macro:
+    return
+
+  # Find end of the boolean expression by matching parentheses
+  (last_line, end_line, end_pos) = CloseExpression(
+      clean_lines, linenum, start_pos)
+  if end_pos < 0:
+    return
+
+  # If the check macro is followed by something other than a
+  # semicolon, assume users will log their own custom error messages
+  # and don't suggest any replacements.
+  if not Match(r'\s*;', last_line[end_pos:]):
+    return
+
+  if linenum == end_line:
+    expression = lines[linenum][start_pos + 1:end_pos - 1]
+  else:
+    expression = lines[linenum][start_pos + 1:]
+    for i in xrange(linenum + 1, end_line):
+      expression += lines[i]
+    expression += last_line[0:end_pos - 1]
+
+  # Parse expression so that we can take parentheses into account.
+  # This avoids false positives for inputs like "CHECK((a < 4) == b)",
+  # which is not replaceable by CHECK_LE.
+  lhs = ''
+  rhs = ''
+  operator = None
+  while expression:
+    matched = Match(r'^\s*(<<|<<=|>>|>>=|->\*|->|&&|\|\||'
+                    r'==|!=|>=|>|<=|<|\()(.*)$', expression)
+    if matched:
+      token = matched.group(1)
+      if token == '(':
+        # Parenthesized operand
+        expression = matched.group(2)
+        (end, _) = FindEndOfExpressionInLine(expression, 0, ['('])
+        if end < 0:
+          return  # Unmatched parenthesis
+        lhs += '(' + expression[0:end]
+        expression = expression[end:]
+      elif token in ('&&', '||'):
+        # Logical and/or operators.  This means the expression
+        # contains more than one term, for example:
+        #   CHECK(42 < a && a < b);
+        #
+        # These are not replaceable with CHECK_LE, so bail out early.
+        return
+      elif token in ('<<', '<<=', '>>', '>>=', '->*', '->'):
+        # Non-relational operator
+        lhs += token
+        expression = matched.group(2)
+      else:
+        # Relational operator
+        operator = token
+        rhs = matched.group(2)
+        break
+    else:
+      # Unparenthesized operand.  Instead of appending to lhs one character
+      # at a time, we do another regular expression match to consume several
+      # characters at once if possible.  Trivial benchmark shows that this
+      # is more efficient when the operands are longer than a single
+      # character, which is generally the case.
+      matched = Match(r'^([^-=!<>()&|]+)(.*)$', expression)
+      if not matched:
+        matched = Match(r'^(\s*\S)(.*)$', expression)
+        if not matched:
+          break
+      lhs += matched.group(1)
+      expression = matched.group(2)
+
+  # Only apply checks if we got all parts of the boolean expression
+  if not (lhs and operator and rhs):
+    return
+
+  # Check that rhs do not contain logical operators.  We already know
+  # that lhs is fine since the loop above parses out && and ||.
+  if rhs.find('&&') > -1 or rhs.find('||') > -1:
+    return
+
+  # At least one of the operands must be a constant literal.  This is
+  # to avoid suggesting replacements for unprintable things like
+  # CHECK(variable != iterator)
+  #
+  # The following pattern matches decimal, hex integers, strings, and
+  # characters (in that order).
+  lhs = lhs.strip()
+  rhs = rhs.strip()
+  match_constant = r'^([-+]?(\d+|0[xX][0-9a-fA-F]+)[lLuU]{0,3}|".*"|\'.*\')$'
+  if Match(match_constant, lhs) or Match(match_constant, rhs):
+    # Note: since we know both lhs and rhs, we can provide a more
+    # descriptive error message like:
+    #   Consider using CHECK_EQ(x, 42) instead of CHECK(x == 42)
+    # Instead of:
+    #   Consider using CHECK_EQ instead of CHECK(a == b)
+    #
+    # We are still keeping the less descriptive message because if lhs
+    # or rhs gets long, the error message might become unreadable.
+    error(filename, linenum, 'readability/check', 2,
+          'Consider using %s instead of %s(a %s b)' % (
+              _CHECK_REPLACEMENT[check_macro][operator],
+              check_macro, operator))
+
+
+def CheckAltTokens(filename, clean_lines, linenum, error):
+  """Check alternative keywords being used in boolean expressions.
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    error: The function to call with any errors found.
+  """
+  line = clean_lines.elided[linenum]
+
+  # Avoid preprocessor lines
+  if Match(r'^\s*#', line):
+    return
+
+  # Last ditch effort to avoid multi-line comments.  This will not help
+  # if the comment started before the current line or ended after the
+  # current line, but it catches most of the false positives.  At least,
+  # it provides a way to workaround this warning for people who use
+  # multi-line comments in preprocessor macros.
+  #
+  # TODO(unknown): remove this once cpplint has better support for
+  # multi-line comments.
+  if line.find('/*') >= 0 or line.find('*/') >= 0:
+    return
+
+  for match in _ALT_TOKEN_REPLACEMENT_PATTERN.finditer(line):
+    error(filename, linenum, 'readability/alt_tokens', 2,
+          'Use operator %s instead of %s' % (
+              _ALT_TOKEN_REPLACEMENT[match.group(1)], match.group(1)))
+
+
+def GetLineWidth(line):
+  """Determines the width of the line in column positions.
+
+  Args:
+    line: A string, which may be a Unicode string.
+
+  Returns:
+    The width of the line in column positions, accounting for Unicode
+    combining characters and wide characters.
+  """
+  if isinstance(line, unicode):
+    width = 0
+    for uc in unicodedata.normalize('NFC', line):
+      if unicodedata.east_asian_width(uc) in ('W', 'F'):
+        width += 2
+      elif not unicodedata.combining(uc):
+        width += 1
+    return width
+  else:
+    return len(line)
+
+
+def CheckStyle(filename, clean_lines, linenum, file_extension, nesting_state,
+               error):
+  """Checks rules from the 'C++ style rules' section of cppguide.html.
+
+  Most of these rules are hard to test (naming, comment style), but we
+  do what we can.  In particular we check for 2-space indents, line lengths,
+  tab usage, spaces inside code, etc.
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    file_extension: The extension (without the dot) of the filename.
+    nesting_state: A NestingState instance which maintains information about
+                   the current stack of nested blocks being parsed.
+    error: The function to call with any errors found.
+  """
+
+  # Don't use "elided" lines here, otherwise we can't check commented lines.
+  # Don't want to use "raw" either, because we don't want to check inside C++11
+  # raw strings,
+  raw_lines = clean_lines.lines_without_raw_strings
+  line = raw_lines[linenum]
+  prev = raw_lines[linenum - 1] if linenum > 0 else ''
+
+  if line.find('\t') != -1:
+    error(filename, linenum, 'whitespace/tab', 1,
+          'Tab found; better to use spaces')
+
+  # One or three blank spaces at the beginning of the line is weird; it's
+  # hard to reconcile that with 2-space indents.
+  # NOTE: here are the conditions rob pike used for his tests.  Mine aren't
+  # as sophisticated, but it may be worth becoming so:  RLENGTH==initial_spaces
+  # if(RLENGTH > 20) complain = 0;
+  # if(match($0, " +(error|private|public|protected):")) complain = 0;
+  # if(match(prev, "&& *$")) complain = 0;
+  # if(match(prev, "\\|\\| *$")) complain = 0;
+  # if(match(prev, "[\",=><] *$")) complain = 0;
+  # if(match($0, " <<")) complain = 0;
+  # if(match(prev, " +for \\(")) complain = 0;
+  # if(prevodd && match(prevprev, " +for \\(")) complain = 0;
+  scope_or_label_pattern = r'\s*\w+\s*:\s*\\?$'
+  classinfo = nesting_state.InnermostClass()
+  initial_spaces = 0
+  cleansed_line = clean_lines.elided[linenum]
+  while initial_spaces < len(line) and line[initial_spaces] == ' ':
+    initial_spaces += 1
+  # There are certain situations we allow one space, notably for
+  # section labels, and also lines containing multi-line raw strings.
+  # We also don't check for lines that look like continuation lines
+  # (of lines ending in double quotes, commas, equals, or angle brackets)
+  # because the rules for how to indent those are non-trivial.
+  if (not Search(r'[",=><] *$', prev) and
+      (initial_spaces == 1 or initial_spaces == 3) and
+      not Match(scope_or_label_pattern, cleansed_line) and
+      not (clean_lines.raw_lines[linenum] != line and
+           Match(r'^\s*""', line))):
+    error(filename, linenum, 'whitespace/indent', 3,
+          'Weird number of spaces at line-start.  '
+          'Are you using a 2-space indent?')
+
+  if line and line[-1].isspace():
+    error(filename, linenum, 'whitespace/end_of_line', 4,
+          'Line ends in whitespace.  Consider deleting these extra spaces.')
+
+  # Check if the line is a header guard.
+  is_header_guard = False
+  if file_extension in GetHeaderExtensions():
+    cppvar = GetHeaderGuardCPPVariable(filename)
+    if (line.startswith('#ifndef %s' % cppvar) or
+        line.startswith('#define %s' % cppvar) or
+        line.startswith('#endif  // %s' % cppvar)):
+      is_header_guard = True
+  # #include lines and header guards can be long, since there's no clean way to
+  # split them.
+  #
+  # URLs can be long too.  It's possible to split these, but it makes them
+  # harder to cut&paste.
+  #
+  # The "$Id:...$" comment may also get very long without it being the
+  # developers fault.
+  #
+  # Doxygen documentation copying can get pretty long when using an overloaded
+  # function declaration
+  if (not line.startswith('#include') and not is_header_guard and
+      not Match(r'^\s*//.*http(s?)://\S*$', line) and
+      not Match(r'^\s*//\s*[^\s]*$', line) and
+      not Match(r'^// \$Id:.*#[0-9]+ \$$', line) and
+      not Match(r'^\s*/// [@\\](copydoc|copydetails|copybrief) .*$', line)):
+    line_width = GetLineWidth(line)
+    if line_width > _line_length:
+      error(filename, linenum, 'whitespace/line_length', 2,
+            'Lines should be <= %i characters long' % _line_length)
+
+  if (cleansed_line.count(';') > 1 and
+      # allow simple single line lambdas
+      not Match(r'^[^{};]*\[[^\[\]]*\][^{}]*\{[^{}\n\r]*\}',
+                line) and
+      # for loops are allowed two ;'s (and may run over two lines).
+      cleansed_line.find('for') == -1 and
+      (GetPreviousNonBlankLine(clean_lines, linenum)[0].find('for') == -1 or
+       GetPreviousNonBlankLine(clean_lines, linenum)[0].find(';') != -1) and
+      # It's ok to have many commands in a switch case that fits in 1 line
+      not ((cleansed_line.find('case ') != -1 or
+            cleansed_line.find('default:') != -1) and
+           cleansed_line.find('break;') != -1)):
+    error(filename, linenum, 'whitespace/newline', 0,
+          'More than one command on the same line')
+
+  # Some more style checks
+  CheckBraces(filename, clean_lines, linenum, error)
+  CheckTrailingSemicolon(filename, clean_lines, linenum, error)
+  CheckEmptyBlockBody(filename, clean_lines, linenum, error)
+  CheckAccess(filename, clean_lines, linenum, nesting_state, error)
+  CheckSpacing(filename, clean_lines, linenum, nesting_state, error)
+  CheckOperatorSpacing(filename, clean_lines, linenum, error)
+  CheckParenthesisSpacing(filename, clean_lines, linenum, error)
+  CheckCommaSpacing(filename, clean_lines, linenum, error)
+  CheckBracesSpacing(filename, clean_lines, linenum, nesting_state, error)
+  CheckSpacingForFunctionCall(filename, clean_lines, linenum, error)
+  CheckCheck(filename, clean_lines, linenum, error)
+  CheckAltTokens(filename, clean_lines, linenum, error)
+  classinfo = nesting_state.InnermostClass()
+  if classinfo:
+    CheckSectionSpacing(filename, clean_lines, classinfo, linenum, error)
+
+
+_RE_PATTERN_INCLUDE = re.compile(r'^\s*#\s*include\s*([<"])([^>"]*)[>"].*$')
+# Matches the first component of a filename delimited by -s and _s. That is:
+#  _RE_FIRST_COMPONENT.match('foo').group(0) == 'foo'
+#  _RE_FIRST_COMPONENT.match('foo.cc').group(0) == 'foo'
+#  _RE_FIRST_COMPONENT.match('foo-bar_baz.cc').group(0) == 'foo'
+#  _RE_FIRST_COMPONENT.match('foo_bar-baz.cc').group(0) == 'foo'
+_RE_FIRST_COMPONENT = re.compile(r'^[^-_.]+')
+
+
+def _DropCommonSuffixes(filename):
+  """Drops common suffixes like _test.cc or -inl.h from filename.
+
+  For example:
+    >>> _DropCommonSuffixes('foo/foo-inl.h')
+    'foo/foo'
+    >>> _DropCommonSuffixes('foo/bar/foo.cc')
+    'foo/bar/foo'
+    >>> _DropCommonSuffixes('foo/foo_internal.h')
+    'foo/foo'
+    >>> _DropCommonSuffixes('foo/foo_unusualinternal.h')
+    'foo/foo_unusualinternal'
+
+  Args:
+    filename: The input filename.
+
+  Returns:
+    The filename with the common suffix removed.
+  """
+  for suffix in itertools.chain(
+      ('%s.%s' % (test_suffix.lstrip('_'), ext)
+       for test_suffix, ext in itertools.product(_test_suffixes, GetNonHeaderExtensions())),
+      ('%s.%s' % (suffix, ext)
+       for suffix, ext in itertools.product(['inl', 'imp', 'internal'], GetHeaderExtensions()))):
+    if (filename.endswith(suffix) and len(filename) > len(suffix) and
+        filename[-len(suffix) - 1] in ('-', '_')):
+      return filename[:-len(suffix) - 1]
+  return os.path.splitext(filename)[0]
+
+
+def _ClassifyInclude(fileinfo, include, is_system):
+  """Figures out what kind of header 'include' is.
+
+  Args:
+    fileinfo: The current file cpplint is running over. A FileInfo instance.
+    include: The path to a #included file.
+    is_system: True if the #include used <> rather than "".
+
+  Returns:
+    One of the _XXX_HEADER constants.
+
+  For example:
+    >>> _ClassifyInclude(FileInfo('foo/foo.cc'), 'stdio.h', True)
+    _C_SYS_HEADER
+    >>> _ClassifyInclude(FileInfo('foo/foo.cc'), 'string', True)
+    _CPP_SYS_HEADER
+    >>> _ClassifyInclude(FileInfo('foo/foo.cc'), 'foo/foo.h', False)
+    _LIKELY_MY_HEADER
+    >>> _ClassifyInclude(FileInfo('foo/foo_unknown_extension.cc'),
+    ...                  'bar/foo_other_ext.h', False)
+    _POSSIBLE_MY_HEADER
+    >>> _ClassifyInclude(FileInfo('foo/foo.cc'), 'foo/bar.h', False)
+    _OTHER_HEADER
+  """
+  # This is a list of all standard c++ header files, except
+  # those already checked for above.
+  is_cpp_h = include in _CPP_HEADERS
+
+  # Headers with C++ extensions shouldn't be considered C system headers
+  if is_system and os.path.splitext(include)[1] in ['.hpp', '.hxx', '.h++']:
+      is_system = False
+
+  if is_system:
+    if is_cpp_h:
+      return _CPP_SYS_HEADER
+    else:
+      return _C_SYS_HEADER
+
+  # If the target file and the include we're checking share a
+  # basename when we drop common extensions, and the include
+  # lives in . , then it's likely to be owned by the target file.
+  target_dir, target_base = (
+      os.path.split(_DropCommonSuffixes(fileinfo.RepositoryName())))
+  include_dir, include_base = os.path.split(_DropCommonSuffixes(include))
+  target_dir_pub = os.path.normpath(target_dir + '/../public')
+  target_dir_pub = target_dir_pub.replace('\\', '/')
+  if target_base == include_base and (
+      include_dir == target_dir or
+      include_dir == target_dir_pub):
+    return _LIKELY_MY_HEADER
+
+  # If the target and include share some initial basename
+  # component, it's possible the target is implementing the
+  # include, so it's allowed to be first, but we'll never
+  # complain if it's not there.
+  target_first_component = _RE_FIRST_COMPONENT.match(target_base)
+  include_first_component = _RE_FIRST_COMPONENT.match(include_base)
+  if (target_first_component and include_first_component and
+      target_first_component.group(0) ==
+      include_first_component.group(0)):
+    return _POSSIBLE_MY_HEADER
+
+  return _OTHER_HEADER
+
+
+
+def CheckIncludeLine(filename, clean_lines, linenum, include_state, error):
+  """Check rules that are applicable to #include lines.
+
+  Strings on #include lines are NOT removed from elided line, to make
+  certain tasks easier. However, to prevent false positives, checks
+  applicable to #include lines in CheckLanguage must be put here.
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    include_state: An _IncludeState instance in which the headers are inserted.
+    error: The function to call with any errors found.
+  """
+  fileinfo = FileInfo(filename)
+  line = clean_lines.lines[linenum]
+
+  # "include" should use the new style "foo/bar.h" instead of just "bar.h"
+  # Only do this check if the included header follows google naming
+  # conventions.  If not, assume that it's a 3rd party API that
+  # requires special include conventions.
+  #
+  # We also make an exception for Lua headers, which follow google
+  # naming convention but not the include convention.
+  match = Match(r'#include\s*"([^/]+\.h)"', line)
+  if match and not _THIRD_PARTY_HEADERS_PATTERN.match(match.group(1)):
+    error(filename, linenum, 'build/include_subdir', 4,
+          'Include the directory when naming .h files')
+
+  # we shouldn't include a file more than once. actually, there are a
+  # handful of instances where doing so is okay, but in general it's
+  # not.
+  match = _RE_PATTERN_INCLUDE.search(line)
+  if match:
+    include = match.group(2)
+    is_system = (match.group(1) == '<')
+    duplicate_line = include_state.FindHeader(include)
+    if duplicate_line >= 0:
+      error(filename, linenum, 'build/include', 4,
+            '"%s" already included at %s:%s' %
+            (include, filename, duplicate_line))
+      return
+
+    for extension in GetNonHeaderExtensions():
+      if (include.endswith('.' + extension) and
+          os.path.dirname(fileinfo.RepositoryName()) != os.path.dirname(include)):
+        error(filename, linenum, 'build/include', 4,
+              'Do not include .' + extension + ' files from other packages')
+        return
+
+    if not _THIRD_PARTY_HEADERS_PATTERN.match(include):
+      include_state.include_list[-1].append((include, linenum))
+
+      # We want to ensure that headers appear in the right order:
+      # 1) for foo.cc, foo.h  (preferred location)
+      # 2) c system files
+      # 3) cpp system files
+      # 4) for foo.cc, foo.h  (deprecated location)
+      # 5) other google headers
+      #
+      # We classify each include statement as one of those 5 types
+      # using a number of techniques. The include_state object keeps
+      # track of the highest type seen, and complains if we see a
+      # lower type after that.
+      error_message = include_state.CheckNextIncludeOrder(
+          _ClassifyInclude(fileinfo, include, is_system))
+      if error_message:
+        error(filename, linenum, 'build/include_order', 4,
+              '%s. Should be: %s.h, c system, c++ system, other.' %
+              (error_message, fileinfo.BaseName()))
+      canonical_include = include_state.CanonicalizeAlphabeticalOrder(include)
+      if not include_state.IsInAlphabeticalOrder(
+          clean_lines, linenum, canonical_include):
+        error(filename, linenum, 'build/include_alpha', 4,
+              'Include "%s" not in alphabetical order' % include)
+      include_state.SetLastHeader(canonical_include)
+
+
+
+def _GetTextInside(text, start_pattern):
+  r"""Retrieves all the text between matching open and close parentheses.
+
+  Given a string of lines and a regular expression string, retrieve all the text
+  following the expression and between opening punctuation symbols like
+  (, [, or {, and the matching close-punctuation symbol. This properly nested
+  occurrences of the punctuations, so for the text like
+    printf(a(), b(c()));
+  a call to _GetTextInside(text, r'printf\(') will return 'a(), b(c())'.
+  start_pattern must match string having an open punctuation symbol at the end.
+
+  Args:
+    text: The lines to extract text. Its comments and strings must be elided.
+           It can be single line and can span multiple lines.
+    start_pattern: The regexp string indicating where to start extracting
+                   the text.
+  Returns:
+    The extracted text.
+    None if either the opening string or ending punctuation could not be found.
+  """
+  # TODO(unknown): Audit cpplint.py to see what places could be profitably
+  # rewritten to use _GetTextInside (and use inferior regexp matching today).
+
+  # Give opening punctuations to get the matching close-punctuations.
+  matching_punctuation = {'(': ')', '{': '}', '[': ']'}
+  closing_punctuation = set(itervalues(matching_punctuation))
+
+  # Find the position to start extracting text.
+  match = re.search(start_pattern, text, re.M)
+  if not match:  # start_pattern not found in text.
+    return None
+  start_position = match.end(0)
+
+  assert start_position > 0, (
+      'start_pattern must ends with an opening punctuation.')
+  assert text[start_position - 1] in matching_punctuation, (
+      'start_pattern must ends with an opening punctuation.')
+  # Stack of closing punctuations we expect to have in text after position.
+  punctuation_stack = [matching_punctuation[text[start_position - 1]]]
+  position = start_position
+  while punctuation_stack and position < len(text):
+    if text[position] == punctuation_stack[-1]:
+      punctuation_stack.pop()
+    elif text[position] in closing_punctuation:
+      # A closing punctuation without matching opening punctuations.
+      return None
+    elif text[position] in matching_punctuation:
+      punctuation_stack.append(matching_punctuation[text[position]])
+    position += 1
+  if punctuation_stack:
+    # Opening punctuations left without matching close-punctuations.
+    return None
+  # punctuations match.
+  return text[start_position:position - 1]
+
+
+# Patterns for matching call-by-reference parameters.
+#
+# Supports nested templates up to 2 levels deep using this messy pattern:
+#   < (?: < (?: < [^<>]*
+#               >
+#           |   [^<>] )*
+#         >
+#     |   [^<>] )*
+#   >
+_RE_PATTERN_IDENT = r'[_a-zA-Z]\w*'  # =~ [[:alpha:]][[:alnum:]]*
+_RE_PATTERN_TYPE = (
+    r'(?:const\s+)?(?:typename\s+|class\s+|struct\s+|union\s+|enum\s+)?'
+    r'(?:\w|'
+    r'\s*<(?:<(?:<[^<>]*>|[^<>])*>|[^<>])*>|'
+    r'::)+')
+# A call-by-reference parameter ends with '& identifier'.
+_RE_PATTERN_REF_PARAM = re.compile(
+    r'(' + _RE_PATTERN_TYPE + r'(?:\s*(?:\bconst\b|[*]))*\s*'
+    r'&\s*' + _RE_PATTERN_IDENT + r')\s*(?:=[^,()]+)?[,)]')
+# A call-by-const-reference parameter either ends with 'const& identifier'
+# or looks like 'const type& identifier' when 'type' is atomic.
+_RE_PATTERN_CONST_REF_PARAM = (
+    r'(?:.*\s*\bconst\s*&\s*' + _RE_PATTERN_IDENT +
+    r'|const\s+' + _RE_PATTERN_TYPE + r'\s*&\s*' + _RE_PATTERN_IDENT + r')')
+# Stream types.
+_RE_PATTERN_REF_STREAM_PARAM = (
+    r'(?:.*stream\s*&\s*' + _RE_PATTERN_IDENT + r')')
+
+
+def CheckLanguage(filename, clean_lines, linenum, file_extension,
+                  include_state, nesting_state, error):
+  """Checks rules from the 'C++ language rules' section of cppguide.html.
+
+  Some of these rules are hard to test (function overloading, using
+  uint32 inappropriately), but we do the best we can.
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    file_extension: The extension (without the dot) of the filename.
+    include_state: An _IncludeState instance in which the headers are inserted.
+    nesting_state: A NestingState instance which maintains information about
+                   the current stack of nested blocks being parsed.
+    error: The function to call with any errors found.
+  """
+  # If the line is empty or consists of entirely a comment, no need to
+  # check it.
+  line = clean_lines.elided[linenum]
+  if not line:
+    return
+
+  match = _RE_PATTERN_INCLUDE.search(line)
+  if match:
+    CheckIncludeLine(filename, clean_lines, linenum, include_state, error)
+    return
+
+  # Reset include state across preprocessor directives.  This is meant
+  # to silence warnings for conditional includes.
+  match = Match(r'^\s*#\s*(if|ifdef|ifndef|elif|else|endif)\b', line)
+  if match:
+    include_state.ResetSection(match.group(1))
+
+
+  # Perform other checks now that we are sure that this is not an include line
+  CheckCasts(filename, clean_lines, linenum, error)
+  CheckGlobalStatic(filename, clean_lines, linenum, error)
+  CheckPrintf(filename, clean_lines, linenum, error)
+
+  if file_extension in GetHeaderExtensions():
+    # TODO(unknown): check that 1-arg constructors are explicit.
+    #                How to tell it's a constructor?
+    #                (handled in CheckForNonStandardConstructs for now)
+    # TODO(unknown): check that classes declare or disable copy/assign
+    #                (level 1 error)
+    pass
+
+  # Check if people are using the verboten C basic types.  The only exception
+  # we regularly allow is "unsigned short port" for port.
+  if Search(r'\bshort port\b', line):
+    if not Search(r'\bunsigned short port\b', line):
+      error(filename, linenum, 'runtime/int', 4,
+            'Use "unsigned short" for ports, not "short"')
+  else:
+    match = Search(r'\b(short|long(?! +double)|long long)\b', line)
+    if match:
+      error(filename, linenum, 'runtime/int', 4,
+            'Use int16/int64/etc, rather than the C type %s' % match.group(1))
+
+  # Check if some verboten operator overloading is going on
+  # TODO(unknown): catch out-of-line unary operator&:
+  #   class X {};
+  #   int operator&(const X& x) { return 42; }  // unary operator&
+  # The trick is it's hard to tell apart from binary operator&:
+  #   class Y { int operator&(const Y& x) { return 23; } }; // binary operator&
+  if Search(r'\boperator\s*&\s*\(\s*\)', line):
+    error(filename, linenum, 'runtime/operator', 4,
+          'Unary operator& is dangerous.  Do not use it.')
+
+  # Check for suspicious usage of "if" like
+  # } if (a == b) {
+  if Search(r'\}\s*if\s*\(', line):
+    error(filename, linenum, 'readability/braces', 4,
+          'Did you mean "else if"? If not, start a new line for "if".')
+
+  # Check for potential format string bugs like printf(foo).
+  # We constrain the pattern not to pick things like DocidForPrintf(foo).
+  # Not perfect but it can catch printf(foo.c_str()) and printf(foo->c_str())
+  # TODO(unknown): Catch the following case. Need to change the calling
+  # convention of the whole function to process multiple line to handle it.
+  #   printf(
+  #       boy_this_is_a_really_long_variable_that_cannot_fit_on_the_prev_line);
+  printf_args = _GetTextInside(line, r'(?i)\b(string)?printf\s*\(')
+  if printf_args:
+    match = Match(r'([\w.\->()]+)$', printf_args)
+    if match and match.group(1) != '__VA_ARGS__':
+      function_name = re.search(r'\b((?:string)?printf)\s*\(',
+                                line, re.I).group(1)
+      error(filename, linenum, 'runtime/printf', 4,
+            'Potential format string bug. Do %s("%%s", %s) instead.'
+            % (function_name, match.group(1)))
+
+  # Check for potential memset bugs like memset(buf, sizeof(buf), 0).
+  match = Search(r'memset\s*\(([^,]*),\s*([^,]*),\s*0\s*\)', line)
+  if match and not Match(r"^''|-?[0-9]+|0x[0-9A-Fa-f]$", match.group(2)):
+    error(filename, linenum, 'runtime/memset', 4,
+          'Did you mean "memset(%s, 0, %s)"?'
+          % (match.group(1), match.group(2)))
+
+  if Search(r'\busing namespace\b', line):
+    if Search(r'\bliterals\b', line):
+      error(filename, linenum, 'build/namespaces_literals', 5,
+            'Do not use namespace using-directives.  '
+            'Use using-declarations instead.')
+    else:
+      error(filename, linenum, 'build/namespaces', 5,
+            'Do not use namespace using-directives.  '
+            'Use using-declarations instead.')
+
+  # Detect variable-length arrays.
+  match = Match(r'\s*(.+::)?(\w+) [a-z]\w*\[(.+)];', line)
+  if (match and match.group(2) != 'return' and match.group(2) != 'delete' and
+      match.group(3).find(']') == -1):
+    # Split the size using space and arithmetic operators as delimiters.
+    # If any of the resulting tokens are not compile time constants then
+    # report the error.
+    tokens = re.split(r'\s|\+|\-|\*|\/|<<|>>]', match.group(3))
+    is_const = True
+    skip_next = False
+    for tok in tokens:
+      if skip_next:
+        skip_next = False
+        continue
+
+      if Search(r'sizeof\(.+\)', tok): continue
+      if Search(r'arraysize\(\w+\)', tok): continue
+
+      tok = tok.lstrip('(')
+      tok = tok.rstrip(')')
+      if not tok: continue
+      if Match(r'\d+', tok): continue
+      if Match(r'0[xX][0-9a-fA-F]+', tok): continue
+      if Match(r'k[A-Z0-9]\w*', tok): continue
+      if Match(r'(.+::)?k[A-Z0-9]\w*', tok): continue
+      if Match(r'(.+::)?[A-Z][A-Z0-9_]*', tok): continue
+      # A catch all for tricky sizeof cases, including 'sizeof expression',
+      # 'sizeof(*type)', 'sizeof(const type)', 'sizeof(struct StructName)'
+      # requires skipping the next token because we split on ' ' and '*'.
+      if tok.startswith('sizeof'):
+        skip_next = True
+        continue
+      is_const = False
+      break
+    if not is_const:
+      error(filename, linenum, 'runtime/arrays', 1,
+            'Do not use variable-length arrays.  Use an appropriately named '
+            "('k' followed by CamelCase) compile-time constant for the size.")
+
+  # Check for use of unnamed namespaces in header files.  Registration
+  # macros are typically OK, so we allow use of "namespace {" on lines
+  # that end with backslashes.
+  if (file_extension in GetHeaderExtensions()
+      and Search(r'\bnamespace\s*{', line)
+      and line[-1] != '\\'):
+    error(filename, linenum, 'build/namespaces', 4,
+          'Do not use unnamed namespaces in header files.  See '
+          'https://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Namespaces'
+          ' for more information.')
+
+
+def CheckGlobalStatic(filename, clean_lines, linenum, error):
+  """Check for unsafe global or static objects.
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    error: The function to call with any errors found.
+  """
+  line = clean_lines.elided[linenum]
+
+  # Match two lines at a time to support multiline declarations
+  if linenum + 1 < clean_lines.NumLines() and not Search(r'[;({]', line):
+    line += clean_lines.elided[linenum + 1].strip()
+
+  # Check for people declaring static/global STL strings at the top level.
+  # This is dangerous because the C++ language does not guarantee that
+  # globals with constructors are initialized before the first access, and
+  # also because globals can be destroyed when some threads are still running.
+  # TODO(unknown): Generalize this to also find static unique_ptr instances.
+  # TODO(unknown): File bugs for clang-tidy to find these.
+  match = Match(
+      r'((?:|static +)(?:|const +))(?::*std::)?string( +const)? +'
+      r'([a-zA-Z0-9_:]+)\b(.*)',
+      line)
+
+  # Remove false positives:
+  # - String pointers (as opposed to values).
+  #    string *pointer
+  #    const string *pointer
+  #    string const *pointer
+  #    string *const pointer
+  #
+  # - Functions and template specializations.
+  #    string Function<Type>(...
+  #    string Class<Type>::Method(...
+  #
+  # - Operators.  These are matched separately because operator names
+  #   cross non-word boundaries, and trying to match both operators
+  #   and functions at the same time would decrease accuracy of
+  #   matching identifiers.
+  #    string Class::operator*()
+  if (match and
+      not Search(r'\bstring\b(\s+const)?\s*[\*\&]\s*(const\s+)?\w', line) and
+      not Search(r'\boperator\W', line) and
+      not Match(r'\s*(<.*>)?(::[a-zA-Z0-9_]+)*\s*\(([^"]|$)', match.group(4))):
+    if Search(r'\bconst\b', line):
+      error(filename, linenum, 'runtime/string', 4,
+            'For a static/global string constant, use a C style string '
+            'instead: "%schar%s %s[]".' %
+            (match.group(1), match.group(2) or '', match.group(3)))
+    else:
+      error(filename, linenum, 'runtime/string', 4,
+            'Static/global string variables are not permitted.')
+
+  if (Search(r'\b([A-Za-z0-9_]*_)\(\1\)', line) or
+      Search(r'\b([A-Za-z0-9_]*_)\(CHECK_NOTNULL\(\1\)\)', line)):
+    error(filename, linenum, 'runtime/init', 4,
+          'You seem to be initializing a member variable with itself.')
+
+
+def CheckPrintf(filename, clean_lines, linenum, error):
+  """Check for printf related issues.
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    error: The function to call with any errors found.
+  """
+  line = clean_lines.elided[linenum]
+
+  # When snprintf is used, the second argument shouldn't be a literal.
+  match = Search(r'snprintf\s*\(([^,]*),\s*([0-9]*)\s*,', line)
+  if match and match.group(2) != '0':
+    # If 2nd arg is zero, snprintf is used to calculate size.
+    error(filename, linenum, 'runtime/printf', 3,
+          'If you can, use sizeof(%s) instead of %s as the 2nd arg '
+          'to snprintf.' % (match.group(1), match.group(2)))
+
+  # Check if some verboten C functions are being used.
+  if Search(r'\bsprintf\s*\(', line):
+    error(filename, linenum, 'runtime/printf', 5,
+          'Never use sprintf. Use snprintf instead.')
+  match = Search(r'\b(strcpy|strcat)\s*\(', line)
+  if match:
+    error(filename, linenum, 'runtime/printf', 4,
+          'Almost always, snprintf is better than %s' % match.group(1))
+
+
+def IsDerivedFunction(clean_lines, linenum):
+  """Check if current line contains an inherited function.
+
+  Args:
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+  Returns:
+    True if current line contains a function with "override"
+    virt-specifier.
+  """
+  # Scan back a few lines for start of current function
+  for i in xrange(linenum, max(-1, linenum - 10), -1):
+    match = Match(r'^([^()]*\w+)\(', clean_lines.elided[i])
+    if match:
+      # Look for "override" after the matching closing parenthesis
+      line, _, closing_paren = CloseExpression(
+          clean_lines, i, len(match.group(1)))
+      return (closing_paren >= 0 and
+              Search(r'\boverride\b', line[closing_paren:]))
+  return False
+
+
+def IsOutOfLineMethodDefinition(clean_lines, linenum):
+  """Check if current line contains an out-of-line method definition.
+
+  Args:
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+  Returns:
+    True if current line contains an out-of-line method definition.
+  """
+  # Scan back a few lines for start of current function
+  for i in xrange(linenum, max(-1, linenum - 10), -1):
+    if Match(r'^([^()]*\w+)\(', clean_lines.elided[i]):
+      return Match(r'^[^()]*\w+::\w+\(', clean_lines.elided[i]) is not None
+  return False
+
+
+def IsInitializerList(clean_lines, linenum):
+  """Check if current line is inside constructor initializer list.
+
+  Args:
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+  Returns:
+    True if current line appears to be inside constructor initializer
+    list, False otherwise.
+  """
+  for i in xrange(linenum, 1, -1):
+    line = clean_lines.elided[i]
+    if i == linenum:
+      remove_function_body = Match(r'^(.*)\{\s*$', line)
+      if remove_function_body:
+        line = remove_function_body.group(1)
+
+    if Search(r'\s:\s*\w+[({]', line):
+      # A lone colon tend to indicate the start of a constructor
+      # initializer list.  It could also be a ternary operator, which
+      # also tend to appear in constructor initializer lists as
+      # opposed to parameter lists.
+      return True
+    if Search(r'\}\s*,\s*$', line):
+      # A closing brace followed by a comma is probably the end of a
+      # brace-initialized member in constructor initializer list.
+      return True
+    if Search(r'[{};]\s*$', line):
+      # Found one of the following:
+      # - A closing brace or semicolon, probably the end of the previous
+      #   function.
+      # - An opening brace, probably the start of current class or namespace.
+      #
+      # Current line is probably not inside an initializer list since
+      # we saw one of those things without seeing the starting colon.
+      return False
+
+  # Got to the beginning of the file without seeing the start of
+  # constructor initializer list.
+  return False
+
+
+def CheckForNonConstReference(filename, clean_lines, linenum,
+                              nesting_state, error):
+  """Check for non-const references.
+
+  Separate from CheckLanguage since it scans backwards from current
+  line, instead of scanning forward.
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    nesting_state: A NestingState instance which maintains information about
+                   the current stack of nested blocks being parsed.
+    error: The function to call with any errors found.
+  """
+  # Do nothing if there is no '&' on current line.
+  line = clean_lines.elided[linenum]
+  if '&' not in line:
+    return
+
+  # If a function is inherited, current function doesn't have much of
+  # a choice, so any non-const references should not be blamed on
+  # derived function.
+  if IsDerivedFunction(clean_lines, linenum):
+    return
+
+  # Don't warn on out-of-line method definitions, as we would warn on the
+  # in-line declaration, if it isn't marked with 'override'.
+  if IsOutOfLineMethodDefinition(clean_lines, linenum):
+    return
+
+  # Long type names may be broken across multiple lines, usually in one
+  # of these forms:
+  #   LongType
+  #       ::LongTypeContinued &identifier
+  #   LongType::
+  #       LongTypeContinued &identifier
+  #   LongType<
+  #       ...>::LongTypeContinued &identifier
+  #
+  # If we detected a type split across two lines, join the previous
+  # line to current line so that we can match const references
+  # accordingly.
+  #
+  # Note that this only scans back one line, since scanning back
+  # arbitrary number of lines would be expensive.  If you have a type
+  # that spans more than 2 lines, please use a typedef.
+  if linenum > 1:
+    previous = None
+    if Match(r'\s*::(?:[\w<>]|::)+\s*&\s*\S', line):
+      # previous_line\n + ::current_line
+      previous = Search(r'\b((?:const\s*)?(?:[\w<>]|::)+[\w<>])\s*$',
+                        clean_lines.elided[linenum - 1])
+    elif Match(r'\s*[a-zA-Z_]([\w<>]|::)+\s*&\s*\S', line):
+      # previous_line::\n + current_line
+      previous = Search(r'\b((?:const\s*)?(?:[\w<>]|::)+::)\s*$',
+                        clean_lines.elided[linenum - 1])
+    if previous:
+      line = previous.group(1) + line.lstrip()
+    else:
+      # Check for templated parameter that is split across multiple lines
+      endpos = line.rfind('>')
+      if endpos > -1:
+        (_, startline, startpos) = ReverseCloseExpression(
+            clean_lines, linenum, endpos)
+        if startpos > -1 and startline < linenum:
+          # Found the matching < on an earlier line, collect all
+          # pieces up to current line.
+          line = ''
+          for i in xrange(startline, linenum + 1):
+            line += clean_lines.elided[i].strip()
+
+  # Check for non-const references in function parameters.  A single '&' may
+  # found in the following places:
+  #   inside expression: binary & for bitwise AND
+  #   inside expression: unary & for taking the address of something
+  #   inside declarators: reference parameter
+  # We will exclude the first two cases by checking that we are not inside a
+  # function body, including one that was just introduced by a trailing '{'.
+  # TODO(unknown): Doesn't account for 'catch(Exception& e)' [rare].
+  if (nesting_state.previous_stack_top and
+      not (isinstance(nesting_state.previous_stack_top, _ClassInfo) or
+           isinstance(nesting_state.previous_stack_top, _NamespaceInfo))):
+    # Not at toplevel, not within a class, and not within a namespace
+    return
+
+  # Avoid initializer lists.  We only need to scan back from the
+  # current line for something that starts with ':'.
+  #
+  # We don't need to check the current line, since the '&' would
+  # appear inside the second set of parentheses on the current line as
+  # opposed to the first set.
+  if linenum > 0:
+    for i in xrange(linenum - 1, max(0, linenum - 10), -1):
+      previous_line = clean_lines.elided[i]
+      if not Search(r'[),]\s*$', previous_line):
+        break
+      if Match(r'^\s*:\s+\S', previous_line):
+        return
+
+  # Avoid preprocessors
+  if Search(r'\\\s*$', line):
+    return
+
+  # Avoid constructor initializer lists
+  if IsInitializerList(clean_lines, linenum):
+    return
+
+  # We allow non-const references in a few standard places, like functions
+  # called "swap()" or iostream operators like "<<" or ">>".  Do not check
+  # those function parameters.
+  #
+  # We also accept & in static_assert, which looks like a function but
+  # it's actually a declaration expression.
+  whitelisted_functions = (r'(?:[sS]wap(?:<\w:+>)?|'
+                           r'operator\s*[<>][<>]|'
+                           r'static_assert|COMPILE_ASSERT'
+                           r')\s*\(')
+  if Search(whitelisted_functions, line):
+    return
+  elif not Search(r'\S+\([^)]*$', line):
+    # Don't see a whitelisted function on this line.  Actually we
+    # didn't see any function name on this line, so this is likely a
+    # multi-line parameter list.  Try a bit harder to catch this case.
+    for i in xrange(2):
+      if (linenum > i and
+          Search(whitelisted_functions, clean_lines.elided[linenum - i - 1])):
+        return
+
+  decls = ReplaceAll(r'{[^}]*}', ' ', line)  # exclude function body
+  for parameter in re.findall(_RE_PATTERN_REF_PARAM, decls):
+    if (not Match(_RE_PATTERN_CONST_REF_PARAM, parameter) and
+        not Match(_RE_PATTERN_REF_STREAM_PARAM, parameter)):
+      error(filename, linenum, 'runtime/references', 2,
+            'Is this a non-const reference? '
+            'If so, make const or use a pointer: ' +
+            ReplaceAll(' *<', '<', parameter))
+
+
+def CheckCasts(filename, clean_lines, linenum, error):
+  """Various cast related checks.
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    error: The function to call with any errors found.
+  """
+  line = clean_lines.elided[linenum]
+
+  # Check to see if they're using an conversion function cast.
+  # I just try to capture the most common basic types, though there are more.
+  # Parameterless conversion functions, such as bool(), are allowed as they are
+  # probably a member operator declaration or default constructor.
+  match = Search(
+      r'(\bnew\s+(?:const\s+)?|\S<\s*(?:const\s+)?)?\b'
+      r'(int|float|double|bool|char|int32|uint32|int64|uint64)'
+      r'(\([^)].*)', line)
+  expecting_function = ExpectingFunctionArgs(clean_lines, linenum)
+  if match and not expecting_function:
+    matched_type = match.group(2)
+
+    # matched_new_or_template is used to silence two false positives:
+    # - New operators
+    # - Template arguments with function types
+    #
+    # For template arguments, we match on types immediately following
+    # an opening bracket without any spaces.  This is a fast way to
+    # silence the common case where the function type is the first
+    # template argument.  False negative with less-than comparison is
+    # avoided because those operators are usually followed by a space.
+    #
+    #   function<double(double)>   // bracket + no space = false positive
+    #   value < double(42)         // bracket + space = true positive
+    matched_new_or_template = match.group(1)
+
+    # Avoid arrays by looking for brackets that come after the closing
+    # parenthesis.
+    if Match(r'\([^()]+\)\s*\[', match.group(3)):
+      return
+
+    # Other things to ignore:
+    # - Function pointers
+    # - Casts to pointer types
+    # - Placement new
+    # - Alias declarations
+    matched_funcptr = match.group(3)
+    if (matched_new_or_template is None and
+        not (matched_funcptr and
+             (Match(r'\((?:[^() ]+::\s*\*\s*)?[^() ]+\)\s*\(',
+                    matched_funcptr) or
+              matched_funcptr.startswith('(*)'))) and
+        not Match(r'\s*using\s+\S+\s*=\s*' + matched_type, line) and
+        not Search(r'new\(\S+\)\s*' + matched_type, line)):
+      error(filename, linenum, 'readability/casting', 4,
+            'Using deprecated casting style.  '
+            'Use static_cast<%s>(...) instead' %
+            matched_type)
+
+  if not expecting_function:
+    CheckCStyleCast(filename, clean_lines, linenum, 'static_cast',
+                    r'\((int|float|double|bool|char|u?int(16|32|64))\)', error)
+
+  # This doesn't catch all cases. Consider (const char * const)"hello".
+  #
+  # (char *) "foo" should always be a const_cast (reinterpret_cast won't
+  # compile).
+  if CheckCStyleCast(filename, clean_lines, linenum, 'const_cast',
+                     r'\((char\s?\*+\s?)\)\s*"', error):
+    pass
+  else:
+    # Check pointer casts for other than string constants
+    CheckCStyleCast(filename, clean_lines, linenum, 'reinterpret_cast',
+                    r'\((\w+\s?\*+\s?)\)', error)
+
+  # In addition, we look for people taking the address of a cast.  This
+  # is dangerous -- casts can assign to temporaries, so the pointer doesn't
+  # point where you think.
+  #
+  # Some non-identifier character is required before the '&' for the
+  # expression to be recognized as a cast.  These are casts:
+  #   expression = &static_cast<int*>(temporary());
+  #   function(&(int*)(temporary()));
+  #
+  # This is not a cast:
+  #   reference_type&(int* function_param);
+  match = Search(
+      r'(?:[^\w]&\(([^)*][^)]*)\)[\w(])|'
+      r'(?:[^\w]&(static|dynamic|down|reinterpret)_cast\b)', line)
+  if match:
+    # Try a better error message when the & is bound to something
+    # dereferenced by the casted pointer, as opposed to the casted
+    # pointer itself.
+    parenthesis_error = False
+    match = Match(r'^(.*&(?:static|dynamic|down|reinterpret)_cast\b)<', line)
+    if match:
+      _, y1, x1 = CloseExpression(clean_lines, linenum, len(match.group(1)))
+      if x1 >= 0 and clean_lines.elided[y1][x1] == '(':
+        _, y2, x2 = CloseExpression(clean_lines, y1, x1)
+        if x2 >= 0:
+          extended_line = clean_lines.elided[y2][x2:]
+          if y2 < clean_lines.NumLines() - 1:
+            extended_line += clean_lines.elided[y2 + 1]
+          if Match(r'\s*(?:->|\[)', extended_line):
+            parenthesis_error = True
+
+    if parenthesis_error:
+      error(filename, linenum, 'readability/casting', 4,
+            ('Are you taking an address of something dereferenced '
+             'from a cast?  Wrapping the dereferenced expression in '
+             'parentheses will make the binding more obvious'))
+    else:
+      error(filename, linenum, 'runtime/casting', 4,
+            ('Are you taking an address of a cast?  '
+             'This is dangerous: could be a temp var.  '
+             'Take the address before doing the cast, rather than after'))
+
+
+def CheckCStyleCast(filename, clean_lines, linenum, cast_type, pattern, error):
+  """Checks for a C-style cast by looking for the pattern.
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    cast_type: The string for the C++ cast to recommend.  This is either
+      reinterpret_cast, static_cast, or const_cast, depending.
+    pattern: The regular expression used to find C-style casts.
+    error: The function to call with any errors found.
+
+  Returns:
+    True if an error was emitted.
+    False otherwise.
+  """
+  line = clean_lines.elided[linenum]
+  match = Search(pattern, line)
+  if not match:
+    return False
+
+  # Exclude lines with keywords that tend to look like casts
+  context = line[0:match.start(1) - 1]
+  if Match(r'.*\b(?:sizeof|alignof|alignas|[_A-Z][_A-Z0-9]*)\s*$', context):
+    return False
+
+  # Try expanding current context to see if we one level of
+  # parentheses inside a macro.
+  if linenum > 0:
+    for i in xrange(linenum - 1, max(0, linenum - 5), -1):
+      context = clean_lines.elided[i] + context
+  if Match(r'.*\b[_A-Z][_A-Z0-9]*\s*\((?:\([^()]*\)|[^()])*$', context):
+    return False
+
+  # operator++(int) and operator--(int)
+  if context.endswith(' operator++') or context.endswith(' operator--'):
+    return False
+
+  # A single unnamed argument for a function tends to look like old style cast.
+  # If we see those, don't issue warnings for deprecated casts.
+  remainder = line[match.end(0):]
+  if Match(r'^\s*(?:;|const\b|throw\b|final\b|override\b|[=>{),]|->)',
+           remainder):
+    return False
+
+  # At this point, all that should be left is actual casts.
+  error(filename, linenum, 'readability/casting', 4,
+        'Using C-style cast.  Use %s<%s>(...) instead' %
+        (cast_type, match.group(1)))
+
+  return True
+
+
+def ExpectingFunctionArgs(clean_lines, linenum):
+  """Checks whether where function type arguments are expected.
+
+  Args:
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+
+  Returns:
+    True if the line at 'linenum' is inside something that expects arguments
+    of function types.
+  """
+  line = clean_lines.elided[linenum]
+  return (Match(r'^\s*MOCK_(CONST_)?METHOD\d+(_T)?\(', line) or
+          (linenum >= 2 and
+           (Match(r'^\s*MOCK_(?:CONST_)?METHOD\d+(?:_T)?\((?:\S+,)?\s*$',
+                  clean_lines.elided[linenum - 1]) or
+            Match(r'^\s*MOCK_(?:CONST_)?METHOD\d+(?:_T)?\(\s*$',
+                  clean_lines.elided[linenum - 2]) or
+            Search(r'\bstd::m?function\s*\<\s*$',
+                   clean_lines.elided[linenum - 1]))))
+
+
+_HEADERS_CONTAINING_TEMPLATES = (
+    ('<deque>', ('deque',)),
+    ('<functional>', ('unary_function', 'binary_function',
+                      'plus', 'minus', 'multiplies', 'divides', 'modulus',
+                      'negate',
+                      'equal_to', 'not_equal_to', 'greater', 'less',
+                      'greater_equal', 'less_equal',
+                      'logical_and', 'logical_or', 'logical_not',
+                      'unary_negate', 'not1', 'binary_negate', 'not2',
+                      'bind1st', 'bind2nd',
+                      'pointer_to_unary_function',
+                      'pointer_to_binary_function',
+                      'ptr_fun',
+                      'mem_fun_t', 'mem_fun', 'mem_fun1_t', 'mem_fun1_ref_t',
+                      'mem_fun_ref_t',
+                      'const_mem_fun_t', 'const_mem_fun1_t',
+                      'const_mem_fun_ref_t', 'const_mem_fun1_ref_t',
+                      'mem_fun_ref',
+                     )),
+    ('<limits>', ('numeric_limits',)),
+    ('<list>', ('list',)),
+    ('<map>', ('map', 'multimap',)),
+    ('<memory>', ('allocator', 'make_shared', 'make_unique', 'shared_ptr',
+                  'unique_ptr', 'weak_ptr')),
+    ('<queue>', ('queue', 'priority_queue',)),
+    ('<set>', ('set', 'multiset',)),
+    ('<stack>', ('stack',)),
+    ('<string>', ('char_traits', 'basic_string',)),
+    ('<tuple>', ('tuple',)),
+    ('<unordered_map>', ('unordered_map', 'unordered_multimap')),
+    ('<unordered_set>', ('unordered_set', 'unordered_multiset')),
+    ('<utility>', ('pair',)),
+    ('<vector>', ('vector',)),
+
+    # gcc extensions.
+    # Note: std::hash is their hash, ::hash is our hash
+    ('<hash_map>', ('hash_map', 'hash_multimap',)),
+    ('<hash_set>', ('hash_set', 'hash_multiset',)),
+    ('<slist>', ('slist',)),
+    )
+
+_HEADERS_MAYBE_TEMPLATES = (
+    ('<algorithm>', ('copy', 'max', 'min', 'min_element', 'sort',
+                     'transform',
+                    )),
+    ('<utility>', ('forward', 'make_pair', 'move', 'swap')),
+    )
+
+_RE_PATTERN_STRING = re.compile(r'\bstring\b')
+
+_re_pattern_headers_maybe_templates = []
+for _header, _templates in _HEADERS_MAYBE_TEMPLATES:
+  for _template in _templates:
+    # Match max<type>(..., ...), max(..., ...), but not foo->max, foo.max or
+    # type::max().
+    _re_pattern_headers_maybe_templates.append(
+        (re.compile(r'[^>.]\b' + _template + r'(<.*?>)?\([^\)]'),
+            _template,
+            _header))
+
+# Other scripts may reach in and modify this pattern.
+_re_pattern_templates = []
+for _header, _templates in _HEADERS_CONTAINING_TEMPLATES:
+  for _template in _templates:
+    _re_pattern_templates.append(
+        (re.compile(r'(\<|\b)' + _template + r'\s*\<'),
+         _template + '<>',
+         _header))
+
+
+def FilesBelongToSameModule(filename_cc, filename_h):
+  """Check if these two filenames belong to the same module.
+
+  The concept of a 'module' here is a as follows:
+  foo.h, foo-inl.h, foo.cc, foo_test.cc and foo_unittest.cc belong to the
+  same 'module' if they are in the same directory.
+  some/path/public/xyzzy and some/path/internal/xyzzy are also considered
+  to belong to the same module here.
+
+  If the filename_cc contains a longer path than the filename_h, for example,
+  '/absolute/path/to/base/sysinfo.cc', and this file would include
+  'base/sysinfo.h', this function also produces the prefix needed to open the
+  header. This is used by the caller of this function to more robustly open the
+  header file. We don't have access to the real include paths in this context,
+  so we need this guesswork here.
+
+  Known bugs: tools/base/bar.cc and base/bar.h belong to the same module
+  according to this implementation. Because of this, this function gives
+  some false positives. This should be sufficiently rare in practice.
+
+  Args:
+    filename_cc: is the path for the source (e.g. .cc) file
+    filename_h: is the path for the header path
+
+  Returns:
+    Tuple with a bool and a string:
+    bool: True if filename_cc and filename_h belong to the same module.
+    string: the additional prefix needed to open the header file.
+  """
+  fileinfo_cc = FileInfo(filename_cc)
+  if not fileinfo_cc.Extension().lstrip('.') in GetNonHeaderExtensions():
+    return (False, '')
+
+  fileinfo_h = FileInfo(filename_h)
+  if not fileinfo_h.Extension().lstrip('.') in GetHeaderExtensions():
+    return (False, '')
+
+  filename_cc = filename_cc[:-(len(fileinfo_cc.Extension()))]
+  matched_test_suffix = Search(_TEST_FILE_SUFFIX, fileinfo_cc.BaseName())
+  if matched_test_suffix:
+    filename_cc = filename_cc[:-len(matched_test_suffix.group(1))]
+
+  filename_cc = filename_cc.replace('/public/', '/')
+  filename_cc = filename_cc.replace('/internal/', '/')
+
+  filename_h = filename_h[:-(len(fileinfo_h.Extension()))]
+  if filename_h.endswith('-inl'):
+    filename_h = filename_h[:-len('-inl')]
+  filename_h = filename_h.replace('/public/', '/')
+  filename_h = filename_h.replace('/internal/', '/')
+
+  files_belong_to_same_module = filename_cc.endswith(filename_h)
+  common_path = ''
+  if files_belong_to_same_module:
+    common_path = filename_cc[:-len(filename_h)]
+  return files_belong_to_same_module, common_path
+
+
+def UpdateIncludeState(filename, include_dict, io=codecs):
+  """Fill up the include_dict with new includes found from the file.
+
+  Args:
+    filename: the name of the header to read.
+    include_dict: a dictionary in which the headers are inserted.
+    io: The io factory to use to read the file. Provided for testability.
+
+  Returns:
+    True if a header was successfully added. False otherwise.
+  """
+  headerfile = None
+  try:
+    headerfile = io.open(filename, 'r', 'utf8', 'replace')
+  except IOError:
+    return False
+  linenum = 0
+  for line in headerfile:
+    linenum += 1
+    clean_line = CleanseComments(line)
+    match = _RE_PATTERN_INCLUDE.search(clean_line)
+    if match:
+      include = match.group(2)
+      include_dict.setdefault(include, linenum)
+  return True
+
+
+def CheckForIncludeWhatYouUse(filename, clean_lines, include_state, error,
+                              io=codecs):
+  """Reports for missing stl includes.
+
+  This function will output warnings to make sure you are including the headers
+  necessary for the stl containers and functions that you use. We only give one
+  reason to include a header. For example, if you use both equal_to<> and
+  less<> in a .h file, only one (the latter in the file) of these will be
+  reported as a reason to include the <functional>.
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    include_state: An _IncludeState instance.
+    error: The function to call with any errors found.
+    io: The IO factory to use to read the header file. Provided for unittest
+        injection.
+  """
+  required = {}  # A map of header name to linenumber and the template entity.
+                 # Example of required: { '<functional>': (1219, 'less<>') }
+
+  for linenum in range(clean_lines.NumLines()):
+    line = clean_lines.elided[linenum]
+    if not line or line[0] == '#':
+      continue
+
+    # String is special -- it is a non-templatized type in STL.
+    matched = _RE_PATTERN_STRING.search(line)
+    if matched:
+      # Don't warn about strings in non-STL namespaces:
+      # (We check only the first match per line; good enough.)
+      prefix = line[:matched.start()]
+      if prefix.endswith('std::') or not prefix.endswith('::'):
+        required['<string>'] = (linenum, 'string')
+
+    for pattern, template, header in _re_pattern_headers_maybe_templates:
+      if pattern.search(line):
+        required[header] = (linenum, template)
+
+    # The following function is just a speed up, no semantics are changed.
+    if not '<' in line:  # Reduces the cpu time usage by skipping lines.
+      continue
+
+    for pattern, template, header in _re_pattern_templates:
+      matched = pattern.search(line)
+      if matched:
+        # Don't warn about IWYU in non-STL namespaces:
+        # (We check only the first match per line; good enough.)
+        prefix = line[:matched.start()]
+        if prefix.endswith('std::') or not prefix.endswith('::'):
+          required[header] = (linenum, template)
+
+  # The policy is that if you #include something in foo.h you don't need to
+  # include it again in foo.cc. Here, we will look at possible includes.
+  # Let's flatten the include_state include_list and copy it into a dictionary.
+  include_dict = dict([item for sublist in include_state.include_list
+                       for item in sublist])
+
+  # Did we find the header for this file (if any) and successfully load it?
+  header_found = False
+
+  # Use the absolute path so that matching works properly.
+  abs_filename = FileInfo(filename).FullName()
+
+  # For Emacs's flymake.
+  # If cpplint is invoked from Emacs's flymake, a temporary file is generated
+  # by flymake and that file name might end with '_flymake.cc'. In that case,
+  # restore original file name here so that the corresponding header file can be
+  # found.
+  # e.g. If the file name is 'foo_flymake.cc', we should search for 'foo.h'
+  # instead of 'foo_flymake.h'
+  abs_filename = re.sub(r'_flymake\.cc$', '.cc', abs_filename)
+
+  # include_dict is modified during iteration, so we iterate over a copy of
+  # the keys.
+  header_keys = list(include_dict.keys())
+  for header in header_keys:
+    (same_module, common_path) = FilesBelongToSameModule(abs_filename, header)
+    fullpath = common_path + header
+    if same_module and UpdateIncludeState(fullpath, include_dict, io):
+      header_found = True
+
+  # If we can't find the header file for a .cc, assume it's because we don't
+  # know where to look. In that case we'll give up as we're not sure they
+  # didn't include it in the .h file.
+  # TODO(unknown): Do a better job of finding .h files so we are confident that
+  # not having the .h file means there isn't one.
+  if not header_found:
+    for extension in GetNonHeaderExtensions():
+      if filename.endswith('.' + extension):
+        return
+
+  # All the lines have been processed, report the errors found.
+  for required_header_unstripped in sorted(required, key=required.__getitem__):
+    template = required[required_header_unstripped][1]
+    if required_header_unstripped.strip('<>"') not in include_dict:
+      error(filename, required[required_header_unstripped][0],
+            'build/include_what_you_use', 4,
+            'Add #include ' + required_header_unstripped + ' for ' + template)
+
+
+_RE_PATTERN_EXPLICIT_MAKEPAIR = re.compile(r'\bmake_pair\s*<')
+
+
+def CheckMakePairUsesDeduction(filename, clean_lines, linenum, error):
+  """Check that make_pair's template arguments are deduced.
+
+  G++ 4.6 in C++11 mode fails badly if make_pair's template arguments are
+  specified explicitly, and such use isn't intended in any case.
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    error: The function to call with any errors found.
+  """
+  line = clean_lines.elided[linenum]
+  match = _RE_PATTERN_EXPLICIT_MAKEPAIR.search(line)
+  if match:
+    error(filename, linenum, 'build/explicit_make_pair',
+          4,  # 4 = high confidence
+          'For C++11-compatibility, omit template arguments from make_pair'
+          ' OR use pair directly OR if appropriate, construct a pair directly')
+
+
+def CheckRedundantVirtual(filename, clean_lines, linenum, error):
+  """Check if line contains a redundant "virtual" function-specifier.
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    error: The function to call with any errors found.
+  """
+  # Look for "virtual" on current line.
+  line = clean_lines.elided[linenum]
+  virtual = Match(r'^(.*)(\bvirtual\b)(.*)$', line)
+  if not virtual: return
+
+  # Ignore "virtual" keywords that are near access-specifiers.  These
+  # are only used in class base-specifier and do not apply to member
+  # functions.
+  if (Search(r'\b(public|protected|private)\s+$', virtual.group(1)) or
+      Match(r'^\s+(public|protected|private)\b', virtual.group(3))):
+    return
+
+  # Ignore the "virtual" keyword from virtual base classes.  Usually
+  # there is a column on the same line in these cases (virtual base
+  # classes are rare in google3 because multiple inheritance is rare).
+  if Match(r'^.*[^:]:[^:].*$', line): return
+
+  # Look for the next opening parenthesis.  This is the start of the
+  # parameter list (possibly on the next line shortly after virtual).
+  # TODO(unknown): doesn't work if there are virtual functions with
+  # decltype() or other things that use parentheses, but csearch suggests
+  # that this is rare.
+  end_col = -1
+  end_line = -1
+  start_col = len(virtual.group(2))
+  for start_line in xrange(linenum, min(linenum + 3, clean_lines.NumLines())):
+    line = clean_lines.elided[start_line][start_col:]
+    parameter_list = Match(r'^([^(]*)\(', line)
+    if parameter_list:
+      # Match parentheses to find the end of the parameter list
+      (_, end_line, end_col) = CloseExpression(
+          clean_lines, start_line, start_col + len(parameter_list.group(1)))
+      break
+    start_col = 0
+
+  if end_col < 0:
+    return  # Couldn't find end of parameter list, give up
+
+  # Look for "override" or "final" after the parameter list
+  # (possibly on the next few lines).
+  for i in xrange(end_line, min(end_line + 3, clean_lines.NumLines())):
+    line = clean_lines.elided[i][end_col:]
+    match = Search(r'\b(override|final)\b', line)
+    if match:
+      error(filename, linenum, 'readability/inheritance', 4,
+            ('"virtual" is redundant since function is '
+             'already declared as "%s"' % match.group(1)))
+
+    # Set end_col to check whole lines after we are done with the
+    # first line.
+    end_col = 0
+    if Search(r'[^\w]\s*$', line):
+      break
+
+
+def CheckRedundantOverrideOrFinal(filename, clean_lines, linenum, error):
+  """Check if line contains a redundant "override" or "final" virt-specifier.
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    error: The function to call with any errors found.
+  """
+  # Look for closing parenthesis nearby.  We need one to confirm where
+  # the declarator ends and where the virt-specifier starts to avoid
+  # false positives.
+  line = clean_lines.elided[linenum]
+  declarator_end = line.rfind(')')
+  if declarator_end >= 0:
+    fragment = line[declarator_end:]
+  else:
+    if linenum > 1 and clean_lines.elided[linenum - 1].rfind(')') >= 0:
+      fragment = line
+    else:
+      return
+
+  # Check that at most one of "override" or "final" is present, not both
+  if Search(r'\boverride\b', fragment) and Search(r'\bfinal\b', fragment):
+    error(filename, linenum, 'readability/inheritance', 4,
+          ('"override" is redundant since function is '
+           'already declared as "final"'))
+
+
+
+
+# Returns true if we are at a new block, and it is directly
+# inside of a namespace.
+def IsBlockInNameSpace(nesting_state, is_forward_declaration):
+  """Checks that the new block is directly in a namespace.
+
+  Args:
+    nesting_state: The _NestingState object that contains info about our state.
+    is_forward_declaration: If the class is a forward declared class.
+  Returns:
+    Whether or not the new block is directly in a namespace.
+  """
+  if is_forward_declaration:
+    return len(nesting_state.stack) >= 1 and (
+      isinstance(nesting_state.stack[-1], _NamespaceInfo))
+
+
+  return (len(nesting_state.stack) > 1 and
+          nesting_state.stack[-1].check_namespace_indentation and
+          isinstance(nesting_state.stack[-2], _NamespaceInfo))
+
+
+def ShouldCheckNamespaceIndentation(nesting_state, is_namespace_indent_item,
+                                    raw_lines_no_comments, linenum):
+  """This method determines if we should apply our namespace indentation check.
+
+  Args:
+    nesting_state: The current nesting state.
+    is_namespace_indent_item: If we just put a new class on the stack, True.
+      If the top of the stack is not a class, or we did not recently
+      add the class, False.
+    raw_lines_no_comments: The lines without the comments.
+    linenum: The current line number we are processing.
+
+  Returns:
+    True if we should apply our namespace indentation check. Currently, it
+    only works for classes and namespaces inside of a namespace.
+  """
+
+  is_forward_declaration = IsForwardClassDeclaration(raw_lines_no_comments,
+                                                     linenum)
+
+  if not (is_namespace_indent_item or is_forward_declaration):
+    return False
+
+  # If we are in a macro, we do not want to check the namespace indentation.
+  if IsMacroDefinition(raw_lines_no_comments, linenum):
+    return False
+
+  return IsBlockInNameSpace(nesting_state, is_forward_declaration)
+
+
+# Call this method if the line is directly inside of a namespace.
+# If the line above is blank (excluding comments) or the start of
+# an inner namespace, it cannot be indented.
+def CheckItemIndentationInNamespace(filename, raw_lines_no_comments, linenum,
+                                    error):
+  line = raw_lines_no_comments[linenum]
+  if Match(r'^\s+', line):
+    error(filename, linenum, 'runtime/indentation_namespace', 4,
+          'Do not indent within a namespace')
+
+
+def ProcessLine(filename, file_extension, clean_lines, line,
+                include_state, function_state, nesting_state, error,
+                extra_check_functions=None):
+  """Processes a single line in the file.
+
+  Args:
+    filename: Filename of the file that is being processed.
+    file_extension: The extension (dot not included) of the file.
+    clean_lines: An array of strings, each representing a line of the file,
+                 with comments stripped.
+    line: Number of line being processed.
+    include_state: An _IncludeState instance in which the headers are inserted.
+    function_state: A _FunctionState instance which counts function lines, etc.
+    nesting_state: A NestingState instance which maintains information about
+                   the current stack of nested blocks being parsed.
+    error: A callable to which errors are reported, which takes 4 arguments:
+           filename, line number, error level, and message
+    extra_check_functions: An array of additional check functions that will be
+                           run on each source line. Each function takes 4
+                           arguments: filename, clean_lines, line, error
+  """
+  raw_lines = clean_lines.raw_lines
+  ParseNolintSuppressions(filename, raw_lines[line], line, error)
+  nesting_state.Update(filename, clean_lines, line, error)
+  CheckForNamespaceIndentation(filename, nesting_state, clean_lines, line,
+                               error)
+  if nesting_state.InAsmBlock(): return
+  CheckForFunctionLengths(filename, clean_lines, line, function_state, error)
+  CheckForMultilineCommentsAndStrings(filename, clean_lines, line, error)
+  CheckStyle(filename, clean_lines, line, file_extension, nesting_state, error)
+  CheckLanguage(filename, clean_lines, line, file_extension, include_state,
+                nesting_state, error)
+  CheckForNonConstReference(filename, clean_lines, line, nesting_state, error)
+  CheckForNonStandardConstructs(filename, clean_lines, line,
+                                nesting_state, error)
+  CheckVlogArguments(filename, clean_lines, line, error)
+  CheckPosixThreading(filename, clean_lines, line, error)
+  CheckInvalidIncrement(filename, clean_lines, line, error)
+  CheckMakePairUsesDeduction(filename, clean_lines, line, error)
+  CheckRedundantVirtual(filename, clean_lines, line, error)
+  CheckRedundantOverrideOrFinal(filename, clean_lines, line, error)
+  if extra_check_functions:
+    for check_fn in extra_check_functions:
+      check_fn(filename, clean_lines, line, error)
+
+def FlagCxx11Features(filename, clean_lines, linenum, error):
+  """Flag those c++11 features that we only allow in certain places.
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    error: The function to call with any errors found.
+  """
+  line = clean_lines.elided[linenum]
+
+  include = Match(r'\s*#\s*include\s+[<"]([^<"]+)[">]', line)
+
+  # Flag unapproved C++ TR1 headers.
+  if include and include.group(1).startswith('tr1/'):
+    error(filename, linenum, 'build/c++tr1', 5,
+          ('C++ TR1 headers such as <%s> are unapproved.') % include.group(1))
+
+  # Flag unapproved C++11 headers.
+  if include and include.group(1) in ('cfenv',
+                                      'condition_variable',
+                                      'fenv.h',
+                                      'future',
+                                      'mutex',
+                                      'thread',
+                                      'chrono',
+                                      'ratio',
+                                      'regex',
+                                      'system_error',
+                                     ):
+    error(filename, linenum, 'build/c++11', 5,
+          ('<%s> is an unapproved C++11 header.') % include.group(1))
+
+  # The only place where we need to worry about C++11 keywords and library
+  # features in preprocessor directives is in macro definitions.
+  if Match(r'\s*#', line) and not Match(r'\s*#\s*define\b', line): return
+
+  # These are classes and free functions.  The classes are always
+  # mentioned as std::*, but we only catch the free functions if
+  # they're not found by ADL.  They're alphabetical by header.
+  for top_name in (
+      # type_traits
+      'alignment_of',
+      'aligned_union',
+      ):
+    if Search(r'\bstd::%s\b' % top_name, line):
+      error(filename, linenum, 'build/c++11', 5,
+            ('std::%s is an unapproved C++11 class or function.  Send c-style '
+             'an example of where it would make your code more readable, and '
+             'they may let you use it.') % top_name)
+
+
+def FlagCxx14Features(filename, clean_lines, linenum, error):
+  """Flag those C++14 features that we restrict.
+
+  Args:
+    filename: The name of the current file.
+    clean_lines: A CleansedLines instance containing the file.
+    linenum: The number of the line to check.
+    error: The function to call with any errors found.
+  """
+  line = clean_lines.elided[linenum]
+
+  include = Match(r'\s*#\s*include\s+[<"]([^<"]+)[">]', line)
+
+  # Flag unapproved C++14 headers.
+  if include and include.group(1) in ('scoped_allocator', 'shared_mutex'):
+    error(filename, linenum, 'build/c++14', 5,
+          ('<%s> is an unapproved C++14 header.') % include.group(1))
+
+
+def ProcessFileData(filename, file_extension, lines, error,
+                    extra_check_functions=None):
+  """Performs lint checks and reports any errors to the given error function.
+
+  Args:
+    filename: Filename of the file that is being processed.
+    file_extension: The extension (dot not included) of the file.
+    lines: An array of strings, each representing a line of the file, with the
+           last element being empty if the file is terminated with a newline.
+    error: A callable to which errors are reported, which takes 4 arguments:
+           filename, line number, error level, and message
+    extra_check_functions: An array of additional check functions that will be
+                           run on each source line. Each function takes 4
+                           arguments: filename, clean_lines, line, error
+  """
+  lines = (['// marker so line numbers and indices both start at 1'] + lines +
+           ['// marker so line numbers end in a known way'])
+
+  include_state = _IncludeState()
+  function_state = _FunctionState()
+  nesting_state = NestingState()
+
+  ResetNolintSuppressions()
+
+  CheckForCopyright(filename, lines, error)
+  ProcessGlobalSuppresions(lines)
+  RemoveMultiLineComments(filename, lines, error)
+  clean_lines = CleansedLines(lines)
+
+  if file_extension in GetHeaderExtensions():
+    CheckForHeaderGuard(filename, clean_lines, error)
+
+  for line in range(clean_lines.NumLines()):
+    ProcessLine(filename, file_extension, clean_lines, line,
+                include_state, function_state, nesting_state, error,
+                extra_check_functions)
+    FlagCxx11Features(filename, clean_lines, line, error)
+  nesting_state.CheckCompletedBlocks(filename, error)
+
+  CheckForIncludeWhatYouUse(filename, clean_lines, include_state, error)
+
+  # Check that the .cc file has included its header if it exists.
+  if _IsSourceExtension(file_extension):
+    CheckHeaderFileIncluded(filename, include_state, error)
+
+  # We check here rather than inside ProcessLine so that we see raw
+  # lines rather than "cleaned" lines.
+  CheckForBadCharacters(filename, lines, error)
+
+  CheckForNewlineAtEOF(filename, lines, error)
+
+def ProcessConfigOverrides(filename):
+  """ Loads the configuration files and processes the config overrides.
+
+  Args:
+    filename: The name of the file being processed by the linter.
+
+  Returns:
+    False if the current |filename| should not be processed further.
+  """
+
+  abs_filename = os.path.abspath(filename)
+  cfg_filters = []
+  keep_looking = True
+  while keep_looking:
+    abs_path, base_name = os.path.split(abs_filename)
+    if not base_name:
+      break  # Reached the root directory.
+
+    cfg_file = os.path.join(abs_path, "CPPLINT.cfg")
+    abs_filename = abs_path
+    if not os.path.isfile(cfg_file):
+      continue
+
+    try:
+      with open(cfg_file) as file_handle:
+        for line in file_handle:
+          line, _, _ = line.partition('#')  # Remove comments.
+          if not line.strip():
+            continue
+
+          name, _, val = line.partition('=')
+          name = name.strip()
+          val = val.strip()
+          if name == 'set noparent':
+            keep_looking = False
+          elif name == 'filter':
+            cfg_filters.append(val)
+          elif name == 'exclude_files':
+            # When matching exclude_files pattern, use the base_name of
+            # the current file name or the directory name we are processing.
+            # For example, if we are checking for lint errors in /foo/bar/baz.cc
+            # and we found the .cfg file at /foo/CPPLINT.cfg, then the config
+            # file's "exclude_files" filter is meant to be checked against "bar"
+            # and not "baz" nor "bar/baz.cc".
+            if base_name:
+              pattern = re.compile(val)
+              if pattern.match(base_name):
+                _cpplint_state.PrintInfo('Ignoring "%s": file excluded by '
+                    '"%s". File path component "%s" matches pattern "%s"\n' %
+                    (filename, cfg_file, base_name, val))
+                return False
+          elif name == 'linelength':
+            global _line_length
+            try:
+                _line_length = int(val)
+            except ValueError:
+                _cpplint_state.PrintError('Line length must be numeric.')
+          elif name == 'extensions':
+              global _valid_extensions
+              try:
+                  extensions = [ext.strip() for ext in val.split(',')]
+                  _valid_extensions = set(extensions)
+              except ValueError:
+                  sys.stderr.write('Extensions should be a comma-separated list of values;'
+                                   'for example: extensions=hpp,cpp\n'
+                                   'This could not be parsed: "%s"' % (val,))
+          elif name == 'headers':
+              global _header_extensions
+              try:
+                  extensions = [ext.strip() for ext in val.split(',')]
+                  _header_extensions = set(extensions)
+              except ValueError:
+                  sys.stderr.write('Extensions should be a comma-separated list of values;'
+                                   'for example: extensions=hpp,cpp\n'
+                                   'This could not be parsed: "%s"' % (val,))
+          elif name == 'root':
+            global _root
+            _root = val
+          else:
+            _cpplint_state.PrintError(
+                'Invalid configuration option (%s) in file %s\n' %
+                (name, cfg_file))
+
+    except IOError:
+      _cpplint_state.PrintError(
+          "Skipping config file '%s': Can't open for reading\n" % cfg_file)
+      keep_looking = False
+
+  # Apply all the accumulated filters in reverse order (top-level directory
+  # config options having the least priority).
+  for cfg_filter in reversed(cfg_filters):
+     _AddFilters(cfg_filter)
+
+  return True
+
+
+def ProcessFile(filename, vlevel, extra_check_functions=None):
+  """Does google-lint on a single file.
+
+  Args:
+    filename: The name of the file to parse.
+
+    vlevel: The level of errors to report.  Every error of confidence
+    >= verbose_level will be reported.  0 is a good default.
+
+    extra_check_functions: An array of additional check functions that will be
+                           run on each source line. Each function takes 4
+                           arguments: filename, clean_lines, line, error
+  """
+
+  _SetVerboseLevel(vlevel)
+  _BackupFilters()
+
+  if not ProcessConfigOverrides(filename):
+    _RestoreFilters()
+    return
+
+  lf_lines = []
+  crlf_lines = []
+  try:
+    # Support the UNIX convention of using "-" for stdin.  Note that
+    # we are not opening the file with universal newline support
+    # (which codecs doesn't support anyway), so the resulting lines do
+    # contain trailing '\r' characters if we are reading a file that
+    # has CRLF endings.
+    # If after the split a trailing '\r' is present, it is removed
+    # below.
+    if filename == '-':
+      lines = codecs.StreamReaderWriter(sys.stdin,
+                                        codecs.getreader('utf8'),
+                                        codecs.getwriter('utf8'),
+                                        'replace').read().split('\n')
+    else:
+      lines = codecs.open(filename, 'r', 'utf8', 'replace').read().split('\n')
+
+    # Remove trailing '\r'.
+    # The -1 accounts for the extra trailing blank line we get from split()
+    for linenum in range(len(lines) - 1):
+      if lines[linenum].endswith('\r'):
+        lines[linenum] = lines[linenum].rstrip('\r')
+        crlf_lines.append(linenum + 1)
+      else:
+        lf_lines.append(linenum + 1)
+
+  except IOError:
+    _cpplint_state.PrintError(
+        "Skipping input '%s': Can't open for reading\n" % filename)
+    _RestoreFilters()
+    return
+
+  # Note, if no dot is found, this will give the entire filename as the ext.
+  file_extension = filename[filename.rfind('.') + 1:]
+
+  # When reading from stdin, the extension is unknown, so no cpplint tests
+  # should rely on the extension.
+  if filename != '-' and file_extension not in GetAllExtensions():
+    _cpplint_state.PrintError('Ignoring %s; not a valid file name '
+                     '(%s)\n' % (filename, ', '.join(GetAllExtensions())))
+  else:
+    ProcessFileData(filename, file_extension, lines, Error,
+                    extra_check_functions)
+
+    # If end-of-line sequences are a mix of LF and CR-LF, issue
+    # warnings on the lines with CR.
+    #
+    # Don't issue any warnings if all lines are uniformly LF or CR-LF,
+    # since critique can handle these just fine, and the style guide
+    # doesn't dictate a particular end of line sequence.
+    #
+    # We can't depend on os.linesep to determine what the desired
+    # end-of-line sequence should be, since that will return the
+    # server-side end-of-line sequence.
+    if lf_lines and crlf_lines:
+      # Warn on every line with CR.  An alternative approach might be to
+      # check whether the file is mostly CRLF or just LF, and warn on the
+      # minority, we bias toward LF here since most tools prefer LF.
+      for linenum in crlf_lines:
+        Error(filename, linenum, 'whitespace/newline', 1,
+              'Unexpected \\r (^M) found; better to use only \\n')
+
+  _cpplint_state.PrintInfo('Done processing %s\n' % filename)
+  _RestoreFilters()
+
+
+def PrintUsage(message):
+  """Prints a brief usage string and exits, optionally with an error message.
+
+  Args:
+    message: The optional error message.
+  """
+  sys.stderr.write(_USAGE)
+
+  if message:
+    sys.exit('\nFATAL ERROR: ' + message)
+  else:
+    sys.exit(0)
+
+
+def PrintCategories():
+  """Prints a list of all the error-categories used by error messages.
+
+  These are the categories used to filter messages via --filter.
+  """
+  sys.stderr.write(''.join('  %s\n' % cat for cat in _ERROR_CATEGORIES))
+  sys.exit(0)
+
+
+def ParseArguments(args):
+  """Parses the command line arguments.
+
+  This may set the output format and verbosity level as side-effects.
+
+  Args:
+    args: The command line arguments:
+
+  Returns:
+    The list of filenames to lint.
+  """
+  try:
+    (opts, filenames) = getopt.getopt(args, '', ['help', 'output=', 'verbose=',
+                                                 'counting=',
+                                                 'filter=',
+                                                 'root=',
+                                                 'repository=',
+                                                 'linelength=',
+                                                 'extensions=',
+                                                 'exclude=',
+                                                 'headers=',
+                                                 'quiet',
+                                                 'recursive'])
+  except getopt.GetoptError:
+    PrintUsage('Invalid arguments.')
+
+  verbosity = _VerboseLevel()
+  output_format = _OutputFormat()
+  filters = ''
+  counting_style = ''
+  recursive = False
+
+  for (opt, val) in opts:
+    if opt == '--help':
+      PrintUsage(None)
+    elif opt == '--output':
+      if val not in ('emacs', 'vs7', 'eclipse', 'junit'):
+        PrintUsage('The only allowed output formats are emacs, vs7, eclipse '
+                   'and junit.')
+      output_format = val
+    elif opt == '--verbose':
+      verbosity = int(val)
+    elif opt == '--filter':
+      filters = val
+      if not filters:
+        PrintCategories()
+    elif opt == '--counting':
+      if val not in ('total', 'toplevel', 'detailed'):
+        PrintUsage('Valid counting options are total, toplevel, and detailed')
+      counting_style = val
+    elif opt == '--root':
+      global _root
+      _root = val
+    elif opt == '--repository':
+      global _repository
+      _repository = val
+    elif opt == '--linelength':
+      global _line_length
+      try:
+        _line_length = int(val)
+      except ValueError:
+        PrintUsage('Line length must be digits.')
+    elif opt == '--exclude':
+      global _excludes
+      if not _excludes:
+        _excludes = set()
+      _excludes.update(glob.glob(val))
+    elif opt == '--extensions':
+      global _valid_extensions
+      try:
+        _valid_extensions = set(val.split(','))
+      except ValueError:
+          PrintUsage('Extensions must be comma separated list.')
+    elif opt == '--headers':
+      global _header_extensions
+      try:
+          _header_extensions = set(val.split(','))
+      except ValueError:
+        PrintUsage('Extensions must be comma separated list.')
+    elif opt == '--recursive':
+      recursive = True
+    elif opt == '--quiet':
+      global _quiet
+      _quiet = True
+
+  if not filenames:
+    PrintUsage('No files were specified.')
+
+  if recursive:
+    filenames = _ExpandDirectories(filenames)
+
+  if _excludes:
+    filenames = _FilterExcludedFiles(filenames)
+
+  _SetOutputFormat(output_format)
+  _SetVerboseLevel(verbosity)
+  _SetFilters(filters)
+  _SetCountingStyle(counting_style)
+
+  return filenames
+
+def _ExpandDirectories(filenames):
+  """Searches a list of filenames and replaces directories in the list with
+  all files descending from those directories. Files with extensions not in
+  the valid extensions list are excluded.
+
+  Args:
+    filenames: A list of files or directories
+
+  Returns:
+    A list of all files that are members of filenames or descended from a
+    directory in filenames
+  """
+  expanded = set()
+  for filename in filenames:
+      if not os.path.isdir(filename):
+        expanded.add(filename)
+        continue
+
+      for root, _, files in os.walk(filename):
+        for loopfile in files:
+          fullname = os.path.join(root, loopfile)
+          if fullname.startswith('.' + os.path.sep):
+            fullname = fullname[len('.' + os.path.sep):]
+          expanded.add(fullname)
+
+  filtered = []
+  for filename in expanded:
+      if os.path.splitext(filename)[1][1:] in GetAllExtensions():
+          filtered.append(filename)
+
+  return filtered
+
+def _FilterExcludedFiles(filenames):
+  """Filters out files listed in the --exclude command line switch. File paths
+  in the switch are evaluated relative to the current working directory
+  """
+  exclude_paths = [os.path.abspath(f) for f in _excludes]
+  return [f for f in filenames if os.path.abspath(f) not in exclude_paths]
+
+def main():
+  filenames = ParseArguments(sys.argv[1:])
+  backup_err = sys.stderr
+  try:
+    # Change stderr to write with replacement characters so we don't die
+    # if we try to print something containing non-ASCII characters.
+    sys.stderr = codecs.StreamReader(sys.stderr, 'replace')
+
+    _cpplint_state.ResetErrorCounts()
+    for filename in filenames:
+      ProcessFile(filename, _cpplint_state.verbose_level)
+    _cpplint_state.PrintErrorCounts()
+
+    if _cpplint_state.output_format == 'junit':
+      sys.stderr.write(_cpplint_state.FormatJUnitXML())
+
+  finally:
+    sys.stderr = backup_err
+
+  sys.exit(_cpplint_state.error_count > 0)
+
+
+if __name__ == '__main__':
+  main()
+
diff --git a/core/build-support/lint_exclusions.txt b/core/build-support/lint_exclusions.txt
new file mode 100644
index 0000000000..226db75a43
--- /dev/null
+++ b/core/build-support/lint_exclusions.txt
@@ -0,0 +1,9 @@
+*cmake-build-debug*
+*cmake-build-release*
+*cmake_build*
+*src/index/thirdparty*
+*thirdparty*
+*easylogging++*
+*SqliteMetaImpl.cpp
+*src/grpc*
+*milvus/include*
\ No newline at end of file
diff --git a/core/build-support/lintutils.py b/core/build-support/lintutils.py
new file mode 100755
index 0000000000..b4b01da3e9
--- /dev/null
+++ b/core/build-support/lintutils.py
@@ -0,0 +1,110 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you 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.
+
+import multiprocessing as mp
+import os
+from fnmatch import fnmatch
+from subprocess import Popen
+
+
+def chunk(seq, n):
+    """
+    divide a sequence into equal sized chunks
+    (the last chunk may be smaller, but won't be empty)
+    """
+    chunks = []
+    some = []
+    for element in seq:
+        if len(some) == n:
+            chunks.append(some)
+            some = []
+        some.append(element)
+    if len(some) > 0:
+        chunks.append(some)
+    return chunks
+
+
+def dechunk(chunks):
+    "flatten chunks into a single list"
+    seq = []
+    for chunk in chunks:
+        seq.extend(chunk)
+    return seq
+
+
+def run_parallel(cmds, **kwargs):
+    """
+    Run each of cmds (with shared **kwargs) using subprocess.Popen
+    then wait for all of them to complete.
+    Runs batches of multiprocessing.cpu_count() * 2 from cmds
+    returns a list of tuples containing each process'
+    returncode, stdout, stderr
+    """
+    complete = []
+    for cmds_batch in chunk(cmds, mp.cpu_count() * 2):
+        procs_batch = [Popen(cmd, **kwargs) for cmd in cmds_batch]
+        for proc in procs_batch:
+            stdout, stderr = proc.communicate()
+            complete.append((proc.returncode, stdout, stderr))
+    return complete
+
+
+_source_extensions = '''
+.h
+.cc
+.cpp
+'''.split()
+
+
+def get_sources(source_dir, exclude_globs=[]):
+    sources = []
+    for directory, subdirs, basenames in os.walk(source_dir):
+        for path in [os.path.join(directory, basename)
+                     for basename in basenames]:
+            # filter out non-source files
+            if os.path.splitext(path)[1] not in _source_extensions:
+                continue
+
+            path = os.path.abspath(path)
+
+            # filter out files that match the globs in the globs file
+            if any([fnmatch(path, glob) for glob in exclude_globs]):
+                continue
+
+            sources.append(path)
+    return sources
+
+
+def stdout_pathcolonline(completed_process, filenames):
+    """
+    given a completed process which may have reported some files as problematic
+    by printing the path name followed by ':' then a line number, examine
+    stdout and return the set of actually reported file names
+    """
+    returncode, stdout, stderr = completed_process
+    bfilenames = set()
+    for filename in filenames:
+        bfilenames.add(filename.encode('utf-8') + b':')
+    problem_files = set()
+    for line in stdout.splitlines():
+        for filename in bfilenames:
+            if line.startswith(filename):
+                problem_files.add(filename.decode('utf-8'))
+                bfilenames.remove(filename)
+                break
+    return problem_files, stdout
+
diff --git a/core/build-support/run_clang_format.py b/core/build-support/run_clang_format.py
new file mode 100755
index 0000000000..4c7fdfb2af
--- /dev/null
+++ b/core/build-support/run_clang_format.py
@@ -0,0 +1,142 @@
+#!/usr/bin/env python
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you 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.
+
+from __future__ import print_function
+import lintutils
+from subprocess import PIPE
+import argparse
+import difflib
+import multiprocessing as mp
+import sys
+from functools import partial
+
+
+# examine the output of clang-format and if changes are
+# present assemble a (unified)patch of the difference
+def _check_one_file(completed_processes, filename):
+    with open(filename, "rb") as reader:
+        original = reader.read()
+
+    returncode, stdout, stderr = completed_processes[filename]
+    formatted = stdout
+    if formatted != original:
+        # Run the equivalent of diff -u
+        diff = list(difflib.unified_diff(
+            original.decode('utf8').splitlines(True),
+            formatted.decode('utf8').splitlines(True),
+            fromfile=filename,
+            tofile="{} (after clang format)".format(
+                filename)))
+    else:
+        diff = None
+
+    return filename, diff
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="Runs clang-format on all of the source "
+        "files. If --fix is specified enforce format by "
+        "modifying in place, otherwise compare the output "
+        "with the existing file and output any necessary "
+        "changes as a patch in unified diff format")
+    parser.add_argument("--clang_format_binary",
+                        required=True,
+                        help="Path to the clang-format binary")
+    parser.add_argument("--exclude_globs",
+                        help="Filename containing globs for files "
+                        "that should be excluded from the checks")
+    parser.add_argument("--source_dir",
+                        required=True,
+                        help="Root directory of the source code")
+    parser.add_argument("--fix", default=False,
+                        action="store_true",
+                        help="If specified, will re-format the source "
+                        "code instead of comparing the re-formatted "
+                        "output, defaults to %(default)s")
+    parser.add_argument("--quiet", default=False,
+                        action="store_true",
+                        help="If specified, only print errors")
+    arguments = parser.parse_args()
+
+    exclude_globs = []
+    if arguments.exclude_globs:
+        for line in open(arguments.exclude_globs):
+            exclude_globs.append(line.strip())
+
+    formatted_filenames = []
+    for path in lintutils.get_sources(arguments.source_dir, exclude_globs):
+        formatted_filenames.append(str(path))
+
+    if arguments.fix:
+        if not arguments.quiet:
+            print("\n".join(map(lambda x: "Formatting {}".format(x),
+                                formatted_filenames)))
+
+        # Break clang-format invocations into chunks: each invocation formats
+        # 16 files. Wait for all processes to complete
+        results = lintutils.run_parallel([
+            [arguments.clang_format_binary, "-i"] + some
+            for some in lintutils.chunk(formatted_filenames, 16)
+        ])
+        for returncode, stdout, stderr in results:
+            # if any clang-format reported a parse error, bubble it
+            if returncode != 0:
+                sys.exit(returncode)
+
+    else:
+        # run an instance of clang-format for each source file in parallel,
+        # then wait for all processes to complete
+        results = lintutils.run_parallel([
+            [arguments.clang_format_binary, filename]
+            for filename in formatted_filenames
+        ], stdout=PIPE, stderr=PIPE)
+        for returncode, stdout, stderr in results:
+            # if any clang-format reported a parse error, bubble it
+            if returncode != 0:
+                sys.exit(returncode)
+
+        error = False
+        checker = partial(_check_one_file, {
+            filename: result
+            for filename, result in zip(formatted_filenames, results)
+        })
+        pool = mp.Pool()
+        try:
+            # check the output from each invocation of clang-format in parallel
+            for filename, diff in pool.imap(checker, formatted_filenames):
+                if not arguments.quiet:
+                    print("Checking {}".format(filename))
+                if diff:
+                    print("{} had clang-format style issues".format(filename))
+                    # Print out the diff to stderr
+                    error = True
+                    # pad with a newline
+                    print(file=sys.stderr)
+                    diff_out = []
+                    for diff_str in diff:
+                        diff_out.append(diff_str.encode('raw_unicode_escape'))
+                    sys.stderr.writelines(diff_out)
+        except Exception:
+            error = True
+            raise
+        finally:
+            pool.terminate()
+            pool.join()
+        sys.exit(1 if error else 0)
+
diff --git a/core/build-support/run_clang_tidy.py b/core/build-support/run_clang_tidy.py
new file mode 100755
index 0000000000..6df17d5379
--- /dev/null
+++ b/core/build-support/run_clang_tidy.py
@@ -0,0 +1,126 @@
+#!/usr/bin/env python
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you 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.
+
+from __future__ import print_function
+import argparse
+import multiprocessing as mp
+import lintutils
+from subprocess import PIPE
+import sys
+from functools import partial
+
+
+def _get_chunk_key(filenames):
+    # lists are not hashable so key on the first filename in a chunk
+    return filenames[0]
+
+
+# clang-tidy outputs complaints in '/path:line_number: complaint' format,
+# so we can scan its output to get a list of files to fix
+def _check_some_files(completed_processes, filenames):
+    result = completed_processes[_get_chunk_key(filenames)]
+    return lintutils.stdout_pathcolonline(result, filenames)
+
+
+def _check_all(cmd, filenames):
+    # each clang-tidy instance will process 16 files
+    chunks = lintutils.chunk(filenames, 16)
+    cmds = [cmd + some for some in chunks]
+    results = lintutils.run_parallel(cmds, stderr=PIPE, stdout=PIPE)
+    error = False
+    # record completed processes (keyed by the first filename in the input
+    # chunk) for lookup in _check_some_files
+    completed_processes = {
+        _get_chunk_key(some): result
+        for some, result in zip(chunks, results)
+    }
+    checker = partial(_check_some_files, completed_processes)
+    pool = mp.Pool()
+    try:
+        # check output of completed clang-tidy invocations in parallel
+        for problem_files, stdout in pool.imap(checker, chunks):
+            if problem_files:
+                msg = "clang-tidy suggested fixes for {}"
+                print("\n".join(map(msg.format, problem_files)))
+                print(stdout)
+                error = True
+    except Exception:
+        error = True
+        raise
+    finally:
+        pool.terminate()
+        pool.join()
+
+    if error:
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="Runs clang-tidy on all ")
+    parser.add_argument("--clang_tidy_binary",
+                        required=True,
+                        help="Path to the clang-tidy binary")
+    parser.add_argument("--exclude_globs",
+                        help="Filename containing globs for files "
+                        "that should be excluded from the checks")
+    parser.add_argument("--compile_commands",
+                        required=True,
+                        help="compile_commands.json to pass clang-tidy")
+    parser.add_argument("--source_dir",
+                        required=True,
+                        help="Root directory of the source code")
+    parser.add_argument("--fix", default=False,
+                        action="store_true",
+                        help="If specified, will attempt to fix the "
+                        "source code instead of recommending fixes, "
+                        "defaults to %(default)s")
+    parser.add_argument("--quiet", default=False,
+                        action="store_true",
+                        help="If specified, only print errors")
+    arguments = parser.parse_args()
+
+    exclude_globs = []
+    if arguments.exclude_globs:
+        for line in open(arguments.exclude_globs):
+            exclude_globs.append(line.strip())
+
+    linted_filenames = []
+    for path in lintutils.get_sources(arguments.source_dir, exclude_globs):
+        linted_filenames.append(path)
+
+    if not arguments.quiet:
+        msg = 'Tidying {}' if arguments.fix else 'Checking {}'
+        print("\n".join(map(msg.format, linted_filenames)))
+
+    cmd = [
+        arguments.clang_tidy_binary,
+        '-p',
+        arguments.compile_commands
+    ]
+    if arguments.fix:
+        cmd.append('-fix')
+        results = lintutils.run_parallel(
+            [cmd + some for some in lintutils.chunk(linted_filenames, 16)])
+        for returncode, stdout, stderr in results:
+            if returncode != 0:
+                sys.exit(returncode)
+
+    else:
+        _check_all(cmd, linted_filenames)
+
diff --git a/core/build-support/run_cpplint.py b/core/build-support/run_cpplint.py
new file mode 100755
index 0000000000..98c4170858
--- /dev/null
+++ b/core/build-support/run_cpplint.py
@@ -0,0 +1,132 @@
+#!/usr/bin/env python
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you 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.
+
+from __future__ import print_function
+import lintutils
+from subprocess import PIPE, STDOUT
+import argparse
+import multiprocessing as mp
+import sys
+import platform
+from functools import partial
+
+
+# NOTE(wesm):
+#
+# * readability/casting is disabled as it aggressively warns about functions
+#   with names like "int32", so "int32(x)", where int32 is a function name,
+#   warns with
+_filters = '''
+-whitespace/comments
+-readability/casting
+-readability/todo
+-readability/alt_tokens
+-build/header_guard
+-build/c++11
+-runtime/references
+-build/include_order
+'''.split()
+
+
+def _get_chunk_key(filenames):
+    # lists are not hashable so key on the first filename in a chunk
+    return filenames[0]
+
+
+def _check_some_files(completed_processes, filenames):
+    # cpplint outputs complaints in '/path:line_number: complaint' format,
+    # so we can scan its output to get a list of files to fix
+    result = completed_processes[_get_chunk_key(filenames)]
+    return lintutils.stdout_pathcolonline(result, filenames)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="Runs cpplint on all of the source files.")
+    parser.add_argument("--cpplint_binary",
+                        required=True,
+                        help="Path to the cpplint binary")
+    parser.add_argument("--exclude_globs",
+                        help="Filename containing globs for files "
+                        "that should be excluded from the checks")
+    parser.add_argument("--source_dir",
+                        required=True,
+                        help="Root directory of the source code")
+    parser.add_argument("--quiet", default=False,
+                        action="store_true",
+                        help="If specified, only print errors")
+    arguments = parser.parse_args()
+
+    exclude_globs = []
+    if arguments.exclude_globs:
+        for line in open(arguments.exclude_globs):
+            exclude_globs.append(line.strip())
+
+    linted_filenames = []
+    for path in lintutils.get_sources(arguments.source_dir, exclude_globs):
+        linted_filenames.append(str(path))
+
+    cmd = [
+        arguments.cpplint_binary,
+        '--verbose=2',
+        '--linelength=120',
+        '--filter=' + ','.join(_filters)
+    ]
+    if (arguments.cpplint_binary.endswith('.py') and
+            platform.system() == 'Windows'):
+        # Windows doesn't support executable scripts; execute with
+        # sys.executable
+        cmd.insert(0, sys.executable)
+    if arguments.quiet:
+        cmd.append('--quiet')
+    else:
+        print("\n".join(map(lambda x: "Linting {}".format(x),
+                            linted_filenames)))
+
+    # lint files in chunks: each invocation of cpplint will process 16 files
+    chunks = lintutils.chunk(linted_filenames, 16)
+    cmds = [cmd + some for some in chunks]
+    results = lintutils.run_parallel(cmds, stdout=PIPE, stderr=STDOUT)
+
+    error = False
+    # record completed processes (keyed by the first filename in the input
+    # chunk) for lookup in _check_some_files
+    completed_processes = {
+        _get_chunk_key(filenames): result
+        for filenames, result in zip(chunks, results)
+    }
+    checker = partial(_check_some_files, completed_processes)
+    pool = mp.Pool()
+    try:
+        # scan the outputs of various cpplint invocations in parallel to
+        # distill a list of problematic files
+        for problem_files, stdout in pool.imap(checker, chunks):
+            if problem_files:
+                if isinstance(stdout, bytes):
+                    stdout = stdout.decode('utf8')
+                print(stdout, file=sys.stderr)
+                error = True
+    except Exception:
+        error = True
+        raise
+    finally:
+        pool.terminate()
+        pool.join()
+
+    sys.exit(1 if error else 0)
+
diff --git a/core/build.sh b/core/build.sh
new file mode 100755
index 0000000000..a662fe497a
--- /dev/null
+++ b/core/build.sh
@@ -0,0 +1,150 @@
+#!/bin/bash
+
+BUILD_OUTPUT_DIR="cmake_build"
+BUILD_TYPE="Debug"
+BUILD_UNITTEST="OFF"
+INSTALL_PREFIX=$(pwd)/milvus
+MAKE_CLEAN="OFF"
+BUILD_COVERAGE="OFF"
+DB_PATH="/tmp/milvus"
+PROFILING="OFF"
+USE_JFROG_CACHE="OFF"
+RUN_CPPLINT="OFF"
+CUSTOMIZATION="OFF" # default use ori faiss
+CUDA_COMPILER=/usr/local/cuda/bin/nvcc
+
+CUSTOMIZED_FAISS_URL="${FAISS_URL:-NONE}"
+wget -q --method HEAD ${CUSTOMIZED_FAISS_URL}
+if [ $? -eq 0 ]; then
+  CUSTOMIZATION="ON"
+else
+  CUSTOMIZATION="OFF"
+fi
+
+while getopts "p:d:t:ulrcgjhx" arg
+do
+        case $arg in
+             p)
+                INSTALL_PREFIX=$OPTARG
+                ;;
+             d)
+                DB_PATH=$OPTARG
+                ;;
+             t)
+                BUILD_TYPE=$OPTARG # BUILD_TYPE
+                ;;
+             u)
+                echo "Build and run unittest cases" ;
+                BUILD_UNITTEST="ON";
+                ;;
+             l)
+                RUN_CPPLINT="ON"
+                ;;
+             r)
+                if [[ -d ${BUILD_OUTPUT_DIR} ]]; then
+                    rm ./${BUILD_OUTPUT_DIR} -r
+                    MAKE_CLEAN="ON"
+                fi
+                ;;
+             c)
+                BUILD_COVERAGE="ON"
+                ;;
+             g)
+                PROFILING="ON"
+                ;;
+             j)
+                USE_JFROG_CACHE="ON"
+                ;;
+             x)
+                CUSTOMIZATION="OFF" # force use ori faiss
+                ;;
+             h) # help
+                echo "
+
+parameter:
+-p: install prefix(default: $(pwd)/milvus)
+-d: db data path(default: /tmp/milvus)
+-t: build type(default: Debug)
+-u: building unit test options(default: OFF)
+-l: run cpplint, clang-format and clang-tidy(default: OFF)
+-r: remove previous build directory(default: OFF)
+-c: code coverage(default: OFF)
+-g: profiling(default: OFF)
+-j: use jfrog cache build directory(default: OFF)
+-h: help
+
+usage:
+./build.sh -p \${INSTALL_PREFIX} -t \${BUILD_TYPE} [-u] [-l] [-r] [-c] [-g] [-j] [-h]
+                "
+                exit 0
+                ;;
+             ?)
+                echo "ERROR! unknown argument"
+        exit 1
+        ;;
+        esac
+done
+
+if [[ ! -d ${BUILD_OUTPUT_DIR} ]]; then
+    mkdir ${BUILD_OUTPUT_DIR}
+fi
+
+cd ${BUILD_OUTPUT_DIR}
+
+# remove make cache since build.sh -l use default variables
+# force update the variables each time
+make rebuild_cache > /dev/null 2>&1
+
+CMAKE_CMD="cmake \
+-DBUILD_UNIT_TEST=${BUILD_UNITTEST} \
+-DCMAKE_INSTALL_PREFIX=${INSTALL_PREFIX}
+-DCMAKE_BUILD_TYPE=${BUILD_TYPE} \
+-DCMAKE_CUDA_COMPILER=${CUDA_COMPILER} \
+-DBUILD_COVERAGE=${BUILD_COVERAGE} \
+-DMILVUS_DB_PATH=${DB_PATH} \
+-DMILVUS_ENABLE_PROFILING=${PROFILING} \
+-DUSE_JFROG_CACHE=${USE_JFROG_CACHE} \
+-DCUSTOMIZATION=${CUSTOMIZATION} \
+-DFAISS_URL=${CUSTOMIZED_FAISS_URL} \
+../"
+echo ${CMAKE_CMD}
+${CMAKE_CMD}
+
+if [[ ${MAKE_CLEAN} == "ON" ]]; then
+    make clean
+fi
+
+if [[ ${RUN_CPPLINT} == "ON" ]]; then
+    # cpplint check
+    make lint
+    if [ $? -ne 0 ]; then
+        echo "ERROR! cpplint check failed"
+        exit 1
+    fi
+    echo "cpplint check passed!"
+
+    # clang-format check
+    make check-clang-format
+    if [ $? -ne 0 ]; then
+        echo "ERROR! clang-format check failed"
+        exit 1
+    fi
+    echo "clang-format check passed!"
+
+#    # clang-tidy check
+#    make check-clang-tidy
+#    if [ $? -ne 0 ]; then
+#        echo "ERROR! clang-tidy check failed"
+#        exit 1
+#    fi
+#    echo "clang-tidy check passed!"
+else
+
+    # strip binary symbol
+    if [[ ${BUILD_TYPE} != "Debug" ]]; then
+        strip src/milvus_server
+    fi
+
+    # compile and build
+    make -j 8 install || exit 1
+fi
\ No newline at end of file
diff --git a/core/cmake/BuildUtils.cmake b/core/cmake/BuildUtils.cmake
new file mode 100644
index 0000000000..68cd22ae58
--- /dev/null
+++ b/core/cmake/BuildUtils.cmake
@@ -0,0 +1,204 @@
+# Define a function that check last file modification
+function(Check_Last_Modify cache_check_lists_file_path working_dir last_modified_commit_id)
+    if(EXISTS "${working_dir}")
+        if(EXISTS "${cache_check_lists_file_path}")
+            set(GIT_LOG_SKIP_NUM 0)
+            set(_MATCH_ALL ON CACHE BOOL "Match all")
+            set(_LOOP_STATUS ON CACHE BOOL "Whether out of loop")
+            file(STRINGS ${cache_check_lists_file_path} CACHE_IGNORE_TXT)
+            while(_LOOP_STATUS)
+                foreach(_IGNORE_ENTRY ${CACHE_IGNORE_TXT})
+                    if(NOT _IGNORE_ENTRY MATCHES "^[^#]+")
+                        continue()
+                    endif()
+
+                    set(_MATCH_ALL OFF)
+                    execute_process(COMMAND git log --no-merges -1 --skip=${GIT_LOG_SKIP_NUM} --name-status --pretty= WORKING_DIRECTORY ${working_dir} OUTPUT_VARIABLE CHANGE_FILES)
+                    if(NOT CHANGE_FILES STREQUAL "")
+                        string(REPLACE "\n" ";" _CHANGE_FILES ${CHANGE_FILES})
+                        foreach(_FILE_ENTRY ${_CHANGE_FILES})
+                            string(REGEX MATCH "[^ \t]+$" _FILE_NAME ${_FILE_ENTRY})
+                            execute_process(COMMAND sh -c "echo ${_FILE_NAME} | grep ${_IGNORE_ENTRY}" RESULT_VARIABLE return_code)
+                            if (return_code EQUAL 0)
+                                execute_process(COMMAND git log --no-merges -1 --skip=${GIT_LOG_SKIP_NUM} --pretty=%H WORKING_DIRECTORY ${working_dir} OUTPUT_VARIABLE LAST_MODIFIED_COMMIT_ID)
+                                set (${last_modified_commit_id} ${LAST_MODIFIED_COMMIT_ID} PARENT_SCOPE)
+                                set(_LOOP_STATUS OFF)
+                            endif()
+                        endforeach()
+                    else()
+                        set(_LOOP_STATUS OFF)
+                    endif()
+                endforeach()
+
+                if(_MATCH_ALL)
+                    execute_process(COMMAND git log --no-merges -1 --skip=${GIT_LOG_SKIP_NUM} --pretty=%H WORKING_DIRECTORY ${working_dir} OUTPUT_VARIABLE LAST_MODIFIED_COMMIT_ID)
+                    set (${last_modified_commit_id} ${LAST_MODIFIED_COMMIT_ID} PARENT_SCOPE)
+                    set(_LOOP_STATUS OFF)
+                endif()
+
+                math(EXPR GIT_LOG_SKIP_NUM "${GIT_LOG_SKIP_NUM} + 1")
+            endwhile(_LOOP_STATUS)
+        else()
+            execute_process(COMMAND git log --no-merges -1 --skip=${GIT_LOG_SKIP_NUM} --pretty=%H WORKING_DIRECTORY ${working_dir} OUTPUT_VARIABLE LAST_MODIFIED_COMMIT_ID)
+            set (${last_modified_commit_id} ${LAST_MODIFIED_COMMIT_ID} PARENT_SCOPE)
+        endif()
+    else()
+        message(FATAL_ERROR "The directory ${working_dir} does not exist")
+    endif()
+endfunction()
+
+# Define a function that extracts a cached package
+function(ExternalProject_Use_Cache project_name package_file install_path)
+    message(STATUS "Will use cached package file: ${package_file}")
+
+    ExternalProject_Add(${project_name}
+        DOWNLOAD_COMMAND ${CMAKE_COMMAND} -E echo
+            "No download step needed (using cached package)"
+        CONFIGURE_COMMAND ${CMAKE_COMMAND} -E echo
+            "No configure step needed (using cached package)"
+        BUILD_COMMAND ${CMAKE_COMMAND} -E echo
+            "No build step needed (using cached package)"
+        INSTALL_COMMAND ${CMAKE_COMMAND} -E echo
+            "No install step needed (using cached package)"
+    )
+
+    # We want our tar files to contain the Install/<package> prefix (not for any
+    # very special reason, only for consistency and so that we can identify them
+    # in the extraction logs) which means that we must extract them in the
+    # binary (top-level build) directory to have them installed in the right
+    # place for subsequent ExternalProjects to pick them up. It seems that the
+    # only way to control the working directory is with Add_Step!
+    ExternalProject_Add_Step(${project_name} extract
+        ALWAYS 1
+        COMMAND
+            ${CMAKE_COMMAND} -E echo
+            "Extracting ${package_file} to ${install_path}"
+        COMMAND
+            ${CMAKE_COMMAND} -E tar xzvf ${package_file} ${install_path}
+            WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+    )
+
+    ExternalProject_Add_StepTargets(${project_name} extract)
+endfunction()
+
+# Define a function that to create a new cached package
+function(ExternalProject_Create_Cache project_name package_file install_path cache_username cache_password cache_path)
+    if(EXISTS ${package_file})
+        message(STATUS "Removing existing package file: ${package_file}")
+        file(REMOVE ${package_file})
+    endif()
+
+    string(REGEX REPLACE "(.+)/.+$" "\\1" package_dir ${package_file})
+    if(NOT EXISTS ${package_dir})
+        file(MAKE_DIRECTORY ${package_dir})
+    endif()
+
+    message(STATUS "Will create cached package file: ${package_file}")
+
+    ExternalProject_Add_Step(${project_name} package
+        DEPENDEES install
+        BYPRODUCTS ${package_file}
+        COMMAND ${CMAKE_COMMAND} -E echo "Updating cached package file: ${package_file}"
+        COMMAND ${CMAKE_COMMAND} -E tar czvf ${package_file} ${install_path}
+        COMMAND ${CMAKE_COMMAND} -E echo "Uploading package file ${package_file} to ${cache_path}"
+        COMMAND curl -u${cache_username}:${cache_password} -T ${package_file} ${cache_path}
+    )
+
+    ExternalProject_Add_StepTargets(${project_name} package)
+endfunction()
+
+function(ADD_THIRDPARTY_LIB LIB_NAME)
+    set(options)
+    set(one_value_args SHARED_LIB STATIC_LIB)
+    set(multi_value_args DEPS INCLUDE_DIRECTORIES)
+    cmake_parse_arguments(ARG
+            "${options}"
+            "${one_value_args}"
+            "${multi_value_args}"
+            ${ARGN})
+    if(ARG_UNPARSED_ARGUMENTS)
+        message(SEND_ERROR "Error: unrecognized arguments: ${ARG_UNPARSED_ARGUMENTS}")
+    endif()
+
+    if(ARG_STATIC_LIB AND ARG_SHARED_LIB)
+        if(NOT ARG_STATIC_LIB)
+            message(FATAL_ERROR "No static or shared library provided for ${LIB_NAME}")
+        endif()
+
+        set(AUG_LIB_NAME "${LIB_NAME}_static")
+        add_library(${AUG_LIB_NAME} STATIC IMPORTED)
+        set_target_properties(${AUG_LIB_NAME}
+                PROPERTIES IMPORTED_LOCATION "${ARG_STATIC_LIB}")
+        if(ARG_DEPS)
+            set_target_properties(${AUG_LIB_NAME}
+                    PROPERTIES INTERFACE_LINK_LIBRARIES "${ARG_DEPS}")
+        endif()
+        message(STATUS "Added static library dependency ${AUG_LIB_NAME}: ${ARG_STATIC_LIB}")
+        if(ARG_INCLUDE_DIRECTORIES)
+            set_target_properties(${AUG_LIB_NAME}
+                    PROPERTIES INTERFACE_INCLUDE_DIRECTORIES
+                    "${ARG_INCLUDE_DIRECTORIES}")
+        endif()
+
+        set(AUG_LIB_NAME "${LIB_NAME}_shared")
+        add_library(${AUG_LIB_NAME} SHARED IMPORTED)
+
+        if(WIN32)
+            # Mark the ".lib" location as part of a Windows DLL
+            set_target_properties(${AUG_LIB_NAME}
+                    PROPERTIES IMPORTED_IMPLIB "${ARG_SHARED_LIB}")
+        else()
+            set_target_properties(${AUG_LIB_NAME}
+                    PROPERTIES IMPORTED_LOCATION "${ARG_SHARED_LIB}")
+        endif()
+        if(ARG_DEPS)
+            set_target_properties(${AUG_LIB_NAME}
+                    PROPERTIES INTERFACE_LINK_LIBRARIES "${ARG_DEPS}")
+        endif()
+        message(STATUS "Added shared library dependency ${AUG_LIB_NAME}: ${ARG_SHARED_LIB}")
+        if(ARG_INCLUDE_DIRECTORIES)
+            set_target_properties(${AUG_LIB_NAME}
+                    PROPERTIES INTERFACE_INCLUDE_DIRECTORIES
+                    "${ARG_INCLUDE_DIRECTORIES}")
+        endif()
+    elseif(ARG_STATIC_LIB)
+        set(AUG_LIB_NAME "${LIB_NAME}_static")
+        add_library(${AUG_LIB_NAME} STATIC IMPORTED)
+        set_target_properties(${AUG_LIB_NAME}
+                PROPERTIES IMPORTED_LOCATION "${ARG_STATIC_LIB}")
+        if(ARG_DEPS)
+            set_target_properties(${AUG_LIB_NAME}
+                    PROPERTIES INTERFACE_LINK_LIBRARIES "${ARG_DEPS}")
+        endif()
+        message(STATUS "Added static library dependency ${AUG_LIB_NAME}: ${ARG_STATIC_LIB}")
+        if(ARG_INCLUDE_DIRECTORIES)
+            set_target_properties(${AUG_LIB_NAME}
+                    PROPERTIES INTERFACE_INCLUDE_DIRECTORIES
+                    "${ARG_INCLUDE_DIRECTORIES}")
+        endif()
+    elseif(ARG_SHARED_LIB)
+        set(AUG_LIB_NAME "${LIB_NAME}_shared")
+        add_library(${AUG_LIB_NAME} SHARED IMPORTED)
+
+        if(WIN32)
+            # Mark the ".lib" location as part of a Windows DLL
+            set_target_properties(${AUG_LIB_NAME}
+                    PROPERTIES IMPORTED_IMPLIB "${ARG_SHARED_LIB}")
+        else()
+            set_target_properties(${AUG_LIB_NAME}
+                    PROPERTIES IMPORTED_LOCATION "${ARG_SHARED_LIB}")
+        endif()
+        message(STATUS "Added shared library dependency ${AUG_LIB_NAME}: ${ARG_SHARED_LIB}")
+        if(ARG_DEPS)
+            set_target_properties(${AUG_LIB_NAME}
+                    PROPERTIES INTERFACE_LINK_LIBRARIES "${ARG_DEPS}")
+        endif()
+        if(ARG_INCLUDE_DIRECTORIES)
+            set_target_properties(${AUG_LIB_NAME}
+                    PROPERTIES INTERFACE_INCLUDE_DIRECTORIES
+                    "${ARG_INCLUDE_DIRECTORIES}")
+        endif()
+    else()
+        message(FATAL_ERROR "No static or shared library provided for ${LIB_NAME}")
+    endif()
+endfunction()
diff --git a/core/cmake/DefineOptions.cmake b/core/cmake/DefineOptions.cmake
new file mode 100644
index 0000000000..7aae177f0b
--- /dev/null
+++ b/core/cmake/DefineOptions.cmake
@@ -0,0 +1,189 @@
+
+macro(set_option_category name)
+    set(MILVUS_OPTION_CATEGORY ${name})
+    list(APPEND "MILVUS_OPTION_CATEGORIES" ${name})
+endmacro()
+
+macro(define_option name description default)
+    option(${name} ${description} ${default})
+    list(APPEND "MILVUS_${MILVUS_OPTION_CATEGORY}_OPTION_NAMES" ${name})
+    set("${name}_OPTION_DESCRIPTION" ${description})
+    set("${name}_OPTION_DEFAULT" ${default})
+    set("${name}_OPTION_TYPE" "bool")
+endmacro()
+
+function(list_join lst glue out)
+    if("${${lst}}" STREQUAL "")
+        set(${out} "" PARENT_SCOPE)
+        return()
+    endif()
+
+    list(GET ${lst} 0 joined)
+    list(REMOVE_AT ${lst} 0)
+    foreach(item ${${lst}})
+        set(joined "${joined}${glue}${item}")
+    endforeach()
+    set(${out} ${joined} PARENT_SCOPE)
+endfunction()
+
+macro(define_option_string name description default)
+    set(${name} ${default} CACHE STRING ${description})
+    list(APPEND "MILVUS_${MILVUS_OPTION_CATEGORY}_OPTION_NAMES" ${name})
+    set("${name}_OPTION_DESCRIPTION" ${description})
+    set("${name}_OPTION_DEFAULT" "\"${default}\"")
+    set("${name}_OPTION_TYPE" "string")
+
+    set("${name}_OPTION_ENUM" ${ARGN})
+    list_join("${name}_OPTION_ENUM" "|" "${name}_OPTION_ENUM")
+    if(NOT ("${${name}_OPTION_ENUM}" STREQUAL ""))
+        set_property(CACHE ${name} PROPERTY STRINGS ${ARGN})
+    endif()
+endmacro()
+
+#----------------------------------------------------------------------
+set_option_category("Thirdparty")
+
+set(MILVUS_DEPENDENCY_SOURCE_DEFAULT "AUTO")
+
+define_option_string(MILVUS_DEPENDENCY_SOURCE
+                    "Method to use for acquiring MILVUS's build dependencies"
+                    "${MILVUS_DEPENDENCY_SOURCE_DEFAULT}"
+                    "AUTO"
+                    "BUNDLED"
+                    "SYSTEM")
+
+define_option(MILVUS_VERBOSE_THIRDPARTY_BUILD
+        "Show output from ExternalProjects rather than just logging to files" ON)
+
+define_option(MILVUS_BOOST_VENDORED "Use vendored Boost instead of existing Boost. \
+Note that this requires linking Boost statically" OFF)
+
+define_option(MILVUS_BOOST_HEADER_ONLY "Use only BOOST headers" OFF)
+
+define_option(MILVUS_WITH_BZ2 "Build with BZ2 compression" ON)
+
+define_option(MILVUS_WITH_EASYLOGGINGPP "Build with Easylogging++ library" ON)
+
+define_option(MILVUS_WITH_LZ4 "Build with lz4 compression" ON)
+
+define_option(MILVUS_WITH_PROMETHEUS "Build with PROMETHEUS library" ON)
+
+define_option(MILVUS_WITH_SNAPPY "Build with Snappy compression" ON)
+
+define_option(MILVUS_WITH_SQLITE "Build with SQLite library" ON)
+
+define_option(MILVUS_WITH_SQLITE_ORM "Build with SQLite ORM library" ON)
+
+define_option(MILVUS_WITH_MYSQLPP "Build with MySQL++" ON)
+
+define_option(MILVUS_WITH_YAMLCPP "Build with yaml-cpp library" ON)
+
+define_option(MILVUS_WITH_ZLIB "Build with zlib compression" ON)
+
+if(CMAKE_VERSION VERSION_LESS 3.7)
+    set(MILVUS_WITH_ZSTD_DEFAULT OFF)
+else()
+    # ExternalProject_Add(SOURCE_SUBDIR) is available since CMake 3.7.
+    set(MILVUS_WITH_ZSTD_DEFAULT ON)
+endif()
+define_option(MILVUS_WITH_ZSTD "Build with zstd compression" ${MILVUS_WITH_ZSTD_DEFAULT})
+
+if (MILVUS_ENABLE_PROFILING STREQUAL "ON")
+    define_option(MILVUS_WITH_LIBUNWIND "Build with libunwind" ON)
+    define_option(MILVUS_WITH_GPERFTOOLS "Build with gperftools" ON)
+endif()
+
+define_option(MILVUS_WITH_GRPC "Build with GRPC" ON)
+
+#----------------------------------------------------------------------
+if(MSVC)
+    set_option_category("MSVC")
+
+    define_option(MSVC_LINK_VERBOSE
+            "Pass verbose linking options when linking libraries and executables"
+            OFF)
+
+    define_option(MILVUS_USE_STATIC_CRT "Build MILVUS with statically linked CRT" OFF)
+endif()
+
+
+#----------------------------------------------------------------------
+set_option_category("Test and benchmark")
+
+unset(MILVUS_BUILD_TESTS CACHE)
+if (BUILD_UNIT_TEST)
+    define_option(MILVUS_BUILD_TESTS "Build the MILVUS googletest unit tests" ON)
+else()
+    define_option(MILVUS_BUILD_TESTS "Build the MILVUS googletest unit tests" OFF)
+endif(BUILD_UNIT_TEST)
+
+#----------------------------------------------------------------------
+macro(config_summary)
+    message(STATUS "---------------------------------------------------------------------")
+    message(STATUS "MILVUS version:                                 ${MILVUS_VERSION}")
+    message(STATUS)
+    message(STATUS "Build configuration summary:")
+
+    message(STATUS "  Generator: ${CMAKE_GENERATOR}")
+    message(STATUS "  Build type: ${CMAKE_BUILD_TYPE}")
+    message(STATUS "  Source directory: ${CMAKE_CURRENT_SOURCE_DIR}")
+    if(${CMAKE_EXPORT_COMPILE_COMMANDS})
+        message(
+                STATUS "  Compile commands: ${CMAKE_CURRENT_BINARY_DIR}/compile_commands.json")
+    endif()
+
+    foreach(category ${MILVUS_OPTION_CATEGORIES})
+
+        message(STATUS)
+        message(STATUS "${category} options:")
+
+        set(option_names ${MILVUS_${category}_OPTION_NAMES})
+
+        set(max_value_length 0)
+        foreach(name ${option_names})
+            string(LENGTH "\"${${name}}\"" value_length)
+            if(${max_value_length} LESS ${value_length})
+                set(max_value_length ${value_length})
+            endif()
+        endforeach()
+
+        foreach(name ${option_names})
+            if("${${name}_OPTION_TYPE}" STREQUAL "string")
+                set(value "\"${${name}}\"")
+            else()
+                set(value "${${name}}")
+            endif()
+
+            set(default ${${name}_OPTION_DEFAULT})
+            set(description ${${name}_OPTION_DESCRIPTION})
+            string(LENGTH ${description} description_length)
+            if(${description_length} LESS 70)
+                string(
+                        SUBSTRING
+                        "                                                                     "
+                        ${description_length} -1 description_padding)
+            else()
+                set(description_padding "
+                ")
+            endif()
+
+            set(comment "[${name}]")
+
+            if("${value}" STREQUAL "${default}")
+                set(comment "[default] ${comment}")
+            endif()
+
+            if(NOT ("${${name}_OPTION_ENUM}" STREQUAL ""))
+                set(comment "${comment} [${${name}_OPTION_ENUM}]")
+            endif()
+
+            string(
+                    SUBSTRING "${value}                                                             "
+                    0 ${max_value_length} value)
+
+            message(STATUS "  ${description} ${description_padding} ${value} ${comment}")
+        endforeach()
+
+    endforeach()
+
+endmacro()
diff --git a/core/cmake/FindClangTools.cmake b/core/cmake/FindClangTools.cmake
new file mode 100644
index 0000000000..83e71d750b
--- /dev/null
+++ b/core/cmake/FindClangTools.cmake
@@ -0,0 +1,109 @@
+#
+# 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.
+#
+# Tries to find the clang-tidy and clang-format modules
+#
+# Usage of this module as follows:
+#
+#  find_package(ClangTools)
+#
+# Variables used by this module, they can change the default behaviour and need
+# to be set before calling find_package:
+#
+#  ClangToolsBin_HOME -
+#   When set, this path is inspected instead of standard library binary locations
+#   to find clang-tidy and clang-format
+#
+# This module defines
+#  CLANG_TIDY_BIN, The  path to the clang tidy binary
+#  CLANG_TIDY_FOUND, Whether clang tidy was found
+#  CLANG_FORMAT_BIN, The path to the clang format binary
+#  CLANG_TIDY_FOUND, Whether clang format was found
+
+find_program(CLANG_TIDY_BIN
+  NAMES
+  clang-tidy-7.0
+  clang-tidy-6.0
+  clang-tidy-5.0
+  clang-tidy-4.0
+  clang-tidy-3.9
+  clang-tidy-3.8
+  clang-tidy-3.7
+  clang-tidy-3.6
+  clang-tidy
+  PATHS ${ClangTools_PATH} $ENV{CLANG_TOOLS_PATH} /usr/local/bin /usr/bin
+        NO_DEFAULT_PATH
+)
+
+if ( "${CLANG_TIDY_BIN}" STREQUAL "CLANG_TIDY_BIN-NOTFOUND" )
+  set(CLANG_TIDY_FOUND 0)
+  message("clang-tidy not found")
+else()
+  set(CLANG_TIDY_FOUND 1)
+  message("clang-tidy found at ${CLANG_TIDY_BIN}")
+endif()
+
+if (CLANG_FORMAT_VERSION)
+    find_program(CLANG_FORMAT_BIN
+      NAMES clang-format-${CLANG_FORMAT_VERSION}
+      PATHS
+            ${ClangTools_PATH}
+            $ENV{CLANG_TOOLS_PATH}
+            /usr/local/bin /usr/bin
+            NO_DEFAULT_PATH
+    )
+
+    # If not found yet, search alternative locations
+    if (("${CLANG_FORMAT_BIN}" STREQUAL "CLANG_FORMAT_BIN-NOTFOUND") AND APPLE)
+        # Homebrew ships older LLVM versions in /usr/local/opt/llvm@version/
+        STRING(REGEX REPLACE "^([0-9]+)\\.[0-9]+" "\\1" CLANG_FORMAT_MAJOR_VERSION "${CLANG_FORMAT_VERSION}")
+        STRING(REGEX REPLACE "^[0-9]+\\.([0-9]+)" "\\1" CLANG_FORMAT_MINOR_VERSION "${CLANG_FORMAT_VERSION}")
+        if ("${CLANG_FORMAT_MINOR_VERSION}" STREQUAL "0")
+            find_program(CLANG_FORMAT_BIN
+              NAMES clang-format
+              PATHS /usr/local/opt/llvm@${CLANG_FORMAT_MAJOR_VERSION}/bin
+                    NO_DEFAULT_PATH
+            )
+        else()
+            find_program(CLANG_FORMAT_BIN
+              NAMES clang-format
+              PATHS /usr/local/opt/llvm@${CLANG_FORMAT_VERSION}/bin
+                    NO_DEFAULT_PATH
+            )
+        endif()
+    endif()
+else()
+    find_program(CLANG_FORMAT_BIN
+      NAMES
+      clang-format-7.0
+      clang-format-6.0
+      clang-format-5.0
+      clang-format-4.0
+      clang-format-3.9
+      clang-format-3.8
+      clang-format-3.7
+      clang-format-3.6
+      clang-format
+      PATHS ${ClangTools_PATH} $ENV{CLANG_TOOLS_PATH} /usr/local/bin /usr/bin
+            NO_DEFAULT_PATH
+    )
+endif()
+
+if ( "${CLANG_FORMAT_BIN}" STREQUAL "CLANG_FORMAT_BIN-NOTFOUND" )
+  set(CLANG_FORMAT_FOUND 0)
+  message("clang-format not found")
+else()
+  set(CLANG_FORMAT_FOUND 1)
+  message("clang-format found at ${CLANG_FORMAT_BIN}")
+endif()
+
diff --git a/core/cmake/ThirdPartyPackages.cmake b/core/cmake/ThirdPartyPackages.cmake
new file mode 100644
index 0000000000..ade57c06ad
--- /dev/null
+++ b/core/cmake/ThirdPartyPackages.cmake
@@ -0,0 +1,1712 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you 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.
+
+set(MILVUS_THIRDPARTY_DEPENDENCIES
+
+        BOOST
+        BZip2
+        GTest
+        Lz4
+        MySQLPP
+        Prometheus
+        Snappy
+        SQLite
+        SQLite_ORM
+        yaml-cpp
+        ZLIB
+        ZSTD
+        libunwind
+        gperftools
+        GRPC)
+
+message(STATUS "Using ${MILVUS_DEPENDENCY_SOURCE} approach to find dependencies")
+
+# For each dependency, set dependency source to global default, if unset
+foreach(DEPENDENCY ${MILVUS_THIRDPARTY_DEPENDENCIES})
+    if("${${DEPENDENCY}_SOURCE}" STREQUAL "")
+        set(${DEPENDENCY}_SOURCE ${MILVUS_DEPENDENCY_SOURCE})
+    endif()
+endforeach()
+
+macro(build_dependency DEPENDENCY_NAME)
+    if("${DEPENDENCY_NAME}" STREQUAL "BZip2")
+        build_bzip2()
+    elseif ("${DEPENDENCY_NAME}" STREQUAL "GTest")
+        build_gtest()
+    elseif("${DEPENDENCY_NAME}" STREQUAL "Lz4")
+        build_lz4()
+    elseif ("${DEPENDENCY_NAME}" STREQUAL "MySQLPP")
+        build_mysqlpp()
+    elseif ("${DEPENDENCY_NAME}" STREQUAL "Prometheus")
+        build_prometheus()
+    elseif ("${DEPENDENCY_NAME}" STREQUAL "Snappy")
+        build_snappy()
+    elseif ("${DEPENDENCY_NAME}" STREQUAL "SQLite")
+        build_sqlite()
+    elseif ("${DEPENDENCY_NAME}" STREQUAL "SQLite_ORM")
+        build_sqlite_orm()
+    elseif("${DEPENDENCY_NAME}" STREQUAL "yaml-cpp")
+        build_yamlcpp()
+    elseif("${DEPENDENCY_NAME}" STREQUAL "ZLIB")
+        build_zlib()
+    elseif("${DEPENDENCY_NAME}" STREQUAL "ZSTD")
+        build_zstd()
+    elseif("${DEPENDENCY_NAME}" STREQUAL "libunwind")
+        build_libunwind()
+    elseif("${DEPENDENCY_NAME}" STREQUAL "gperftools")
+        build_gperftools()
+    elseif("${DEPENDENCY_NAME}" STREQUAL "GRPC")
+        build_grpc()
+    else()
+        message(FATAL_ERROR "Unknown thirdparty dependency to build: ${DEPENDENCY_NAME}")
+    endif ()
+endmacro()
+
+# ----------------------------------------------------------------------
+# Identify OS
+if (UNIX)
+    if (APPLE)
+        set (CMAKE_OS_NAME "osx" CACHE STRING "Operating system name" FORCE)
+    else (APPLE)
+        ## Check for Debian GNU/Linux ________________
+        find_file (DEBIAN_FOUND debian_version debconf.conf
+            PATHS /etc
+        )
+        if (DEBIAN_FOUND)
+            set (CMAKE_OS_NAME "debian" CACHE STRING "Operating system name" FORCE)
+        endif (DEBIAN_FOUND)
+        ##  Check for Fedora _________________________
+        find_file (FEDORA_FOUND fedora-release
+            PATHS /etc
+        )
+        if (FEDORA_FOUND)
+            set (CMAKE_OS_NAME "fedora" CACHE STRING "Operating system name" FORCE)
+        endif (FEDORA_FOUND)
+        ##  Check for RedHat _________________________
+        find_file (REDHAT_FOUND redhat-release inittab.RH
+            PATHS /etc
+        )
+        if (REDHAT_FOUND)
+            set (CMAKE_OS_NAME "redhat" CACHE STRING "Operating system name" FORCE)
+        endif (REDHAT_FOUND)
+        ## Extra check for Ubuntu ____________________
+        if (DEBIAN_FOUND)
+            ## At its core Ubuntu is a Debian system, with
+            ## a slightly altered configuration; hence from
+            ## a first superficial inspection a system will
+            ## be considered as Debian, which signifies an
+            ## extra check is required.
+            find_file (UBUNTU_EXTRA legal issue
+                PATHS /etc
+            )
+            if (UBUNTU_EXTRA)
+                ## Scan contents of file
+                file (STRINGS ${UBUNTU_EXTRA} UBUNTU_FOUND
+                    REGEX Ubuntu
+                )
+                ## Check result of string search
+                if (UBUNTU_FOUND)
+                    set (CMAKE_OS_NAME "ubuntu" CACHE STRING "Operating system name" FORCE)
+                    set (DEBIAN_FOUND FALSE)
+                endif (UBUNTU_FOUND)
+            endif (UBUNTU_EXTRA)
+        endif (DEBIAN_FOUND)
+    endif (APPLE)
+endif (UNIX)
+
+# ----------------------------------------------------------------------
+# thirdparty directory
+set(THIRDPARTY_DIR "${MILVUS_SOURCE_DIR}/thirdparty")
+
+# ----------------------------------------------------------------------
+# JFrog
+if(NOT DEFINED USE_JFROG_CACHE)
+    set(USE_JFROG_CACHE "OFF")
+endif()
+if(USE_JFROG_CACHE STREQUAL "ON")
+    if(DEFINED ENV{JFROG_ARTFACTORY_URL})
+        set(JFROG_ARTFACTORY_URL "$ENV{JFROG_ARTFACTORY_URL}")
+    endif()
+    if(NOT DEFINED JFROG_ARTFACTORY_URL)
+        message(FATAL_ERROR "JFROG_ARTFACTORY_URL is not set")
+    endif()
+    set(JFROG_ARTFACTORY_CACHE_URL "${JFROG_ARTFACTORY_URL}/milvus/thirdparty/cache/${CMAKE_OS_NAME}/${MILVUS_BUILD_ARCH}/${BUILD_TYPE}")
+    if(DEFINED ENV{JFROG_USER_NAME})
+        set(JFROG_USER_NAME "$ENV{JFROG_USER_NAME}")
+    endif()
+    if(NOT DEFINED JFROG_USER_NAME)
+        message(FATAL_ERROR "JFROG_USER_NAME is not set")
+    endif()
+    if(DEFINED ENV{JFROG_PASSWORD})
+        set(JFROG_PASSWORD "$ENV{JFROG_PASSWORD}")
+    endif()
+    if(NOT DEFINED JFROG_PASSWORD)
+        message(FATAL_ERROR "JFROG_PASSWORD is not set")
+    endif()
+
+    set(THIRDPARTY_PACKAGE_CACHE "${THIRDPARTY_DIR}/cache")
+    if(NOT EXISTS ${THIRDPARTY_PACKAGE_CACHE})
+        message(STATUS "Will create cached directory: ${THIRDPARTY_PACKAGE_CACHE}")
+        file(MAKE_DIRECTORY ${THIRDPARTY_PACKAGE_CACHE})
+    endif()
+endif()
+
+macro(resolve_dependency DEPENDENCY_NAME)
+    if (${DEPENDENCY_NAME}_SOURCE STREQUAL "AUTO")
+        #disable find_package for now
+        build_dependency(${DEPENDENCY_NAME})
+    elseif (${DEPENDENCY_NAME}_SOURCE STREQUAL "BUNDLED")
+        build_dependency(${DEPENDENCY_NAME})
+    elseif (${DEPENDENCY_NAME}_SOURCE STREQUAL "SYSTEM")
+        find_package(${DEPENDENCY_NAME} REQUIRED)
+    endif ()
+endmacro()
+
+# ----------------------------------------------------------------------
+# ExternalProject options
+
+string(TOUPPER ${CMAKE_BUILD_TYPE} UPPERCASE_BUILD_TYPE)
+
+set(EP_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_${UPPERCASE_BUILD_TYPE}}")
+set(EP_C_FLAGS "${CMAKE_C_FLAGS} ${CMAKE_C_FLAGS_${UPPERCASE_BUILD_TYPE}}")
+
+# Set -fPIC on all external projects
+set(EP_CXX_FLAGS "${EP_CXX_FLAGS} -fPIC")
+set(EP_C_FLAGS "${EP_C_FLAGS} -fPIC")
+
+# CC/CXX environment variables are captured on the first invocation of the
+# builder (e.g make or ninja) instead of when CMake is invoked into to build
+# directory. This leads to issues if the variables are exported in a subshell
+# and the invocation of make/ninja is in distinct subshell without the same
+# environment (CC/CXX).
+set(EP_COMMON_TOOLCHAIN -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+        -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER})
+
+if(CMAKE_AR)
+    set(EP_COMMON_TOOLCHAIN ${EP_COMMON_TOOLCHAIN} -DCMAKE_AR=${CMAKE_AR})
+endif()
+
+if(CMAKE_RANLIB)
+    set(EP_COMMON_TOOLCHAIN ${EP_COMMON_TOOLCHAIN} -DCMAKE_RANLIB=${CMAKE_RANLIB})
+endif()
+
+# External projects are still able to override the following declarations.
+# cmake command line will favor the last defined variable when a duplicate is
+# encountered. This requires that `EP_COMMON_CMAKE_ARGS` is always the first
+# argument.
+set(EP_COMMON_CMAKE_ARGS
+        ${EP_COMMON_TOOLCHAIN}
+        -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
+        -DCMAKE_C_FLAGS=${EP_C_FLAGS}
+        -DCMAKE_C_FLAGS_${UPPERCASE_BUILD_TYPE}=${EP_C_FLAGS}
+        -DCMAKE_CXX_FLAGS=${EP_CXX_FLAGS}
+        -DCMAKE_CXX_FLAGS_${UPPERCASE_BUILD_TYPE}=${EP_CXX_FLAGS})
+
+if(NOT MILVUS_VERBOSE_THIRDPARTY_BUILD)
+    set(EP_LOG_OPTIONS LOG_CONFIGURE 1 LOG_BUILD 1 LOG_INSTALL 1 LOG_DOWNLOAD 1)
+else()
+    set(EP_LOG_OPTIONS)
+endif()
+
+# Ensure that a default make is set
+if("${MAKE}" STREQUAL "")
+    find_program(MAKE make)
+endif()
+
+if (NOT DEFINED MAKE_BUILD_ARGS)
+    set(MAKE_BUILD_ARGS "-j8")
+endif()
+message(STATUS "Third Party MAKE_BUILD_ARGS = ${MAKE_BUILD_ARGS}")
+
+# ----------------------------------------------------------------------
+# Find pthreads
+
+set(THREADS_PREFER_PTHREAD_FLAG ON)
+find_package(Threads REQUIRED)
+
+# ----------------------------------------------------------------------
+# Versions and URLs for toolchain builds, which also can be used to configure
+# offline builds
+
+# Read toolchain versions from cpp/thirdparty/versions.txt
+file(STRINGS "${THIRDPARTY_DIR}/versions.txt" TOOLCHAIN_VERSIONS_TXT)
+foreach(_VERSION_ENTRY ${TOOLCHAIN_VERSIONS_TXT})
+    # Exclude comments
+    if(NOT _VERSION_ENTRY MATCHES "^[^#][A-Za-z0-9-_]+_VERSION=")
+        continue()
+    endif()
+
+    string(REGEX MATCH "^[^=]*" _LIB_NAME ${_VERSION_ENTRY})
+    string(REPLACE "${_LIB_NAME}=" "" _LIB_VERSION ${_VERSION_ENTRY})
+
+    # Skip blank or malformed lines
+    if(${_LIB_VERSION} STREQUAL "")
+        continue()
+    endif()
+
+    # For debugging
+    #message(STATUS "${_LIB_NAME}: ${_LIB_VERSION}")
+
+    set(${_LIB_NAME} "${_LIB_VERSION}")
+endforeach()
+
+if(DEFINED ENV{MILVUS_BOOST_URL})
+    set(BOOST_SOURCE_URL "$ENV{MILVUS_BOOST_URL}")
+else()
+    string(REPLACE "." "_" BOOST_VERSION_UNDERSCORES ${BOOST_VERSION})
+    set(BOOST_SOURCE_URL
+            "https://nchc.dl.sourceforge.net/project/boost/boost/${BOOST_VERSION}/boost_${BOOST_VERSION_UNDERSCORES}.tar.gz")
+            #"https://dl.bintray.com/boostorg/release/${BOOST_VERSION}/source/boost_${BOOST_VERSION_UNDERSCORES}.tar.gz")
+endif()
+set(BOOST_MD5 "fea771fe8176828fabf9c09242ee8c26")
+
+if(DEFINED ENV{MILVUS_BZIP2_URL})
+    set(BZIP2_SOURCE_URL "$ENV{MILVUS_BZIP2_URL}")
+else()
+    set(BZIP2_SOURCE_URL "https://sourceware.org/pub/bzip2/bzip2-${BZIP2_VERSION}.tar.gz")
+endif()
+set(BZIP2_MD5 "00b516f4704d4a7cb50a1d97e6e8e15b")
+
+if (DEFINED ENV{MILVUS_GTEST_URL})
+    set(GTEST_SOURCE_URL "$ENV{MILVUS_GTEST_URL}")
+else ()
+    set(GTEST_SOURCE_URL
+            "https://github.com/google/googletest/archive/release-${GTEST_VERSION}.tar.gz")
+endif()
+set(GTEST_MD5 "2e6fbeb6a91310a16efe181886c59596")
+
+if(DEFINED ENV{MILVUS_LZ4_URL})
+    set(LZ4_SOURCE_URL "$ENV{MILVUS_LZ4_URL}")
+else()
+    set(LZ4_SOURCE_URL "https://github.com/lz4/lz4/archive/${LZ4_VERSION}.tar.gz")
+endif()
+set(LZ4_MD5 "a80f28f2a2e5fe59ebfe8407f793da22")
+
+if(DEFINED ENV{MILVUS_MYSQLPP_URL})
+    set(MYSQLPP_SOURCE_URL "$ENV{MILVUS_MYSQLPP_URL}")
+else()
+    set(MYSQLPP_SOURCE_URL "https://tangentsoft.com/mysqlpp/releases/mysql++-${MYSQLPP_VERSION}.tar.gz")
+endif()
+set(MYSQLPP_MD5 "cda38b5ecc0117de91f7c42292dd1e79")
+
+if (DEFINED ENV{MILVUS_PROMETHEUS_URL})
+    set(PROMETHEUS_SOURCE_URL "$ENV{PROMETHEUS_OPENBLAS_URL}")
+else ()
+    set(PROMETHEUS_SOURCE_URL
+            https://github.com/jupp0r/prometheus-cpp.git)
+endif()
+
+if(DEFINED ENV{MILVUS_SNAPPY_URL})
+    set(SNAPPY_SOURCE_URL "$ENV{MILVUS_SNAPPY_URL}")
+else()
+    set(SNAPPY_SOURCE_URL
+            "https://github.com/google/snappy/archive/${SNAPPY_VERSION}.tar.gz")
+endif()
+set(SNAPPY_MD5 "ee9086291c9ae8deb4dac5e0b85bf54a")
+
+if(DEFINED ENV{MILVUS_SQLITE_URL})
+    set(SQLITE_SOURCE_URL "$ENV{MILVUS_SQLITE_URL}")
+else()
+    set(SQLITE_SOURCE_URL
+            "https://www.sqlite.org/2019/sqlite-autoconf-${SQLITE_VERSION}.tar.gz")
+endif()
+set(SQLITE_MD5 "3c68eb400f8354605736cd55400e1572")
+
+if(DEFINED ENV{MILVUS_SQLITE_ORM_URL})
+    set(SQLITE_ORM_SOURCE_URL "$ENV{MILVUS_SQLITE_ORM_URL}")
+else()
+    set(SQLITE_ORM_SOURCE_URL
+#            "http://192.168.1.105:6060/Test/sqlite_orm/-/archive/master/sqlite_orm-master.zip")
+            "https://github.com/fnc12/sqlite_orm/archive/${SQLITE_ORM_VERSION}.zip")
+endif()
+set(SQLITE_ORM_MD5 "ba9a405a8a1421c093aa8ce988ff8598")
+
+if(DEFINED ENV{MILVUS_YAMLCPP_URL})
+    set(YAMLCPP_SOURCE_URL "$ENV{MILVUS_YAMLCPP_URL}")
+else()
+    set(YAMLCPP_SOURCE_URL "https://github.com/jbeder/yaml-cpp/archive/yaml-cpp-${YAMLCPP_VERSION}.tar.gz")
+endif()
+set(YAMLCPP_MD5 "5b943e9af0060d0811148b037449ef82")
+
+if(DEFINED ENV{MILVUS_ZLIB_URL})
+    set(ZLIB_SOURCE_URL "$ENV{MILVUS_ZLIB_URL}")
+else()
+    set(ZLIB_SOURCE_URL "https://github.com/madler/zlib/archive/${ZLIB_VERSION}.tar.gz")
+endif()
+set(ZLIB_MD5 "0095d2d2d1f3442ce1318336637b695f")
+
+if(DEFINED ENV{MILVUS_ZSTD_URL})
+    set(ZSTD_SOURCE_URL "$ENV{MILVUS_ZSTD_URL}")
+else()
+    set(ZSTD_SOURCE_URL "https://github.com/facebook/zstd/archive/${ZSTD_VERSION}.tar.gz")
+endif()
+set(ZSTD_MD5 "340c837db48354f8d5eafe74c6077120")
+
+if(DEFINED ENV{MILVUS_LIBUNWIND_URL})
+    set(LIBUNWIND_SOURCE_URL "$ENV{MILVUS_LIBUNWIND_URL}")
+else()
+    set(LIBUNWIND_SOURCE_URL
+            "https://github.com/libunwind/libunwind/releases/download/v${LIBUNWIND_VERSION}/libunwind-${LIBUNWIND_VERSION}.tar.gz")
+endif()
+set(LIBUNWIND_MD5 "a04f69d66d8e16f8bf3ab72a69112cd6")
+
+if(DEFINED ENV{MILVUS_GPERFTOOLS_URL})
+    set(GPERFTOOLS_SOURCE_URL "$ENV{MILVUS_GPERFTOOLS_URL}")
+else()
+    set(GPERFTOOLS_SOURCE_URL
+            "https://github.com/gperftools/gperftools/releases/download/gperftools-${GPERFTOOLS_VERSION}/gperftools-${GPERFTOOLS_VERSION}.tar.gz")
+endif()
+set(GPERFTOOLS_MD5 "c6a852a817e9160c79bdb2d3101b4601")
+
+if(DEFINED ENV{MILVUS_GRPC_URL})
+    set(GRPC_SOURCE_URL "$ENV{MILVUS_GRPC_URL}")
+else()
+    set(GRPC_SOURCE_URL
+            "https://github.com/youny626/grpc-milvus/archive/${GRPC_VERSION}.zip")
+endif()
+set(GRPC_MD5 "0362ba219f59432c530070b5f5c3df73")
+
+
+# ----------------------------------------------------------------------
+# Add Boost dependencies (code adapted from Apache Kudu (incubating))
+
+set(Boost_USE_MULTITHREADED ON)
+set(Boost_ADDITIONAL_VERSIONS
+        "1.70.0"
+        "1.70"
+        "1.69.0"
+        "1.69"
+        "1.68.0"
+        "1.68"
+        "1.67.0"
+        "1.67"
+        "1.66.0"
+        "1.66"
+        "1.65.0"
+        "1.65"
+        "1.64.0"
+        "1.64"
+        "1.63.0"
+        "1.63"
+        "1.62.0"
+        "1.61"
+        "1.61.0"
+        "1.62"
+        "1.60.0"
+        "1.60")
+
+if(MILVUS_BOOST_VENDORED)
+    set(BOOST_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/boost_ep-prefix/src/boost_ep")
+    set(BOOST_LIB_DIR "${BOOST_PREFIX}/stage/lib")
+    set(BOOST_BUILD_LINK "static")
+    set(BOOST_STATIC_SYSTEM_LIBRARY
+            "${BOOST_LIB_DIR}/${CMAKE_STATIC_LIBRARY_PREFIX}boost_system${CMAKE_STATIC_LIBRARY_SUFFIX}"
+    )
+    set(BOOST_STATIC_FILESYSTEM_LIBRARY
+            "${BOOST_LIB_DIR}/${CMAKE_STATIC_LIBRARY_PREFIX}boost_filesystem${CMAKE_STATIC_LIBRARY_SUFFIX}"
+    )
+    set(BOOST_STATIC_SERIALIZATION_LIBRARY
+            "${BOOST_LIB_DIR}/${CMAKE_STATIC_LIBRARY_PREFIX}boost_serialization${CMAKE_STATIC_LIBRARY_SUFFIX}"
+    )
+    set(BOOST_SYSTEM_LIBRARY boost_system_static)
+    set(BOOST_FILESYSTEM_LIBRARY boost_filesystem_static)
+    set(BOOST_SERIALIZATION_LIBRARY boost_serialization_static)
+
+    if(MILVUS_BOOST_HEADER_ONLY)
+        set(BOOST_BUILD_PRODUCTS)
+        set(BOOST_CONFIGURE_COMMAND "")
+        set(BOOST_BUILD_COMMAND "")
+    else()
+        set(BOOST_BUILD_PRODUCTS ${BOOST_STATIC_SYSTEM_LIBRARY}
+                ${BOOST_STATIC_FILESYSTEM_LIBRARY} ${BOOST_STATIC_SERIALIZATION_LIBRARY})
+        set(BOOST_CONFIGURE_COMMAND "./bootstrap.sh" "--prefix=${BOOST_PREFIX}"
+                "--with-libraries=filesystem,serialization,system")
+        if("${CMAKE_BUILD_TYPE}" STREQUAL "DEBUG")
+            set(BOOST_BUILD_VARIANT "debug")
+        else()
+            set(BOOST_BUILD_VARIANT "release")
+        endif()
+        set(BOOST_BUILD_COMMAND
+                "./b2"
+                "link=${BOOST_BUILD_LINK}"
+                "variant=${BOOST_BUILD_VARIANT}"
+                "cxxflags=-fPIC")
+
+        add_thirdparty_lib(boost_system STATIC_LIB "${BOOST_STATIC_SYSTEM_LIBRARY}")
+
+        add_thirdparty_lib(boost_filesystem STATIC_LIB "${BOOST_STATIC_FILESYSTEM_LIBRARY}")
+
+        add_thirdparty_lib(boost_serialization STATIC_LIB "${BOOST_STATIC_SERIALIZATION_LIBRARY}")
+
+        set(MILVUS_BOOST_LIBS ${BOOST_SYSTEM_LIBRARY} ${BOOST_FILESYSTEM_LIBRARY} ${BOOST_STATIC_SERIALIZATION_LIBRARY})
+    endif()
+    externalproject_add(boost_ep
+            URL
+            ${BOOST_SOURCE_URL}
+            BUILD_BYPRODUCTS
+            ${BOOST_BUILD_PRODUCTS}
+            BUILD_IN_SOURCE
+            1
+            CONFIGURE_COMMAND
+            ${BOOST_CONFIGURE_COMMAND}
+            BUILD_COMMAND
+            ${BOOST_BUILD_COMMAND}
+            INSTALL_COMMAND
+            ""
+            ${EP_LOG_OPTIONS})
+
+
+    set(Boost_INCLUDE_DIR "${BOOST_PREFIX}")
+    set(Boost_INCLUDE_DIRS "${Boost_INCLUDE_DIR}")
+    add_dependencies(boost_system_static boost_ep)
+    add_dependencies(boost_filesystem_static boost_ep)
+    add_dependencies(boost_serialization_static boost_ep)
+
+endif()
+
+include_directories(SYSTEM ${Boost_INCLUDE_DIR})
+link_directories(SYSTEM ${BOOST_LIB_DIR})
+
+# ----------------------------------------------------------------------
+# bzip2
+
+macro(build_bzip2)
+    message(STATUS "Building BZip2-${BZIP2_VERSION} from source")
+    set(BZIP2_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/bzip2_ep-prefix/src/bzip2_ep")
+    set(BZIP2_INCLUDE_DIR "${BZIP2_PREFIX}/include")
+    set(BZIP2_STATIC_LIB
+            "${BZIP2_PREFIX}/lib/${CMAKE_STATIC_LIBRARY_PREFIX}bz2${CMAKE_STATIC_LIBRARY_SUFFIX}")
+
+    if(USE_JFROG_CACHE STREQUAL "ON")
+        set(BZIP2_CACHE_PACKAGE_NAME "bzip2_${BZIP2_MD5}.tar.gz")
+        set(BZIP2_CACHE_URL "${JFROG_ARTFACTORY_CACHE_URL}/${BZIP2_CACHE_PACKAGE_NAME}")
+        set(BZIP2_CACHE_PACKAGE_PATH "${THIRDPARTY_PACKAGE_CACHE}/${BZIP2_CACHE_PACKAGE_NAME}")
+
+        execute_process(COMMAND wget -q --method HEAD ${BZIP2_CACHE_URL} RESULT_VARIABLE return_code)
+        message(STATUS "Check the remote cache file ${BZIP2_CACHE_URL}. return code = ${return_code}")
+        if (NOT return_code EQUAL 0)
+            externalproject_add(bzip2_ep
+                                ${EP_LOG_OPTIONS}
+                                CONFIGURE_COMMAND
+                                ""
+                                BUILD_IN_SOURCE
+                                1
+                                BUILD_COMMAND
+                                ${MAKE}
+                                ${MAKE_BUILD_ARGS}
+                                CFLAGS=${EP_C_FLAGS}
+                                INSTALL_COMMAND
+                                ${MAKE}
+                                install
+                                PREFIX=${BZIP2_PREFIX}
+                                CFLAGS=${EP_C_FLAGS}
+                                INSTALL_DIR
+                                ${BZIP2_PREFIX}
+                                URL
+                                ${BZIP2_SOURCE_URL}
+                                BUILD_BYPRODUCTS
+                                "${BZIP2_STATIC_LIB}")
+
+            ExternalProject_Create_Cache(bzip2_ep ${BZIP2_CACHE_PACKAGE_PATH} "${CMAKE_CURRENT_BINARY_DIR}/bzip2_ep-prefix" ${JFROG_USER_NAME} ${JFROG_PASSWORD} ${BZIP2_CACHE_URL})
+        else()
+            file(DOWNLOAD ${BZIP2_CACHE_URL} ${BZIP2_CACHE_PACKAGE_PATH} STATUS status)
+            list(GET status 0 status_code)
+            message(STATUS "DOWNLOADING FROM ${BZIP2_CACHE_URL} TO ${BZIP2_CACHE_PACKAGE_PATH}. STATUS = ${status_code}")
+            if (status_code EQUAL 0)
+                ExternalProject_Use_Cache(bzip2_ep ${BZIP2_CACHE_PACKAGE_PATH} ${CMAKE_CURRENT_BINARY_DIR})
+            endif()
+        endif()
+    else()
+        externalproject_add(bzip2_ep
+                                ${EP_LOG_OPTIONS}
+                                CONFIGURE_COMMAND
+                                ""
+                                BUILD_IN_SOURCE
+                                1
+                                BUILD_COMMAND
+                                ${MAKE}
+                                ${MAKE_BUILD_ARGS}
+                                CFLAGS=${EP_C_FLAGS}
+                                INSTALL_COMMAND
+                                ${MAKE}
+                                install
+                                PREFIX=${BZIP2_PREFIX}
+                                CFLAGS=${EP_C_FLAGS}
+                                INSTALL_DIR
+                                ${BZIP2_PREFIX}
+                                URL
+                                ${BZIP2_SOURCE_URL}
+                                BUILD_BYPRODUCTS
+                                "${BZIP2_STATIC_LIB}")
+    endif()
+
+    file(MAKE_DIRECTORY "${BZIP2_INCLUDE_DIR}")
+    add_library(bzip2 STATIC IMPORTED)
+    set_target_properties(
+            bzip2
+            PROPERTIES IMPORTED_LOCATION "${BZIP2_STATIC_LIB}"
+            INTERFACE_INCLUDE_DIRECTORIES "${BZIP2_INCLUDE_DIR}")
+
+    add_dependencies(bzip2 bzip2_ep)
+endmacro()
+
+if(MILVUS_WITH_BZ2)
+    resolve_dependency(BZip2)
+
+    if(NOT TARGET bzip2)
+        add_library(bzip2 UNKNOWN IMPORTED)
+        set_target_properties(bzip2
+                PROPERTIES IMPORTED_LOCATION "${BZIP2_LIBRARIES}"
+                INTERFACE_INCLUDE_DIRECTORIES "${BZIP2_INCLUDE_DIR}")
+    endif()
+    link_directories(SYSTEM ${BZIP2_PREFIX}/lib/)
+    include_directories(SYSTEM "${BZIP2_INCLUDE_DIR}")
+endif()
+
+# ----------------------------------------------------------------------
+# Google gtest
+
+macro(build_gtest)
+    message(STATUS "Building gtest-${GTEST_VERSION} from source")
+    set(GTEST_VENDORED TRUE)
+    set(GTEST_CMAKE_CXX_FLAGS "${EP_CXX_FLAGS}")
+
+    if(APPLE)
+        set(GTEST_CMAKE_CXX_FLAGS
+                ${GTEST_CMAKE_CXX_FLAGS}
+                -DGTEST_USE_OWN_TR1_TUPLE=1
+                -Wno-unused-value
+                -Wno-ignored-attributes)
+    endif()
+
+    set(GTEST_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/googletest_ep-prefix/src/googletest_ep")
+    set(GTEST_INCLUDE_DIR "${GTEST_PREFIX}/include")
+    set(GTEST_STATIC_LIB
+            "${GTEST_PREFIX}/lib/${CMAKE_STATIC_LIBRARY_PREFIX}gtest${CMAKE_STATIC_LIBRARY_SUFFIX}")
+    set(GTEST_MAIN_STATIC_LIB
+            "${GTEST_PREFIX}/lib/${CMAKE_STATIC_LIBRARY_PREFIX}gtest_main${CMAKE_STATIC_LIBRARY_SUFFIX}")
+
+    set(GTEST_CMAKE_ARGS
+            ${EP_COMMON_CMAKE_ARGS}
+            "-DCMAKE_INSTALL_PREFIX=${GTEST_PREFIX}"
+            "-DCMAKE_INSTALL_LIBDIR=lib"
+            -DCMAKE_CXX_FLAGS=${GTEST_CMAKE_CXX_FLAGS}
+            -DCMAKE_BUILD_TYPE=Release)
+
+    set(GMOCK_INCLUDE_DIR "${GTEST_PREFIX}/include")
+    set(GMOCK_STATIC_LIB
+            "${GTEST_PREFIX}/lib/${CMAKE_STATIC_LIBRARY_PREFIX}gmock${CMAKE_STATIC_LIBRARY_SUFFIX}"
+    )
+
+    if(USE_JFROG_CACHE STREQUAL "ON")
+        set(GTEST_CACHE_PACKAGE_NAME "googletest_${GTEST_MD5}.tar.gz")
+        set(GTEST_CACHE_URL "${JFROG_ARTFACTORY_CACHE_URL}/${GTEST_CACHE_PACKAGE_NAME}")
+        set(GTEST_CACHE_PACKAGE_PATH "${THIRDPARTY_PACKAGE_CACHE}/${GTEST_CACHE_PACKAGE_NAME}")
+
+        file(DOWNLOAD ${GTEST_CACHE_URL} ${GTEST_CACHE_PACKAGE_PATH} STATUS status)
+        list(GET status 0 status_code)
+        message(STATUS "DOWNLOADING FROM ${GTEST_CACHE_URL} TO ${GTEST_CACHE_PACKAGE_PATH}. STATUS = ${status_code}")
+        if (NOT status_code EQUAL 0)
+            ExternalProject_Add(googletest_ep
+                    URL
+                    ${GTEST_SOURCE_URL}
+                    BUILD_COMMAND
+                    ${MAKE}
+                    ${MAKE_BUILD_ARGS}
+                    BUILD_BYPRODUCTS
+                    ${GTEST_STATIC_LIB}
+                    ${GTEST_MAIN_STATIC_LIB}
+                    ${GMOCK_STATIC_LIB}
+                    CMAKE_ARGS
+                    ${GTEST_CMAKE_ARGS}
+                    ${EP_LOG_OPTIONS})
+
+            ExternalProject_Create_Cache(googletest_ep ${GTEST_CACHE_PACKAGE_PATH} "${CMAKE_CURRENT_BINARY_DIR}/googletest_ep-prefix" ${JFROG_USER_NAME} ${JFROG_PASSWORD} ${GTEST_CACHE_URL})
+        else()
+            ExternalProject_Use_Cache(googletest_ep ${GTEST_CACHE_PACKAGE_PATH} ${CMAKE_CURRENT_BINARY_DIR})
+        endif()
+    else()
+        ExternalProject_Add(googletest_ep
+                URL
+                ${GTEST_SOURCE_URL}
+                BUILD_COMMAND
+                ${MAKE}
+                ${MAKE_BUILD_ARGS}
+                BUILD_BYPRODUCTS
+                ${GTEST_STATIC_LIB}
+                ${GTEST_MAIN_STATIC_LIB}
+                ${GMOCK_STATIC_LIB}
+                CMAKE_ARGS
+                ${GTEST_CMAKE_ARGS}
+                ${EP_LOG_OPTIONS})
+    endif()
+
+    # The include directory must exist before it is referenced by a target.
+    file(MAKE_DIRECTORY "${GTEST_INCLUDE_DIR}")
+
+    add_library(gtest STATIC IMPORTED)
+    set_target_properties(gtest
+                            PROPERTIES IMPORTED_LOCATION "${GTEST_STATIC_LIB}"
+                            INTERFACE_INCLUDE_DIRECTORIES "${GTEST_INCLUDE_DIR}")
+
+    add_library(gtest_main STATIC IMPORTED)
+    set_target_properties(gtest_main
+                            PROPERTIES IMPORTED_LOCATION "${GTEST_MAIN_STATIC_LIB}"
+                            INTERFACE_INCLUDE_DIRECTORIES "${GTEST_INCLUDE_DIR}")
+
+    add_library(gmock STATIC IMPORTED)
+    set_target_properties(gmock
+            PROPERTIES IMPORTED_LOCATION "${GMOCK_STATIC_LIB}"
+            INTERFACE_INCLUDE_DIRECTORIES "${GTEST_INCLUDE_DIR}")
+
+    add_dependencies(gtest googletest_ep)
+    add_dependencies(gtest_main googletest_ep)
+    add_dependencies(gmock googletest_ep)
+
+endmacro()
+
+if (MILVUS_BUILD_TESTS)
+    resolve_dependency(GTest)
+
+    if(NOT GTEST_VENDORED)
+    endif()
+
+    get_target_property(GTEST_INCLUDE_DIR gtest INTERFACE_INCLUDE_DIRECTORIES)
+    link_directories(SYSTEM "${GTEST_PREFIX}/lib")
+    include_directories(SYSTEM ${GTEST_INCLUDE_DIR})
+endif()
+
+# ----------------------------------------------------------------------
+# lz4
+
+macro(build_lz4)
+    message(STATUS "Building lz4-${LZ4_VERSION} from source")
+    set(LZ4_BUILD_DIR "${CMAKE_CURRENT_BINARY_DIR}/lz4_ep-prefix/src/lz4_ep")
+    set(LZ4_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/lz4_ep-prefix/")
+
+    set(LZ4_STATIC_LIB "${LZ4_BUILD_DIR}/lib/liblz4.a")
+    set(LZ4_BUILD_COMMAND BUILD_COMMAND ${MAKE} ${MAKE_BUILD_ARGS} CFLAGS=${EP_C_FLAGS})
+
+    # We need to copy the header in lib to directory outside of the build
+    if(USE_JFROG_CACHE STREQUAL "ON")
+        set(LZ4_CACHE_PACKAGE_NAME "lz4_${LZ4_MD5}.tar.gz")
+        set(LZ4_CACHE_URL "${JFROG_ARTFACTORY_CACHE_URL}/${LZ4_CACHE_PACKAGE_NAME}")
+        set(LZ4_CACHE_PACKAGE_PATH "${THIRDPARTY_PACKAGE_CACHE}/${LZ4_CACHE_PACKAGE_NAME}")
+
+        execute_process(COMMAND wget -q --method HEAD ${LZ4_CACHE_URL} RESULT_VARIABLE return_code)
+        message(STATUS "Check the remote file ${LZ4_CACHE_URL}. return code = ${return_code}")
+        if (NOT return_code EQUAL 0)
+            externalproject_add(lz4_ep
+                    URL
+                    ${LZ4_SOURCE_URL}
+                    ${EP_LOG_OPTIONS}
+                    UPDATE_COMMAND
+                    ${CMAKE_COMMAND}
+                    -E
+                    copy_directory
+                    "${LZ4_BUILD_DIR}/lib"
+                    "${LZ4_PREFIX}/include"
+                    ${LZ4_PATCH_COMMAND}
+                    CONFIGURE_COMMAND
+                    ""
+                    INSTALL_COMMAND
+                    ""
+                    BINARY_DIR
+                    ${LZ4_BUILD_DIR}
+                    BUILD_BYPRODUCTS
+                    ${LZ4_STATIC_LIB}
+                    ${LZ4_BUILD_COMMAND})
+
+            ExternalProject_Create_Cache(lz4_ep ${LZ4_CACHE_PACKAGE_PATH} "${CMAKE_CURRENT_BINARY_DIR}/lz4_ep-prefix" ${JFROG_USER_NAME} ${JFROG_PASSWORD} ${LZ4_CACHE_URL})
+        else()
+            file(DOWNLOAD ${LZ4_CACHE_URL} ${LZ4_CACHE_PACKAGE_PATH} STATUS status)
+            list(GET status 0 status_code)
+            message(STATUS "DOWNLOADING FROM ${LZ4_CACHE_URL} TO ${LZ4_CACHE_PACKAGE_PATH}. STATUS = ${status_code}")
+            if (status_code EQUAL 0)
+                ExternalProject_Use_Cache(lz4_ep ${LZ4_CACHE_PACKAGE_PATH} ${CMAKE_CURRENT_BINARY_DIR})
+            endif()
+        endif()
+    else()
+        externalproject_add(lz4_ep
+                URL
+                ${LZ4_SOURCE_URL}
+                ${EP_LOG_OPTIONS}
+                UPDATE_COMMAND
+                ${CMAKE_COMMAND}
+                -E
+                copy_directory
+                "${LZ4_BUILD_DIR}/lib"
+                "${LZ4_PREFIX}/include"
+                ${LZ4_PATCH_COMMAND}
+                CONFIGURE_COMMAND
+                ""
+                INSTALL_COMMAND
+                ""
+                BINARY_DIR
+                ${LZ4_BUILD_DIR}
+                BUILD_BYPRODUCTS
+                ${LZ4_STATIC_LIB}
+                ${LZ4_BUILD_COMMAND})
+    endif()
+
+    file(MAKE_DIRECTORY "${LZ4_PREFIX}/include")
+    add_library(lz4 STATIC IMPORTED)
+    set_target_properties(lz4
+            PROPERTIES IMPORTED_LOCATION "${LZ4_STATIC_LIB}"
+            INTERFACE_INCLUDE_DIRECTORIES "${LZ4_PREFIX}/include")
+    add_dependencies(lz4 lz4_ep)
+endmacro()
+
+if(MILVUS_WITH_LZ4)
+    resolve_dependency(Lz4)
+
+    get_target_property(LZ4_INCLUDE_DIR lz4 INTERFACE_INCLUDE_DIRECTORIES)
+    link_directories(SYSTEM ${LZ4_BUILD_DIR}/lib/)
+    include_directories(SYSTEM ${LZ4_INCLUDE_DIR})
+endif()
+
+# ----------------------------------------------------------------------
+# MySQL++
+
+macro(build_mysqlpp)
+    message(STATUS "Building MySQL++-${MYSQLPP_VERSION} from source")
+    set(MYSQLPP_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/mysqlpp_ep-prefix/src/mysqlpp_ep")
+    set(MYSQLPP_INCLUDE_DIR "${MYSQLPP_PREFIX}/include")
+    set(MYSQLPP_SHARED_LIB
+            "${MYSQLPP_PREFIX}/lib/${CMAKE_SHARED_LIBRARY_PREFIX}mysqlpp${CMAKE_SHARED_LIBRARY_SUFFIX}")
+
+    set(MYSQLPP_CONFIGURE_ARGS
+            "--prefix=${MYSQLPP_PREFIX}"
+            "--enable-thread-check"
+            "CFLAGS=${EP_C_FLAGS}"
+            "CXXFLAGS=${EP_CXX_FLAGS}"
+            "LDFLAGS=-pthread")
+
+    if(USE_JFROG_CACHE STREQUAL "ON")
+        set(MYSQLPP_CACHE_PACKAGE_NAME "mysqlpp_${MYSQLPP_MD5}.tar.gz")
+        set(MYSQLPP_CACHE_URL "${JFROG_ARTFACTORY_CACHE_URL}/${MYSQLPP_CACHE_PACKAGE_NAME}")
+        set(MYSQLPP_CACHE_PACKAGE_PATH "${THIRDPARTY_PACKAGE_CACHE}/${MYSQLPP_CACHE_PACKAGE_NAME}")
+
+        execute_process(COMMAND wget -q --method HEAD ${MYSQLPP_CACHE_URL} RESULT_VARIABLE return_code)
+        message(STATUS "Check the remote file ${MYSQLPP_CACHE_URL}. return code = ${return_code}")
+        if (NOT return_code EQUAL 0)
+            externalproject_add(mysqlpp_ep
+                    URL
+                    ${MYSQLPP_SOURCE_URL}
+                    ${EP_LOG_OPTIONS}
+                    CONFIGURE_COMMAND
+                    "./configure"
+                    ${MYSQLPP_CONFIGURE_ARGS}
+                    BUILD_COMMAND
+                    ${MAKE} ${MAKE_BUILD_ARGS}
+                    BUILD_IN_SOURCE
+                    1
+                    BUILD_BYPRODUCTS
+                    ${MYSQLPP_SHARED_LIB})
+
+            ExternalProject_Create_Cache(mysqlpp_ep ${MYSQLPP_CACHE_PACKAGE_PATH} "${CMAKE_CURRENT_BINARY_DIR}/mysqlpp_ep-prefix" ${JFROG_USER_NAME} ${JFROG_PASSWORD} ${MYSQLPP_CACHE_URL})
+        else()
+            file(DOWNLOAD ${MYSQLPP_CACHE_URL} ${MYSQLPP_CACHE_PACKAGE_PATH} STATUS status)
+            list(GET status 0 status_code)
+            message(STATUS "DOWNLOADING FROM ${MYSQLPP_CACHE_URL} TO ${MYSQLPP_CACHE_PACKAGE_PATH}. STATUS = ${status_code}")
+            if (status_code EQUAL 0)
+                ExternalProject_Use_Cache(mysqlpp_ep ${MYSQLPP_CACHE_PACKAGE_PATH} ${CMAKE_CURRENT_BINARY_DIR})
+            endif()
+        endif()
+    else()
+        externalproject_add(mysqlpp_ep
+                URL
+                ${MYSQLPP_SOURCE_URL}
+                ${EP_LOG_OPTIONS}
+                CONFIGURE_COMMAND
+                "./configure"
+                ${MYSQLPP_CONFIGURE_ARGS}
+                BUILD_COMMAND
+                ${MAKE} ${MAKE_BUILD_ARGS}
+                BUILD_IN_SOURCE
+                1
+                BUILD_BYPRODUCTS
+                ${MYSQLPP_SHARED_LIB})
+    endif()
+
+    file(MAKE_DIRECTORY "${MYSQLPP_INCLUDE_DIR}")
+    add_library(mysqlpp SHARED IMPORTED)
+    set_target_properties(
+            mysqlpp
+            PROPERTIES
+            IMPORTED_LOCATION "${MYSQLPP_SHARED_LIB}"
+            INTERFACE_INCLUDE_DIRECTORIES "${MYSQLPP_INCLUDE_DIR}")
+
+    add_dependencies(mysqlpp mysqlpp_ep)
+
+endmacro()
+
+if(MILVUS_WITH_MYSQLPP)
+
+    resolve_dependency(MySQLPP)
+    get_target_property(MYSQLPP_INCLUDE_DIR mysqlpp INTERFACE_INCLUDE_DIRECTORIES)
+    include_directories(SYSTEM "${MYSQLPP_INCLUDE_DIR}")
+    link_directories(SYSTEM ${MYSQLPP_PREFIX}/lib)
+endif()
+
+# ----------------------------------------------------------------------
+# Prometheus
+
+macro(build_prometheus)
+    message(STATUS "Building Prometheus-${PROMETHEUS_VERSION} from source")
+    set(PROMETHEUS_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/prometheus_ep-prefix/src/prometheus_ep")
+    set(PROMETHEUS_STATIC_LIB_NAME prometheus-cpp)
+    set(PROMETHEUS_CORE_STATIC_LIB
+            "${PROMETHEUS_PREFIX}/core/${CMAKE_STATIC_LIBRARY_PREFIX}${PROMETHEUS_STATIC_LIB_NAME}-core${CMAKE_STATIC_LIBRARY_SUFFIX}"
+            )
+    set(PROMETHEUS_PUSH_STATIC_LIB
+            "${PROMETHEUS_PREFIX}/push/${CMAKE_STATIC_LIBRARY_PREFIX}${PROMETHEUS_STATIC_LIB_NAME}-push${CMAKE_STATIC_LIBRARY_SUFFIX}"
+            )
+    set(PROMETHEUS_PULL_STATIC_LIB
+            "${PROMETHEUS_PREFIX}/pull/${CMAKE_STATIC_LIBRARY_PREFIX}${PROMETHEUS_STATIC_LIB_NAME}-pull${CMAKE_STATIC_LIBRARY_SUFFIX}"
+            )
+
+    set(PROMETHEUS_CMAKE_ARGS
+            ${EP_COMMON_CMAKE_ARGS}
+            -DCMAKE_INSTALL_LIBDIR=lib
+            -DBUILD_SHARED_LIBS=OFF
+            "-DCMAKE_INSTALL_PREFIX=${PROMETHEUS_PREFIX}"
+            -DCMAKE_BUILD_TYPE=Release)
+
+    if(USE_JFROG_CACHE STREQUAL "ON")
+        execute_process(COMMAND sh -c "git ls-remote --heads --tags ${PROMETHEUS_SOURCE_URL} ${PROMETHEUS_VERSION} | cut -f 1" OUTPUT_VARIABLE PROMETHEUS_LAST_COMMIT_ID)
+        if(${PROMETHEUS_LAST_COMMIT_ID} MATCHES "^[^#][a-z0-9]+")
+            string(MD5 PROMETHEUS_COMBINE_MD5 "${PROMETHEUS_LAST_COMMIT_ID}")
+            set(PROMETHEUS_CACHE_PACKAGE_NAME "prometheus_${PROMETHEUS_COMBINE_MD5}.tar.gz")
+            set(PROMETHEUS_CACHE_URL "${JFROG_ARTFACTORY_CACHE_URL}/${PROMETHEUS_CACHE_PACKAGE_NAME}")
+            set(PROMETHEUS_CACHE_PACKAGE_PATH "${THIRDPARTY_PACKAGE_CACHE}/${PROMETHEUS_CACHE_PACKAGE_NAME}")
+
+            execute_process(COMMAND wget -q --method HEAD ${PROMETHEUS_CACHE_URL} RESULT_VARIABLE return_code)
+            message(STATUS "Check the remote file ${PROMETHEUS_CACHE_URL}. return code = ${return_code}")
+            if (NOT return_code EQUAL 0)
+                externalproject_add(prometheus_ep
+                        GIT_REPOSITORY
+                        ${PROMETHEUS_SOURCE_URL}
+                        GIT_TAG
+                        ${PROMETHEUS_VERSION}
+                        GIT_SHALLOW
+                        TRUE
+                        ${EP_LOG_OPTIONS}
+                        CMAKE_ARGS
+                        ${PROMETHEUS_CMAKE_ARGS}
+                        BUILD_COMMAND
+                        ${MAKE}
+                        ${MAKE_BUILD_ARGS}
+                        BUILD_IN_SOURCE
+                        1
+                        INSTALL_COMMAND
+                        ${MAKE}
+                        "DESTDIR=${PROMETHEUS_PREFIX}"
+                        install
+                        BUILD_BYPRODUCTS
+                        "${PROMETHEUS_CORE_STATIC_LIB}"
+                        "${PROMETHEUS_PUSH_STATIC_LIB}"
+                        "${PROMETHEUS_PULL_STATIC_LIB}")
+
+                ExternalProject_Create_Cache(prometheus_ep ${PROMETHEUS_CACHE_PACKAGE_PATH} "${CMAKE_CURRENT_BINARY_DIR}/prometheus_ep-prefix" ${JFROG_USER_NAME} ${JFROG_PASSWORD} ${PROMETHEUS_CACHE_URL})
+            else()
+                file(DOWNLOAD ${PROMETHEUS_CACHE_URL} ${PROMETHEUS_CACHE_PACKAGE_PATH} STATUS status)
+                list(GET status 0 status_code)
+                message(STATUS "DOWNLOADING FROM ${PROMETHEUS_CACHE_URL} TO ${PROMETHEUS_CACHE_PACKAGE_PATH}. STATUS = ${status_code}")
+                if (status_code EQUAL 0)
+                    ExternalProject_Use_Cache(prometheus_ep ${PROMETHEUS_CACHE_PACKAGE_PATH} ${CMAKE_CURRENT_BINARY_DIR})
+                endif()
+            endif()
+        else()
+            message(FATAL_ERROR "The last commit ID of \"${PROMETHEUS_SOURCE_URL}\" repository don't match!")
+        endif()
+    else()
+        externalproject_add(prometheus_ep
+                GIT_REPOSITORY
+                ${PROMETHEUS_SOURCE_URL}
+                GIT_TAG
+                ${PROMETHEUS_VERSION}
+                GIT_SHALLOW
+                TRUE
+                ${EP_LOG_OPTIONS}
+                CMAKE_ARGS
+                ${PROMETHEUS_CMAKE_ARGS}
+                BUILD_COMMAND
+                ${MAKE}
+                ${MAKE_BUILD_ARGS}
+                BUILD_IN_SOURCE
+                1
+                INSTALL_COMMAND
+                ${MAKE}
+                "DESTDIR=${PROMETHEUS_PREFIX}"
+                install
+                BUILD_BYPRODUCTS
+                "${PROMETHEUS_CORE_STATIC_LIB}"
+                "${PROMETHEUS_PUSH_STATIC_LIB}"
+                "${PROMETHEUS_PULL_STATIC_LIB}")
+    endif()
+
+    file(MAKE_DIRECTORY "${PROMETHEUS_PREFIX}/push/include")
+    add_library(prometheus-cpp-push STATIC IMPORTED)
+    set_target_properties(prometheus-cpp-push
+            PROPERTIES IMPORTED_LOCATION "${PROMETHEUS_PUSH_STATIC_LIB}"
+            INTERFACE_INCLUDE_DIRECTORIES "${PROMETHEUS_PREFIX}/push/include")
+    add_dependencies(prometheus-cpp-push prometheus_ep)
+
+    file(MAKE_DIRECTORY "${PROMETHEUS_PREFIX}/pull/include")
+    add_library(prometheus-cpp-pull STATIC IMPORTED)
+    set_target_properties(prometheus-cpp-pull
+            PROPERTIES IMPORTED_LOCATION "${PROMETHEUS_PULL_STATIC_LIB}"
+            INTERFACE_INCLUDE_DIRECTORIES "${PROMETHEUS_PREFIX}/pull/include")
+    add_dependencies(prometheus-cpp-pull prometheus_ep)
+
+    file(MAKE_DIRECTORY "${PROMETHEUS_PREFIX}/core/include")
+    add_library(prometheus-cpp-core STATIC IMPORTED)
+    set_target_properties(prometheus-cpp-core
+            PROPERTIES IMPORTED_LOCATION "${PROMETHEUS_CORE_STATIC_LIB}"
+            INTERFACE_INCLUDE_DIRECTORIES "${PROMETHEUS_PREFIX}/core/include")
+    add_dependencies(prometheus-cpp-core prometheus_ep)
+endmacro()
+
+if(MILVUS_WITH_PROMETHEUS)
+
+    resolve_dependency(Prometheus)
+
+    link_directories(SYSTEM ${PROMETHEUS_PREFIX}/push/)
+    include_directories(SYSTEM ${PROMETHEUS_PREFIX}/push/include)
+
+    link_directories(SYSTEM ${PROMETHEUS_PREFIX}/pull/)
+    include_directories(SYSTEM ${PROMETHEUS_PREFIX}/pull/include)
+
+    link_directories(SYSTEM ${PROMETHEUS_PREFIX}/core/)
+    include_directories(SYSTEM ${PROMETHEUS_PREFIX}/core/include)
+
+endif()
+
+# ----------------------------------------------------------------------
+# Snappy
+
+macro(build_snappy)
+    message(STATUS "Building snappy-${SNAPPY_VERSION} from source")
+    set(SNAPPY_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/snappy_ep-prefix/src/snappy_ep")
+    set(SNAPPY_INCLUDE_DIRS "${SNAPPY_PREFIX}/include")
+    set(SNAPPY_STATIC_LIB_NAME snappy)
+    set(SNAPPY_STATIC_LIB
+            "${SNAPPY_PREFIX}/lib/${CMAKE_STATIC_LIBRARY_PREFIX}${SNAPPY_STATIC_LIB_NAME}${CMAKE_STATIC_LIBRARY_SUFFIX}"
+    )
+
+    set(SNAPPY_CMAKE_ARGS
+            ${EP_COMMON_CMAKE_ARGS}
+            -DCMAKE_INSTALL_LIBDIR=lib
+            -DSNAPPY_BUILD_TESTS=OFF
+            "-DCMAKE_INSTALL_PREFIX=${SNAPPY_PREFIX}")
+
+    if(USE_JFROG_CACHE STREQUAL "ON")
+        set(SNAPPY_CACHE_PACKAGE_NAME "snappy_${SNAPPY_MD5}.tar.gz")
+        set(SNAPPY_CACHE_URL "${JFROG_ARTFACTORY_CACHE_URL}/${SNAPPY_CACHE_PACKAGE_NAME}")
+        set(SNAPPY_CACHE_PACKAGE_PATH "${THIRDPARTY_PACKAGE_CACHE}/${SNAPPY_CACHE_PACKAGE_NAME}")
+
+        execute_process(COMMAND wget -q --method HEAD ${SNAPPY_CACHE_URL} RESULT_VARIABLE return_code)
+        message(STATUS "Check the remote file ${SNAPPY_CACHE_URL}. return code = ${return_code}")
+        if (NOT return_code EQUAL 0)
+            externalproject_add(snappy_ep
+                    ${EP_LOG_OPTIONS}
+                    BUILD_COMMAND
+                    ${MAKE}
+                    ${MAKE_BUILD_ARGS}
+                    BUILD_IN_SOURCE
+                    1
+                    INSTALL_DIR
+                    ${SNAPPY_PREFIX}
+                    URL
+                    ${SNAPPY_SOURCE_URL}
+                    CMAKE_ARGS
+                    ${SNAPPY_CMAKE_ARGS}
+                    BUILD_BYPRODUCTS
+                    "${SNAPPY_STATIC_LIB}")
+
+            ExternalProject_Create_Cache(snappy_ep ${SNAPPY_CACHE_PACKAGE_PATH} "${CMAKE_CURRENT_BINARY_DIR}/snappy_ep-prefix" ${JFROG_USER_NAME} ${JFROG_PASSWORD} ${SNAPPY_CACHE_URL})
+        else()
+            file(DOWNLOAD ${SNAPPY_CACHE_URL} ${SNAPPY_CACHE_PACKAGE_PATH} STATUS status)
+            list(GET status 0 status_code)
+            message(STATUS "DOWNLOADING FROM ${SNAPPY_CACHE_URL} TO ${SNAPPY_CACHE_PACKAGE_PATH}. STATUS = ${status_code}")
+            if (status_code EQUAL 0)
+                ExternalProject_Use_Cache(snappy_ep ${SNAPPY_CACHE_PACKAGE_PATH} ${CMAKE_CURRENT_BINARY_DIR})
+            endif()
+        endif()
+    else()
+        externalproject_add(snappy_ep
+                ${EP_LOG_OPTIONS}
+                BUILD_COMMAND
+                ${MAKE}
+                ${MAKE_BUILD_ARGS}
+                BUILD_IN_SOURCE
+                1
+                INSTALL_DIR
+                ${SNAPPY_PREFIX}
+                URL
+                ${SNAPPY_SOURCE_URL}
+                CMAKE_ARGS
+                ${SNAPPY_CMAKE_ARGS}
+                BUILD_BYPRODUCTS
+                "${SNAPPY_STATIC_LIB}")
+    endif()
+
+    file(MAKE_DIRECTORY "${SNAPPY_INCLUDE_DIR}")
+    add_library(snappy STATIC IMPORTED)
+    set_target_properties(snappy
+                        PROPERTIES IMPORTED_LOCATION "${SNAPPY_STATIC_LIB}"
+                        INTERFACE_INCLUDE_DIRECTORIES
+                        "${SNAPPY_INCLUDE_DIR}")
+    add_dependencies(snappy snappy_ep)
+endmacro()
+
+if(MILVUS_WITH_SNAPPY)
+
+    resolve_dependency(Snappy)
+
+    get_target_property(SNAPPY_INCLUDE_DIRS snappy INTERFACE_INCLUDE_DIRECTORIES)
+    link_directories(SYSTEM ${SNAPPY_PREFIX}/lib/)
+    include_directories(SYSTEM ${SNAPPY_INCLUDE_DIRS})
+endif()
+
+# ----------------------------------------------------------------------
+# SQLite
+
+macro(build_sqlite)
+    message(STATUS "Building SQLITE-${SQLITE_VERSION} from source")
+    set(SQLITE_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/sqlite_ep-prefix/src/sqlite_ep")
+    set(SQLITE_INCLUDE_DIR "${SQLITE_PREFIX}/include")
+    set(SQLITE_STATIC_LIB
+            "${SQLITE_PREFIX}/lib/${CMAKE_STATIC_LIBRARY_PREFIX}sqlite3${CMAKE_STATIC_LIBRARY_SUFFIX}")
+
+    set(SQLITE_CONFIGURE_ARGS
+            "--prefix=${SQLITE_PREFIX}"
+            "CC=${CMAKE_C_COMPILER}"
+            "CXX=${CMAKE_CXX_COMPILER}"
+            "CFLAGS=${EP_C_FLAGS}"
+            "CXXFLAGS=${EP_CXX_FLAGS}")
+
+    if(USE_JFROG_CACHE STREQUAL "ON")
+        set(SQLITE_CACHE_PACKAGE_NAME "sqlite_${SQLITE_MD5}.tar.gz")
+        set(SQLITE_CACHE_URL "${JFROG_ARTFACTORY_CACHE_URL}/${SQLITE_CACHE_PACKAGE_NAME}")
+        set(SQLITE_CACHE_PACKAGE_PATH "${THIRDPARTY_PACKAGE_CACHE}/${SQLITE_CACHE_PACKAGE_NAME}")
+
+        execute_process(COMMAND wget -q --method HEAD ${SQLITE_CACHE_URL} RESULT_VARIABLE return_code)
+        message(STATUS "Check the remote file ${SQLITE_CACHE_URL}. return code = ${return_code}")
+        if (NOT return_code EQUAL 0)
+            externalproject_add(sqlite_ep
+                    URL
+                    ${SQLITE_SOURCE_URL}
+                    ${EP_LOG_OPTIONS}
+                    CONFIGURE_COMMAND
+                    "./configure"
+                    ${SQLITE_CONFIGURE_ARGS}
+                    BUILD_COMMAND
+                    ${MAKE}
+                    ${MAKE_BUILD_ARGS}
+                    BUILD_IN_SOURCE
+                    1
+                    BUILD_BYPRODUCTS
+                    "${SQLITE_STATIC_LIB}")
+
+            ExternalProject_Create_Cache(sqlite_ep ${SQLITE_CACHE_PACKAGE_PATH} "${CMAKE_CURRENT_BINARY_DIR}/sqlite_ep-prefix" ${JFROG_USER_NAME} ${JFROG_PASSWORD} ${SQLITE_CACHE_URL})
+        else()
+            file(DOWNLOAD ${SQLITE_CACHE_URL} ${SQLITE_CACHE_PACKAGE_PATH} STATUS status)
+            list(GET status 0 status_code)
+            message(STATUS "DOWNLOADING FROM ${SQLITE_CACHE_URL} TO ${SQLITE_CACHE_PACKAGE_PATH}. STATUS = ${status_code}")
+            if (status_code EQUAL 0)
+                ExternalProject_Use_Cache(sqlite_ep ${SQLITE_CACHE_PACKAGE_PATH} ${CMAKE_CURRENT_BINARY_DIR})
+            endif()
+        endif()
+    else()
+        externalproject_add(sqlite_ep
+                URL
+                ${SQLITE_SOURCE_URL}
+                ${EP_LOG_OPTIONS}
+                CONFIGURE_COMMAND
+                "./configure"
+                ${SQLITE_CONFIGURE_ARGS}
+                BUILD_COMMAND
+                ${MAKE}
+                ${MAKE_BUILD_ARGS}
+                BUILD_IN_SOURCE
+                1
+                BUILD_BYPRODUCTS
+                "${SQLITE_STATIC_LIB}")
+    endif()
+
+    file(MAKE_DIRECTORY "${SQLITE_INCLUDE_DIR}")
+    add_library(sqlite STATIC IMPORTED)
+    set_target_properties(
+            sqlite
+            PROPERTIES IMPORTED_LOCATION "${SQLITE_STATIC_LIB}"
+            INTERFACE_INCLUDE_DIRECTORIES "${SQLITE_INCLUDE_DIR}")
+
+    add_dependencies(sqlite sqlite_ep)
+endmacro()
+
+if(MILVUS_WITH_SQLITE)
+    resolve_dependency(SQLite)
+    include_directories(SYSTEM "${SQLITE_INCLUDE_DIR}")
+    link_directories(SYSTEM ${SQLITE_PREFIX}/lib/)
+endif()
+
+# ----------------------------------------------------------------------
+# SQLite_ORM
+
+macro(build_sqlite_orm)
+    message(STATUS "Building SQLITE_ORM-${SQLITE_ORM_VERSION} from source")
+
+    set(SQLITE_ORM_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/sqlite_orm_ep-prefix")
+    set(SQLITE_ORM_TAR_NAME "${SQLITE_ORM_PREFIX}/sqlite_orm-${SQLITE_ORM_VERSION}.tar.gz")
+    set(SQLITE_ORM_INCLUDE_DIR "${SQLITE_ORM_PREFIX}/sqlite_orm-${SQLITE_ORM_VERSION}/include/sqlite_orm")
+    if (NOT EXISTS ${SQLITE_ORM_INCLUDE_DIR})
+        file(MAKE_DIRECTORY ${SQLITE_ORM_PREFIX})
+        file(DOWNLOAD ${SQLITE_ORM_SOURCE_URL}
+                ${SQLITE_ORM_TAR_NAME})
+        execute_process(COMMAND ${CMAKE_COMMAND} -E tar -xf ${SQLITE_ORM_TAR_NAME}
+                        WORKING_DIRECTORY ${SQLITE_ORM_PREFIX})
+
+    endif ()
+
+endmacro()
+
+if(MILVUS_WITH_SQLITE_ORM)
+    resolve_dependency(SQLite_ORM)
+    include_directories(SYSTEM "${SQLITE_ORM_INCLUDE_DIR}")
+endif()
+
+# ----------------------------------------------------------------------
+# yaml-cpp
+
+macro(build_yamlcpp)
+    message(STATUS "Building yaml-cpp-${YAMLCPP_VERSION} from source")
+    set(YAMLCPP_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/yaml-cpp_ep-prefix/src/yaml-cpp_ep")
+    set(YAMLCPP_STATIC_LIB "${YAMLCPP_PREFIX}/lib/${CMAKE_STATIC_LIBRARY_PREFIX}yaml-cpp${CMAKE_STATIC_LIBRARY_SUFFIX}")
+    set(YAMLCPP_INCLUDE_DIR "${YAMLCPP_PREFIX}/include")
+    set(YAMLCPP_CMAKE_ARGS
+            ${EP_COMMON_CMAKE_ARGS}
+            "-DCMAKE_INSTALL_PREFIX=${YAMLCPP_PREFIX}"
+            -DCMAKE_INSTALL_LIBDIR=lib
+            -DYAML_CPP_BUILD_TESTS=OFF
+            -DYAML_CPP_BUILD_TOOLS=OFF)
+
+    if(USE_JFROG_CACHE STREQUAL "ON")
+        set(YAMLCPP_CACHE_PACKAGE_NAME "yaml-cpp_${YAMLCPP_MD5}.tar.gz")
+        set(YAMLCPP_CACHE_URL "${JFROG_ARTFACTORY_CACHE_URL}/${YAMLCPP_CACHE_PACKAGE_NAME}")
+        set(YAMLCPP_CACHE_PACKAGE_PATH "${THIRDPARTY_PACKAGE_CACHE}/${YAMLCPP_CACHE_PACKAGE_NAME}")
+
+        execute_process(COMMAND wget -q --method HEAD ${YAMLCPP_CACHE_URL} RESULT_VARIABLE return_code)
+        message(STATUS "Check the remote file ${YAMLCPP_CACHE_URL}. return code = ${return_code}")
+        if (NOT return_code EQUAL 0)
+            externalproject_add(yaml-cpp_ep
+                    URL
+                    ${YAMLCPP_SOURCE_URL}
+                    ${EP_LOG_OPTIONS}
+                    BUILD_COMMAND
+                    ${MAKE}
+                    ${MAKE_BUILD_ARGS}
+                    BUILD_BYPRODUCTS
+                    "${YAMLCPP_STATIC_LIB}"
+                    CMAKE_ARGS
+                    ${YAMLCPP_CMAKE_ARGS})
+
+            ExternalProject_Create_Cache(yaml-cpp_ep ${YAMLCPP_CACHE_PACKAGE_PATH} "${CMAKE_CURRENT_BINARY_DIR}/yaml-cpp_ep-prefix" ${JFROG_USER_NAME} ${JFROG_PASSWORD} ${YAMLCPP_CACHE_URL})
+        else()
+            file(DOWNLOAD ${YAMLCPP_CACHE_URL} ${YAMLCPP_CACHE_PACKAGE_PATH} STATUS status)
+            list(GET status 0 status_code)
+            message(STATUS "DOWNLOADING FROM ${YAMLCPP_CACHE_URL} TO ${YAMLCPP_CACHE_PACKAGE_PATH}. STATUS = ${status_code}")
+            if (status_code EQUAL 0)
+                ExternalProject_Use_Cache(yaml-cpp_ep ${YAMLCPP_CACHE_PACKAGE_PATH} ${CMAKE_CURRENT_BINARY_DIR})
+            endif()
+        endif()
+    else()
+        externalproject_add(yaml-cpp_ep
+                URL
+                ${YAMLCPP_SOURCE_URL}
+                ${EP_LOG_OPTIONS}
+                BUILD_COMMAND
+                ${MAKE}
+                ${MAKE_BUILD_ARGS}
+                BUILD_BYPRODUCTS
+                "${YAMLCPP_STATIC_LIB}"
+                CMAKE_ARGS
+                ${YAMLCPP_CMAKE_ARGS})
+    endif()
+
+    file(MAKE_DIRECTORY "${YAMLCPP_INCLUDE_DIR}")
+    add_library(yaml-cpp STATIC IMPORTED)
+    set_target_properties(yaml-cpp
+            PROPERTIES IMPORTED_LOCATION "${YAMLCPP_STATIC_LIB}"
+            INTERFACE_INCLUDE_DIRECTORIES "${YAMLCPP_INCLUDE_DIR}")
+
+    add_dependencies(yaml-cpp yaml-cpp_ep)
+endmacro()
+
+if(MILVUS_WITH_YAMLCPP)
+    resolve_dependency(yaml-cpp)
+
+    get_target_property(YAMLCPP_INCLUDE_DIR yaml-cpp INTERFACE_INCLUDE_DIRECTORIES)
+    link_directories(SYSTEM ${YAMLCPP_PREFIX}/lib/)
+    include_directories(SYSTEM ${YAMLCPP_INCLUDE_DIR})
+endif()
+
+# ----------------------------------------------------------------------
+# zlib
+
+macro(build_zlib)
+    message(STATUS "Building ZLIB-${ZLIB_VERSION} from source")
+    set(ZLIB_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/zlib_ep-prefix/src/zlib_ep")
+    set(ZLIB_STATIC_LIB_NAME libz.a)
+    set(ZLIB_STATIC_LIB "${ZLIB_PREFIX}/lib/${ZLIB_STATIC_LIB_NAME}")
+    set(ZLIB_INCLUDE_DIR "${ZLIB_PREFIX}/include")
+    set(ZLIB_CMAKE_ARGS ${EP_COMMON_CMAKE_ARGS} "-DCMAKE_INSTALL_PREFIX=${ZLIB_PREFIX}"
+            -DBUILD_SHARED_LIBS=OFF)
+
+    if(USE_JFROG_CACHE STREQUAL "ON")
+        set(ZLIB_CACHE_PACKAGE_NAME "zlib_${ZLIB_MD5}.tar.gz")
+        set(ZLIB_CACHE_URL "${JFROG_ARTFACTORY_CACHE_URL}/${ZLIB_CACHE_PACKAGE_NAME}")
+        set(ZLIB_CACHE_PACKAGE_PATH "${THIRDPARTY_PACKAGE_CACHE}/${ZLIB_CACHE_PACKAGE_NAME}")
+
+        execute_process(COMMAND wget -q --method HEAD ${ZLIB_CACHE_URL} RESULT_VARIABLE return_code)
+        message(STATUS "Check the remote file ${ZLIB_CACHE_URL}. return code = ${return_code}")
+        if (NOT return_code EQUAL 0)
+            externalproject_add(zlib_ep
+                    URL
+                    ${ZLIB_SOURCE_URL}
+                    ${EP_LOG_OPTIONS}
+                    BUILD_COMMAND
+                    ${MAKE}
+                    ${MAKE_BUILD_ARGS}
+                    BUILD_BYPRODUCTS
+                    "${ZLIB_STATIC_LIB}"
+                    CMAKE_ARGS
+                    ${ZLIB_CMAKE_ARGS})
+
+            ExternalProject_Create_Cache(zlib_ep ${ZLIB_CACHE_PACKAGE_PATH} "${CMAKE_CURRENT_BINARY_DIR}/zlib_ep-prefix" ${JFROG_USER_NAME} ${JFROG_PASSWORD} ${ZLIB_CACHE_URL})
+        else()
+            file(DOWNLOAD ${ZLIB_CACHE_URL} ${ZLIB_CACHE_PACKAGE_PATH} STATUS status)
+            list(GET status 0 status_code)
+            message(STATUS "DOWNLOADING FROM ${ZLIB_CACHE_URL} TO ${ZLIB_CACHE_PACKAGE_PATH}. STATUS = ${status_code}")
+            if (status_code EQUAL 0)
+                ExternalProject_Use_Cache(zlib_ep ${ZLIB_CACHE_PACKAGE_PATH} ${CMAKE_CURRENT_BINARY_DIR})
+            endif()
+        endif()
+    else()
+        externalproject_add(zlib_ep
+                URL
+                ${ZLIB_SOURCE_URL}
+                ${EP_LOG_OPTIONS}
+                BUILD_COMMAND
+                ${MAKE}
+                ${MAKE_BUILD_ARGS}
+                BUILD_BYPRODUCTS
+                "${ZLIB_STATIC_LIB}"
+                CMAKE_ARGS
+                ${ZLIB_CMAKE_ARGS})
+    endif()
+
+    file(MAKE_DIRECTORY "${ZLIB_INCLUDE_DIR}")
+    add_library(zlib STATIC IMPORTED)
+    set_target_properties(zlib
+            PROPERTIES IMPORTED_LOCATION "${ZLIB_STATIC_LIB}"
+            INTERFACE_INCLUDE_DIRECTORIES "${ZLIB_INCLUDE_DIR}")
+
+    add_dependencies(zlib zlib_ep)
+endmacro()
+
+if(MILVUS_WITH_ZLIB)
+    resolve_dependency(ZLIB)
+
+    get_target_property(ZLIB_INCLUDE_DIR zlib INTERFACE_INCLUDE_DIRECTORIES)
+    include_directories(SYSTEM ${ZLIB_INCLUDE_DIR})
+endif()
+
+# ----------------------------------------------------------------------
+# zstd
+
+macro(build_zstd)
+    message(STATUS "Building zstd-${ZSTD_VERSION} from source")
+    set(ZSTD_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/zstd_ep-prefix/src/zstd_ep")
+
+    set(ZSTD_CMAKE_ARGS
+            ${EP_COMMON_TOOLCHAIN}
+            "-DCMAKE_INSTALL_PREFIX=${ZSTD_PREFIX}"
+            -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
+            -DCMAKE_INSTALL_LIBDIR=lib #${CMAKE_INSTALL_LIBDIR}
+            -DZSTD_BUILD_PROGRAMS=off
+            -DZSTD_BUILD_SHARED=off
+            -DZSTD_BUILD_STATIC=on
+            -DZSTD_MULTITHREAD_SUPPORT=off)
+
+
+    set(ZSTD_STATIC_LIB "${ZSTD_PREFIX}/lib/libzstd.a")
+    set(ZSTD_INCLUDE_DIR "${ZSTD_PREFIX}/include")
+    set(ZSTD_CMAKE_ARGS
+            ${ZSTD_CMAKE_ARGS}
+            -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+            -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
+            -DCMAKE_C_FLAGS=${EP_C_FLAGS}
+            -DCMAKE_CXX_FLAGS=${EP_CXX_FLAGS})
+
+    if(CMAKE_VERSION VERSION_LESS 3.7)
+        message(FATAL_ERROR "Building zstd using ExternalProject requires at least CMake 3.7")
+    endif()
+
+    if(USE_JFROG_CACHE STREQUAL "ON")
+        set(ZSTD_CACHE_PACKAGE_NAME "zstd_${ZSTD_MD5}.tar.gz")
+        set(ZSTD_CACHE_URL "${JFROG_ARTFACTORY_CACHE_URL}/${ZSTD_CACHE_PACKAGE_NAME}")
+        set(ZSTD_CACHE_PACKAGE_PATH "${THIRDPARTY_PACKAGE_CACHE}/${ZSTD_CACHE_PACKAGE_NAME}")
+
+        execute_process(COMMAND wget -q --method HEAD ${ZSTD_CACHE_URL} RESULT_VARIABLE return_code)
+        message(STATUS "Check the remote file ${ZSTD_CACHE_URL}. return code = ${return_code}")
+        if (NOT return_code EQUAL 0)
+            externalproject_add(zstd_ep
+                    ${EP_LOG_OPTIONS}
+                    CMAKE_ARGS
+                    ${ZSTD_CMAKE_ARGS}
+                    SOURCE_SUBDIR
+                    "build/cmake"
+                    BUILD_COMMAND
+                    ${MAKE}
+                    ${MAKE_BUILD_ARGS}
+                    INSTALL_DIR
+                    ${ZSTD_PREFIX}
+                    URL
+                    ${ZSTD_SOURCE_URL}
+                    BUILD_BYPRODUCTS
+                    "${ZSTD_STATIC_LIB}")
+
+            ExternalProject_Create_Cache(zstd_ep ${ZSTD_CACHE_PACKAGE_PATH} "${CMAKE_CURRENT_BINARY_DIR}/zstd_ep-prefix" ${JFROG_USER_NAME} ${JFROG_PASSWORD} ${ZSTD_CACHE_URL})
+        else()
+            file(DOWNLOAD ${ZSTD_CACHE_URL} ${ZSTD_CACHE_PACKAGE_PATH} STATUS status)
+            list(GET status 0 status_code)
+            message(STATUS "DOWNLOADING FROM ${ZSTD_CACHE_URL} TO ${ZSTD_CACHE_PACKAGE_PATH}. STATUS = ${status_code}")
+            if (status_code EQUAL 0)
+                ExternalProject_Use_Cache(zstd_ep ${ZSTD_CACHE_PACKAGE_PATH} ${CMAKE_CURRENT_BINARY_DIR})
+            endif()
+        endif()
+    else()
+        externalproject_add(zstd_ep
+                ${EP_LOG_OPTIONS}
+                CMAKE_ARGS
+                ${ZSTD_CMAKE_ARGS}
+                SOURCE_SUBDIR
+                "build/cmake"
+                BUILD_COMMAND
+                ${MAKE}
+                ${MAKE_BUILD_ARGS}
+                INSTALL_DIR
+                ${ZSTD_PREFIX}
+                URL
+                ${ZSTD_SOURCE_URL}
+                BUILD_BYPRODUCTS
+                "${ZSTD_STATIC_LIB}")
+    endif()
+
+    file(MAKE_DIRECTORY "${ZSTD_INCLUDE_DIR}")
+    add_library(zstd STATIC IMPORTED)
+    set_target_properties(zstd
+            PROPERTIES IMPORTED_LOCATION "${ZSTD_STATIC_LIB}"
+            INTERFACE_INCLUDE_DIRECTORIES "${ZSTD_INCLUDE_DIR}")
+
+    add_dependencies(zstd zstd_ep)
+endmacro()
+
+if(MILVUS_WITH_ZSTD)
+    resolve_dependency(ZSTD)
+
+    get_target_property(ZSTD_INCLUDE_DIR zstd INTERFACE_INCLUDE_DIRECTORIES)
+    link_directories(SYSTEM ${ZSTD_PREFIX}/lib)
+    include_directories(SYSTEM ${ZSTD_INCLUDE_DIR})
+endif()
+
+# ----------------------------------------------------------------------
+# libunwind
+
+macro(build_libunwind)
+    message(STATUS "Building libunwind-${LIBUNWIND_VERSION} from source")
+    set(LIBUNWIND_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/libunwind_ep-prefix/src/libunwind_ep/install")
+    set(LIBUNWIND_INCLUDE_DIR "${LIBUNWIND_PREFIX}/include")
+    set(LIBUNWIND_SHARED_LIB "${LIBUNWIND_PREFIX}/lib/libunwind${CMAKE_SHARED_LIBRARY_SUFFIX}")
+    set(LIBUNWIND_CONFIGURE_ARGS "--prefix=${LIBUNWIND_PREFIX}")
+
+    if(USE_JFROG_CACHE STREQUAL "ON")
+        set(LIBUNWIND_CACHE_PACKAGE_NAME "libunwind_${LIBUNWIND_MD5}.tar.gz")
+        set(LIBUNWIND_CACHE_URL "${JFROG_ARTFACTORY_CACHE_URL}/${LIBUNWIND_CACHE_PACKAGE_NAME}")
+        set(LIBUNWIND_CACHE_PACKAGE_PATH "${THIRDPARTY_PACKAGE_CACHE}/${LIBUNWIND_CACHE_PACKAGE_NAME}")
+
+        execute_process(COMMAND wget -q --method HEAD ${LIBUNWIND_CACHE_URL} RESULT_VARIABLE return_code)
+        message(STATUS "Check the remote file ${LIBUNWIND_CACHE_URL}. return code = ${return_code}")
+        if (NOT return_code EQUAL 0)
+            externalproject_add(libunwind_ep
+                    URL
+                    ${LIBUNWIND_SOURCE_URL}
+                    ${EP_LOG_OPTIONS}
+                    CONFIGURE_COMMAND
+                    "./configure"
+                    ${LIBUNWIND_CONFIGURE_ARGS}
+                    BUILD_COMMAND
+                    ${MAKE} ${MAKE_BUILD_ARGS}
+                    BUILD_IN_SOURCE
+                    1
+                    INSTALL_COMMAND
+                    ${MAKE} install
+                    BUILD_BYPRODUCTS
+                    ${LIBUNWIND_SHARED_LIB})
+
+            ExternalProject_Create_Cache(libunwind_ep ${LIBUNWIND_CACHE_PACKAGE_PATH} "${CMAKE_CURRENT_BINARY_DIR}/libunwind_ep-prefix" ${JFROG_USER_NAME} ${JFROG_PASSWORD} ${LIBUNWIND_CACHE_URL})
+        else()
+            file(DOWNLOAD ${LIBUNWIND_CACHE_URL} ${LIBUNWIND_CACHE_PACKAGE_PATH} STATUS status)
+            list(GET status 0 status_code)
+            message(STATUS "DOWNLOADING FROM ${LIBUNWIND_CACHE_URL} TO ${LIBUNWIND_CACHE_PACKAGE_PATH}. STATUS = ${status_code}")
+            if (status_code EQUAL 0)
+                ExternalProject_Use_Cache(libunwind_ep ${LIBUNWIND_CACHE_PACKAGE_PATH} ${CMAKE_CURRENT_BINARY_DIR})
+            endif()
+        endif()
+    else()
+        externalproject_add(libunwind_ep
+                URL
+                ${LIBUNWIND_SOURCE_URL}
+                ${EP_LOG_OPTIONS}
+                CONFIGURE_COMMAND
+                "./configure"
+                ${LIBUNWIND_CONFIGURE_ARGS}
+                BUILD_COMMAND
+                ${MAKE} ${MAKE_BUILD_ARGS}
+                BUILD_IN_SOURCE
+                1
+                INSTALL_COMMAND
+                ${MAKE} install
+                BUILD_BYPRODUCTS
+                ${LIBUNWIND_SHARED_LIB})
+    endif()
+
+    file(MAKE_DIRECTORY "${LIBUNWIND_INCLUDE_DIR}")
+
+    add_library(libunwind SHARED IMPORTED)
+    set_target_properties(libunwind
+            PROPERTIES IMPORTED_LOCATION "${LIBUNWIND_SHARED_LIB}"
+            INTERFACE_INCLUDE_DIRECTORIES "${LIBUNWIND_INCLUDE_DIR}")
+
+    add_dependencies(libunwind libunwind_ep)
+endmacro()
+
+if(MILVUS_WITH_LIBUNWIND)
+    resolve_dependency(libunwind)
+
+    get_target_property(LIBUNWIND_INCLUDE_DIR libunwind INTERFACE_INCLUDE_DIRECTORIES)
+    include_directories(SYSTEM ${LIBUNWIND_INCLUDE_DIR})
+endif()
+
+# ----------------------------------------------------------------------
+# gperftools
+
+macro(build_gperftools)
+    message(STATUS "Building gperftools-${GPERFTOOLS_VERSION} from source")
+    set(GPERFTOOLS_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/gperftools_ep-prefix/src/gperftools_ep")
+    set(GPERFTOOLS_INCLUDE_DIR "${GPERFTOOLS_PREFIX}/include")
+    set(GPERFTOOLS_STATIC_LIB "${GPERFTOOLS_PREFIX}/lib/libprofiler${CMAKE_STATIC_LIBRARY_SUFFIX}")
+    set(GPERFTOOLS_CONFIGURE_ARGS "--prefix=${GPERFTOOLS_PREFIX}")
+
+    if(USE_JFROG_CACHE STREQUAL "ON")
+        set(GPERFTOOLS_CACHE_PACKAGE_NAME "gperftools_${GPERFTOOLS_MD5}.tar.gz")
+        set(GPERFTOOLS_CACHE_URL "${JFROG_ARTFACTORY_CACHE_URL}/${GPERFTOOLS_CACHE_PACKAGE_NAME}")
+        set(GPERFTOOLS_CACHE_PACKAGE_PATH "${THIRDPARTY_PACKAGE_CACHE}/${GPERFTOOLS_CACHE_PACKAGE_NAME}")
+
+        execute_process(COMMAND wget -q --method HEAD ${GPERFTOOLS_CACHE_URL} RESULT_VARIABLE return_code)
+        message(STATUS "Check the remote file ${GPERFTOOLS_CACHE_URL}. return code = ${return_code}")
+        if (NOT return_code EQUAL 0)
+            externalproject_add(gperftools_ep
+                    URL
+                    ${GPERFTOOLS_SOURCE_URL}
+                    ${EP_LOG_OPTIONS}
+                    CONFIGURE_COMMAND
+                    "./configure"
+                    ${GPERFTOOLS_CONFIGURE_ARGS}
+                    BUILD_COMMAND
+                    ${MAKE} ${MAKE_BUILD_ARGS}
+                    BUILD_IN_SOURCE
+                    1
+                    INSTALL_COMMAND
+                    ${MAKE} install
+                    BUILD_BYPRODUCTS
+                    ${GPERFTOOLS_STATIC_LIB})
+
+            ExternalProject_Create_Cache(gperftools_ep ${GPERFTOOLS_CACHE_PACKAGE_PATH} "${CMAKE_CURRENT_BINARY_DIR}/gperftools_ep-prefix" ${JFROG_USER_NAME} ${JFROG_PASSWORD} ${GPERFTOOLS_CACHE_URL})
+        else()
+            file(DOWNLOAD ${GPERFTOOLS_CACHE_URL} ${GPERFTOOLS_CACHE_PACKAGE_PATH} STATUS status)
+            list(GET status 0 status_code)
+            message(STATUS "DOWNLOADING FROM ${GPERFTOOLS_CACHE_URL} TO ${GPERFTOOLS_CACHE_PACKAGE_PATH}. STATUS = ${status_code}")
+            if (status_code EQUAL 0)
+                ExternalProject_Use_Cache(gperftools_ep ${GPERFTOOLS_CACHE_PACKAGE_PATH} ${CMAKE_CURRENT_BINARY_DIR})
+            endif()
+        endif()
+    else()
+        externalproject_add(gperftools_ep
+                URL
+                ${GPERFTOOLS_SOURCE_URL}
+                ${EP_LOG_OPTIONS}
+                CONFIGURE_COMMAND
+                "./configure"
+                ${GPERFTOOLS_CONFIGURE_ARGS}
+                BUILD_COMMAND
+                ${MAKE} ${MAKE_BUILD_ARGS}
+                BUILD_IN_SOURCE
+                1
+                INSTALL_COMMAND
+                ${MAKE} install
+                BUILD_BYPRODUCTS
+                ${GPERFTOOLS_STATIC_LIB})
+    endif()
+
+    ExternalProject_Add_StepDependencies(gperftools_ep build libunwind_ep)
+
+    file(MAKE_DIRECTORY "${GPERFTOOLS_INCLUDE_DIR}")
+
+    add_library(gperftools STATIC IMPORTED)
+    set_target_properties(gperftools
+            PROPERTIES IMPORTED_LOCATION "${GPERFTOOLS_STATIC_LIB}"
+            INTERFACE_INCLUDE_DIRECTORIES "${GPERFTOOLS_INCLUDE_DIR}"
+            INTERFACE_LINK_LIBRARIES libunwind)
+
+    add_dependencies(gperftools gperftools_ep)
+    add_dependencies(gperftools libunwind_ep)
+endmacro()
+
+if(MILVUS_WITH_GPERFTOOLS)
+    resolve_dependency(gperftools)
+
+    get_target_property(GPERFTOOLS_INCLUDE_DIR gperftools INTERFACE_INCLUDE_DIRECTORIES)
+    include_directories(SYSTEM ${GPERFTOOLS_INCLUDE_DIR})
+    link_directories(SYSTEM ${GPERFTOOLS_PREFIX}/lib)
+endif()
+
+# ----------------------------------------------------------------------
+# GRPC
+
+macro(build_grpc)
+    message(STATUS "Building GRPC-${GRPC_VERSION} from source")
+    set(GRPC_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/grpc_ep-prefix/src/grpc_ep/install")
+    set(GRPC_INCLUDE_DIR "${GRPC_PREFIX}/include")
+    set(GRPC_STATIC_LIB "${GRPC_PREFIX}/lib/${CMAKE_STATIC_LIBRARY_PREFIX}grpc${CMAKE_STATIC_LIBRARY_SUFFIX}")
+    set(GRPC++_STATIC_LIB "${GRPC_PREFIX}/lib/${CMAKE_STATIC_LIBRARY_PREFIX}grpc++${CMAKE_STATIC_LIBRARY_SUFFIX}")
+    set(GRPCPP_CHANNELZ_STATIC_LIB "${GRPC_PREFIX}/lib/${CMAKE_STATIC_LIBRARY_PREFIX}grpcpp_channelz${CMAKE_STATIC_LIBRARY_SUFFIX}")
+    set(GRPC_PROTOBUF_LIB_DIR "${CMAKE_CURRENT_BINARY_DIR}/grpc_ep-prefix/src/grpc_ep/libs/opt/protobuf")
+    set(GRPC_PROTOBUF_STATIC_LIB "${GRPC_PROTOBUF_LIB_DIR}/${CMAKE_STATIC_LIBRARY_PREFIX}protobuf${CMAKE_STATIC_LIBRARY_SUFFIX}")
+    set(GRPC_PROTOC_STATIC_LIB "${GRPC_PROTOBUF_LIB_DIR}/${CMAKE_STATIC_LIBRARY_PREFIX}protoc${CMAKE_STATIC_LIBRARY_SUFFIX}")
+
+    if(USE_JFROG_CACHE STREQUAL "ON")
+        set(GRPC_CACHE_PACKAGE_NAME "grpc_${GRPC_MD5}.tar.gz")
+        set(GRPC_CACHE_URL "${JFROG_ARTFACTORY_CACHE_URL}/${GRPC_CACHE_PACKAGE_NAME}")
+        set(GRPC_CACHE_PACKAGE_PATH "${THIRDPARTY_PACKAGE_CACHE}/${GRPC_CACHE_PACKAGE_NAME}")
+
+        execute_process(COMMAND wget -q --method HEAD ${GRPC_CACHE_URL} RESULT_VARIABLE return_code)
+        message(STATUS "Check the remote file ${GRPC_CACHE_URL}. return code = ${return_code}")
+        if (NOT return_code EQUAL 0)
+            externalproject_add(grpc_ep
+                    URL
+                    ${GRPC_SOURCE_URL}
+                    ${EP_LOG_OPTIONS}
+                    CONFIGURE_COMMAND
+                    ""
+                    BUILD_IN_SOURCE
+                    1
+                    BUILD_COMMAND
+                    ${MAKE} ${MAKE_BUILD_ARGS} prefix=${GRPC_PREFIX}
+                    INSTALL_COMMAND
+                    ${MAKE} install prefix=${GRPC_PREFIX}
+                    BUILD_BYPRODUCTS
+                    ${GRPC_STATIC_LIB}
+                    ${GRPC++_STATIC_LIB}
+                    ${GRPCPP_CHANNELZ_STATIC_LIB}
+                    ${GRPC_PROTOBUF_STATIC_LIB}
+                    ${GRPC_PROTOC_STATIC_LIB})
+
+            ExternalProject_Create_Cache(grpc_ep ${GRPC_CACHE_PACKAGE_PATH} "${CMAKE_CURRENT_BINARY_DIR}/grpc_ep-prefix" ${JFROG_USER_NAME} ${JFROG_PASSWORD} ${GRPC_CACHE_URL})
+        else()
+            file(DOWNLOAD ${GRPC_CACHE_URL} ${GRPC_CACHE_PACKAGE_PATH} STATUS status)
+            list(GET status 0 status_code)
+            message(STATUS "DOWNLOADING FROM ${GRPC_CACHE_URL} TO ${GRPC_CACHE_PACKAGE_PATH}. STATUS = ${status_code}")
+            if (status_code EQUAL 0)
+                ExternalProject_Use_Cache(grpc_ep ${GRPC_CACHE_PACKAGE_PATH} ${CMAKE_CURRENT_BINARY_DIR})
+            endif()
+        endif()
+    else()
+        externalproject_add(grpc_ep
+                URL
+                ${GRPC_SOURCE_URL}
+                ${EP_LOG_OPTIONS}
+                CONFIGURE_COMMAND
+                ""
+                BUILD_IN_SOURCE
+                1
+                BUILD_COMMAND
+                ${MAKE} ${MAKE_BUILD_ARGS} prefix=${GRPC_PREFIX}
+                INSTALL_COMMAND
+                ${MAKE} install prefix=${GRPC_PREFIX}
+                BUILD_BYPRODUCTS
+                ${GRPC_STATIC_LIB}
+                ${GRPC++_STATIC_LIB}
+                ${GRPCPP_CHANNELZ_STATIC_LIB}
+                ${GRPC_PROTOBUF_STATIC_LIB}
+                ${GRPC_PROTOC_STATIC_LIB})
+    endif()
+
+    file(MAKE_DIRECTORY "${GRPC_INCLUDE_DIR}")
+
+    add_library(grpc STATIC IMPORTED)
+    set_target_properties(grpc
+            PROPERTIES IMPORTED_LOCATION "${GRPC_STATIC_LIB}"
+            INTERFACE_INCLUDE_DIRECTORIES "${GRPC_INCLUDE_DIR}")
+
+    add_library(grpc++ STATIC IMPORTED)
+    set_target_properties(grpc++
+            PROPERTIES IMPORTED_LOCATION "${GRPC++_STATIC_LIB}"
+            INTERFACE_INCLUDE_DIRECTORIES "${GRPC_INCLUDE_DIR}")
+
+    add_library(grpcpp_channelz STATIC IMPORTED)
+    set_target_properties(grpcpp_channelz
+            PROPERTIES IMPORTED_LOCATION "${GRPCPP_CHANNELZ_STATIC_LIB}"
+            INTERFACE_INCLUDE_DIRECTORIES "${GRPC_INCLUDE_DIR}")
+
+    add_library(grpc_protobuf STATIC IMPORTED)
+    set_target_properties(grpc_protobuf
+            PROPERTIES IMPORTED_LOCATION "${GRPC_PROTOBUF_STATIC_LIB}")
+
+    add_library(grpc_protoc STATIC IMPORTED)
+    set_target_properties(grpc_protoc
+            PROPERTIES IMPORTED_LOCATION "${GRPC_PROTOC_STATIC_LIB}")
+
+    add_dependencies(grpc grpc_ep)
+    add_dependencies(grpc++ grpc_ep)
+    add_dependencies(grpcpp_channelz grpc_ep)
+    add_dependencies(grpc_protobuf grpc_ep)
+    add_dependencies(grpc_protoc grpc_ep)
+endmacro()
+
+if(MILVUS_WITH_GRPC)
+    resolve_dependency(GRPC)
+
+    get_target_property(GRPC_INCLUDE_DIR grpc INTERFACE_INCLUDE_DIRECTORIES)
+    include_directories(SYSTEM ${GRPC_INCLUDE_DIR})
+    link_directories(SYSTEM ${GRPC_PREFIX}/lib)
+
+    set(GRPC_THIRD_PARTY_DIR ${CMAKE_CURRENT_BINARY_DIR}/grpc_ep-prefix/src/grpc_ep/third_party)
+    include_directories(SYSTEM ${GRPC_THIRD_PARTY_DIR}/protobuf/src)
+    link_directories(SYSTEM ${GRPC_PROTOBUF_LIB_DIR})
+endif()
diff --git a/core/conf/log_config.template b/core/conf/log_config.template
new file mode 100644
index 0000000000..a3fb15af6d
--- /dev/null
+++ b/core/conf/log_config.template
@@ -0,0 +1,27 @@
+* GLOBAL:
+    FORMAT                  =   "%datetime | %level | %logger | %msg"
+    FILENAME                =   "@MILVUS_DB_PATH@/logs/milvus-%datetime{%y-%M-%d-%H:%m}-global.log"
+    ENABLED                 =   true
+    TO_FILE                 =   true
+    TO_STANDARD_OUTPUT      =   false
+    SUBSECOND_PRECISION     =   3
+    PERFORMANCE_TRACKING    =   false
+    MAX_LOG_FILE_SIZE       =   209715200 ## Throw log files away after 200MB
+* DEBUG:
+    FILENAME                =   "@MILVUS_DB_PATH@/logs/milvus-%datetime{%y-%M-%d-%H:%m}-debug.log"
+    ENABLED                 =   true
+* WARNING:
+    FILENAME                =   "@MILVUS_DB_PATH@/logs/milvus-%datetime{%y-%M-%d-%H:%m}-warning.log"
+* TRACE:
+    FILENAME                =   "@MILVUS_DB_PATH@/logs/milvus-%datetime{%y-%M-%d-%H:%m}-trace.log"
+* VERBOSE:
+    FORMAT                  =   "%datetime{%d/%M/%y} | %level-%vlevel | %msg"
+    TO_FILE                 =   false
+    TO_STANDARD_OUTPUT      =   false
+## Error logs
+* ERROR:
+    ENABLED                 =   true
+    FILENAME                =   "@MILVUS_DB_PATH@/logs/milvus-%datetime{%y-%M-%d-%H:%m}-error.log"
+* FATAL:
+    ENABLED                 =   true
+    FILENAME                =   "@MILVUS_DB_PATH@/logs/milvus-%datetime{%y-%M-%d-%H:%m}-fatal.log"
\ No newline at end of file
diff --git a/core/conf/server_config.template b/core/conf/server_config.template
new file mode 100644
index 0000000000..7abfb8b055
--- /dev/null
+++ b/core/conf/server_config.template
@@ -0,0 +1,43 @@
+# Default values are used when you make no changes to the following parameters.
+
+server_config:
+  address: 0.0.0.0                  # milvus server ip address (IPv4)
+  port: 19530                       # port range: 1025 ~ 65534
+  deploy_mode: single               # deployment type: single, cluster_readonly, cluster_writable
+  time_zone: UTC+8
+
+db_config:
+  primary_path: @MILVUS_DB_PATH@    # path used to store data and meta
+  secondary_path:                   # path used to store data only, split by semicolon
+
+  backend_url: sqlite://:@:/        # URI format: dialect://username:password@host:port/database
+                                    # Keep 'dialect://:@:/', and replace other texts with real values
+                                    # Replace 'dialect' with 'mysql' or 'sqlite'
+
+  insert_buffer_size: 4             # GB, maximum insert buffer size allowed
+                                    # sum of insert_buffer_size and cpu_cache_capacity cannot exceed total memory
+
+  preload_table:                    # preload data at startup, '*' means load all tables, empty value means no preload
+                                    # you can specify preload tables like this: table1,table2,table3
+
+metric_config:
+  enable_monitor: false             # enable monitoring or not
+  collector: prometheus             # prometheus
+  prometheus_config:
+    port: 8080                      # port prometheus uses to fetch metrics
+
+cache_config:
+  cpu_cache_capacity: 16            # GB, CPU memory used for cache
+  cpu_cache_threshold: 0.85         # percentage of data that will be kept when cache cleanup is triggered
+  gpu_cache_capacity: 4             # GB, GPU memory used for cache
+  gpu_cache_threshold: 0.85         # percentage of data that will be kept when cache cleanup is triggered
+  cache_insert_data: false          # whether to load inserted data into cache
+
+engine_config:
+  use_blas_threshold: 20            # if nq <  use_blas_threshold, use SSE, faster with fluctuated response times
+                                    # if nq >= use_blas_threshold, use OpenBlas, slower with stable response times
+
+resource_config:
+  search_resources:                 # define the GPUs used for search computation, valid value: gpux
+    - gpu0
+  index_build_device: gpu0          # GPU used for building index
\ No newline at end of file
diff --git a/core/coverage.sh b/core/coverage.sh
new file mode 100755
index 0000000000..74f9f4219d
--- /dev/null
+++ b/core/coverage.sh
@@ -0,0 +1,128 @@
+#!/bin/bash
+
+export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$(pwd)/milvus/lib
+
+MYSQL_USER_NAME=root
+MYSQL_PASSWORD=123456
+MYSQL_HOST='127.0.0.1'
+MYSQL_PORT='3306'
+
+while getopts "u:p:t:h" arg
+do
+        case $arg in
+             u)
+                MYSQL_USER_NAME=$OPTARG
+                ;;
+             p)
+                MYSQL_PASSWORD=$OPTARG
+                ;;
+             t)
+                MYSQL_HOST=$OPTARG
+                ;;
+             h) # help
+                echo "
+
+parameter:
+-u: mysql account
+-p: mysql password
+-t: mysql host
+-h: help
+
+usage:
+./coverage.sh -u \${MYSQL_USER} -p \${MYSQL_PASSWORD} -t \${MYSQL_HOST} [-h]
+                "
+                exit 0
+                ;;
+             ?)
+                echo "ERROR! unknown argument"
+        exit 1
+        ;;
+        esac
+done
+
+LCOV_CMD="lcov"
+LCOV_GEN_CMD="genhtml"
+
+FILE_INFO_BASE="base.info"
+FILE_INFO_MILVUS="server.info"
+FILE_INFO_OUTPUT="output.info"
+FILE_INFO_OUTPUT_NEW="output_new.info"
+DIR_LCOV_OUTPUT="lcov_out"
+
+DIR_GCNO="cmake_build"
+DIR_UNITTEST="milvus/unittest"
+
+# delete old code coverage info files
+rm -f FILE_INFO_BASE
+rm -f FILE_INFO_MILVUS
+rm -f FILE_INFO_OUTPUT
+rm -f FILE_INFO_OUTPUT_NEW
+rm -rf lcov_out
+rm -f FILE_INFO_BASE FILE_INFO_MILVUS FILE_INFO_OUTPUT FILE_INFO_OUTPUT_NEW
+
+MYSQL_DB_NAME=milvus_`date +%s%N`
+
+function mysql_exc()
+{
+    cmd=$1
+    mysql -h${MYSQL_HOST} -u${MYSQL_USER_NAME} -p${MYSQL_PASSWORD} -e "${cmd}"
+    if [ $? -ne 0 ]; then
+        echo "mysql $cmd run failed"
+    fi
+}
+
+mysql_exc "CREATE DATABASE IF NOT EXISTS ${MYSQL_DB_NAME};"
+mysql_exc "GRANT ALL PRIVILEGES ON ${MYSQL_DB_NAME}.* TO '${MYSQL_USER_NAME}'@'%';"
+mysql_exc "FLUSH PRIVILEGES;"
+mysql_exc "USE ${MYSQL_DB_NAME};"
+
+# get baseline
+${LCOV_CMD} -c -i -d ${DIR_GCNO} -o "${FILE_INFO_BASE}"
+if [ $? -ne 0 ]; then
+    echo "gen baseline coverage run failed"
+    exit -1
+fi
+
+for test in `ls ${DIR_UNITTEST}`; do
+    echo $test
+    case ${test} in
+        test_db)
+            # set run args for test_db
+            args="mysql://${MYSQL_USER_NAME}:${MYSQL_PASSWORD}@${MYSQL_HOST}:${MYSQL_PORT}/${MYSQL_DB_NAME}"
+            ;;
+        *test_*)
+            args=""
+            ;;
+    esac
+    # run unittest
+    ./${DIR_UNITTEST}/${test} "${args}"
+    if [ $? -ne 0 ]; then
+        echo ${args}
+        echo ${DIR_UNITTEST}/${test} "run failed"
+    fi
+done
+
+mysql_exc "DROP DATABASE IF EXISTS ${MYSQL_DB_NAME};"
+
+# gen code coverage
+${LCOV_CMD} -d ${DIR_GCNO} -o "${FILE_INFO_MILVUS}" -c
+# merge coverage
+${LCOV_CMD} -a ${FILE_INFO_BASE} -a ${FILE_INFO_MILVUS} -o "${FILE_INFO_OUTPUT}"
+
+# remove third party from tracefiles
+${LCOV_CMD} -r "${FILE_INFO_OUTPUT}" -o "${FILE_INFO_OUTPUT_NEW}" \
+    "/usr/*" \
+    "*/boost/*" \
+    "*/cmake_build/*_ep-prefix/*" \
+    "*/src/index/cmake_build*" \
+    "*/src/index/thirdparty*" \
+    "*/src/grpc*" \
+    "*/src/metrics/MetricBase.h" \
+    "*/src/server/Server.cpp" \
+    "*/src/server/DBWrapper.cpp" \
+    "*/src/server/grpc_impl/GrpcServer.cpp" \
+    "*/src/utils/easylogging++.h" \
+    "*/src/utils/easylogging++.cc"
+
+# gen html report
+${LCOV_GEN_CMD} "${FILE_INFO_OUTPUT_NEW}" --output-directory ${DIR_LCOV_OUTPUT}/
diff --git a/core/scripts/start_server.sh b/core/scripts/start_server.sh
new file mode 100755
index 0000000000..312cef86d6
--- /dev/null
+++ b/core/scripts/start_server.sh
@@ -0,0 +1,4 @@
+#!/bin/bash
+
+../bin/milvus_server -c ../conf/server_config.yaml -l ../conf/log_config.conf
+
diff --git a/core/scripts/stop_server.sh b/core/scripts/stop_server.sh
new file mode 100755
index 0000000000..f15e48a954
--- /dev/null
+++ b/core/scripts/stop_server.sh
@@ -0,0 +1,16 @@
+#!/bin/bash
+
+function kill_progress()
+{
+  kill -s SIGUSR2 $(pgrep $1)
+
+  sleep 2
+}
+
+STATUS=$(kill_progress "milvus_server" )
+
+if [[ ${STATUS} == "false" ]];then
+  echo "Milvus server closed abnormally!"
+else
+  echo "Milvus server closed successfully!"
+fi
diff --git a/core/src/CMakeLists.txt b/core/src/CMakeLists.txt
new file mode 100644
index 0000000000..b0228bd090
--- /dev/null
+++ b/core/src/CMakeLists.txt
@@ -0,0 +1,191 @@
+#-------------------------------------------------------------------------------
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you 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_directories(${MILVUS_SOURCE_DIR})
+include_directories(${MILVUS_ENGINE_SRC})
+
+include_directories(${CUDA_TOOLKIT_ROOT_DIR}/include)
+include_directories(${MILVUS_ENGINE_SRC}/grpc/gen-status)
+include_directories(${MILVUS_ENGINE_SRC}/grpc/gen-milvus)
+
+#this statement must put here, since the INDEX_INCLUDE_DIRS is defined in code/CMakeList.txt
+add_subdirectory(index)
+
+set(INDEX_INCLUDE_DIRS ${INDEX_INCLUDE_DIRS} PARENT_SCOPE)
+foreach (dir ${INDEX_INCLUDE_DIRS})
+    include_directories(${dir})
+endforeach ()
+
+aux_source_directory(${MILVUS_ENGINE_SRC}/cache cache_files)
+aux_source_directory(${MILVUS_ENGINE_SRC}/config config_files)
+aux_source_directory(${MILVUS_ENGINE_SRC}/metrics metrics_files)
+aux_source_directory(${MILVUS_ENGINE_SRC}/db db_main_files)
+aux_source_directory(${MILVUS_ENGINE_SRC}/db/engine db_engine_files)
+aux_source_directory(${MILVUS_ENGINE_SRC}/db/insert db_insert_files)
+aux_source_directory(${MILVUS_ENGINE_SRC}/db/meta db_meta_files)
+
+set(grpc_service_files
+        ${MILVUS_ENGINE_SRC}/grpc/gen-milvus/milvus.grpc.pb.cc
+        ${MILVUS_ENGINE_SRC}/grpc/gen-milvus/milvus.pb.cc
+        ${MILVUS_ENGINE_SRC}/grpc/gen-status/status.grpc.pb.cc
+        ${MILVUS_ENGINE_SRC}/grpc/gen-status/status.pb.cc
+        )
+
+aux_source_directory(${MILVUS_ENGINE_SRC}/scheduler scheduler_main_files)
+aux_source_directory(${MILVUS_ENGINE_SRC}/scheduler/action scheduler_action_files)
+aux_source_directory(${MILVUS_ENGINE_SRC}/scheduler/event scheduler_event_files)
+aux_source_directory(${MILVUS_ENGINE_SRC}/scheduler/job scheduler_job_files)
+aux_source_directory(${MILVUS_ENGINE_SRC}/scheduler/optimizer scheduler_optimizer_files)
+aux_source_directory(${MILVUS_ENGINE_SRC}/scheduler/resource scheduler_resource_files)
+aux_source_directory(${MILVUS_ENGINE_SRC}/scheduler/task scheduler_task_files)
+set(scheduler_files
+        ${scheduler_main_files}
+        ${scheduler_action_files}
+        ${scheduler_event_files}
+        ${scheduler_job_files}
+        ${scheduler_optimizer_files}
+        ${scheduler_resource_files}
+        ${scheduler_task_files}
+        )
+
+aux_source_directory(${MILVUS_ENGINE_SRC}/server server_files)
+aux_source_directory(${MILVUS_ENGINE_SRC}/server/grpc_impl grpc_server_files)
+aux_source_directory(${MILVUS_ENGINE_SRC}/utils utils_files)
+aux_source_directory(${MILVUS_ENGINE_SRC}/wrapper wrapper_files)
+
+set(engine_files
+        ${CMAKE_CURRENT_SOURCE_DIR}/main.cpp
+        ${cache_files}
+        ${db_main_files}
+        ${db_engine_files}
+        ${db_insert_files}
+        ${db_meta_files}
+        ${metrics_files}
+        ${utils_files}
+        ${wrapper_files}
+        )
+
+set(client_grpc_lib
+        grpcpp_channelz
+        grpc++
+        grpc
+        grpc_protobuf
+        grpc_protoc
+        )
+
+set(prometheus_lib
+        prometheus-cpp-push
+        prometheus-cpp-pull
+        prometheus-cpp-core
+        )
+
+set(boost_lib
+        libboost_system.a
+        libboost_filesystem.a
+        libboost_serialization.a
+        )
+
+set(cuda_lib
+        ${CUDA_TOOLKIT_ROOT_DIR}/lib64/stubs/libnvidia-ml.so
+        cudart
+        cublas
+        )
+
+set(third_party_libs
+        sqlite
+        ${client_grpc_lib}
+        yaml-cpp
+        ${prometheus_lib}
+        ${boost_lib}
+        bzip2
+        lz4
+        snappy
+        zlib
+        zstd
+        ${cuda_lib}
+        mysqlpp
+        )
+
+if (MILVUS_ENABLE_PROFILING STREQUAL "ON")
+    set(third_party_libs ${third_party_libs}
+        gperftools
+        libunwind
+        )
+endif ()
+
+link_directories("${CUDA_TOOLKIT_ROOT_DIR}/lib64")
+set(engine_libs
+        pthread
+        libgomp.a
+        libgfortran.a
+        )
+
+if (NOT ${CMAKE_SYSTEM_PROCESSOR} MATCHES "aarch64")
+    set(engine_libs
+            ${engine_libs}
+            libquadmath.a
+            )
+endif ()
+
+cuda_add_library(milvus_engine STATIC ${engine_files})
+target_link_libraries(milvus_engine
+        knowhere
+        ${engine_libs}
+        ${third_party_libs}
+        )
+
+add_library(metrics STATIC ${metrics_files})
+
+set(metrics_lib
+        yaml-cpp
+        ${prometheus_lib}
+        )
+
+target_link_libraries(metrics ${metrics_lib})
+
+set(server_libs
+        milvus_engine
+        pthread
+        dl
+        metrics
+        )
+
+add_executable(milvus_server
+        ${config_files}
+        ${metrics_files}
+        ${scheduler_files}
+        ${server_files}
+        ${grpc_server_files}
+        ${grpc_service_files}
+        ${utils_files}
+        )
+
+target_link_libraries(milvus_server
+        ${server_libs}
+        )
+
+install(TARGETS milvus_server DESTINATION bin)
+
+install(FILES
+        ${CMAKE_BINARY_DIR}/mysqlpp_ep-prefix/src/mysqlpp_ep/lib/${CMAKE_SHARED_LIBRARY_PREFIX}mysqlpp${CMAKE_SHARED_LIBRARY_SUFFIX}
+        ${CMAKE_BINARY_DIR}/mysqlpp_ep-prefix/src/mysqlpp_ep/lib/${CMAKE_SHARED_LIBRARY_PREFIX}mysqlpp${CMAKE_SHARED_LIBRARY_SUFFIX}.3
+        ${CMAKE_BINARY_DIR}/mysqlpp_ep-prefix/src/mysqlpp_ep/lib/${CMAKE_SHARED_LIBRARY_PREFIX}mysqlpp${CMAKE_SHARED_LIBRARY_SUFFIX}.3.2.4
+        DESTINATION lib)
+
+add_subdirectory(sdk)
diff --git a/core/src/cache/Cache.h b/core/src/cache/Cache.h
new file mode 100644
index 0000000000..62a7f13ca8
--- /dev/null
+++ b/core/src/cache/Cache.h
@@ -0,0 +1,91 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "LRU.h"
+#include "utils/Log.h"
+
+#include <atomic>
+#include <mutex>
+#include <set>
+#include <string>
+
+namespace milvus {
+namespace cache {
+
+template <typename ItemObj>
+class Cache {
+ public:
+    // mem_capacity, units:GB
+    Cache(int64_t capacity_gb, uint64_t cache_max_count);
+    ~Cache() = default;
+
+    int64_t
+    usage() const {
+        return usage_;
+    }
+
+    int64_t
+    capacity() const {
+        return capacity_;
+    }  // unit: BYTE
+    void
+    set_capacity(int64_t capacity);  // unit: BYTE
+
+    double
+    freemem_percent() const {
+        return freemem_percent_;
+    }
+
+    void
+    set_freemem_percent(double percent) {
+        freemem_percent_ = percent;
+    }
+
+    size_t
+    size() const;
+    bool
+    exists(const std::string& key);
+    ItemObj
+    get(const std::string& key);
+    void
+    insert(const std::string& key, const ItemObj& item);
+    void
+    erase(const std::string& key);
+    void
+    print();
+    void
+    clear();
+
+ private:
+    void
+    free_memory();
+
+ private:
+    int64_t usage_;
+    int64_t capacity_;
+    double freemem_percent_;
+
+    LRU<std::string, ItemObj> lru_;
+    mutable std::mutex mutex_;
+};
+
+}  // namespace cache
+}  // namespace milvus
+
+#include "cache/Cache.inl"
diff --git a/core/src/cache/Cache.inl b/core/src/cache/Cache.inl
new file mode 100644
index 0000000000..3a60dd288f
--- /dev/null
+++ b/core/src/cache/Cache.inl
@@ -0,0 +1,194 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+
+
+
+namespace milvus {
+namespace cache {
+
+constexpr double DEFAULT_THRESHHOLD_PERCENT = 0.85;
+
+template<typename ItemObj>
+Cache<ItemObj>::Cache(int64_t capacity, uint64_t cache_max_count)
+    : usage_(0),
+      capacity_(capacity),
+      freemem_percent_(DEFAULT_THRESHHOLD_PERCENT),
+      lru_(cache_max_count) {
+//    AGENT_LOG_DEBUG << "Construct Cache with capacity " << std::to_string(mem_capacity)
+}
+
+template<typename ItemObj>
+void
+Cache<ItemObj>::set_capacity(int64_t capacity) {
+    if (capacity > 0) {
+        capacity_ = capacity;
+        free_memory();
+    }
+}
+
+template<typename ItemObj>
+size_t
+Cache<ItemObj>::size() const {
+    std::lock_guard<std::mutex> lock(mutex_);
+    return lru_.size();
+}
+
+template<typename ItemObj>
+bool
+Cache<ItemObj>::exists(const std::string &key) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    return lru_.exists(key);
+}
+
+template<typename ItemObj>
+ItemObj
+Cache<ItemObj>::get(const std::string &key) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    if (!lru_.exists(key)) {
+        return nullptr;
+    }
+
+    return lru_.get(key);
+}
+
+template<typename ItemObj>
+void
+Cache<ItemObj>::insert(const std::string &key, const ItemObj &item) {
+    if (item == nullptr) {
+        return;
+    }
+
+//    if(item->size() > capacity_) {
+//        SERVER_LOG_ERROR << "Item size " << item->size()
+//                        << " is too large to insert into cache, capacity " << capacity_;
+//        return;
+//    }
+
+    //calculate usage
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+
+        //if key already exist, subtract old item size
+        if (lru_.exists(key)) {
+            const ItemObj &old_item = lru_.get(key);
+            usage_ -= old_item->Size();
+        }
+
+        //plus new item size
+        usage_ += item->Size();
+    }
+
+    //if usage exceed capacity, free some items
+    if (usage_ > capacity_) {
+        SERVER_LOG_DEBUG << "Current usage " << usage_
+                         << " exceeds cache capacity " << capacity_
+                         << ", start free memory";
+        free_memory();
+    }
+
+    //insert new item
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+
+        lru_.put(key, item);
+        SERVER_LOG_DEBUG << "Insert " << key << " size:" << item->Size()
+                         << " bytes into cache, usage: " << usage_ << " bytes";
+    }
+}
+
+template<typename ItemObj>
+void
+Cache<ItemObj>::erase(const std::string &key) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    if (!lru_.exists(key)) {
+        return;
+    }
+
+    const ItemObj &old_item = lru_.get(key);
+    usage_ -= old_item->Size();
+
+    SERVER_LOG_DEBUG << "Erase " << key << " size: " << old_item->Size();
+
+    lru_.erase(key);
+}
+
+template<typename ItemObj>
+void
+Cache<ItemObj>::clear() {
+    std::lock_guard<std::mutex> lock(mutex_);
+    lru_.clear();
+    usage_ = 0;
+    SERVER_LOG_DEBUG << "Clear cache !";
+}
+
+/* free memory space when CACHE occupation exceed its capacity */
+template<typename ItemObj>
+void
+Cache<ItemObj>::free_memory() {
+    if (usage_ <= capacity_) return;
+
+    int64_t threshhold = capacity_ * freemem_percent_;
+    int64_t delta_size = usage_ - threshhold;
+    if (delta_size <= 0) {
+        delta_size = 1;//ensure at least one item erased
+    }
+
+    std::set<std::string> key_array;
+    int64_t released_size = 0;
+
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+
+        auto it = lru_.rbegin();
+        while (it != lru_.rend() && released_size < delta_size) {
+            auto &key = it->first;
+            auto &obj_ptr = it->second;
+
+            key_array.emplace(key);
+            released_size += obj_ptr->Size();
+            ++it;
+        }
+    }
+
+    SERVER_LOG_DEBUG << "to be released memory size: " << released_size;
+
+    for (auto &key : key_array) {
+        erase(key);
+    }
+
+    print();
+}
+
+template<typename ItemObj>
+void
+Cache<ItemObj>::print() {
+    size_t cache_count = 0;
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        cache_count = lru_.size();
+    }
+
+    SERVER_LOG_DEBUG << "[Cache item count]: " << cache_count;
+    SERVER_LOG_DEBUG << "[Cache usage]: " << usage_ << " bytes";
+    SERVER_LOG_DEBUG << "[Cache capacity]: " << capacity_ << " bytes";
+}
+
+} // namespace cache
+} // namespace milvus
+
+
diff --git a/core/src/cache/CacheMgr.h b/core/src/cache/CacheMgr.h
new file mode 100644
index 0000000000..f5e04f6509
--- /dev/null
+++ b/core/src/cache/CacheMgr.h
@@ -0,0 +1,73 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "Cache.h"
+#include "metrics/Metrics.h"
+#include "utils/Log.h"
+
+#include <memory>
+#include <string>
+
+namespace milvus {
+namespace cache {
+
+template <typename ItemObj>
+class CacheMgr {
+ public:
+    virtual uint64_t
+    ItemCount() const;
+
+    virtual bool
+    ItemExists(const std::string& key);
+
+    virtual ItemObj
+    GetItem(const std::string& key);
+
+    virtual void
+    InsertItem(const std::string& key, const ItemObj& data);
+
+    virtual void
+    EraseItem(const std::string& key);
+
+    virtual void
+    PrintInfo();
+
+    virtual void
+    ClearCache();
+
+    int64_t
+    CacheUsage() const;
+    int64_t
+    CacheCapacity() const;
+    void
+    SetCapacity(int64_t capacity);
+
+ protected:
+    CacheMgr();
+    virtual ~CacheMgr();
+
+ protected:
+    using CachePtr = std::shared_ptr<Cache<ItemObj>>;
+    CachePtr cache_;
+};
+
+}  // namespace cache
+}  // namespace milvus
+
+#include "cache/CacheMgr.inl"
diff --git a/core/src/cache/CacheMgr.inl b/core/src/cache/CacheMgr.inl
new file mode 100644
index 0000000000..23b2f0df74
--- /dev/null
+++ b/core/src/cache/CacheMgr.inl
@@ -0,0 +1,145 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+
+
+namespace milvus {
+namespace cache {
+
+template<typename ItemObj>
+CacheMgr<ItemObj>::CacheMgr() {
+}
+
+template<typename ItemObj>
+CacheMgr<ItemObj>::~CacheMgr() {
+
+}
+
+template<typename ItemObj>
+uint64_t
+CacheMgr<ItemObj>::ItemCount() const {
+    if (cache_ == nullptr) {
+        SERVER_LOG_ERROR << "Cache doesn't exist";
+        return 0;
+    }
+
+    return (uint64_t) (cache_->size());
+}
+
+template<typename ItemObj>
+bool
+CacheMgr<ItemObj>::ItemExists(const std::string &key) {
+    if (cache_ == nullptr) {
+        SERVER_LOG_ERROR << "Cache doesn't exist";
+        return false;
+    }
+
+    return cache_->exists(key);
+}
+
+template<typename ItemObj>
+ItemObj
+CacheMgr<ItemObj>::GetItem(const std::string &key) {
+    if (cache_ == nullptr) {
+        SERVER_LOG_ERROR << "Cache doesn't exist";
+        return nullptr;
+    }
+    server::Metrics::GetInstance().CacheAccessTotalIncrement();
+    return cache_->get(key);
+}
+
+template<typename ItemObj>
+void
+CacheMgr<ItemObj>::InsertItem(const std::string &key, const ItemObj &data) {
+    if (cache_ == nullptr) {
+        SERVER_LOG_ERROR << "Cache doesn't exist";
+        return;
+    }
+
+    cache_->insert(key, data);
+    server::Metrics::GetInstance().CacheAccessTotalIncrement();
+}
+
+template<typename ItemObj>
+void
+CacheMgr<ItemObj>::EraseItem(const std::string &key) {
+    if (cache_ == nullptr) {
+        SERVER_LOG_ERROR << "Cache doesn't exist";
+        return;
+    }
+
+    cache_->erase(key);
+    server::Metrics::GetInstance().CacheAccessTotalIncrement();
+}
+
+template<typename ItemObj>
+void
+CacheMgr<ItemObj>::PrintInfo() {
+    if (cache_ == nullptr) {
+        SERVER_LOG_ERROR << "Cache doesn't exist";
+        return;
+    }
+
+    cache_->print();
+}
+
+template<typename ItemObj>
+void
+CacheMgr<ItemObj>::ClearCache() {
+    if (cache_ == nullptr) {
+        SERVER_LOG_ERROR << "Cache doesn't exist";
+        return;
+    }
+
+    cache_->clear();
+}
+
+template<typename ItemObj>
+int64_t
+CacheMgr<ItemObj>::CacheUsage() const {
+    if (cache_ == nullptr) {
+        SERVER_LOG_ERROR << "Cache doesn't exist";
+        return 0;
+    }
+
+    return cache_->usage();
+}
+
+template<typename ItemObj>
+int64_t
+CacheMgr<ItemObj>::CacheCapacity() const {
+    if (cache_ == nullptr) {
+        SERVER_LOG_ERROR << "Cache doesn't exist";
+        return 0;
+    }
+
+    return cache_->capacity();
+}
+
+template<typename ItemObj>
+void
+CacheMgr<ItemObj>::SetCapacity(int64_t capacity) {
+    if (cache_ == nullptr) {
+        SERVER_LOG_ERROR << "Cache doesn't exist";
+        return;
+    }
+    cache_->set_capacity(capacity);
+}
+
+} // namespace cache
+} // namespace milvus
+
diff --git a/core/src/cache/CpuCacheMgr.cpp b/core/src/cache/CpuCacheMgr.cpp
new file mode 100644
index 0000000000..1f560cbf8d
--- /dev/null
+++ b/core/src/cache/CpuCacheMgr.cpp
@@ -0,0 +1,69 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "cache/CpuCacheMgr.h"
+#include "server/Config.h"
+#include "utils/Log.h"
+
+#include <utility>
+
+namespace milvus {
+namespace cache {
+
+namespace {
+constexpr int64_t unit = 1024 * 1024 * 1024;
+}
+
+CpuCacheMgr::CpuCacheMgr() {
+    server::Config& config = server::Config::GetInstance();
+    Status s;
+
+    int64_t cpu_cache_cap;
+    s = config.GetCacheConfigCpuCacheCapacity(cpu_cache_cap);
+    if (!s.ok()) {
+        SERVER_LOG_ERROR << s.message();
+    }
+    int64_t cap = cpu_cache_cap * unit;
+    cache_ = std::make_shared<Cache<DataObjPtr>>(cap, 1UL << 32);
+
+    float cpu_cache_threshold;
+    s = config.GetCacheConfigCpuCacheThreshold(cpu_cache_threshold);
+    if (!s.ok()) {
+        SERVER_LOG_ERROR << s.message();
+    }
+    if (cpu_cache_threshold > 0.0 && cpu_cache_threshold <= 1.0) {
+        cache_->set_freemem_percent(cpu_cache_threshold);
+    } else {
+        SERVER_LOG_ERROR << "Invalid cpu_cache_threshold: " << cpu_cache_threshold << ", by default set to "
+                         << cache_->freemem_percent();
+    }
+}
+
+CpuCacheMgr*
+CpuCacheMgr::GetInstance() {
+    static CpuCacheMgr s_mgr;
+    return &s_mgr;
+}
+
+DataObjPtr
+CpuCacheMgr::GetIndex(const std::string& key) {
+    DataObjPtr obj = GetItem(key);
+    return obj;
+}
+
+}  // namespace cache
+}  // namespace milvus
diff --git a/core/src/cache/CpuCacheMgr.h b/core/src/cache/CpuCacheMgr.h
new file mode 100644
index 0000000000..81d529f556
--- /dev/null
+++ b/core/src/cache/CpuCacheMgr.h
@@ -0,0 +1,43 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "CacheMgr.h"
+#include "DataObj.h"
+
+#include <memory>
+#include <string>
+
+namespace milvus {
+namespace cache {
+
+class CpuCacheMgr : public CacheMgr<DataObjPtr> {
+ private:
+    CpuCacheMgr();
+
+ public:
+    // TODO(myh): use smart pointer instead
+    static CpuCacheMgr*
+    GetInstance();
+
+    DataObjPtr
+    GetIndex(const std::string& key);
+};
+
+}  // namespace cache
+}  // namespace milvus
diff --git a/core/src/cache/DataObj.h b/core/src/cache/DataObj.h
new file mode 100644
index 0000000000..fa4959e847
--- /dev/null
+++ b/core/src/cache/DataObj.h
@@ -0,0 +1,34 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <memory>
+
+namespace milvus {
+namespace cache {
+
+class DataObj {
+ public:
+    virtual int64_t
+    Size() = 0;
+};
+
+using DataObjPtr = std::shared_ptr<DataObj>;
+
+}  // namespace cache
+}  // namespace milvus
diff --git a/core/src/cache/GpuCacheMgr.cpp b/core/src/cache/GpuCacheMgr.cpp
new file mode 100644
index 0000000000..d862bc0393
--- /dev/null
+++ b/core/src/cache/GpuCacheMgr.cpp
@@ -0,0 +1,81 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "cache/GpuCacheMgr.h"
+#include "server/Config.h"
+#include "utils/Log.h"
+
+#include <sstream>
+#include <utility>
+
+namespace milvus {
+namespace cache {
+
+std::mutex GpuCacheMgr::mutex_;
+std::unordered_map<uint64_t, GpuCacheMgrPtr> GpuCacheMgr::instance_;
+
+namespace {
+constexpr int64_t G_BYTE = 1024 * 1024 * 1024;
+}
+
+GpuCacheMgr::GpuCacheMgr() {
+    server::Config& config = server::Config::GetInstance();
+    Status s;
+
+    int64_t gpu_cache_cap;
+    s = config.GetCacheConfigGpuCacheCapacity(gpu_cache_cap);
+    if (!s.ok()) {
+        SERVER_LOG_ERROR << s.message();
+    }
+    int64_t cap = gpu_cache_cap * G_BYTE;
+    cache_ = std::make_shared<Cache<DataObjPtr>>(cap, 1UL << 32);
+
+    float gpu_mem_threshold;
+    s = config.GetCacheConfigGpuCacheThreshold(gpu_mem_threshold);
+    if (!s.ok()) {
+        SERVER_LOG_ERROR << s.message();
+    }
+    if (gpu_mem_threshold > 0.0 && gpu_mem_threshold <= 1.0) {
+        cache_->set_freemem_percent(gpu_mem_threshold);
+    } else {
+        SERVER_LOG_ERROR << "Invalid gpu_mem_threshold: " << gpu_mem_threshold << ", by default set to "
+                         << cache_->freemem_percent();
+    }
+}
+
+GpuCacheMgr*
+GpuCacheMgr::GetInstance(uint64_t gpu_id) {
+    if (instance_.find(gpu_id) == instance_.end()) {
+        std::lock_guard<std::mutex> lock(mutex_);
+        if (instance_.find(gpu_id) == instance_.end()) {
+            instance_.insert(std::pair<uint64_t, GpuCacheMgrPtr>(gpu_id, std::make_shared<GpuCacheMgr>()));
+        }
+        return instance_[gpu_id].get();
+    } else {
+        std::lock_guard<std::mutex> lock(mutex_);
+        return instance_[gpu_id].get();
+    }
+}
+
+DataObjPtr
+GpuCacheMgr::GetIndex(const std::string& key) {
+    DataObjPtr obj = GetItem(key);
+    return obj;
+}
+
+}  // namespace cache
+}  // namespace milvus
diff --git a/core/src/cache/GpuCacheMgr.h b/core/src/cache/GpuCacheMgr.h
new file mode 100644
index 0000000000..4d434b2cfb
--- /dev/null
+++ b/core/src/cache/GpuCacheMgr.h
@@ -0,0 +1,47 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "CacheMgr.h"
+#include "DataObj.h"
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+namespace milvus {
+namespace cache {
+
+class GpuCacheMgr;
+using GpuCacheMgrPtr = std::shared_ptr<GpuCacheMgr>;
+
+class GpuCacheMgr : public CacheMgr<DataObjPtr> {
+ public:
+    GpuCacheMgr();
+
+    static GpuCacheMgr*
+    GetInstance(uint64_t gpu_id);
+
+    DataObjPtr
+    GetIndex(const std::string& key);
+
+ private:
+    static std::mutex mutex_;
+    static std::unordered_map<uint64_t, GpuCacheMgrPtr> instance_;
+};
+
+}  // namespace cache
+}  // namespace milvus
diff --git a/core/src/cache/LRU.h b/core/src/cache/LRU.h
new file mode 100644
index 0000000000..9b0eac0608
--- /dev/null
+++ b/core/src/cache/LRU.h
@@ -0,0 +1,122 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <cstddef>
+#include <list>
+#include <stdexcept>
+#include <unordered_map>
+#include <utility>
+
+namespace milvus {
+namespace cache {
+
+template <typename key_t, typename value_t>
+class LRU {
+ public:
+    typedef typename std::pair<key_t, value_t> key_value_pair_t;
+    typedef typename std::list<key_value_pair_t>::iterator list_iterator_t;
+    typedef typename std::list<key_value_pair_t>::reverse_iterator reverse_list_iterator_t;
+
+    explicit LRU(size_t max_size) : max_size_(max_size) {
+    }
+
+    void
+    put(const key_t& key, const value_t& value) {
+        auto it = cache_items_map_.find(key);
+        cache_items_list_.push_front(key_value_pair_t(key, value));
+        if (it != cache_items_map_.end()) {
+            cache_items_list_.erase(it->second);
+            cache_items_map_.erase(it);
+        }
+        cache_items_map_[key] = cache_items_list_.begin();
+
+        if (cache_items_map_.size() > max_size_) {
+            auto last = cache_items_list_.end();
+            last--;
+            cache_items_map_.erase(last->first);
+            cache_items_list_.pop_back();
+        }
+    }
+
+    const value_t&
+    get(const key_t& key) {
+        auto it = cache_items_map_.find(key);
+        if (it == cache_items_map_.end()) {
+            throw std::range_error("There is no such key in cache");
+        } else {
+            cache_items_list_.splice(cache_items_list_.begin(), cache_items_list_, it->second);
+            return it->second->second;
+        }
+    }
+
+    void
+    erase(const key_t& key) {
+        auto it = cache_items_map_.find(key);
+        if (it != cache_items_map_.end()) {
+            cache_items_list_.erase(it->second);
+            cache_items_map_.erase(it);
+        }
+    }
+
+    bool
+    exists(const key_t& key) const {
+        return cache_items_map_.find(key) != cache_items_map_.end();
+    }
+
+    size_t
+    size() const {
+        return cache_items_map_.size();
+    }
+
+    list_iterator_t
+    begin() {
+        iter_ = cache_items_list_.begin();
+        return iter_;
+    }
+
+    list_iterator_t
+    end() {
+        return cache_items_list_.end();
+    }
+
+    reverse_list_iterator_t
+    rbegin() {
+        return cache_items_list_.rbegin();
+    }
+
+    reverse_list_iterator_t
+    rend() {
+        return cache_items_list_.rend();
+    }
+
+    void
+    clear() {
+        cache_items_list_.clear();
+        cache_items_map_.clear();
+    }
+
+ private:
+    std::list<key_value_pair_t> cache_items_list_;
+    std::unordered_map<key_t, list_iterator_t> cache_items_map_;
+    size_t max_size_;
+    list_iterator_t iter_;
+};
+
+}  // namespace cache
+}  // namespace milvus
diff --git a/core/src/config/ConfigMgr.h b/core/src/config/ConfigMgr.h
new file mode 100644
index 0000000000..9d79e07a70
--- /dev/null
+++ b/core/src/config/ConfigMgr.h
@@ -0,0 +1,47 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <string>
+
+#include "ConfigNode.h"
+#include "utils/Status.h"
+
+namespace milvus {
+namespace server {
+
+class ConfigMgr {
+ public:
+    virtual Status
+    LoadConfigFile(const std::string& filename) = 0;
+
+    virtual void
+    Print() const = 0;  // will be deleted
+
+    virtual std::string
+    DumpString() const = 0;
+
+    virtual const ConfigNode&
+    GetRootNode() const = 0;
+
+    virtual ConfigNode&
+    GetRootNode() = 0;
+};
+
+}  // namespace server
+}  // namespace milvus
diff --git a/core/src/config/ConfigNode.cpp b/core/src/config/ConfigNode.cpp
new file mode 100644
index 0000000000..cf148e4d29
--- /dev/null
+++ b/core/src/config/ConfigNode.cpp
@@ -0,0 +1,235 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "config/ConfigNode.h"
+#include "utils/Error.h"
+#include "utils/Log.h"
+
+#include <algorithm>
+#include <sstream>
+#include <string>
+
+namespace milvus {
+namespace server {
+
+void
+ConfigNode::Combine(const ConfigNode& target) {
+    const std::map<std::string, std::string>& kv = target.GetConfig();
+    for (auto itr = kv.begin(); itr != kv.end(); ++itr) {
+        config_[itr->first] = itr->second;
+    }
+
+    const std::map<std::string, std::vector<std::string> >& sequences = target.GetSequences();
+    for (auto itr = sequences.begin(); itr != sequences.end(); ++itr) {
+        sequences_[itr->first] = itr->second;
+    }
+
+    const std::map<std::string, ConfigNode>& children = target.GetChildren();
+    for (auto itr = children.begin(); itr != children.end(); ++itr) {
+        children_[itr->first] = itr->second;
+    }
+}
+
+// key/value pair config
+void
+ConfigNode::SetValue(const std::string& key, const std::string& value) {
+    config_[key] = value;
+}
+
+std::string
+ConfigNode::GetValue(const std::string& param_key, const std::string& default_val) const {
+    auto ref = config_.find(param_key);
+    if (ref != config_.end()) {
+        return ref->second;
+    }
+
+    // THROW_UNEXPECTED_ERROR("Can't find parameter key: " + param_key);
+    return default_val;
+}
+
+bool
+ConfigNode::GetBoolValue(const std::string& param_key, bool default_val) const {
+    std::string val = GetValue(param_key);
+    if (!val.empty()) {
+        std::transform(val.begin(), val.end(), val.begin(), ::tolower);
+        return (val == "true" || val == "on" || val == "yes" || val == "1");
+    } else {
+        return default_val;
+    }
+}
+
+int32_t
+ConfigNode::GetInt32Value(const std::string& param_key, int32_t default_val) const {
+    std::string val = GetValue(param_key);
+    if (!val.empty()) {
+        return (int32_t)std::strtol(val.c_str(), nullptr, 10);
+    } else {
+        return default_val;
+    }
+}
+
+int64_t
+ConfigNode::GetInt64Value(const std::string& param_key, int64_t default_val) const {
+    std::string val = GetValue(param_key);
+    if (!val.empty()) {
+        return std::strtol(val.c_str(), nullptr, 10);
+    } else {
+        return default_val;
+    }
+}
+
+float
+ConfigNode::GetFloatValue(const std::string& param_key, float default_val) const {
+    std::string val = GetValue(param_key);
+    if (!val.empty()) {
+        return std::strtof(val.c_str(), nullptr);
+    } else {
+        return default_val;
+    }
+}
+
+double
+ConfigNode::GetDoubleValue(const std::string& param_key, double default_val) const {
+    std::string val = GetValue(param_key);
+    if (!val.empty()) {
+        return std::strtod(val.c_str(), nullptr);
+    } else {
+        return default_val;
+    }
+}
+
+const std::map<std::string, std::string>&
+ConfigNode::GetConfig() const {
+    return config_;
+}
+
+void
+ConfigNode::ClearConfig() {
+    config_.clear();
+}
+
+// key/object config
+void
+ConfigNode::AddChild(const std::string& type_name, const ConfigNode& config) {
+    children_[type_name] = config;
+}
+
+ConfigNode
+ConfigNode::GetChild(const std::string& type_name) const {
+    auto ref = children_.find(type_name);
+    if (ref != children_.end()) {
+        return ref->second;
+    }
+
+    ConfigNode nc;
+    return nc;
+}
+
+ConfigNode&
+ConfigNode::GetChild(const std::string& type_name) {
+    return children_[type_name];
+}
+
+void
+ConfigNode::GetChildren(ConfigNodeArr& arr) const {
+    arr.clear();
+    for (auto ref : children_) {
+        arr.push_back(ref.second);
+    }
+}
+
+const std::map<std::string, ConfigNode>&
+ConfigNode::GetChildren() const {
+    return children_;
+}
+
+void
+ConfigNode::ClearChildren() {
+    children_.clear();
+}
+
+// key/sequence config
+void
+ConfigNode::AddSequenceItem(const std::string& key, const std::string& item) {
+    sequences_[key].push_back(item);
+}
+
+std::vector<std::string>
+ConfigNode::GetSequence(const std::string& key) const {
+    auto itr = sequences_.find(key);
+    if (itr != sequences_.end()) {
+        return itr->second;
+    } else {
+        std::vector<std::string> temp;
+        return temp;
+    }
+}
+
+const std::map<std::string, std::vector<std::string> >&
+ConfigNode::GetSequences() const {
+    return sequences_;
+}
+
+void
+ConfigNode::ClearSequences() {
+    sequences_.clear();
+}
+
+void
+ConfigNode::PrintAll(const std::string& prefix) const {
+    for (auto& elem : config_) {
+        SERVER_LOG_INFO << prefix << elem.first + ": " << elem.second;
+    }
+
+    for (auto& elem : sequences_) {
+        SERVER_LOG_INFO << prefix << elem.first << ": ";
+        for (auto& str : elem.second) {
+            SERVER_LOG_INFO << prefix << "    - " << str;
+        }
+    }
+
+    for (auto& elem : children_) {
+        SERVER_LOG_INFO << prefix << elem.first << ": ";
+        elem.second.PrintAll(prefix + "    ");
+    }
+}
+
+std::string
+ConfigNode::DumpString(const std::string& prefix) const {
+    std::stringstream str_buffer;
+    const std::string endl = "\n";
+    for (auto& elem : config_) {
+        str_buffer << prefix << elem.first << ": " << elem.second << endl;
+    }
+
+    for (auto& elem : sequences_) {
+        str_buffer << prefix << elem.first << ": " << endl;
+        for (auto& str : elem.second) {
+            str_buffer << prefix + "    - " << str << endl;
+        }
+    }
+
+    for (auto& elem : children_) {
+        str_buffer << prefix << elem.first << ": " << endl;
+        str_buffer << elem.second.DumpString(prefix + "    ") << endl;
+    }
+
+    return str_buffer.str();
+}
+
+}  // namespace server
+}  // namespace milvus
diff --git a/core/src/config/ConfigNode.h b/core/src/config/ConfigNode.h
new file mode 100644
index 0000000000..b7bf2c3af1
--- /dev/null
+++ b/core/src/config/ConfigNode.h
@@ -0,0 +1,95 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <map>
+#include <string>
+#include <vector>
+
+namespace milvus {
+namespace server {
+
+class ConfigNode;
+typedef std::vector<ConfigNode> ConfigNodeArr;
+
+class ConfigNode {
+ public:
+    void
+    Combine(const ConfigNode& target);
+
+    // key/value pair config
+    void
+    SetValue(const std::string& key, const std::string& value);
+
+    std::string
+    GetValue(const std::string& param_key, const std::string& default_val = "") const;
+    bool
+    GetBoolValue(const std::string& param_key, bool default_val = false) const;
+    int32_t
+    GetInt32Value(const std::string& param_key, int32_t default_val = 0) const;
+    int64_t
+    GetInt64Value(const std::string& param_key, int64_t default_val = 0) const;
+    float
+    GetFloatValue(const std::string& param_key, float default_val = 0.0) const;
+    double
+    GetDoubleValue(const std::string& param_key, double default_val = 0.0) const;
+
+    const std::map<std::string, std::string>&
+    GetConfig() const;
+    void
+    ClearConfig();
+
+    // key/object config
+    void
+    AddChild(const std::string& type_name, const ConfigNode& config);
+    ConfigNode
+    GetChild(const std::string& type_name) const;
+    ConfigNode&
+    GetChild(const std::string& type_name);
+    void
+    GetChildren(ConfigNodeArr& arr) const;
+
+    const std::map<std::string, ConfigNode>&
+    GetChildren() const;
+    void
+    ClearChildren();
+
+    // key/sequence config
+    void
+    AddSequenceItem(const std::string& key, const std::string& item);
+    std::vector<std::string>
+    GetSequence(const std::string& key) const;
+
+    const std::map<std::string, std::vector<std::string> >&
+    GetSequences() const;
+    void
+    ClearSequences();
+
+    void
+    PrintAll(const std::string& prefix = "") const;
+    std::string
+    DumpString(const std::string& prefix = "") const;
+
+ private:
+    std::map<std::string, std::string> config_;
+    std::map<std::string, ConfigNode> children_;
+    std::map<std::string, std::vector<std::string> > sequences_;
+};
+
+}  // namespace server
+}  // namespace milvus
diff --git a/core/src/config/YamlConfigMgr.cpp b/core/src/config/YamlConfigMgr.cpp
new file mode 100644
index 0000000000..c84d2cc729
--- /dev/null
+++ b/core/src/config/YamlConfigMgr.cpp
@@ -0,0 +1,108 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "config/YamlConfigMgr.h"
+#include "utils/Log.h"
+
+namespace milvus {
+namespace server {
+
+Status
+YamlConfigMgr::LoadConfigFile(const std::string& filename) {
+    try {
+        node_ = YAML::LoadFile(filename);
+        LoadConfigNode(node_, config_);
+    } catch (YAML::Exception& e) {
+        std::string str = "Exception: load config file fail: " + std::string(e.what());
+        return Status(SERVER_UNEXPECTED_ERROR, str);
+    }
+
+    return Status::OK();
+}
+
+void
+YamlConfigMgr::Print() const {
+    SERVER_LOG_INFO << "System config content:";
+    config_.PrintAll();
+}
+
+std::string
+YamlConfigMgr::DumpString() const {
+    return config_.DumpString("");
+}
+
+const ConfigNode&
+YamlConfigMgr::GetRootNode() const {
+    return config_;
+}
+
+ConfigNode&
+YamlConfigMgr::GetRootNode() {
+    return config_;
+}
+
+bool
+YamlConfigMgr::SetConfigValue(const YAML::Node& node, const std::string& key, ConfigNode& config) {
+    if (node[key].IsDefined()) {
+        config.SetValue(key, node[key].as<std::string>());
+        return true;
+    }
+    return false;
+}
+
+bool
+YamlConfigMgr::SetChildConfig(const YAML::Node& node, const std::string& child_name, ConfigNode& config) {
+    if (node[child_name].IsDefined()) {
+        ConfigNode sub_config;
+        LoadConfigNode(node[child_name], sub_config);
+        config.AddChild(child_name, sub_config);
+        return true;
+    }
+    return false;
+}
+
+bool
+YamlConfigMgr::SetSequence(const YAML::Node& node, const std::string& child_name, ConfigNode& config) {
+    if (node[child_name].IsDefined()) {
+        size_t cnt = node[child_name].size();
+        for (size_t i = 0; i < cnt; i++) {
+            config.AddSequenceItem(child_name, node[child_name][i].as<std::string>());
+        }
+        return true;
+    }
+    return false;
+}
+
+void
+YamlConfigMgr::LoadConfigNode(const YAML::Node& node, ConfigNode& config) {
+    std::string key;
+    for (YAML::const_iterator it = node.begin(); it != node.end(); ++it) {
+        if (!it->first.IsNull()) {
+            key = it->first.as<std::string>();
+        }
+        if (node[key].IsScalar()) {
+            SetConfigValue(node, key, config);
+        } else if (node[key].IsMap()) {
+            SetChildConfig(node, key, config);
+        } else if (node[key].IsSequence()) {
+            SetSequence(node, key, config);
+        }
+    }
+}
+
+}  // namespace server
+}  // namespace milvus
diff --git a/core/src/config/YamlConfigMgr.h b/core/src/config/YamlConfigMgr.h
new file mode 100644
index 0000000000..669e38017a
--- /dev/null
+++ b/core/src/config/YamlConfigMgr.h
@@ -0,0 +1,71 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <yaml-cpp/yaml.h>
+#include <string>
+
+#include "ConfigMgr.h"
+#include "utils/Status.h"
+
+namespace milvus {
+namespace server {
+
+class YamlConfigMgr : public ConfigMgr {
+ public:
+    static ConfigMgr*
+    GetInstance() {
+        static YamlConfigMgr mgr;
+        return &mgr;
+    }
+
+    virtual Status
+    LoadConfigFile(const std::string& filename);
+
+    virtual void
+    Print() const;
+
+    virtual std::string
+    DumpString() const;
+
+    virtual const ConfigNode&
+    GetRootNode() const;
+
+    virtual ConfigNode&
+    GetRootNode();
+
+ private:
+    bool
+    SetConfigValue(const YAML::Node& node, const std::string& key, ConfigNode& config);
+
+    bool
+    SetChildConfig(const YAML::Node& node, const std::string& child_name, ConfigNode& config);
+
+    bool
+    SetSequence(const YAML::Node& node, const std::string& child_name, ConfigNode& config);
+
+    void
+    LoadConfigNode(const YAML::Node& node, ConfigNode& config);
+
+ private:
+    YAML::Node node_;
+    ConfigNode config_;
+};
+
+}  // namespace server
+}  // namespace milvus
diff --git a/core/src/db/Constants.h b/core/src/db/Constants.h
new file mode 100644
index 0000000000..a1e09bc196
--- /dev/null
+++ b/core/src/db/Constants.h
@@ -0,0 +1,39 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <stdint.h>
+
+namespace milvus {
+namespace engine {
+
+constexpr uint64_t K = 1024UL;
+constexpr uint64_t M = K * K;
+constexpr uint64_t G = K * M;
+constexpr uint64_t T = K * G;
+
+constexpr uint64_t MAX_TABLE_FILE_MEM = 128 * M;
+
+constexpr int VECTOR_TYPE_SIZE = sizeof(float);
+
+static constexpr uint64_t ONE_KB = K;
+static constexpr uint64_t ONE_MB = ONE_KB * ONE_KB;
+static constexpr uint64_t ONE_GB = ONE_KB * ONE_MB;
+
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/db/DB.h b/core/src/db/DB.h
new file mode 100644
index 0000000000..a790fadb50
--- /dev/null
+++ b/core/src/db/DB.h
@@ -0,0 +1,97 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "Options.h"
+#include "Types.h"
+#include "meta/Meta.h"
+#include "utils/Status.h"
+
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace milvus {
+namespace engine {
+
+class Env;
+
+class DB {
+ public:
+    DB() = default;
+    DB(const DB&) = delete;
+    DB&
+    operator=(const DB&) = delete;
+
+    virtual ~DB() = default;
+
+    virtual Status
+    Start() = 0;
+    virtual Status
+    Stop() = 0;
+
+    virtual Status
+    CreateTable(meta::TableSchema& table_schema_) = 0;
+    virtual Status
+    DeleteTable(const std::string& table_id, const meta::DatesT& dates) = 0;
+    virtual Status
+    DescribeTable(meta::TableSchema& table_schema_) = 0;
+    virtual Status
+    HasTable(const std::string& table_id, bool& has_or_not_) = 0;
+    virtual Status
+    AllTables(std::vector<meta::TableSchema>& table_schema_array) = 0;
+    virtual Status
+    GetTableRowCount(const std::string& table_id, uint64_t& row_count) = 0;
+    virtual Status
+    PreloadTable(const std::string& table_id) = 0;
+    virtual Status
+    UpdateTableFlag(const std::string& table_id, int64_t flag) = 0;
+
+    virtual Status
+    InsertVectors(const std::string& table_id_, uint64_t n, const float* vectors, IDNumbers& vector_ids_) = 0;
+
+    virtual Status
+    Query(const std::string& table_id, uint64_t k, uint64_t nq, uint64_t nprobe, const float* vectors,
+          QueryResults& results) = 0;
+
+    virtual Status
+    Query(const std::string& table_id, uint64_t k, uint64_t nq, uint64_t nprobe, const float* vectors,
+          const meta::DatesT& dates, QueryResults& results) = 0;
+
+    virtual Status
+    Query(const std::string& table_id, const std::vector<std::string>& file_ids, uint64_t k, uint64_t nq,
+          uint64_t nprobe, const float* vectors, const meta::DatesT& dates, QueryResults& results) = 0;
+
+    virtual Status
+    Size(uint64_t& result) = 0;
+
+    virtual Status
+    CreateIndex(const std::string& table_id, const TableIndex& index) = 0;
+    virtual Status
+    DescribeIndex(const std::string& table_id, TableIndex& index) = 0;
+    virtual Status
+    DropIndex(const std::string& table_id) = 0;
+
+    virtual Status
+    DropAll() = 0;
+};  // DB
+
+using DBPtr = std::shared_ptr<DB>;
+
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/db/DBFactory.cpp b/core/src/db/DBFactory.cpp
new file mode 100644
index 0000000000..fae3a180c0
--- /dev/null
+++ b/core/src/db/DBFactory.cpp
@@ -0,0 +1,48 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "db/DBFactory.h"
+#include "DBImpl.h"
+#include "meta/MetaFactory.h"
+#include "meta/MySQLMetaImpl.h"
+#include "meta/SqliteMetaImpl.h"
+#include "utils/Exception.h"
+
+#include <stdlib.h>
+#include <time.h>
+#include <cstdlib>
+#include <sstream>
+#include <string>
+
+namespace milvus {
+namespace engine {
+
+DBOptions
+DBFactory::BuildOption() {
+    auto meta = MetaFactory::BuildOption();
+    DBOptions options;
+    options.meta_ = meta;
+    return options;
+}
+
+DBPtr
+DBFactory::Build(const DBOptions& options) {
+    return std::make_shared<DBImpl>(options);
+}
+
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/db/DBFactory.h b/core/src/db/DBFactory.h
new file mode 100644
index 0000000000..e787f7c883
--- /dev/null
+++ b/core/src/db/DBFactory.h
@@ -0,0 +1,39 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "DB.h"
+#include "Options.h"
+
+#include <memory>
+#include <string>
+
+namespace milvus {
+namespace engine {
+
+class DBFactory {
+ public:
+    static DBOptions
+    BuildOption();
+
+    static DBPtr
+    Build(const DBOptions& options);
+};
+
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/db/DBImpl.cpp b/core/src/db/DBImpl.cpp
new file mode 100644
index 0000000000..324d304e2a
--- /dev/null
+++ b/core/src/db/DBImpl.cpp
@@ -0,0 +1,776 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "db/DBImpl.h"
+#include "Utils.h"
+#include "cache/CpuCacheMgr.h"
+#include "cache/GpuCacheMgr.h"
+#include "engine/EngineFactory.h"
+#include "insert/MemMenagerFactory.h"
+#include "meta/MetaConsts.h"
+#include "meta/MetaFactory.h"
+#include "meta/SqliteMetaImpl.h"
+#include "metrics/Metrics.h"
+#include "scheduler/SchedInst.h"
+#include "scheduler/job/BuildIndexJob.h"
+#include "scheduler/job/DeleteJob.h"
+#include "scheduler/job/SearchJob.h"
+#include "utils/Log.h"
+#include "utils/TimeRecorder.h"
+
+#include <assert.h>
+#include <algorithm>
+#include <boost/filesystem.hpp>
+#include <chrono>
+#include <cstring>
+#include <iostream>
+#include <thread>
+
+namespace milvus {
+namespace engine {
+
+namespace {
+
+constexpr uint64_t METRIC_ACTION_INTERVAL = 1;
+constexpr uint64_t COMPACT_ACTION_INTERVAL = 1;
+constexpr uint64_t INDEX_ACTION_INTERVAL = 1;
+
+}  // namespace
+
+DBImpl::DBImpl(const DBOptions& options)
+    : options_(options), shutting_down_(true), compact_thread_pool_(1, 1), index_thread_pool_(1, 1) {
+    meta_ptr_ = MetaFactory::Build(options.meta_, options.mode_);
+    mem_mgr_ = MemManagerFactory::Build(meta_ptr_, options_);
+    Start();
+}
+
+DBImpl::~DBImpl() {
+    Stop();
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// external api
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+Status
+DBImpl::Start() {
+    if (!shutting_down_.load(std::memory_order_acquire)) {
+        return Status::OK();
+    }
+
+    ENGINE_LOG_TRACE << "DB service start";
+    shutting_down_.store(false, std::memory_order_release);
+
+    // for distribute version, some nodes are read only
+    if (options_.mode_ != DBOptions::MODE::CLUSTER_READONLY) {
+        ENGINE_LOG_TRACE << "StartTimerTasks";
+        bg_timer_thread_ = std::thread(&DBImpl::BackgroundTimerTask, this);
+    }
+
+    return Status::OK();
+}
+
+Status
+DBImpl::Stop() {
+    if (shutting_down_.load(std::memory_order_acquire)) {
+        return Status::OK();
+    }
+
+    shutting_down_.store(true, std::memory_order_release);
+
+    // makesure all memory data serialized
+    MemSerialize();
+
+    // wait compaction/buildindex finish
+    bg_timer_thread_.join();
+
+    if (options_.mode_ != DBOptions::MODE::CLUSTER_READONLY) {
+        meta_ptr_->CleanUp();
+    }
+
+    ENGINE_LOG_TRACE << "DB service stop";
+    return Status::OK();
+}
+
+Status
+DBImpl::DropAll() {
+    return meta_ptr_->DropAll();
+}
+
+Status
+DBImpl::CreateTable(meta::TableSchema& table_schema) {
+    if (shutting_down_.load(std::memory_order_acquire)) {
+        return Status(DB_ERROR, "Milsvus server is shutdown!");
+    }
+
+    meta::TableSchema temp_schema = table_schema;
+    temp_schema.index_file_size_ *= ONE_MB;  // store as MB
+    return meta_ptr_->CreateTable(temp_schema);
+}
+
+Status
+DBImpl::DeleteTable(const std::string& table_id, const meta::DatesT& dates) {
+    if (shutting_down_.load(std::memory_order_acquire)) {
+        return Status(DB_ERROR, "Milsvus server is shutdown!");
+    }
+
+    // dates partly delete files of the table but currently we don't support
+    ENGINE_LOG_DEBUG << "Prepare to delete table " << table_id;
+
+    if (dates.empty()) {
+        mem_mgr_->EraseMemVector(table_id);  // not allow insert
+        meta_ptr_->DeleteTable(table_id);    // soft delete table
+
+        // scheduler will determine when to delete table files
+        auto nres = scheduler::ResMgrInst::GetInstance()->GetNumOfComputeResource();
+        scheduler::DeleteJobPtr job = std::make_shared<scheduler::DeleteJob>(0, table_id, meta_ptr_, nres);
+        scheduler::JobMgrInst::GetInstance()->Put(job);
+        job->WaitAndDelete();
+    } else {
+        meta_ptr_->DropPartitionsByDates(table_id, dates);
+    }
+
+    return Status::OK();
+}
+
+Status
+DBImpl::DescribeTable(meta::TableSchema& table_schema) {
+    if (shutting_down_.load(std::memory_order_acquire)) {
+        return Status(DB_ERROR, "Milsvus server is shutdown!");
+    }
+
+    auto stat = meta_ptr_->DescribeTable(table_schema);
+    table_schema.index_file_size_ /= ONE_MB;  // return as MB
+    return stat;
+}
+
+Status
+DBImpl::HasTable(const std::string& table_id, bool& has_or_not) {
+    if (shutting_down_.load(std::memory_order_acquire)) {
+        return Status(DB_ERROR, "Milsvus server is shutdown!");
+    }
+
+    return meta_ptr_->HasTable(table_id, has_or_not);
+}
+
+Status
+DBImpl::AllTables(std::vector<meta::TableSchema>& table_schema_array) {
+    if (shutting_down_.load(std::memory_order_acquire)) {
+        return Status(DB_ERROR, "Milsvus server is shutdown!");
+    }
+
+    return meta_ptr_->AllTables(table_schema_array);
+}
+
+Status
+DBImpl::PreloadTable(const std::string& table_id) {
+    if (shutting_down_.load(std::memory_order_acquire)) {
+        return Status(DB_ERROR, "Milsvus server is shutdown!");
+    }
+
+    meta::DatePartionedTableFilesSchema files;
+
+    meta::DatesT dates;
+    std::vector<size_t> ids;
+    auto status = meta_ptr_->FilesToSearch(table_id, ids, dates, files);
+    if (!status.ok()) {
+        return status;
+    }
+
+    int64_t size = 0;
+    int64_t cache_total = cache::CpuCacheMgr::GetInstance()->CacheCapacity();
+    int64_t cache_usage = cache::CpuCacheMgr::GetInstance()->CacheUsage();
+    int64_t available_size = cache_total - cache_usage;
+
+    for (auto& day_files : files) {
+        for (auto& file : day_files.second) {
+            ExecutionEnginePtr engine =
+                EngineFactory::Build(file.dimension_, file.location_, (EngineType)file.engine_type_,
+                                     (MetricType)file.metric_type_, file.nlist_);
+            if (engine == nullptr) {
+                ENGINE_LOG_ERROR << "Invalid engine type";
+                return Status(DB_ERROR, "Invalid engine type");
+            }
+
+            size += engine->PhysicalSize();
+            if (size > available_size) {
+                return Status(SERVER_CACHE_FULL, "Cache is full");
+            } else {
+                try {
+                    // step 1: load index
+                    engine->Load(true);
+                } catch (std::exception& ex) {
+                    std::string msg = "Pre-load table encounter exception: " + std::string(ex.what());
+                    ENGINE_LOG_ERROR << msg;
+                    return Status(DB_ERROR, msg);
+                }
+            }
+        }
+    }
+    return Status::OK();
+}
+
+Status
+DBImpl::UpdateTableFlag(const std::string& table_id, int64_t flag) {
+    if (shutting_down_.load(std::memory_order_acquire)) {
+        return Status(DB_ERROR, "Milsvus server is shutdown!");
+    }
+
+    return meta_ptr_->UpdateTableFlag(table_id, flag);
+}
+
+Status
+DBImpl::GetTableRowCount(const std::string& table_id, uint64_t& row_count) {
+    if (shutting_down_.load(std::memory_order_acquire)) {
+        return Status(DB_ERROR, "Milsvus server is shutdown!");
+    }
+
+    return meta_ptr_->Count(table_id, row_count);
+}
+
+Status
+DBImpl::InsertVectors(const std::string& table_id, uint64_t n, const float* vectors, IDNumbers& vector_ids) {
+    //    ENGINE_LOG_DEBUG << "Insert " << n << " vectors to cache";
+    if (shutting_down_.load(std::memory_order_acquire)) {
+        return Status(DB_ERROR, "Milsvus server is shutdown!");
+    }
+
+    Status status;
+    milvus::server::CollectInsertMetrics metrics(n, status);
+    status = mem_mgr_->InsertVectors(table_id, n, vectors, vector_ids);
+
+    return status;
+}
+
+Status
+DBImpl::CreateIndex(const std::string& table_id, const TableIndex& index) {
+    {
+        std::unique_lock<std::mutex> lock(build_index_mutex_);
+
+        // step 1: check index difference
+        TableIndex old_index;
+        auto status = DescribeIndex(table_id, old_index);
+        if (!status.ok()) {
+            ENGINE_LOG_ERROR << "Failed to get table index info for table: " << table_id;
+            return status;
+        }
+
+        // step 2: update index info
+        TableIndex new_index = index;
+        new_index.metric_type_ = old_index.metric_type_;  // dont change metric type, it was defined by CreateTable
+        if (!utils::IsSameIndex(old_index, new_index)) {
+            DropIndex(table_id);
+
+            status = meta_ptr_->UpdateTableIndex(table_id, new_index);
+            if (!status.ok()) {
+                ENGINE_LOG_ERROR << "Failed to update table index info for table: " << table_id;
+                return status;
+            }
+        }
+    }
+
+    // step 3: let merge file thread finish
+    // to avoid duplicate data bug
+    WaitMergeFileFinish();
+
+    // step 4: wait and build index
+    // for IDMAP type, only wait all NEW file converted to RAW file
+    // for other type, wait NEW/RAW/NEW_MERGE/NEW_INDEX/TO_INDEX files converted to INDEX files
+    std::vector<int> file_types;
+    if (index.engine_type_ == static_cast<int32_t>(EngineType::FAISS_IDMAP)) {
+        file_types = {
+            static_cast<int32_t>(meta::TableFileSchema::NEW),
+            static_cast<int32_t>(meta::TableFileSchema::NEW_MERGE),
+        };
+    } else {
+        file_types = {
+            static_cast<int32_t>(meta::TableFileSchema::RAW),
+            static_cast<int32_t>(meta::TableFileSchema::NEW),
+            static_cast<int32_t>(meta::TableFileSchema::NEW_MERGE),
+            static_cast<int32_t>(meta::TableFileSchema::NEW_INDEX),
+            static_cast<int32_t>(meta::TableFileSchema::TO_INDEX),
+        };
+    }
+
+    std::vector<std::string> file_ids;
+    auto status = meta_ptr_->FilesByType(table_id, file_types, file_ids);
+    int times = 1;
+
+    while (!file_ids.empty()) {
+        ENGINE_LOG_DEBUG << "Non index files detected! Will build index " << times;
+        if (index.engine_type_ != (int)EngineType::FAISS_IDMAP) {
+            status = meta_ptr_->UpdateTableFilesToIndex(table_id);
+        }
+
+        std::this_thread::sleep_for(std::chrono::milliseconds(std::min(10 * 1000, times * 100)));
+        status = meta_ptr_->FilesByType(table_id, file_types, file_ids);
+        times++;
+    }
+
+    return Status::OK();
+}
+
+Status
+DBImpl::DescribeIndex(const std::string& table_id, TableIndex& index) {
+    return meta_ptr_->DescribeTableIndex(table_id, index);
+}
+
+Status
+DBImpl::DropIndex(const std::string& table_id) {
+    ENGINE_LOG_DEBUG << "Drop index for table: " << table_id;
+    return meta_ptr_->DropTableIndex(table_id);
+}
+
+Status
+DBImpl::Query(const std::string& table_id, uint64_t k, uint64_t nq, uint64_t nprobe, const float* vectors,
+              QueryResults& results) {
+    if (shutting_down_.load(std::memory_order_acquire)) {
+        return Status(DB_ERROR, "Milsvus server is shutdown!");
+    }
+
+    meta::DatesT dates = {utils::GetDate()};
+    Status result = Query(table_id, k, nq, nprobe, vectors, dates, results);
+
+    return result;
+}
+
+Status
+DBImpl::Query(const std::string& table_id, uint64_t k, uint64_t nq, uint64_t nprobe, const float* vectors,
+              const meta::DatesT& dates, QueryResults& results) {
+    if (shutting_down_.load(std::memory_order_acquire)) {
+        return Status(DB_ERROR, "Milsvus server is shutdown!");
+    }
+
+    ENGINE_LOG_DEBUG << "Query by dates for table: " << table_id << " date range count: " << dates.size();
+
+    // get all table files from table
+    meta::DatePartionedTableFilesSchema files;
+    std::vector<size_t> ids;
+    auto status = meta_ptr_->FilesToSearch(table_id, ids, dates, files);
+    if (!status.ok()) {
+        return status;
+    }
+
+    meta::TableFilesSchema file_id_array;
+    for (auto& day_files : files) {
+        for (auto& file : day_files.second) {
+            file_id_array.push_back(file);
+        }
+    }
+
+    cache::CpuCacheMgr::GetInstance()->PrintInfo();  // print cache info before query
+    status = QueryAsync(table_id, file_id_array, k, nq, nprobe, vectors, results);
+    cache::CpuCacheMgr::GetInstance()->PrintInfo();  // print cache info after query
+    return status;
+}
+
+Status
+DBImpl::Query(const std::string& table_id, const std::vector<std::string>& file_ids, uint64_t k, uint64_t nq,
+              uint64_t nprobe, const float* vectors, const meta::DatesT& dates, QueryResults& results) {
+    if (shutting_down_.load(std::memory_order_acquire)) {
+        return Status(DB_ERROR, "Milsvus server is shutdown!");
+    }
+
+    ENGINE_LOG_DEBUG << "Query by file ids for table: " << table_id << " date range count: " << dates.size();
+
+    // get specified files
+    std::vector<size_t> ids;
+    for (auto& id : file_ids) {
+        meta::TableFileSchema table_file;
+        table_file.table_id_ = table_id;
+        std::string::size_type sz;
+        ids.push_back(std::stoul(id, &sz));
+    }
+
+    meta::DatePartionedTableFilesSchema files_array;
+    auto status = meta_ptr_->FilesToSearch(table_id, ids, dates, files_array);
+    if (!status.ok()) {
+        return status;
+    }
+
+    meta::TableFilesSchema file_id_array;
+    for (auto& day_files : files_array) {
+        for (auto& file : day_files.second) {
+            file_id_array.push_back(file);
+        }
+    }
+
+    if (file_id_array.empty()) {
+        return Status(DB_ERROR, "Invalid file id");
+    }
+
+    cache::CpuCacheMgr::GetInstance()->PrintInfo();  // print cache info before query
+    status = QueryAsync(table_id, file_id_array, k, nq, nprobe, vectors, results);
+    cache::CpuCacheMgr::GetInstance()->PrintInfo();  // print cache info after query
+    return status;
+}
+
+Status
+DBImpl::Size(uint64_t& result) {
+    if (shutting_down_.load(std::memory_order_acquire)) {
+        return Status(DB_ERROR, "Milsvus server is shutdown!");
+    }
+
+    return meta_ptr_->Size(result);
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// internal methods
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+Status
+DBImpl::QueryAsync(const std::string& table_id, const meta::TableFilesSchema& files, uint64_t k, uint64_t nq,
+                   uint64_t nprobe, const float* vectors, QueryResults& results) {
+    server::CollectQueryMetrics metrics(nq);
+
+    TimeRecorder rc("");
+
+    // step 1: get files to search
+    ENGINE_LOG_DEBUG << "Engine query begin, index file count: " << files.size();
+    scheduler::SearchJobPtr job = std::make_shared<scheduler::SearchJob>(0, k, nq, nprobe, vectors);
+    for (auto& file : files) {
+        scheduler::TableFileSchemaPtr file_ptr = std::make_shared<meta::TableFileSchema>(file);
+        job->AddIndexFile(file_ptr);
+    }
+
+    // step 2: put search task to scheduler
+    scheduler::JobMgrInst::GetInstance()->Put(job);
+    job->WaitResult();
+    if (!job->GetStatus().ok()) {
+        return job->GetStatus();
+    }
+
+    // step 3: construct results
+    results = job->GetResult();
+    rc.ElapseFromBegin("Engine query totally cost");
+
+    return Status::OK();
+}
+
+void
+DBImpl::BackgroundTimerTask() {
+    Status status;
+    server::SystemInfo::GetInstance().Init();
+    while (true) {
+        if (shutting_down_.load(std::memory_order_acquire)) {
+            WaitMergeFileFinish();
+            WaitBuildIndexFinish();
+
+            ENGINE_LOG_DEBUG << "DB background thread exit";
+            break;
+        }
+
+        std::this_thread::sleep_for(std::chrono::seconds(1));
+
+        StartMetricTask();
+        StartCompactionTask();
+        StartBuildIndexTask();
+    }
+}
+
+void
+DBImpl::WaitMergeFileFinish() {
+    std::lock_guard<std::mutex> lck(compact_result_mutex_);
+    for (auto& iter : compact_thread_results_) {
+        iter.wait();
+    }
+}
+
+void
+DBImpl::WaitBuildIndexFinish() {
+    std::lock_guard<std::mutex> lck(index_result_mutex_);
+    for (auto& iter : index_thread_results_) {
+        iter.wait();
+    }
+}
+
+void
+DBImpl::StartMetricTask() {
+    static uint64_t metric_clock_tick = 0;
+    metric_clock_tick++;
+    if (metric_clock_tick % METRIC_ACTION_INTERVAL != 0) {
+        return;
+    }
+
+    ENGINE_LOG_TRACE << "Start metric task";
+
+    server::Metrics::GetInstance().KeepingAliveCounterIncrement(METRIC_ACTION_INTERVAL);
+    int64_t cache_usage = cache::CpuCacheMgr::GetInstance()->CacheUsage();
+    int64_t cache_total = cache::CpuCacheMgr::GetInstance()->CacheCapacity();
+    if (cache_total > 0) {
+        double cache_usage_double = cache_usage;
+        server::Metrics::GetInstance().CpuCacheUsageGaugeSet(cache_usage_double * 100 / cache_total);
+    } else {
+        server::Metrics::GetInstance().CpuCacheUsageGaugeSet(0);
+    }
+
+    server::Metrics::GetInstance().GpuCacheUsageGaugeSet();
+    uint64_t size;
+    Size(size);
+    server::Metrics::GetInstance().DataFileSizeGaugeSet(size);
+    server::Metrics::GetInstance().CPUUsagePercentSet();
+    server::Metrics::GetInstance().RAMUsagePercentSet();
+    server::Metrics::GetInstance().GPUPercentGaugeSet();
+    server::Metrics::GetInstance().GPUMemoryUsageGaugeSet();
+    server::Metrics::GetInstance().OctetsSet();
+
+    server::Metrics::GetInstance().CPUCoreUsagePercentSet();
+    server::Metrics::GetInstance().GPUTemperature();
+    server::Metrics::GetInstance().CPUTemperature();
+
+    ENGINE_LOG_TRACE << "Metric task finished";
+}
+
+Status
+DBImpl::MemSerialize() {
+    std::lock_guard<std::mutex> lck(mem_serialize_mutex_);
+    std::set<std::string> temp_table_ids;
+    mem_mgr_->Serialize(temp_table_ids);
+    for (auto& id : temp_table_ids) {
+        compact_table_ids_.insert(id);
+    }
+
+    if (!temp_table_ids.empty()) {
+        SERVER_LOG_DEBUG << "Insert cache serialized";
+    }
+
+    return Status::OK();
+}
+
+void
+DBImpl::StartCompactionTask() {
+    static uint64_t compact_clock_tick = 0;
+    compact_clock_tick++;
+    if (compact_clock_tick % COMPACT_ACTION_INTERVAL != 0) {
+        return;
+    }
+
+    // serialize memory data
+    MemSerialize();
+
+    // compactiong has been finished?
+    {
+        std::lock_guard<std::mutex> lck(compact_result_mutex_);
+        if (!compact_thread_results_.empty()) {
+            std::chrono::milliseconds span(10);
+            if (compact_thread_results_.back().wait_for(span) == std::future_status::ready) {
+                compact_thread_results_.pop_back();
+            }
+        }
+    }
+
+    // add new compaction task
+    {
+        std::lock_guard<std::mutex> lck(compact_result_mutex_);
+        if (compact_thread_results_.empty()) {
+            compact_thread_results_.push_back(
+                compact_thread_pool_.enqueue(&DBImpl::BackgroundCompaction, this, compact_table_ids_));
+            compact_table_ids_.clear();
+        }
+    }
+}
+
+Status
+DBImpl::MergeFiles(const std::string& table_id, const meta::DateT& date, const meta::TableFilesSchema& files) {
+    ENGINE_LOG_DEBUG << "Merge files for table: " << table_id;
+
+    // step 1: create table file
+    meta::TableFileSchema table_file;
+    table_file.table_id_ = table_id;
+    table_file.date_ = date;
+    table_file.file_type_ = meta::TableFileSchema::NEW_MERGE;
+    Status status = meta_ptr_->CreateTableFile(table_file);
+
+    if (!status.ok()) {
+        ENGINE_LOG_ERROR << "Failed to create table: " << status.ToString();
+        return status;
+    }
+
+    // step 2: merge files
+    ExecutionEnginePtr index =
+        EngineFactory::Build(table_file.dimension_, table_file.location_, (EngineType)table_file.engine_type_,
+                             (MetricType)table_file.metric_type_, table_file.nlist_);
+
+    meta::TableFilesSchema updated;
+    int64_t index_size = 0;
+
+    for (auto& file : files) {
+        server::CollectMergeFilesMetrics metrics;
+
+        index->Merge(file.location_);
+        auto file_schema = file;
+        file_schema.file_type_ = meta::TableFileSchema::TO_DELETE;
+        updated.push_back(file_schema);
+        ENGINE_LOG_DEBUG << "Merging file " << file_schema.file_id_;
+        index_size = index->Size();
+
+        if (index_size >= file_schema.index_file_size_) {
+            break;
+        }
+    }
+
+    // step 3: serialize to disk
+    try {
+        index->Serialize();
+    } catch (std::exception& ex) {
+        // typical error: out of disk space or permition denied
+        std::string msg = "Serialize merged index encounter exception: " + std::string(ex.what());
+        ENGINE_LOG_ERROR << msg;
+
+        table_file.file_type_ = meta::TableFileSchema::TO_DELETE;
+        status = meta_ptr_->UpdateTableFile(table_file);
+        ENGINE_LOG_DEBUG << "Failed to update file to index, mark file: " << table_file.file_id_ << " to to_delete";
+
+        std::cout << "ERROR: failed to persist merged index file: " << table_file.location_
+                  << ", possible out of disk space" << std::endl;
+
+        return Status(DB_ERROR, msg);
+    }
+
+    // step 4: update table files state
+    // if index type isn't IDMAP, set file type to TO_INDEX if file size execeed index_file_size
+    // else set file type to RAW, no need to build index
+    if (table_file.engine_type_ != (int)EngineType::FAISS_IDMAP) {
+        table_file.file_type_ = (index->PhysicalSize() >= table_file.index_file_size_) ? meta::TableFileSchema::TO_INDEX
+                                                                                       : meta::TableFileSchema::RAW;
+    } else {
+        table_file.file_type_ = meta::TableFileSchema::RAW;
+    }
+    table_file.file_size_ = index->PhysicalSize();
+    table_file.row_count_ = index->Count();
+    updated.push_back(table_file);
+    status = meta_ptr_->UpdateTableFiles(updated);
+    ENGINE_LOG_DEBUG << "New merged file " << table_file.file_id_ << " of size " << index->PhysicalSize() << " bytes";
+
+    if (options_.insert_cache_immediately_) {
+        index->Cache();
+    }
+
+    return status;
+}
+
+Status
+DBImpl::BackgroundMergeFiles(const std::string& table_id) {
+    meta::DatePartionedTableFilesSchema raw_files;
+    auto status = meta_ptr_->FilesToMerge(table_id, raw_files);
+    if (!status.ok()) {
+        ENGINE_LOG_ERROR << "Failed to get merge files for table: " << table_id;
+        return status;
+    }
+
+    for (auto& kv : raw_files) {
+        auto files = kv.second;
+        if (files.size() < options_.merge_trigger_number_) {
+            ENGINE_LOG_DEBUG << "Files number not greater equal than merge trigger number, skip merge action";
+            continue;
+        }
+
+        MergeFiles(table_id, kv.first, kv.second);
+
+        if (shutting_down_.load(std::memory_order_acquire)) {
+            ENGINE_LOG_DEBUG << "Server will shutdown, skip merge action for table: " << table_id;
+            break;
+        }
+    }
+
+    return Status::OK();
+}
+
+void
+DBImpl::BackgroundCompaction(std::set<std::string> table_ids) {
+    ENGINE_LOG_TRACE << " Background compaction thread start";
+
+    Status status;
+    for (auto& table_id : table_ids) {
+        status = BackgroundMergeFiles(table_id);
+        if (!status.ok()) {
+            ENGINE_LOG_ERROR << "Merge files for table " << table_id << " failed: " << status.ToString();
+        }
+
+        if (shutting_down_.load(std::memory_order_acquire)) {
+            ENGINE_LOG_DEBUG << "Server will shutdown, skip merge action";
+            break;
+        }
+    }
+
+    meta_ptr_->Archive();
+
+    int ttl = 5 * meta::M_SEC;  // default: file will be deleted after 5 minutes
+    if (options_.mode_ == DBOptions::MODE::CLUSTER_WRITABLE) {
+        ttl = meta::D_SEC;
+    }
+    meta_ptr_->CleanUpFilesWithTTL(ttl);
+
+    ENGINE_LOG_TRACE << " Background compaction thread exit";
+}
+
+void
+DBImpl::StartBuildIndexTask(bool force) {
+    static uint64_t index_clock_tick = 0;
+    index_clock_tick++;
+    if (!force && (index_clock_tick % INDEX_ACTION_INTERVAL != 0)) {
+        return;
+    }
+
+    // build index has been finished?
+    {
+        std::lock_guard<std::mutex> lck(index_result_mutex_);
+        if (!index_thread_results_.empty()) {
+            std::chrono::milliseconds span(10);
+            if (index_thread_results_.back().wait_for(span) == std::future_status::ready) {
+                index_thread_results_.pop_back();
+            }
+        }
+    }
+
+    // add new build index task
+    {
+        std::lock_guard<std::mutex> lck(index_result_mutex_);
+        if (index_thread_results_.empty()) {
+            index_thread_results_.push_back(index_thread_pool_.enqueue(&DBImpl::BackgroundBuildIndex, this));
+        }
+    }
+}
+
+void
+DBImpl::BackgroundBuildIndex() {
+    ENGINE_LOG_TRACE << "Background build index thread start";
+
+    std::unique_lock<std::mutex> lock(build_index_mutex_);
+    meta::TableFilesSchema to_index_files;
+    meta_ptr_->FilesToIndex(to_index_files);
+    Status status;
+
+    if (!to_index_files.empty()) {
+        scheduler::BuildIndexJobPtr job = std::make_shared<scheduler::BuildIndexJob>(0, meta_ptr_, options_);
+
+        // step 2: put build index task to scheduler
+        for (auto& file : to_index_files) {
+            scheduler::TableFileSchemaPtr file_ptr = std::make_shared<meta::TableFileSchema>(file);
+            job->AddToIndexFiles(file_ptr);
+        }
+        scheduler::JobMgrInst::GetInstance()->Put(job);
+        job->WaitBuildIndexFinish();
+        if (!job->GetStatus().ok()) {
+            Status status = job->GetStatus();
+            ENGINE_LOG_ERROR << "Building index failed: " << status.ToString();
+        }
+    }
+
+    ENGINE_LOG_TRACE << "Background build index thread exit";
+}
+
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/db/DBImpl.h b/core/src/db/DBImpl.h
new file mode 100644
index 0000000000..e1e030cc32
--- /dev/null
+++ b/core/src/db/DBImpl.h
@@ -0,0 +1,163 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "DB.h"
+#include "Types.h"
+#include "src/db/insert/MemManager.h"
+#include "utils/ThreadPool.h"
+
+#include <atomic>
+#include <condition_variable>
+#include <list>
+#include <memory>
+#include <mutex>
+#include <set>
+#include <string>
+#include <thread>
+#include <vector>
+
+namespace milvus {
+namespace engine {
+
+class Env;
+
+namespace meta {
+class Meta;
+}
+
+class DBImpl : public DB {
+ public:
+    explicit DBImpl(const DBOptions& options);
+    ~DBImpl();
+
+    Status
+    Start() override;
+    Status
+    Stop() override;
+    Status
+    DropAll() override;
+
+    Status
+    CreateTable(meta::TableSchema& table_schema) override;
+
+    Status
+    DeleteTable(const std::string& table_id, const meta::DatesT& dates) override;
+
+    Status
+    DescribeTable(meta::TableSchema& table_schema) override;
+
+    Status
+    HasTable(const std::string& table_id, bool& has_or_not) override;
+
+    Status
+    AllTables(std::vector<meta::TableSchema>& table_schema_array) override;
+
+    Status
+    PreloadTable(const std::string& table_id) override;
+
+    Status
+    UpdateTableFlag(const std::string& table_id, int64_t flag);
+
+    Status
+    GetTableRowCount(const std::string& table_id, uint64_t& row_count) override;
+
+    Status
+    InsertVectors(const std::string& table_id, uint64_t n, const float* vectors, IDNumbers& vector_ids) override;
+
+    Status
+    CreateIndex(const std::string& table_id, const TableIndex& index) override;
+
+    Status
+    DescribeIndex(const std::string& table_id, TableIndex& index) override;
+
+    Status
+    DropIndex(const std::string& table_id) override;
+
+    Status
+    Query(const std::string& table_id, uint64_t k, uint64_t nq, uint64_t nprobe, const float* vectors,
+          QueryResults& results) override;
+
+    Status
+    Query(const std::string& table_id, uint64_t k, uint64_t nq, uint64_t nprobe, const float* vectors,
+          const meta::DatesT& dates, QueryResults& results) override;
+
+    Status
+    Query(const std::string& table_id, const std::vector<std::string>& file_ids, uint64_t k, uint64_t nq,
+          uint64_t nprobe, const float* vectors, const meta::DatesT& dates, QueryResults& results) override;
+
+    Status
+    Size(uint64_t& result) override;
+
+ private:
+    Status
+    QueryAsync(const std::string& table_id, const meta::TableFilesSchema& files, uint64_t k, uint64_t nq,
+               uint64_t nprobe, const float* vectors, QueryResults& results);
+
+    void
+    BackgroundTimerTask();
+    void
+    WaitMergeFileFinish();
+    void
+    WaitBuildIndexFinish();
+
+    void
+    StartMetricTask();
+
+    void
+    StartCompactionTask();
+    Status
+    MergeFiles(const std::string& table_id, const meta::DateT& date, const meta::TableFilesSchema& files);
+    Status
+    BackgroundMergeFiles(const std::string& table_id);
+    void
+    BackgroundCompaction(std::set<std::string> table_ids);
+
+    void
+    StartBuildIndexTask(bool force = false);
+    void
+    BackgroundBuildIndex();
+
+    Status
+    MemSerialize();
+
+ private:
+    const DBOptions options_;
+
+    std::atomic<bool> shutting_down_;
+
+    std::thread bg_timer_thread_;
+
+    meta::MetaPtr meta_ptr_;
+    MemManagerPtr mem_mgr_;
+    std::mutex mem_serialize_mutex_;
+
+    ThreadPool compact_thread_pool_;
+    std::mutex compact_result_mutex_;
+    std::list<std::future<void>> compact_thread_results_;
+    std::set<std::string> compact_table_ids_;
+
+    ThreadPool index_thread_pool_;
+    std::mutex index_result_mutex_;
+    std::list<std::future<void>> index_thread_results_;
+
+    std::mutex build_index_mutex_;
+};  // DBImpl
+
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/db/IDGenerator.cpp b/core/src/db/IDGenerator.cpp
new file mode 100644
index 0000000000..6b150a926a
--- /dev/null
+++ b/core/src/db/IDGenerator.cpp
@@ -0,0 +1,65 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "db/IDGenerator.h"
+
+#include <assert.h>
+#include <chrono>
+#include <iostream>
+
+namespace milvus {
+namespace engine {
+
+IDGenerator::~IDGenerator() = default;
+
+constexpr size_t SimpleIDGenerator::MAX_IDS_PER_MICRO;
+
+IDNumber
+SimpleIDGenerator::GetNextIDNumber() {
+    auto now = std::chrono::system_clock::now();
+    auto micros = std::chrono::duration_cast<std::chrono::microseconds>(now.time_since_epoch()).count();
+    return micros * MAX_IDS_PER_MICRO;
+}
+
+void
+SimpleIDGenerator::NextIDNumbers(size_t n, IDNumbers& ids) {
+    if (n > MAX_IDS_PER_MICRO) {
+        NextIDNumbers(n - MAX_IDS_PER_MICRO, ids);
+        NextIDNumbers(MAX_IDS_PER_MICRO, ids);
+        return;
+    }
+    if (n <= 0) {
+        return;
+    }
+
+    auto now = std::chrono::system_clock::now();
+    auto micros = std::chrono::duration_cast<std::chrono::microseconds>(now.time_since_epoch()).count();
+    micros *= MAX_IDS_PER_MICRO;
+
+    for (int pos = 0; pos < n; ++pos) {
+        ids.push_back(micros + pos);
+    }
+}
+
+void
+SimpleIDGenerator::GetNextIDNumbers(size_t n, IDNumbers& ids) {
+    ids.clear();
+    NextIDNumbers(n, ids);
+}
+
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/db/IDGenerator.h b/core/src/db/IDGenerator.h
new file mode 100644
index 0000000000..cdd22efc1a
--- /dev/null
+++ b/core/src/db/IDGenerator.h
@@ -0,0 +1,57 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "Types.h"
+
+#include <cstddef>
+#include <vector>
+
+namespace milvus {
+namespace engine {
+
+class IDGenerator {
+ public:
+    virtual IDNumber
+    GetNextIDNumber() = 0;
+
+    virtual void
+    GetNextIDNumbers(size_t n, IDNumbers& ids) = 0;
+
+    virtual ~IDGenerator() = 0;
+};  // IDGenerator
+
+class SimpleIDGenerator : public IDGenerator {
+ public:
+    ~SimpleIDGenerator() override = default;
+
+    IDNumber
+    GetNextIDNumber() override;
+
+    void
+    GetNextIDNumbers(size_t n, IDNumbers& ids) override;
+
+ private:
+    void
+    NextIDNumbers(size_t n, IDNumbers& ids);
+
+    static constexpr size_t MAX_IDS_PER_MICRO = 1000;
+};  // SimpleIDGenerator
+
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/db/Options.cpp b/core/src/db/Options.cpp
new file mode 100644
index 0000000000..9d6a7d0236
--- /dev/null
+++ b/core/src/db/Options.cpp
@@ -0,0 +1,92 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "db/Options.h"
+#include "utils/Exception.h"
+#include "utils/Log.h"
+
+#include <assert.h>
+#include <stdlib.h>
+#include <boost/algorithm/string.hpp>
+
+namespace milvus {
+namespace engine {
+
+ArchiveConf::ArchiveConf(const std::string& type, const std::string& criterias) {
+    ParseType(type);
+    ParseCritirias(criterias);
+}
+
+void
+ArchiveConf::SetCriterias(const ArchiveConf::CriteriaT& criterial) {
+    for (auto& pair : criterial) {
+        criterias_[pair.first] = pair.second;
+    }
+}
+
+void
+ArchiveConf::ParseCritirias(const std::string& criterias) {
+    std::stringstream ss(criterias);
+    std::vector<std::string> tokens;
+
+    boost::algorithm::split(tokens, criterias, boost::is_any_of(";"));
+
+    if (tokens.size() == 0) {
+        return;
+    }
+
+    for (auto& token : tokens) {
+        if (token.empty()) {
+            continue;
+        }
+
+        std::vector<std::string> kv;
+        boost::algorithm::split(kv, token, boost::is_any_of(":"));
+        if (kv.size() != 2) {
+            ENGINE_LOG_WARNING << "Invalid ArchiveConf Criterias: " << token << " Ignore!";
+            continue;
+        }
+        if (kv[0] != "disk" && kv[0] != "days") {
+            ENGINE_LOG_WARNING << "Invalid ArchiveConf Criterias: " << token << " Ignore!";
+            continue;
+        }
+        try {
+            auto value = std::stoi(kv[1]);
+            criterias_[kv[0]] = value;
+        } catch (std::out_of_range&) {
+            std::string msg = "Out of range: '" + kv[1] + "'";
+            ENGINE_LOG_ERROR << msg;
+            throw InvalidArgumentException(msg);
+        } catch (...) {
+            std::string msg = "Invalid argument: '" + kv[1] + "'";
+            ENGINE_LOG_ERROR << msg;
+            throw InvalidArgumentException(msg);
+        }
+    }
+}
+
+void
+ArchiveConf::ParseType(const std::string& type) {
+    if (type != "delete" && type != "swap") {
+        std::string msg = "Invalid argument: type='" + type + "'";
+        throw InvalidArgumentException(msg);
+    }
+    type_ = type;
+}
+
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/db/Options.h b/core/src/db/Options.h
new file mode 100644
index 0000000000..ebecb4de5a
--- /dev/null
+++ b/core/src/db/Options.h
@@ -0,0 +1,82 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "Constants.h"
+
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace milvus {
+namespace engine {
+
+class Env;
+
+static const char* ARCHIVE_CONF_DISK = "disk";
+static const char* ARCHIVE_CONF_DAYS = "days";
+
+struct ArchiveConf {
+    using CriteriaT = std::map<std::string, int>;
+
+    explicit ArchiveConf(const std::string& type, const std::string& criterias = std::string());
+
+    const std::string&
+    GetType() const {
+        return type_;
+    }
+
+    const CriteriaT
+    GetCriterias() const {
+        return criterias_;
+    }
+
+    void
+    SetCriterias(const ArchiveConf::CriteriaT& criterial);
+
+ private:
+    void
+    ParseCritirias(const std::string& criterias);
+    void
+    ParseType(const std::string& type);
+
+    std::string type_;
+    CriteriaT criterias_;
+};
+
+struct DBMetaOptions {
+    std::string path_;
+    std::vector<std::string> slave_paths_;
+    std::string backend_uri_;
+    ArchiveConf archive_conf_ = ArchiveConf("delete");
+};  // DBMetaOptions
+
+struct DBOptions {
+    typedef enum { SINGLE = 0, CLUSTER_READONLY, CLUSTER_WRITABLE } MODE;
+
+    uint16_t merge_trigger_number_ = 2;
+    DBMetaOptions meta_;
+    int mode_ = MODE::SINGLE;
+
+    size_t insert_buffer_size_ = 4 * ONE_GB;
+    bool insert_cache_immediately_ = false;
+};  // Options
+
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/db/Types.h b/core/src/db/Types.h
new file mode 100644
index 0000000000..94528a9a8a
--- /dev/null
+++ b/core/src/db/Types.h
@@ -0,0 +1,43 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "db/engine/ExecutionEngine.h"
+
+#include <stdint.h>
+#include <utility>
+#include <vector>
+
+namespace milvus {
+namespace engine {
+
+typedef int64_t IDNumber;
+typedef IDNumber* IDNumberPtr;
+typedef std::vector<IDNumber> IDNumbers;
+
+typedef std::vector<std::pair<IDNumber, double>> QueryResult;
+typedef std::vector<QueryResult> QueryResults;
+
+struct TableIndex {
+    int32_t engine_type_ = (int)EngineType::FAISS_IDMAP;
+    int32_t nlist_ = 16384;
+    int32_t metric_type_ = (int)MetricType::L2;
+};
+
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/db/Utils.cpp b/core/src/db/Utils.cpp
new file mode 100644
index 0000000000..0ddf03568a
--- /dev/null
+++ b/core/src/db/Utils.cpp
@@ -0,0 +1,240 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "db/Utils.h"
+#include "utils/CommonUtil.h"
+#include "utils/Log.h"
+
+#include <boost/filesystem.hpp>
+#include <chrono>
+#include <mutex>
+#include <regex>
+#include <vector>
+
+namespace milvus {
+namespace engine {
+namespace utils {
+
+namespace {
+
+const char* TABLES_FOLDER = "/tables/";
+
+uint64_t index_file_counter = 0;
+std::mutex index_file_counter_mutex;
+
+std::string
+ConstructParentFolder(const std::string& db_path, const meta::TableFileSchema& table_file) {
+    std::string table_path = db_path + TABLES_FOLDER + table_file.table_id_;
+    std::string partition_path = table_path + "/" + std::to_string(table_file.date_);
+    return partition_path;
+}
+
+std::string
+GetTableFileParentFolder(const DBMetaOptions& options, const meta::TableFileSchema& table_file) {
+    uint64_t path_count = options.slave_paths_.size() + 1;
+    std::string target_path = options.path_;
+    uint64_t index = 0;
+
+    if (meta::TableFileSchema::NEW_INDEX == table_file.file_type_) {
+        // index file is large file and to be persisted permanently
+        // we need to distribute index files to each db_path averagely
+        // round robin according to a file counter
+        std::lock_guard<std::mutex> lock(index_file_counter_mutex);
+        index = index_file_counter % path_count;
+        index_file_counter++;
+    } else {
+        // for other type files, they could be merged or deleted
+        // so we round robin according to their file id
+        index = table_file.id_ % path_count;
+    }
+
+    if (index > 0) {
+        target_path = options.slave_paths_[index - 1];
+    }
+
+    return ConstructParentFolder(target_path, table_file);
+}
+
+}  // namespace
+
+int64_t
+GetMicroSecTimeStamp() {
+    auto now = std::chrono::system_clock::now();
+    auto micros = std::chrono::duration_cast<std::chrono::microseconds>(now.time_since_epoch()).count();
+
+    return micros;
+}
+
+Status
+CreateTablePath(const DBMetaOptions& options, const std::string& table_id) {
+    std::string db_path = options.path_;
+    std::string table_path = db_path + TABLES_FOLDER + table_id;
+    auto status = server::CommonUtil::CreateDirectory(table_path);
+    if (!status.ok()) {
+        ENGINE_LOG_ERROR << status.message();
+        return status;
+    }
+
+    for (auto& path : options.slave_paths_) {
+        table_path = path + TABLES_FOLDER + table_id;
+        status = server::CommonUtil::CreateDirectory(table_path);
+        if (!status.ok()) {
+            ENGINE_LOG_ERROR << status.message();
+            return status;
+        }
+    }
+
+    return Status::OK();
+}
+
+Status
+DeleteTablePath(const DBMetaOptions& options, const std::string& table_id, bool force) {
+    std::vector<std::string> paths = options.slave_paths_;
+    paths.push_back(options.path_);
+
+    for (auto& path : paths) {
+        std::string table_path = path + TABLES_FOLDER + table_id;
+        if (force) {
+            boost::filesystem::remove_all(table_path);
+            ENGINE_LOG_DEBUG << "Remove table folder: " << table_path;
+        } else if (boost::filesystem::exists(table_path) && boost::filesystem::is_empty(table_path)) {
+            boost::filesystem::remove_all(table_path);
+            ENGINE_LOG_DEBUG << "Remove table folder: " << table_path;
+        }
+    }
+
+    return Status::OK();
+}
+
+Status
+CreateTableFilePath(const DBMetaOptions& options, meta::TableFileSchema& table_file) {
+    std::string parent_path = GetTableFileParentFolder(options, table_file);
+
+    auto status = server::CommonUtil::CreateDirectory(parent_path);
+    if (!status.ok()) {
+        ENGINE_LOG_ERROR << status.message();
+        return status;
+    }
+
+    table_file.location_ = parent_path + "/" + table_file.file_id_;
+
+    return Status::OK();
+}
+
+Status
+GetTableFilePath(const DBMetaOptions& options, meta::TableFileSchema& table_file) {
+    std::string parent_path = ConstructParentFolder(options.path_, table_file);
+    std::string file_path = parent_path + "/" + table_file.file_id_;
+    if (boost::filesystem::exists(file_path)) {
+        table_file.location_ = file_path;
+        return Status::OK();
+    }
+
+    for (auto& path : options.slave_paths_) {
+        parent_path = ConstructParentFolder(path, table_file);
+        file_path = parent_path + "/" + table_file.file_id_;
+        if (boost::filesystem::exists(file_path)) {
+            table_file.location_ = file_path;
+            return Status::OK();
+        }
+    }
+
+    std::string msg = "Table file doesn't exist: " + file_path;
+    ENGINE_LOG_ERROR << msg << " in path: " << options.path_ << " for table: " << table_file.table_id_;
+
+    return Status(DB_ERROR, msg);
+}
+
+Status
+DeleteTableFilePath(const DBMetaOptions& options, meta::TableFileSchema& table_file) {
+    utils::GetTableFilePath(options, table_file);
+    boost::filesystem::remove(table_file.location_);
+    return Status::OK();
+}
+
+bool
+IsSameIndex(const TableIndex& index1, const TableIndex& index2) {
+    return index1.engine_type_ == index2.engine_type_ && index1.nlist_ == index2.nlist_ &&
+           index1.metric_type_ == index2.metric_type_;
+}
+
+meta::DateT
+GetDate(const std::time_t& t, int day_delta) {
+    struct tm ltm;
+    localtime_r(&t, &ltm);
+    if (day_delta > 0) {
+        do {
+            ++ltm.tm_mday;
+            --day_delta;
+        } while (day_delta > 0);
+        mktime(&ltm);
+    } else if (day_delta < 0) {
+        do {
+            --ltm.tm_mday;
+            ++day_delta;
+        } while (day_delta < 0);
+        mktime(&ltm);
+    } else {
+        ltm.tm_mday;
+    }
+    return ltm.tm_year * 10000 + ltm.tm_mon * 100 + ltm.tm_mday;
+}
+
+meta::DateT
+GetDateWithDelta(int day_delta) {
+    return GetDate(std::time(nullptr), day_delta);
+}
+
+meta::DateT
+GetDate() {
+    return GetDate(std::time(nullptr), 0);
+}
+
+// URI format: dialect://username:password@host:port/database
+Status
+ParseMetaUri(const std::string& uri, MetaUriInfo& info) {
+    std::string dialect_regex = "(.*)";
+    std::string username_tegex = "(.*)";
+    std::string password_regex = "(.*)";
+    std::string host_regex = "(.*)";
+    std::string port_regex = "(.*)";
+    std::string db_name_regex = "(.*)";
+    std::string uri_regex_str = dialect_regex + "\\:\\/\\/" + username_tegex + "\\:" + password_regex + "\\@" +
+                                host_regex + "\\:" + port_regex + "\\/" + db_name_regex;
+
+    std::regex uri_regex(uri_regex_str);
+    std::smatch pieces_match;
+
+    if (std::regex_match(uri, pieces_match, uri_regex)) {
+        info.dialect_ = pieces_match[1].str();
+        info.username_ = pieces_match[2].str();
+        info.password_ = pieces_match[3].str();
+        info.host_ = pieces_match[4].str();
+        info.port_ = pieces_match[5].str();
+        info.db_name_ = pieces_match[6].str();
+
+        // TODO(myh): verify host, port...
+    } else {
+        return Status(DB_INVALID_META_URI, "Invalid meta uri: " + uri);
+    }
+
+    return Status::OK();
+}
+
+}  // namespace utils
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/db/Utils.h b/core/src/db/Utils.h
new file mode 100644
index 0000000000..0b157f6dfd
--- /dev/null
+++ b/core/src/db/Utils.h
@@ -0,0 +1,70 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "Options.h"
+#include "db/Types.h"
+#include "db/meta/MetaTypes.h"
+
+#include <ctime>
+#include <string>
+
+namespace milvus {
+namespace engine {
+namespace utils {
+
+int64_t
+GetMicroSecTimeStamp();
+
+Status
+CreateTablePath(const DBMetaOptions& options, const std::string& table_id);
+Status
+DeleteTablePath(const DBMetaOptions& options, const std::string& table_id, bool force = true);
+
+Status
+CreateTableFilePath(const DBMetaOptions& options, meta::TableFileSchema& table_file);
+Status
+GetTableFilePath(const DBMetaOptions& options, meta::TableFileSchema& table_file);
+Status
+DeleteTableFilePath(const DBMetaOptions& options, meta::TableFileSchema& table_file);
+
+bool
+IsSameIndex(const TableIndex& index1, const TableIndex& index2);
+
+meta::DateT
+GetDate(const std::time_t& t, int day_delta = 0);
+meta::DateT
+GetDate();
+meta::DateT
+GetDateWithDelta(int day_delta);
+
+struct MetaUriInfo {
+    std::string dialect_;
+    std::string username_;
+    std::string password_;
+    std::string host_;
+    std::string port_;
+    std::string db_name_;
+};
+
+Status
+ParseMetaUri(const std::string& uri, MetaUriInfo& info);
+
+}  // namespace utils
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/db/engine/EngineFactory.cpp b/core/src/db/engine/EngineFactory.cpp
new file mode 100644
index 0000000000..c3597d1020
--- /dev/null
+++ b/core/src/db/engine/EngineFactory.cpp
@@ -0,0 +1,44 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "db/engine/EngineFactory.h"
+#include "db/engine/ExecutionEngineImpl.h"
+#include "utils/Log.h"
+
+#include <memory>
+
+namespace milvus {
+namespace engine {
+
+ExecutionEnginePtr
+EngineFactory::Build(uint16_t dimension, const std::string& location, EngineType index_type, MetricType metric_type,
+                     int32_t nlist) {
+    if (index_type == EngineType::INVALID) {
+        ENGINE_LOG_ERROR << "Unsupported engine type";
+        return nullptr;
+    }
+
+    ENGINE_LOG_DEBUG << "EngineFactory index type: " << (int)index_type;
+    ExecutionEnginePtr execution_engine_ptr =
+        std::make_shared<ExecutionEngineImpl>(dimension, location, index_type, metric_type, nlist);
+
+    execution_engine_ptr->Init();
+    return execution_engine_ptr;
+}
+
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/db/engine/EngineFactory.h b/core/src/db/engine/EngineFactory.h
new file mode 100644
index 0000000000..d98952ccd9
--- /dev/null
+++ b/core/src/db/engine/EngineFactory.h
@@ -0,0 +1,36 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "ExecutionEngine.h"
+#include "utils/Status.h"
+
+#include <string>
+
+namespace milvus {
+namespace engine {
+
+class EngineFactory {
+ public:
+    static ExecutionEnginePtr
+    Build(uint16_t dimension, const std::string& location, EngineType index_type, MetricType metric_type,
+          int32_t nlist);
+};
+
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/db/engine/ExecutionEngine.h b/core/src/db/engine/ExecutionEngine.h
new file mode 100644
index 0000000000..51c77eb78e
--- /dev/null
+++ b/core/src/db/engine/ExecutionEngine.h
@@ -0,0 +1,110 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "utils/Status.h"
+
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace milvus {
+namespace engine {
+
+enum class EngineType {
+    INVALID = 0,
+    FAISS_IDMAP = 1,
+    FAISS_IVFFLAT,
+    FAISS_IVFSQ8,
+    NSG_MIX,
+    FAISS_IVFSQ8H,
+    MAX_VALUE = FAISS_IVFSQ8H,
+};
+
+enum class MetricType {
+    L2 = 1,
+    IP = 2,
+};
+
+class ExecutionEngine {
+ public:
+    virtual Status
+    AddWithIds(int64_t n, const float* xdata, const int64_t* xids) = 0;
+
+    virtual size_t
+    Count() const = 0;
+
+    virtual size_t
+    Size() const = 0;
+
+    virtual size_t
+    Dimension() const = 0;
+
+    virtual size_t
+    PhysicalSize() const = 0;
+
+    virtual Status
+    Serialize() = 0;
+
+    virtual Status
+    Load(bool to_cache = true) = 0;
+
+    virtual Status
+    CopyToGpu(uint64_t device_id, bool hybrid) = 0;
+
+    virtual Status
+    CopyToIndexFileToGpu(uint64_t device_id) = 0;
+
+    virtual Status
+    CopyToCpu() = 0;
+
+    virtual std::shared_ptr<ExecutionEngine>
+    Clone() = 0;
+
+    virtual Status
+    Merge(const std::string& location) = 0;
+
+    virtual Status
+    Search(int64_t n, const float* data, int64_t k, int64_t nprobe, float* distances, int64_t* labels, bool hybrid) = 0;
+
+    virtual std::shared_ptr<ExecutionEngine>
+    BuildIndex(const std::string& location, EngineType engine_type) = 0;
+
+    virtual Status
+    Cache() = 0;
+
+    virtual Status
+    GpuCache(uint64_t gpu_id) = 0;
+
+    virtual Status
+    Init() = 0;
+
+    virtual EngineType
+    IndexEngineType() const = 0;
+
+    virtual MetricType
+    IndexMetricType() const = 0;
+
+    virtual std::string
+    GetLocation() const = 0;
+};
+
+using ExecutionEnginePtr = std::shared_ptr<ExecutionEngine>;
+
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/db/engine/ExecutionEngineImpl.cpp b/core/src/db/engine/ExecutionEngineImpl.cpp
new file mode 100644
index 0000000000..ecd6ff0650
--- /dev/null
+++ b/core/src/db/engine/ExecutionEngineImpl.cpp
@@ -0,0 +1,526 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "db/engine/ExecutionEngineImpl.h"
+#include "cache/CpuCacheMgr.h"
+#include "cache/GpuCacheMgr.h"
+#include "metrics/Metrics.h"
+#include "utils/CommonUtil.h"
+#include "utils/Exception.h"
+#include "utils/Log.h"
+
+#include "knowhere/common/Config.h"
+#include "knowhere/common/Exception.h"
+#include "knowhere/index/vector_index/IndexIVFSQHybrid.h"
+#include "scheduler/Utils.h"
+#include "server/Config.h"
+#include "wrapper/ConfAdapter.h"
+#include "wrapper/ConfAdapterMgr.h"
+#include "wrapper/VecImpl.h"
+#include "wrapper/VecIndex.h"
+
+#include <stdexcept>
+#include <utility>
+#include <vector>
+
+//#define ON_SEARCH
+namespace milvus {
+namespace engine {
+
+class CachedQuantizer : public cache::DataObj {
+ public:
+    explicit CachedQuantizer(knowhere::QuantizerPtr data) : data_(std::move(data)) {
+    }
+
+    knowhere::QuantizerPtr
+    Data() {
+        return data_;
+    }
+
+    int64_t
+    Size() override {
+        return data_->size;
+    }
+
+ private:
+    knowhere::QuantizerPtr data_;
+};
+
+ExecutionEngineImpl::ExecutionEngineImpl(uint16_t dimension, const std::string& location, EngineType index_type,
+                                         MetricType metric_type, int32_t nlist)
+    : location_(location), dim_(dimension), index_type_(index_type), metric_type_(metric_type), nlist_(nlist) {
+    index_ = CreatetVecIndex(EngineType::FAISS_IDMAP);
+    if (!index_) {
+        throw Exception(DB_ERROR, "Unsupported index type");
+    }
+
+    TempMetaConf temp_conf;
+    temp_conf.gpu_id = gpu_num_;
+    temp_conf.dim = dimension;
+    temp_conf.metric_type = (metric_type_ == MetricType::IP) ? knowhere::METRICTYPE::IP : knowhere::METRICTYPE::L2;
+    auto adapter = AdapterMgr::GetInstance().GetAdapter(index_->GetType());
+    auto conf = adapter->Match(temp_conf);
+
+    auto ec = std::static_pointer_cast<BFIndex>(index_)->Build(conf);
+    if (ec != KNOWHERE_SUCCESS) {
+        throw Exception(DB_ERROR, "Build index error");
+    }
+}
+
+ExecutionEngineImpl::ExecutionEngineImpl(VecIndexPtr index, const std::string& location, EngineType index_type,
+                                         MetricType metric_type, int32_t nlist)
+    : index_(std::move(index)), location_(location), index_type_(index_type), metric_type_(metric_type), nlist_(nlist) {
+}
+
+VecIndexPtr
+ExecutionEngineImpl::CreatetVecIndex(EngineType type) {
+    std::shared_ptr<VecIndex> index;
+    switch (type) {
+        case EngineType::FAISS_IDMAP: {
+            index = GetVecIndexFactory(IndexType::FAISS_IDMAP);
+            break;
+        }
+        case EngineType::FAISS_IVFFLAT: {
+            index = GetVecIndexFactory(IndexType::FAISS_IVFFLAT_MIX);
+            break;
+        }
+        case EngineType::FAISS_IVFSQ8: {
+            index = GetVecIndexFactory(IndexType::FAISS_IVFSQ8_MIX);
+            break;
+        }
+        case EngineType::NSG_MIX: {
+            index = GetVecIndexFactory(IndexType::NSG_MIX);
+            break;
+        }
+        case EngineType::FAISS_IVFSQ8H: {
+            index = GetVecIndexFactory(IndexType::FAISS_IVFSQ8_HYBRID);
+            break;
+        }
+        default: {
+            ENGINE_LOG_ERROR << "Unsupported index type";
+            return nullptr;
+        }
+    }
+    return index;
+}
+
+void
+ExecutionEngineImpl::HybridLoad() const {
+    if (index_type_ != EngineType::FAISS_IVFSQ8H) {
+        return;
+    }
+
+    if (index_->GetType() == IndexType::FAISS_IDMAP) {
+        ENGINE_LOG_WARNING << "HybridLoad with type FAISS_IDMAP, ignore";
+        return;
+    }
+
+    const std::string key = location_ + ".quantizer";
+    std::vector<uint64_t> gpus = scheduler::get_gpu_pool();
+
+    // cache hit
+    {
+        const int64_t NOT_FOUND = -1;
+        int64_t device_id = NOT_FOUND;
+        knowhere::QuantizerPtr quantizer = nullptr;
+
+        for (auto& gpu : gpus) {
+            auto cache = cache::GpuCacheMgr::GetInstance(gpu);
+            if (auto cached_quantizer = cache->GetIndex(key)) {
+                device_id = gpu;
+                quantizer = std::static_pointer_cast<CachedQuantizer>(cached_quantizer)->Data();
+            }
+        }
+
+        if (device_id != NOT_FOUND) {
+            index_->SetQuantizer(quantizer);
+            return;
+        }
+    }
+
+    // cache miss
+    {
+        std::vector<int64_t> all_free_mem;
+        for (auto& gpu : gpus) {
+            auto cache = cache::GpuCacheMgr::GetInstance(gpu);
+            auto free_mem = cache->CacheCapacity() - cache->CacheUsage();
+            all_free_mem.push_back(free_mem);
+        }
+
+        auto max_e = std::max_element(all_free_mem.begin(), all_free_mem.end());
+        auto best_index = std::distance(all_free_mem.begin(), max_e);
+        auto best_device_id = gpus[best_index];
+
+        auto quantizer_conf = std::make_shared<knowhere::QuantizerCfg>();
+        quantizer_conf->mode = 1;
+        quantizer_conf->gpu_id = best_device_id;
+        auto quantizer = index_->LoadQuantizer(quantizer_conf);
+        if (quantizer == nullptr) {
+            ENGINE_LOG_ERROR << "quantizer is nullptr";
+        }
+        index_->SetQuantizer(quantizer);
+        auto cache_quantizer = std::make_shared<CachedQuantizer>(quantizer);
+        cache::GpuCacheMgr::GetInstance(best_device_id)->InsertItem(key, cache_quantizer);
+    }
+}
+
+void
+ExecutionEngineImpl::HybridUnset() const {
+    if (index_type_ != EngineType::FAISS_IVFSQ8H) {
+        return;
+    }
+    if (index_->GetType() == IndexType::FAISS_IDMAP) {
+        return;
+    }
+    index_->UnsetQuantizer();
+}
+
+Status
+ExecutionEngineImpl::AddWithIds(int64_t n, const float* xdata, const int64_t* xids) {
+    auto status = index_->Add(n, xdata, xids);
+    return status;
+}
+
+size_t
+ExecutionEngineImpl::Count() const {
+    if (index_ == nullptr) {
+        ENGINE_LOG_ERROR << "ExecutionEngineImpl: index is null, return count 0";
+        return 0;
+    }
+    return index_->Count();
+}
+
+size_t
+ExecutionEngineImpl::Size() const {
+    return (size_t)(Count() * Dimension()) * sizeof(float);
+}
+
+size_t
+ExecutionEngineImpl::Dimension() const {
+    if (index_ == nullptr) {
+        ENGINE_LOG_ERROR << "ExecutionEngineImpl: index is null, return dimension " << dim_;
+        return dim_;
+    }
+    return index_->Dimension();
+}
+
+size_t
+ExecutionEngineImpl::PhysicalSize() const {
+    return server::CommonUtil::GetFileSize(location_);
+}
+
+Status
+ExecutionEngineImpl::Serialize() {
+    auto status = write_index(index_, location_);
+    return status;
+}
+
+Status
+ExecutionEngineImpl::Load(bool to_cache) {
+    index_ = std::static_pointer_cast<VecIndex>(cache::CpuCacheMgr::GetInstance()->GetIndex(location_));
+    bool already_in_cache = (index_ != nullptr);
+    if (!already_in_cache) {
+        try {
+            double physical_size = PhysicalSize();
+            server::CollectExecutionEngineMetrics metrics(physical_size);
+            index_ = read_index(location_);
+            if (index_ == nullptr) {
+                std::string msg = "Failed to load index from " + location_;
+                ENGINE_LOG_ERROR << msg;
+                return Status(DB_ERROR, msg);
+            } else {
+                ENGINE_LOG_DEBUG << "Disk io from: " << location_;
+            }
+        } catch (std::exception& e) {
+            ENGINE_LOG_ERROR << e.what();
+            return Status(DB_ERROR, e.what());
+        }
+    }
+
+    if (!already_in_cache && to_cache) {
+        Cache();
+    }
+    return Status::OK();
+}
+
+Status
+ExecutionEngineImpl::CopyToGpu(uint64_t device_id, bool hybrid) {
+    if (hybrid) {
+        return Status::OK();
+    }
+
+    auto index = std::static_pointer_cast<VecIndex>(cache::GpuCacheMgr::GetInstance(device_id)->GetIndex(location_));
+    bool already_in_cache = (index != nullptr);
+    if (already_in_cache) {
+        index_ = index;
+    } else {
+        if (index_ == nullptr) {
+            ENGINE_LOG_ERROR << "ExecutionEngineImpl: index is null, failed to copy to gpu";
+            return Status(DB_ERROR, "index is null");
+        }
+
+        try {
+            index_ = index_->CopyToGpu(device_id);
+            ENGINE_LOG_DEBUG << "CPU to GPU" << device_id;
+        } catch (std::exception& e) {
+            ENGINE_LOG_ERROR << e.what();
+            return Status(DB_ERROR, e.what());
+        }
+    }
+
+    if (!already_in_cache) {
+        GpuCache(device_id);
+    }
+
+    return Status::OK();
+}
+
+Status
+ExecutionEngineImpl::CopyToIndexFileToGpu(uint64_t device_id) {
+    auto to_index_data = std::make_shared<ToIndexData>(PhysicalSize());
+    cache::DataObjPtr obj = std::static_pointer_cast<cache::DataObj>(to_index_data);
+    milvus::cache::GpuCacheMgr::GetInstance(device_id)->InsertItem(location_, obj);
+    return Status::OK();
+}
+
+Status
+ExecutionEngineImpl::CopyToCpu() {
+    auto index = std::static_pointer_cast<VecIndex>(cache::CpuCacheMgr::GetInstance()->GetIndex(location_));
+    bool already_in_cache = (index != nullptr);
+    if (already_in_cache) {
+        index_ = index;
+    } else {
+        if (index_ == nullptr) {
+            ENGINE_LOG_ERROR << "ExecutionEngineImpl: index is null, failed to copy to cpu";
+            return Status(DB_ERROR, "index is null");
+        }
+
+        try {
+            index_ = index_->CopyToCpu();
+            ENGINE_LOG_DEBUG << "GPU to CPU";
+        } catch (std::exception& e) {
+            ENGINE_LOG_ERROR << e.what();
+            return Status(DB_ERROR, e.what());
+        }
+    }
+
+    if (!already_in_cache) {
+        Cache();
+    }
+    return Status::OK();
+}
+
+ExecutionEnginePtr
+ExecutionEngineImpl::Clone() {
+    if (index_ == nullptr) {
+        ENGINE_LOG_ERROR << "ExecutionEngineImpl: index is null, failed to clone";
+        return nullptr;
+    }
+
+    auto ret = std::make_shared<ExecutionEngineImpl>(dim_, location_, index_type_, metric_type_, nlist_);
+    ret->Init();
+    ret->index_ = index_->Clone();
+    return ret;
+}
+
+Status
+ExecutionEngineImpl::Merge(const std::string& location) {
+    if (location == location_) {
+        return Status(DB_ERROR, "Cannot Merge Self");
+    }
+    ENGINE_LOG_DEBUG << "Merge index file: " << location << " to: " << location_;
+
+    auto to_merge = cache::CpuCacheMgr::GetInstance()->GetIndex(location);
+    if (!to_merge) {
+        try {
+            double physical_size = server::CommonUtil::GetFileSize(location);
+            server::CollectExecutionEngineMetrics metrics(physical_size);
+            to_merge = read_index(location);
+        } catch (std::exception& e) {
+            ENGINE_LOG_ERROR << e.what();
+            return Status(DB_ERROR, e.what());
+        }
+    }
+
+    if (index_ == nullptr) {
+        ENGINE_LOG_ERROR << "ExecutionEngineImpl: index is null, failed to merge";
+        return Status(DB_ERROR, "index is null");
+    }
+
+    if (auto file_index = std::dynamic_pointer_cast<BFIndex>(to_merge)) {
+        auto status = index_->Add(file_index->Count(), file_index->GetRawVectors(), file_index->GetRawIds());
+        if (!status.ok()) {
+            ENGINE_LOG_ERROR << "Merge: Add Error";
+        }
+        return status;
+    } else {
+        return Status(DB_ERROR, "file index type is not idmap");
+    }
+}
+
+ExecutionEnginePtr
+ExecutionEngineImpl::BuildIndex(const std::string& location, EngineType engine_type) {
+    ENGINE_LOG_DEBUG << "Build index file: " << location << " from: " << location_;
+
+    auto from_index = std::dynamic_pointer_cast<BFIndex>(index_);
+    if (from_index == nullptr) {
+        ENGINE_LOG_ERROR << "ExecutionEngineImpl: from_index is null, failed to build index";
+        return nullptr;
+    }
+
+    auto to_index = CreatetVecIndex(engine_type);
+    if (!to_index) {
+        throw Exception(DB_ERROR, "Unsupported index type");
+    }
+
+    TempMetaConf temp_conf;
+    temp_conf.gpu_id = gpu_num_;
+    temp_conf.dim = Dimension();
+    temp_conf.nlist = nlist_;
+    temp_conf.metric_type = (metric_type_ == MetricType::IP) ? knowhere::METRICTYPE::IP : knowhere::METRICTYPE::L2;
+    temp_conf.size = Count();
+
+    auto adapter = AdapterMgr::GetInstance().GetAdapter(to_index->GetType());
+    auto conf = adapter->Match(temp_conf);
+
+    auto status = to_index->BuildAll(Count(), from_index->GetRawVectors(), from_index->GetRawIds(), conf);
+    if (!status.ok()) {
+        throw Exception(DB_ERROR, status.message());
+    }
+
+    return std::make_shared<ExecutionEngineImpl>(to_index, location, engine_type, metric_type_, nlist_);
+}
+
+Status
+ExecutionEngineImpl::Search(int64_t n, const float* data, int64_t k, int64_t nprobe, float* distances, int64_t* labels,
+                            bool hybrid) {
+#if 0
+    if (index_type_ == EngineType::FAISS_IVFSQ8H) {
+        if (!hybrid) {
+            const std::string key = location_ + ".quantizer";
+            std::vector<uint64_t> gpus = scheduler::get_gpu_pool();
+
+            const int64_t NOT_FOUND = -1;
+            int64_t device_id = NOT_FOUND;
+
+            // cache hit
+            {
+                knowhere::QuantizerPtr quantizer = nullptr;
+
+                for (auto& gpu : gpus) {
+                    auto cache = cache::GpuCacheMgr::GetInstance(gpu);
+                    if (auto cached_quantizer = cache->GetIndex(key)) {
+                        device_id = gpu;
+                        quantizer = std::static_pointer_cast<CachedQuantizer>(cached_quantizer)->Data();
+                    }
+                }
+
+                if (device_id != NOT_FOUND) {
+                    // cache hit
+                    auto config = std::make_shared<knowhere::QuantizerCfg>();
+                    config->gpu_id = device_id;
+                    config->mode = 2;
+                    auto new_index = index_->LoadData(quantizer, config);
+                    index_ = new_index;
+                }
+            }
+
+            if (device_id == NOT_FOUND) {
+                // cache miss
+                std::vector<int64_t> all_free_mem;
+                for (auto& gpu : gpus) {
+                    auto cache = cache::GpuCacheMgr::GetInstance(gpu);
+                    auto free_mem = cache->CacheCapacity() - cache->CacheUsage();
+                    all_free_mem.push_back(free_mem);
+                }
+
+                auto max_e = std::max_element(all_free_mem.begin(), all_free_mem.end());
+                auto best_index = std::distance(all_free_mem.begin(), max_e);
+                device_id = gpus[best_index];
+
+                auto pair = index_->CopyToGpuWithQuantizer(device_id);
+                index_ = pair.first;
+
+                // cache
+                auto cached_quantizer = std::make_shared<CachedQuantizer>(pair.second);
+                cache::GpuCacheMgr::GetInstance(device_id)->InsertItem(key, cached_quantizer);
+            }
+        }
+    }
+#endif
+
+    if (index_ == nullptr) {
+        ENGINE_LOG_ERROR << "ExecutionEngineImpl: index is null, failed to search";
+        return Status(DB_ERROR, "index is null");
+    }
+
+    ENGINE_LOG_DEBUG << "Search Params: [k]  " << k << " [nprobe] " << nprobe;
+
+    // TODO(linxj): remove here. Get conf from function
+    TempMetaConf temp_conf;
+    temp_conf.k = k;
+    temp_conf.nprobe = nprobe;
+
+    auto adapter = AdapterMgr::GetInstance().GetAdapter(index_->GetType());
+    auto conf = adapter->MatchSearch(temp_conf, index_->GetType());
+
+    if (hybrid) {
+        HybridLoad();
+    }
+
+    auto status = index_->Search(n, data, distances, labels, conf);
+
+    if (hybrid) {
+        HybridUnset();
+    }
+
+    if (!status.ok()) {
+        ENGINE_LOG_ERROR << "Search error";
+    }
+    return status;
+}
+
+Status
+ExecutionEngineImpl::Cache() {
+    cache::DataObjPtr obj = std::static_pointer_cast<cache::DataObj>(index_);
+    milvus::cache::CpuCacheMgr::GetInstance()->InsertItem(location_, obj);
+
+    return Status::OK();
+}
+
+Status
+ExecutionEngineImpl::GpuCache(uint64_t gpu_id) {
+    cache::DataObjPtr obj = std::static_pointer_cast<cache::DataObj>(index_);
+    milvus::cache::GpuCacheMgr::GetInstance(gpu_id)->InsertItem(location_, obj);
+
+    return Status::OK();
+}
+
+// TODO(linxj): remove.
+Status
+ExecutionEngineImpl::Init() {
+    server::Config& config = server::Config::GetInstance();
+    Status s = config.GetResourceConfigIndexBuildDevice(gpu_num_);
+    if (!s.ok()) {
+        return s;
+    }
+
+    return Status::OK();
+}
+
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/db/engine/ExecutionEngineImpl.h b/core/src/db/engine/ExecutionEngineImpl.h
new file mode 100644
index 0000000000..7eb304426e
--- /dev/null
+++ b/core/src/db/engine/ExecutionEngineImpl.h
@@ -0,0 +1,130 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "ExecutionEngine.h"
+#include "wrapper/VecIndex.h"
+
+#include <memory>
+#include <string>
+
+namespace milvus {
+namespace engine {
+
+class ExecutionEngineImpl : public ExecutionEngine {
+ public:
+    ExecutionEngineImpl(uint16_t dimension, const std::string& location, EngineType index_type, MetricType metric_type,
+                        int32_t nlist);
+
+    ExecutionEngineImpl(VecIndexPtr index, const std::string& location, EngineType index_type, MetricType metric_type,
+                        int32_t nlist);
+
+    Status
+    AddWithIds(int64_t n, const float* xdata, const int64_t* xids) override;
+
+    size_t
+    Count() const override;
+
+    size_t
+    Size() const override;
+
+    size_t
+    Dimension() const override;
+
+    size_t
+    PhysicalSize() const override;
+
+    Status
+    Serialize() override;
+
+    Status
+    Load(bool to_cache) override;
+
+    Status
+    CopyToGpu(uint64_t device_id, bool hybrid = false) override;
+
+    Status
+    CopyToIndexFileToGpu(uint64_t device_id) override;
+
+    Status
+    CopyToCpu() override;
+
+    ExecutionEnginePtr
+    Clone() override;
+
+    Status
+    Merge(const std::string& location) override;
+
+    Status
+    Search(int64_t n, const float* data, int64_t k, int64_t nprobe, float* distances, int64_t* labels,
+           bool hybrid = false) override;
+
+    ExecutionEnginePtr
+    BuildIndex(const std::string& location, EngineType engine_type) override;
+
+    Status
+    Cache() override;
+
+    Status
+    GpuCache(uint64_t gpu_id) override;
+
+    Status
+    Init() override;
+
+    EngineType
+    IndexEngineType() const override {
+        return index_type_;
+    }
+
+    MetricType
+    IndexMetricType() const override {
+        return metric_type_;
+    }
+
+    std::string
+    GetLocation() const override {
+        return location_;
+    }
+
+ private:
+    VecIndexPtr
+    CreatetVecIndex(EngineType type);
+
+    VecIndexPtr
+    Load(const std::string& location);
+
+    void
+    HybridLoad() const;
+
+    void
+    HybridUnset() const;
+
+ protected:
+    VecIndexPtr index_ = nullptr;
+    EngineType index_type_;
+    MetricType metric_type_;
+
+    int64_t dim_;
+    std::string location_;
+
+    int32_t nlist_ = 0;
+    int32_t gpu_num_ = 0;
+};
+
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/db/insert/MemManager.h b/core/src/db/insert/MemManager.h
new file mode 100644
index 0000000000..cc76604165
--- /dev/null
+++ b/core/src/db/insert/MemManager.h
@@ -0,0 +1,54 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "db/Types.h"
+#include "utils/Status.h"
+
+#include <memory>
+#include <set>
+#include <string>
+
+namespace milvus {
+namespace engine {
+
+class MemManager {
+ public:
+    virtual Status
+    InsertVectors(const std::string& table_id, size_t n, const float* vectors, IDNumbers& vector_ids) = 0;
+
+    virtual Status
+    Serialize(std::set<std::string>& table_ids) = 0;
+
+    virtual Status
+    EraseMemVector(const std::string& table_id) = 0;
+
+    virtual size_t
+    GetCurrentMutableMem() = 0;
+
+    virtual size_t
+    GetCurrentImmutableMem() = 0;
+
+    virtual size_t
+    GetCurrentMem() = 0;
+};  // MemManagerAbstract
+
+using MemManagerPtr = std::shared_ptr<MemManager>;
+
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/db/insert/MemManagerImpl.cpp b/core/src/db/insert/MemManagerImpl.cpp
new file mode 100644
index 0000000000..69c3397eb9
--- /dev/null
+++ b/core/src/db/insert/MemManagerImpl.cpp
@@ -0,0 +1,141 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "db/insert/MemManagerImpl.h"
+#include "VectorSource.h"
+#include "db/Constants.h"
+#include "utils/Log.h"
+
+#include <thread>
+
+namespace milvus {
+namespace engine {
+
+MemTablePtr
+MemManagerImpl::GetMemByTable(const std::string& table_id) {
+    auto memIt = mem_id_map_.find(table_id);
+    if (memIt != mem_id_map_.end()) {
+        return memIt->second;
+    }
+
+    mem_id_map_[table_id] = std::make_shared<MemTable>(table_id, meta_, options_);
+    return mem_id_map_[table_id];
+}
+
+Status
+MemManagerImpl::InsertVectors(const std::string& table_id_, size_t n_, const float* vectors_, IDNumbers& vector_ids_) {
+    while (GetCurrentMem() > options_.insert_buffer_size_) {
+        std::this_thread::sleep_for(std::chrono::milliseconds(1));
+    }
+
+    std::unique_lock<std::mutex> lock(mutex_);
+
+    return InsertVectorsNoLock(table_id_, n_, vectors_, vector_ids_);
+}
+
+Status
+MemManagerImpl::InsertVectorsNoLock(const std::string& table_id, size_t n, const float* vectors,
+                                    IDNumbers& vector_ids) {
+    MemTablePtr mem = GetMemByTable(table_id);
+    VectorSourcePtr source = std::make_shared<VectorSource>(n, vectors);
+
+    auto status = mem->Add(source, vector_ids);
+    if (status.ok()) {
+        if (vector_ids.empty()) {
+            vector_ids = source->GetVectorIds();
+        }
+    }
+    return status;
+}
+
+Status
+MemManagerImpl::ToImmutable() {
+    std::unique_lock<std::mutex> lock(mutex_);
+    MemIdMap temp_map;
+    for (auto& kv : mem_id_map_) {
+        if (kv.second->Empty()) {
+            // empty table, no need to serialize
+            temp_map.insert(kv);
+        } else {
+            immu_mem_list_.push_back(kv.second);
+        }
+    }
+
+    mem_id_map_.swap(temp_map);
+    return Status::OK();
+}
+
+Status
+MemManagerImpl::Serialize(std::set<std::string>& table_ids) {
+    ToImmutable();
+    std::unique_lock<std::mutex> lock(serialization_mtx_);
+    table_ids.clear();
+    for (auto& mem : immu_mem_list_) {
+        mem->Serialize();
+        table_ids.insert(mem->GetTableId());
+    }
+    immu_mem_list_.clear();
+    return Status::OK();
+}
+
+Status
+MemManagerImpl::EraseMemVector(const std::string& table_id) {
+    {  // erase MemVector from rapid-insert cache
+        std::unique_lock<std::mutex> lock(mutex_);
+        mem_id_map_.erase(table_id);
+    }
+
+    {  // erase MemVector from serialize cache
+        std::unique_lock<std::mutex> lock(serialization_mtx_);
+        MemList temp_list;
+        for (auto& mem : immu_mem_list_) {
+            if (mem->GetTableId() != table_id) {
+                temp_list.push_back(mem);
+            }
+        }
+        immu_mem_list_.swap(temp_list);
+    }
+
+    return Status::OK();
+}
+
+size_t
+MemManagerImpl::GetCurrentMutableMem() {
+    size_t total_mem = 0;
+    for (auto& kv : mem_id_map_) {
+        auto memTable = kv.second;
+        total_mem += memTable->GetCurrentMem();
+    }
+    return total_mem;
+}
+
+size_t
+MemManagerImpl::GetCurrentImmutableMem() {
+    size_t total_mem = 0;
+    for (auto& mem_table : immu_mem_list_) {
+        total_mem += mem_table->GetCurrentMem();
+    }
+    return total_mem;
+}
+
+size_t
+MemManagerImpl::GetCurrentMem() {
+    return GetCurrentMutableMem() + GetCurrentImmutableMem();
+}
+
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/db/insert/MemManagerImpl.h b/core/src/db/insert/MemManagerImpl.h
new file mode 100644
index 0000000000..862b068d0f
--- /dev/null
+++ b/core/src/db/insert/MemManagerImpl.h
@@ -0,0 +1,81 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "MemManager.h"
+#include "MemTable.h"
+#include "db/meta/Meta.h"
+#include "utils/Status.h"
+
+#include <ctime>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <set>
+#include <string>
+#include <vector>
+
+namespace milvus {
+namespace engine {
+
+class MemManagerImpl : public MemManager {
+ public:
+    using Ptr = std::shared_ptr<MemManagerImpl>;
+
+    MemManagerImpl(const meta::MetaPtr& meta, const DBOptions& options) : meta_(meta), options_(options) {
+    }
+
+    Status
+    InsertVectors(const std::string& table_id, size_t n, const float* vectors, IDNumbers& vector_ids) override;
+
+    Status
+    Serialize(std::set<std::string>& table_ids) override;
+
+    Status
+    EraseMemVector(const std::string& table_id) override;
+
+    size_t
+    GetCurrentMutableMem() override;
+
+    size_t
+    GetCurrentImmutableMem() override;
+
+    size_t
+    GetCurrentMem() override;
+
+ private:
+    MemTablePtr
+    GetMemByTable(const std::string& table_id);
+
+    Status
+    InsertVectorsNoLock(const std::string& table_id, size_t n, const float* vectors, IDNumbers& vector_ids);
+    Status
+    ToImmutable();
+
+    using MemIdMap = std::map<std::string, MemTablePtr>;
+    using MemList = std::vector<MemTablePtr>;
+    MemIdMap mem_id_map_;
+    MemList immu_mem_list_;
+    meta::MetaPtr meta_;
+    DBOptions options_;
+    std::mutex mutex_;
+    std::mutex serialization_mtx_;
+};  // NewMemManager
+
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/db/insert/MemMenagerFactory.cpp b/core/src/db/insert/MemMenagerFactory.cpp
new file mode 100644
index 0000000000..033992501b
--- /dev/null
+++ b/core/src/db/insert/MemMenagerFactory.cpp
@@ -0,0 +1,40 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "db/insert/MemMenagerFactory.h"
+#include "MemManagerImpl.h"
+#include "utils/Exception.h"
+#include "utils/Log.h"
+
+#include <stdlib.h>
+#include <time.h>
+#include <cstdlib>
+#include <memory>
+#include <regex>
+#include <sstream>
+#include <string>
+
+namespace milvus {
+namespace engine {
+
+MemManagerPtr
+MemManagerFactory::Build(const std::shared_ptr<meta::Meta>& meta, const DBOptions& options) {
+    return std::make_shared<MemManagerImpl>(meta, options);
+}
+
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/db/insert/MemMenagerFactory.h b/core/src/db/insert/MemMenagerFactory.h
new file mode 100644
index 0000000000..a489a3952b
--- /dev/null
+++ b/core/src/db/insert/MemMenagerFactory.h
@@ -0,0 +1,35 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "MemManager.h"
+#include "db/meta/Meta.h"
+
+#include <memory>
+
+namespace milvus {
+namespace engine {
+
+class MemManagerFactory {
+ public:
+    static MemManagerPtr
+    Build(const std::shared_ptr<meta::Meta>& meta, const DBOptions& options);
+};
+
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/db/insert/MemTable.cpp b/core/src/db/insert/MemTable.cpp
new file mode 100644
index 0000000000..871eab8d7d
--- /dev/null
+++ b/core/src/db/insert/MemTable.cpp
@@ -0,0 +1,105 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "db/insert/MemTable.h"
+#include "utils/Log.h"
+
+#include <memory>
+#include <string>
+
+namespace milvus {
+namespace engine {
+
+MemTable::MemTable(const std::string& table_id, const meta::MetaPtr& meta, const DBOptions& options)
+    : table_id_(table_id), meta_(meta), options_(options) {
+}
+
+Status
+MemTable::Add(VectorSourcePtr& source, IDNumbers& vector_ids) {
+    while (!source->AllAdded()) {
+        MemTableFilePtr current_mem_table_file;
+        if (!mem_table_file_list_.empty()) {
+            current_mem_table_file = mem_table_file_list_.back();
+        }
+
+        Status status;
+        if (mem_table_file_list_.empty() || current_mem_table_file->IsFull()) {
+            MemTableFilePtr new_mem_table_file = std::make_shared<MemTableFile>(table_id_, meta_, options_);
+            status = new_mem_table_file->Add(source, vector_ids);
+            if (status.ok()) {
+                mem_table_file_list_.emplace_back(new_mem_table_file);
+            }
+        } else {
+            status = current_mem_table_file->Add(source, vector_ids);
+        }
+
+        if (!status.ok()) {
+            std::string err_msg = "Insert failed: " + status.ToString();
+            ENGINE_LOG_ERROR << err_msg;
+            return Status(DB_ERROR, err_msg);
+        }
+    }
+    return Status::OK();
+}
+
+void
+MemTable::GetCurrentMemTableFile(MemTableFilePtr& mem_table_file) {
+    mem_table_file = mem_table_file_list_.back();
+}
+
+size_t
+MemTable::GetTableFileCount() {
+    return mem_table_file_list_.size();
+}
+
+Status
+MemTable::Serialize() {
+    for (auto mem_table_file = mem_table_file_list_.begin(); mem_table_file != mem_table_file_list_.end();) {
+        auto status = (*mem_table_file)->Serialize();
+        if (!status.ok()) {
+            std::string err_msg = "Insert data serialize failed: " + status.ToString();
+            ENGINE_LOG_ERROR << err_msg;
+            return Status(DB_ERROR, err_msg);
+        }
+        std::lock_guard<std::mutex> lock(mutex_);
+        mem_table_file = mem_table_file_list_.erase(mem_table_file);
+    }
+    return Status::OK();
+}
+
+bool
+MemTable::Empty() {
+    return mem_table_file_list_.empty();
+}
+
+const std::string&
+MemTable::GetTableId() const {
+    return table_id_;
+}
+
+size_t
+MemTable::GetCurrentMem() {
+    std::lock_guard<std::mutex> lock(mutex_);
+    size_t total_mem = 0;
+    for (auto& mem_table_file : mem_table_file_list_) {
+        total_mem += mem_table_file->GetCurrentMem();
+    }
+    return total_mem;
+}
+
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/db/insert/MemTable.h b/core/src/db/insert/MemTable.h
new file mode 100644
index 0000000000..cb22b6ed34
--- /dev/null
+++ b/core/src/db/insert/MemTable.h
@@ -0,0 +1,74 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "MemTableFile.h"
+#include "VectorSource.h"
+#include "utils/Status.h"
+
+#include <memory>
+#include <mutex>
+#include <string>
+#include <vector>
+
+namespace milvus {
+namespace engine {
+
+class MemTable {
+ public:
+    using MemTableFileList = std::vector<MemTableFilePtr>;
+
+    MemTable(const std::string& table_id, const meta::MetaPtr& meta, const DBOptions& options);
+
+    Status
+    Add(VectorSourcePtr& source, IDNumbers& vector_ids);
+
+    void
+    GetCurrentMemTableFile(MemTableFilePtr& mem_table_file);
+
+    size_t
+    GetTableFileCount();
+
+    Status
+    Serialize();
+
+    bool
+    Empty();
+
+    const std::string&
+    GetTableId() const;
+
+    size_t
+    GetCurrentMem();
+
+ private:
+    const std::string table_id_;
+
+    MemTableFileList mem_table_file_list_;
+
+    meta::MetaPtr meta_;
+
+    DBOptions options_;
+
+    std::mutex mutex_;
+};  // MemTable
+
+using MemTablePtr = std::shared_ptr<MemTable>;
+
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/db/insert/MemTableFile.cpp b/core/src/db/insert/MemTableFile.cpp
new file mode 100644
index 0000000000..2c877c78ed
--- /dev/null
+++ b/core/src/db/insert/MemTableFile.cpp
@@ -0,0 +1,127 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "db/insert/MemTableFile.h"
+#include "db/Constants.h"
+#include "db/engine/EngineFactory.h"
+#include "metrics/Metrics.h"
+#include "utils/Log.h"
+
+#include <cmath>
+#include <string>
+
+namespace milvus {
+namespace engine {
+
+MemTableFile::MemTableFile(const std::string& table_id, const meta::MetaPtr& meta, const DBOptions& options)
+    : table_id_(table_id), meta_(meta), options_(options) {
+    current_mem_ = 0;
+    auto status = CreateTableFile();
+    if (status.ok()) {
+        execution_engine_ = EngineFactory::Build(
+            table_file_schema_.dimension_, table_file_schema_.location_, (EngineType)table_file_schema_.engine_type_,
+            (MetricType)table_file_schema_.metric_type_, table_file_schema_.nlist_);
+    }
+}
+
+Status
+MemTableFile::CreateTableFile() {
+    meta::TableFileSchema table_file_schema;
+    table_file_schema.table_id_ = table_id_;
+    auto status = meta_->CreateTableFile(table_file_schema);
+    if (status.ok()) {
+        table_file_schema_ = table_file_schema;
+    } else {
+        std::string err_msg = "MemTableFile::CreateTableFile failed: " + status.ToString();
+        ENGINE_LOG_ERROR << err_msg;
+    }
+    return status;
+}
+
+Status
+MemTableFile::Add(const VectorSourcePtr& source, IDNumbers& vector_ids) {
+    if (table_file_schema_.dimension_ <= 0) {
+        std::string err_msg =
+            "MemTableFile::Add: table_file_schema dimension = " + std::to_string(table_file_schema_.dimension_) +
+            ", table_id = " + table_file_schema_.table_id_;
+        ENGINE_LOG_ERROR << err_msg;
+        return Status(DB_ERROR, "Not able to create table file");
+    }
+
+    size_t single_vector_mem_size = table_file_schema_.dimension_ * VECTOR_TYPE_SIZE;
+    size_t mem_left = GetMemLeft();
+    if (mem_left >= single_vector_mem_size) {
+        size_t num_vectors_to_add = std::ceil(mem_left / single_vector_mem_size);
+        size_t num_vectors_added;
+        auto status =
+            source->Add(execution_engine_, table_file_schema_, num_vectors_to_add, num_vectors_added, vector_ids);
+        if (status.ok()) {
+            current_mem_ += (num_vectors_added * single_vector_mem_size);
+        }
+        return status;
+    }
+    return Status::OK();
+}
+
+size_t
+MemTableFile::GetCurrentMem() {
+    return current_mem_;
+}
+
+size_t
+MemTableFile::GetMemLeft() {
+    return (MAX_TABLE_FILE_MEM - current_mem_);
+}
+
+bool
+MemTableFile::IsFull() {
+    size_t single_vector_mem_size = table_file_schema_.dimension_ * VECTOR_TYPE_SIZE;
+    return (GetMemLeft() < single_vector_mem_size);
+}
+
+Status
+MemTableFile::Serialize() {
+    size_t size = GetCurrentMem();
+    server::CollectSerializeMetrics metrics(size);
+
+    execution_engine_->Serialize();
+    table_file_schema_.file_size_ = execution_engine_->PhysicalSize();
+    table_file_schema_.row_count_ = execution_engine_->Count();
+
+    // if index type isn't IDMAP, set file type to TO_INDEX if file size execeed index_file_size
+    // else set file type to RAW, no need to build index
+    if (table_file_schema_.engine_type_ != (int)EngineType::FAISS_IDMAP) {
+        table_file_schema_.file_type_ = (size >= table_file_schema_.index_file_size_) ? meta::TableFileSchema::TO_INDEX
+                                                                                      : meta::TableFileSchema::RAW;
+    } else {
+        table_file_schema_.file_type_ = meta::TableFileSchema::RAW;
+    }
+
+    auto status = meta_->UpdateTableFile(table_file_schema_);
+
+    ENGINE_LOG_DEBUG << "New " << ((table_file_schema_.file_type_ == meta::TableFileSchema::RAW) ? "raw" : "to_index")
+                     << " file " << table_file_schema_.file_id_ << " of size " << size << " bytes";
+
+    if (options_.insert_cache_immediately_) {
+        execution_engine_->Cache();
+    }
+
+    return status;
+}
+
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/db/insert/MemTableFile.h b/core/src/db/insert/MemTableFile.h
new file mode 100644
index 0000000000..e11274b7de
--- /dev/null
+++ b/core/src/db/insert/MemTableFile.h
@@ -0,0 +1,67 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "VectorSource.h"
+#include "db/engine/ExecutionEngine.h"
+#include "db/meta/Meta.h"
+#include "utils/Status.h"
+
+#include <memory>
+#include <string>
+
+namespace milvus {
+namespace engine {
+
+class MemTableFile {
+ public:
+    MemTableFile(const std::string& table_id, const meta::MetaPtr& meta, const DBOptions& options);
+
+    Status
+    Add(const VectorSourcePtr& source, IDNumbers& vector_ids);
+
+    size_t
+    GetCurrentMem();
+
+    size_t
+    GetMemLeft();
+
+    bool
+    IsFull();
+
+    Status
+    Serialize();
+
+ private:
+    Status
+    CreateTableFile();
+
+ private:
+    const std::string table_id_;
+    meta::TableFileSchema table_file_schema_;
+    meta::MetaPtr meta_;
+    DBOptions options_;
+    size_t current_mem_;
+
+    ExecutionEnginePtr execution_engine_;
+};  // MemTableFile
+
+using MemTableFilePtr = std::shared_ptr<MemTableFile>;
+
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/db/insert/VectorSource.cpp b/core/src/db/insert/VectorSource.cpp
new file mode 100644
index 0000000000..dbedf58029
--- /dev/null
+++ b/core/src/db/insert/VectorSource.cpp
@@ -0,0 +1,78 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "db/insert/VectorSource.h"
+#include "db/engine/EngineFactory.h"
+#include "db/engine/ExecutionEngine.h"
+#include "metrics/Metrics.h"
+#include "utils/Log.h"
+
+namespace milvus {
+namespace engine {
+
+VectorSource::VectorSource(const size_t& n, const float* vectors)
+    : n_(n), vectors_(vectors), id_generator_(std::make_shared<SimpleIDGenerator>()) {
+    current_num_vectors_added = 0;
+}
+
+Status
+VectorSource::Add(const ExecutionEnginePtr& execution_engine, const meta::TableFileSchema& table_file_schema,
+                  const size_t& num_vectors_to_add, size_t& num_vectors_added, IDNumbers& vector_ids) {
+    server::CollectAddMetrics metrics(n_, table_file_schema.dimension_);
+
+    num_vectors_added =
+        current_num_vectors_added + num_vectors_to_add <= n_ ? num_vectors_to_add : n_ - current_num_vectors_added;
+    IDNumbers vector_ids_to_add;
+    if (vector_ids.empty()) {
+        id_generator_->GetNextIDNumbers(num_vectors_added, vector_ids_to_add);
+    } else {
+        vector_ids_to_add.resize(num_vectors_added);
+        for (int pos = current_num_vectors_added; pos < current_num_vectors_added + num_vectors_added; pos++) {
+            vector_ids_to_add[pos - current_num_vectors_added] = vector_ids[pos];
+        }
+    }
+    Status status = execution_engine->AddWithIds(num_vectors_added,
+                                                 vectors_ + current_num_vectors_added * table_file_schema.dimension_,
+                                                 vector_ids_to_add.data());
+    if (status.ok()) {
+        current_num_vectors_added += num_vectors_added;
+        vector_ids_.insert(vector_ids_.end(), std::make_move_iterator(vector_ids_to_add.begin()),
+                           std::make_move_iterator(vector_ids_to_add.end()));
+    } else {
+        ENGINE_LOG_ERROR << "VectorSource::Add failed: " + status.ToString();
+    }
+
+    return status;
+}
+
+size_t
+VectorSource::GetNumVectorsAdded() {
+    return current_num_vectors_added;
+}
+
+bool
+VectorSource::AllAdded() {
+    return (current_num_vectors_added == n_);
+}
+
+IDNumbers
+VectorSource::GetVectorIds() {
+    return vector_ids_;
+}
+
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/db/insert/VectorSource.h b/core/src/db/insert/VectorSource.h
new file mode 100644
index 0000000000..1d936268f4
--- /dev/null
+++ b/core/src/db/insert/VectorSource.h
@@ -0,0 +1,60 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "db/IDGenerator.h"
+#include "db/engine/ExecutionEngine.h"
+#include "db/meta/Meta.h"
+#include "utils/Status.h"
+
+#include <memory>
+
+namespace milvus {
+namespace engine {
+
+class VectorSource {
+ public:
+    VectorSource(const size_t& n, const float* vectors);
+
+    Status
+    Add(const ExecutionEnginePtr& execution_engine, const meta::TableFileSchema& table_file_schema,
+        const size_t& num_vectors_to_add, size_t& num_vectors_added, IDNumbers& vector_ids);
+
+    size_t
+    GetNumVectorsAdded();
+
+    bool
+    AllAdded();
+
+    IDNumbers
+    GetVectorIds();
+
+ private:
+    const size_t n_;
+    const float* vectors_;
+    IDNumbers vector_ids_;
+
+    size_t current_num_vectors_added;
+
+    std::shared_ptr<IDGenerator> id_generator_;
+};  // VectorSource
+
+using VectorSourcePtr = std::shared_ptr<VectorSource>;
+
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/db/meta/Meta.h b/core/src/db/meta/Meta.h
new file mode 100644
index 0000000000..ec4b66916d
--- /dev/null
+++ b/core/src/db/meta/Meta.h
@@ -0,0 +1,125 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "MetaTypes.h"
+#include "db/Options.h"
+#include "db/Types.h"
+#include "utils/Status.h"
+
+#include <cstddef>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace milvus {
+namespace engine {
+namespace meta {
+
+static const char* META_TABLES = "Tables";
+static const char* META_TABLEFILES = "TableFiles";
+
+class Meta {
+ public:
+    virtual ~Meta() = default;
+
+    virtual Status
+    CreateTable(TableSchema& table_schema) = 0;
+
+    virtual Status
+    DescribeTable(TableSchema& table_schema) = 0;
+
+    virtual Status
+    HasTable(const std::string& table_id, bool& has_or_not) = 0;
+
+    virtual Status
+    AllTables(std::vector<TableSchema>& table_schema_array) = 0;
+
+    virtual Status
+    UpdateTableIndex(const std::string& table_id, const TableIndex& index) = 0;
+
+    virtual Status
+    UpdateTableFlag(const std::string& table_id, int64_t flag) = 0;
+
+    virtual Status
+    DeleteTable(const std::string& table_id) = 0;
+
+    virtual Status
+    DeleteTableFiles(const std::string& table_id) = 0;
+
+    virtual Status
+    CreateTableFile(TableFileSchema& file_schema) = 0;
+
+    virtual Status
+    DropPartitionsByDates(const std::string& table_id, const DatesT& dates) = 0;
+
+    virtual Status
+    GetTableFiles(const std::string& table_id, const std::vector<size_t>& ids, TableFilesSchema& table_files) = 0;
+
+    virtual Status
+    UpdateTableFilesToIndex(const std::string& table_id) = 0;
+
+    virtual Status
+    UpdateTableFile(TableFileSchema& file_schema) = 0;
+
+    virtual Status
+    UpdateTableFiles(TableFilesSchema& files) = 0;
+
+    virtual Status
+    FilesToSearch(const std::string& table_id, const std::vector<size_t>& ids, const DatesT& dates,
+                  DatePartionedTableFilesSchema& files) = 0;
+
+    virtual Status
+    FilesToMerge(const std::string& table_id, DatePartionedTableFilesSchema& files) = 0;
+
+    virtual Status
+    Size(uint64_t& result) = 0;
+
+    virtual Status
+    Archive() = 0;
+
+    virtual Status
+    FilesToIndex(TableFilesSchema&) = 0;
+
+    virtual Status
+    FilesByType(const std::string& table_id, const std::vector<int>& file_types,
+                std::vector<std::string>& file_ids) = 0;
+
+    virtual Status
+    DescribeTableIndex(const std::string& table_id, TableIndex& index) = 0;
+
+    virtual Status
+    DropTableIndex(const std::string& table_id) = 0;
+
+    virtual Status
+    CleanUp() = 0;
+
+    virtual Status CleanUpFilesWithTTL(uint16_t) = 0;
+
+    virtual Status
+    DropAll() = 0;
+
+    virtual Status
+    Count(const std::string& table_id, uint64_t& result) = 0;
+};  // MetaData
+
+using MetaPtr = std::shared_ptr<Meta>;
+
+}  // namespace meta
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/db/meta/MetaConsts.h b/core/src/db/meta/MetaConsts.h
new file mode 100644
index 0000000000..4e40ff7731
--- /dev/null
+++ b/core/src/db/meta/MetaConsts.h
@@ -0,0 +1,37 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+namespace milvus {
+namespace engine {
+namespace meta {
+
+const size_t S_PS = 1UL;
+const size_t MS_PS = 1000 * S_PS;
+const size_t US_PS = 1000 * MS_PS;
+const size_t NS_PS = 1000 * US_PS;
+
+const size_t SECOND = 1UL;
+const size_t M_SEC = 60 * SECOND;
+const size_t H_SEC = 60 * M_SEC;
+const size_t D_SEC = 24 * H_SEC;
+const size_t W_SEC = 7 * D_SEC;
+
+}  // namespace meta
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/db/meta/MetaFactory.cpp b/core/src/db/meta/MetaFactory.cpp
new file mode 100644
index 0000000000..8031038e37
--- /dev/null
+++ b/core/src/db/meta/MetaFactory.cpp
@@ -0,0 +1,76 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "db/meta/MetaFactory.h"
+#include "MySQLMetaImpl.h"
+#include "SqliteMetaImpl.h"
+#include "db/Utils.h"
+#include "utils/Exception.h"
+#include "utils/Log.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <cstdlib>
+#include <memory>
+#include <sstream>
+#include <string>
+
+namespace milvus {
+namespace engine {
+
+DBMetaOptions
+MetaFactory::BuildOption(const std::string& path) {
+    auto p = path;
+    if (p == "") {
+        srand(time(nullptr));
+        std::stringstream ss;
+        uint32_t seed = 1;
+        ss << "/tmp/" << rand_r(&seed);
+        p = ss.str();
+    }
+
+    DBMetaOptions meta;
+    meta.path_ = p;
+    return meta;
+}
+
+meta::MetaPtr
+MetaFactory::Build(const DBMetaOptions& metaOptions, const int& mode) {
+    std::string uri = metaOptions.backend_uri_;
+
+    utils::MetaUriInfo uri_info;
+    auto status = utils::ParseMetaUri(uri, uri_info);
+    if (!status.ok()) {
+        ENGINE_LOG_ERROR << "Wrong URI format: URI = " << uri;
+        throw InvalidArgumentException("Wrong URI format ");
+    }
+
+    if (strcasecmp(uri_info.dialect_.c_str(), "mysql") == 0) {
+        ENGINE_LOG_INFO << "Using MySQL";
+        return std::make_shared<meta::MySQLMetaImpl>(metaOptions, mode);
+    } else if (strcasecmp(uri_info.dialect_.c_str(), "sqlite") == 0) {
+        ENGINE_LOG_INFO << "Using SQLite";
+        return std::make_shared<meta::SqliteMetaImpl>(metaOptions);
+    } else {
+        ENGINE_LOG_ERROR << "Invalid dialect in URI: dialect = " << uri_info.dialect_;
+        throw InvalidArgumentException("URI dialect is not mysql / sqlite");
+    }
+}
+
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/db/meta/MetaFactory.h b/core/src/db/meta/MetaFactory.h
new file mode 100644
index 0000000000..f16584426e
--- /dev/null
+++ b/core/src/db/meta/MetaFactory.h
@@ -0,0 +1,38 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "Meta.h"
+#include "db/Options.h"
+
+#include <string>
+
+namespace milvus {
+namespace engine {
+
+class MetaFactory {
+ public:
+    static DBMetaOptions
+    BuildOption(const std::string& path = "");
+
+    static meta::MetaPtr
+    Build(const DBMetaOptions& metaOptions, const int& mode);
+};
+
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/db/meta/MetaTypes.h b/core/src/db/meta/MetaTypes.h
new file mode 100644
index 0000000000..c973f3fdea
--- /dev/null
+++ b/core/src/db/meta/MetaTypes.h
@@ -0,0 +1,97 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "db/Constants.h"
+#include "db/engine/ExecutionEngine.h"
+
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace milvus {
+namespace engine {
+namespace meta {
+
+constexpr int32_t DEFAULT_ENGINE_TYPE = (int)EngineType::FAISS_IDMAP;
+constexpr int32_t DEFAULT_NLIST = 16384;
+constexpr int32_t DEFAULT_METRIC_TYPE = (int)MetricType::L2;
+constexpr int32_t DEFAULT_INDEX_FILE_SIZE = ONE_GB;
+
+constexpr int64_t FLAG_MASK_NO_USERID = 0x1;
+constexpr int64_t FLAG_MASK_HAS_USERID = 0x1 << 1;
+
+using DateT = int;
+const DateT EmptyDate = -1;
+using DatesT = std::vector<DateT>;
+
+struct TableSchema {
+    typedef enum {
+        NORMAL,
+        TO_DELETE,
+    } TABLE_STATE;
+
+    size_t id_ = 0;
+    std::string table_id_;
+    int32_t state_ = (int)NORMAL;
+    uint16_t dimension_ = 0;
+    int64_t created_on_ = 0;
+    int64_t flag_ = 0;
+    int64_t index_file_size_ = DEFAULT_INDEX_FILE_SIZE;
+    int32_t engine_type_ = DEFAULT_ENGINE_TYPE;
+    int32_t nlist_ = DEFAULT_NLIST;
+    int32_t metric_type_ = DEFAULT_METRIC_TYPE;
+};  // TableSchema
+
+struct TableFileSchema {
+    typedef enum {
+        NEW,
+        RAW,
+        TO_INDEX,
+        INDEX,
+        TO_DELETE,
+        NEW_MERGE,
+        NEW_INDEX,
+        BACKUP,
+    } FILE_TYPE;
+
+    size_t id_ = 0;
+    std::string table_id_;
+    std::string file_id_;
+    int32_t file_type_ = NEW;
+    size_t file_size_ = 0;
+    size_t row_count_ = 0;
+    DateT date_ = EmptyDate;
+    uint16_t dimension_ = 0;
+    std::string location_;
+    int64_t updated_time_ = 0;
+    int64_t created_on_ = 0;
+    int64_t index_file_size_ = DEFAULT_INDEX_FILE_SIZE;  // not persist to meta
+    int32_t engine_type_ = DEFAULT_ENGINE_TYPE;
+    int32_t nlist_ = DEFAULT_NLIST;              // not persist to meta
+    int32_t metric_type_ = DEFAULT_METRIC_TYPE;  // not persist to meta
+};                                               // TableFileSchema
+
+using TableFileSchemaPtr = std::shared_ptr<meta::TableFileSchema>;
+using TableFilesSchema = std::vector<TableFileSchema>;
+using DatePartionedTableFilesSchema = std::map<DateT, TableFilesSchema>;
+
+}  // namespace meta
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/db/meta/MySQLConnectionPool.cpp b/core/src/db/meta/MySQLConnectionPool.cpp
new file mode 100644
index 0000000000..ef013dce95
--- /dev/null
+++ b/core/src/db/meta/MySQLConnectionPool.cpp
@@ -0,0 +1,96 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "db/meta/MySQLConnectionPool.h"
+
+namespace milvus {
+namespace engine {
+namespace meta {
+
+// Do a simple form of in-use connection limiting: wait to return
+// a connection until there are a reasonably low number in use
+// already.  Can't do this in create() because we're interested in
+// connections actually in use, not those created.  Also note that
+// we keep our own count; ConnectionPool::size() isn't the same!
+mysqlpp::Connection*
+MySQLConnectionPool::grab() {
+    while (conns_in_use_ > max_pool_size_) {
+        sleep(1);
+    }
+
+    ++conns_in_use_;
+    return mysqlpp::ConnectionPool::grab();
+}
+
+// Other half of in-use conn count limit
+void
+MySQLConnectionPool::release(const mysqlpp::Connection* pc) {
+    mysqlpp::ConnectionPool::release(pc);
+    if (conns_in_use_ <= 0) {
+        ENGINE_LOG_WARNING << "MySQLConnetionPool::release: conns_in_use_ is less than zero.  conns_in_use_ = "
+                           << conns_in_use_;
+    } else {
+        --conns_in_use_;
+    }
+}
+
+//    int MySQLConnectionPool::getConnectionsInUse() {
+//        return conns_in_use_;
+//    }
+//
+//    void MySQLConnectionPool::set_max_idle_time(int max_idle) {
+//        max_idle_time_ = max_idle;
+//    }
+
+std::string
+MySQLConnectionPool::getDB() {
+    return db_;
+}
+
+// Superclass overrides
+mysqlpp::Connection*
+MySQLConnectionPool::create() {
+    try {
+        // Create connection using the parameters we were passed upon
+        // creation.
+        auto conn = new mysqlpp::Connection();
+        conn->set_option(new mysqlpp::ReconnectOption(true));
+        conn->connect(db_.empty() ? 0 : db_.c_str(), server_.empty() ? 0 : server_.c_str(),
+                      user_.empty() ? 0 : user_.c_str(), password_.empty() ? 0 : password_.c_str(), port_);
+        return conn;
+    } catch (const mysqlpp::ConnectionFailed& er) {
+        ENGINE_LOG_ERROR << "Failed to connect to database server"
+                         << ": " << er.what();
+        return nullptr;
+    }
+}
+
+void
+MySQLConnectionPool::destroy(mysqlpp::Connection* cp) {
+    // Our superclass can't know how we created the Connection, so
+    // it delegates destruction to us, to be safe.
+    delete cp;
+}
+
+unsigned int
+MySQLConnectionPool::max_idle_time() {
+    return max_idle_time_;
+}
+
+}  // namespace meta
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/db/meta/MySQLConnectionPool.h b/core/src/db/meta/MySQLConnectionPool.h
new file mode 100644
index 0000000000..60e353c3c4
--- /dev/null
+++ b/core/src/db/meta/MySQLConnectionPool.h
@@ -0,0 +1,91 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 <mysql++/mysql++.h>
+
+#include <unistd.h>
+#include <atomic>
+#include <string>
+
+#include "utils/Log.h"
+
+namespace milvus {
+namespace engine {
+namespace meta {
+
+class MySQLConnectionPool : public mysqlpp::ConnectionPool {
+ public:
+    // The object's only constructor
+    MySQLConnectionPool(std::string dbName, std::string userName, std::string passWord, std::string serverIp,
+                        int port = 0, int maxPoolSize = 8)
+        : db_(dbName),
+          user_(userName),
+          password_(passWord),
+          server_(serverIp),
+          port_(port),
+          max_pool_size_(maxPoolSize) {
+        conns_in_use_ = 0;
+        max_idle_time_ = 10;  // 10 seconds
+    }
+
+    // The destructor.  We _must_ call ConnectionPool::clear() here,
+    // because our superclass can't do it for us.
+    ~MySQLConnectionPool() override {
+        clear();
+    }
+
+    mysqlpp::Connection*
+    grab() override;
+
+    // Other half of in-use conn count limit
+    void
+    release(const mysqlpp::Connection* pc) override;
+
+    //    int getConnectionsInUse();
+    //
+    //    void set_max_idle_time(int max_idle);
+
+    std::string
+    getDB();
+
+ protected:
+    // Superclass overrides
+    mysqlpp::Connection*
+    create() override;
+
+    void
+    destroy(mysqlpp::Connection* cp) override;
+
+    unsigned int
+    max_idle_time() override;
+
+ private:
+    // Number of connections currently in use
+    std::atomic<int> conns_in_use_;
+
+    // Our connection parameters
+    std::string db_, user_, password_, server_;
+    int port_;
+
+    int max_pool_size_;
+
+    unsigned int max_idle_time_;
+};
+
+}  // namespace meta
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/db/meta/MySQLMetaImpl.cpp b/core/src/db/meta/MySQLMetaImpl.cpp
new file mode 100644
index 0000000000..44594636ad
--- /dev/null
+++ b/core/src/db/meta/MySQLMetaImpl.cpp
@@ -0,0 +1,1998 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "db/meta/MySQLMetaImpl.h"
+#include "MetaConsts.h"
+#include "db/IDGenerator.h"
+#include "db/Utils.h"
+#include "metrics/Metrics.h"
+#include "utils/Exception.h"
+#include "utils/Log.h"
+
+#include <mysql++/mysql++.h>
+#include <string.h>
+#include <unistd.h>
+#include <boost/filesystem.hpp>
+#include <chrono>
+#include <fstream>
+#include <iostream>
+#include <map>
+#include <mutex>
+#include <regex>
+#include <set>
+#include <sstream>
+#include <string>
+#include <thread>
+
+namespace milvus {
+namespace engine {
+namespace meta {
+
+namespace {
+
+Status
+HandleException(const std::string& desc, const char* what = nullptr) {
+    if (what == nullptr) {
+        ENGINE_LOG_ERROR << desc;
+        return Status(DB_META_TRANSACTION_FAILED, desc);
+    }
+
+    std::string msg = desc + ":" + what;
+    ENGINE_LOG_ERROR << msg;
+    return Status(DB_META_TRANSACTION_FAILED, msg);
+}
+
+class MetaField {
+ public:
+    MetaField(const std::string& name, const std::string& type, const std::string& setting)
+        : name_(name), type_(type), setting_(setting) {
+    }
+
+    std::string
+    name() const {
+        return name_;
+    }
+
+    std::string
+    ToString() const {
+        return name_ + " " + type_ + " " + setting_;
+    }
+
+    // mysql field type has additional information. for instance, a filed type is defined as 'BIGINT'
+    // we get the type from sql is 'bigint(20)', so we need to ignore the '(20)'
+    bool
+    IsEqual(const MetaField& field) const {
+        size_t name_len_min = field.name_.length() > name_.length() ? name_.length() : field.name_.length();
+        size_t type_len_min = field.type_.length() > type_.length() ? type_.length() : field.type_.length();
+        return strncasecmp(field.name_.c_str(), name_.c_str(), name_len_min) == 0 &&
+               strncasecmp(field.type_.c_str(), type_.c_str(), type_len_min) == 0;
+    }
+
+ private:
+    std::string name_;
+    std::string type_;
+    std::string setting_;
+};
+
+using MetaFields = std::vector<MetaField>;
+class MetaSchema {
+ public:
+    MetaSchema(const std::string& name, const MetaFields& fields) : name_(name), fields_(fields) {
+    }
+
+    std::string
+    name() const {
+        return name_;
+    }
+
+    std::string
+    ToString() const {
+        std::string result;
+        for (auto& field : fields_) {
+            if (!result.empty()) {
+                result += ",";
+            }
+            result += field.ToString();
+        }
+        return result;
+    }
+
+    // if the outer fields contains all this MetaSchema fields, return true
+    // otherwise return false
+    bool
+    IsEqual(const MetaFields& fields) const {
+        std::vector<std::string> found_field;
+        for (const auto& this_field : fields_) {
+            for (const auto& outer_field : fields) {
+                if (this_field.IsEqual(outer_field)) {
+                    found_field.push_back(this_field.name());
+                    break;
+                }
+            }
+        }
+
+        return found_field.size() == fields_.size();
+    }
+
+ private:
+    std::string name_;
+    MetaFields fields_;
+};
+
+// Tables schema
+static const MetaSchema TABLES_SCHEMA(META_TABLES, {
+                                                       MetaField("id", "BIGINT", "PRIMARY KEY AUTO_INCREMENT"),
+                                                       MetaField("table_id", "VARCHAR(255)", "UNIQUE NOT NULL"),
+                                                       MetaField("state", "INT", "NOT NULL"),
+                                                       MetaField("dimension", "SMALLINT", "NOT NULL"),
+                                                       MetaField("created_on", "BIGINT", "NOT NULL"),
+                                                       MetaField("flag", "BIGINT", "DEFAULT 0 NOT NULL"),
+                                                       MetaField("index_file_size", "BIGINT", "DEFAULT 1024 NOT NULL"),
+                                                       MetaField("engine_type", "INT", "DEFAULT 1 NOT NULL"),
+                                                       MetaField("nlist", "INT", "DEFAULT 16384 NOT NULL"),
+                                                       MetaField("metric_type", "INT", "DEFAULT 1 NOT NULL"),
+                                                   });
+
+// TableFiles schema
+static const MetaSchema TABLEFILES_SCHEMA(META_TABLEFILES, {
+                                                               MetaField("id", "BIGINT", "PRIMARY KEY AUTO_INCREMENT"),
+                                                               MetaField("table_id", "VARCHAR(255)", "NOT NULL"),
+                                                               MetaField("engine_type", "INT", "DEFAULT 1 NOT NULL"),
+                                                               MetaField("file_id", "VARCHAR(255)", "NOT NULL"),
+                                                               MetaField("file_type", "INT", "DEFAULT 0 NOT NULL"),
+                                                               MetaField("file_size", "BIGINT", "DEFAULT 0 NOT NULL"),
+                                                               MetaField("row_count", "BIGINT", "DEFAULT 0 NOT NULL"),
+                                                               MetaField("updated_time", "BIGINT", "NOT NULL"),
+                                                               MetaField("created_on", "BIGINT", "NOT NULL"),
+                                                               MetaField("date", "INT", "DEFAULT -1 NOT NULL"),
+                                                           });
+
+}  // namespace
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+MySQLMetaImpl::MySQLMetaImpl(const DBMetaOptions& options, const int& mode) : options_(options), mode_(mode) {
+    Initialize();
+}
+
+MySQLMetaImpl::~MySQLMetaImpl() {
+}
+
+Status
+MySQLMetaImpl::NextTableId(std::string& table_id) {
+    std::stringstream ss;
+    SimpleIDGenerator g;
+    ss << g.GetNextIDNumber();
+    table_id = ss.str();
+    return Status::OK();
+}
+
+Status
+MySQLMetaImpl::NextFileId(std::string& file_id) {
+    std::stringstream ss;
+    SimpleIDGenerator g;
+    ss << g.GetNextIDNumber();
+    file_id = ss.str();
+    return Status::OK();
+}
+
+void
+MySQLMetaImpl::ValidateMetaSchema() {
+    if (nullptr == mysql_connection_pool_) {
+        return;
+    }
+
+    mysqlpp::ScopedConnection connectionPtr(*mysql_connection_pool_, safe_grab_);
+    if (connectionPtr == nullptr) {
+        return;
+    }
+
+    auto validate_func = [&](const MetaSchema& schema) {
+        mysqlpp::Query query_statement = connectionPtr->query();
+        query_statement << "DESC " << schema.name() << ";";
+
+        MetaFields exist_fields;
+
+        try {
+            mysqlpp::StoreQueryResult res = query_statement.store();
+            for (size_t i = 0; i < res.num_rows(); i++) {
+                const mysqlpp::Row& row = res[i];
+                std::string name, type;
+                row["Field"].to_string(name);
+                row["Type"].to_string(type);
+
+                exist_fields.push_back(MetaField(name, type, ""));
+            }
+        } catch (std::exception& e) {
+            ENGINE_LOG_DEBUG << "Meta table '" << schema.name() << "' not exist and will be created";
+        }
+
+        if (exist_fields.empty()) {
+            return true;
+        }
+
+        return schema.IsEqual(exist_fields);
+    };
+
+    // verify Tables
+    if (!validate_func(TABLES_SCHEMA)) {
+        throw Exception(DB_INCOMPATIB_META, "Meta Tables schema is created by Milvus old version");
+    }
+
+    // verufy TableFiles
+    if (!validate_func(TABLEFILES_SCHEMA)) {
+        throw Exception(DB_INCOMPATIB_META, "Meta TableFiles schema is created by Milvus old version");
+    }
+}
+
+Status
+MySQLMetaImpl::Initialize() {
+    // step 1: create db root path
+    if (!boost::filesystem::is_directory(options_.path_)) {
+        auto ret = boost::filesystem::create_directory(options_.path_);
+        if (!ret) {
+            std::string msg = "Failed to create db directory " + options_.path_;
+            ENGINE_LOG_ERROR << msg;
+            return Status(DB_META_TRANSACTION_FAILED, msg);
+        }
+    }
+
+    std::string uri = options_.backend_uri_;
+
+    // step 2: parse and check meta uri
+    utils::MetaUriInfo uri_info;
+    auto status = utils::ParseMetaUri(uri, uri_info);
+    if (!status.ok()) {
+        std::string msg = "Wrong URI format: " + uri;
+        ENGINE_LOG_ERROR << msg;
+        throw Exception(DB_INVALID_META_URI, msg);
+    }
+
+    if (strcasecmp(uri_info.dialect_.c_str(), "mysql") != 0) {
+        std::string msg = "URI's dialect is not MySQL";
+        ENGINE_LOG_ERROR << msg;
+        throw Exception(DB_INVALID_META_URI, msg);
+    }
+
+    // step 3: connect mysql
+    int thread_hint = std::thread::hardware_concurrency();
+    int max_pool_size = (thread_hint == 0) ? 8 : thread_hint;
+    unsigned int port = 0;
+    if (!uri_info.port_.empty()) {
+        port = std::stoi(uri_info.port_);
+    }
+
+    mysql_connection_pool_ = std::make_shared<MySQLConnectionPool>(
+        uri_info.db_name_, uri_info.username_, uri_info.password_, uri_info.host_, port, max_pool_size);
+    ENGINE_LOG_DEBUG << "MySQL connection pool: maximum pool size = " << std::to_string(max_pool_size);
+
+    // step 4: validate to avoid open old version schema
+    ValidateMetaSchema();
+
+    // step 5: create meta tables
+    try {
+        if (mode_ != DBOptions::MODE::CLUSTER_READONLY) {
+            CleanUp();
+        }
+
+        {
+            mysqlpp::ScopedConnection connectionPtr(*mysql_connection_pool_, safe_grab_);
+
+            if (connectionPtr == nullptr) {
+                return Status(DB_ERROR, "Failed to connect to database server");
+            }
+
+            if (!connectionPtr->thread_aware()) {
+                ENGINE_LOG_ERROR << "MySQL++ wasn't built with thread awareness! Can't run without it.";
+                return Status(DB_ERROR, "MySQL++ wasn't built with thread awareness! Can't run without it.");
+            }
+            mysqlpp::Query InitializeQuery = connectionPtr->query();
+
+            InitializeQuery << "CREATE TABLE IF NOT EXISTS " << TABLES_SCHEMA.name() << " ("
+                            << TABLES_SCHEMA.ToString() + ");";
+
+            ENGINE_LOG_DEBUG << "MySQLMetaImpl::Initialize: " << InitializeQuery.str();
+
+            if (!InitializeQuery.exec()) {
+                return HandleException("Initialization Error", InitializeQuery.error());
+            }
+
+            InitializeQuery << "CREATE TABLE IF NOT EXISTS " << TABLEFILES_SCHEMA.name() << " ("
+                            << TABLEFILES_SCHEMA.ToString() + ");";
+
+            ENGINE_LOG_DEBUG << "MySQLMetaImpl::Initialize: " << InitializeQuery.str();
+
+            if (!InitializeQuery.exec()) {
+                return HandleException("Initialization Error", InitializeQuery.error());
+            }
+        }  // Scoped Connection
+    } catch (std::exception& e) {
+        return HandleException("GENERAL ERROR DURING INITIALIZATION", e.what());
+    }
+
+    return Status::OK();
+}
+
+// TODO(myh): Delete single vecotor by id
+Status
+MySQLMetaImpl::DropPartitionsByDates(const std::string& table_id, const DatesT& dates) {
+    if (dates.empty()) {
+        return Status::OK();
+    }
+
+    TableSchema table_schema;
+    table_schema.table_id_ = table_id;
+    auto status = DescribeTable(table_schema);
+    if (!status.ok()) {
+        return status;
+    }
+
+    try {
+        std::stringstream dateListSS;
+        for (auto& date : dates) {
+            dateListSS << std::to_string(date) << ", ";
+        }
+        std::string dateListStr = dateListSS.str();
+        dateListStr = dateListStr.substr(0, dateListStr.size() - 2);  // remove the last ", "
+
+        {
+            mysqlpp::ScopedConnection connectionPtr(*mysql_connection_pool_, safe_grab_);
+
+            if (connectionPtr == nullptr) {
+                return Status(DB_ERROR, "Failed to connect to database server");
+            }
+
+            mysqlpp::Query dropPartitionsByDatesQuery = connectionPtr->query();
+
+            dropPartitionsByDatesQuery << "UPDATE " << META_TABLEFILES << " "
+                                       << "SET file_type = " << std::to_string(TableFileSchema::TO_DELETE) << ","
+                                       << "updated_time = " << utils::GetMicroSecTimeStamp() << " "
+                                       << "WHERE table_id = " << mysqlpp::quote << table_id << " AND "
+                                       << "date in (" << dateListStr << ");";
+
+            ENGINE_LOG_DEBUG << "MySQLMetaImpl::DropPartitionsByDates: " << dropPartitionsByDatesQuery.str();
+
+            if (!dropPartitionsByDatesQuery.exec()) {
+                return HandleException("QUERY ERROR WHEN DROPPING PARTITIONS BY DATES",
+                                       dropPartitionsByDatesQuery.error());
+            }
+        }  // Scoped Connection
+
+        ENGINE_LOG_DEBUG << "Successfully drop partitions, table id = " << table_schema.table_id_;
+    } catch (std::exception& e) {
+        return HandleException("GENERAL ERROR WHEN DROPPING PARTITIONS BY DATES", e.what());
+    }
+    return Status::OK();
+}
+
+Status
+MySQLMetaImpl::CreateTable(TableSchema& table_schema) {
+    try {
+        server::MetricCollector metric;
+        {
+            mysqlpp::ScopedConnection connectionPtr(*mysql_connection_pool_, safe_grab_);
+
+            if (connectionPtr == nullptr) {
+                return Status(DB_ERROR, "Failed to connect to database server");
+            }
+
+            mysqlpp::Query createTableQuery = connectionPtr->query();
+
+            if (table_schema.table_id_.empty()) {
+                NextTableId(table_schema.table_id_);
+            } else {
+                createTableQuery << "SELECT state FROM " << META_TABLES << " "
+                                 << "WHERE table_id = " << mysqlpp::quote << table_schema.table_id_ << ";";
+
+                ENGINE_LOG_DEBUG << "MySQLMetaImpl::CreateTable: " << createTableQuery.str();
+
+                mysqlpp::StoreQueryResult res = createTableQuery.store();
+
+                if (res.num_rows() == 1) {
+                    int state = res[0]["state"];
+                    if (TableSchema::TO_DELETE == state) {
+                        return Status(DB_ERROR, "Table already exists and it is in delete state, please wait a second");
+                    } else {
+                        return Status(DB_ALREADY_EXIST, "Table already exists");
+                    }
+                }
+            }
+
+            table_schema.id_ = -1;
+            table_schema.created_on_ = utils::GetMicroSecTimeStamp();
+
+            std::string id = "NULL";  // auto-increment
+            std::string table_id = table_schema.table_id_;
+            std::string state = std::to_string(table_schema.state_);
+            std::string dimension = std::to_string(table_schema.dimension_);
+            std::string created_on = std::to_string(table_schema.created_on_);
+            std::string flag = std::to_string(table_schema.flag_);
+            std::string index_file_size = std::to_string(table_schema.index_file_size_);
+            std::string engine_type = std::to_string(table_schema.engine_type_);
+            std::string nlist = std::to_string(table_schema.nlist_);
+            std::string metric_type = std::to_string(table_schema.metric_type_);
+
+            createTableQuery << "INSERT INTO " << META_TABLES << " "
+                             << "VALUES(" << id << ", " << mysqlpp::quote << table_id << ", " << state << ", "
+                             << dimension << ", " << created_on << ", " << flag << ", " << index_file_size << ", "
+                             << engine_type << ", " << nlist << ", " << metric_type << ");";
+
+            ENGINE_LOG_DEBUG << "MySQLMetaImpl::CreateTable: " << createTableQuery.str();
+
+            if (mysqlpp::SimpleResult res = createTableQuery.execute()) {
+                table_schema.id_ = res.insert_id();  // Might need to use SELECT LAST_INSERT_ID()?
+
+                // Consume all results to avoid "Commands out of sync" error
+            } else {
+                return HandleException("Add Table Error", createTableQuery.error());
+            }
+        }  // Scoped Connection
+
+        ENGINE_LOG_DEBUG << "Successfully create table: " << table_schema.table_id_;
+        return utils::CreateTablePath(options_, table_schema.table_id_);
+    } catch (std::exception& e) {
+        return HandleException("GENERAL ERROR WHEN CREATING TABLE", e.what());
+    }
+}
+
+Status
+MySQLMetaImpl::FilesByType(const std::string& table_id, const std::vector<int>& file_types,
+                           std::vector<std::string>& file_ids) {
+    if (file_types.empty()) {
+        return Status(DB_ERROR, "file types array is empty");
+    }
+
+    try {
+        file_ids.clear();
+
+        mysqlpp::StoreQueryResult res;
+        {
+            mysqlpp::ScopedConnection connectionPtr(*mysql_connection_pool_, safe_grab_);
+
+            if (connectionPtr == nullptr) {
+                return Status(DB_ERROR, "Failed to connect to database server");
+            }
+
+            std::string types;
+            for (auto type : file_types) {
+                if (!types.empty()) {
+                    types += ",";
+                }
+                types += std::to_string(type);
+            }
+
+            mysqlpp::Query hasNonIndexFilesQuery = connectionPtr->query();
+            // since table_id is a unique column we just need to check whether it exists or not
+            hasNonIndexFilesQuery << "SELECT file_id, file_type FROM " << META_TABLEFILES << " "
+                                  << "WHERE table_id = " << mysqlpp::quote << table_id << " AND "
+                                  << "file_type in (" << types << ");";
+
+            ENGINE_LOG_DEBUG << "MySQLMetaImpl::FilesByType: " << hasNonIndexFilesQuery.str();
+
+            res = hasNonIndexFilesQuery.store();
+        }  // Scoped Connection
+
+        if (res.num_rows() > 0) {
+            int raw_count = 0, new_count = 0, new_merge_count = 0, new_index_count = 0;
+            int to_index_count = 0, index_count = 0, backup_count = 0;
+            for (auto& resRow : res) {
+                std::string file_id;
+                resRow["file_id"].to_string(file_id);
+                file_ids.push_back(file_id);
+
+                int32_t file_type = resRow["file_type"];
+                switch (file_type) {
+                    case (int)TableFileSchema::RAW:
+                        raw_count++;
+                        break;
+                    case (int)TableFileSchema::NEW:
+                        new_count++;
+                        break;
+                    case (int)TableFileSchema::NEW_MERGE:
+                        new_merge_count++;
+                        break;
+                    case (int)TableFileSchema::NEW_INDEX:
+                        new_index_count++;
+                        break;
+                    case (int)TableFileSchema::TO_INDEX:
+                        to_index_count++;
+                        break;
+                    case (int)TableFileSchema::INDEX:
+                        index_count++;
+                        break;
+                    case (int)TableFileSchema::BACKUP:
+                        backup_count++;
+                        break;
+                    default:
+                        break;
+                }
+            }
+
+            ENGINE_LOG_DEBUG << "Table " << table_id << " currently has raw files:" << raw_count
+                             << " new files:" << new_count << " new_merge files:" << new_merge_count
+                             << " new_index files:" << new_index_count << " to_index files:" << to_index_count
+                             << " index files:" << index_count << " backup files:" << backup_count;
+        }
+    } catch (std::exception& e) {
+        return HandleException("GENERAL ERROR WHEN GET FILE BY TYPE", e.what());
+    }
+
+    return Status::OK();
+}
+
+Status
+MySQLMetaImpl::UpdateTableIndex(const std::string& table_id, const TableIndex& index) {
+    try {
+        server::MetricCollector metric;
+
+        {
+            mysqlpp::ScopedConnection connectionPtr(*mysql_connection_pool_, safe_grab_);
+
+            if (connectionPtr == nullptr) {
+                return Status(DB_ERROR, "Failed to connect to database server");
+            }
+
+            mysqlpp::Query updateTableIndexParamQuery = connectionPtr->query();
+            updateTableIndexParamQuery << "SELECT id, state, dimension, created_on FROM " << META_TABLES << " "
+                                       << "WHERE table_id = " << mysqlpp::quote << table_id << " AND "
+                                       << "state <> " << std::to_string(TableSchema::TO_DELETE) << ";";
+
+            ENGINE_LOG_DEBUG << "MySQLMetaImpl::UpdateTableIndex: " << updateTableIndexParamQuery.str();
+
+            mysqlpp::StoreQueryResult res = updateTableIndexParamQuery.store();
+
+            if (res.num_rows() == 1) {
+                const mysqlpp::Row& resRow = res[0];
+
+                size_t id = resRow["id"];
+                int32_t state = resRow["state"];
+                uint16_t dimension = resRow["dimension"];
+                int64_t created_on = resRow["created_on"];
+
+                updateTableIndexParamQuery << "UPDATE " << META_TABLES << " "
+                                           << "SET id = " << id << ", "
+                                           << "state = " << state << ", "
+                                           << "dimension = " << dimension << ", "
+                                           << "created_on = " << created_on << ", "
+                                           << "engine_type = " << index.engine_type_ << ", "
+                                           << "nlist = " << index.nlist_ << ", "
+                                           << "metric_type = " << index.metric_type_ << " "
+                                           << "WHERE table_id = " << mysqlpp::quote << table_id << ";";
+
+                ENGINE_LOG_DEBUG << "MySQLMetaImpl::UpdateTableIndex: " << updateTableIndexParamQuery.str();
+
+                if (!updateTableIndexParamQuery.exec()) {
+                    return HandleException("QUERY ERROR WHEN UPDATING TABLE INDEX PARAM",
+                                           updateTableIndexParamQuery.error());
+                }
+            } else {
+                return Status(DB_NOT_FOUND, "Table " + table_id + " not found");
+            }
+        }  // Scoped Connection
+
+        ENGINE_LOG_DEBUG << "Successfully update table index, table id = " << table_id;
+    } catch (std::exception& e) {
+        return HandleException("GENERAL ERROR WHEN UPDATING TABLE INDEX PARAM", e.what());
+    }
+
+    return Status::OK();
+}
+
+Status
+MySQLMetaImpl::UpdateTableFlag(const std::string& table_id, int64_t flag) {
+    try {
+        server::MetricCollector metric;
+
+        {
+            mysqlpp::ScopedConnection connectionPtr(*mysql_connection_pool_, safe_grab_);
+
+            if (connectionPtr == nullptr) {
+                return Status(DB_ERROR, "Failed to connect to database server");
+            }
+
+            mysqlpp::Query updateTableFlagQuery = connectionPtr->query();
+            updateTableFlagQuery << "UPDATE " << META_TABLES << " "
+                                 << "SET flag = " << flag << " "
+                                 << "WHERE table_id = " << mysqlpp::quote << table_id << ";";
+
+            ENGINE_LOG_DEBUG << "MySQLMetaImpl::UpdateTableFlag: " << updateTableFlagQuery.str();
+
+            if (!updateTableFlagQuery.exec()) {
+                return HandleException("QUERY ERROR WHEN UPDATING TABLE FLAG", updateTableFlagQuery.error());
+            }
+        }  // Scoped Connection
+
+        ENGINE_LOG_DEBUG << "Successfully update table flag, table id = " << table_id;
+    } catch (std::exception& e) {
+        return HandleException("GENERAL ERROR WHEN UPDATING TABLE FLAG", e.what());
+    }
+
+    return Status::OK();
+}
+
+Status
+MySQLMetaImpl::DescribeTableIndex(const std::string& table_id, TableIndex& index) {
+    try {
+        server::MetricCollector metric;
+
+        {
+            mysqlpp::ScopedConnection connectionPtr(*mysql_connection_pool_, safe_grab_);
+
+            if (connectionPtr == nullptr) {
+                return Status(DB_ERROR, "Failed to connect to database server");
+            }
+
+            mysqlpp::Query describeTableIndexQuery = connectionPtr->query();
+            describeTableIndexQuery << "SELECT engine_type, nlist, index_file_size, metric_type FROM " << META_TABLES
+                                    << " "
+                                    << "WHERE table_id = " << mysqlpp::quote << table_id << " AND "
+                                    << "state <> " << std::to_string(TableSchema::TO_DELETE) << ";";
+
+            ENGINE_LOG_DEBUG << "MySQLMetaImpl::DescribeTableIndex: " << describeTableIndexQuery.str();
+
+            mysqlpp::StoreQueryResult res = describeTableIndexQuery.store();
+
+            if (res.num_rows() == 1) {
+                const mysqlpp::Row& resRow = res[0];
+
+                index.engine_type_ = resRow["engine_type"];
+                index.nlist_ = resRow["nlist"];
+                index.metric_type_ = resRow["metric_type"];
+            } else {
+                return Status(DB_NOT_FOUND, "Table " + table_id + " not found");
+            }
+        }  // Scoped Connection
+    } catch (std::exception& e) {
+        return HandleException("GENERAL ERROR WHEN UPDATING TABLE FLAG", e.what());
+    }
+
+    return Status::OK();
+}
+
+Status
+MySQLMetaImpl::DropTableIndex(const std::string& table_id) {
+    try {
+        server::MetricCollector metric;
+
+        {
+            mysqlpp::ScopedConnection connectionPtr(*mysql_connection_pool_, safe_grab_);
+
+            if (connectionPtr == nullptr) {
+                return Status(DB_ERROR, "Failed to connect to database server");
+            }
+
+            mysqlpp::Query dropTableIndexQuery = connectionPtr->query();
+
+            // soft delete index files
+            dropTableIndexQuery << "UPDATE " << META_TABLEFILES << " "
+                                << "SET file_type = " << std::to_string(TableFileSchema::TO_DELETE) << ","
+                                << "updated_time = " << utils::GetMicroSecTimeStamp() << " "
+                                << "WHERE table_id = " << mysqlpp::quote << table_id << " AND "
+                                << "file_type = " << std::to_string(TableFileSchema::INDEX) << ";";
+
+            ENGINE_LOG_DEBUG << "MySQLMetaImpl::DropTableIndex: " << dropTableIndexQuery.str();
+
+            if (!dropTableIndexQuery.exec()) {
+                return HandleException("QUERY ERROR WHEN DROPPING TABLE INDEX", dropTableIndexQuery.error());
+            }
+
+            // set all backup file to raw
+            dropTableIndexQuery << "UPDATE " << META_TABLEFILES << " "
+                                << "SET file_type = " << std::to_string(TableFileSchema::RAW) << ","
+                                << "updated_time = " << utils::GetMicroSecTimeStamp() << " "
+                                << "WHERE table_id = " << mysqlpp::quote << table_id << " AND "
+                                << "file_type = " << std::to_string(TableFileSchema::BACKUP) << ";";
+
+            ENGINE_LOG_DEBUG << "MySQLMetaImpl::DropTableIndex: " << dropTableIndexQuery.str();
+
+            if (!dropTableIndexQuery.exec()) {
+                return HandleException("QUERY ERROR WHEN DROPPING TABLE INDEX", dropTableIndexQuery.error());
+            }
+
+            // set table index type to raw
+            dropTableIndexQuery << "UPDATE " << META_TABLES << " "
+                                << "SET engine_type = " << std::to_string(DEFAULT_ENGINE_TYPE) << ","
+                                << "nlist = " << std::to_string(DEFAULT_NLIST) << ", "
+                                << "metric_type = " << std::to_string(DEFAULT_METRIC_TYPE) << " "
+                                << "WHERE table_id = " << mysqlpp::quote << table_id << ";";
+
+            ENGINE_LOG_DEBUG << "MySQLMetaImpl::DropTableIndex: " << dropTableIndexQuery.str();
+
+            if (!dropTableIndexQuery.exec()) {
+                return HandleException("QUERY ERROR WHEN DROPPING TABLE INDEX", dropTableIndexQuery.error());
+            }
+        }  // Scoped Connection
+
+        ENGINE_LOG_DEBUG << "Successfully drop table index, table id = " << table_id;
+    } catch (std::exception& e) {
+        return HandleException("GENERAL ERROR WHEN DROPPING TABLE INDEX", e.what());
+    }
+
+    return Status::OK();
+}
+
+Status
+MySQLMetaImpl::DeleteTable(const std::string& table_id) {
+    try {
+        server::MetricCollector metric;
+        {
+            mysqlpp::ScopedConnection connectionPtr(*mysql_connection_pool_, safe_grab_);
+
+            if (connectionPtr == nullptr) {
+                return Status(DB_ERROR, "Failed to connect to database server");
+            }
+
+            // soft delete table
+            mysqlpp::Query deleteTableQuery = connectionPtr->query();
+            //
+            deleteTableQuery << "UPDATE " << META_TABLES << " "
+                             << "SET state = " << std::to_string(TableSchema::TO_DELETE) << " "
+                             << "WHERE table_id = " << mysqlpp::quote << table_id << ";";
+
+            ENGINE_LOG_DEBUG << "MySQLMetaImpl::DeleteTable: " << deleteTableQuery.str();
+
+            if (!deleteTableQuery.exec()) {
+                return HandleException("QUERY ERROR WHEN DELETING TABLE", deleteTableQuery.error());
+            }
+        }  // Scoped Connection
+
+        if (mode_ == DBOptions::MODE::CLUSTER_WRITABLE) {
+            DeleteTableFiles(table_id);
+        }
+
+        ENGINE_LOG_DEBUG << "Successfully delete table, table id = " << table_id;
+    } catch (std::exception& e) {
+        return HandleException("GENERAL ERROR WHEN DELETING TABLE", e.what());
+    }
+
+    return Status::OK();
+}
+
+Status
+MySQLMetaImpl::DeleteTableFiles(const std::string& table_id) {
+    try {
+        server::MetricCollector metric;
+        {
+            mysqlpp::ScopedConnection connectionPtr(*mysql_connection_pool_, safe_grab_);
+
+            if (connectionPtr == nullptr) {
+                return Status(DB_ERROR, "Failed to connect to database server");
+            }
+
+            // soft delete table files
+            mysqlpp::Query deleteTableFilesQuery = connectionPtr->query();
+            //
+            deleteTableFilesQuery << "UPDATE " << META_TABLEFILES << " "
+                                  << "SET file_type = " << std::to_string(TableFileSchema::TO_DELETE) << ", "
+                                  << "updated_time = " << std::to_string(utils::GetMicroSecTimeStamp()) << " "
+                                  << "WHERE table_id = " << mysqlpp::quote << table_id << " AND "
+                                  << "file_type <> " << std::to_string(TableFileSchema::TO_DELETE) << ";";
+
+            ENGINE_LOG_DEBUG << "MySQLMetaImpl::DeleteTableFiles: " << deleteTableFilesQuery.str();
+
+            if (!deleteTableFilesQuery.exec()) {
+                return HandleException("QUERY ERROR WHEN DELETING TABLE FILES", deleteTableFilesQuery.error());
+            }
+        }  // Scoped Connection
+
+        ENGINE_LOG_DEBUG << "Successfully delete table files, table id = " << table_id;
+    } catch (std::exception& e) {
+        return HandleException("GENERAL ERROR WHEN DELETING TABLE FILES", e.what());
+    }
+
+    return Status::OK();
+}
+
+Status
+MySQLMetaImpl::DescribeTable(TableSchema& table_schema) {
+    try {
+        server::MetricCollector metric;
+        mysqlpp::StoreQueryResult res;
+        {
+            mysqlpp::ScopedConnection connectionPtr(*mysql_connection_pool_, safe_grab_);
+
+            if (connectionPtr == nullptr) {
+                return Status(DB_ERROR, "Failed to connect to database server");
+            }
+
+            mysqlpp::Query describeTableQuery = connectionPtr->query();
+            describeTableQuery
+                << "SELECT id, state, dimension, created_on, flag, index_file_size, engine_type, nlist, metric_type "
+                << " FROM " << META_TABLES << " "
+                << "WHERE table_id = " << mysqlpp::quote << table_schema.table_id_ << " "
+                << "AND state <> " << std::to_string(TableSchema::TO_DELETE) << ";";
+
+            ENGINE_LOG_DEBUG << "MySQLMetaImpl::DescribeTable: " << describeTableQuery.str();
+
+            res = describeTableQuery.store();
+        }  // Scoped Connection
+
+        if (res.num_rows() == 1) {
+            const mysqlpp::Row& resRow = res[0];
+
+            table_schema.id_ = resRow["id"];  // implicit conversion
+
+            table_schema.state_ = resRow["state"];
+
+            table_schema.dimension_ = resRow["dimension"];
+
+            table_schema.created_on_ = resRow["created_on"];
+
+            table_schema.flag_ = resRow["flag"];
+
+            table_schema.index_file_size_ = resRow["index_file_size"];
+
+            table_schema.engine_type_ = resRow["engine_type"];
+
+            table_schema.nlist_ = resRow["nlist"];
+
+            table_schema.metric_type_ = resRow["metric_type"];
+        } else {
+            return Status(DB_NOT_FOUND, "Table " + table_schema.table_id_ + " not found");
+        }
+    } catch (std::exception& e) {
+        return HandleException("GENERAL ERROR WHEN DESCRIBING TABLE", e.what());
+    }
+
+    return Status::OK();
+}
+
+Status
+MySQLMetaImpl::HasTable(const std::string& table_id, bool& has_or_not) {
+    try {
+        server::MetricCollector metric;
+        mysqlpp::StoreQueryResult res;
+        {
+            mysqlpp::ScopedConnection connectionPtr(*mysql_connection_pool_, safe_grab_);
+
+            if (connectionPtr == nullptr) {
+                return Status(DB_ERROR, "Failed to connect to database server");
+            }
+
+            mysqlpp::Query hasTableQuery = connectionPtr->query();
+            // since table_id is a unique column we just need to check whether it exists or not
+            hasTableQuery << "SELECT EXISTS "
+                          << "(SELECT 1 FROM " << META_TABLES << " "
+                          << "WHERE table_id = " << mysqlpp::quote << table_id << " "
+                          << "AND state <> " << std::to_string(TableSchema::TO_DELETE) << ") "
+                          << "AS " << mysqlpp::quote << "check"
+                          << ";";
+
+            ENGINE_LOG_DEBUG << "MySQLMetaImpl::HasTable: " << hasTableQuery.str();
+
+            res = hasTableQuery.store();
+        }  // Scoped Connection
+
+        int check = res[0]["check"];
+        has_or_not = (check == 1);
+    } catch (std::exception& e) {
+        return HandleException("GENERAL ERROR WHEN CHECKING IF TABLE EXISTS", e.what());
+    }
+
+    return Status::OK();
+}
+
+Status
+MySQLMetaImpl::AllTables(std::vector<TableSchema>& table_schema_array) {
+    try {
+        server::MetricCollector metric;
+        mysqlpp::StoreQueryResult res;
+        {
+            mysqlpp::ScopedConnection connectionPtr(*mysql_connection_pool_, safe_grab_);
+
+            if (connectionPtr == nullptr) {
+                return Status(DB_ERROR, "Failed to connect to database server");
+            }
+
+            mysqlpp::Query allTablesQuery = connectionPtr->query();
+            allTablesQuery << "SELECT id, table_id, dimension, engine_type, nlist, index_file_size, metric_type FROM "
+                           << META_TABLES << " "
+                           << "WHERE state <> " << std::to_string(TableSchema::TO_DELETE) << ";";
+
+            ENGINE_LOG_DEBUG << "MySQLMetaImpl::AllTables: " << allTablesQuery.str();
+
+            res = allTablesQuery.store();
+        }  // Scoped Connection
+
+        for (auto& resRow : res) {
+            TableSchema table_schema;
+
+            table_schema.id_ = resRow["id"];  // implicit conversion
+
+            std::string table_id;
+            resRow["table_id"].to_string(table_id);
+            table_schema.table_id_ = table_id;
+
+            table_schema.dimension_ = resRow["dimension"];
+
+            table_schema.index_file_size_ = resRow["index_file_size"];
+
+            table_schema.engine_type_ = resRow["engine_type"];
+
+            table_schema.nlist_ = resRow["nlist"];
+
+            table_schema.metric_type_ = resRow["metric_type"];
+
+            table_schema_array.emplace_back(table_schema);
+        }
+    } catch (std::exception& e) {
+        return HandleException("GENERAL ERROR WHEN DESCRIBING ALL TABLES", e.what());
+    }
+
+    return Status::OK();
+}
+
+Status
+MySQLMetaImpl::CreateTableFile(TableFileSchema& file_schema) {
+    if (file_schema.date_ == EmptyDate) {
+        file_schema.date_ = utils::GetDate();
+    }
+    TableSchema table_schema;
+    table_schema.table_id_ = file_schema.table_id_;
+    auto status = DescribeTable(table_schema);
+    if (!status.ok()) {
+        return status;
+    }
+
+    try {
+        server::MetricCollector metric;
+
+        NextFileId(file_schema.file_id_);
+        file_schema.dimension_ = table_schema.dimension_;
+        file_schema.file_size_ = 0;
+        file_schema.row_count_ = 0;
+        file_schema.created_on_ = utils::GetMicroSecTimeStamp();
+        file_schema.updated_time_ = file_schema.created_on_;
+        file_schema.index_file_size_ = table_schema.index_file_size_;
+        file_schema.engine_type_ = table_schema.engine_type_;
+        file_schema.nlist_ = table_schema.nlist_;
+        file_schema.metric_type_ = table_schema.metric_type_;
+
+        std::string id = "NULL";  // auto-increment
+        std::string table_id = file_schema.table_id_;
+        std::string engine_type = std::to_string(file_schema.engine_type_);
+        std::string file_id = file_schema.file_id_;
+        std::string file_type = std::to_string(file_schema.file_type_);
+        std::string file_size = std::to_string(file_schema.file_size_);
+        std::string row_count = std::to_string(file_schema.row_count_);
+        std::string updated_time = std::to_string(file_schema.updated_time_);
+        std::string created_on = std::to_string(file_schema.created_on_);
+        std::string date = std::to_string(file_schema.date_);
+
+        {
+            mysqlpp::ScopedConnection connectionPtr(*mysql_connection_pool_, safe_grab_);
+
+            if (connectionPtr == nullptr) {
+                return Status(DB_ERROR, "Failed to connect to database server");
+            }
+
+            mysqlpp::Query createTableFileQuery = connectionPtr->query();
+
+            createTableFileQuery << "INSERT INTO " << META_TABLEFILES << " "
+                                 << "VALUES(" << id << ", " << mysqlpp::quote << table_id << ", " << engine_type << ", "
+                                 << mysqlpp::quote << file_id << ", " << file_type << ", " << file_size << ", "
+                                 << row_count << ", " << updated_time << ", " << created_on << ", " << date << ");";
+
+            ENGINE_LOG_DEBUG << "MySQLMetaImpl::CreateTableFile: " << createTableFileQuery.str();
+
+            if (mysqlpp::SimpleResult res = createTableFileQuery.execute()) {
+                file_schema.id_ = res.insert_id();  // Might need to use SELECT LAST_INSERT_ID()?
+
+                // Consume all results to avoid "Commands out of sync" error
+            } else {
+                return HandleException("QUERY ERROR WHEN CREATING TABLE FILE", createTableFileQuery.error());
+            }
+        }  // Scoped Connection
+
+        ENGINE_LOG_DEBUG << "Successfully create table file, file id = " << file_schema.file_id_;
+        return utils::CreateTableFilePath(options_, file_schema);
+    } catch (std::exception& e) {
+        return HandleException("GENERAL ERROR WHEN CREATING TABLE FILE", e.what());
+    }
+}
+
+Status
+MySQLMetaImpl::FilesToIndex(TableFilesSchema& files) {
+    files.clear();
+
+    try {
+        server::MetricCollector metric;
+        mysqlpp::StoreQueryResult res;
+        {
+            mysqlpp::ScopedConnection connectionPtr(*mysql_connection_pool_, safe_grab_);
+
+            if (connectionPtr == nullptr) {
+                return Status(DB_ERROR, "Failed to connect to database server");
+            }
+
+            mysqlpp::Query filesToIndexQuery = connectionPtr->query();
+            filesToIndexQuery
+                << "SELECT id, table_id, engine_type, file_id, file_type, file_size, row_count, date, created_on FROM "
+                << META_TABLEFILES << " "
+                << "WHERE file_type = " << std::to_string(TableFileSchema::TO_INDEX) << ";";
+
+            ENGINE_LOG_DEBUG << "MySQLMetaImpl::FilesToIndex: " << filesToIndexQuery.str();
+
+            res = filesToIndexQuery.store();
+        }  // Scoped Connection
+
+        Status ret;
+        std::map<std::string, TableSchema> groups;
+        TableFileSchema table_file;
+        for (auto& resRow : res) {
+            table_file.id_ = resRow["id"];  // implicit conversion
+
+            std::string table_id;
+            resRow["table_id"].to_string(table_id);
+            table_file.table_id_ = table_id;
+
+            table_file.engine_type_ = resRow["engine_type"];
+
+            std::string file_id;
+            resRow["file_id"].to_string(file_id);
+            table_file.file_id_ = file_id;
+
+            table_file.file_type_ = resRow["file_type"];
+
+            table_file.file_size_ = resRow["file_size"];
+
+            table_file.row_count_ = resRow["row_count"];
+
+            table_file.date_ = resRow["date"];
+
+            table_file.created_on_ = resRow["created_on"];
+
+            auto groupItr = groups.find(table_file.table_id_);
+            if (groupItr == groups.end()) {
+                TableSchema table_schema;
+                table_schema.table_id_ = table_file.table_id_;
+                auto status = DescribeTable(table_schema);
+                if (!status.ok()) {
+                    return status;
+                }
+                groups[table_file.table_id_] = table_schema;
+            }
+            table_file.dimension_ = groups[table_file.table_id_].dimension_;
+            table_file.index_file_size_ = groups[table_file.table_id_].index_file_size_;
+            table_file.nlist_ = groups[table_file.table_id_].nlist_;
+            table_file.metric_type_ = groups[table_file.table_id_].metric_type_;
+
+            auto status = utils::GetTableFilePath(options_, table_file);
+            if (!status.ok()) {
+                ret = status;
+            }
+
+            files.push_back(table_file);
+        }
+
+        if (res.size() > 0) {
+            ENGINE_LOG_DEBUG << "Collect " << res.size() << " to-index files";
+        }
+        return ret;
+    } catch (std::exception& e) {
+        return HandleException("GENERAL ERROR WHEN FINDING TABLE FILES TO INDEX", e.what());
+    }
+}
+
+Status
+MySQLMetaImpl::FilesToSearch(const std::string& table_id, const std::vector<size_t>& ids, const DatesT& dates,
+                             DatePartionedTableFilesSchema& files) {
+    files.clear();
+
+    try {
+        server::MetricCollector metric;
+        mysqlpp::StoreQueryResult res;
+        {
+            mysqlpp::ScopedConnection connectionPtr(*mysql_connection_pool_, safe_grab_);
+
+            if (connectionPtr == nullptr) {
+                return Status(DB_ERROR, "Failed to connect to database server");
+            }
+
+            mysqlpp::Query filesToSearchQuery = connectionPtr->query();
+            filesToSearchQuery
+                << "SELECT id, table_id, engine_type, file_id, file_type, file_size, row_count, date FROM "
+                << META_TABLEFILES << " "
+                << "WHERE table_id = " << mysqlpp::quote << table_id;
+
+            if (!dates.empty()) {
+                std::stringstream partitionListSS;
+                for (auto& date : dates) {
+                    partitionListSS << std::to_string(date) << ", ";
+                }
+                std::string partitionListStr = partitionListSS.str();
+
+                partitionListStr = partitionListStr.substr(0, partitionListStr.size() - 2);  // remove the last ", "
+                filesToSearchQuery << " AND "
+                                   << "date IN (" << partitionListStr << ")";
+            }
+
+            if (!ids.empty()) {
+                std::stringstream idSS;
+                for (auto& id : ids) {
+                    idSS << "id = " << std::to_string(id) << " OR ";
+                }
+                std::string idStr = idSS.str();
+                idStr = idStr.substr(0, idStr.size() - 4);  // remove the last " OR "
+
+                filesToSearchQuery << " AND "
+                                   << "(" << idStr << ")";
+            }
+            // End
+            filesToSearchQuery << " AND "
+                               << "(file_type = " << std::to_string(TableFileSchema::RAW) << " OR "
+                               << "file_type = " << std::to_string(TableFileSchema::TO_INDEX) << " OR "
+                               << "file_type = " << std::to_string(TableFileSchema::INDEX) << ");";
+
+            ENGINE_LOG_DEBUG << "MySQLMetaImpl::FilesToSearch: " << filesToSearchQuery.str();
+
+            res = filesToSearchQuery.store();
+        }  // Scoped Connection
+
+        TableSchema table_schema;
+        table_schema.table_id_ = table_id;
+        auto status = DescribeTable(table_schema);
+        if (!status.ok()) {
+            return status;
+        }
+
+        Status ret;
+        TableFileSchema table_file;
+        for (auto& resRow : res) {
+            table_file.id_ = resRow["id"];  // implicit conversion
+
+            std::string table_id_str;
+            resRow["table_id"].to_string(table_id_str);
+            table_file.table_id_ = table_id_str;
+
+            table_file.index_file_size_ = table_schema.index_file_size_;
+
+            table_file.engine_type_ = resRow["engine_type"];
+
+            table_file.nlist_ = table_schema.nlist_;
+
+            table_file.metric_type_ = table_schema.metric_type_;
+
+            std::string file_id;
+            resRow["file_id"].to_string(file_id);
+            table_file.file_id_ = file_id;
+
+            table_file.file_type_ = resRow["file_type"];
+
+            table_file.file_size_ = resRow["file_size"];
+
+            table_file.row_count_ = resRow["row_count"];
+
+            table_file.date_ = resRow["date"];
+
+            table_file.dimension_ = table_schema.dimension_;
+
+            auto status = utils::GetTableFilePath(options_, table_file);
+            if (!status.ok()) {
+                ret = status;
+            }
+
+            auto dateItr = files.find(table_file.date_);
+            if (dateItr == files.end()) {
+                files[table_file.date_] = TableFilesSchema();
+            }
+
+            files[table_file.date_].push_back(table_file);
+        }
+
+        if (res.size() > 0) {
+            ENGINE_LOG_DEBUG << "Collect " << res.size() << " to-search files";
+        }
+        return ret;
+    } catch (std::exception& e) {
+        return HandleException("GENERAL ERROR WHEN FINDING TABLE FILES TO SEARCH", e.what());
+    }
+}
+
+Status
+MySQLMetaImpl::FilesToMerge(const std::string& table_id, DatePartionedTableFilesSchema& files) {
+    files.clear();
+
+    try {
+        server::MetricCollector metric;
+
+        // check table existence
+        TableSchema table_schema;
+        table_schema.table_id_ = table_id;
+        auto status = DescribeTable(table_schema);
+        if (!status.ok()) {
+            return status;
+        }
+
+        mysqlpp::StoreQueryResult res;
+        {
+            mysqlpp::ScopedConnection connectionPtr(*mysql_connection_pool_, safe_grab_);
+
+            if (connectionPtr == nullptr) {
+                return Status(DB_ERROR, "Failed to connect to database server");
+            }
+
+            mysqlpp::Query filesToMergeQuery = connectionPtr->query();
+            filesToMergeQuery
+                << "SELECT id, table_id, file_id, file_type, file_size, row_count, date, engine_type, created_on FROM "
+                << META_TABLEFILES << " "
+                << "WHERE table_id = " << mysqlpp::quote << table_id << " AND "
+                << "file_type = " << std::to_string(TableFileSchema::RAW) << " "
+                << "ORDER BY row_count DESC"
+                << ";";
+
+            ENGINE_LOG_DEBUG << "MySQLMetaImpl::FilesToMerge: " << filesToMergeQuery.str();
+
+            res = filesToMergeQuery.store();
+        }  // Scoped Connection
+
+        Status ret;
+        for (auto& resRow : res) {
+            TableFileSchema table_file;
+            table_file.file_size_ = resRow["file_size"];
+            if (table_file.file_size_ >= table_schema.index_file_size_) {
+                continue;  // skip large file
+            }
+
+            table_file.id_ = resRow["id"];  // implicit conversion
+
+            std::string table_id_str;
+            resRow["table_id"].to_string(table_id_str);
+            table_file.table_id_ = table_id_str;
+
+            std::string file_id;
+            resRow["file_id"].to_string(file_id);
+            table_file.file_id_ = file_id;
+
+            table_file.file_type_ = resRow["file_type"];
+
+            table_file.row_count_ = resRow["row_count"];
+
+            table_file.date_ = resRow["date"];
+
+            table_file.index_file_size_ = table_schema.index_file_size_;
+
+            table_file.engine_type_ = resRow["engine_type"];
+
+            table_file.nlist_ = table_schema.nlist_;
+
+            table_file.metric_type_ = table_schema.metric_type_;
+
+            table_file.created_on_ = resRow["created_on"];
+
+            table_file.dimension_ = table_schema.dimension_;
+
+            auto status = utils::GetTableFilePath(options_, table_file);
+            if (!status.ok()) {
+                ret = status;
+            }
+
+            auto dateItr = files.find(table_file.date_);
+            if (dateItr == files.end()) {
+                files[table_file.date_] = TableFilesSchema();
+            }
+
+            files[table_file.date_].push_back(table_file);
+        }
+
+        if (res.size() > 0) {
+            ENGINE_LOG_DEBUG << "Collect " << res.size() << " to-merge files";
+        }
+        return ret;
+    } catch (std::exception& e) {
+        return HandleException("GENERAL ERROR WHEN FINDING TABLE FILES TO MERGE", e.what());
+    }
+}
+
+Status
+MySQLMetaImpl::GetTableFiles(const std::string& table_id, const std::vector<size_t>& ids,
+                             TableFilesSchema& table_files) {
+    if (ids.empty()) {
+        return Status::OK();
+    }
+
+    std::stringstream idSS;
+    for (auto& id : ids) {
+        idSS << "id = " << std::to_string(id) << " OR ";
+    }
+    std::string idStr = idSS.str();
+    idStr = idStr.substr(0, idStr.size() - 4);  // remove the last " OR "
+
+    try {
+        mysqlpp::StoreQueryResult res;
+        {
+            mysqlpp::ScopedConnection connectionPtr(*mysql_connection_pool_, safe_grab_);
+
+            if (connectionPtr == nullptr) {
+                return Status(DB_ERROR, "Failed to connect to database server");
+            }
+
+            mysqlpp::Query getTableFileQuery = connectionPtr->query();
+            getTableFileQuery
+                << "SELECT id, engine_type, file_id, file_type, file_size, row_count, date, created_on FROM "
+                << META_TABLEFILES << " "
+                << "WHERE table_id = " << mysqlpp::quote << table_id << " AND "
+                << "(" << idStr << ") AND "
+                << "file_type <> " << std::to_string(TableFileSchema::TO_DELETE) << ";";
+
+            ENGINE_LOG_DEBUG << "MySQLMetaImpl::GetTableFiles: " << getTableFileQuery.str();
+
+            res = getTableFileQuery.store();
+        }  // Scoped Connection
+
+        TableSchema table_schema;
+        table_schema.table_id_ = table_id;
+        DescribeTable(table_schema);
+
+        Status ret;
+        for (auto& resRow : res) {
+            TableFileSchema file_schema;
+
+            file_schema.id_ = resRow["id"];
+
+            file_schema.table_id_ = table_id;
+
+            file_schema.index_file_size_ = table_schema.index_file_size_;
+
+            file_schema.engine_type_ = resRow["engine_type"];
+
+            file_schema.nlist_ = table_schema.nlist_;
+
+            file_schema.metric_type_ = table_schema.metric_type_;
+
+            std::string file_id;
+            resRow["file_id"].to_string(file_id);
+            file_schema.file_id_ = file_id;
+
+            file_schema.file_type_ = resRow["file_type"];
+
+            file_schema.file_size_ = resRow["file_size"];
+
+            file_schema.row_count_ = resRow["row_count"];
+
+            file_schema.date_ = resRow["date"];
+
+            file_schema.created_on_ = resRow["created_on"];
+
+            file_schema.dimension_ = table_schema.dimension_;
+
+            utils::GetTableFilePath(options_, file_schema);
+
+            table_files.emplace_back(file_schema);
+        }
+
+        ENGINE_LOG_DEBUG << "Get table files by id";
+        return ret;
+    } catch (std::exception& e) {
+        return HandleException("GENERAL ERROR WHEN RETRIEVING TABLE FILES", e.what());
+    }
+}
+
+// TODO(myh): Support swap to cloud storage
+Status
+MySQLMetaImpl::Archive() {
+    auto& criterias = options_.archive_conf_.GetCriterias();
+    if (criterias.empty()) {
+        return Status::OK();
+    }
+
+    for (auto& kv : criterias) {
+        auto& criteria = kv.first;
+        auto& limit = kv.second;
+        if (criteria == engine::ARCHIVE_CONF_DAYS) {
+            size_t usecs = limit * D_SEC * US_PS;
+            int64_t now = utils::GetMicroSecTimeStamp();
+
+            try {
+                mysqlpp::ScopedConnection connectionPtr(*mysql_connection_pool_, safe_grab_);
+
+                if (connectionPtr == nullptr) {
+                    return Status(DB_ERROR, "Failed to connect to database server");
+                }
+
+                mysqlpp::Query archiveQuery = connectionPtr->query();
+                archiveQuery << "UPDATE " << META_TABLEFILES << " "
+                             << "SET file_type = " << std::to_string(TableFileSchema::TO_DELETE) << " "
+                             << "WHERE created_on < " << std::to_string(now - usecs) << " AND "
+                             << "file_type <> " << std::to_string(TableFileSchema::TO_DELETE) << ";";
+
+                ENGINE_LOG_DEBUG << "MySQLMetaImpl::Archive: " << archiveQuery.str();
+
+                if (!archiveQuery.exec()) {
+                    return HandleException("QUERY ERROR DURING ARCHIVE", archiveQuery.error());
+                }
+
+                ENGINE_LOG_DEBUG << "Archive old files";
+            } catch (std::exception& e) {
+                return HandleException("GENERAL ERROR WHEN DURING ARCHIVE", e.what());
+            }
+        }
+        if (criteria == engine::ARCHIVE_CONF_DISK) {
+            uint64_t sum = 0;
+            Size(sum);
+
+            auto to_delete = (sum - limit * G);
+            DiscardFiles(to_delete);
+
+            ENGINE_LOG_DEBUG << "Archive files to free disk";
+        }
+    }
+
+    return Status::OK();
+}
+
+Status
+MySQLMetaImpl::Size(uint64_t& result) {
+    result = 0;
+
+    try {
+        mysqlpp::StoreQueryResult res;
+        {
+            mysqlpp::ScopedConnection connectionPtr(*mysql_connection_pool_, safe_grab_);
+
+            if (connectionPtr == nullptr) {
+                return Status(DB_ERROR, "Failed to connect to database server");
+            }
+
+            mysqlpp::Query getSizeQuery = connectionPtr->query();
+            getSizeQuery << "SELECT IFNULL(SUM(file_size),0) AS sum FROM " << META_TABLEFILES << " "
+                         << "WHERE file_type <> " << std::to_string(TableFileSchema::TO_DELETE) << ";";
+
+            ENGINE_LOG_DEBUG << "MySQLMetaImpl::Size: " << getSizeQuery.str();
+
+            res = getSizeQuery.store();
+        }  // Scoped Connection
+
+        if (res.empty()) {
+            result = 0;
+        } else {
+            result = res[0]["sum"];
+        }
+    } catch (std::exception& e) {
+        return HandleException("GENERAL ERROR WHEN RETRIEVING SIZE", e.what());
+    }
+
+    return Status::OK();
+}
+
+Status
+MySQLMetaImpl::DiscardFiles(int64_t to_discard_size) {
+    if (to_discard_size <= 0) {
+        return Status::OK();
+    }
+    ENGINE_LOG_DEBUG << "About to discard size=" << to_discard_size;
+
+    try {
+        server::MetricCollector metric;
+        bool status;
+        {
+            mysqlpp::ScopedConnection connectionPtr(*mysql_connection_pool_, safe_grab_);
+
+            if (connectionPtr == nullptr) {
+                return Status(DB_ERROR, "Failed to connect to database server");
+            }
+
+            mysqlpp::Query discardFilesQuery = connectionPtr->query();
+            discardFilesQuery << "SELECT id, file_size FROM " << META_TABLEFILES << " "
+                              << "WHERE file_type <> " << std::to_string(TableFileSchema::TO_DELETE) << " "
+                              << "ORDER BY id ASC "
+                              << "LIMIT 10;";
+
+            ENGINE_LOG_DEBUG << "MySQLMetaImpl::DiscardFiles: " << discardFilesQuery.str();
+
+            mysqlpp::StoreQueryResult res = discardFilesQuery.store();
+            if (res.num_rows() == 0) {
+                return Status::OK();
+            }
+
+            TableFileSchema table_file;
+            std::stringstream idsToDiscardSS;
+            for (auto& resRow : res) {
+                if (to_discard_size <= 0) {
+                    break;
+                }
+                table_file.id_ = resRow["id"];
+                table_file.file_size_ = resRow["file_size"];
+                idsToDiscardSS << "id = " << std::to_string(table_file.id_) << " OR ";
+                ENGINE_LOG_DEBUG << "Discard table_file.id=" << table_file.file_id_
+                                 << " table_file.size=" << table_file.file_size_;
+                to_discard_size -= table_file.file_size_;
+            }
+
+            std::string idsToDiscardStr = idsToDiscardSS.str();
+            idsToDiscardStr = idsToDiscardStr.substr(0, idsToDiscardStr.size() - 4);  // remove the last " OR "
+
+            discardFilesQuery << "UPDATE " << META_TABLEFILES << " "
+                              << "SET file_type = " << std::to_string(TableFileSchema::TO_DELETE) << ", "
+                              << "updated_time = " << std::to_string(utils::GetMicroSecTimeStamp()) << " "
+                              << "WHERE " << idsToDiscardStr << ";";
+
+            ENGINE_LOG_DEBUG << "MySQLMetaImpl::DiscardFiles: " << discardFilesQuery.str();
+
+            status = discardFilesQuery.exec();
+            if (!status) {
+                return HandleException("QUERY ERROR WHEN DISCARDING FILES", discardFilesQuery.error());
+            }
+        }  // Scoped Connection
+
+        return DiscardFiles(to_discard_size);
+    } catch (std::exception& e) {
+        return HandleException("GENERAL ERROR WHEN DISCARDING FILES", e.what());
+    }
+}
+
+// ZR: this function assumes all fields in file_schema have value
+Status
+MySQLMetaImpl::UpdateTableFile(TableFileSchema& file_schema) {
+    file_schema.updated_time_ = utils::GetMicroSecTimeStamp();
+
+    try {
+        server::MetricCollector metric;
+        {
+            mysqlpp::ScopedConnection connectionPtr(*mysql_connection_pool_, safe_grab_);
+
+            if (connectionPtr == nullptr) {
+                return Status(DB_ERROR, "Failed to connect to database server");
+            }
+
+            mysqlpp::Query updateTableFileQuery = connectionPtr->query();
+
+            // if the table has been deleted, just mark the table file as TO_DELETE
+            // clean thread will delete the file later
+            updateTableFileQuery << "SELECT state FROM " << META_TABLES << " "
+                                 << "WHERE table_id = " << mysqlpp::quote << file_schema.table_id_ << ";";
+
+            ENGINE_LOG_DEBUG << "MySQLMetaImpl::UpdateTableFile: " << updateTableFileQuery.str();
+
+            mysqlpp::StoreQueryResult res = updateTableFileQuery.store();
+
+            if (res.num_rows() == 1) {
+                int state = res[0]["state"];
+                if (state == TableSchema::TO_DELETE) {
+                    file_schema.file_type_ = TableFileSchema::TO_DELETE;
+                }
+            } else {
+                file_schema.file_type_ = TableFileSchema::TO_DELETE;
+            }
+
+            std::string id = std::to_string(file_schema.id_);
+            std::string table_id = file_schema.table_id_;
+            std::string engine_type = std::to_string(file_schema.engine_type_);
+            std::string file_id = file_schema.file_id_;
+            std::string file_type = std::to_string(file_schema.file_type_);
+            std::string file_size = std::to_string(file_schema.file_size_);
+            std::string row_count = std::to_string(file_schema.row_count_);
+            std::string updated_time = std::to_string(file_schema.updated_time_);
+            std::string created_on = std::to_string(file_schema.created_on_);
+            std::string date = std::to_string(file_schema.date_);
+
+            updateTableFileQuery << "UPDATE " << META_TABLEFILES << " "
+                                 << "SET table_id = " << mysqlpp::quote << table_id << ", "
+                                 << "engine_type = " << engine_type << ", "
+                                 << "file_id = " << mysqlpp::quote << file_id << ", "
+                                 << "file_type = " << file_type << ", "
+                                 << "file_size = " << file_size << ", "
+                                 << "row_count = " << row_count << ", "
+                                 << "updated_time = " << updated_time << ", "
+                                 << "created_on = " << created_on << ", "
+                                 << "date = " << date << " "
+                                 << "WHERE id = " << id << ";";
+
+            ENGINE_LOG_DEBUG << "MySQLMetaImpl::UpdateTableFile: " << updateTableFileQuery.str();
+
+            if (!updateTableFileQuery.exec()) {
+                ENGINE_LOG_DEBUG << "table_id= " << file_schema.table_id_ << " file_id=" << file_schema.file_id_;
+                return HandleException("QUERY ERROR WHEN UPDATING TABLE FILE", updateTableFileQuery.error());
+            }
+        }  // Scoped Connection
+
+        ENGINE_LOG_DEBUG << "Update single table file, file id = " << file_schema.file_id_;
+    } catch (std::exception& e) {
+        return HandleException("GENERAL ERROR WHEN UPDATING TABLE FILE", e.what());
+    }
+
+    return Status::OK();
+}
+
+Status
+MySQLMetaImpl::UpdateTableFilesToIndex(const std::string& table_id) {
+    try {
+        mysqlpp::ScopedConnection connectionPtr(*mysql_connection_pool_, safe_grab_);
+
+        if (connectionPtr == nullptr) {
+            return Status(DB_ERROR, "Failed to connect to database server");
+        }
+
+        mysqlpp::Query updateTableFilesToIndexQuery = connectionPtr->query();
+
+        updateTableFilesToIndexQuery << "UPDATE " << META_TABLEFILES << " "
+                                     << "SET file_type = " << std::to_string(TableFileSchema::TO_INDEX) << " "
+                                     << "WHERE table_id = " << mysqlpp::quote << table_id << " AND "
+                                     << "file_type = " << std::to_string(TableFileSchema::RAW) << ";";
+
+        ENGINE_LOG_DEBUG << "MySQLMetaImpl::UpdateTableFilesToIndex: " << updateTableFilesToIndexQuery.str();
+
+        if (!updateTableFilesToIndexQuery.exec()) {
+            return HandleException("QUERY ERROR WHEN UPDATING TABLE FILE TO INDEX",
+                                   updateTableFilesToIndexQuery.error());
+        }
+
+        ENGINE_LOG_DEBUG << "Update files to to_index, table id = " << table_id;
+    } catch (std::exception& e) {
+        return HandleException("GENERAL ERROR WHEN UPDATING TABLE FILES TO INDEX", e.what());
+    }
+
+    return Status::OK();
+}
+
+Status
+MySQLMetaImpl::UpdateTableFiles(TableFilesSchema& files) {
+    try {
+        server::MetricCollector metric;
+        {
+            mysqlpp::ScopedConnection connectionPtr(*mysql_connection_pool_, safe_grab_);
+
+            if (connectionPtr == nullptr) {
+                return Status(DB_ERROR, "Failed to connect to database server");
+            }
+
+            mysqlpp::Query updateTableFilesQuery = connectionPtr->query();
+
+            std::map<std::string, bool> has_tables;
+            for (auto& file_schema : files) {
+                if (has_tables.find(file_schema.table_id_) != has_tables.end()) {
+                    continue;
+                }
+
+                updateTableFilesQuery << "SELECT EXISTS "
+                                      << "(SELECT 1 FROM " << META_TABLES << " "
+                                      << "WHERE table_id = " << mysqlpp::quote << file_schema.table_id_ << " "
+                                      << "AND state <> " << std::to_string(TableSchema::TO_DELETE) << ") "
+                                      << "AS " << mysqlpp::quote << "check"
+                                      << ";";
+
+                ENGINE_LOG_DEBUG << "MySQLMetaImpl::UpdateTableFiles: " << updateTableFilesQuery.str();
+
+                mysqlpp::StoreQueryResult res = updateTableFilesQuery.store();
+
+                int check = res[0]["check"];
+                has_tables[file_schema.table_id_] = (check == 1);
+            }
+
+            for (auto& file_schema : files) {
+                if (!has_tables[file_schema.table_id_]) {
+                    file_schema.file_type_ = TableFileSchema::TO_DELETE;
+                }
+                file_schema.updated_time_ = utils::GetMicroSecTimeStamp();
+
+                std::string id = std::to_string(file_schema.id_);
+                std::string table_id = file_schema.table_id_;
+                std::string engine_type = std::to_string(file_schema.engine_type_);
+                std::string file_id = file_schema.file_id_;
+                std::string file_type = std::to_string(file_schema.file_type_);
+                std::string file_size = std::to_string(file_schema.file_size_);
+                std::string row_count = std::to_string(file_schema.row_count_);
+                std::string updated_time = std::to_string(file_schema.updated_time_);
+                std::string created_on = std::to_string(file_schema.created_on_);
+                std::string date = std::to_string(file_schema.date_);
+
+                updateTableFilesQuery << "UPDATE " << META_TABLEFILES << " "
+                                      << "SET table_id = " << mysqlpp::quote << table_id << ", "
+                                      << "engine_type = " << engine_type << ", "
+                                      << "file_id = " << mysqlpp::quote << file_id << ", "
+                                      << "file_type = " << file_type << ", "
+                                      << "file_size = " << file_size << ", "
+                                      << "row_count = " << row_count << ", "
+                                      << "updated_time = " << updated_time << ", "
+                                      << "created_on = " << created_on << ", "
+                                      << "date = " << date << " "
+                                      << "WHERE id = " << id << ";";
+
+                ENGINE_LOG_DEBUG << "MySQLMetaImpl::UpdateTableFiles: " << updateTableFilesQuery.str();
+
+                if (!updateTableFilesQuery.exec()) {
+                    return HandleException("QUERY ERROR WHEN UPDATING TABLE FILES", updateTableFilesQuery.error());
+                }
+            }
+        }  // Scoped Connection
+
+        ENGINE_LOG_DEBUG << "Update " << files.size() << " table files";
+    } catch (std::exception& e) {
+        return HandleException("GENERAL ERROR WHEN UPDATING TABLE FILES", e.what());
+    }
+
+    return Status::OK();
+}
+
+Status
+MySQLMetaImpl::CleanUpFilesWithTTL(uint16_t seconds) {
+    auto now = utils::GetMicroSecTimeStamp();
+    std::set<std::string> table_ids;
+
+    // remove to_delete files
+    try {
+        server::MetricCollector metric;
+
+        {
+            mysqlpp::ScopedConnection connectionPtr(*mysql_connection_pool_, safe_grab_);
+
+            if (connectionPtr == nullptr) {
+                return Status(DB_ERROR, "Failed to connect to database server");
+            }
+
+            mysqlpp::Query cleanUpFilesWithTTLQuery = connectionPtr->query();
+            cleanUpFilesWithTTLQuery << "SELECT id, table_id, file_id, date FROM " << META_TABLEFILES << " "
+                                     << "WHERE file_type = " << std::to_string(TableFileSchema::TO_DELETE) << " AND "
+                                     << "updated_time < " << std::to_string(now - seconds * US_PS) << ";";
+
+            ENGINE_LOG_DEBUG << "MySQLMetaImpl::CleanUpFilesWithTTL: " << cleanUpFilesWithTTLQuery.str();
+
+            mysqlpp::StoreQueryResult res = cleanUpFilesWithTTLQuery.store();
+
+            TableFileSchema table_file;
+            std::vector<std::string> idsToDelete;
+
+            for (auto& resRow : res) {
+                table_file.id_ = resRow["id"];  // implicit conversion
+
+                std::string table_id;
+                resRow["table_id"].to_string(table_id);
+                table_file.table_id_ = table_id;
+
+                std::string file_id;
+                resRow["file_id"].to_string(file_id);
+                table_file.file_id_ = file_id;
+
+                table_file.date_ = resRow["date"];
+
+                utils::DeleteTableFilePath(options_, table_file);
+
+                ENGINE_LOG_DEBUG << "Removing file id:" << table_file.id_ << " location:" << table_file.location_;
+
+                idsToDelete.emplace_back(std::to_string(table_file.id_));
+
+                table_ids.insert(table_file.table_id_);
+            }
+
+            if (!idsToDelete.empty()) {
+                std::stringstream idsToDeleteSS;
+                for (auto& id : idsToDelete) {
+                    idsToDeleteSS << "id = " << id << " OR ";
+                }
+
+                std::string idsToDeleteStr = idsToDeleteSS.str();
+                idsToDeleteStr = idsToDeleteStr.substr(0, idsToDeleteStr.size() - 4);  // remove the last " OR "
+                cleanUpFilesWithTTLQuery << "DELETE FROM " << META_TABLEFILES << " "
+                                         << "WHERE " << idsToDeleteStr << ";";
+
+                ENGINE_LOG_DEBUG << "MySQLMetaImpl::CleanUpFilesWithTTL: " << cleanUpFilesWithTTLQuery.str();
+
+                if (!cleanUpFilesWithTTLQuery.exec()) {
+                    return HandleException("QUERY ERROR WHEN CLEANING UP FILES WITH TTL",
+                                           cleanUpFilesWithTTLQuery.error());
+                }
+            }
+
+            if (res.size() > 0) {
+                ENGINE_LOG_DEBUG << "Clean " << res.size() << " files deleted in " << seconds << " seconds";
+            }
+        }  // Scoped Connection
+    } catch (std::exception& e) {
+        return HandleException("GENERAL ERROR WHEN CLEANING UP FILES WITH TTL", e.what());
+    }
+
+    // remove to_delete tables
+    try {
+        server::MetricCollector metric;
+
+        {
+            mysqlpp::ScopedConnection connectionPtr(*mysql_connection_pool_, safe_grab_);
+
+            if (connectionPtr == nullptr) {
+                return Status(DB_ERROR, "Failed to connect to database server");
+            }
+
+            mysqlpp::Query cleanUpFilesWithTTLQuery = connectionPtr->query();
+            cleanUpFilesWithTTLQuery << "SELECT id, table_id FROM " << META_TABLES << " "
+                                     << "WHERE state = " << std::to_string(TableSchema::TO_DELETE) << ";";
+
+            ENGINE_LOG_DEBUG << "MySQLMetaImpl::CleanUpFilesWithTTL: " << cleanUpFilesWithTTLQuery.str();
+
+            mysqlpp::StoreQueryResult res = cleanUpFilesWithTTLQuery.store();
+
+            if (!res.empty()) {
+                std::stringstream idsToDeleteSS;
+                for (auto& resRow : res) {
+                    size_t id = resRow["id"];
+                    std::string table_id;
+                    resRow["table_id"].to_string(table_id);
+
+                    utils::DeleteTablePath(options_, table_id, false);  // only delete empty folder
+
+                    idsToDeleteSS << "id = " << std::to_string(id) << " OR ";
+                }
+                std::string idsToDeleteStr = idsToDeleteSS.str();
+                idsToDeleteStr = idsToDeleteStr.substr(0, idsToDeleteStr.size() - 4);  // remove the last " OR "
+                cleanUpFilesWithTTLQuery << "DELETE FROM " << META_TABLES << " "
+                                         << "WHERE " << idsToDeleteStr << ";";
+
+                ENGINE_LOG_DEBUG << "MySQLMetaImpl::CleanUpFilesWithTTL: " << cleanUpFilesWithTTLQuery.str();
+
+                if (!cleanUpFilesWithTTLQuery.exec()) {
+                    return HandleException("QUERY ERROR WHEN CLEANING UP TABLES WITH TTL",
+                                           cleanUpFilesWithTTLQuery.error());
+                }
+            }
+
+            if (res.size() > 0) {
+                ENGINE_LOG_DEBUG << "Remove " << res.size() << " tables from meta";
+            }
+        }  // Scoped Connection
+    } catch (std::exception& e) {
+        return HandleException("GENERAL ERROR WHEN CLEANING UP TABLES WITH TTL", e.what());
+    }
+
+    // remove deleted table folder
+    // don't remove table folder until all its files has been deleted
+    try {
+        server::MetricCollector metric;
+
+        {
+            mysqlpp::ScopedConnection connectionPtr(*mysql_connection_pool_, safe_grab_);
+
+            if (connectionPtr == nullptr) {
+                return Status(DB_ERROR, "Failed to connect to database server");
+            }
+
+            for (auto& table_id : table_ids) {
+                mysqlpp::Query cleanUpFilesWithTTLQuery = connectionPtr->query();
+                cleanUpFilesWithTTLQuery << "SELECT file_id FROM " << META_TABLEFILES << " "
+                                         << "WHERE table_id = " << mysqlpp::quote << table_id << ";";
+
+                ENGINE_LOG_DEBUG << "MySQLMetaImpl::CleanUpFilesWithTTL: " << cleanUpFilesWithTTLQuery.str();
+
+                mysqlpp::StoreQueryResult res = cleanUpFilesWithTTLQuery.store();
+
+                if (res.empty()) {
+                    utils::DeleteTablePath(options_, table_id);
+                }
+            }
+
+            if (table_ids.size() > 0) {
+                ENGINE_LOG_DEBUG << "Remove " << table_ids.size() << " tables folder";
+            }
+        }
+    } catch (std::exception& e) {
+        return HandleException("GENERAL ERROR WHEN CLEANING UP TABLES WITH TTL", e.what());
+    }
+
+    return Status::OK();
+}
+
+Status
+MySQLMetaImpl::CleanUp() {
+    try {
+        mysqlpp::ScopedConnection connectionPtr(*mysql_connection_pool_, safe_grab_);
+
+        if (connectionPtr == nullptr) {
+            return Status(DB_ERROR, "Failed to connect to database server");
+        }
+
+        mysqlpp::Query cleanUpQuery = connectionPtr->query();
+        cleanUpQuery << "SELECT table_name "
+                     << "FROM information_schema.tables "
+                     << "WHERE table_schema = " << mysqlpp::quote << mysql_connection_pool_->getDB() << " "
+                     << "AND table_name = " << mysqlpp::quote << META_TABLEFILES << ";";
+
+        ENGINE_LOG_DEBUG << "MySQLMetaImpl::CleanUp: " << cleanUpQuery.str();
+
+        mysqlpp::StoreQueryResult res = cleanUpQuery.store();
+
+        if (!res.empty()) {
+            ENGINE_LOG_DEBUG << "Remove table file type as NEW";
+            cleanUpQuery << "DELETE FROM " << META_TABLEFILES << " WHERE file_type IN ("
+                         << std::to_string(TableFileSchema::NEW) << "," << std::to_string(TableFileSchema::NEW_MERGE)
+                         << "," << std::to_string(TableFileSchema::NEW_INDEX) << ");";
+
+            ENGINE_LOG_DEBUG << "MySQLMetaImpl::CleanUp: " << cleanUpQuery.str();
+
+            if (!cleanUpQuery.exec()) {
+                return HandleException("QUERY ERROR WHEN CLEANING UP FILES", cleanUpQuery.error());
+            }
+        }
+
+        if (res.size() > 0) {
+            ENGINE_LOG_DEBUG << "Clean " << res.size() << " files";
+        }
+    } catch (std::exception& e) {
+        return HandleException("GENERAL ERROR WHEN CLEANING UP FILES", e.what());
+    }
+
+    return Status::OK();
+}
+
+Status
+MySQLMetaImpl::Count(const std::string& table_id, uint64_t& result) {
+    try {
+        server::MetricCollector metric;
+
+        TableSchema table_schema;
+        table_schema.table_id_ = table_id;
+        auto status = DescribeTable(table_schema);
+
+        if (!status.ok()) {
+            return status;
+        }
+
+        mysqlpp::StoreQueryResult res;
+        {
+            mysqlpp::ScopedConnection connectionPtr(*mysql_connection_pool_, safe_grab_);
+
+            if (connectionPtr == nullptr) {
+                return Status(DB_ERROR, "Failed to connect to database server");
+            }
+
+            mysqlpp::Query countQuery = connectionPtr->query();
+            countQuery << "SELECT row_count FROM " << META_TABLEFILES << " "
+                       << "WHERE table_id = " << mysqlpp::quote << table_id << " AND "
+                       << "(file_type = " << std::to_string(TableFileSchema::RAW) << " OR "
+                       << "file_type = " << std::to_string(TableFileSchema::TO_INDEX) << " OR "
+                       << "file_type = " << std::to_string(TableFileSchema::INDEX) << ");";
+
+            ENGINE_LOG_DEBUG << "MySQLMetaImpl::Count: " << countQuery.str();
+
+            res = countQuery.store();
+        }  // Scoped Connection
+
+        result = 0;
+        for (auto& resRow : res) {
+            size_t size = resRow["row_count"];
+            result += size;
+        }
+    } catch (std::exception& e) {
+        return HandleException("GENERAL ERROR WHEN RETRIEVING COUNT", e.what());
+    }
+
+    return Status::OK();
+}
+
+Status
+MySQLMetaImpl::DropAll() {
+    try {
+        ENGINE_LOG_DEBUG << "Drop all mysql meta";
+        mysqlpp::ScopedConnection connectionPtr(*mysql_connection_pool_, safe_grab_);
+
+        if (connectionPtr == nullptr) {
+            return Status(DB_ERROR, "Failed to connect to database server");
+        }
+
+        mysqlpp::Query dropTableQuery = connectionPtr->query();
+        dropTableQuery << "DROP TABLE IF EXISTS " << TABLES_SCHEMA.name() << ", " << TABLEFILES_SCHEMA.name() << ";";
+
+        ENGINE_LOG_DEBUG << "MySQLMetaImpl::DropAll: " << dropTableQuery.str();
+
+        if (dropTableQuery.exec()) {
+            return Status::OK();
+        }
+        return HandleException("QUERY ERROR WHEN DROPPING ALL", dropTableQuery.error());
+    } catch (std::exception& e) {
+        return HandleException("GENERAL ERROR WHEN DROPPING ALL", e.what());
+    }
+}
+
+}  // namespace meta
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/db/meta/MySQLMetaImpl.h b/core/src/db/meta/MySQLMetaImpl.h
new file mode 100644
index 0000000000..02bc6e1752
--- /dev/null
+++ b/core/src/db/meta/MySQLMetaImpl.h
@@ -0,0 +1,144 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "Meta.h"
+#include "MySQLConnectionPool.h"
+#include "db/Options.h"
+
+#include <mysql++/mysql++.h>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <vector>
+
+namespace milvus {
+namespace engine {
+namespace meta {
+
+class MySQLMetaImpl : public Meta {
+ public:
+    MySQLMetaImpl(const DBMetaOptions& options, const int& mode);
+    ~MySQLMetaImpl();
+
+    Status
+    CreateTable(TableSchema& table_schema) override;
+
+    Status
+    DescribeTable(TableSchema& table_schema) override;
+
+    Status
+    HasTable(const std::string& table_id, bool& has_or_not) override;
+
+    Status
+    AllTables(std::vector<TableSchema>& table_schema_array) override;
+
+    Status
+    DeleteTable(const std::string& table_id) override;
+
+    Status
+    DeleteTableFiles(const std::string& table_id) override;
+
+    Status
+    CreateTableFile(TableFileSchema& file_schema) override;
+
+    Status
+    DropPartitionsByDates(const std::string& table_id, const DatesT& dates) override;
+
+    Status
+    GetTableFiles(const std::string& table_id, const std::vector<size_t>& ids, TableFilesSchema& table_files) override;
+
+    Status
+    FilesByType(const std::string& table_id, const std::vector<int>& file_types,
+                std::vector<std::string>& file_ids) override;
+
+    Status
+    UpdateTableIndex(const std::string& table_id, const TableIndex& index) override;
+
+    Status
+    UpdateTableFlag(const std::string& table_id, int64_t flag) override;
+
+    Status
+    DescribeTableIndex(const std::string& table_id, TableIndex& index) override;
+
+    Status
+    DropTableIndex(const std::string& table_id) override;
+
+    Status
+    UpdateTableFile(TableFileSchema& file_schema) override;
+
+    Status
+    UpdateTableFilesToIndex(const std::string& table_id) override;
+
+    Status
+    UpdateTableFiles(TableFilesSchema& files) override;
+
+    Status
+    FilesToSearch(const std::string& table_id, const std::vector<size_t>& ids, const DatesT& dates,
+                  DatePartionedTableFilesSchema& files) override;
+
+    Status
+    FilesToMerge(const std::string& table_id, DatePartionedTableFilesSchema& files) override;
+
+    Status
+    FilesToIndex(TableFilesSchema&) override;
+
+    Status
+    Archive() override;
+
+    Status
+    Size(uint64_t& result) override;
+
+    Status
+    CleanUp() override;
+
+    Status
+    CleanUpFilesWithTTL(uint16_t seconds) override;
+
+    Status
+    DropAll() override;
+
+    Status
+    Count(const std::string& table_id, uint64_t& result) override;
+
+ private:
+    Status
+    NextFileId(std::string& file_id);
+    Status
+    NextTableId(std::string& table_id);
+    Status
+    DiscardFiles(int64_t to_discard_size);
+
+    void
+    ValidateMetaSchema();
+    Status
+    Initialize();
+
+ private:
+    const DBMetaOptions options_;
+    const int mode_;
+
+    std::shared_ptr<MySQLConnectionPool> mysql_connection_pool_;
+    bool safe_grab_ = false;
+
+    //        std::mutex connectionMutex_;
+};  // DBMetaImpl
+
+}  // namespace meta
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/db/meta/SqliteMetaImpl.cpp b/core/src/db/meta/SqliteMetaImpl.cpp
new file mode 100644
index 0000000000..3fed2a81d4
--- /dev/null
+++ b/core/src/db/meta/SqliteMetaImpl.cpp
@@ -0,0 +1,1351 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "db/meta/SqliteMetaImpl.h"
+#include "db/IDGenerator.h"
+#include "db/Utils.h"
+#include "utils/Log.h"
+#include "utils/Exception.h"
+#include "MetaConsts.h"
+#include "metrics/Metrics.h"
+
+#include <unistd.h>
+#include <sstream>
+#include <iostream>
+#include <boost/filesystem.hpp>
+#include <chrono>
+#include <fstream>
+#include <memory>
+#include <map>
+#include <set>
+#include <sqlite_orm.h>
+
+
+namespace milvus {
+namespace engine {
+namespace meta {
+
+using namespace sqlite_orm;
+
+namespace {
+
+Status
+HandleException(const std::string &desc, const char *what = nullptr) {
+    if (what == nullptr) {
+        ENGINE_LOG_ERROR << desc;
+        return Status(DB_META_TRANSACTION_FAILED, desc);
+    } else {
+        std::string msg = desc + ":" + what;
+        ENGINE_LOG_ERROR << msg;
+        return Status(DB_META_TRANSACTION_FAILED, msg);
+    }
+}
+
+} // namespace
+
+inline auto
+StoragePrototype(const std::string &path) {
+    return make_storage(path,
+                        make_table(META_TABLES,
+                                   make_column("id", &TableSchema::id_, primary_key()),
+                                   make_column("table_id", &TableSchema::table_id_, unique()),
+                                   make_column("state", &TableSchema::state_),
+                                   make_column("dimension", &TableSchema::dimension_),
+                                   make_column("created_on", &TableSchema::created_on_),
+                                   make_column("flag", &TableSchema::flag_, default_value(0)),
+                                   make_column("index_file_size", &TableSchema::index_file_size_),
+                                   make_column("engine_type", &TableSchema::engine_type_),
+                                   make_column("nlist", &TableSchema::nlist_),
+                                   make_column("metric_type", &TableSchema::metric_type_)),
+                        make_table(META_TABLEFILES,
+                                   make_column("id", &TableFileSchema::id_, primary_key()),
+                                   make_column("table_id", &TableFileSchema::table_id_),
+                                   make_column("engine_type", &TableFileSchema::engine_type_),
+                                   make_column("file_id", &TableFileSchema::file_id_),
+                                   make_column("file_type", &TableFileSchema::file_type_),
+                                   make_column("file_size", &TableFileSchema::file_size_, default_value(0)),
+                                   make_column("row_count", &TableFileSchema::row_count_, default_value(0)),
+                                   make_column("updated_time", &TableFileSchema::updated_time_),
+                                   make_column("created_on", &TableFileSchema::created_on_),
+                                   make_column("date", &TableFileSchema::date_)));
+}
+
+using ConnectorT = decltype(StoragePrototype(""));
+static std::unique_ptr<ConnectorT> ConnectorPtr;
+
+SqliteMetaImpl::SqliteMetaImpl(const DBMetaOptions &options)
+    : options_(options) {
+    Initialize();
+}
+
+SqliteMetaImpl::~SqliteMetaImpl() {
+}
+
+Status
+SqliteMetaImpl::NextTableId(std::string &table_id) {
+    std::stringstream ss;
+    SimpleIDGenerator g;
+    ss << g.GetNextIDNumber();
+    table_id = ss.str();
+    return Status::OK();
+}
+
+Status
+SqliteMetaImpl::NextFileId(std::string &file_id) {
+    std::stringstream ss;
+    SimpleIDGenerator g;
+    ss << g.GetNextIDNumber();
+    file_id = ss.str();
+    return Status::OK();
+}
+
+void
+SqliteMetaImpl::ValidateMetaSchema() {
+    if (ConnectorPtr == nullptr) {
+        return;
+    }
+
+    //old meta could be recreated since schema changed, throw exception if meta schema is not compatible
+    auto ret = ConnectorPtr->sync_schema_simulate();
+    if (ret.find(META_TABLES) != ret.end()
+        && sqlite_orm::sync_schema_result::dropped_and_recreated == ret[META_TABLES]) {
+        throw Exception(DB_INCOMPATIB_META, "Meta Tables schema is created by Milvus old version");
+    }
+    if (ret.find(META_TABLEFILES) != ret.end()
+        && sqlite_orm::sync_schema_result::dropped_and_recreated == ret[META_TABLEFILES]) {
+        throw Exception(DB_INCOMPATIB_META, "Meta TableFiles schema is created by Milvus old version");
+    }
+}
+
+Status
+SqliteMetaImpl::Initialize() {
+    if (!boost::filesystem::is_directory(options_.path_)) {
+        auto ret = boost::filesystem::create_directory(options_.path_);
+        if (!ret) {
+            std::string msg = "Failed to create db directory " + options_.path_;
+            ENGINE_LOG_ERROR << msg;
+            return Status(DB_INVALID_PATH, msg);
+        }
+    }
+
+    ConnectorPtr = std::make_unique<ConnectorT>(StoragePrototype(options_.path_ + "/meta.sqlite"));
+
+    ValidateMetaSchema();
+
+    ConnectorPtr->sync_schema();
+    ConnectorPtr->open_forever(); // thread safe option
+    ConnectorPtr->pragma.journal_mode(journal_mode::WAL); // WAL => write ahead log
+
+    CleanUp();
+
+    return Status::OK();
+}
+
+// TODO(myh): Delete single vecotor by id
+Status
+SqliteMetaImpl::DropPartitionsByDates(const std::string &table_id,
+                                      const DatesT &dates) {
+    if (dates.empty()) {
+        return Status::OK();
+    }
+
+    TableSchema table_schema;
+    table_schema.table_id_ = table_id;
+    auto status = DescribeTable(table_schema);
+    if (!status.ok()) {
+        return status;
+    }
+
+    try {
+        //sqlite_orm has a bug, 'in' statement cannot handle too many elements
+        //so we split one query into multi-queries, this is a work-around!!
+        std::vector<DatesT> split_dates;
+        split_dates.push_back(DatesT());
+        const size_t batch_size = 30;
+        for(DateT date : dates) {
+            DatesT& last_batch = *split_dates.rbegin();
+            last_batch.push_back(date);
+            if(last_batch.size() > batch_size) {
+                split_dates.push_back(DatesT());
+            }
+        }
+
+        //multi-threads call sqlite update may get exception('bad logic', etc), so we add a lock here
+        std::lock_guard<std::mutex> meta_lock(meta_mutex_);
+
+        for(auto& batch_dates : split_dates) {
+            if(batch_dates.empty()) {
+                continue;
+            }
+
+            ConnectorPtr->update_all(
+                set(
+                    c(&TableFileSchema::file_type_) = (int)TableFileSchema::TO_DELETE,
+                    c(&TableFileSchema::updated_time_) = utils::GetMicroSecTimeStamp()),
+                where(
+                    c(&TableFileSchema::table_id_) == table_id and
+                    in(&TableFileSchema::date_, batch_dates)));
+        }
+
+        ENGINE_LOG_DEBUG << "Successfully drop partitions, table id = " << table_schema.table_id_;
+    } catch (std::exception &e) {
+        return HandleException("Encounter exception when drop partition", e.what());
+    }
+
+    return Status::OK();
+}
+
+Status
+SqliteMetaImpl::CreateTable(TableSchema &table_schema) {
+    try {
+        server::MetricCollector metric;
+
+        //multi-threads call sqlite update may get exception('bad logic', etc), so we add a lock here
+        std::lock_guard<std::mutex> meta_lock(meta_mutex_);
+
+        if (table_schema.table_id_ == "") {
+            NextTableId(table_schema.table_id_);
+        } else {
+            auto table = ConnectorPtr->select(columns(&TableSchema::state_),
+                                              where(c(&TableSchema::table_id_) == table_schema.table_id_));
+            if (table.size() == 1) {
+                if (TableSchema::TO_DELETE == std::get<0>(table[0])) {
+                    return Status(DB_ERROR, "Table already exists and it is in delete state, please wait a second");
+                } else {
+                    // Change from no error to already exist.
+                    return Status(DB_ALREADY_EXIST, "Table already exists");
+                }
+            }
+        }
+
+        table_schema.id_ = -1;
+        table_schema.created_on_ = utils::GetMicroSecTimeStamp();
+
+        try {
+            auto id = ConnectorPtr->insert(table_schema);
+            table_schema.id_ = id;
+        } catch (std::exception &e) {
+            return HandleException("Encounter exception when create table", e.what());
+        }
+
+        ENGINE_LOG_DEBUG << "Successfully create table: " << table_schema.table_id_;
+
+        return utils::CreateTablePath(options_, table_schema.table_id_);
+    } catch (std::exception &e) {
+        return HandleException("Encounter exception when create table", e.what());
+    }
+}
+
+Status
+SqliteMetaImpl::DeleteTable(const std::string &table_id) {
+    try {
+        server::MetricCollector metric;
+
+        //multi-threads call sqlite update may get exception('bad logic', etc), so we add a lock here
+        std::lock_guard<std::mutex> meta_lock(meta_mutex_);
+
+        //soft delete table
+        ConnectorPtr->update_all(
+            set(
+                c(&TableSchema::state_) = (int) TableSchema::TO_DELETE),
+            where(
+                c(&TableSchema::table_id_) == table_id and
+                    c(&TableSchema::state_) != (int) TableSchema::TO_DELETE));
+
+        ENGINE_LOG_DEBUG << "Successfully delete table, table id = " << table_id;
+    } catch (std::exception &e) {
+        return HandleException("Encounter exception when delete table", e.what());
+    }
+
+    return Status::OK();
+}
+
+Status
+SqliteMetaImpl::DeleteTableFiles(const std::string &table_id) {
+    try {
+        server::MetricCollector metric;
+
+        //multi-threads call sqlite update may get exception('bad logic', etc), so we add a lock here
+        std::lock_guard<std::mutex> meta_lock(meta_mutex_);
+
+        //soft delete table files
+        ConnectorPtr->update_all(
+            set(
+                c(&TableFileSchema::file_type_) = (int) TableFileSchema::TO_DELETE,
+                c(&TableFileSchema::updated_time_) = utils::GetMicroSecTimeStamp()),
+            where(
+                c(&TableFileSchema::table_id_) == table_id and
+                    c(&TableFileSchema::file_type_) != (int) TableFileSchema::TO_DELETE));
+
+        ENGINE_LOG_DEBUG << "Successfully delete table files, table id = " << table_id;
+    } catch (std::exception &e) {
+        return HandleException("Encounter exception when delete table files", e.what());
+    }
+
+    return Status::OK();
+}
+
+Status
+SqliteMetaImpl::DescribeTable(TableSchema &table_schema) {
+    try {
+        server::MetricCollector metric;
+
+        auto groups = ConnectorPtr->select(columns(&TableSchema::id_,
+                                                   &TableSchema::state_,
+                                                   &TableSchema::dimension_,
+                                                   &TableSchema::created_on_,
+                                                   &TableSchema::flag_,
+                                                   &TableSchema::index_file_size_,
+                                                   &TableSchema::engine_type_,
+                                                   &TableSchema::nlist_,
+                                                   &TableSchema::metric_type_),
+                                           where(c(&TableSchema::table_id_) == table_schema.table_id_
+                                                     and c(&TableSchema::state_) != (int) TableSchema::TO_DELETE));
+
+        if (groups.size() == 1) {
+            table_schema.id_ = std::get<0>(groups[0]);
+            table_schema.state_ = std::get<1>(groups[0]);
+            table_schema.dimension_ = std::get<2>(groups[0]);
+            table_schema.created_on_ = std::get<3>(groups[0]);
+            table_schema.flag_ = std::get<4>(groups[0]);
+            table_schema.index_file_size_ = std::get<5>(groups[0]);
+            table_schema.engine_type_ = std::get<6>(groups[0]);
+            table_schema.nlist_ = std::get<7>(groups[0]);
+            table_schema.metric_type_ = std::get<8>(groups[0]);
+        } else {
+            return Status(DB_NOT_FOUND, "Table " + table_schema.table_id_ + " not found");
+        }
+    } catch (std::exception &e) {
+        return HandleException("Encounter exception when describe table", e.what());
+    }
+
+    return Status::OK();
+}
+
+Status
+SqliteMetaImpl::FilesByType(const std::string &table_id,
+                            const std::vector<int> &file_types,
+                            std::vector<std::string> &file_ids) {
+    if (file_types.empty()) {
+        return Status(DB_ERROR, "file types array is empty");
+    }
+
+    try {
+        file_ids.clear();
+        auto selected = ConnectorPtr->select(columns(&TableFileSchema::file_id_,
+                                                     &TableFileSchema::file_type_),
+                                             where(in(&TableFileSchema::file_type_, file_types)
+                                                       and c(&TableFileSchema::table_id_) == table_id));
+
+        if (selected.size() >= 1) {
+            int raw_count = 0, new_count = 0, new_merge_count = 0, new_index_count = 0;
+            int to_index_count = 0, index_count = 0, backup_count = 0;
+            for (auto &file : selected) {
+                file_ids.push_back(std::get<0>(file));
+                switch (std::get<1>(file)) {
+                    case (int) TableFileSchema::RAW:raw_count++;
+                        break;
+                    case (int) TableFileSchema::NEW:new_count++;
+                        break;
+                    case (int) TableFileSchema::NEW_MERGE:new_merge_count++;
+                        break;
+                    case (int) TableFileSchema::NEW_INDEX:new_index_count++;
+                        break;
+                    case (int) TableFileSchema::TO_INDEX:to_index_count++;
+                        break;
+                    case (int) TableFileSchema::INDEX:index_count++;
+                        break;
+                    case (int) TableFileSchema::BACKUP:backup_count++;
+                        break;
+                    default:break;
+                }
+            }
+
+            ENGINE_LOG_DEBUG << "Table " << table_id << " currently has raw files:" << raw_count
+                             << " new files:" << new_count << " new_merge files:" << new_merge_count
+                             << " new_index files:" << new_index_count << " to_index files:" << to_index_count
+                             << " index files:" << index_count << " backup files:" << backup_count;
+        }
+    } catch (std::exception &e) {
+        return HandleException("Encounter exception when check non index files", e.what());
+    }
+    return Status::OK();
+}
+
+Status
+SqliteMetaImpl::UpdateTableIndex(const std::string &table_id, const TableIndex &index) {
+    try {
+        server::MetricCollector metric;
+
+        //multi-threads call sqlite update may get exception('bad logic', etc), so we add a lock here
+        std::lock_guard<std::mutex> meta_lock(meta_mutex_);
+
+        auto tables = ConnectorPtr->select(columns(&TableSchema::id_,
+                                                   &TableSchema::state_,
+                                                   &TableSchema::dimension_,
+                                                   &TableSchema::created_on_,
+                                                   &TableSchema::flag_,
+                                                   &TableSchema::index_file_size_),
+                                           where(c(&TableSchema::table_id_) == table_id
+                                                     and c(&TableSchema::state_) != (int) TableSchema::TO_DELETE));
+
+        if (tables.size() > 0) {
+            meta::TableSchema table_schema;
+            table_schema.id_ = std::get<0>(tables[0]);
+            table_schema.table_id_ = table_id;
+            table_schema.state_ = std::get<1>(tables[0]);
+            table_schema.dimension_ = std::get<2>(tables[0]);
+            table_schema.created_on_ = std::get<3>(tables[0]);
+            table_schema.flag_ = std::get<4>(tables[0]);
+            table_schema.index_file_size_ = std::get<5>(tables[0]);
+            table_schema.engine_type_ = index.engine_type_;
+            table_schema.nlist_ = index.nlist_;
+            table_schema.metric_type_ = index.metric_type_;
+
+            ConnectorPtr->update(table_schema);
+        } else {
+            return Status(DB_NOT_FOUND, "Table " + table_id + " not found");
+        }
+
+        //set all backup file to raw
+        ConnectorPtr->update_all(
+            set(
+                c(&TableFileSchema::file_type_) = (int) TableFileSchema::RAW,
+                c(&TableFileSchema::updated_time_) = utils::GetMicroSecTimeStamp()),
+            where(
+                c(&TableFileSchema::table_id_) == table_id and
+                    c(&TableFileSchema::file_type_) == (int) TableFileSchema::BACKUP));
+
+        ENGINE_LOG_DEBUG << "Successfully update table index, table id = " << table_id;
+    } catch (std::exception &e) {
+        std::string msg = "Encounter exception when update table index: table_id = " + table_id;
+        return HandleException(msg, e.what());
+    }
+
+    return Status::OK();
+}
+
+Status
+SqliteMetaImpl::UpdateTableFlag(const std::string &table_id, int64_t flag) {
+    try {
+        server::MetricCollector metric;
+
+        //set all backup file to raw
+        ConnectorPtr->update_all(
+            set(
+                c(&TableSchema::flag_) = flag),
+            where(
+                c(&TableSchema::table_id_) == table_id));
+        ENGINE_LOG_DEBUG << "Successfully update table flag, table id = " << table_id;
+    } catch (std::exception &e) {
+        std::string msg = "Encounter exception when update table flag: table_id = " + table_id;
+        return HandleException(msg, e.what());
+    }
+
+    return Status::OK();
+}
+
+Status
+SqliteMetaImpl::DescribeTableIndex(const std::string &table_id, TableIndex &index) {
+    try {
+        server::MetricCollector metric;
+
+        auto groups = ConnectorPtr->select(columns(&TableSchema::engine_type_,
+                                                   &TableSchema::nlist_,
+                                                   &TableSchema::metric_type_),
+                                           where(c(&TableSchema::table_id_) == table_id
+                                                     and c(&TableSchema::state_) != (int) TableSchema::TO_DELETE));
+
+        if (groups.size() == 1) {
+            index.engine_type_ = std::get<0>(groups[0]);
+            index.nlist_ = std::get<1>(groups[0]);
+            index.metric_type_ = std::get<2>(groups[0]);
+        } else {
+            return Status(DB_NOT_FOUND, "Table " + table_id + " not found");
+        }
+    } catch (std::exception &e) {
+        return HandleException("Encounter exception when describe index", e.what());
+    }
+
+    return Status::OK();
+}
+
+Status
+SqliteMetaImpl::DropTableIndex(const std::string &table_id) {
+    try {
+        server::MetricCollector metric;
+
+        //multi-threads call sqlite update may get exception('bad logic', etc), so we add a lock here
+        std::lock_guard<std::mutex> meta_lock(meta_mutex_);
+
+        //soft delete index files
+        ConnectorPtr->update_all(
+            set(
+                c(&TableFileSchema::file_type_) = (int) TableFileSchema::TO_DELETE,
+                c(&TableFileSchema::updated_time_) = utils::GetMicroSecTimeStamp()),
+            where(
+                c(&TableFileSchema::table_id_) == table_id and
+                    c(&TableFileSchema::file_type_) == (int) TableFileSchema::INDEX));
+
+        //set all backup file to raw
+        ConnectorPtr->update_all(
+            set(
+                c(&TableFileSchema::file_type_) = (int) TableFileSchema::RAW,
+                c(&TableFileSchema::updated_time_) = utils::GetMicroSecTimeStamp()),
+            where(
+                c(&TableFileSchema::table_id_) == table_id and
+                    c(&TableFileSchema::file_type_) == (int) TableFileSchema::BACKUP));
+
+        //set table index type to raw
+        ConnectorPtr->update_all(
+            set(
+                c(&TableSchema::engine_type_) = DEFAULT_ENGINE_TYPE,
+                c(&TableSchema::nlist_) = DEFAULT_NLIST,
+                c(&TableSchema::metric_type_) = DEFAULT_METRIC_TYPE),
+            where(
+                c(&TableSchema::table_id_) == table_id));
+
+        ENGINE_LOG_DEBUG << "Successfully drop table index, table id = " << table_id;
+    } catch (std::exception &e) {
+        return HandleException("Encounter exception when delete table index files", e.what());
+    }
+
+    return Status::OK();
+}
+
+Status
+SqliteMetaImpl::HasTable(const std::string &table_id, bool &has_or_not) {
+    has_or_not = false;
+
+    try {
+        server::MetricCollector metric;
+        auto tables = ConnectorPtr->select(columns(&TableSchema::id_),
+                                           where(c(&TableSchema::table_id_) == table_id
+                                                     and c(&TableSchema::state_) != (int) TableSchema::TO_DELETE));
+        if (tables.size() == 1) {
+            has_or_not = true;
+        } else {
+            has_or_not = false;
+        }
+    } catch (std::exception &e) {
+        return HandleException("Encounter exception when lookup table", e.what());
+    }
+
+    return Status::OK();
+}
+
+Status
+SqliteMetaImpl::AllTables(std::vector<TableSchema> &table_schema_array) {
+    try {
+        server::MetricCollector metric;
+
+        auto selected = ConnectorPtr->select(columns(&TableSchema::id_,
+                                                     &TableSchema::table_id_,
+                                                     &TableSchema::dimension_,
+                                                     &TableSchema::created_on_,
+                                                     &TableSchema::flag_,
+                                                     &TableSchema::index_file_size_,
+                                                     &TableSchema::engine_type_,
+                                                     &TableSchema::nlist_,
+                                                     &TableSchema::metric_type_),
+                                             where(c(&TableSchema::state_) != (int) TableSchema::TO_DELETE));
+        for (auto &table : selected) {
+            TableSchema schema;
+            schema.id_ = std::get<0>(table);
+            schema.table_id_ = std::get<1>(table);
+            schema.dimension_ = std::get<2>(table);
+            schema.created_on_ = std::get<3>(table);
+            schema.flag_ = std::get<4>(table);
+            schema.index_file_size_ = std::get<5>(table);
+            schema.engine_type_ = std::get<6>(table);
+            schema.nlist_ = std::get<7>(table);
+            schema.metric_type_ = std::get<8>(table);
+
+            table_schema_array.emplace_back(schema);
+        }
+    } catch (std::exception &e) {
+        return HandleException("Encounter exception when lookup all tables", e.what());
+    }
+
+    return Status::OK();
+}
+
+Status
+SqliteMetaImpl::CreateTableFile(TableFileSchema &file_schema) {
+    if (file_schema.date_ == EmptyDate) {
+        file_schema.date_ = utils::GetDate();
+    }
+    TableSchema table_schema;
+    table_schema.table_id_ = file_schema.table_id_;
+    auto status = DescribeTable(table_schema);
+    if (!status.ok()) {
+        return status;
+    }
+
+    try {
+        server::MetricCollector metric;
+
+        NextFileId(file_schema.file_id_);
+        file_schema.dimension_ = table_schema.dimension_;
+        file_schema.file_size_ = 0;
+        file_schema.row_count_ = 0;
+        file_schema.created_on_ = utils::GetMicroSecTimeStamp();
+        file_schema.updated_time_ = file_schema.created_on_;
+        file_schema.index_file_size_ = table_schema.index_file_size_;
+        file_schema.engine_type_ = table_schema.engine_type_;
+        file_schema.nlist_ = table_schema.nlist_;
+        file_schema.metric_type_ = table_schema.metric_type_;
+
+        //multi-threads call sqlite update may get exception('bad logic', etc), so we add a lock here
+        std::lock_guard<std::mutex> meta_lock(meta_mutex_);
+
+        auto id = ConnectorPtr->insert(file_schema);
+        file_schema.id_ = id;
+
+        ENGINE_LOG_DEBUG << "Successfully create table file, file id = " << file_schema.file_id_;
+        return utils::CreateTableFilePath(options_, file_schema);
+    } catch (std::exception &e) {
+        return HandleException("Encounter exception when create table file", e.what());
+    }
+
+    return Status::OK();
+}
+
+Status
+SqliteMetaImpl::FilesToIndex(TableFilesSchema &files) {
+    files.clear();
+
+    try {
+        server::MetricCollector metric;
+
+        auto selected = ConnectorPtr->select(columns(&TableFileSchema::id_,
+                                                     &TableFileSchema::table_id_,
+                                                     &TableFileSchema::file_id_,
+                                                     &TableFileSchema::file_type_,
+                                                     &TableFileSchema::file_size_,
+                                                     &TableFileSchema::row_count_,
+                                                     &TableFileSchema::date_,
+                                                     &TableFileSchema::engine_type_,
+                                                     &TableFileSchema::created_on_),
+                                             where(c(&TableFileSchema::file_type_)
+                                                       == (int) TableFileSchema::TO_INDEX));
+
+        std::map<std::string, TableSchema> groups;
+        TableFileSchema table_file;
+
+        Status ret;
+        for (auto &file : selected) {
+            table_file.id_ = std::get<0>(file);
+            table_file.table_id_ = std::get<1>(file);
+            table_file.file_id_ = std::get<2>(file);
+            table_file.file_type_ = std::get<3>(file);
+            table_file.file_size_ = std::get<4>(file);
+            table_file.row_count_ = std::get<5>(file);
+            table_file.date_ = std::get<6>(file);
+            table_file.engine_type_ = std::get<7>(file);
+            table_file.created_on_ = std::get<8>(file);
+
+            auto status = utils::GetTableFilePath(options_, table_file);
+            if (!status.ok()) {
+                ret = status;
+            }
+            auto groupItr = groups.find(table_file.table_id_);
+            if (groupItr == groups.end()) {
+                TableSchema table_schema;
+                table_schema.table_id_ = table_file.table_id_;
+                auto status = DescribeTable(table_schema);
+                if (!status.ok()) {
+                    return status;
+                }
+                groups[table_file.table_id_] = table_schema;
+            }
+            table_file.dimension_ = groups[table_file.table_id_].dimension_;
+            table_file.index_file_size_ = groups[table_file.table_id_].index_file_size_;
+            table_file.nlist_ = groups[table_file.table_id_].nlist_;
+            table_file.metric_type_ = groups[table_file.table_id_].metric_type_;
+            files.push_back(table_file);
+        }
+
+        if (selected.size() > 0) {
+            ENGINE_LOG_DEBUG << "Collect " << selected.size() << " to-index files";
+        }
+        return ret;
+    } catch (std::exception &e) {
+        return HandleException("Encounter exception when iterate raw files", e.what());
+    }
+}
+
+Status
+SqliteMetaImpl::FilesToSearch(const std::string &table_id,
+                              const std::vector<size_t> &ids,
+                              const DatesT &dates,
+                              DatePartionedTableFilesSchema &files) {
+    files.clear();
+    server::MetricCollector metric;
+
+    try {
+        auto select_columns = columns(&TableFileSchema::id_,
+                                      &TableFileSchema::table_id_,
+                                      &TableFileSchema::file_id_,
+                                      &TableFileSchema::file_type_,
+                                      &TableFileSchema::file_size_,
+                                      &TableFileSchema::row_count_,
+                                      &TableFileSchema::date_,
+                                      &TableFileSchema::engine_type_);
+
+        auto match_tableid = c(&TableFileSchema::table_id_) == table_id;
+
+        std::vector<int> file_types = {
+            (int) TableFileSchema::RAW,
+            (int) TableFileSchema::TO_INDEX,
+            (int) TableFileSchema::INDEX
+        };
+        auto match_type = in(&TableFileSchema::file_type_, file_types);
+
+        TableSchema table_schema;
+        table_schema.table_id_ = table_id;
+        auto status = DescribeTable(table_schema);
+        if (!status.ok()) { return status; }
+
+        //sqlite_orm has a bug, 'in' statement cannot handle too many elements
+        //so we split one query into multi-queries, this is a work-around!!
+        std::vector<DatesT> split_dates;
+        split_dates.push_back(DatesT());
+        const size_t batch_size = 30;
+        for(DateT date : dates) {
+            DatesT& last_batch = *split_dates.rbegin();
+            last_batch.push_back(date);
+            if(last_batch.size() > batch_size) {
+                split_dates.push_back(DatesT());
+            }
+        }
+
+        //perform query
+        decltype(ConnectorPtr->select(select_columns)) selected;
+        if (dates.empty() && ids.empty()) {
+            auto filter = where(match_tableid and match_type);
+            selected = ConnectorPtr->select(select_columns, filter);
+        } else if (dates.empty() && !ids.empty()) {
+            auto match_fileid = in(&TableFileSchema::id_, ids);
+            auto filter = where(match_tableid and match_fileid and match_type);
+            selected = ConnectorPtr->select(select_columns, filter);
+        } else if (!dates.empty() && ids.empty()) {
+            for(auto& batch_dates : split_dates) {
+                if(batch_dates.empty()) {
+                    continue;
+                }
+                auto match_date = in(&TableFileSchema::date_, batch_dates);
+                auto filter = where(match_tableid and match_date and match_type);
+                auto batch_selected = ConnectorPtr->select(select_columns, filter);
+                for (auto &file : batch_selected) {
+                    selected.push_back(file);
+                }
+            }
+
+        } else if (!dates.empty() && !ids.empty()) {
+            for(auto& batch_dates : split_dates) {
+                if(batch_dates.empty()) {
+                    continue;
+                }
+                auto match_fileid = in(&TableFileSchema::id_, ids);
+                auto match_date = in(&TableFileSchema::date_, batch_dates);
+                auto filter = where(match_tableid and match_fileid and match_date and match_type);
+                auto batch_selected = ConnectorPtr->select(select_columns, filter);
+                for (auto &file : batch_selected) {
+                    selected.push_back(file);
+                }
+            }
+        }
+
+        Status ret;
+        TableFileSchema table_file;
+        for (auto &file : selected) {
+            table_file.id_ = std::get<0>(file);
+            table_file.table_id_ = std::get<1>(file);
+            table_file.file_id_ = std::get<2>(file);
+            table_file.file_type_ = std::get<3>(file);
+            table_file.file_size_ = std::get<4>(file);
+            table_file.row_count_ = std::get<5>(file);
+            table_file.date_ = std::get<6>(file);
+            table_file.engine_type_ = std::get<7>(file);
+            table_file.dimension_ = table_schema.dimension_;
+            table_file.index_file_size_ = table_schema.index_file_size_;
+            table_file.nlist_ = table_schema.nlist_;
+            table_file.metric_type_ = table_schema.metric_type_;
+
+            auto status = utils::GetTableFilePath(options_, table_file);
+            if (!status.ok()) {
+                ret = status;
+            }
+
+            auto dateItr = files.find(table_file.date_);
+            if (dateItr == files.end()) {
+                files[table_file.date_] = TableFilesSchema();
+            }
+            files[table_file.date_].push_back(table_file);
+        }
+        if (files.empty()) {
+            ENGINE_LOG_ERROR << "No file to search for table: " << table_id;
+        }
+
+        if (selected.size() > 0) {
+            ENGINE_LOG_DEBUG << "Collect " << selected.size() << " to-search files";
+        }
+        return ret;
+    } catch (std::exception &e) {
+        return HandleException("Encounter exception when iterate index files", e.what());
+    }
+}
+
+Status
+SqliteMetaImpl::FilesToMerge(const std::string &table_id,
+                             DatePartionedTableFilesSchema &files) {
+    files.clear();
+
+    try {
+        server::MetricCollector metric;
+
+        //check table existence
+        TableSchema table_schema;
+        table_schema.table_id_ = table_id;
+        auto status = DescribeTable(table_schema);
+        if (!status.ok()) {
+            return status;
+        }
+
+        //get files to merge
+        auto selected = ConnectorPtr->select(columns(&TableFileSchema::id_,
+                                                     &TableFileSchema::table_id_,
+                                                     &TableFileSchema::file_id_,
+                                                     &TableFileSchema::file_type_,
+                                                     &TableFileSchema::file_size_,
+                                                     &TableFileSchema::row_count_,
+                                                     &TableFileSchema::date_,
+                                                     &TableFileSchema::created_on_),
+                                             where(c(&TableFileSchema::file_type_) == (int) TableFileSchema::RAW and
+                                                 c(&TableFileSchema::table_id_) == table_id),
+                                             order_by(&TableFileSchema::file_size_).desc());
+
+        Status result;
+        for (auto &file : selected) {
+            TableFileSchema table_file;
+            table_file.file_size_ = std::get<4>(file);
+            if (table_file.file_size_ >= table_schema.index_file_size_) {
+                continue;//skip large file
+            }
+
+            table_file.id_ = std::get<0>(file);
+            table_file.table_id_ = std::get<1>(file);
+            table_file.file_id_ = std::get<2>(file);
+            table_file.file_type_ = std::get<3>(file);
+            table_file.row_count_ = std::get<5>(file);
+            table_file.date_ = std::get<6>(file);
+            table_file.created_on_ = std::get<7>(file);
+            table_file.dimension_ = table_schema.dimension_;
+            table_file.index_file_size_ = table_schema.index_file_size_;
+            table_file.nlist_ = table_schema.nlist_;
+            table_file.metric_type_ = table_schema.metric_type_;
+
+            auto status = utils::GetTableFilePath(options_, table_file);
+            if (!status.ok()) {
+                result = status;
+            }
+
+            auto dateItr = files.find(table_file.date_);
+            if (dateItr == files.end()) {
+                files[table_file.date_] = TableFilesSchema();
+            }
+            files[table_file.date_].push_back(table_file);
+        }
+
+        if (selected.size() > 0) {
+            ENGINE_LOG_DEBUG << "Collect " << selected.size() << " to-merge files";
+        }
+        return result;
+    } catch (std::exception &e) {
+        return HandleException("Encounter exception when iterate merge files", e.what());
+    }
+}
+
+Status
+SqliteMetaImpl::GetTableFiles(const std::string &table_id,
+                              const std::vector<size_t> &ids,
+                              TableFilesSchema &table_files) {
+    try {
+        table_files.clear();
+        auto files = ConnectorPtr->select(columns(&TableFileSchema::id_,
+                                                  &TableFileSchema::file_id_,
+                                                  &TableFileSchema::file_type_,
+                                                  &TableFileSchema::file_size_,
+                                                  &TableFileSchema::row_count_,
+                                                  &TableFileSchema::date_,
+                                                  &TableFileSchema::engine_type_,
+                                                  &TableFileSchema::created_on_),
+                                          where(c(&TableFileSchema::table_id_) == table_id and
+                                              in(&TableFileSchema::id_, ids) and
+                                              c(&TableFileSchema::file_type_) != (int) TableFileSchema::TO_DELETE));
+
+        TableSchema table_schema;
+        table_schema.table_id_ = table_id;
+        auto status = DescribeTable(table_schema);
+        if (!status.ok()) {
+            return status;
+        }
+
+        Status result;
+        for (auto &file : files) {
+            TableFileSchema file_schema;
+            file_schema.table_id_ = table_id;
+            file_schema.id_ = std::get<0>(file);
+            file_schema.file_id_ = std::get<1>(file);
+            file_schema.file_type_ = std::get<2>(file);
+            file_schema.file_size_ = std::get<3>(file);
+            file_schema.row_count_ = std::get<4>(file);
+            file_schema.date_ = std::get<5>(file);
+            file_schema.engine_type_ = std::get<6>(file);
+            file_schema.created_on_ = std::get<7>(file);
+            file_schema.dimension_ = table_schema.dimension_;
+            file_schema.index_file_size_ = table_schema.index_file_size_;
+            file_schema.nlist_ = table_schema.nlist_;
+            file_schema.metric_type_ = table_schema.metric_type_;
+
+            utils::GetTableFilePath(options_, file_schema);
+
+            table_files.emplace_back(file_schema);
+        }
+
+        ENGINE_LOG_DEBUG << "Get table files by id";
+        return result;
+    } catch (std::exception &e) {
+        return HandleException("Encounter exception when lookup table files", e.what());
+    }
+}
+
+// TODO(myh): Support swap to cloud storage
+Status
+SqliteMetaImpl::Archive() {
+    auto &criterias = options_.archive_conf_.GetCriterias();
+    if (criterias.size() == 0) {
+        return Status::OK();
+    }
+
+    for (auto kv : criterias) {
+        auto &criteria = kv.first;
+        auto &limit = kv.second;
+        if (criteria == engine::ARCHIVE_CONF_DAYS) {
+            int64_t usecs = limit * D_SEC * US_PS;
+            int64_t now = utils::GetMicroSecTimeStamp();
+            try {
+                //multi-threads call sqlite update may get exception('bad logic', etc), so we add a lock here
+                std::lock_guard<std::mutex> meta_lock(meta_mutex_);
+
+                ConnectorPtr->update_all(
+                    set(
+                        c(&TableFileSchema::file_type_) = (int) TableFileSchema::TO_DELETE),
+                    where(
+                        c(&TableFileSchema::created_on_) < (int64_t) (now - usecs) and
+                            c(&TableFileSchema::file_type_) != (int) TableFileSchema::TO_DELETE));
+            } catch (std::exception &e) {
+                return HandleException("Encounter exception when update table files", e.what());
+            }
+
+            ENGINE_LOG_DEBUG << "Archive old files";
+        }
+        if (criteria == engine::ARCHIVE_CONF_DISK) {
+            uint64_t sum = 0;
+            Size(sum);
+
+            int64_t to_delete = (int64_t) sum - limit * G;
+            DiscardFiles(to_delete);
+
+            ENGINE_LOG_DEBUG << "Archive files to free disk";
+        }
+    }
+
+    return Status::OK();
+}
+
+Status
+SqliteMetaImpl::Size(uint64_t &result) {
+    result = 0;
+    try {
+        auto selected = ConnectorPtr->select(columns(sum(&TableFileSchema::file_size_)),
+                                             where(
+                                                 c(&TableFileSchema::file_type_) != (int) TableFileSchema::TO_DELETE));
+        for (auto &total_size : selected) {
+            if (!std::get<0>(total_size)) {
+                continue;
+            }
+            result += (uint64_t) (*std::get<0>(total_size));
+        }
+    } catch (std::exception &e) {
+        return HandleException("Encounter exception when calculte db size", e.what());
+    }
+
+    return Status::OK();
+}
+
+Status
+SqliteMetaImpl::DiscardFiles(int64_t to_discard_size) {
+    if (to_discard_size <= 0) {
+        return Status::OK();
+    }
+
+    ENGINE_LOG_DEBUG << "About to discard size=" << to_discard_size;
+
+    try {
+        server::MetricCollector metric;
+
+        //multi-threads call sqlite update may get exception('bad logic', etc), so we add a lock here
+        std::lock_guard<std::mutex> meta_lock(meta_mutex_);
+
+        auto commited = ConnectorPtr->transaction([&]() mutable {
+            auto selected = ConnectorPtr->select(columns(&TableFileSchema::id_,
+                                                         &TableFileSchema::file_size_),
+                                                 where(c(&TableFileSchema::file_type_)
+                                                           != (int) TableFileSchema::TO_DELETE),
+                                                 order_by(&TableFileSchema::id_),
+                                                 limit(10));
+
+            std::vector<int> ids;
+            TableFileSchema table_file;
+
+            for (auto &file : selected) {
+                if (to_discard_size <= 0) break;
+                table_file.id_ = std::get<0>(file);
+                table_file.file_size_ = std::get<1>(file);
+                ids.push_back(table_file.id_);
+                ENGINE_LOG_DEBUG << "Discard table_file.id=" << table_file.file_id_
+                                 << " table_file.size=" << table_file.file_size_;
+                to_discard_size -= table_file.file_size_;
+            }
+
+            if (ids.size() == 0) {
+                return true;
+            }
+
+            ConnectorPtr->update_all(
+                set(
+                    c(&TableFileSchema::file_type_) = (int) TableFileSchema::TO_DELETE,
+                    c(&TableFileSchema::updated_time_) = utils::GetMicroSecTimeStamp()),
+                where(
+                    in(&TableFileSchema::id_, ids)));
+
+            return true;
+        });
+
+        if (!commited) {
+            return HandleException("DiscardFiles error: sqlite transaction failed");
+        }
+    } catch (std::exception &e) {
+        return HandleException("Encounter exception when discard table file", e.what());
+    }
+
+    return DiscardFiles(to_discard_size);
+}
+
+Status
+SqliteMetaImpl::UpdateTableFile(TableFileSchema &file_schema) {
+    file_schema.updated_time_ = utils::GetMicroSecTimeStamp();
+    try {
+        server::MetricCollector metric;
+
+        //multi-threads call sqlite update may get exception('bad logic', etc), so we add a lock here
+        std::lock_guard<std::mutex> meta_lock(meta_mutex_);
+
+        auto tables = ConnectorPtr->select(columns(&TableSchema::state_),
+                                           where(c(&TableSchema::table_id_) == file_schema.table_id_));
+
+        //if the table has been deleted, just mark the table file as TO_DELETE
+        //clean thread will delete the file later
+        if (tables.size() < 1 || std::get<0>(tables[0]) == (int) TableSchema::TO_DELETE) {
+            file_schema.file_type_ = TableFileSchema::TO_DELETE;
+        }
+
+        ConnectorPtr->update(file_schema);
+
+        ENGINE_LOG_DEBUG << "Update single table file, file id = " << file_schema.file_id_;
+    } catch (std::exception &e) {
+        std::string msg = "Exception update table file: table_id = " + file_schema.table_id_
+            + " file_id = " + file_schema.file_id_;
+        return HandleException(msg, e.what());
+    }
+    return Status::OK();
+}
+
+Status
+SqliteMetaImpl::UpdateTableFilesToIndex(const std::string &table_id) {
+    try {
+        server::MetricCollector metric;
+
+        //multi-threads call sqlite update may get exception('bad logic', etc), so we add a lock here
+        std::lock_guard<std::mutex> meta_lock(meta_mutex_);
+
+        ConnectorPtr->update_all(
+            set(
+                c(&TableFileSchema::file_type_) = (int) TableFileSchema::TO_INDEX),
+            where(
+                c(&TableFileSchema::table_id_) == table_id and
+                    c(&TableFileSchema::file_type_) == (int) TableFileSchema::RAW));
+
+        ENGINE_LOG_DEBUG << "Update files to to_index, table id = " << table_id;
+    } catch (std::exception &e) {
+        return HandleException("Encounter exception when update table files to to_index", e.what());
+    }
+
+    return Status::OK();
+}
+
+Status
+SqliteMetaImpl::UpdateTableFiles(TableFilesSchema &files) {
+    try {
+        server::MetricCollector metric;
+
+        //multi-threads call sqlite update may get exception('bad logic', etc), so we add a lock here
+        std::lock_guard<std::mutex> meta_lock(meta_mutex_);
+
+        std::map<std::string, bool> has_tables;
+        for (auto &file : files) {
+            if (has_tables.find(file.table_id_) != has_tables.end()) {
+                continue;
+            }
+            auto tables = ConnectorPtr->select(columns(&TableSchema::id_),
+                                               where(c(&TableSchema::table_id_) == file.table_id_
+                                                         and c(&TableSchema::state_) != (int) TableSchema::TO_DELETE));
+            if (tables.size() >= 1) {
+                has_tables[file.table_id_] = true;
+            } else {
+                has_tables[file.table_id_] = false;
+            }
+        }
+
+        auto commited = ConnectorPtr->transaction([&]() mutable {
+            for (auto &file : files) {
+                if (!has_tables[file.table_id_]) {
+                    file.file_type_ = TableFileSchema::TO_DELETE;
+                }
+
+                file.updated_time_ = utils::GetMicroSecTimeStamp();
+                ConnectorPtr->update(file);
+            }
+            return true;
+        });
+
+        if (!commited) {
+            return HandleException("UpdateTableFiles error: sqlite transaction failed");
+        }
+
+        ENGINE_LOG_DEBUG << "Update " << files.size() << " table files";
+    } catch (std::exception &e) {
+        return HandleException("Encounter exception when update table files", e.what());
+    }
+    return Status::OK();
+}
+
+Status
+SqliteMetaImpl::CleanUpFilesWithTTL(uint16_t seconds) {
+    auto now = utils::GetMicroSecTimeStamp();
+    std::set<std::string> table_ids;
+
+    //remove to_delete files
+    try {
+        server::MetricCollector metric;
+
+        //multi-threads call sqlite update may get exception('bad logic', etc), so we add a lock here
+        std::lock_guard<std::mutex> meta_lock(meta_mutex_);
+
+        auto files = ConnectorPtr->select(columns(&TableFileSchema::id_,
+                                                  &TableFileSchema::table_id_,
+                                                  &TableFileSchema::file_id_,
+                                                  &TableFileSchema::date_),
+                                          where(
+                                              c(&TableFileSchema::file_type_) ==
+                                                  (int) TableFileSchema::TO_DELETE
+                                                  and
+                                                      c(&TableFileSchema::updated_time_)
+                                                          < now - seconds * US_PS));
+
+        auto commited = ConnectorPtr->transaction([&]() mutable {
+            TableFileSchema table_file;
+            for (auto &file : files) {
+                table_file.id_ = std::get<0>(file);
+                table_file.table_id_ = std::get<1>(file);
+                table_file.file_id_ = std::get<2>(file);
+                table_file.date_ = std::get<3>(file);
+
+                utils::DeleteTableFilePath(options_, table_file);
+                ENGINE_LOG_DEBUG << "Removing file id:" << table_file.file_id_ << " location:" << table_file.location_;
+                ConnectorPtr->remove<TableFileSchema>(table_file.id_);
+
+                table_ids.insert(table_file.table_id_);
+            }
+            return true;
+        });
+
+        if (!commited) {
+            return HandleException("CleanUpFilesWithTTL error: sqlite transaction failed");
+        }
+
+        if (files.size() > 0) {
+            ENGINE_LOG_DEBUG << "Clean " << files.size() << " files deleted in " << seconds << " seconds";
+        }
+    } catch (std::exception &e) {
+        return HandleException("Encounter exception when clean table files", e.what());
+    }
+
+    //remove to_delete tables
+    try {
+        server::MetricCollector metric;
+
+        //multi-threads call sqlite update may get exception('bad logic', etc), so we add a lock here
+        std::lock_guard<std::mutex> meta_lock(meta_mutex_);
+
+        auto tables = ConnectorPtr->select(columns(&TableSchema::id_,
+                                                   &TableSchema::table_id_),
+                                           where(c(&TableSchema::state_) == (int) TableSchema::TO_DELETE));
+
+        auto commited = ConnectorPtr->transaction([&]() mutable {
+            for (auto &table : tables) {
+                utils::DeleteTablePath(options_, std::get<1>(table), false);//only delete empty folder
+                ConnectorPtr->remove<TableSchema>(std::get<0>(table));
+            }
+
+            return true;
+        });
+
+        if (!commited) {
+            return HandleException("CleanUpFilesWithTTL error: sqlite transaction failed");
+        }
+
+        if (tables.size() > 0) {
+            ENGINE_LOG_DEBUG << "Remove " << tables.size() << " tables from meta";
+        }
+    } catch (std::exception &e) {
+        return HandleException("Encounter exception when clean table files", e.what());
+    }
+
+    //remove deleted table folder
+    //don't remove table folder until all its files has been deleted
+    try {
+        server::MetricCollector metric;
+
+        for (auto &table_id : table_ids) {
+            auto selected = ConnectorPtr->select(columns(&TableFileSchema::file_id_),
+                                                 where(c(&TableFileSchema::table_id_) == table_id));
+            if (selected.size() == 0) {
+                utils::DeleteTablePath(options_, table_id);
+            }
+        }
+
+        if (table_ids.size() > 0) {
+            ENGINE_LOG_DEBUG << "Remove " << table_ids.size() << " tables folder";
+        }
+    } catch (std::exception &e) {
+        return HandleException("Encounter exception when delete table folder", e.what());
+    }
+
+    return Status::OK();
+}
+
+Status
+SqliteMetaImpl::CleanUp() {
+    try {
+        server::MetricCollector metric;
+
+        //multi-threads call sqlite update may get exception('bad logic', etc), so we add a lock here
+        std::lock_guard<std::mutex> meta_lock(meta_mutex_);
+
+        std::vector<int> file_types = {
+            (int) TableFileSchema::NEW,
+            (int) TableFileSchema::NEW_INDEX,
+            (int) TableFileSchema::NEW_MERGE
+        };
+        auto files =
+            ConnectorPtr->select(columns(&TableFileSchema::id_), where(in(&TableFileSchema::file_type_, file_types)));
+
+        auto commited = ConnectorPtr->transaction([&]() mutable {
+            for (auto &file : files) {
+                ENGINE_LOG_DEBUG << "Remove table file type as NEW";
+                ConnectorPtr->remove<TableFileSchema>(std::get<0>(file));
+            }
+            return true;
+        });
+
+        if (!commited) {
+            return HandleException("CleanUp error: sqlite transaction failed");
+        }
+
+        if (files.size() > 0) {
+            ENGINE_LOG_DEBUG << "Clean " << files.size() << " files";
+        }
+    } catch (std::exception &e) {
+        return HandleException("Encounter exception when clean table file", e.what());
+    }
+
+    return Status::OK();
+}
+
+Status
+SqliteMetaImpl::Count(const std::string &table_id, uint64_t &result) {
+    try {
+        server::MetricCollector metric;
+
+        std::vector<int> file_types = {
+            (int) TableFileSchema::RAW,
+            (int) TableFileSchema::TO_INDEX,
+            (int) TableFileSchema::INDEX
+        };
+        auto selected = ConnectorPtr->select(columns(&TableFileSchema::row_count_),
+                                             where(in(&TableFileSchema::file_type_, file_types)
+                                                       and c(&TableFileSchema::table_id_) == table_id));
+
+        TableSchema table_schema;
+        table_schema.table_id_ = table_id;
+        auto status = DescribeTable(table_schema);
+
+        if (!status.ok()) {
+            return status;
+        }
+
+        result = 0;
+        for (auto &file : selected) {
+            result += std::get<0>(file);
+        }
+    } catch (std::exception &e) {
+        return HandleException("Encounter exception when calculate table file size", e.what());
+    }
+    return Status::OK();
+}
+
+Status
+SqliteMetaImpl::DropAll() {
+    ENGINE_LOG_DEBUG << "Drop all sqlite meta";
+
+    try {
+        ConnectorPtr->drop_table(META_TABLES);
+        ConnectorPtr->drop_table(META_TABLEFILES);
+    } catch (std::exception &e) {
+        return HandleException("Encounter exception when drop all meta", e.what());
+    }
+
+    return Status::OK();
+}
+
+} // namespace meta
+} // namespace engine
+} // namespace milvus
+
diff --git a/core/src/db/meta/SqliteMetaImpl.h b/core/src/db/meta/SqliteMetaImpl.h
new file mode 100644
index 0000000000..c8b99b358a
--- /dev/null
+++ b/core/src/db/meta/SqliteMetaImpl.h
@@ -0,0 +1,139 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "Meta.h"
+#include "db/Options.h"
+
+#include <mutex>
+#include <string>
+#include <vector>
+
+namespace milvus {
+namespace engine {
+namespace meta {
+
+auto
+StoragePrototype(const std::string& path);
+
+class SqliteMetaImpl : public Meta {
+ public:
+    explicit SqliteMetaImpl(const DBMetaOptions& options);
+    ~SqliteMetaImpl();
+
+    Status
+    CreateTable(TableSchema& table_schema) override;
+
+    Status
+    DescribeTable(TableSchema& table_schema) override;
+
+    Status
+    HasTable(const std::string& table_id, bool& has_or_not) override;
+
+    Status
+    AllTables(std::vector<TableSchema>& table_schema_array) override;
+
+    Status
+    DeleteTable(const std::string& table_id) override;
+
+    Status
+    DeleteTableFiles(const std::string& table_id) override;
+
+    Status
+    CreateTableFile(TableFileSchema& file_schema) override;
+
+    Status
+    DropPartitionsByDates(const std::string& table_id, const DatesT& dates) override;
+
+    Status
+    GetTableFiles(const std::string& table_id, const std::vector<size_t>& ids, TableFilesSchema& table_files) override;
+
+    Status
+    FilesByType(const std::string& table_id, const std::vector<int>& file_types,
+                std::vector<std::string>& file_ids) override;
+
+    Status
+    UpdateTableIndex(const std::string& table_id, const TableIndex& index) override;
+
+    Status
+    UpdateTableFlag(const std::string& table_id, int64_t flag) override;
+
+    Status
+    DescribeTableIndex(const std::string& table_id, TableIndex& index) override;
+
+    Status
+    DropTableIndex(const std::string& table_id) override;
+
+    Status
+    UpdateTableFilesToIndex(const std::string& table_id) override;
+
+    Status
+    UpdateTableFile(TableFileSchema& file_schema) override;
+
+    Status
+    UpdateTableFiles(TableFilesSchema& files) override;
+
+    Status
+    FilesToSearch(const std::string& table_id, const std::vector<size_t>& ids, const DatesT& dates,
+                  DatePartionedTableFilesSchema& files) override;
+
+    Status
+    FilesToMerge(const std::string& table_id, DatePartionedTableFilesSchema& files) override;
+
+    Status
+    FilesToIndex(TableFilesSchema&) override;
+
+    Status
+    Archive() override;
+
+    Status
+    Size(uint64_t& result) override;
+
+    Status
+    CleanUp() override;
+
+    Status
+    CleanUpFilesWithTTL(uint16_t seconds) override;
+
+    Status
+    DropAll() override;
+
+    Status
+    Count(const std::string& table_id, uint64_t& result) override;
+
+ private:
+    Status
+    NextFileId(std::string& file_id);
+    Status
+    NextTableId(std::string& table_id);
+    Status
+    DiscardFiles(int64_t to_discard_size);
+
+    void
+    ValidateMetaSchema();
+    Status
+    Initialize();
+
+ private:
+    const DBMetaOptions options_;
+    std::mutex meta_mutex_;
+};  // DBMetaImpl
+
+}  // namespace meta
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/external/nlohmann/json.hpp b/core/src/external/nlohmann/json.hpp
new file mode 100644
index 0000000000..2a32a82963
--- /dev/null
+++ b/core/src/external/nlohmann/json.hpp
@@ -0,0 +1,22684 @@
+/*
+    __ _____ _____ _____
+ __|  |   __|     |   | |  JSON for Modern C++
+|  |  |__   |  |  | | | |  version 3.7.0
+|_____|_____|_____|_|___|  https://github.com/nlohmann/json
+
+Licensed under the MIT License <http://opensource.org/licenses/MIT>.
+SPDX-License-Identifier: MIT
+Copyright (c) 2013-2019 Niels Lohmann <http://nlohmann.me>.
+
+Permission is hereby  granted, free of charge, to any  person obtaining a copy
+of this software and associated  documentation files (the "Software"), to deal
+in the Software  without restriction, including without  limitation the rights
+to  use, copy,  modify, merge,  publish, distribute,  sublicense, and/or  sell
+copies  of  the Software,  and  to  permit persons  to  whom  the Software  is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE  IS PROVIDED "AS  IS", WITHOUT WARRANTY  OF ANY KIND,  EXPRESS OR
+IMPLIED,  INCLUDING BUT  NOT  LIMITED TO  THE  WARRANTIES OF  MERCHANTABILITY,
+FITNESS FOR  A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN NO EVENT  SHALL THE
+AUTHORS  OR COPYRIGHT  HOLDERS  BE  LIABLE FOR  ANY  CLAIM,  DAMAGES OR  OTHER
+LIABILITY, WHETHER IN AN ACTION OF  CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE  OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+#ifndef INCLUDE_NLOHMANN_JSON_HPP_
+#define INCLUDE_NLOHMANN_JSON_HPP_
+
+#define NLOHMANN_JSON_VERSION_MAJOR 3
+#define NLOHMANN_JSON_VERSION_MINOR 7
+#define NLOHMANN_JSON_VERSION_PATCH 0
+
+#include <algorithm> // all_of, find, for_each
+#include <cassert> // assert
+#include <ciso646> // and, not, or
+#include <cstddef> // nullptr_t, ptrdiff_t, size_t
+#include <functional> // hash, less
+#include <initializer_list> // initializer_list
+#include <iosfwd> // istream, ostream
+#include <iterator> // random_access_iterator_tag
+#include <memory> // unique_ptr
+#include <numeric> // accumulate
+#include <string> // string, stoi, to_string
+#include <utility> // declval, forward, move, pair, swap
+#include <vector> // vector
+
+// #include <nlohmann/adl_serializer.hpp>
+
+
+#include <utility>
+
+// #include <nlohmann/detail/conversions/from_json.hpp>
+
+
+#include <algorithm> // transform
+#include <array> // array
+#include <ciso646> // and, not
+#include <forward_list> // forward_list
+#include <iterator> // inserter, front_inserter, end
+#include <map> // map
+#include <string> // string
+#include <tuple> // tuple, make_tuple
+#include <type_traits> // is_arithmetic, is_same, is_enum, underlying_type, is_convertible
+#include <unordered_map> // unordered_map
+#include <utility> // pair, declval
+#include <valarray> // valarray
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+
+#include <exception> // exception
+#include <stdexcept> // runtime_error
+#include <string> // to_string
+
+// #include <nlohmann/detail/input/position_t.hpp>
+
+
+#include <cstddef> // size_t
+
+namespace nlohmann
+{
+namespace detail
+{
+/// struct to capture the start position of the current token
+struct position_t
+{
+    /// the total number of characters read
+    std::size_t chars_read_total = 0;
+    /// the number of characters read in the current line
+    std::size_t chars_read_current_line = 0;
+    /// the number of lines read
+    std::size_t lines_read = 0;
+
+    /// conversion to size_t to preserve SAX interface
+    constexpr operator size_t() const
+    {
+        return chars_read_total;
+    }
+};
+
+} // namespace detail
+} // namespace nlohmann
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+#include <utility> // pair
+// #include <nlohmann/thirdparty/hedley/hedley.hpp>
+/* Hedley - https://nemequ.github.io/hedley
+ * Created by Evan Nemerson <evan@nemerson.com>
+ *
+ * To the extent possible under law, the author(s) have dedicated all
+ * copyright and related and neighboring rights to this software to
+ * the public domain worldwide. This software is distributed without
+ * any warranty.
+ *
+ * For details, see <http://creativecommons.org/publicdomain/zero/1.0/>.
+ * SPDX-License-Identifier: CC0-1.0
+ */
+
+#if !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < 9)
+#if defined(JSON_HEDLEY_VERSION)
+    #undef JSON_HEDLEY_VERSION
+#endif
+#define JSON_HEDLEY_VERSION 9
+
+#if defined(JSON_HEDLEY_STRINGIFY_EX)
+    #undef JSON_HEDLEY_STRINGIFY_EX
+#endif
+#define JSON_HEDLEY_STRINGIFY_EX(x) #x
+
+#if defined(JSON_HEDLEY_STRINGIFY)
+    #undef JSON_HEDLEY_STRINGIFY
+#endif
+#define JSON_HEDLEY_STRINGIFY(x) JSON_HEDLEY_STRINGIFY_EX(x)
+
+#if defined(JSON_HEDLEY_CONCAT_EX)
+    #undef JSON_HEDLEY_CONCAT_EX
+#endif
+#define JSON_HEDLEY_CONCAT_EX(a,b) a##b
+
+#if defined(JSON_HEDLEY_CONCAT)
+    #undef JSON_HEDLEY_CONCAT
+#endif
+#define JSON_HEDLEY_CONCAT(a,b) JSON_HEDLEY_CONCAT_EX(a,b)
+
+#if defined(JSON_HEDLEY_VERSION_ENCODE)
+    #undef JSON_HEDLEY_VERSION_ENCODE
+#endif
+#define JSON_HEDLEY_VERSION_ENCODE(major,minor,revision) (((major) * 1000000) + ((minor) * 1000) + (revision))
+
+#if defined(JSON_HEDLEY_VERSION_DECODE_MAJOR)
+    #undef JSON_HEDLEY_VERSION_DECODE_MAJOR
+#endif
+#define JSON_HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000)
+
+#if defined(JSON_HEDLEY_VERSION_DECODE_MINOR)
+    #undef JSON_HEDLEY_VERSION_DECODE_MINOR
+#endif
+#define JSON_HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000)
+
+#if defined(JSON_HEDLEY_VERSION_DECODE_REVISION)
+    #undef JSON_HEDLEY_VERSION_DECODE_REVISION
+#endif
+#define JSON_HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000)
+
+#if defined(JSON_HEDLEY_GNUC_VERSION)
+    #undef JSON_HEDLEY_GNUC_VERSION
+#endif
+#if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__)
+    #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
+#elif defined(__GNUC__)
+    #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, 0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_VERSION_CHECK)
+    #undef JSON_HEDLEY_GNUC_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_GNUC_VERSION)
+    #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GNUC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_MSVC_VERSION)
+    #undef JSON_HEDLEY_MSVC_VERSION
+#endif
+#if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000)
+    #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 10000000, (_MSC_FULL_VER % 10000000) / 100000, (_MSC_FULL_VER % 100000) / 100)
+#elif defined(_MSC_FULL_VER)
+    #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 1000000, (_MSC_FULL_VER % 1000000) / 10000, (_MSC_FULL_VER % 10000) / 10)
+#elif defined(_MSC_VER)
+    #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_VER / 100, _MSC_VER % 100, 0)
+#endif
+
+#if defined(JSON_HEDLEY_MSVC_VERSION_CHECK)
+    #undef JSON_HEDLEY_MSVC_VERSION_CHECK
+#endif
+#if !defined(_MSC_VER)
+    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (0)
+#elif defined(_MSC_VER) && (_MSC_VER >= 1400)
+    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch)))
+#elif defined(_MSC_VER) && (_MSC_VER >= 1200)
+    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch)))
+#else
+    #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_VER >= ((major * 100) + (minor)))
+#endif
+
+#if defined(JSON_HEDLEY_INTEL_VERSION)
+    #undef JSON_HEDLEY_INTEL_VERSION
+#endif
+#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE)
+    #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, __INTEL_COMPILER_UPDATE)
+#elif defined(__INTEL_COMPILER)
+    #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0)
+#endif
+
+#if defined(JSON_HEDLEY_INTEL_VERSION_CHECK)
+    #undef JSON_HEDLEY_INTEL_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_INTEL_VERSION)
+    #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_PGI_VERSION)
+    #undef JSON_HEDLEY_PGI_VERSION
+#endif
+#if defined(__PGI) && defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__)
+    #define JSON_HEDLEY_PGI_VERSION JSON_HEDLEY_VERSION_ENCODE(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__)
+#endif
+
+#if defined(JSON_HEDLEY_PGI_VERSION_CHECK)
+    #undef JSON_HEDLEY_PGI_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_PGI_VERSION)
+    #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PGI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_SUNPRO_VERSION)
+    #undef JSON_HEDLEY_SUNPRO_VERSION
+#endif
+#if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000)
+    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_C >> 16) & 0xf) * 10) + ((__SUNPRO_C >> 12) & 0xf), (((__SUNPRO_C >> 8) & 0xf) * 10) + ((__SUNPRO_C >> 4) & 0xf), (__SUNPRO_C & 0xf) * 10)
+#elif defined(__SUNPRO_C)
+    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_C >> 8) & 0xf, (__SUNPRO_C >> 4) & 0xf, (__SUNPRO_C) & 0xf)
+#elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000)
+    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_CC >> 16) & 0xf) * 10) + ((__SUNPRO_CC >> 12) & 0xf), (((__SUNPRO_CC >> 8) & 0xf) * 10) + ((__SUNPRO_CC >> 4) & 0xf), (__SUNPRO_CC & 0xf) * 10)
+#elif defined(__SUNPRO_CC)
+    #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_CC >> 8) & 0xf, (__SUNPRO_CC >> 4) & 0xf, (__SUNPRO_CC) & 0xf)
+#endif
+
+#if defined(JSON_HEDLEY_SUNPRO_VERSION_CHECK)
+    #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_SUNPRO_VERSION)
+    #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_SUNPRO_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
+    #undef JSON_HEDLEY_EMSCRIPTEN_VERSION
+#endif
+#if defined(__EMSCRIPTEN__)
+    #define JSON_HEDLEY_EMSCRIPTEN_VERSION JSON_HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__)
+#endif
+
+#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK)
+    #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
+    #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_EMSCRIPTEN_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_ARM_VERSION)
+    #undef JSON_HEDLEY_ARM_VERSION
+#endif
+#if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION)
+    #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCOMPILER_VERSION / 1000000, (__ARMCOMPILER_VERSION % 1000000) / 10000, (__ARMCOMPILER_VERSION % 10000) / 100)
+#elif defined(__CC_ARM) && defined(__ARMCC_VERSION)
+    #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCC_VERSION / 1000000, (__ARMCC_VERSION % 1000000) / 10000, (__ARMCC_VERSION % 10000) / 100)
+#endif
+
+#if defined(JSON_HEDLEY_ARM_VERSION_CHECK)
+    #undef JSON_HEDLEY_ARM_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_ARM_VERSION)
+    #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_ARM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_IBM_VERSION)
+    #undef JSON_HEDLEY_IBM_VERSION
+#endif
+#if defined(__ibmxl__)
+    #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ibmxl_version__, __ibmxl_release__, __ibmxl_modification__)
+#elif defined(__xlC__) && defined(__xlC_ver__)
+    #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, (__xlC_ver__ >> 8) & 0xff)
+#elif defined(__xlC__)
+    #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, 0)
+#endif
+
+#if defined(JSON_HEDLEY_IBM_VERSION_CHECK)
+    #undef JSON_HEDLEY_IBM_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_IBM_VERSION)
+    #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IBM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TI_VERSION)
+    #undef JSON_HEDLEY_TI_VERSION
+#endif
+#if defined(__TI_COMPILER_VERSION__)
+    #define JSON_HEDLEY_TI_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
+#endif
+
+#if defined(JSON_HEDLEY_TI_VERSION_CHECK)
+    #undef JSON_HEDLEY_TI_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TI_VERSION)
+    #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_CRAY_VERSION)
+    #undef JSON_HEDLEY_CRAY_VERSION
+#endif
+#if defined(_CRAYC)
+    #if defined(_RELEASE_PATCHLEVEL)
+        #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, _RELEASE_PATCHLEVEL)
+    #else
+        #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0)
+    #endif
+#endif
+
+#if defined(JSON_HEDLEY_CRAY_VERSION_CHECK)
+    #undef JSON_HEDLEY_CRAY_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_CRAY_VERSION)
+    #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_CRAY_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_IAR_VERSION)
+    #undef JSON_HEDLEY_IAR_VERSION
+#endif
+#if defined(__IAR_SYSTEMS_ICC__)
+    #if __VER__ > 1000
+        #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE((__VER__ / 1000000), ((__VER__ / 1000) % 1000), (__VER__ % 1000))
+    #else
+        #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE(VER / 100, __VER__ % 100, 0)
+    #endif
+#endif
+
+#if defined(JSON_HEDLEY_IAR_VERSION_CHECK)
+    #undef JSON_HEDLEY_IAR_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_IAR_VERSION)
+    #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IAR_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_TINYC_VERSION)
+    #undef JSON_HEDLEY_TINYC_VERSION
+#endif
+#if defined(__TINYC__)
+    #define JSON_HEDLEY_TINYC_VERSION JSON_HEDLEY_VERSION_ENCODE(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100)
+#endif
+
+#if defined(JSON_HEDLEY_TINYC_VERSION_CHECK)
+    #undef JSON_HEDLEY_TINYC_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_TINYC_VERSION)
+    #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TINYC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_DMC_VERSION)
+    #undef JSON_HEDLEY_DMC_VERSION
+#endif
+#if defined(__DMC__)
+    #define JSON_HEDLEY_DMC_VERSION JSON_HEDLEY_VERSION_ENCODE(__DMC__ >> 8, (__DMC__ >> 4) & 0xf, __DMC__ & 0xf)
+#endif
+
+#if defined(JSON_HEDLEY_DMC_VERSION_CHECK)
+    #undef JSON_HEDLEY_DMC_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_DMC_VERSION)
+    #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_DMC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_COMPCERT_VERSION)
+    #undef JSON_HEDLEY_COMPCERT_VERSION
+#endif
+#if defined(__COMPCERT_VERSION__)
+    #define JSON_HEDLEY_COMPCERT_VERSION JSON_HEDLEY_VERSION_ENCODE(__COMPCERT_VERSION__ / 10000, (__COMPCERT_VERSION__ / 100) % 100, __COMPCERT_VERSION__ % 100)
+#endif
+
+#if defined(JSON_HEDLEY_COMPCERT_VERSION_CHECK)
+    #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_COMPCERT_VERSION)
+    #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_COMPCERT_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_PELLES_VERSION)
+    #undef JSON_HEDLEY_PELLES_VERSION
+#endif
+#if defined(__POCC__)
+    #define JSON_HEDLEY_PELLES_VERSION JSON_HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0)
+#endif
+
+#if defined(JSON_HEDLEY_PELLES_VERSION_CHECK)
+    #undef JSON_HEDLEY_PELLES_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_PELLES_VERSION)
+    #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PELLES_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_VERSION)
+    #undef JSON_HEDLEY_GCC_VERSION
+#endif
+#if \
+    defined(JSON_HEDLEY_GNUC_VERSION) && \
+    !defined(__clang__) && \
+    !defined(JSON_HEDLEY_INTEL_VERSION) && \
+    !defined(JSON_HEDLEY_PGI_VERSION) && \
+    !defined(JSON_HEDLEY_ARM_VERSION) && \
+    !defined(JSON_HEDLEY_TI_VERSION) && \
+    !defined(__COMPCERT__)
+    #define JSON_HEDLEY_GCC_VERSION JSON_HEDLEY_GNUC_VERSION
+#endif
+
+#if defined(JSON_HEDLEY_GCC_VERSION_CHECK)
+    #undef JSON_HEDLEY_GCC_VERSION_CHECK
+#endif
+#if defined(JSON_HEDLEY_GCC_VERSION)
+    #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
+#else
+    #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (0)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_ATTRIBUTE)
+    #undef JSON_HEDLEY_HAS_ATTRIBUTE
+#endif
+#if defined(__has_attribute)
+    #define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute)
+#else
+    #define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_ATTRIBUTE)
+    #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
+#endif
+#if defined(__has_attribute)
+    #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) __has_attribute(attribute)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_ATTRIBUTE)
+    #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
+#endif
+#if defined(__has_attribute)
+    #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) __has_attribute(attribute)
+#else
+    #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE)
+    #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
+#endif
+#if defined(__has_cpp_attribute) && defined(__cplusplus)
+    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) __has_cpp_attribute(attribute)
+#else
+    #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE)
+    #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
+#endif
+#if defined(__has_cpp_attribute) && defined(__cplusplus)
+    #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE)
+    #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
+#endif
+#if defined(__has_cpp_attribute) && defined(__cplusplus)
+    #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
+#else
+    #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_BUILTIN)
+    #undef JSON_HEDLEY_HAS_BUILTIN
+#endif
+#if defined(__has_builtin)
+    #define JSON_HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin)
+#else
+    #define JSON_HEDLEY_HAS_BUILTIN(builtin) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_BUILTIN)
+    #undef JSON_HEDLEY_GNUC_HAS_BUILTIN
+#endif
+#if defined(__has_builtin)
+    #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_BUILTIN)
+    #undef JSON_HEDLEY_GCC_HAS_BUILTIN
+#endif
+#if defined(__has_builtin)
+    #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
+#else
+    #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_FEATURE)
+    #undef JSON_HEDLEY_HAS_FEATURE
+#endif
+#if defined(__has_feature)
+    #define JSON_HEDLEY_HAS_FEATURE(feature) __has_feature(feature)
+#else
+    #define JSON_HEDLEY_HAS_FEATURE(feature) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_FEATURE)
+    #undef JSON_HEDLEY_GNUC_HAS_FEATURE
+#endif
+#if defined(__has_feature)
+    #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_FEATURE)
+    #undef JSON_HEDLEY_GCC_HAS_FEATURE
+#endif
+#if defined(__has_feature)
+    #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
+#else
+    #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_EXTENSION)
+    #undef JSON_HEDLEY_HAS_EXTENSION
+#endif
+#if defined(__has_extension)
+    #define JSON_HEDLEY_HAS_EXTENSION(extension) __has_extension(extension)
+#else
+    #define JSON_HEDLEY_HAS_EXTENSION(extension) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_EXTENSION)
+    #undef JSON_HEDLEY_GNUC_HAS_EXTENSION
+#endif
+#if defined(__has_extension)
+    #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_EXTENSION)
+    #undef JSON_HEDLEY_GCC_HAS_EXTENSION
+#endif
+#if defined(__has_extension)
+    #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
+#else
+    #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE)
+    #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
+#endif
+#if defined(__has_declspec_attribute)
+    #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) __has_declspec_attribute(attribute)
+#else
+    #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE)
+    #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
+#endif
+#if defined(__has_declspec_attribute)
+    #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE)
+    #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
+#endif
+#if defined(__has_declspec_attribute)
+    #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
+#else
+    #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_HAS_WARNING)
+    #undef JSON_HEDLEY_HAS_WARNING
+#endif
+#if defined(__has_warning)
+    #define JSON_HEDLEY_HAS_WARNING(warning) __has_warning(warning)
+#else
+    #define JSON_HEDLEY_HAS_WARNING(warning) (0)
+#endif
+
+#if defined(JSON_HEDLEY_GNUC_HAS_WARNING)
+    #undef JSON_HEDLEY_GNUC_HAS_WARNING
+#endif
+#if defined(__has_warning)
+    #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
+#else
+    #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_GCC_HAS_WARNING)
+    #undef JSON_HEDLEY_GCC_HAS_WARNING
+#endif
+#if defined(__has_warning)
+    #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
+#else
+    #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if \
+    (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
+    defined(__clang__) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(6,0,0) || \
+    JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) || \
+    JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,17) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(8,0,0) || \
+    (JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) && defined(__C99_PRAGMA_OPERATOR))
+    #define JSON_HEDLEY_PRAGMA(value) _Pragma(#value)
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
+    #define JSON_HEDLEY_PRAGMA(value) __pragma(value)
+#else
+    #define JSON_HEDLEY_PRAGMA(value)
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_PUSH)
+    #undef JSON_HEDLEY_DIAGNOSTIC_PUSH
+#endif
+#if defined(JSON_HEDLEY_DIAGNOSTIC_POP)
+    #undef JSON_HEDLEY_DIAGNOSTIC_POP
+#endif
+#if defined(__clang__)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("clang diagnostic pop")
+#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop")
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(push))
+    #define JSON_HEDLEY_DIAGNOSTIC_POP __pragma(warning(pop))
+#elif JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("push")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("pop")
+#elif JSON_HEDLEY_TI_VERSION_CHECK(8,1,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("diag_push")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("diag_pop")
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
+    #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_PUSH
+    #define JSON_HEDLEY_DIAGNOSTIC_POP
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED)
+    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wdeprecated-declarations")
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"")
+#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warning(disable:1478 1786)")
+#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:4996))
+#elif JSON_HEDLEY_TI_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1291,1718")
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && !defined(__cplusplus)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,E_DEPRECATED_ATT,E_DEPRECATED_ATT_MESS)")
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && defined(__cplusplus)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,symdeprecated,symdeprecated2)")
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress=Pe1444,Pe1215")
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warn(disable:2241)")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS)
+    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("clang diagnostic ignored \"-Wunknown-pragmas\"")
+#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("warning(disable:161)")
+#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 1675")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("GCC diagnostic ignored \"-Wunknown-pragmas\"")
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:4068))
+#elif JSON_HEDLEY_TI_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress=Pe161")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
+#endif
+
+#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL)
+    #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wcast-qual")
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("clang diagnostic ignored \"-Wcast-qual\"")
+#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("warning(disable:2203 2331)")
+#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0)
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("GCC diagnostic ignored \"-Wcast-qual\"")
+#else
+    #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
+#endif
+
+#if defined(JSON_HEDLEY_DEPRECATED)
+    #undef JSON_HEDLEY_DEPRECATED
+#endif
+#if defined(JSON_HEDLEY_DEPRECATED_FOR)
+    #undef JSON_HEDLEY_DEPRECATED_FOR
+#endif
+#if defined(__cplusplus) && (__cplusplus >= 201402L)
+    #define JSON_HEDLEY_DEPRECATED(since) [[deprecated("Since " #since)]]
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) [[deprecated("Since " #since "; use " #replacement)]]
+#elif \
+    JSON_HEDLEY_HAS_EXTENSION(attribute_deprecated_with_message) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(8,3,0)
+    #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__("Since " #since)))
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__("Since " #since "; use " #replacement)))
+#elif \
+    JSON_HEDLEY_HAS_ATTRIBUTE(deprecated) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(8,0,0) || \
+    (JSON_HEDLEY_TI_VERSION_CHECK(7,3,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))
+    #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__))
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__))
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0)
+    #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated("Since " # since))
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated("Since " #since "; use " #replacement))
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
+    JSON_HEDLEY_PELLES_VERSION_CHECK(6,50,0)
+    #define JSON_HEDLEY_DEPRECATED(since) _declspec(deprecated)
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated)
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_DEPRECATED(since) _Pragma("deprecated")
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) _Pragma("deprecated")
+#else
+    #define JSON_HEDLEY_DEPRECATED(since)
+    #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement)
+#endif
+
+#if defined(JSON_HEDLEY_UNAVAILABLE)
+    #undef JSON_HEDLEY_UNAVAILABLE
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(warning) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+    #define JSON_HEDLEY_UNAVAILABLE(available_since) __attribute__((__warning__("Not available until " #available_since)))
+#else
+    #define JSON_HEDLEY_UNAVAILABLE(available_since)
+#endif
+
+#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT)
+    #undef JSON_HEDLEY_WARN_UNUSED_RESULT
+#endif
+#if defined(__cplusplus) && (__cplusplus >= 201703L)
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT [[nodiscard]]
+#elif \
+    JSON_HEDLEY_HAS_ATTRIBUTE(warn_unused_result) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(8,0,0) || \
+    (JSON_HEDLEY_TI_VERSION_CHECK(7,3,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__))
+#elif defined(_Check_return_) /* SAL */
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT _Check_return_
+#else
+    #define JSON_HEDLEY_WARN_UNUSED_RESULT
+#endif
+
+#if defined(JSON_HEDLEY_SENTINEL)
+    #undef JSON_HEDLEY_SENTINEL
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(sentinel) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0)
+    #define JSON_HEDLEY_SENTINEL(position) __attribute__((__sentinel__(position)))
+#else
+    #define JSON_HEDLEY_SENTINEL(position)
+#endif
+
+#if defined(JSON_HEDLEY_NO_RETURN)
+    #undef JSON_HEDLEY_NO_RETURN
+#endif
+#if JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_NO_RETURN __noreturn
+#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+    #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
+#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
+    #define JSON_HEDLEY_NO_RETURN _Noreturn
+#elif defined(__cplusplus) && (__cplusplus >= 201103L)
+    #define JSON_HEDLEY_NO_RETURN [[noreturn]]
+#elif \
+    JSON_HEDLEY_HAS_ATTRIBUTE(noreturn) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,2,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(18,0,0) || \
+    (JSON_HEDLEY_TI_VERSION_CHECK(17,3,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))
+    #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0)
+    #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
+#elif JSON_HEDLEY_TI_VERSION_CHECK(6,0,0) && defined(__cplusplus)
+    #define JSON_HEDLEY_NO_RETURN _Pragma("FUNC_NEVER_RETURNS;")
+#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
+    #define JSON_HEDLEY_NO_RETURN __attribute((noreturn))
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
+    #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
+#else
+    #define JSON_HEDLEY_NO_RETURN
+#endif
+
+#if defined(JSON_HEDLEY_UNREACHABLE)
+    #undef JSON_HEDLEY_UNREACHABLE
+#endif
+#if defined(JSON_HEDLEY_UNREACHABLE_RETURN)
+    #undef JSON_HEDLEY_UNREACHABLE_RETURN
+#endif
+#if \
+    (JSON_HEDLEY_HAS_BUILTIN(__builtin_unreachable) && (!defined(JSON_HEDLEY_ARM_VERSION))) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(13,1,5)
+    #define JSON_HEDLEY_UNREACHABLE() __builtin_unreachable()
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0)
+    #define JSON_HEDLEY_UNREACHABLE() __assume(0)
+#elif JSON_HEDLEY_TI_VERSION_CHECK(6,0,0)
+    #if defined(__cplusplus)
+        #define JSON_HEDLEY_UNREACHABLE() std::_nassert(0)
+    #else
+        #define JSON_HEDLEY_UNREACHABLE() _nassert(0)
+    #endif
+    #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return value
+#elif defined(EXIT_FAILURE)
+    #define JSON_HEDLEY_UNREACHABLE() abort()
+#else
+    #define JSON_HEDLEY_UNREACHABLE()
+    #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return value
+#endif
+#if !defined(JSON_HEDLEY_UNREACHABLE_RETURN)
+    #define JSON_HEDLEY_UNREACHABLE_RETURN(value) JSON_HEDLEY_UNREACHABLE()
+#endif
+
+#if defined(JSON_HEDLEY_ASSUME)
+    #undef JSON_HEDLEY_ASSUME
+#endif
+#if \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+    #define JSON_HEDLEY_ASSUME(expr) __assume(expr)
+#elif JSON_HEDLEY_HAS_BUILTIN(__builtin_assume)
+    #define JSON_HEDLEY_ASSUME(expr) __builtin_assume(expr)
+#elif JSON_HEDLEY_TI_VERSION_CHECK(6,0,0)
+    #if defined(__cplusplus)
+        #define JSON_HEDLEY_ASSUME(expr) std::_nassert(expr)
+    #else
+        #define JSON_HEDLEY_ASSUME(expr) _nassert(expr)
+    #endif
+#elif \
+    (JSON_HEDLEY_HAS_BUILTIN(__builtin_unreachable) && !defined(JSON_HEDLEY_ARM_VERSION)) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(13,1,5)
+    #define JSON_HEDLEY_ASSUME(expr) ((void) ((expr) ? 1 : (__builtin_unreachable(), 1)))
+#else
+    #define JSON_HEDLEY_ASSUME(expr) ((void) (expr))
+#endif
+
+
+JSON_HEDLEY_DIAGNOSTIC_PUSH
+#if \
+    JSON_HEDLEY_HAS_WARNING("-Wvariadic-macros") || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0)
+    #if defined(__clang__)
+        #pragma clang diagnostic ignored "-Wvariadic-macros"
+    #elif defined(JSON_HEDLEY_GCC_VERSION)
+        #pragma GCC diagnostic ignored "-Wvariadic-macros"
+    #endif
+#endif
+#if defined(JSON_HEDLEY_NON_NULL)
+    #undef JSON_HEDLEY_NON_NULL
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(nonnull) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
+    #define JSON_HEDLEY_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__)))
+#else
+    #define JSON_HEDLEY_NON_NULL(...)
+#endif
+JSON_HEDLEY_DIAGNOSTIC_POP
+
+#if defined(JSON_HEDLEY_PRINTF_FORMAT)
+    #undef JSON_HEDLEY_PRINTF_FORMAT
+#endif
+#if defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && !defined(__USE_MINGW_ANSI_STDIO)
+    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(ms_printf, string_idx, first_to_check)))
+#elif defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && defined(__USE_MINGW_ANSI_STDIO)
+    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(gnu_printf, string_idx, first_to_check)))
+#elif \
+    JSON_HEDLEY_HAS_ATTRIBUTE(format) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(8,0,0) || \
+    (JSON_HEDLEY_TI_VERSION_CHECK(7,3,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))
+    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(__printf__, string_idx, first_to_check)))
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(6,0,0)
+    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __declspec(vaformat(printf,string_idx,first_to_check))
+#else
+    #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check)
+#endif
+
+#if defined(JSON_HEDLEY_CONSTEXPR)
+    #undef JSON_HEDLEY_CONSTEXPR
+#endif
+#if defined(__cplusplus)
+    #if __cplusplus >= 201103L
+        #define JSON_HEDLEY_CONSTEXPR constexpr
+    #endif
+#endif
+#if !defined(JSON_HEDLEY_CONSTEXPR)
+    #define JSON_HEDLEY_CONSTEXPR
+#endif
+
+#if defined(JSON_HEDLEY_PREDICT)
+    #undef JSON_HEDLEY_PREDICT
+#endif
+#if defined(JSON_HEDLEY_LIKELY)
+    #undef JSON_HEDLEY_LIKELY
+#endif
+#if defined(JSON_HEDLEY_UNLIKELY)
+    #undef JSON_HEDLEY_UNLIKELY
+#endif
+#if defined(JSON_HEDLEY_UNPREDICTABLE)
+    #undef JSON_HEDLEY_UNPREDICTABLE
+#endif
+#if JSON_HEDLEY_HAS_BUILTIN(__builtin_unpredictable)
+    #define JSON_HEDLEY_UNPREDICTABLE(expr) __builtin_unpredictable(!!(expr))
+#endif
+#if \
+  JSON_HEDLEY_HAS_BUILTIN(__builtin_expect_with_probability) || \
+  JSON_HEDLEY_GCC_VERSION_CHECK(9,0,0)
+#  define JSON_HEDLEY_PREDICT(expr, value, probability) __builtin_expect_with_probability(expr, value, probability)
+#  define JSON_HEDLEY_PREDICT_TRUE(expr, probability) __builtin_expect_with_probability(!!(expr), 1, probability)
+#  define JSON_HEDLEY_PREDICT_FALSE(expr, probability) __builtin_expect_with_probability(!!(expr), 0, probability)
+#  define JSON_HEDLEY_LIKELY(expr) __builtin_expect(!!(expr), 1)
+#  define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0)
+#if !defined(JSON_HEDLEY_BUILTIN_UNPREDICTABLE)
+    #define JSON_HEDLEY_BUILTIN_UNPREDICTABLE(expr) __builtin_expect_with_probability(!!(expr), 1, 0.5)
+#endif
+#elif \
+  JSON_HEDLEY_HAS_BUILTIN(__builtin_expect) || \
+  JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+  (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
+  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+  JSON_HEDLEY_TI_VERSION_CHECK(6,1,0) || \
+  JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,27)
+#  define JSON_HEDLEY_PREDICT(expr, expected, probability) \
+    (((probability) >= 0.9) ? __builtin_expect(!!(expr), (expected)) : (((void) (expected)), !!(expr)))
+#  define JSON_HEDLEY_PREDICT_TRUE(expr, probability) \
+    (__extension__ ({ \
+        JSON_HEDLEY_CONSTEXPR double hedley_probability_ = (probability); \
+        ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 1) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 0) : !!(expr))); \
+    }))
+#  define JSON_HEDLEY_PREDICT_FALSE(expr, probability) \
+    (__extension__ ({ \
+        JSON_HEDLEY_CONSTEXPR double hedley_probability_ = (probability); \
+        ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 0) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 1) : !!(expr))); \
+    }))
+#  define JSON_HEDLEY_LIKELY(expr)   __builtin_expect(!!(expr), 1)
+#  define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0)
+#else
+#  define JSON_HEDLEY_PREDICT(expr, expected, probability) (((void) (expected)), !!(expr))
+#  define JSON_HEDLEY_PREDICT_TRUE(expr, probability) (!!(expr))
+#  define JSON_HEDLEY_PREDICT_FALSE(expr, probability) (!!(expr))
+#  define JSON_HEDLEY_LIKELY(expr) (!!(expr))
+#  define JSON_HEDLEY_UNLIKELY(expr) (!!(expr))
+#endif
+#if !defined(JSON_HEDLEY_UNPREDICTABLE)
+    #define JSON_HEDLEY_UNPREDICTABLE(expr) JSON_HEDLEY_PREDICT(expr, 1, 0.5)
+#endif
+
+#if defined(JSON_HEDLEY_MALLOC)
+    #undef JSON_HEDLEY_MALLOC
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(malloc) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(8,0,0) || \
+    (JSON_HEDLEY_TI_VERSION_CHECK(7,3,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))
+    #define JSON_HEDLEY_MALLOC __attribute__((__malloc__))
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(14, 0, 0)
+    #define JSON_HEDLEY_MALLOC __declspec(restrict)
+#else
+    #define JSON_HEDLEY_MALLOC
+#endif
+
+#if defined(JSON_HEDLEY_PURE)
+    #undef JSON_HEDLEY_PURE
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(pure) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(2,96,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(8,0,0) || \
+    (JSON_HEDLEY_TI_VERSION_CHECK(7,3,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
+    #define JSON_HEDLEY_PURE __attribute__((__pure__))
+#elif JSON_HEDLEY_TI_VERSION_CHECK(6,0,0) && defined(__cplusplus)
+    #define JSON_HEDLEY_PURE _Pragma("FUNC_IS_PURE;")
+#else
+    #define JSON_HEDLEY_PURE
+#endif
+
+#if defined(JSON_HEDLEY_CONST)
+    #undef JSON_HEDLEY_CONST
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(const) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(2,5,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(8,0,0) || \
+    (JSON_HEDLEY_TI_VERSION_CHECK(7,3,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
+    #define JSON_HEDLEY_CONST __attribute__((__const__))
+#else
+    #define JSON_HEDLEY_CONST JSON_HEDLEY_PURE
+#endif
+
+#if defined(JSON_HEDLEY_RESTRICT)
+    #undef JSON_HEDLEY_RESTRICT
+#endif
+#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(__cplusplus)
+    #define JSON_HEDLEY_RESTRICT restrict
+#elif \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+    JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(8,0,0) || \
+    (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)) || \
+    JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
+    defined(__clang__)
+    #define JSON_HEDLEY_RESTRICT __restrict
+#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,3,0) && !defined(__cplusplus)
+    #define JSON_HEDLEY_RESTRICT _Restrict
+#else
+    #define JSON_HEDLEY_RESTRICT
+#endif
+
+#if defined(JSON_HEDLEY_INLINE)
+    #undef JSON_HEDLEY_INLINE
+#endif
+#if \
+    (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
+    (defined(__cplusplus) && (__cplusplus >= 199711L))
+    #define JSON_HEDLEY_INLINE inline
+#elif \
+    defined(JSON_HEDLEY_GCC_VERSION) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(6,2,0)
+    #define JSON_HEDLEY_INLINE __inline__
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_INLINE __inline
+#else
+    #define JSON_HEDLEY_INLINE
+#endif
+
+#if defined(JSON_HEDLEY_ALWAYS_INLINE)
+    #undef JSON_HEDLEY_ALWAYS_INLINE
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(always_inline) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(8,0,0) || \
+    (JSON_HEDLEY_TI_VERSION_CHECK(7,3,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))
+    #define JSON_HEDLEY_ALWAYS_INLINE __attribute__((__always_inline__)) JSON_HEDLEY_INLINE
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0)
+    #define JSON_HEDLEY_ALWAYS_INLINE __forceinline
+#elif JSON_HEDLEY_TI_VERSION_CHECK(7,0,0) && defined(__cplusplus)
+    #define JSON_HEDLEY_ALWAYS_INLINE _Pragma("FUNC_ALWAYS_INLINE;")
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_ALWAYS_INLINE _Pragma("inline=forced")
+#else
+    #define JSON_HEDLEY_ALWAYS_INLINE JSON_HEDLEY_INLINE
+#endif
+
+#if defined(JSON_HEDLEY_NEVER_INLINE)
+    #undef JSON_HEDLEY_NEVER_INLINE
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(noinline) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(8,0,0) || \
+    (JSON_HEDLEY_TI_VERSION_CHECK(7,3,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))
+    #define JSON_HEDLEY_NEVER_INLINE __attribute__((__noinline__))
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0)
+    #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
+#elif JSON_HEDLEY_PGI_VERSION_CHECK(10,2,0)
+    #define JSON_HEDLEY_NEVER_INLINE _Pragma("noinline")
+#elif JSON_HEDLEY_TI_VERSION_CHECK(6,0,0) && defined(__cplusplus)
+    #define JSON_HEDLEY_NEVER_INLINE _Pragma("FUNC_CANNOT_INLINE;")
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+    #define JSON_HEDLEY_NEVER_INLINE _Pragma("inline=never")
+#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
+    #define JSON_HEDLEY_NEVER_INLINE __attribute((noinline))
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
+    #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
+#else
+    #define JSON_HEDLEY_NEVER_INLINE
+#endif
+
+#if defined(JSON_HEDLEY_PRIVATE)
+    #undef JSON_HEDLEY_PRIVATE
+#endif
+#if defined(JSON_HEDLEY_PUBLIC)
+    #undef JSON_HEDLEY_PUBLIC
+#endif
+#if defined(JSON_HEDLEY_IMPORT)
+    #undef JSON_HEDLEY_IMPORT
+#endif
+#if defined(_WIN32) || defined(__CYGWIN__)
+    #define JSON_HEDLEY_PRIVATE
+    #define JSON_HEDLEY_PUBLIC   __declspec(dllexport)
+    #define JSON_HEDLEY_IMPORT   __declspec(dllimport)
+#else
+    #if \
+        JSON_HEDLEY_HAS_ATTRIBUTE(visibility) || \
+        JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
+        JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
+        JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+        JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+        JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
+        JSON_HEDLEY_TI_VERSION_CHECK(8,0,0) || \
+        (JSON_HEDLEY_TI_VERSION_CHECK(7,3,0) && defined(__TI_EABI__) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))
+        #define JSON_HEDLEY_PRIVATE __attribute__((__visibility__("hidden")))
+        #define JSON_HEDLEY_PUBLIC  __attribute__((__visibility__("default")))
+    #else
+        #define JSON_HEDLEY_PRIVATE
+        #define JSON_HEDLEY_PUBLIC
+    #endif
+    #define JSON_HEDLEY_IMPORT    extern
+#endif
+
+#if defined(JSON_HEDLEY_NO_THROW)
+    #undef JSON_HEDLEY_NO_THROW
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(nothrow) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+    #define JSON_HEDLEY_NO_THROW __attribute__((__nothrow__))
+#elif \
+    JSON_HEDLEY_MSVC_VERSION_CHECK(13,1,0) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
+    #define JSON_HEDLEY_NO_THROW __declspec(nothrow)
+#else
+    #define JSON_HEDLEY_NO_THROW
+#endif
+
+#if defined(JSON_HEDLEY_FALL_THROUGH)
+    #undef JSON_HEDLEY_FALL_THROUGH
+#endif
+#if \
+    defined(__cplusplus) && \
+    (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) && \
+    !defined(JSON_HEDLEY_PGI_VERSION)
+    #if \
+        (__cplusplus >= 201703L) || \
+        ((__cplusplus >= 201103L) && JSON_HEDLEY_HAS_CPP_ATTRIBUTE(fallthrough))
+        #define JSON_HEDLEY_FALL_THROUGH [[fallthrough]]
+    #elif (__cplusplus >= 201103L) && JSON_HEDLEY_HAS_CPP_ATTRIBUTE(clang::fallthrough)
+        #define JSON_HEDLEY_FALL_THROUGH [[clang::fallthrough]]
+    #elif (__cplusplus >= 201103L) && JSON_HEDLEY_GCC_VERSION_CHECK(7,0,0)
+        #define JSON_HEDLEY_FALL_THROUGH [[gnu::fallthrough]]
+    #endif
+#endif
+#if !defined(JSON_HEDLEY_FALL_THROUGH)
+    #if JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(fallthrough,7,0,0) && !defined(JSON_HEDLEY_PGI_VERSION)
+        #define JSON_HEDLEY_FALL_THROUGH __attribute__((__fallthrough__))
+    #elif defined(__fallthrough) /* SAL */
+        #define JSON_HEDLEY_FALL_THROUGH __fallthrough
+    #else
+        #define JSON_HEDLEY_FALL_THROUGH
+    #endif
+#endif
+
+#if defined(JSON_HEDLEY_RETURNS_NON_NULL)
+    #undef JSON_HEDLEY_RETURNS_NON_NULL
+#endif
+#if \
+    JSON_HEDLEY_HAS_ATTRIBUTE(returns_nonnull) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0)
+    #define JSON_HEDLEY_RETURNS_NON_NULL __attribute__((__returns_nonnull__))
+#elif defined(_Ret_notnull_) /* SAL */
+    #define JSON_HEDLEY_RETURNS_NON_NULL _Ret_notnull_
+#else
+    #define JSON_HEDLEY_RETURNS_NON_NULL
+#endif
+
+#if defined(JSON_HEDLEY_ARRAY_PARAM)
+    #undef JSON_HEDLEY_ARRAY_PARAM
+#endif
+#if \
+    defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \
+    !defined(__STDC_NO_VLA__) && \
+    !defined(__cplusplus) && \
+    !defined(JSON_HEDLEY_PGI_VERSION) && \
+    !defined(JSON_HEDLEY_TINYC_VERSION)
+    #define JSON_HEDLEY_ARRAY_PARAM(name) (name)
+#else
+    #define JSON_HEDLEY_ARRAY_PARAM(name)
+#endif
+
+#if defined(JSON_HEDLEY_IS_CONSTANT)
+    #undef JSON_HEDLEY_IS_CONSTANT
+#endif
+#if defined(JSON_HEDLEY_REQUIRE_CONSTEXPR)
+    #undef JSON_HEDLEY_REQUIRE_CONSTEXPR
+#endif
+/* Note the double-underscore. For internal use only; no API
+ * guarantees! */
+#if defined(JSON_HEDLEY__IS_CONSTEXPR)
+    #undef JSON_HEDLEY__IS_CONSTEXPR
+#endif
+
+#if \
+    JSON_HEDLEY_HAS_BUILTIN(__builtin_constant_p) || \
+    JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
+    JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+    JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,19) || \
+    JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
+    JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
+    JSON_HEDLEY_TI_VERSION_CHECK(6,1,0) || \
+    JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) || \
+    JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0)
+    #define JSON_HEDLEY_IS_CONSTANT(expr) __builtin_constant_p(expr)
+#endif
+#if !defined(__cplusplus)
+#  if \
+       JSON_HEDLEY_HAS_BUILTIN(__builtin_types_compatible_p) || \
+       JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
+       JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+       JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
+       JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
+       JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \
+       JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,24)
+#if defined(__INTPTR_TYPE__)
+    #define JSON_HEDLEY__IS_CONSTEXPR(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0)), int*)
+#else
+    #include <stdint.h>
+    #define JSON_HEDLEY__IS_CONSTEXPR(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((intptr_t) ((expr) * 0)) : (int*) 0)), int*)
+#endif
+#  elif \
+       (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && !defined(JSON_HEDLEY_SUNPRO_VERSION) && !defined(JSON_HEDLEY_PGI_VERSION)) || \
+       JSON_HEDLEY_HAS_EXTENSION(c_generic_selections) || \
+       JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \
+       JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) || \
+       JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
+       JSON_HEDLEY_ARM_VERSION_CHECK(5,3,0)
+#if defined(__INTPTR_TYPE__)
+    #define JSON_HEDLEY__IS_CONSTEXPR(expr) _Generic((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0), int*: 1, void*: 0)
+#else
+    #include <stdint.h>
+    #define JSON_HEDLEY__IS_CONSTEXPR(expr) _Generic((1 ? (void*) ((intptr_t) * 0) : (int*) 0), int*: 1, void*: 0)
+#endif
+#  elif \
+       defined(JSON_HEDLEY_GCC_VERSION) || \
+       defined(JSON_HEDLEY_INTEL_VERSION) || \
+       defined(JSON_HEDLEY_TINYC_VERSION) || \
+       defined(JSON_HEDLEY_TI_VERSION) || \
+       defined(__clang__)
+#    define JSON_HEDLEY__IS_CONSTEXPR(expr) ( \
+        sizeof(void) != \
+        sizeof(*( \
+                  1 ? \
+                  ((void*) ((expr) * 0L) ) : \
+((struct { char v[sizeof(void) * 2]; } *) 1) \
+                ) \
+              ) \
+                                            )
+#  endif
+#endif
+#if defined(JSON_HEDLEY__IS_CONSTEXPR)
+    #if !defined(JSON_HEDLEY_IS_CONSTANT)
+        #define JSON_HEDLEY_IS_CONSTANT(expr) JSON_HEDLEY__IS_CONSTEXPR(expr)
+    #endif
+    #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (JSON_HEDLEY__IS_CONSTEXPR(expr) ? (expr) : (-1))
+#else
+    #if !defined(JSON_HEDLEY_IS_CONSTANT)
+        #define JSON_HEDLEY_IS_CONSTANT(expr) (0)
+    #endif
+    #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (expr)
+#endif
+
+#if defined(JSON_HEDLEY_BEGIN_C_DECLS)
+    #undef JSON_HEDLEY_BEGIN_C_DECLS
+#endif
+#if defined(JSON_HEDLEY_END_C_DECLS)
+    #undef JSON_HEDLEY_END_C_DECLS
+#endif
+#if defined(JSON_HEDLEY_C_DECL)
+    #undef JSON_HEDLEY_C_DECL
+#endif
+#if defined(__cplusplus)
+    #define JSON_HEDLEY_BEGIN_C_DECLS extern "C" {
+    #define JSON_HEDLEY_END_C_DECLS }
+    #define JSON_HEDLEY_C_DECL extern "C"
+#else
+    #define JSON_HEDLEY_BEGIN_C_DECLS
+    #define JSON_HEDLEY_END_C_DECLS
+    #define JSON_HEDLEY_C_DECL
+#endif
+
+#if defined(JSON_HEDLEY_STATIC_ASSERT)
+    #undef JSON_HEDLEY_STATIC_ASSERT
+#endif
+#if \
+  !defined(__cplusplus) && ( \
+      (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) || \
+      JSON_HEDLEY_HAS_FEATURE(c_static_assert) || \
+      JSON_HEDLEY_GCC_VERSION_CHECK(6,0,0) || \
+      JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
+      defined(_Static_assert) \
+    )
+#  define JSON_HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message)
+#elif \
+  (defined(__cplusplus) && (__cplusplus >= 201703L)) || \
+  JSON_HEDLEY_MSVC_VERSION_CHECK(16,0,0) || \
+  (defined(__cplusplus) && JSON_HEDLEY_TI_VERSION_CHECK(8,3,0))
+#  define JSON_HEDLEY_STATIC_ASSERT(expr, message) static_assert(expr, message)
+#elif defined(__cplusplus) && (__cplusplus >= 201103L)
+#  define JSON_HEDLEY_STATIC_ASSERT(expr, message) static_assert(expr)
+#else
+#  define JSON_HEDLEY_STATIC_ASSERT(expr, message)
+#endif
+
+#if defined(JSON_HEDLEY_CONST_CAST)
+    #undef JSON_HEDLEY_CONST_CAST
+#endif
+#if defined(__cplusplus)
+#  define JSON_HEDLEY_CONST_CAST(T, expr) (const_cast<T>(expr))
+#elif \
+  JSON_HEDLEY_HAS_WARNING("-Wcast-qual") || \
+  JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+#  define JSON_HEDLEY_CONST_CAST(T, expr) (__extension__ ({ \
+        JSON_HEDLEY_DIAGNOSTIC_PUSH \
+        JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \
+        ((T) (expr)); \
+        JSON_HEDLEY_DIAGNOSTIC_POP \
+    }))
+#else
+#  define JSON_HEDLEY_CONST_CAST(T, expr) ((T) (expr))
+#endif
+
+#if defined(JSON_HEDLEY_REINTERPRET_CAST)
+    #undef JSON_HEDLEY_REINTERPRET_CAST
+#endif
+#if defined(__cplusplus)
+    #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (reinterpret_cast<T>(expr))
+#else
+    #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (*((T*) &(expr)))
+#endif
+
+#if defined(JSON_HEDLEY_STATIC_CAST)
+    #undef JSON_HEDLEY_STATIC_CAST
+#endif
+#if defined(__cplusplus)
+    #define JSON_HEDLEY_STATIC_CAST(T, expr) (static_cast<T>(expr))
+#else
+    #define JSON_HEDLEY_STATIC_CAST(T, expr) ((T) (expr))
+#endif
+
+#if defined(JSON_HEDLEY_CPP_CAST)
+    #undef JSON_HEDLEY_CPP_CAST
+#endif
+#if defined(__cplusplus)
+    #define JSON_HEDLEY_CPP_CAST(T, expr) static_cast<T>(expr)
+#else
+    #define JSON_HEDLEY_CPP_CAST(T, expr) (expr)
+#endif
+
+#if defined(JSON_HEDLEY_MESSAGE)
+    #undef JSON_HEDLEY_MESSAGE
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
+#  define JSON_HEDLEY_MESSAGE(msg) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
+    JSON_HEDLEY_PRAGMA(message msg) \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#elif \
+  JSON_HEDLEY_GCC_VERSION_CHECK(4,4,0) || \
+  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
+#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message msg)
+#elif JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0)
+#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(_CRI message msg)
+#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
+#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
+#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,0,0)
+#  define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
+#else
+#  define JSON_HEDLEY_MESSAGE(msg)
+#endif
+
+#if defined(JSON_HEDLEY_WARNING)
+    #undef JSON_HEDLEY_WARNING
+#endif
+#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
+#  define JSON_HEDLEY_WARNING(msg) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
+    JSON_HEDLEY_PRAGMA(clang warning msg) \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#elif \
+  JSON_HEDLEY_GCC_VERSION_CHECK(4,8,0) || \
+  JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0)
+#  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(GCC warning msg)
+#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
+#  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(message(msg))
+#else
+#  define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_MESSAGE(msg)
+#endif
+
+#if defined(JSON_HEDLEY_REQUIRE_MSG)
+    #undef JSON_HEDLEY_REQUIRE_MSG
+#endif
+#if JSON_HEDLEY_HAS_ATTRIBUTE(diagnose_if)
+#  if JSON_HEDLEY_HAS_WARNING("-Wgcc-compat")
+#    define JSON_HEDLEY_REQUIRE_MSG(expr, msg) \
+    JSON_HEDLEY_DIAGNOSTIC_PUSH \
+    _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
+    __attribute__((__diagnose_if__(!(expr), msg, "error"))) \
+    JSON_HEDLEY_DIAGNOSTIC_POP
+#  else
+#    define JSON_HEDLEY_REQUIRE_MSG(expr, msg) __attribute__((__diagnose_if__(!(expr), msg, "error")))
+#  endif
+#else
+#  define JSON_HEDLEY_REQUIRE_MSG(expr, msg)
+#endif
+
+#if defined(JSON_HEDLEY_REQUIRE)
+    #undef JSON_HEDLEY_REQUIRE
+#endif
+#define JSON_HEDLEY_REQUIRE(expr) JSON_HEDLEY_REQUIRE_MSG(expr, #expr)
+
+#if defined(JSON_HEDLEY_FLAGS)
+    #undef JSON_HEDLEY_FLAGS
+#endif
+#if JSON_HEDLEY_HAS_ATTRIBUTE(flag_enum)
+    #define JSON_HEDLEY_FLAGS __attribute__((__flag_enum__))
+#endif
+
+#if defined(JSON_HEDLEY_FLAGS_CAST)
+    #undef JSON_HEDLEY_FLAGS_CAST
+#endif
+#if JSON_HEDLEY_INTEL_VERSION_CHECK(19,0,0)
+#  define JSON_HEDLEY_FLAGS_CAST(T, expr) (__extension__ ({ \
+        JSON_HEDLEY_DIAGNOSTIC_PUSH \
+        _Pragma("warning(disable:188)") \
+        ((T) (expr)); \
+        JSON_HEDLEY_DIAGNOSTIC_POP \
+    }))
+#else
+#  define JSON_HEDLEY_FLAGS_CAST(T, expr) JSON_HEDLEY_STATIC_CAST(T, expr)
+#endif
+
+/* Remaining macros are deprecated. */
+
+#if defined(JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK)
+    #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
+#endif
+#if defined(__clang__)
+    #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) (0)
+#else
+    #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
+#endif
+
+#if defined(JSON_HEDLEY_CLANG_HAS_ATTRIBUTE)
+    #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
+#endif
+#define JSON_HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE)
+    #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
+#endif
+#define JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_BUILTIN)
+    #undef JSON_HEDLEY_CLANG_HAS_BUILTIN
+#endif
+#define JSON_HEDLEY_CLANG_HAS_BUILTIN(builtin) JSON_HEDLEY_HAS_BUILTIN(builtin)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_FEATURE)
+    #undef JSON_HEDLEY_CLANG_HAS_FEATURE
+#endif
+#define JSON_HEDLEY_CLANG_HAS_FEATURE(feature) JSON_HEDLEY_HAS_FEATURE(feature)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_EXTENSION)
+    #undef JSON_HEDLEY_CLANG_HAS_EXTENSION
+#endif
+#define JSON_HEDLEY_CLANG_HAS_EXTENSION(extension) JSON_HEDLEY_HAS_EXTENSION(extension)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE)
+    #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
+#endif
+#define JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute)
+
+#if defined(JSON_HEDLEY_CLANG_HAS_WARNING)
+    #undef JSON_HEDLEY_CLANG_HAS_WARNING
+#endif
+#define JSON_HEDLEY_CLANG_HAS_WARNING(warning) JSON_HEDLEY_HAS_WARNING(warning)
+
+#endif /* !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < X) */
+
+
+// This file contains all internal macro definitions
+// You MUST include macro_unscope.hpp at the end of json.hpp to undef all of them
+
+// exclude unsupported compilers
+#if !defined(JSON_SKIP_UNSUPPORTED_COMPILER_CHECK)
+    #if defined(__clang__)
+        #if (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) < 30400
+            #error "unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers"
+        #endif
+    #elif defined(__GNUC__) && !(defined(__ICC) || defined(__INTEL_COMPILER))
+        #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40800
+            #error "unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers"
+        #endif
+    #endif
+#endif
+
+// C++ language standard detection
+#if (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464
+    #define JSON_HAS_CPP_17
+    #define JSON_HAS_CPP_14
+#elif (defined(__cplusplus) && __cplusplus >= 201402L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1)
+    #define JSON_HAS_CPP_14
+#endif
+
+// disable float-equal warnings on GCC/clang
+#if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
+    #pragma GCC diagnostic push
+    #pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+
+// disable documentation warnings on clang
+#if defined(__clang__)
+    #pragma GCC diagnostic push
+    #pragma GCC diagnostic ignored "-Wdocumentation"
+#endif
+
+// allow to disable exceptions
+#if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION)
+    #define JSON_THROW(exception) throw exception
+    #define JSON_TRY try
+    #define JSON_CATCH(exception) catch(exception)
+    #define JSON_INTERNAL_CATCH(exception) catch(exception)
+#else
+    #include <cstdlib>
+    #define JSON_THROW(exception) std::abort()
+    #define JSON_TRY if(true)
+    #define JSON_CATCH(exception) if(false)
+    #define JSON_INTERNAL_CATCH(exception) if(false)
+#endif
+
+// override exception macros
+#if defined(JSON_THROW_USER)
+    #undef JSON_THROW
+    #define JSON_THROW JSON_THROW_USER
+#endif
+#if defined(JSON_TRY_USER)
+    #undef JSON_TRY
+    #define JSON_TRY JSON_TRY_USER
+#endif
+#if defined(JSON_CATCH_USER)
+    #undef JSON_CATCH
+    #define JSON_CATCH JSON_CATCH_USER
+    #undef JSON_INTERNAL_CATCH
+    #define JSON_INTERNAL_CATCH JSON_CATCH_USER
+#endif
+#if defined(JSON_INTERNAL_CATCH_USER)
+    #undef JSON_INTERNAL_CATCH
+    #define JSON_INTERNAL_CATCH JSON_INTERNAL_CATCH_USER
+#endif
+
+/*!
+@brief macro to briefly define a mapping between an enum and JSON
+@def NLOHMANN_JSON_SERIALIZE_ENUM
+@since version 3.4.0
+*/
+#define NLOHMANN_JSON_SERIALIZE_ENUM(ENUM_TYPE, ...)                                           \
+    template<typename BasicJsonType>                                                           \
+    inline void to_json(BasicJsonType& j, const ENUM_TYPE& e)                                  \
+    {                                                                                          \
+        static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!");         \
+        static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__;                    \
+        auto it = std::find_if(std::begin(m), std::end(m),                                     \
+                               [e](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
+        {                                                                                      \
+            return ej_pair.first == e;                                                         \
+        });                                                                                    \
+        j = ((it != std::end(m)) ? it : std::begin(m))->second;                                \
+    }                                                                                          \
+    template<typename BasicJsonType>                                                           \
+    inline void from_json(const BasicJsonType& j, ENUM_TYPE& e)                                \
+    {                                                                                          \
+        static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!");         \
+        static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__;                    \
+        auto it = std::find_if(std::begin(m), std::end(m),                                     \
+                               [j](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
+        {                                                                                      \
+            return ej_pair.second == j;                                                        \
+        });                                                                                    \
+        e = ((it != std::end(m)) ? it : std::begin(m))->first;                                 \
+    }
+
+// Ugly macros to avoid uglier copy-paste when specializing basic_json. They
+// may be removed in the future once the class is split.
+
+#define NLOHMANN_BASIC_JSON_TPL_DECLARATION                                \
+    template<template<typename, typename, typename...> class ObjectType,   \
+             template<typename, typename...> class ArrayType,              \
+             class StringType, class BooleanType, class NumberIntegerType, \
+             class NumberUnsignedType, class NumberFloatType,              \
+             template<typename> class AllocatorType,                       \
+             template<typename, typename = void> class JSONSerializer>
+
+#define NLOHMANN_BASIC_JSON_TPL                                            \
+    basic_json<ObjectType, ArrayType, StringType, BooleanType,             \
+    NumberIntegerType, NumberUnsignedType, NumberFloatType,                \
+    AllocatorType, JSONSerializer>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+////////////////
+// exceptions //
+////////////////
+
+/*!
+@brief general exception of the @ref basic_json class
+
+This class is an extension of `std::exception` objects with a member @a id for
+exception ids. It is used as the base class for all exceptions thrown by the
+@ref basic_json class. This class can hence be used as "wildcard" to catch
+exceptions.
+
+Subclasses:
+- @ref parse_error for exceptions indicating a parse error
+- @ref invalid_iterator for exceptions indicating errors with iterators
+- @ref type_error for exceptions indicating executing a member function with
+                  a wrong type
+- @ref out_of_range for exceptions indicating access out of the defined range
+- @ref other_error for exceptions indicating other library errors
+
+@internal
+@note To have nothrow-copy-constructible exceptions, we internally use
+      `std::runtime_error` which can cope with arbitrary-length error messages.
+      Intermediate strings are built with static functions and then passed to
+      the actual constructor.
+@endinternal
+
+@liveexample{The following code shows how arbitrary library exceptions can be
+caught.,exception}
+
+@since version 3.0.0
+*/
+class exception : public std::exception
+{
+  public:
+    /// returns the explanatory string
+    JSON_HEDLEY_RETURNS_NON_NULL
+    const char* what() const noexcept override
+    {
+        return m.what();
+    }
+
+    /// the id of the exception
+    const int id;
+
+  protected:
+    JSON_HEDLEY_NON_NULL(3)
+    exception(int id_, const char* what_arg) : id(id_), m(what_arg) {}
+
+    static std::string name(const std::string& ename, int id_)
+    {
+        return "[json.exception." + ename + "." + std::to_string(id_) + "] ";
+    }
+
+  private:
+    /// an exception object as storage for error messages
+    std::runtime_error m;
+};
+
+/*!
+@brief exception indicating a parse error
+
+This exception is thrown by the library when a parse error occurs. Parse errors
+can occur during the deserialization of JSON text, CBOR, MessagePack, as well
+as when using JSON Patch.
+
+Member @a byte holds the byte index of the last read character in the input
+file.
+
+Exceptions have ids 1xx.
+
+name / id                      | example message | description
+------------------------------ | --------------- | -------------------------
+json.exception.parse_error.101 | parse error at 2: unexpected end of input; expected string literal | This error indicates a syntax error while deserializing a JSON text. The error message describes that an unexpected token (character) was encountered, and the member @a byte indicates the error position.
+json.exception.parse_error.102 | parse error at 14: missing or wrong low surrogate | JSON uses the `\uxxxx` format to describe Unicode characters. Code points above above 0xFFFF are split into two `\uxxxx` entries ("surrogate pairs"). This error indicates that the surrogate pair is incomplete or contains an invalid code point.
+json.exception.parse_error.103 | parse error: code points above 0x10FFFF are invalid | Unicode supports code points up to 0x10FFFF. Code points above 0x10FFFF are invalid.
+json.exception.parse_error.104 | parse error: JSON patch must be an array of objects | [RFC 6902](https://tools.ietf.org/html/rfc6902) requires a JSON Patch document to be a JSON document that represents an array of objects.
+json.exception.parse_error.105 | parse error: operation must have string member 'op' | An operation of a JSON Patch document must contain exactly one "op" member, whose value indicates the operation to perform. Its value must be one of "add", "remove", "replace", "move", "copy", or "test"; other values are errors.
+json.exception.parse_error.106 | parse error: array index '01' must not begin with '0' | An array index in a JSON Pointer ([RFC 6901](https://tools.ietf.org/html/rfc6901)) may be `0` or any number without a leading `0`.
+json.exception.parse_error.107 | parse error: JSON pointer must be empty or begin with '/' - was: 'foo' | A JSON Pointer must be a Unicode string containing a sequence of zero or more reference tokens, each prefixed by a `/` character.
+json.exception.parse_error.108 | parse error: escape character '~' must be followed with '0' or '1' | In a JSON Pointer, only `~0` and `~1` are valid escape sequences.
+json.exception.parse_error.109 | parse error: array index 'one' is not a number | A JSON Pointer array index must be a number.
+json.exception.parse_error.110 | parse error at 1: cannot read 2 bytes from vector | When parsing CBOR or MessagePack, the byte vector ends before the complete value has been read.
+json.exception.parse_error.112 | parse error at 1: error reading CBOR; last byte: 0xF8 | Not all types of CBOR or MessagePack are supported. This exception occurs if an unsupported byte was read.
+json.exception.parse_error.113 | parse error at 2: expected a CBOR string; last byte: 0x98 | While parsing a map key, a value that is not a string has been read.
+json.exception.parse_error.114 | parse error: Unsupported BSON record type 0x0F | The parsing of the corresponding BSON record type is not implemented (yet).
+
+@note For an input with n bytes, 1 is the index of the first character and n+1
+      is the index of the terminating null byte or the end of file. This also
+      holds true when reading a byte vector (CBOR or MessagePack).
+
+@liveexample{The following code shows how a `parse_error` exception can be
+caught.,parse_error}
+
+@sa - @ref exception for the base class of the library exceptions
+@sa - @ref invalid_iterator for exceptions indicating errors with iterators
+@sa - @ref type_error for exceptions indicating executing a member function with
+                    a wrong type
+@sa - @ref out_of_range for exceptions indicating access out of the defined range
+@sa - @ref other_error for exceptions indicating other library errors
+
+@since version 3.0.0
+*/
+class parse_error : public exception
+{
+  public:
+    /*!
+    @brief create a parse error exception
+    @param[in] id_       the id of the exception
+    @param[in] pos       the position where the error occurred (or with
+                         chars_read_total=0 if the position cannot be
+                         determined)
+    @param[in] what_arg  the explanatory string
+    @return parse_error object
+    */
+    static parse_error create(int id_, const position_t& pos, const std::string& what_arg)
+    {
+        std::string w = exception::name("parse_error", id_) + "parse error" +
+                        position_string(pos) + ": " + what_arg;
+        return parse_error(id_, pos.chars_read_total, w.c_str());
+    }
+
+    static parse_error create(int id_, std::size_t byte_, const std::string& what_arg)
+    {
+        std::string w = exception::name("parse_error", id_) + "parse error" +
+                        (byte_ != 0 ? (" at byte " + std::to_string(byte_)) : "") +
+                        ": " + what_arg;
+        return parse_error(id_, byte_, w.c_str());
+    }
+
+    /*!
+    @brief byte index of the parse error
+
+    The byte index of the last read character in the input file.
+
+    @note For an input with n bytes, 1 is the index of the first character and
+          n+1 is the index of the terminating null byte or the end of file.
+          This also holds true when reading a byte vector (CBOR or MessagePack).
+    */
+    const std::size_t byte;
+
+  private:
+    parse_error(int id_, std::size_t byte_, const char* what_arg)
+        : exception(id_, what_arg), byte(byte_) {}
+
+    static std::string position_string(const position_t& pos)
+    {
+        return " at line " + std::to_string(pos.lines_read + 1) +
+               ", column " + std::to_string(pos.chars_read_current_line);
+    }
+};
+
+/*!
+@brief exception indicating errors with iterators
+
+This exception is thrown if iterators passed to a library function do not match
+the expected semantics.
+
+Exceptions have ids 2xx.
+
+name / id                           | example message | description
+----------------------------------- | --------------- | -------------------------
+json.exception.invalid_iterator.201 | iterators are not compatible | The iterators passed to constructor @ref basic_json(InputIT first, InputIT last) are not compatible, meaning they do not belong to the same container. Therefore, the range (@a first, @a last) is invalid.
+json.exception.invalid_iterator.202 | iterator does not fit current value | In an erase or insert function, the passed iterator @a pos does not belong to the JSON value for which the function was called. It hence does not define a valid position for the deletion/insertion.
+json.exception.invalid_iterator.203 | iterators do not fit current value | Either iterator passed to function @ref erase(IteratorType first, IteratorType last) does not belong to the JSON value from which values shall be erased. It hence does not define a valid range to delete values from.
+json.exception.invalid_iterator.204 | iterators out of range | When an iterator range for a primitive type (number, boolean, or string) is passed to a constructor or an erase function, this range has to be exactly (@ref begin(), @ref end()), because this is the only way the single stored value is expressed. All other ranges are invalid.
+json.exception.invalid_iterator.205 | iterator out of range | When an iterator for a primitive type (number, boolean, or string) is passed to an erase function, the iterator has to be the @ref begin() iterator, because it is the only way to address the stored value. All other iterators are invalid.
+json.exception.invalid_iterator.206 | cannot construct with iterators from null | The iterators passed to constructor @ref basic_json(InputIT first, InputIT last) belong to a JSON null value and hence to not define a valid range.
+json.exception.invalid_iterator.207 | cannot use key() for non-object iterators | The key() member function can only be used on iterators belonging to a JSON object, because other types do not have a concept of a key.
+json.exception.invalid_iterator.208 | cannot use operator[] for object iterators | The operator[] to specify a concrete offset cannot be used on iterators belonging to a JSON object, because JSON objects are unordered.
+json.exception.invalid_iterator.209 | cannot use offsets with object iterators | The offset operators (+, -, +=, -=) cannot be used on iterators belonging to a JSON object, because JSON objects are unordered.
+json.exception.invalid_iterator.210 | iterators do not fit | The iterator range passed to the insert function are not compatible, meaning they do not belong to the same container. Therefore, the range (@a first, @a last) is invalid.
+json.exception.invalid_iterator.211 | passed iterators may not belong to container | The iterator range passed to the insert function must not be a subrange of the container to insert to.
+json.exception.invalid_iterator.212 | cannot compare iterators of different containers | When two iterators are compared, they must belong to the same container.
+json.exception.invalid_iterator.213 | cannot compare order of object iterators | The order of object iterators cannot be compared, because JSON objects are unordered.
+json.exception.invalid_iterator.214 | cannot get value | Cannot get value for iterator: Either the iterator belongs to a null value or it is an iterator to a primitive type (number, boolean, or string), but the iterator is different to @ref begin().
+
+@liveexample{The following code shows how an `invalid_iterator` exception can be
+caught.,invalid_iterator}
+
+@sa - @ref exception for the base class of the library exceptions
+@sa - @ref parse_error for exceptions indicating a parse error
+@sa - @ref type_error for exceptions indicating executing a member function with
+                    a wrong type
+@sa - @ref out_of_range for exceptions indicating access out of the defined range
+@sa - @ref other_error for exceptions indicating other library errors
+
+@since version 3.0.0
+*/
+class invalid_iterator : public exception
+{
+  public:
+    static invalid_iterator create(int id_, const std::string& what_arg)
+    {
+        std::string w = exception::name("invalid_iterator", id_) + what_arg;
+        return invalid_iterator(id_, w.c_str());
+    }
+
+  private:
+    JSON_HEDLEY_NON_NULL(3)
+    invalid_iterator(int id_, const char* what_arg)
+        : exception(id_, what_arg) {}
+};
+
+/*!
+@brief exception indicating executing a member function with a wrong type
+
+This exception is thrown in case of a type error; that is, a library function is
+executed on a JSON value whose type does not match the expected semantics.
+
+Exceptions have ids 3xx.
+
+name / id                     | example message | description
+----------------------------- | --------------- | -------------------------
+json.exception.type_error.301 | cannot create object from initializer list | To create an object from an initializer list, the initializer list must consist only of a list of pairs whose first element is a string. When this constraint is violated, an array is created instead.
+json.exception.type_error.302 | type must be object, but is array | During implicit or explicit value conversion, the JSON type must be compatible to the target type. For instance, a JSON string can only be converted into string types, but not into numbers or boolean types.
+json.exception.type_error.303 | incompatible ReferenceType for get_ref, actual type is object | To retrieve a reference to a value stored in a @ref basic_json object with @ref get_ref, the type of the reference must match the value type. For instance, for a JSON array, the @a ReferenceType must be @ref array_t &.
+json.exception.type_error.304 | cannot use at() with string | The @ref at() member functions can only be executed for certain JSON types.
+json.exception.type_error.305 | cannot use operator[] with string | The @ref operator[] member functions can only be executed for certain JSON types.
+json.exception.type_error.306 | cannot use value() with string | The @ref value() member functions can only be executed for certain JSON types.
+json.exception.type_error.307 | cannot use erase() with string | The @ref erase() member functions can only be executed for certain JSON types.
+json.exception.type_error.308 | cannot use push_back() with string | The @ref push_back() and @ref operator+= member functions can only be executed for certain JSON types.
+json.exception.type_error.309 | cannot use insert() with | The @ref insert() member functions can only be executed for certain JSON types.
+json.exception.type_error.310 | cannot use swap() with number | The @ref swap() member functions can only be executed for certain JSON types.
+json.exception.type_error.311 | cannot use emplace_back() with string | The @ref emplace_back() member function can only be executed for certain JSON types.
+json.exception.type_error.312 | cannot use update() with string | The @ref update() member functions can only be executed for certain JSON types.
+json.exception.type_error.313 | invalid value to unflatten | The @ref unflatten function converts an object whose keys are JSON Pointers back into an arbitrary nested JSON value. The JSON Pointers must not overlap, because then the resulting value would not be well defined.
+json.exception.type_error.314 | only objects can be unflattened | The @ref unflatten function only works for an object whose keys are JSON Pointers.
+json.exception.type_error.315 | values in object must be primitive | The @ref unflatten function only works for an object whose keys are JSON Pointers and whose values are primitive.
+json.exception.type_error.316 | invalid UTF-8 byte at index 10: 0x7E | The @ref dump function only works with UTF-8 encoded strings; that is, if you assign a `std::string` to a JSON value, make sure it is UTF-8 encoded. |
+json.exception.type_error.317 | JSON value cannot be serialized to requested format | The dynamic type of the object cannot be represented in the requested serialization format (e.g. a raw `true` or `null` JSON object cannot be serialized to BSON) |
+
+@liveexample{The following code shows how a `type_error` exception can be
+caught.,type_error}
+
+@sa - @ref exception for the base class of the library exceptions
+@sa - @ref parse_error for exceptions indicating a parse error
+@sa - @ref invalid_iterator for exceptions indicating errors with iterators
+@sa - @ref out_of_range for exceptions indicating access out of the defined range
+@sa - @ref other_error for exceptions indicating other library errors
+
+@since version 3.0.0
+*/
+class type_error : public exception
+{
+  public:
+    static type_error create(int id_, const std::string& what_arg)
+    {
+        std::string w = exception::name("type_error", id_) + what_arg;
+        return type_error(id_, w.c_str());
+    }
+
+  private:
+    JSON_HEDLEY_NON_NULL(3)
+    type_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
+};
+
+/*!
+@brief exception indicating access out of the defined range
+
+This exception is thrown in case a library function is called on an input
+parameter that exceeds the expected range, for instance in case of array
+indices or nonexisting object keys.
+
+Exceptions have ids 4xx.
+
+name / id                       | example message | description
+------------------------------- | --------------- | -------------------------
+json.exception.out_of_range.401 | array index 3 is out of range | The provided array index @a i is larger than @a size-1.
+json.exception.out_of_range.402 | array index '-' (3) is out of range | The special array index `-` in a JSON Pointer never describes a valid element of the array, but the index past the end. That is, it can only be used to add elements at this position, but not to read it.
+json.exception.out_of_range.403 | key 'foo' not found | The provided key was not found in the JSON object.
+json.exception.out_of_range.404 | unresolved reference token 'foo' | A reference token in a JSON Pointer could not be resolved.
+json.exception.out_of_range.405 | JSON pointer has no parent | The JSON Patch operations 'remove' and 'add' can not be applied to the root element of the JSON value.
+json.exception.out_of_range.406 | number overflow parsing '10E1000' | A parsed number could not be stored as without changing it to NaN or INF.
+json.exception.out_of_range.407 | number overflow serializing '9223372036854775808' | UBJSON and BSON only support integer numbers up to 9223372036854775807. |
+json.exception.out_of_range.408 | excessive array size: 8658170730974374167 | The size (following `#`) of an UBJSON array or object exceeds the maximal capacity. |
+json.exception.out_of_range.409 | BSON key cannot contain code point U+0000 (at byte 2) | Key identifiers to be serialized to BSON cannot contain code point U+0000, since the key is stored as zero-terminated c-string |
+
+@liveexample{The following code shows how an `out_of_range` exception can be
+caught.,out_of_range}
+
+@sa - @ref exception for the base class of the library exceptions
+@sa - @ref parse_error for exceptions indicating a parse error
+@sa - @ref invalid_iterator for exceptions indicating errors with iterators
+@sa - @ref type_error for exceptions indicating executing a member function with
+                    a wrong type
+@sa - @ref other_error for exceptions indicating other library errors
+
+@since version 3.0.0
+*/
+class out_of_range : public exception
+{
+  public:
+    static out_of_range create(int id_, const std::string& what_arg)
+    {
+        std::string w = exception::name("out_of_range", id_) + what_arg;
+        return out_of_range(id_, w.c_str());
+    }
+
+  private:
+    JSON_HEDLEY_NON_NULL(3)
+    out_of_range(int id_, const char* what_arg) : exception(id_, what_arg) {}
+};
+
+/*!
+@brief exception indicating other library errors
+
+This exception is thrown in case of errors that cannot be classified with the
+other exception types.
+
+Exceptions have ids 5xx.
+
+name / id                      | example message | description
+------------------------------ | --------------- | -------------------------
+json.exception.other_error.501 | unsuccessful: {"op":"test","path":"/baz", "value":"bar"} | A JSON Patch operation 'test' failed. The unsuccessful operation is also printed.
+
+@sa - @ref exception for the base class of the library exceptions
+@sa - @ref parse_error for exceptions indicating a parse error
+@sa - @ref invalid_iterator for exceptions indicating errors with iterators
+@sa - @ref type_error for exceptions indicating executing a member function with
+                    a wrong type
+@sa - @ref out_of_range for exceptions indicating access out of the defined range
+
+@liveexample{The following code shows how an `other_error` exception can be
+caught.,other_error}
+
+@since version 3.0.0
+*/
+class other_error : public exception
+{
+  public:
+    static other_error create(int id_, const std::string& what_arg)
+    {
+        std::string w = exception::name("other_error", id_) + what_arg;
+        return other_error(id_, w.c_str());
+    }
+
+  private:
+    JSON_HEDLEY_NON_NULL(3)
+    other_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+
+#include <ciso646> // not
+#include <cstddef> // size_t
+#include <type_traits> // conditional, enable_if, false_type, integral_constant, is_constructible, is_integral, is_same, remove_cv, remove_reference, true_type
+
+namespace nlohmann
+{
+namespace detail
+{
+// alias templates to reduce boilerplate
+template<bool B, typename T = void>
+using enable_if_t = typename std::enable_if<B, T>::type;
+
+template<typename T>
+using uncvref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
+
+// implementation of C++14 index_sequence and affiliates
+// source: https://stackoverflow.com/a/32223343
+template<std::size_t... Ints>
+struct index_sequence
+{
+    using type = index_sequence;
+    using value_type = std::size_t;
+    static constexpr std::size_t size() noexcept
+    {
+        return sizeof...(Ints);
+    }
+};
+
+template<class Sequence1, class Sequence2>
+struct merge_and_renumber;
+
+template<std::size_t... I1, std::size_t... I2>
+struct merge_and_renumber<index_sequence<I1...>, index_sequence<I2...>>
+        : index_sequence < I1..., (sizeof...(I1) + I2)... > {};
+
+template<std::size_t N>
+struct make_index_sequence
+    : merge_and_renumber < typename make_index_sequence < N / 2 >::type,
+      typename make_index_sequence < N - N / 2 >::type > {};
+
+template<> struct make_index_sequence<0> : index_sequence<> {};
+template<> struct make_index_sequence<1> : index_sequence<0> {};
+
+template<typename... Ts>
+using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
+
+// dispatch utility (taken from ranges-v3)
+template<unsigned N> struct priority_tag : priority_tag < N - 1 > {};
+template<> struct priority_tag<0> {};
+
+// taken from ranges-v3
+template<typename T>
+struct static_const
+{
+    static constexpr T value{};
+};
+
+template<typename T>
+constexpr T static_const<T>::value;
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+
+#include <ciso646> // not
+#include <limits> // numeric_limits
+#include <type_traits> // false_type, is_constructible, is_integral, is_same, true_type
+#include <utility> // declval
+
+// #include <nlohmann/detail/iterators/iterator_traits.hpp>
+
+
+#include <iterator> // random_access_iterator_tag
+
+// #include <nlohmann/detail/meta/void_t.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+template <typename ...Ts> struct make_void
+{
+    using type = void;
+};
+template <typename ...Ts> using void_t = typename make_void<Ts...>::type;
+} // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+template <typename It, typename = void>
+struct iterator_types {};
+
+template <typename It>
+struct iterator_types <
+    It,
+    void_t<typename It::difference_type, typename It::value_type, typename It::pointer,
+    typename It::reference, typename It::iterator_category >>
+{
+    using difference_type = typename It::difference_type;
+    using value_type = typename It::value_type;
+    using pointer = typename It::pointer;
+    using reference = typename It::reference;
+    using iterator_category = typename It::iterator_category;
+};
+
+// This is required as some compilers implement std::iterator_traits in a way that
+// doesn't work with SFINAE. See https://github.com/nlohmann/json/issues/1341.
+template <typename T, typename = void>
+struct iterator_traits
+{
+};
+
+template <typename T>
+struct iterator_traits < T, enable_if_t < !std::is_pointer<T>::value >>
+            : iterator_types<T>
+{
+};
+
+template <typename T>
+struct iterator_traits<T*, enable_if_t<std::is_object<T>::value>>
+{
+    using iterator_category = std::random_access_iterator_tag;
+    using value_type = T;
+    using difference_type = ptrdiff_t;
+    using pointer = T*;
+    using reference = T&;
+};
+} // namespace detail
+} // namespace nlohmann
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/meta/detected.hpp>
+
+
+#include <type_traits>
+
+// #include <nlohmann/detail/meta/void_t.hpp>
+
+
+// http://en.cppreference.com/w/cpp/experimental/is_detected
+namespace nlohmann
+{
+namespace detail
+{
+struct nonesuch
+{
+    nonesuch() = delete;
+    ~nonesuch() = delete;
+    nonesuch(nonesuch const&) = delete;
+    nonesuch(nonesuch const&&) = delete;
+    void operator=(nonesuch const&) = delete;
+    void operator=(nonesuch&&) = delete;
+};
+
+template <class Default,
+          class AlwaysVoid,
+          template <class...> class Op,
+          class... Args>
+struct detector
+{
+    using value_t = std::false_type;
+    using type = Default;
+};
+
+template <class Default, template <class...> class Op, class... Args>
+struct detector<Default, void_t<Op<Args...>>, Op, Args...>
+{
+    using value_t = std::true_type;
+    using type = Op<Args...>;
+};
+
+template <template <class...> class Op, class... Args>
+using is_detected = typename detector<nonesuch, void, Op, Args...>::value_t;
+
+template <template <class...> class Op, class... Args>
+using detected_t = typename detector<nonesuch, void, Op, Args...>::type;
+
+template <class Default, template <class...> class Op, class... Args>
+using detected_or = detector<Default, void, Op, Args...>;
+
+template <class Default, template <class...> class Op, class... Args>
+using detected_or_t = typename detected_or<Default, Op, Args...>::type;
+
+template <class Expected, template <class...> class Op, class... Args>
+using is_detected_exact = std::is_same<Expected, detected_t<Op, Args...>>;
+
+template <class To, template <class...> class Op, class... Args>
+using is_detected_convertible =
+    std::is_convertible<detected_t<Op, Args...>, To>;
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/json_fwd.hpp>
+#ifndef INCLUDE_NLOHMANN_JSON_FWD_HPP_
+#define INCLUDE_NLOHMANN_JSON_FWD_HPP_
+
+#include <cstdint> // int64_t, uint64_t
+#include <map> // map
+#include <memory> // allocator
+#include <string> // string
+#include <vector> // vector
+
+/*!
+@brief namespace for Niels Lohmann
+@see https://github.com/nlohmann
+@since version 1.0.0
+*/
+namespace nlohmann
+{
+/*!
+@brief default JSONSerializer template argument
+
+This serializer ignores the template arguments and uses ADL
+([argument-dependent lookup](https://en.cppreference.com/w/cpp/language/adl))
+for serialization.
+*/
+template<typename T = void, typename SFINAE = void>
+struct adl_serializer;
+
+template<template<typename U, typename V, typename... Args> class ObjectType =
+         std::map,
+         template<typename U, typename... Args> class ArrayType = std::vector,
+         class StringType = std::string, class BooleanType = bool,
+         class NumberIntegerType = std::int64_t,
+         class NumberUnsignedType = std::uint64_t,
+         class NumberFloatType = double,
+         template<typename U> class AllocatorType = std::allocator,
+         template<typename T, typename SFINAE = void> class JSONSerializer =
+         adl_serializer>
+class basic_json;
+
+/*!
+@brief JSON Pointer
+
+A JSON pointer defines a string syntax for identifying a specific value
+within a JSON document. It can be used with functions `at` and
+`operator[]`. Furthermore, JSON pointers are the base for JSON patches.
+
+@sa [RFC 6901](https://tools.ietf.org/html/rfc6901)
+
+@since version 2.0.0
+*/
+template<typename BasicJsonType>
+class json_pointer;
+
+/*!
+@brief default JSON class
+
+This type is the default specialization of the @ref basic_json class which
+uses the standard template types.
+
+@since version 1.0.0
+*/
+using json = basic_json<>;
+}  // namespace nlohmann
+
+#endif  // INCLUDE_NLOHMANN_JSON_FWD_HPP_
+
+
+namespace nlohmann
+{
+/*!
+@brief detail namespace with internal helper functions
+
+This namespace collects functions that should not be exposed,
+implementations of some @ref basic_json methods, and meta-programming helpers.
+
+@since version 2.1.0
+*/
+namespace detail
+{
+/////////////
+// helpers //
+/////////////
+
+// Note to maintainers:
+//
+// Every trait in this file expects a non CV-qualified type.
+// The only exceptions are in the 'aliases for detected' section
+// (i.e. those of the form: decltype(T::member_function(std::declval<T>())))
+//
+// In this case, T has to be properly CV-qualified to constraint the function arguments
+// (e.g. to_json(BasicJsonType&, const T&))
+
+template<typename> struct is_basic_json : std::false_type {};
+
+NLOHMANN_BASIC_JSON_TPL_DECLARATION
+struct is_basic_json<NLOHMANN_BASIC_JSON_TPL> : std::true_type {};
+
+//////////////////////////
+// aliases for detected //
+//////////////////////////
+
+template <typename T>
+using mapped_type_t = typename T::mapped_type;
+
+template <typename T>
+using key_type_t = typename T::key_type;
+
+template <typename T>
+using value_type_t = typename T::value_type;
+
+template <typename T>
+using difference_type_t = typename T::difference_type;
+
+template <typename T>
+using pointer_t = typename T::pointer;
+
+template <typename T>
+using reference_t = typename T::reference;
+
+template <typename T>
+using iterator_category_t = typename T::iterator_category;
+
+template <typename T>
+using iterator_t = typename T::iterator;
+
+template <typename T, typename... Args>
+using to_json_function = decltype(T::to_json(std::declval<Args>()...));
+
+template <typename T, typename... Args>
+using from_json_function = decltype(T::from_json(std::declval<Args>()...));
+
+template <typename T, typename U>
+using get_template_function = decltype(std::declval<T>().template get<U>());
+
+// trait checking if JSONSerializer<T>::from_json(json const&, udt&) exists
+template <typename BasicJsonType, typename T, typename = void>
+struct has_from_json : std::false_type {};
+
+template <typename BasicJsonType, typename T>
+struct has_from_json<BasicJsonType, T,
+           enable_if_t<not is_basic_json<T>::value>>
+{
+    using serializer = typename BasicJsonType::template json_serializer<T, void>;
+
+    static constexpr bool value =
+        is_detected_exact<void, from_json_function, serializer,
+        const BasicJsonType&, T&>::value;
+};
+
+// This trait checks if JSONSerializer<T>::from_json(json const&) exists
+// this overload is used for non-default-constructible user-defined-types
+template <typename BasicJsonType, typename T, typename = void>
+struct has_non_default_from_json : std::false_type {};
+
+template<typename BasicJsonType, typename T>
+struct has_non_default_from_json<BasicJsonType, T, enable_if_t<not is_basic_json<T>::value>>
+{
+    using serializer = typename BasicJsonType::template json_serializer<T, void>;
+
+    static constexpr bool value =
+        is_detected_exact<T, from_json_function, serializer,
+        const BasicJsonType&>::value;
+};
+
+// This trait checks if BasicJsonType::json_serializer<T>::to_json exists
+// Do not evaluate the trait when T is a basic_json type, to avoid template instantiation infinite recursion.
+template <typename BasicJsonType, typename T, typename = void>
+struct has_to_json : std::false_type {};
+
+template <typename BasicJsonType, typename T>
+struct has_to_json<BasicJsonType, T, enable_if_t<not is_basic_json<T>::value>>
+{
+    using serializer = typename BasicJsonType::template json_serializer<T, void>;
+
+    static constexpr bool value =
+        is_detected_exact<void, to_json_function, serializer, BasicJsonType&,
+        T>::value;
+};
+
+
+///////////////////
+// is_ functions //
+///////////////////
+
+template <typename T, typename = void>
+struct is_iterator_traits : std::false_type {};
+
+template <typename T>
+struct is_iterator_traits<iterator_traits<T>>
+{
+  private:
+    using traits = iterator_traits<T>;
+
+  public:
+    static constexpr auto value =
+        is_detected<value_type_t, traits>::value &&
+        is_detected<difference_type_t, traits>::value &&
+        is_detected<pointer_t, traits>::value &&
+        is_detected<iterator_category_t, traits>::value &&
+        is_detected<reference_t, traits>::value;
+};
+
+// source: https://stackoverflow.com/a/37193089/4116453
+
+template <typename T, typename = void>
+struct is_complete_type : std::false_type {};
+
+template <typename T>
+struct is_complete_type<T, decltype(void(sizeof(T)))> : std::true_type {};
+
+template <typename BasicJsonType, typename CompatibleObjectType,
+          typename = void>
+struct is_compatible_object_type_impl : std::false_type {};
+
+template <typename BasicJsonType, typename CompatibleObjectType>
+struct is_compatible_object_type_impl <
+    BasicJsonType, CompatibleObjectType,
+    enable_if_t<is_detected<mapped_type_t, CompatibleObjectType>::value and
+    is_detected<key_type_t, CompatibleObjectType>::value >>
+{
+
+    using object_t = typename BasicJsonType::object_t;
+
+    // macOS's is_constructible does not play well with nonesuch...
+    static constexpr bool value =
+        std::is_constructible<typename object_t::key_type,
+        typename CompatibleObjectType::key_type>::value and
+        std::is_constructible<typename object_t::mapped_type,
+        typename CompatibleObjectType::mapped_type>::value;
+};
+
+template <typename BasicJsonType, typename CompatibleObjectType>
+struct is_compatible_object_type
+    : is_compatible_object_type_impl<BasicJsonType, CompatibleObjectType> {};
+
+template <typename BasicJsonType, typename ConstructibleObjectType,
+          typename = void>
+struct is_constructible_object_type_impl : std::false_type {};
+
+template <typename BasicJsonType, typename ConstructibleObjectType>
+struct is_constructible_object_type_impl <
+    BasicJsonType, ConstructibleObjectType,
+    enable_if_t<is_detected<mapped_type_t, ConstructibleObjectType>::value and
+    is_detected<key_type_t, ConstructibleObjectType>::value >>
+{
+    using object_t = typename BasicJsonType::object_t;
+
+    static constexpr bool value =
+        (std::is_default_constructible<ConstructibleObjectType>::value and
+         (std::is_move_assignable<ConstructibleObjectType>::value or
+          std::is_copy_assignable<ConstructibleObjectType>::value) and
+         (std::is_constructible<typename ConstructibleObjectType::key_type,
+          typename object_t::key_type>::value and
+          std::is_same <
+          typename object_t::mapped_type,
+          typename ConstructibleObjectType::mapped_type >::value)) or
+        (has_from_json<BasicJsonType,
+         typename ConstructibleObjectType::mapped_type>::value or
+         has_non_default_from_json <
+         BasicJsonType,
+         typename ConstructibleObjectType::mapped_type >::value);
+};
+
+template <typename BasicJsonType, typename ConstructibleObjectType>
+struct is_constructible_object_type
+    : is_constructible_object_type_impl<BasicJsonType,
+      ConstructibleObjectType> {};
+
+template <typename BasicJsonType, typename CompatibleStringType,
+          typename = void>
+struct is_compatible_string_type_impl : std::false_type {};
+
+template <typename BasicJsonType, typename CompatibleStringType>
+struct is_compatible_string_type_impl <
+    BasicJsonType, CompatibleStringType,
+    enable_if_t<is_detected_exact<typename BasicJsonType::string_t::value_type,
+    value_type_t, CompatibleStringType>::value >>
+{
+    static constexpr auto value =
+        std::is_constructible<typename BasicJsonType::string_t, CompatibleStringType>::value;
+};
+
+template <typename BasicJsonType, typename ConstructibleStringType>
+struct is_compatible_string_type
+    : is_compatible_string_type_impl<BasicJsonType, ConstructibleStringType> {};
+
+template <typename BasicJsonType, typename ConstructibleStringType,
+          typename = void>
+struct is_constructible_string_type_impl : std::false_type {};
+
+template <typename BasicJsonType, typename ConstructibleStringType>
+struct is_constructible_string_type_impl <
+    BasicJsonType, ConstructibleStringType,
+    enable_if_t<is_detected_exact<typename BasicJsonType::string_t::value_type,
+    value_type_t, ConstructibleStringType>::value >>
+{
+    static constexpr auto value =
+        std::is_constructible<ConstructibleStringType,
+        typename BasicJsonType::string_t>::value;
+};
+
+template <typename BasicJsonType, typename ConstructibleStringType>
+struct is_constructible_string_type
+    : is_constructible_string_type_impl<BasicJsonType, ConstructibleStringType> {};
+
+template <typename BasicJsonType, typename CompatibleArrayType, typename = void>
+struct is_compatible_array_type_impl : std::false_type {};
+
+template <typename BasicJsonType, typename CompatibleArrayType>
+struct is_compatible_array_type_impl <
+    BasicJsonType, CompatibleArrayType,
+    enable_if_t<is_detected<value_type_t, CompatibleArrayType>::value and
+    is_detected<iterator_t, CompatibleArrayType>::value and
+// This is needed because json_reverse_iterator has a ::iterator type...
+// Therefore it is detected as a CompatibleArrayType.
+// The real fix would be to have an Iterable concept.
+    not is_iterator_traits<
+    iterator_traits<CompatibleArrayType>>::value >>
+{
+    static constexpr bool value =
+        std::is_constructible<BasicJsonType,
+        typename CompatibleArrayType::value_type>::value;
+};
+
+template <typename BasicJsonType, typename CompatibleArrayType>
+struct is_compatible_array_type
+    : is_compatible_array_type_impl<BasicJsonType, CompatibleArrayType> {};
+
+template <typename BasicJsonType, typename ConstructibleArrayType, typename = void>
+struct is_constructible_array_type_impl : std::false_type {};
+
+template <typename BasicJsonType, typename ConstructibleArrayType>
+struct is_constructible_array_type_impl <
+    BasicJsonType, ConstructibleArrayType,
+    enable_if_t<std::is_same<ConstructibleArrayType,
+    typename BasicJsonType::value_type>::value >>
+            : std::true_type {};
+
+template <typename BasicJsonType, typename ConstructibleArrayType>
+struct is_constructible_array_type_impl <
+    BasicJsonType, ConstructibleArrayType,
+    enable_if_t<not std::is_same<ConstructibleArrayType,
+    typename BasicJsonType::value_type>::value and
+    std::is_default_constructible<ConstructibleArrayType>::value and
+(std::is_move_assignable<ConstructibleArrayType>::value or
+ std::is_copy_assignable<ConstructibleArrayType>::value) and
+is_detected<value_type_t, ConstructibleArrayType>::value and
+is_detected<iterator_t, ConstructibleArrayType>::value and
+is_complete_type<
+detected_t<value_type_t, ConstructibleArrayType>>::value >>
+{
+    static constexpr bool value =
+        // This is needed because json_reverse_iterator has a ::iterator type,
+        // furthermore, std::back_insert_iterator (and other iterators) have a
+        // base class `iterator`... Therefore it is detected as a
+        // ConstructibleArrayType. The real fix would be to have an Iterable
+        // concept.
+        not is_iterator_traits<iterator_traits<ConstructibleArrayType>>::value and
+
+        (std::is_same<typename ConstructibleArrayType::value_type,
+         typename BasicJsonType::array_t::value_type>::value or
+         has_from_json<BasicJsonType,
+         typename ConstructibleArrayType::value_type>::value or
+         has_non_default_from_json <
+         BasicJsonType, typename ConstructibleArrayType::value_type >::value);
+};
+
+template <typename BasicJsonType, typename ConstructibleArrayType>
+struct is_constructible_array_type
+    : is_constructible_array_type_impl<BasicJsonType, ConstructibleArrayType> {};
+
+template <typename RealIntegerType, typename CompatibleNumberIntegerType,
+          typename = void>
+struct is_compatible_integer_type_impl : std::false_type {};
+
+template <typename RealIntegerType, typename CompatibleNumberIntegerType>
+struct is_compatible_integer_type_impl <
+    RealIntegerType, CompatibleNumberIntegerType,
+    enable_if_t<std::is_integral<RealIntegerType>::value and
+    std::is_integral<CompatibleNumberIntegerType>::value and
+    not std::is_same<bool, CompatibleNumberIntegerType>::value >>
+{
+    // is there an assert somewhere on overflows?
+    using RealLimits = std::numeric_limits<RealIntegerType>;
+    using CompatibleLimits = std::numeric_limits<CompatibleNumberIntegerType>;
+
+    static constexpr auto value =
+        std::is_constructible<RealIntegerType,
+        CompatibleNumberIntegerType>::value and
+        CompatibleLimits::is_integer and
+        RealLimits::is_signed == CompatibleLimits::is_signed;
+};
+
+template <typename RealIntegerType, typename CompatibleNumberIntegerType>
+struct is_compatible_integer_type
+    : is_compatible_integer_type_impl<RealIntegerType,
+      CompatibleNumberIntegerType> {};
+
+template <typename BasicJsonType, typename CompatibleType, typename = void>
+struct is_compatible_type_impl: std::false_type {};
+
+template <typename BasicJsonType, typename CompatibleType>
+struct is_compatible_type_impl <
+    BasicJsonType, CompatibleType,
+    enable_if_t<is_complete_type<CompatibleType>::value >>
+{
+    static constexpr bool value =
+        has_to_json<BasicJsonType, CompatibleType>::value;
+};
+
+template <typename BasicJsonType, typename CompatibleType>
+struct is_compatible_type
+    : is_compatible_type_impl<BasicJsonType, CompatibleType> {};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+#include <array> // array
+#include <ciso646> // and
+#include <cstddef> // size_t
+#include <cstdint> // uint8_t
+#include <string> // string
+
+namespace nlohmann
+{
+namespace detail
+{
+///////////////////////////
+// JSON type enumeration //
+///////////////////////////
+
+/*!
+@brief the JSON type enumeration
+
+This enumeration collects the different JSON types. It is internally used to
+distinguish the stored values, and the functions @ref basic_json::is_null(),
+@ref basic_json::is_object(), @ref basic_json::is_array(),
+@ref basic_json::is_string(), @ref basic_json::is_boolean(),
+@ref basic_json::is_number() (with @ref basic_json::is_number_integer(),
+@ref basic_json::is_number_unsigned(), and @ref basic_json::is_number_float()),
+@ref basic_json::is_discarded(), @ref basic_json::is_primitive(), and
+@ref basic_json::is_structured() rely on it.
+
+@note There are three enumeration entries (number_integer, number_unsigned, and
+number_float), because the library distinguishes these three types for numbers:
+@ref basic_json::number_unsigned_t is used for unsigned integers,
+@ref basic_json::number_integer_t is used for signed integers, and
+@ref basic_json::number_float_t is used for floating-point numbers or to
+approximate integers which do not fit in the limits of their respective type.
+
+@sa @ref basic_json::basic_json(const value_t value_type) -- create a JSON
+value with the default value for a given type
+
+@since version 1.0.0
+*/
+enum class value_t : std::uint8_t
+{
+    null,             ///< null value
+    object,           ///< object (unordered set of name/value pairs)
+    array,            ///< array (ordered collection of values)
+    string,           ///< string value
+    boolean,          ///< boolean value
+    number_integer,   ///< number value (signed integer)
+    number_unsigned,  ///< number value (unsigned integer)
+    number_float,     ///< number value (floating-point)
+    discarded         ///< discarded by the the parser callback function
+};
+
+/*!
+@brief comparison operator for JSON types
+
+Returns an ordering that is similar to Python:
+- order: null < boolean < number < object < array < string
+- furthermore, each type is not smaller than itself
+- discarded values are not comparable
+
+@since version 1.0.0
+*/
+inline bool operator<(const value_t lhs, const value_t rhs) noexcept
+{
+    static constexpr std::array<std::uint8_t, 8> order = {{
+            0 /* null */, 3 /* object */, 4 /* array */, 5 /* string */,
+            1 /* boolean */, 2 /* integer */, 2 /* unsigned */, 2 /* float */
+        }
+    };
+
+    const auto l_index = static_cast<std::size_t>(lhs);
+    const auto r_index = static_cast<std::size_t>(rhs);
+    return l_index < order.size() and r_index < order.size() and order[l_index] < order[r_index];
+}
+}  // namespace detail
+}  // namespace nlohmann
+
+
+namespace nlohmann
+{
+namespace detail
+{
+template<typename BasicJsonType>
+void from_json(const BasicJsonType& j, typename std::nullptr_t& n)
+{
+    if (JSON_HEDLEY_UNLIKELY(not j.is_null()))
+    {
+        JSON_THROW(type_error::create(302, "type must be null, but is " + std::string(j.type_name())));
+    }
+    n = nullptr;
+}
+
+// overloads for basic_json template parameters
+template<typename BasicJsonType, typename ArithmeticType,
+         enable_if_t<std::is_arithmetic<ArithmeticType>::value and
+                     not std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
+                     int> = 0>
+void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)
+{
+    switch (static_cast<value_t>(j))
+    {
+        case value_t::number_unsigned:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
+            break;
+        }
+        case value_t::number_integer:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
+            break;
+        }
+        case value_t::number_float:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
+            break;
+        }
+
+        default:
+            JSON_THROW(type_error::create(302, "type must be number, but is " + std::string(j.type_name())));
+    }
+}
+
+template<typename BasicJsonType>
+void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b)
+{
+    if (JSON_HEDLEY_UNLIKELY(not j.is_boolean()))
+    {
+        JSON_THROW(type_error::create(302, "type must be boolean, but is " + std::string(j.type_name())));
+    }
+    b = *j.template get_ptr<const typename BasicJsonType::boolean_t*>();
+}
+
+template<typename BasicJsonType>
+void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s)
+{
+    if (JSON_HEDLEY_UNLIKELY(not j.is_string()))
+    {
+        JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name())));
+    }
+    s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
+}
+
+template <
+    typename BasicJsonType, typename ConstructibleStringType,
+    enable_if_t <
+        is_constructible_string_type<BasicJsonType, ConstructibleStringType>::value and
+        not std::is_same<typename BasicJsonType::string_t,
+                         ConstructibleStringType>::value,
+        int > = 0 >
+void from_json(const BasicJsonType& j, ConstructibleStringType& s)
+{
+    if (JSON_HEDLEY_UNLIKELY(not j.is_string()))
+    {
+        JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name())));
+    }
+
+    s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
+}
+
+template<typename BasicJsonType>
+void from_json(const BasicJsonType& j, typename BasicJsonType::number_float_t& val)
+{
+    get_arithmetic_value(j, val);
+}
+
+template<typename BasicJsonType>
+void from_json(const BasicJsonType& j, typename BasicJsonType::number_unsigned_t& val)
+{
+    get_arithmetic_value(j, val);
+}
+
+template<typename BasicJsonType>
+void from_json(const BasicJsonType& j, typename BasicJsonType::number_integer_t& val)
+{
+    get_arithmetic_value(j, val);
+}
+
+template<typename BasicJsonType, typename EnumType,
+         enable_if_t<std::is_enum<EnumType>::value, int> = 0>
+void from_json(const BasicJsonType& j, EnumType& e)
+{
+    typename std::underlying_type<EnumType>::type val;
+    get_arithmetic_value(j, val);
+    e = static_cast<EnumType>(val);
+}
+
+// forward_list doesn't have an insert method
+template<typename BasicJsonType, typename T, typename Allocator,
+         enable_if_t<std::is_convertible<BasicJsonType, T>::value, int> = 0>
+void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l)
+{
+    if (JSON_HEDLEY_UNLIKELY(not j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
+    }
+    l.clear();
+    std::transform(j.rbegin(), j.rend(),
+                   std::front_inserter(l), [](const BasicJsonType & i)
+    {
+        return i.template get<T>();
+    });
+}
+
+// valarray doesn't have an insert method
+template<typename BasicJsonType, typename T,
+         enable_if_t<std::is_convertible<BasicJsonType, T>::value, int> = 0>
+void from_json(const BasicJsonType& j, std::valarray<T>& l)
+{
+    if (JSON_HEDLEY_UNLIKELY(not j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
+    }
+    l.resize(j.size());
+    std::copy(j.m_value.array->begin(), j.m_value.array->end(), std::begin(l));
+}
+
+template <typename BasicJsonType, typename T, std::size_t N>
+auto from_json(const BasicJsonType& j, T (&arr)[N])
+-> decltype(j.template get<T>(), void())
+{
+    for (std::size_t i = 0; i < N; ++i)
+    {
+        arr[i] = j.at(i).template get<T>();
+    }
+}
+
+template<typename BasicJsonType>
+void from_json_array_impl(const BasicJsonType& j, typename BasicJsonType::array_t& arr, priority_tag<3> /*unused*/)
+{
+    arr = *j.template get_ptr<const typename BasicJsonType::array_t*>();
+}
+
+template <typename BasicJsonType, typename T, std::size_t N>
+auto from_json_array_impl(const BasicJsonType& j, std::array<T, N>& arr,
+                          priority_tag<2> /*unused*/)
+-> decltype(j.template get<T>(), void())
+{
+    for (std::size_t i = 0; i < N; ++i)
+    {
+        arr[i] = j.at(i).template get<T>();
+    }
+}
+
+template<typename BasicJsonType, typename ConstructibleArrayType>
+auto from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr, priority_tag<1> /*unused*/)
+-> decltype(
+    arr.reserve(std::declval<typename ConstructibleArrayType::size_type>()),
+    j.template get<typename ConstructibleArrayType::value_type>(),
+    void())
+{
+    using std::end;
+
+    ConstructibleArrayType ret;
+    ret.reserve(j.size());
+    std::transform(j.begin(), j.end(),
+                   std::inserter(ret, end(ret)), [](const BasicJsonType & i)
+    {
+        // get<BasicJsonType>() returns *this, this won't call a from_json
+        // method when value_type is BasicJsonType
+        return i.template get<typename ConstructibleArrayType::value_type>();
+    });
+    arr = std::move(ret);
+}
+
+template <typename BasicJsonType, typename ConstructibleArrayType>
+void from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr,
+                          priority_tag<0> /*unused*/)
+{
+    using std::end;
+
+    ConstructibleArrayType ret;
+    std::transform(
+        j.begin(), j.end(), std::inserter(ret, end(ret)),
+        [](const BasicJsonType & i)
+    {
+        // get<BasicJsonType>() returns *this, this won't call a from_json
+        // method when value_type is BasicJsonType
+        return i.template get<typename ConstructibleArrayType::value_type>();
+    });
+    arr = std::move(ret);
+}
+
+template <typename BasicJsonType, typename ConstructibleArrayType,
+          enable_if_t <
+              is_constructible_array_type<BasicJsonType, ConstructibleArrayType>::value and
+              not is_constructible_object_type<BasicJsonType, ConstructibleArrayType>::value and
+              not is_constructible_string_type<BasicJsonType, ConstructibleArrayType>::value and
+              not is_basic_json<ConstructibleArrayType>::value,
+              int > = 0 >
+
+auto from_json(const BasicJsonType& j, ConstructibleArrayType& arr)
+-> decltype(from_json_array_impl(j, arr, priority_tag<3> {}),
+j.template get<typename ConstructibleArrayType::value_type>(),
+void())
+{
+    if (JSON_HEDLEY_UNLIKELY(not j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, "type must be array, but is " +
+                                      std::string(j.type_name())));
+    }
+
+    from_json_array_impl(j, arr, priority_tag<3> {});
+}
+
+template<typename BasicJsonType, typename ConstructibleObjectType,
+         enable_if_t<is_constructible_object_type<BasicJsonType, ConstructibleObjectType>::value, int> = 0>
+void from_json(const BasicJsonType& j, ConstructibleObjectType& obj)
+{
+    if (JSON_HEDLEY_UNLIKELY(not j.is_object()))
+    {
+        JSON_THROW(type_error::create(302, "type must be object, but is " + std::string(j.type_name())));
+    }
+
+    ConstructibleObjectType ret;
+    auto inner_object = j.template get_ptr<const typename BasicJsonType::object_t*>();
+    using value_type = typename ConstructibleObjectType::value_type;
+    std::transform(
+        inner_object->begin(), inner_object->end(),
+        std::inserter(ret, ret.begin()),
+        [](typename BasicJsonType::object_t::value_type const & p)
+    {
+        return value_type(p.first, p.second.template get<typename ConstructibleObjectType::mapped_type>());
+    });
+    obj = std::move(ret);
+}
+
+// overload for arithmetic types, not chosen for basic_json template arguments
+// (BooleanType, etc..); note: Is it really necessary to provide explicit
+// overloads for boolean_t etc. in case of a custom BooleanType which is not
+// an arithmetic type?
+template<typename BasicJsonType, typename ArithmeticType,
+         enable_if_t <
+             std::is_arithmetic<ArithmeticType>::value and
+             not std::is_same<ArithmeticType, typename BasicJsonType::number_unsigned_t>::value and
+             not std::is_same<ArithmeticType, typename BasicJsonType::number_integer_t>::value and
+             not std::is_same<ArithmeticType, typename BasicJsonType::number_float_t>::value and
+             not std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
+             int> = 0>
+void from_json(const BasicJsonType& j, ArithmeticType& val)
+{
+    switch (static_cast<value_t>(j))
+    {
+        case value_t::number_unsigned:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
+            break;
+        }
+        case value_t::number_integer:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
+            break;
+        }
+        case value_t::number_float:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
+            break;
+        }
+        case value_t::boolean:
+        {
+            val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::boolean_t*>());
+            break;
+        }
+
+        default:
+            JSON_THROW(type_error::create(302, "type must be number, but is " + std::string(j.type_name())));
+    }
+}
+
+template<typename BasicJsonType, typename A1, typename A2>
+void from_json(const BasicJsonType& j, std::pair<A1, A2>& p)
+{
+    p = {j.at(0).template get<A1>(), j.at(1).template get<A2>()};
+}
+
+template<typename BasicJsonType, typename Tuple, std::size_t... Idx>
+void from_json_tuple_impl(const BasicJsonType& j, Tuple& t, index_sequence<Idx...> /*unused*/)
+{
+    t = std::make_tuple(j.at(Idx).template get<typename std::tuple_element<Idx, Tuple>::type>()...);
+}
+
+template<typename BasicJsonType, typename... Args>
+void from_json(const BasicJsonType& j, std::tuple<Args...>& t)
+{
+    from_json_tuple_impl(j, t, index_sequence_for<Args...> {});
+}
+
+template <typename BasicJsonType, typename Key, typename Value, typename Compare, typename Allocator,
+          typename = enable_if_t<not std::is_constructible<
+                                     typename BasicJsonType::string_t, Key>::value>>
+void from_json(const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>& m)
+{
+    if (JSON_HEDLEY_UNLIKELY(not j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
+    }
+    m.clear();
+    for (const auto& p : j)
+    {
+        if (JSON_HEDLEY_UNLIKELY(not p.is_array()))
+        {
+            JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name())));
+        }
+        m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
+    }
+}
+
+template <typename BasicJsonType, typename Key, typename Value, typename Hash, typename KeyEqual, typename Allocator,
+          typename = enable_if_t<not std::is_constructible<
+                                     typename BasicJsonType::string_t, Key>::value>>
+void from_json(const BasicJsonType& j, std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>& m)
+{
+    if (JSON_HEDLEY_UNLIKELY(not j.is_array()))
+    {
+        JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
+    }
+    m.clear();
+    for (const auto& p : j)
+    {
+        if (JSON_HEDLEY_UNLIKELY(not p.is_array()))
+        {
+            JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name())));
+        }
+        m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
+    }
+}
+
+struct from_json_fn
+{
+    template<typename BasicJsonType, typename T>
+    auto operator()(const BasicJsonType& j, T& val) const
+    noexcept(noexcept(from_json(j, val)))
+    -> decltype(from_json(j, val), void())
+    {
+        return from_json(j, val);
+    }
+};
+}  // namespace detail
+
+/// namespace to hold default `from_json` function
+/// to see why this is required:
+/// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html
+namespace
+{
+constexpr const auto& from_json = detail::static_const<detail::from_json_fn>::value;
+} // namespace
+} // namespace nlohmann
+
+// #include <nlohmann/detail/conversions/to_json.hpp>
+
+
+#include <algorithm> // copy
+#include <ciso646> // or, and, not
+#include <iterator> // begin, end
+#include <string> // string
+#include <tuple> // tuple, get
+#include <type_traits> // is_same, is_constructible, is_floating_point, is_enum, underlying_type
+#include <utility> // move, forward, declval, pair
+#include <valarray> // valarray
+#include <vector> // vector
+
+// #include <nlohmann/detail/iterators/iteration_proxy.hpp>
+
+
+#include <cstddef> // size_t
+#include <iterator> // input_iterator_tag
+#include <string> // string, to_string
+#include <tuple> // tuple_size, get, tuple_element
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+template <typename IteratorType> class iteration_proxy_value
+{
+  public:
+    using difference_type = std::ptrdiff_t;
+    using value_type = iteration_proxy_value;
+    using pointer = value_type * ;
+    using reference = value_type & ;
+    using iterator_category = std::input_iterator_tag;
+
+  private:
+    /// the iterator
+    IteratorType anchor;
+    /// an index for arrays (used to create key names)
+    std::size_t array_index = 0;
+    /// last stringified array index
+    mutable std::size_t array_index_last = 0;
+    /// a string representation of the array index
+    mutable std::string array_index_str = "0";
+    /// an empty string (to return a reference for primitive values)
+    const std::string empty_str = "";
+
+  public:
+    explicit iteration_proxy_value(IteratorType it) noexcept : anchor(it) {}
+
+    /// dereference operator (needed for range-based for)
+    iteration_proxy_value& operator*()
+    {
+        return *this;
+    }
+
+    /// increment operator (needed for range-based for)
+    iteration_proxy_value& operator++()
+    {
+        ++anchor;
+        ++array_index;
+
+        return *this;
+    }
+
+    /// equality operator (needed for InputIterator)
+    bool operator==(const iteration_proxy_value& o) const
+    {
+        return anchor == o.anchor;
+    }
+
+    /// inequality operator (needed for range-based for)
+    bool operator!=(const iteration_proxy_value& o) const
+    {
+        return anchor != o.anchor;
+    }
+
+    /// return key of the iterator
+    const std::string& key() const
+    {
+        assert(anchor.m_object != nullptr);
+
+        switch (anchor.m_object->type())
+        {
+            // use integer array index as key
+            case value_t::array:
+            {
+                if (array_index != array_index_last)
+                {
+                    array_index_str = std::to_string(array_index);
+                    array_index_last = array_index;
+                }
+                return array_index_str;
+            }
+
+            // use key from the object
+            case value_t::object:
+                return anchor.key();
+
+            // use an empty key for all primitive types
+            default:
+                return empty_str;
+        }
+    }
+
+    /// return value of the iterator
+    typename IteratorType::reference value() const
+    {
+        return anchor.value();
+    }
+};
+
+/// proxy class for the items() function
+template<typename IteratorType> class iteration_proxy
+{
+  private:
+    /// the container to iterate
+    typename IteratorType::reference container;
+
+  public:
+    /// construct iteration proxy from a container
+    explicit iteration_proxy(typename IteratorType::reference cont) noexcept
+        : container(cont) {}
+
+    /// return iterator begin (needed for range-based for)
+    iteration_proxy_value<IteratorType> begin() noexcept
+    {
+        return iteration_proxy_value<IteratorType>(container.begin());
+    }
+
+    /// return iterator end (needed for range-based for)
+    iteration_proxy_value<IteratorType> end() noexcept
+    {
+        return iteration_proxy_value<IteratorType>(container.end());
+    }
+};
+// Structured Bindings Support
+// For further reference see https://blog.tartanllama.xyz/structured-bindings/
+// And see https://github.com/nlohmann/json/pull/1391
+template <std::size_t N, typename IteratorType, enable_if_t<N == 0, int> = 0>
+auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.key())
+{
+    return i.key();
+}
+// Structured Bindings Support
+// For further reference see https://blog.tartanllama.xyz/structured-bindings/
+// And see https://github.com/nlohmann/json/pull/1391
+template <std::size_t N, typename IteratorType, enable_if_t<N == 1, int> = 0>
+auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.value())
+{
+    return i.value();
+}
+}  // namespace detail
+}  // namespace nlohmann
+
+// The Addition to the STD Namespace is required to add
+// Structured Bindings Support to the iteration_proxy_value class
+// For further reference see https://blog.tartanllama.xyz/structured-bindings/
+// And see https://github.com/nlohmann/json/pull/1391
+namespace std
+{
+#if defined(__clang__)
+    // Fix: https://github.com/nlohmann/json/issues/1401
+    #pragma clang diagnostic push
+    #pragma clang diagnostic ignored "-Wmismatched-tags"
+#endif
+template <typename IteratorType>
+class tuple_size<::nlohmann::detail::iteration_proxy_value<IteratorType>>
+            : public std::integral_constant<std::size_t, 2> {};
+
+template <std::size_t N, typename IteratorType>
+class tuple_element<N, ::nlohmann::detail::iteration_proxy_value<IteratorType >>
+{
+  public:
+    using type = decltype(
+                     get<N>(std::declval <
+                            ::nlohmann::detail::iteration_proxy_value<IteratorType >> ()));
+};
+#if defined(__clang__)
+    #pragma clang diagnostic pop
+#endif
+} // namespace std
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+//////////////////
+// constructors //
+//////////////////
+
+template<value_t> struct external_constructor;
+
+template<>
+struct external_constructor<value_t::boolean>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::boolean_t b) noexcept
+    {
+        j.m_type = value_t::boolean;
+        j.m_value = b;
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::string>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, const typename BasicJsonType::string_t& s)
+    {
+        j.m_type = value_t::string;
+        j.m_value = s;
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::string_t&& s)
+    {
+        j.m_type = value_t::string;
+        j.m_value = std::move(s);
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType, typename CompatibleStringType,
+             enable_if_t<not std::is_same<CompatibleStringType, typename BasicJsonType::string_t>::value,
+                         int> = 0>
+    static void construct(BasicJsonType& j, const CompatibleStringType& str)
+    {
+        j.m_type = value_t::string;
+        j.m_value.string = j.template create<typename BasicJsonType::string_t>(str);
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::number_float>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::number_float_t val) noexcept
+    {
+        j.m_type = value_t::number_float;
+        j.m_value = val;
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::number_unsigned>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::number_unsigned_t val) noexcept
+    {
+        j.m_type = value_t::number_unsigned;
+        j.m_value = val;
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::number_integer>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::number_integer_t val) noexcept
+    {
+        j.m_type = value_t::number_integer;
+        j.m_value = val;
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::array>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, const typename BasicJsonType::array_t& arr)
+    {
+        j.m_type = value_t::array;
+        j.m_value = arr;
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
+    {
+        j.m_type = value_t::array;
+        j.m_value = std::move(arr);
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType, typename CompatibleArrayType,
+             enable_if_t<not std::is_same<CompatibleArrayType, typename BasicJsonType::array_t>::value,
+                         int> = 0>
+    static void construct(BasicJsonType& j, const CompatibleArrayType& arr)
+    {
+        using std::begin;
+        using std::end;
+        j.m_type = value_t::array;
+        j.m_value.array = j.template create<typename BasicJsonType::array_t>(begin(arr), end(arr));
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, const std::vector<bool>& arr)
+    {
+        j.m_type = value_t::array;
+        j.m_value = value_t::array;
+        j.m_value.array->reserve(arr.size());
+        for (const bool x : arr)
+        {
+            j.m_value.array->push_back(x);
+        }
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType, typename T,
+             enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
+    static void construct(BasicJsonType& j, const std::valarray<T>& arr)
+    {
+        j.m_type = value_t::array;
+        j.m_value = value_t::array;
+        j.m_value.array->resize(arr.size());
+        std::copy(std::begin(arr), std::end(arr), j.m_value.array->begin());
+        j.assert_invariant();
+    }
+};
+
+template<>
+struct external_constructor<value_t::object>
+{
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, const typename BasicJsonType::object_t& obj)
+    {
+        j.m_type = value_t::object;
+        j.m_value = obj;
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType>
+    static void construct(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
+    {
+        j.m_type = value_t::object;
+        j.m_value = std::move(obj);
+        j.assert_invariant();
+    }
+
+    template<typename BasicJsonType, typename CompatibleObjectType,
+             enable_if_t<not std::is_same<CompatibleObjectType, typename BasicJsonType::object_t>::value, int> = 0>
+    static void construct(BasicJsonType& j, const CompatibleObjectType& obj)
+    {
+        using std::begin;
+        using std::end;
+
+        j.m_type = value_t::object;
+        j.m_value.object = j.template create<typename BasicJsonType::object_t>(begin(obj), end(obj));
+        j.assert_invariant();
+    }
+};
+
+/////////////
+// to_json //
+/////////////
+
+template<typename BasicJsonType, typename T,
+         enable_if_t<std::is_same<T, typename BasicJsonType::boolean_t>::value, int> = 0>
+void to_json(BasicJsonType& j, T b) noexcept
+{
+    external_constructor<value_t::boolean>::construct(j, b);
+}
+
+template<typename BasicJsonType, typename CompatibleString,
+         enable_if_t<std::is_constructible<typename BasicJsonType::string_t, CompatibleString>::value, int> = 0>
+void to_json(BasicJsonType& j, const CompatibleString& s)
+{
+    external_constructor<value_t::string>::construct(j, s);
+}
+
+template<typename BasicJsonType>
+void to_json(BasicJsonType& j, typename BasicJsonType::string_t&& s)
+{
+    external_constructor<value_t::string>::construct(j, std::move(s));
+}
+
+template<typename BasicJsonType, typename FloatType,
+         enable_if_t<std::is_floating_point<FloatType>::value, int> = 0>
+void to_json(BasicJsonType& j, FloatType val) noexcept
+{
+    external_constructor<value_t::number_float>::construct(j, static_cast<typename BasicJsonType::number_float_t>(val));
+}
+
+template<typename BasicJsonType, typename CompatibleNumberUnsignedType,
+         enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_unsigned_t, CompatibleNumberUnsignedType>::value, int> = 0>
+void to_json(BasicJsonType& j, CompatibleNumberUnsignedType val) noexcept
+{
+    external_constructor<value_t::number_unsigned>::construct(j, static_cast<typename BasicJsonType::number_unsigned_t>(val));
+}
+
+template<typename BasicJsonType, typename CompatibleNumberIntegerType,
+         enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_integer_t, CompatibleNumberIntegerType>::value, int> = 0>
+void to_json(BasicJsonType& j, CompatibleNumberIntegerType val) noexcept
+{
+    external_constructor<value_t::number_integer>::construct(j, static_cast<typename BasicJsonType::number_integer_t>(val));
+}
+
+template<typename BasicJsonType, typename EnumType,
+         enable_if_t<std::is_enum<EnumType>::value, int> = 0>
+void to_json(BasicJsonType& j, EnumType e) noexcept
+{
+    using underlying_type = typename std::underlying_type<EnumType>::type;
+    external_constructor<value_t::number_integer>::construct(j, static_cast<underlying_type>(e));
+}
+
+template<typename BasicJsonType>
+void to_json(BasicJsonType& j, const std::vector<bool>& e)
+{
+    external_constructor<value_t::array>::construct(j, e);
+}
+
+template <typename BasicJsonType, typename CompatibleArrayType,
+          enable_if_t<is_compatible_array_type<BasicJsonType,
+                      CompatibleArrayType>::value and
+                      not is_compatible_object_type<
+                          BasicJsonType, CompatibleArrayType>::value and
+                      not is_compatible_string_type<BasicJsonType, CompatibleArrayType>::value and
+                      not is_basic_json<CompatibleArrayType>::value,
+                      int> = 0>
+void to_json(BasicJsonType& j, const CompatibleArrayType& arr)
+{
+    external_constructor<value_t::array>::construct(j, arr);
+}
+
+template<typename BasicJsonType, typename T,
+         enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
+void to_json(BasicJsonType& j, const std::valarray<T>& arr)
+{
+    external_constructor<value_t::array>::construct(j, std::move(arr));
+}
+
+template<typename BasicJsonType>
+void to_json(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
+{
+    external_constructor<value_t::array>::construct(j, std::move(arr));
+}
+
+template<typename BasicJsonType, typename CompatibleObjectType,
+         enable_if_t<is_compatible_object_type<BasicJsonType, CompatibleObjectType>::value and not is_basic_json<CompatibleObjectType>::value, int> = 0>
+void to_json(BasicJsonType& j, const CompatibleObjectType& obj)
+{
+    external_constructor<value_t::object>::construct(j, obj);
+}
+
+template<typename BasicJsonType>
+void to_json(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
+{
+    external_constructor<value_t::object>::construct(j, std::move(obj));
+}
+
+template <
+    typename BasicJsonType, typename T, std::size_t N,
+    enable_if_t<not std::is_constructible<typename BasicJsonType::string_t,
+                const T(&)[N]>::value,
+                int> = 0 >
+void to_json(BasicJsonType& j, const T(&arr)[N])
+{
+    external_constructor<value_t::array>::construct(j, arr);
+}
+
+template<typename BasicJsonType, typename... Args>
+void to_json(BasicJsonType& j, const std::pair<Args...>& p)
+{
+    j = { p.first, p.second };
+}
+
+// for https://github.com/nlohmann/json/pull/1134
+template < typename BasicJsonType, typename T,
+           enable_if_t<std::is_same<T, iteration_proxy_value<typename BasicJsonType::iterator>>::value, int> = 0>
+void to_json(BasicJsonType& j, const T& b)
+{
+    j = { {b.key(), b.value()} };
+}
+
+template<typename BasicJsonType, typename Tuple, std::size_t... Idx>
+void to_json_tuple_impl(BasicJsonType& j, const Tuple& t, index_sequence<Idx...> /*unused*/)
+{
+    j = { std::get<Idx>(t)... };
+}
+
+template<typename BasicJsonType, typename... Args>
+void to_json(BasicJsonType& j, const std::tuple<Args...>& t)
+{
+    to_json_tuple_impl(j, t, index_sequence_for<Args...> {});
+}
+
+struct to_json_fn
+{
+    template<typename BasicJsonType, typename T>
+    auto operator()(BasicJsonType& j, T&& val) const noexcept(noexcept(to_json(j, std::forward<T>(val))))
+    -> decltype(to_json(j, std::forward<T>(val)), void())
+    {
+        return to_json(j, std::forward<T>(val));
+    }
+};
+}  // namespace detail
+
+/// namespace to hold default `to_json` function
+namespace
+{
+constexpr const auto& to_json = detail::static_const<detail::to_json_fn>::value;
+} // namespace
+} // namespace nlohmann
+
+
+namespace nlohmann
+{
+
+template<typename, typename>
+struct adl_serializer
+{
+    /*!
+    @brief convert a JSON value to any value type
+
+    This function is usually called by the `get()` function of the
+    @ref basic_json class (either explicit or via conversion operators).
+
+    @param[in] j        JSON value to read from
+    @param[in,out] val  value to write to
+    */
+    template<typename BasicJsonType, typename ValueType>
+    static auto from_json(BasicJsonType&& j, ValueType& val) noexcept(
+        noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), val)))
+    -> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), val), void())
+    {
+        ::nlohmann::from_json(std::forward<BasicJsonType>(j), val);
+    }
+
+    /*!
+    @brief convert any value type to a JSON value
+
+    This function is usually called by the constructors of the @ref basic_json
+    class.
+
+    @param[in,out] j  JSON value to write to
+    @param[in] val    value to read from
+    */
+    template <typename BasicJsonType, typename ValueType>
+    static auto to_json(BasicJsonType& j, ValueType&& val) noexcept(
+        noexcept(::nlohmann::to_json(j, std::forward<ValueType>(val))))
+    -> decltype(::nlohmann::to_json(j, std::forward<ValueType>(val)), void())
+    {
+        ::nlohmann::to_json(j, std::forward<ValueType>(val));
+    }
+};
+
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/conversions/from_json.hpp>
+
+// #include <nlohmann/detail/conversions/to_json.hpp>
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/input/binary_reader.hpp>
+
+
+#include <algorithm> // generate_n
+#include <array> // array
+#include <cassert> // assert
+#include <cmath> // ldexp
+#include <cstddef> // size_t
+#include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
+#include <cstdio> // snprintf
+#include <cstring> // memcpy
+#include <iterator> // back_inserter
+#include <limits> // numeric_limits
+#include <string> // char_traits, string
+#include <utility> // make_pair, move
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/input/input_adapters.hpp>
+
+
+#include <array> // array
+#include <cassert> // assert
+#include <cstddef> // size_t
+#include <cstdio> //FILE *
+#include <cstring> // strlen
+#include <istream> // istream
+#include <iterator> // begin, end, iterator_traits, random_access_iterator_tag, distance, next
+#include <memory> // shared_ptr, make_shared, addressof
+#include <numeric> // accumulate
+#include <string> // string, char_traits
+#include <type_traits> // enable_if, is_base_of, is_pointer, is_integral, remove_pointer
+#include <utility> // pair, declval
+
+// #include <nlohmann/detail/iterators/iterator_traits.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+/// the supported input formats
+enum class input_format_t { json, cbor, msgpack, ubjson, bson };
+
+////////////////////
+// input adapters //
+////////////////////
+
+/*!
+@brief abstract input adapter interface
+
+Produces a stream of std::char_traits<char>::int_type characters from a
+std::istream, a buffer, or some other input type. Accepts the return of
+exactly one non-EOF character for future input. The int_type characters
+returned consist of all valid char values as positive values (typically
+unsigned char), plus an EOF value outside that range, specified by the value
+of the function std::char_traits<char>::eof(). This value is typically -1, but
+could be any arbitrary value which is not a valid char value.
+*/
+struct input_adapter_protocol
+{
+    /// get a character [0,255] or std::char_traits<char>::eof().
+    virtual std::char_traits<char>::int_type get_character() = 0;
+    virtual ~input_adapter_protocol() = default;
+};
+
+/// a type to simplify interfaces
+using input_adapter_t = std::shared_ptr<input_adapter_protocol>;
+
+/*!
+Input adapter for stdio file access. This adapter read only 1 byte and do not use any
+ buffer. This adapter is a very low level adapter.
+*/
+class file_input_adapter : public input_adapter_protocol
+{
+  public:
+    JSON_HEDLEY_NON_NULL(2)
+    explicit file_input_adapter(std::FILE* f)  noexcept
+        : m_file(f)
+    {}
+
+    // make class move-only
+    file_input_adapter(const file_input_adapter&) = delete;
+    file_input_adapter(file_input_adapter&&) = default;
+    file_input_adapter& operator=(const file_input_adapter&) = delete;
+    file_input_adapter& operator=(file_input_adapter&&) = default;
+    ~file_input_adapter() override = default;
+
+    std::char_traits<char>::int_type get_character() noexcept override
+    {
+        return std::fgetc(m_file);
+    }
+
+  private:
+    /// the file pointer to read from
+    std::FILE* m_file;
+};
+
+
+/*!
+Input adapter for a (caching) istream. Ignores a UFT Byte Order Mark at
+beginning of input. Does not support changing the underlying std::streambuf
+in mid-input. Maintains underlying std::istream and std::streambuf to support
+subsequent use of standard std::istream operations to process any input
+characters following those used in parsing the JSON input.  Clears the
+std::istream flags; any input errors (e.g., EOF) will be detected by the first
+subsequent call for input from the std::istream.
+*/
+class input_stream_adapter : public input_adapter_protocol
+{
+  public:
+    ~input_stream_adapter() override
+    {
+        // clear stream flags; we use underlying streambuf I/O, do not
+        // maintain ifstream flags, except eof
+        is.clear(is.rdstate() & std::ios::eofbit);
+    }
+
+    explicit input_stream_adapter(std::istream& i)
+        : is(i), sb(*i.rdbuf())
+    {}
+
+    // delete because of pointer members
+    input_stream_adapter(const input_stream_adapter&) = delete;
+    input_stream_adapter& operator=(input_stream_adapter&) = delete;
+    input_stream_adapter(input_stream_adapter&&) = delete;
+    input_stream_adapter& operator=(input_stream_adapter&&) = delete;
+
+    // std::istream/std::streambuf use std::char_traits<char>::to_int_type, to
+    // ensure that std::char_traits<char>::eof() and the character 0xFF do not
+    // end up as the same value, eg. 0xFFFFFFFF.
+    std::char_traits<char>::int_type get_character() override
+    {
+        auto res = sb.sbumpc();
+        // set eof manually, as we don't use the istream interface.
+        if (res == EOF)
+        {
+            is.clear(is.rdstate() | std::ios::eofbit);
+        }
+        return res;
+    }
+
+  private:
+    /// the associated input stream
+    std::istream& is;
+    std::streambuf& sb;
+};
+
+/// input adapter for buffer input
+class input_buffer_adapter : public input_adapter_protocol
+{
+  public:
+    JSON_HEDLEY_NON_NULL(2)
+    input_buffer_adapter(const char* b, const std::size_t l) noexcept
+        : cursor(b), limit(b + l)
+    {}
+
+    // delete because of pointer members
+    input_buffer_adapter(const input_buffer_adapter&) = delete;
+    input_buffer_adapter& operator=(input_buffer_adapter&) = delete;
+    input_buffer_adapter(input_buffer_adapter&&) = delete;
+    input_buffer_adapter& operator=(input_buffer_adapter&&) = delete;
+    ~input_buffer_adapter() override = default;
+
+    std::char_traits<char>::int_type get_character() noexcept override
+    {
+        if (JSON_HEDLEY_LIKELY(cursor < limit))
+        {
+            return std::char_traits<char>::to_int_type(*(cursor++));
+        }
+
+        return std::char_traits<char>::eof();
+    }
+
+  private:
+    /// pointer to the current character
+    const char* cursor;
+    /// pointer past the last character
+    const char* const limit;
+};
+
+template<typename WideStringType, size_t T>
+struct wide_string_input_helper
+{
+    // UTF-32
+    static void fill_buffer(const WideStringType& str,
+                            size_t& current_wchar,
+                            std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
+                            size_t& utf8_bytes_index,
+                            size_t& utf8_bytes_filled)
+    {
+        utf8_bytes_index = 0;
+
+        if (current_wchar == str.size())
+        {
+            utf8_bytes[0] = std::char_traits<char>::eof();
+            utf8_bytes_filled = 1;
+        }
+        else
+        {
+            // get the current character
+            const auto wc = static_cast<unsigned int>(str[current_wchar++]);
+
+            // UTF-32 to UTF-8 encoding
+            if (wc < 0x80)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
+                utf8_bytes_filled = 1;
+            }
+            else if (wc <= 0x7FF)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xC0u | ((wc >> 6u) & 0x1Fu));
+                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (wc & 0x3Fu));
+                utf8_bytes_filled = 2;
+            }
+            else if (wc <= 0xFFFF)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xE0u | ((wc >> 12u) & 0x0Fu));
+                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((wc >> 6u) & 0x3Fu));
+                utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | (wc & 0x3Fu));
+                utf8_bytes_filled = 3;
+            }
+            else if (wc <= 0x10FFFF)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | ((wc >> 18u) & 0x07u));
+                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((wc >> 12u) & 0x3Fu));
+                utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((wc >> 6u) & 0x3Fu));
+                utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (wc & 0x3Fu));
+                utf8_bytes_filled = 4;
+            }
+            else
+            {
+                // unknown character
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
+                utf8_bytes_filled = 1;
+            }
+        }
+    }
+};
+
+template<typename WideStringType>
+struct wide_string_input_helper<WideStringType, 2>
+{
+    // UTF-16
+    static void fill_buffer(const WideStringType& str,
+                            size_t& current_wchar,
+                            std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
+                            size_t& utf8_bytes_index,
+                            size_t& utf8_bytes_filled)
+    {
+        utf8_bytes_index = 0;
+
+        if (current_wchar == str.size())
+        {
+            utf8_bytes[0] = std::char_traits<char>::eof();
+            utf8_bytes_filled = 1;
+        }
+        else
+        {
+            // get the current character
+            const auto wc = static_cast<unsigned int>(str[current_wchar++]);
+
+            // UTF-16 to UTF-8 encoding
+            if (wc < 0x80)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
+                utf8_bytes_filled = 1;
+            }
+            else if (wc <= 0x7FF)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xC0u | ((wc >> 6u)));
+                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (wc & 0x3Fu));
+                utf8_bytes_filled = 2;
+            }
+            else if (0xD800 > wc or wc >= 0xE000)
+            {
+                utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xE0u | ((wc >> 12u)));
+                utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((wc >> 6u) & 0x3Fu));
+                utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | (wc & 0x3Fu));
+                utf8_bytes_filled = 3;
+            }
+            else
+            {
+                if (current_wchar < str.size())
+                {
+                    const auto wc2 = static_cast<unsigned int>(str[current_wchar++]);
+                    const auto charcode = 0x10000u + (((wc & 0x3FFu) << 10u) | (wc2 & 0x3FFu));
+                    utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | (charcode >> 18u));
+                    utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 12u) & 0x3Fu));
+                    utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 6u) & 0x3Fu));
+                    utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (charcode & 0x3Fu));
+                    utf8_bytes_filled = 4;
+                }
+                else
+                {
+                    // unknown character
+                    ++current_wchar;
+                    utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
+                    utf8_bytes_filled = 1;
+                }
+            }
+        }
+    }
+};
+
+template<typename WideStringType>
+class wide_string_input_adapter : public input_adapter_protocol
+{
+  public:
+    explicit wide_string_input_adapter(const WideStringType& w) noexcept
+        : str(w)
+    {}
+
+    std::char_traits<char>::int_type get_character() noexcept override
+    {
+        // check if buffer needs to be filled
+        if (utf8_bytes_index == utf8_bytes_filled)
+        {
+            fill_buffer<sizeof(typename WideStringType::value_type)>();
+
+            assert(utf8_bytes_filled > 0);
+            assert(utf8_bytes_index == 0);
+        }
+
+        // use buffer
+        assert(utf8_bytes_filled > 0);
+        assert(utf8_bytes_index < utf8_bytes_filled);
+        return utf8_bytes[utf8_bytes_index++];
+    }
+
+  private:
+    template<size_t T>
+    void fill_buffer()
+    {
+        wide_string_input_helper<WideStringType, T>::fill_buffer(str, current_wchar, utf8_bytes, utf8_bytes_index, utf8_bytes_filled);
+    }
+
+    /// the wstring to process
+    const WideStringType& str;
+
+    /// index of the current wchar in str
+    std::size_t current_wchar = 0;
+
+    /// a buffer for UTF-8 bytes
+    std::array<std::char_traits<char>::int_type, 4> utf8_bytes = {{0, 0, 0, 0}};
+
+    /// index to the utf8_codes array for the next valid byte
+    std::size_t utf8_bytes_index = 0;
+    /// number of valid bytes in the utf8_codes array
+    std::size_t utf8_bytes_filled = 0;
+};
+
+class input_adapter
+{
+  public:
+    // native support
+    JSON_HEDLEY_NON_NULL(2)
+    input_adapter(std::FILE* file)
+        : ia(std::make_shared<file_input_adapter>(file)) {}
+    /// input adapter for input stream
+    input_adapter(std::istream& i)
+        : ia(std::make_shared<input_stream_adapter>(i)) {}
+
+    /// input adapter for input stream
+    input_adapter(std::istream&& i)
+        : ia(std::make_shared<input_stream_adapter>(i)) {}
+
+    input_adapter(const std::wstring& ws)
+        : ia(std::make_shared<wide_string_input_adapter<std::wstring>>(ws)) {}
+
+    input_adapter(const std::u16string& ws)
+        : ia(std::make_shared<wide_string_input_adapter<std::u16string>>(ws)) {}
+
+    input_adapter(const std::u32string& ws)
+        : ia(std::make_shared<wide_string_input_adapter<std::u32string>>(ws)) {}
+
+    /// input adapter for buffer
+    template<typename CharT,
+             typename std::enable_if<
+                 std::is_pointer<CharT>::value and
+                 std::is_integral<typename std::remove_pointer<CharT>::type>::value and
+                 sizeof(typename std::remove_pointer<CharT>::type) == 1,
+                 int>::type = 0>
+    input_adapter(CharT b, std::size_t l)
+        : ia(std::make_shared<input_buffer_adapter>(reinterpret_cast<const char*>(b), l)) {}
+
+    // derived support
+
+    /// input adapter for string literal
+    template<typename CharT,
+             typename std::enable_if<
+                 std::is_pointer<CharT>::value and
+                 std::is_integral<typename std::remove_pointer<CharT>::type>::value and
+                 sizeof(typename std::remove_pointer<CharT>::type) == 1,
+                 int>::type = 0>
+    input_adapter(CharT b)
+        : input_adapter(reinterpret_cast<const char*>(b),
+                        std::strlen(reinterpret_cast<const char*>(b))) {}
+
+    /// input adapter for iterator range with contiguous storage
+    template<class IteratorType,
+             typename std::enable_if<
+                 std::is_same<typename iterator_traits<IteratorType>::iterator_category, std::random_access_iterator_tag>::value,
+                 int>::type = 0>
+    input_adapter(IteratorType first, IteratorType last)
+    {
+#ifndef NDEBUG
+        // assertion to check that the iterator range is indeed contiguous,
+        // see http://stackoverflow.com/a/35008842/266378 for more discussion
+        const auto is_contiguous = std::accumulate(
+                                       first, last, std::pair<bool, int>(true, 0),
+                                       [&first](std::pair<bool, int> res, decltype(*first) val)
+        {
+            res.first &= (val == *(std::next(std::addressof(*first), res.second++)));
+            return res;
+        }).first;
+        assert(is_contiguous);
+#endif
+
+        // assertion to check that each element is 1 byte long
+        static_assert(
+            sizeof(typename iterator_traits<IteratorType>::value_type) == 1,
+            "each element in the iterator range must have the size of 1 byte");
+
+        const auto len = static_cast<size_t>(std::distance(first, last));
+        if (JSON_HEDLEY_LIKELY(len > 0))
+        {
+            // there is at least one element: use the address of first
+            ia = std::make_shared<input_buffer_adapter>(reinterpret_cast<const char*>(&(*first)), len);
+        }
+        else
+        {
+            // the address of first cannot be used: use nullptr
+            ia = std::make_shared<input_buffer_adapter>(nullptr, len);
+        }
+    }
+
+    /// input adapter for array
+    template<class T, std::size_t N>
+    input_adapter(T (&array)[N])
+        : input_adapter(std::begin(array), std::end(array)) {}
+
+    /// input adapter for contiguous container
+    template<class ContiguousContainer, typename
+             std::enable_if<not std::is_pointer<ContiguousContainer>::value and
+                            std::is_base_of<std::random_access_iterator_tag, typename iterator_traits<decltype(std::begin(std::declval<ContiguousContainer const>()))>::iterator_category>::value,
+                            int>::type = 0>
+    input_adapter(const ContiguousContainer& c)
+        : input_adapter(std::begin(c), std::end(c)) {}
+
+    operator input_adapter_t()
+    {
+        return ia;
+    }
+
+  private:
+    /// the actual adapter
+    input_adapter_t ia = nullptr;
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/input/json_sax.hpp>
+
+
+#include <cassert> // assert
+#include <cstddef>
+#include <string> // string
+#include <utility> // move
+#include <vector> // vector
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+namespace nlohmann
+{
+
+/*!
+@brief SAX interface
+
+This class describes the SAX interface used by @ref nlohmann::json::sax_parse.
+Each function is called in different situations while the input is parsed. The
+boolean return value informs the parser whether to continue processing the
+input.
+*/
+template<typename BasicJsonType>
+struct json_sax
+{
+    /// type for (signed) integers
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    /// type for unsigned integers
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    /// type for floating-point numbers
+    using number_float_t = typename BasicJsonType::number_float_t;
+    /// type for strings
+    using string_t = typename BasicJsonType::string_t;
+
+    /*!
+    @brief a null value was read
+    @return whether parsing should proceed
+    */
+    virtual bool null() = 0;
+
+    /*!
+    @brief a boolean value was read
+    @param[in] val  boolean value
+    @return whether parsing should proceed
+    */
+    virtual bool boolean(bool val) = 0;
+
+    /*!
+    @brief an integer number was read
+    @param[in] val  integer value
+    @return whether parsing should proceed
+    */
+    virtual bool number_integer(number_integer_t val) = 0;
+
+    /*!
+    @brief an unsigned integer number was read
+    @param[in] val  unsigned integer value
+    @return whether parsing should proceed
+    */
+    virtual bool number_unsigned(number_unsigned_t val) = 0;
+
+    /*!
+    @brief an floating-point number was read
+    @param[in] val  floating-point value
+    @param[in] s    raw token value
+    @return whether parsing should proceed
+    */
+    virtual bool number_float(number_float_t val, const string_t& s) = 0;
+
+    /*!
+    @brief a string was read
+    @param[in] val  string value
+    @return whether parsing should proceed
+    @note It is safe to move the passed string.
+    */
+    virtual bool string(string_t& val) = 0;
+
+    /*!
+    @brief the beginning of an object was read
+    @param[in] elements  number of object elements or -1 if unknown
+    @return whether parsing should proceed
+    @note binary formats may report the number of elements
+    */
+    virtual bool start_object(std::size_t elements) = 0;
+
+    /*!
+    @brief an object key was read
+    @param[in] val  object key
+    @return whether parsing should proceed
+    @note It is safe to move the passed string.
+    */
+    virtual bool key(string_t& val) = 0;
+
+    /*!
+    @brief the end of an object was read
+    @return whether parsing should proceed
+    */
+    virtual bool end_object() = 0;
+
+    /*!
+    @brief the beginning of an array was read
+    @param[in] elements  number of array elements or -1 if unknown
+    @return whether parsing should proceed
+    @note binary formats may report the number of elements
+    */
+    virtual bool start_array(std::size_t elements) = 0;
+
+    /*!
+    @brief the end of an array was read
+    @return whether parsing should proceed
+    */
+    virtual bool end_array() = 0;
+
+    /*!
+    @brief a parse error occurred
+    @param[in] position    the position in the input where the error occurs
+    @param[in] last_token  the last read token
+    @param[in] ex          an exception object describing the error
+    @return whether parsing should proceed (must return false)
+    */
+    virtual bool parse_error(std::size_t position,
+                             const std::string& last_token,
+                             const detail::exception& ex) = 0;
+
+    virtual ~json_sax() = default;
+};
+
+
+namespace detail
+{
+/*!
+@brief SAX implementation to create a JSON value from SAX events
+
+This class implements the @ref json_sax interface and processes the SAX events
+to create a JSON value which makes it basically a DOM parser. The structure or
+hierarchy of the JSON value is managed by the stack `ref_stack` which contains
+a pointer to the respective array or object for each recursion depth.
+
+After successful parsing, the value that is passed by reference to the
+constructor contains the parsed value.
+
+@tparam BasicJsonType  the JSON type
+*/
+template<typename BasicJsonType>
+class json_sax_dom_parser
+{
+  public:
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+
+    /*!
+    @param[in, out] r  reference to a JSON value that is manipulated while
+                       parsing
+    @param[in] allow_exceptions_  whether parse errors yield exceptions
+    */
+    explicit json_sax_dom_parser(BasicJsonType& r, const bool allow_exceptions_ = true)
+        : root(r), allow_exceptions(allow_exceptions_)
+    {}
+
+    // make class move-only
+    json_sax_dom_parser(const json_sax_dom_parser&) = delete;
+    json_sax_dom_parser(json_sax_dom_parser&&) = default;
+    json_sax_dom_parser& operator=(const json_sax_dom_parser&) = delete;
+    json_sax_dom_parser& operator=(json_sax_dom_parser&&) = default;
+    ~json_sax_dom_parser() = default;
+
+    bool null()
+    {
+        handle_value(nullptr);
+        return true;
+    }
+
+    bool boolean(bool val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_integer(number_integer_t val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_unsigned(number_unsigned_t val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_float(number_float_t val, const string_t& /*unused*/)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool string(string_t& val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool start_object(std::size_t len)
+    {
+        ref_stack.push_back(handle_value(BasicJsonType::value_t::object));
+
+        if (JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) and len > ref_stack.back()->max_size()))
+        {
+            JSON_THROW(out_of_range::create(408,
+                                            "excessive object size: " + std::to_string(len)));
+        }
+
+        return true;
+    }
+
+    bool key(string_t& val)
+    {
+        // add null at given key and store the reference for later
+        object_element = &(ref_stack.back()->m_value.object->operator[](val));
+        return true;
+    }
+
+    bool end_object()
+    {
+        ref_stack.pop_back();
+        return true;
+    }
+
+    bool start_array(std::size_t len)
+    {
+        ref_stack.push_back(handle_value(BasicJsonType::value_t::array));
+
+        if (JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) and len > ref_stack.back()->max_size()))
+        {
+            JSON_THROW(out_of_range::create(408,
+                                            "excessive array size: " + std::to_string(len)));
+        }
+
+        return true;
+    }
+
+    bool end_array()
+    {
+        ref_stack.pop_back();
+        return true;
+    }
+
+    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
+                     const detail::exception& ex)
+    {
+        errored = true;
+        if (allow_exceptions)
+        {
+            // determine the proper exception type from the id
+            switch ((ex.id / 100) % 100)
+            {
+                case 1:
+                    JSON_THROW(*static_cast<const detail::parse_error*>(&ex));
+                case 4:
+                    JSON_THROW(*static_cast<const detail::out_of_range*>(&ex));
+                // LCOV_EXCL_START
+                case 2:
+                    JSON_THROW(*static_cast<const detail::invalid_iterator*>(&ex));
+                case 3:
+                    JSON_THROW(*static_cast<const detail::type_error*>(&ex));
+                case 5:
+                    JSON_THROW(*static_cast<const detail::other_error*>(&ex));
+                default:
+                    assert(false);
+                    // LCOV_EXCL_STOP
+            }
+        }
+        return false;
+    }
+
+    constexpr bool is_errored() const
+    {
+        return errored;
+    }
+
+  private:
+    /*!
+    @invariant If the ref stack is empty, then the passed value will be the new
+               root.
+    @invariant If the ref stack contains a value, then it is an array or an
+               object to which we can add elements
+    */
+    template<typename Value>
+    JSON_HEDLEY_RETURNS_NON_NULL
+    BasicJsonType* handle_value(Value&& v)
+    {
+        if (ref_stack.empty())
+        {
+            root = BasicJsonType(std::forward<Value>(v));
+            return &root;
+        }
+
+        assert(ref_stack.back()->is_array() or ref_stack.back()->is_object());
+
+        if (ref_stack.back()->is_array())
+        {
+            ref_stack.back()->m_value.array->emplace_back(std::forward<Value>(v));
+            return &(ref_stack.back()->m_value.array->back());
+        }
+
+        assert(ref_stack.back()->is_object());
+        assert(object_element);
+        *object_element = BasicJsonType(std::forward<Value>(v));
+        return object_element;
+    }
+
+    /// the parsed JSON value
+    BasicJsonType& root;
+    /// stack to model hierarchy of values
+    std::vector<BasicJsonType*> ref_stack {};
+    /// helper to hold the reference for the next object element
+    BasicJsonType* object_element = nullptr;
+    /// whether a syntax error occurred
+    bool errored = false;
+    /// whether to throw exceptions in case of errors
+    const bool allow_exceptions = true;
+};
+
+template<typename BasicJsonType>
+class json_sax_dom_callback_parser
+{
+  public:
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using parser_callback_t = typename BasicJsonType::parser_callback_t;
+    using parse_event_t = typename BasicJsonType::parse_event_t;
+
+    json_sax_dom_callback_parser(BasicJsonType& r,
+                                 const parser_callback_t cb,
+                                 const bool allow_exceptions_ = true)
+        : root(r), callback(cb), allow_exceptions(allow_exceptions_)
+    {
+        keep_stack.push_back(true);
+    }
+
+    // make class move-only
+    json_sax_dom_callback_parser(const json_sax_dom_callback_parser&) = delete;
+    json_sax_dom_callback_parser(json_sax_dom_callback_parser&&) = default;
+    json_sax_dom_callback_parser& operator=(const json_sax_dom_callback_parser&) = delete;
+    json_sax_dom_callback_parser& operator=(json_sax_dom_callback_parser&&) = default;
+    ~json_sax_dom_callback_parser() = default;
+
+    bool null()
+    {
+        handle_value(nullptr);
+        return true;
+    }
+
+    bool boolean(bool val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_integer(number_integer_t val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_unsigned(number_unsigned_t val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool number_float(number_float_t val, const string_t& /*unused*/)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool string(string_t& val)
+    {
+        handle_value(val);
+        return true;
+    }
+
+    bool start_object(std::size_t len)
+    {
+        // check callback for object start
+        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::object_start, discarded);
+        keep_stack.push_back(keep);
+
+        auto val = handle_value(BasicJsonType::value_t::object, true);
+        ref_stack.push_back(val.second);
+
+        // check object limit
+        if (ref_stack.back() and JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) and len > ref_stack.back()->max_size()))
+        {
+            JSON_THROW(out_of_range::create(408, "excessive object size: " + std::to_string(len)));
+        }
+
+        return true;
+    }
+
+    bool key(string_t& val)
+    {
+        BasicJsonType k = BasicJsonType(val);
+
+        // check callback for key
+        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::key, k);
+        key_keep_stack.push_back(keep);
+
+        // add discarded value at given key and store the reference for later
+        if (keep and ref_stack.back())
+        {
+            object_element = &(ref_stack.back()->m_value.object->operator[](val) = discarded);
+        }
+
+        return true;
+    }
+
+    bool end_object()
+    {
+        if (ref_stack.back() and not callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::object_end, *ref_stack.back()))
+        {
+            // discard object
+            *ref_stack.back() = discarded;
+        }
+
+        assert(not ref_stack.empty());
+        assert(not keep_stack.empty());
+        ref_stack.pop_back();
+        keep_stack.pop_back();
+
+        if (not ref_stack.empty() and ref_stack.back() and ref_stack.back()->is_object())
+        {
+            // remove discarded value
+            for (auto it = ref_stack.back()->begin(); it != ref_stack.back()->end(); ++it)
+            {
+                if (it->is_discarded())
+                {
+                    ref_stack.back()->erase(it);
+                    break;
+                }
+            }
+        }
+
+        return true;
+    }
+
+    bool start_array(std::size_t len)
+    {
+        const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::array_start, discarded);
+        keep_stack.push_back(keep);
+
+        auto val = handle_value(BasicJsonType::value_t::array, true);
+        ref_stack.push_back(val.second);
+
+        // check array limit
+        if (ref_stack.back() and JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) and len > ref_stack.back()->max_size()))
+        {
+            JSON_THROW(out_of_range::create(408, "excessive array size: " + std::to_string(len)));
+        }
+
+        return true;
+    }
+
+    bool end_array()
+    {
+        bool keep = true;
+
+        if (ref_stack.back())
+        {
+            keep = callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::array_end, *ref_stack.back());
+            if (not keep)
+            {
+                // discard array
+                *ref_stack.back() = discarded;
+            }
+        }
+
+        assert(not ref_stack.empty());
+        assert(not keep_stack.empty());
+        ref_stack.pop_back();
+        keep_stack.pop_back();
+
+        // remove discarded value
+        if (not keep and not ref_stack.empty() and ref_stack.back()->is_array())
+        {
+            ref_stack.back()->m_value.array->pop_back();
+        }
+
+        return true;
+    }
+
+    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
+                     const detail::exception& ex)
+    {
+        errored = true;
+        if (allow_exceptions)
+        {
+            // determine the proper exception type from the id
+            switch ((ex.id / 100) % 100)
+            {
+                case 1:
+                    JSON_THROW(*static_cast<const detail::parse_error*>(&ex));
+                case 4:
+                    JSON_THROW(*static_cast<const detail::out_of_range*>(&ex));
+                // LCOV_EXCL_START
+                case 2:
+                    JSON_THROW(*static_cast<const detail::invalid_iterator*>(&ex));
+                case 3:
+                    JSON_THROW(*static_cast<const detail::type_error*>(&ex));
+                case 5:
+                    JSON_THROW(*static_cast<const detail::other_error*>(&ex));
+                default:
+                    assert(false);
+                    // LCOV_EXCL_STOP
+            }
+        }
+        return false;
+    }
+
+    constexpr bool is_errored() const
+    {
+        return errored;
+    }
+
+  private:
+    /*!
+    @param[in] v  value to add to the JSON value we build during parsing
+    @param[in] skip_callback  whether we should skip calling the callback
+               function; this is required after start_array() and
+               start_object() SAX events, because otherwise we would call the
+               callback function with an empty array or object, respectively.
+
+    @invariant If the ref stack is empty, then the passed value will be the new
+               root.
+    @invariant If the ref stack contains a value, then it is an array or an
+               object to which we can add elements
+
+    @return pair of boolean (whether value should be kept) and pointer (to the
+            passed value in the ref_stack hierarchy; nullptr if not kept)
+    */
+    template<typename Value>
+    std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
+    {
+        assert(not keep_stack.empty());
+
+        // do not handle this value if we know it would be added to a discarded
+        // container
+        if (not keep_stack.back())
+        {
+            return {false, nullptr};
+        }
+
+        // create value
+        auto value = BasicJsonType(std::forward<Value>(v));
+
+        // check callback
+        const bool keep = skip_callback or callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
+
+        // do not handle this value if we just learnt it shall be discarded
+        if (not keep)
+        {
+            return {false, nullptr};
+        }
+
+        if (ref_stack.empty())
+        {
+            root = std::move(value);
+            return {true, &root};
+        }
+
+        // skip this value if we already decided to skip the parent
+        // (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
+        if (not ref_stack.back())
+        {
+            return {false, nullptr};
+        }
+
+        // we now only expect arrays and objects
+        assert(ref_stack.back()->is_array() or ref_stack.back()->is_object());
+
+        // array
+        if (ref_stack.back()->is_array())
+        {
+            ref_stack.back()->m_value.array->push_back(std::move(value));
+            return {true, &(ref_stack.back()->m_value.array->back())};
+        }
+
+        // object
+        assert(ref_stack.back()->is_object());
+        // check if we should store an element for the current key
+        assert(not key_keep_stack.empty());
+        const bool store_element = key_keep_stack.back();
+        key_keep_stack.pop_back();
+
+        if (not store_element)
+        {
+            return {false, nullptr};
+        }
+
+        assert(object_element);
+        *object_element = std::move(value);
+        return {true, object_element};
+    }
+
+    /// the parsed JSON value
+    BasicJsonType& root;
+    /// stack to model hierarchy of values
+    std::vector<BasicJsonType*> ref_stack {};
+    /// stack to manage which values to keep
+    std::vector<bool> keep_stack {};
+    /// stack to manage which object keys to keep
+    std::vector<bool> key_keep_stack {};
+    /// helper to hold the reference for the next object element
+    BasicJsonType* object_element = nullptr;
+    /// whether a syntax error occurred
+    bool errored = false;
+    /// callback function
+    const parser_callback_t callback = nullptr;
+    /// whether to throw exceptions in case of errors
+    const bool allow_exceptions = true;
+    /// a discarded value for the callback
+    BasicJsonType discarded = BasicJsonType::value_t::discarded;
+};
+
+template<typename BasicJsonType>
+class json_sax_acceptor
+{
+  public:
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+
+    bool null()
+    {
+        return true;
+    }
+
+    bool boolean(bool /*unused*/)
+    {
+        return true;
+    }
+
+    bool number_integer(number_integer_t /*unused*/)
+    {
+        return true;
+    }
+
+    bool number_unsigned(number_unsigned_t /*unused*/)
+    {
+        return true;
+    }
+
+    bool number_float(number_float_t /*unused*/, const string_t& /*unused*/)
+    {
+        return true;
+    }
+
+    bool string(string_t& /*unused*/)
+    {
+        return true;
+    }
+
+    bool start_object(std::size_t  /*unused*/ = std::size_t(-1))
+    {
+        return true;
+    }
+
+    bool key(string_t& /*unused*/)
+    {
+        return true;
+    }
+
+    bool end_object()
+    {
+        return true;
+    }
+
+    bool start_array(std::size_t  /*unused*/ = std::size_t(-1))
+    {
+        return true;
+    }
+
+    bool end_array()
+    {
+        return true;
+    }
+
+    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/, const detail::exception& /*unused*/)
+    {
+        return false;
+    }
+};
+}  // namespace detail
+
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/is_sax.hpp>
+
+
+#include <cstdint> // size_t
+#include <utility> // declval
+#include <string> // string
+
+// #include <nlohmann/detail/meta/detected.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+template <typename T>
+using null_function_t = decltype(std::declval<T&>().null());
+
+template <typename T>
+using boolean_function_t =
+    decltype(std::declval<T&>().boolean(std::declval<bool>()));
+
+template <typename T, typename Integer>
+using number_integer_function_t =
+    decltype(std::declval<T&>().number_integer(std::declval<Integer>()));
+
+template <typename T, typename Unsigned>
+using number_unsigned_function_t =
+    decltype(std::declval<T&>().number_unsigned(std::declval<Unsigned>()));
+
+template <typename T, typename Float, typename String>
+using number_float_function_t = decltype(std::declval<T&>().number_float(
+                                    std::declval<Float>(), std::declval<const String&>()));
+
+template <typename T, typename String>
+using string_function_t =
+    decltype(std::declval<T&>().string(std::declval<String&>()));
+
+template <typename T>
+using start_object_function_t =
+    decltype(std::declval<T&>().start_object(std::declval<std::size_t>()));
+
+template <typename T, typename String>
+using key_function_t =
+    decltype(std::declval<T&>().key(std::declval<String&>()));
+
+template <typename T>
+using end_object_function_t = decltype(std::declval<T&>().end_object());
+
+template <typename T>
+using start_array_function_t =
+    decltype(std::declval<T&>().start_array(std::declval<std::size_t>()));
+
+template <typename T>
+using end_array_function_t = decltype(std::declval<T&>().end_array());
+
+template <typename T, typename Exception>
+using parse_error_function_t = decltype(std::declval<T&>().parse_error(
+        std::declval<std::size_t>(), std::declval<const std::string&>(),
+        std::declval<const Exception&>()));
+
+template <typename SAX, typename BasicJsonType>
+struct is_sax
+{
+  private:
+    static_assert(is_basic_json<BasicJsonType>::value,
+                  "BasicJsonType must be of type basic_json<...>");
+
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using exception_t = typename BasicJsonType::exception;
+
+  public:
+    static constexpr bool value =
+        is_detected_exact<bool, null_function_t, SAX>::value &&
+        is_detected_exact<bool, boolean_function_t, SAX>::value &&
+        is_detected_exact<bool, number_integer_function_t, SAX,
+        number_integer_t>::value &&
+        is_detected_exact<bool, number_unsigned_function_t, SAX,
+        number_unsigned_t>::value &&
+        is_detected_exact<bool, number_float_function_t, SAX, number_float_t,
+        string_t>::value &&
+        is_detected_exact<bool, string_function_t, SAX, string_t>::value &&
+        is_detected_exact<bool, start_object_function_t, SAX>::value &&
+        is_detected_exact<bool, key_function_t, SAX, string_t>::value &&
+        is_detected_exact<bool, end_object_function_t, SAX>::value &&
+        is_detected_exact<bool, start_array_function_t, SAX>::value &&
+        is_detected_exact<bool, end_array_function_t, SAX>::value &&
+        is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value;
+};
+
+template <typename SAX, typename BasicJsonType>
+struct is_sax_static_asserts
+{
+  private:
+    static_assert(is_basic_json<BasicJsonType>::value,
+                  "BasicJsonType must be of type basic_json<...>");
+
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using exception_t = typename BasicJsonType::exception;
+
+  public:
+    static_assert(is_detected_exact<bool, null_function_t, SAX>::value,
+                  "Missing/invalid function: bool null()");
+    static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
+                  "Missing/invalid function: bool boolean(bool)");
+    static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
+                  "Missing/invalid function: bool boolean(bool)");
+    static_assert(
+        is_detected_exact<bool, number_integer_function_t, SAX,
+        number_integer_t>::value,
+        "Missing/invalid function: bool number_integer(number_integer_t)");
+    static_assert(
+        is_detected_exact<bool, number_unsigned_function_t, SAX,
+        number_unsigned_t>::value,
+        "Missing/invalid function: bool number_unsigned(number_unsigned_t)");
+    static_assert(is_detected_exact<bool, number_float_function_t, SAX,
+                  number_float_t, string_t>::value,
+                  "Missing/invalid function: bool number_float(number_float_t, const string_t&)");
+    static_assert(
+        is_detected_exact<bool, string_function_t, SAX, string_t>::value,
+        "Missing/invalid function: bool string(string_t&)");
+    static_assert(is_detected_exact<bool, start_object_function_t, SAX>::value,
+                  "Missing/invalid function: bool start_object(std::size_t)");
+    static_assert(is_detected_exact<bool, key_function_t, SAX, string_t>::value,
+                  "Missing/invalid function: bool key(string_t&)");
+    static_assert(is_detected_exact<bool, end_object_function_t, SAX>::value,
+                  "Missing/invalid function: bool end_object()");
+    static_assert(is_detected_exact<bool, start_array_function_t, SAX>::value,
+                  "Missing/invalid function: bool start_array(std::size_t)");
+    static_assert(is_detected_exact<bool, end_array_function_t, SAX>::value,
+                  "Missing/invalid function: bool end_array()");
+    static_assert(
+        is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value,
+        "Missing/invalid function: bool parse_error(std::size_t, const "
+        "std::string&, const exception&)");
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+///////////////////
+// binary reader //
+///////////////////
+
+/*!
+@brief deserialization of CBOR, MessagePack, and UBJSON values
+*/
+template<typename BasicJsonType, typename SAX = json_sax_dom_parser<BasicJsonType>>
+class binary_reader
+{
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using json_sax_t = SAX;
+
+  public:
+    /*!
+    @brief create a binary reader
+
+    @param[in] adapter  input adapter to read from
+    */
+    explicit binary_reader(input_adapter_t adapter) : ia(std::move(adapter))
+    {
+        (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
+        assert(ia);
+    }
+
+    // make class move-only
+    binary_reader(const binary_reader&) = delete;
+    binary_reader(binary_reader&&) = default;
+    binary_reader& operator=(const binary_reader&) = delete;
+    binary_reader& operator=(binary_reader&&) = default;
+    ~binary_reader() = default;
+
+    /*!
+    @param[in] format  the binary format to parse
+    @param[in] sax_    a SAX event processor
+    @param[in] strict  whether to expect the input to be consumed completed
+
+    @return
+    */
+    JSON_HEDLEY_NON_NULL(3)
+    bool sax_parse(const input_format_t format,
+                   json_sax_t* sax_,
+                   const bool strict = true)
+    {
+        sax = sax_;
+        bool result = false;
+
+        switch (format)
+        {
+            case input_format_t::bson:
+                result = parse_bson_internal();
+                break;
+
+            case input_format_t::cbor:
+                result = parse_cbor_internal();
+                break;
+
+            case input_format_t::msgpack:
+                result = parse_msgpack_internal();
+                break;
+
+            case input_format_t::ubjson:
+                result = parse_ubjson_internal();
+                break;
+
+            default:            // LCOV_EXCL_LINE
+                assert(false);  // LCOV_EXCL_LINE
+        }
+
+        // strict mode: next byte must be EOF
+        if (result and strict)
+        {
+            if (format == input_format_t::ubjson)
+            {
+                get_ignore_noop();
+            }
+            else
+            {
+                get();
+            }
+
+            if (JSON_HEDLEY_UNLIKELY(current != std::char_traits<char>::eof()))
+            {
+                return sax->parse_error(chars_read, get_token_string(),
+                                        parse_error::create(110, chars_read, exception_message(format, "expected end of input; last byte: 0x" + get_token_string(), "value")));
+            }
+        }
+
+        return result;
+    }
+
+    /*!
+    @brief determine system byte order
+
+    @return true if and only if system's byte order is little endian
+
+    @note from http://stackoverflow.com/a/1001328/266378
+    */
+    static constexpr bool little_endianess(int num = 1) noexcept
+    {
+        return *reinterpret_cast<char*>(&num) == 1;
+    }
+
+  private:
+    //////////
+    // BSON //
+    //////////
+
+    /*!
+    @brief Reads in a BSON-object and passes it to the SAX-parser.
+    @return whether a valid BSON-value was passed to the SAX parser
+    */
+    bool parse_bson_internal()
+    {
+        std::int32_t document_size;
+        get_number<std::int32_t, true>(input_format_t::bson, document_size);
+
+        if (JSON_HEDLEY_UNLIKELY(not sax->start_object(std::size_t(-1))))
+        {
+            return false;
+        }
+
+        if (JSON_HEDLEY_UNLIKELY(not parse_bson_element_list(/*is_array*/false)))
+        {
+            return false;
+        }
+
+        return sax->end_object();
+    }
+
+    /*!
+    @brief Parses a C-style string from the BSON input.
+    @param[in, out] result  A reference to the string variable where the read
+                            string is to be stored.
+    @return `true` if the \x00-byte indicating the end of the string was
+             encountered before the EOF; false` indicates an unexpected EOF.
+    */
+    bool get_bson_cstr(string_t& result)
+    {
+        auto out = std::back_inserter(result);
+        while (true)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::bson, "cstring")))
+            {
+                return false;
+            }
+            if (current == 0x00)
+            {
+                return true;
+            }
+            *out++ = static_cast<char>(current);
+        }
+
+        return true;
+    }
+
+    /*!
+    @brief Parses a zero-terminated string of length @a len from the BSON
+           input.
+    @param[in] len  The length (including the zero-byte at the end) of the
+                    string to be read.
+    @param[in, out] result  A reference to the string variable where the read
+                            string is to be stored.
+    @tparam NumberType The type of the length @a len
+    @pre len >= 1
+    @return `true` if the string was successfully parsed
+    */
+    template<typename NumberType>
+    bool get_bson_string(const NumberType len, string_t& result)
+    {
+        if (JSON_HEDLEY_UNLIKELY(len < 1))
+        {
+            auto last_token = get_token_string();
+            return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::bson, "string length must be at least 1, is " + std::to_string(len), "string")));
+        }
+
+        return get_string(input_format_t::bson, len - static_cast<NumberType>(1), result) and get() != std::char_traits<char>::eof();
+    }
+
+    /*!
+    @brief Read a BSON document element of the given @a element_type.
+    @param[in] element_type The BSON element type, c.f. http://bsonspec.org/spec.html
+    @param[in] element_type_parse_position The position in the input stream,
+               where the `element_type` was read.
+    @warning Not all BSON element types are supported yet. An unsupported
+             @a element_type will give rise to a parse_error.114:
+             Unsupported BSON record type 0x...
+    @return whether a valid BSON-object/array was passed to the SAX parser
+    */
+    bool parse_bson_element_internal(const int element_type,
+                                     const std::size_t element_type_parse_position)
+    {
+        switch (element_type)
+        {
+            case 0x01: // double
+            {
+                double number;
+                return get_number<double, true>(input_format_t::bson, number) and sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 0x02: // string
+            {
+                std::int32_t len;
+                string_t value;
+                return get_number<std::int32_t, true>(input_format_t::bson, len) and get_bson_string(len, value) and sax->string(value);
+            }
+
+            case 0x03: // object
+            {
+                return parse_bson_internal();
+            }
+
+            case 0x04: // array
+            {
+                return parse_bson_array();
+            }
+
+            case 0x08: // boolean
+            {
+                return sax->boolean(get() != 0);
+            }
+
+            case 0x0A: // null
+            {
+                return sax->null();
+            }
+
+            case 0x10: // int32
+            {
+                std::int32_t value;
+                return get_number<std::int32_t, true>(input_format_t::bson, value) and sax->number_integer(value);
+            }
+
+            case 0x12: // int64
+            {
+                std::int64_t value;
+                return get_number<std::int64_t, true>(input_format_t::bson, value) and sax->number_integer(value);
+            }
+
+            default: // anything else not supported (yet)
+            {
+                std::array<char, 3> cr{{}};
+                (std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(element_type));
+                return sax->parse_error(element_type_parse_position, std::string(cr.data()), parse_error::create(114, element_type_parse_position, "Unsupported BSON record type 0x" + std::string(cr.data())));
+            }
+        }
+    }
+
+    /*!
+    @brief Read a BSON element list (as specified in the BSON-spec)
+
+    The same binary layout is used for objects and arrays, hence it must be
+    indicated with the argument @a is_array which one is expected
+    (true --> array, false --> object).
+
+    @param[in] is_array Determines if the element list being read is to be
+                        treated as an object (@a is_array == false), or as an
+                        array (@a is_array == true).
+    @return whether a valid BSON-object/array was passed to the SAX parser
+    */
+    bool parse_bson_element_list(const bool is_array)
+    {
+        string_t key;
+        while (int element_type = get())
+        {
+            if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::bson, "element list")))
+            {
+                return false;
+            }
+
+            const std::size_t element_type_parse_position = chars_read;
+            if (JSON_HEDLEY_UNLIKELY(not get_bson_cstr(key)))
+            {
+                return false;
+            }
+
+            if (not is_array and not sax->key(key))
+            {
+                return false;
+            }
+
+            if (JSON_HEDLEY_UNLIKELY(not parse_bson_element_internal(element_type, element_type_parse_position)))
+            {
+                return false;
+            }
+
+            // get_bson_cstr only appends
+            key.clear();
+        }
+
+        return true;
+    }
+
+    /*!
+    @brief Reads an array from the BSON input and passes it to the SAX-parser.
+    @return whether a valid BSON-array was passed to the SAX parser
+    */
+    bool parse_bson_array()
+    {
+        std::int32_t document_size;
+        get_number<std::int32_t, true>(input_format_t::bson, document_size);
+
+        if (JSON_HEDLEY_UNLIKELY(not sax->start_array(std::size_t(-1))))
+        {
+            return false;
+        }
+
+        if (JSON_HEDLEY_UNLIKELY(not parse_bson_element_list(/*is_array*/true)))
+        {
+            return false;
+        }
+
+        return sax->end_array();
+    }
+
+    //////////
+    // CBOR //
+    //////////
+
+    /*!
+    @param[in] get_char  whether a new character should be retrieved from the
+                         input (true, default) or whether the last read
+                         character should be considered instead
+
+    @return whether a valid CBOR value was passed to the SAX parser
+    */
+    bool parse_cbor_internal(const bool get_char = true)
+    {
+        switch (get_char ? get() : current)
+        {
+            // EOF
+            case std::char_traits<char>::eof():
+                return unexpect_eof(input_format_t::cbor, "value");
+
+            // Integer 0x00..0x17 (0..23)
+            case 0x00:
+            case 0x01:
+            case 0x02:
+            case 0x03:
+            case 0x04:
+            case 0x05:
+            case 0x06:
+            case 0x07:
+            case 0x08:
+            case 0x09:
+            case 0x0A:
+            case 0x0B:
+            case 0x0C:
+            case 0x0D:
+            case 0x0E:
+            case 0x0F:
+            case 0x10:
+            case 0x11:
+            case 0x12:
+            case 0x13:
+            case 0x14:
+            case 0x15:
+            case 0x16:
+            case 0x17:
+                return sax->number_unsigned(static_cast<number_unsigned_t>(current));
+
+            case 0x18: // Unsigned integer (one-byte uint8_t follows)
+            {
+                std::uint8_t number;
+                return get_number(input_format_t::cbor, number) and sax->number_unsigned(number);
+            }
+
+            case 0x19: // Unsigned integer (two-byte uint16_t follows)
+            {
+                std::uint16_t number;
+                return get_number(input_format_t::cbor, number) and sax->number_unsigned(number);
+            }
+
+            case 0x1A: // Unsigned integer (four-byte uint32_t follows)
+            {
+                std::uint32_t number;
+                return get_number(input_format_t::cbor, number) and sax->number_unsigned(number);
+            }
+
+            case 0x1B: // Unsigned integer (eight-byte uint64_t follows)
+            {
+                std::uint64_t number;
+                return get_number(input_format_t::cbor, number) and sax->number_unsigned(number);
+            }
+
+            // Negative integer -1-0x00..-1-0x17 (-1..-24)
+            case 0x20:
+            case 0x21:
+            case 0x22:
+            case 0x23:
+            case 0x24:
+            case 0x25:
+            case 0x26:
+            case 0x27:
+            case 0x28:
+            case 0x29:
+            case 0x2A:
+            case 0x2B:
+            case 0x2C:
+            case 0x2D:
+            case 0x2E:
+            case 0x2F:
+            case 0x30:
+            case 0x31:
+            case 0x32:
+            case 0x33:
+            case 0x34:
+            case 0x35:
+            case 0x36:
+            case 0x37:
+                return sax->number_integer(static_cast<std::int8_t>(0x20 - 1 - current));
+
+            case 0x38: // Negative integer (one-byte uint8_t follows)
+            {
+                std::uint8_t number;
+                return get_number(input_format_t::cbor, number) and sax->number_integer(static_cast<number_integer_t>(-1) - number);
+            }
+
+            case 0x39: // Negative integer -1-n (two-byte uint16_t follows)
+            {
+                std::uint16_t number;
+                return get_number(input_format_t::cbor, number) and sax->number_integer(static_cast<number_integer_t>(-1) - number);
+            }
+
+            case 0x3A: // Negative integer -1-n (four-byte uint32_t follows)
+            {
+                std::uint32_t number;
+                return get_number(input_format_t::cbor, number) and sax->number_integer(static_cast<number_integer_t>(-1) - number);
+            }
+
+            case 0x3B: // Negative integer -1-n (eight-byte uint64_t follows)
+            {
+                std::uint64_t number;
+                return get_number(input_format_t::cbor, number) and sax->number_integer(static_cast<number_integer_t>(-1)
+                        - static_cast<number_integer_t>(number));
+            }
+
+            // UTF-8 string (0x00..0x17 bytes follow)
+            case 0x60:
+            case 0x61:
+            case 0x62:
+            case 0x63:
+            case 0x64:
+            case 0x65:
+            case 0x66:
+            case 0x67:
+            case 0x68:
+            case 0x69:
+            case 0x6A:
+            case 0x6B:
+            case 0x6C:
+            case 0x6D:
+            case 0x6E:
+            case 0x6F:
+            case 0x70:
+            case 0x71:
+            case 0x72:
+            case 0x73:
+            case 0x74:
+            case 0x75:
+            case 0x76:
+            case 0x77:
+            case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
+            case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
+            case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
+            case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
+            case 0x7F: // UTF-8 string (indefinite length)
+            {
+                string_t s;
+                return get_cbor_string(s) and sax->string(s);
+            }
+
+            // array (0x00..0x17 data items follow)
+            case 0x80:
+            case 0x81:
+            case 0x82:
+            case 0x83:
+            case 0x84:
+            case 0x85:
+            case 0x86:
+            case 0x87:
+            case 0x88:
+            case 0x89:
+            case 0x8A:
+            case 0x8B:
+            case 0x8C:
+            case 0x8D:
+            case 0x8E:
+            case 0x8F:
+            case 0x90:
+            case 0x91:
+            case 0x92:
+            case 0x93:
+            case 0x94:
+            case 0x95:
+            case 0x96:
+            case 0x97:
+                return get_cbor_array(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu));
+
+            case 0x98: // array (one-byte uint8_t for n follows)
+            {
+                std::uint8_t len;
+                return get_number(input_format_t::cbor, len) and get_cbor_array(static_cast<std::size_t>(len));
+            }
+
+            case 0x99: // array (two-byte uint16_t for n follow)
+            {
+                std::uint16_t len;
+                return get_number(input_format_t::cbor, len) and get_cbor_array(static_cast<std::size_t>(len));
+            }
+
+            case 0x9A: // array (four-byte uint32_t for n follow)
+            {
+                std::uint32_t len;
+                return get_number(input_format_t::cbor, len) and get_cbor_array(static_cast<std::size_t>(len));
+            }
+
+            case 0x9B: // array (eight-byte uint64_t for n follow)
+            {
+                std::uint64_t len;
+                return get_number(input_format_t::cbor, len) and get_cbor_array(static_cast<std::size_t>(len));
+            }
+
+            case 0x9F: // array (indefinite length)
+                return get_cbor_array(std::size_t(-1));
+
+            // map (0x00..0x17 pairs of data items follow)
+            case 0xA0:
+            case 0xA1:
+            case 0xA2:
+            case 0xA3:
+            case 0xA4:
+            case 0xA5:
+            case 0xA6:
+            case 0xA7:
+            case 0xA8:
+            case 0xA9:
+            case 0xAA:
+            case 0xAB:
+            case 0xAC:
+            case 0xAD:
+            case 0xAE:
+            case 0xAF:
+            case 0xB0:
+            case 0xB1:
+            case 0xB2:
+            case 0xB3:
+            case 0xB4:
+            case 0xB5:
+            case 0xB6:
+            case 0xB7:
+                return get_cbor_object(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu));
+
+            case 0xB8: // map (one-byte uint8_t for n follows)
+            {
+                std::uint8_t len;
+                return get_number(input_format_t::cbor, len) and get_cbor_object(static_cast<std::size_t>(len));
+            }
+
+            case 0xB9: // map (two-byte uint16_t for n follow)
+            {
+                std::uint16_t len;
+                return get_number(input_format_t::cbor, len) and get_cbor_object(static_cast<std::size_t>(len));
+            }
+
+            case 0xBA: // map (four-byte uint32_t for n follow)
+            {
+                std::uint32_t len;
+                return get_number(input_format_t::cbor, len) and get_cbor_object(static_cast<std::size_t>(len));
+            }
+
+            case 0xBB: // map (eight-byte uint64_t for n follow)
+            {
+                std::uint64_t len;
+                return get_number(input_format_t::cbor, len) and get_cbor_object(static_cast<std::size_t>(len));
+            }
+
+            case 0xBF: // map (indefinite length)
+                return get_cbor_object(std::size_t(-1));
+
+            case 0xF4: // false
+                return sax->boolean(false);
+
+            case 0xF5: // true
+                return sax->boolean(true);
+
+            case 0xF6: // null
+                return sax->null();
+
+            case 0xF9: // Half-Precision Float (two-byte IEEE 754)
+            {
+                const int byte1_raw = get();
+                if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::cbor, "number")))
+                {
+                    return false;
+                }
+                const int byte2_raw = get();
+                if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::cbor, "number")))
+                {
+                    return false;
+                }
+
+                const auto byte1 = static_cast<unsigned char>(byte1_raw);
+                const auto byte2 = static_cast<unsigned char>(byte2_raw);
+
+                // code from RFC 7049, Appendix D, Figure 3:
+                // As half-precision floating-point numbers were only added
+                // to IEEE 754 in 2008, today's programming platforms often
+                // still only have limited support for them. It is very
+                // easy to include at least decoding support for them even
+                // without such support. An example of a small decoder for
+                // half-precision floating-point numbers in the C language
+                // is shown in Fig. 3.
+                const auto half = static_cast<unsigned int>((byte1 << 8u) + byte2);
+                const double val = [&half]
+                {
+                    const int exp = (half >> 10u) & 0x1Fu;
+                    const unsigned int mant = half & 0x3FFu;
+                    assert(0 <= exp and exp <= 32);
+                    assert(0 <= mant and mant <= 1024);
+                    switch (exp)
+                    {
+                        case 0:
+                            return std::ldexp(mant, -24);
+                        case 31:
+                            return (mant == 0)
+                            ? std::numeric_limits<double>::infinity()
+                            : std::numeric_limits<double>::quiet_NaN();
+                        default:
+                            return std::ldexp(mant + 1024, exp - 25);
+                    }
+                }();
+                return sax->number_float((half & 0x8000u) != 0
+                                         ? static_cast<number_float_t>(-val)
+                                         : static_cast<number_float_t>(val), "");
+            }
+
+            case 0xFA: // Single-Precision Float (four-byte IEEE 754)
+            {
+                float number;
+                return get_number(input_format_t::cbor, number) and sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 0xFB: // Double-Precision Float (eight-byte IEEE 754)
+            {
+                double number;
+                return get_number(input_format_t::cbor, number) and sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            default: // anything else (0xFF is handled inside the other types)
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::cbor, "invalid byte: 0x" + last_token, "value")));
+            }
+        }
+    }
+
+    /*!
+    @brief reads a CBOR string
+
+    This function first reads starting bytes to determine the expected
+    string length and then copies this number of bytes into a string.
+    Additionally, CBOR's strings with indefinite lengths are supported.
+
+    @param[out] result  created string
+
+    @return whether string creation completed
+    */
+    bool get_cbor_string(string_t& result)
+    {
+        if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::cbor, "string")))
+        {
+            return false;
+        }
+
+        switch (current)
+        {
+            // UTF-8 string (0x00..0x17 bytes follow)
+            case 0x60:
+            case 0x61:
+            case 0x62:
+            case 0x63:
+            case 0x64:
+            case 0x65:
+            case 0x66:
+            case 0x67:
+            case 0x68:
+            case 0x69:
+            case 0x6A:
+            case 0x6B:
+            case 0x6C:
+            case 0x6D:
+            case 0x6E:
+            case 0x6F:
+            case 0x70:
+            case 0x71:
+            case 0x72:
+            case 0x73:
+            case 0x74:
+            case 0x75:
+            case 0x76:
+            case 0x77:
+            {
+                return get_string(input_format_t::cbor, static_cast<unsigned int>(current) & 0x1Fu, result);
+            }
+
+            case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
+            {
+                std::uint8_t len;
+                return get_number(input_format_t::cbor, len) and get_string(input_format_t::cbor, len, result);
+            }
+
+            case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
+            {
+                std::uint16_t len;
+                return get_number(input_format_t::cbor, len) and get_string(input_format_t::cbor, len, result);
+            }
+
+            case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
+            {
+                std::uint32_t len;
+                return get_number(input_format_t::cbor, len) and get_string(input_format_t::cbor, len, result);
+            }
+
+            case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
+            {
+                std::uint64_t len;
+                return get_number(input_format_t::cbor, len) and get_string(input_format_t::cbor, len, result);
+            }
+
+            case 0x7F: // UTF-8 string (indefinite length)
+            {
+                while (get() != 0xFF)
+                {
+                    string_t chunk;
+                    if (not get_cbor_string(chunk))
+                    {
+                        return false;
+                    }
+                    result.append(chunk);
+                }
+                return true;
+            }
+
+            default:
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::cbor, "expected length specification (0x60-0x7B) or indefinite string type (0x7F); last byte: 0x" + last_token, "string")));
+            }
+        }
+    }
+
+    /*!
+    @param[in] len  the length of the array or std::size_t(-1) for an
+                    array of indefinite size
+    @return whether array creation completed
+    */
+    bool get_cbor_array(const std::size_t len)
+    {
+        if (JSON_HEDLEY_UNLIKELY(not sax->start_array(len)))
+        {
+            return false;
+        }
+
+        if (len != std::size_t(-1))
+        {
+            for (std::size_t i = 0; i < len; ++i)
+            {
+                if (JSON_HEDLEY_UNLIKELY(not parse_cbor_internal()))
+                {
+                    return false;
+                }
+            }
+        }
+        else
+        {
+            while (get() != 0xFF)
+            {
+                if (JSON_HEDLEY_UNLIKELY(not parse_cbor_internal(false)))
+                {
+                    return false;
+                }
+            }
+        }
+
+        return sax->end_array();
+    }
+
+    /*!
+    @param[in] len  the length of the object or std::size_t(-1) for an
+                    object of indefinite size
+    @return whether object creation completed
+    */
+    bool get_cbor_object(const std::size_t len)
+    {
+        if (JSON_HEDLEY_UNLIKELY(not sax->start_object(len)))
+        {
+            return false;
+        }
+
+        string_t key;
+        if (len != std::size_t(-1))
+        {
+            for (std::size_t i = 0; i < len; ++i)
+            {
+                get();
+                if (JSON_HEDLEY_UNLIKELY(not get_cbor_string(key) or not sax->key(key)))
+                {
+                    return false;
+                }
+
+                if (JSON_HEDLEY_UNLIKELY(not parse_cbor_internal()))
+                {
+                    return false;
+                }
+                key.clear();
+            }
+        }
+        else
+        {
+            while (get() != 0xFF)
+            {
+                if (JSON_HEDLEY_UNLIKELY(not get_cbor_string(key) or not sax->key(key)))
+                {
+                    return false;
+                }
+
+                if (JSON_HEDLEY_UNLIKELY(not parse_cbor_internal()))
+                {
+                    return false;
+                }
+                key.clear();
+            }
+        }
+
+        return sax->end_object();
+    }
+
+    /////////////
+    // MsgPack //
+    /////////////
+
+    /*!
+    @return whether a valid MessagePack value was passed to the SAX parser
+    */
+    bool parse_msgpack_internal()
+    {
+        switch (get())
+        {
+            // EOF
+            case std::char_traits<char>::eof():
+                return unexpect_eof(input_format_t::msgpack, "value");
+
+            // positive fixint
+            case 0x00:
+            case 0x01:
+            case 0x02:
+            case 0x03:
+            case 0x04:
+            case 0x05:
+            case 0x06:
+            case 0x07:
+            case 0x08:
+            case 0x09:
+            case 0x0A:
+            case 0x0B:
+            case 0x0C:
+            case 0x0D:
+            case 0x0E:
+            case 0x0F:
+            case 0x10:
+            case 0x11:
+            case 0x12:
+            case 0x13:
+            case 0x14:
+            case 0x15:
+            case 0x16:
+            case 0x17:
+            case 0x18:
+            case 0x19:
+            case 0x1A:
+            case 0x1B:
+            case 0x1C:
+            case 0x1D:
+            case 0x1E:
+            case 0x1F:
+            case 0x20:
+            case 0x21:
+            case 0x22:
+            case 0x23:
+            case 0x24:
+            case 0x25:
+            case 0x26:
+            case 0x27:
+            case 0x28:
+            case 0x29:
+            case 0x2A:
+            case 0x2B:
+            case 0x2C:
+            case 0x2D:
+            case 0x2E:
+            case 0x2F:
+            case 0x30:
+            case 0x31:
+            case 0x32:
+            case 0x33:
+            case 0x34:
+            case 0x35:
+            case 0x36:
+            case 0x37:
+            case 0x38:
+            case 0x39:
+            case 0x3A:
+            case 0x3B:
+            case 0x3C:
+            case 0x3D:
+            case 0x3E:
+            case 0x3F:
+            case 0x40:
+            case 0x41:
+            case 0x42:
+            case 0x43:
+            case 0x44:
+            case 0x45:
+            case 0x46:
+            case 0x47:
+            case 0x48:
+            case 0x49:
+            case 0x4A:
+            case 0x4B:
+            case 0x4C:
+            case 0x4D:
+            case 0x4E:
+            case 0x4F:
+            case 0x50:
+            case 0x51:
+            case 0x52:
+            case 0x53:
+            case 0x54:
+            case 0x55:
+            case 0x56:
+            case 0x57:
+            case 0x58:
+            case 0x59:
+            case 0x5A:
+            case 0x5B:
+            case 0x5C:
+            case 0x5D:
+            case 0x5E:
+            case 0x5F:
+            case 0x60:
+            case 0x61:
+            case 0x62:
+            case 0x63:
+            case 0x64:
+            case 0x65:
+            case 0x66:
+            case 0x67:
+            case 0x68:
+            case 0x69:
+            case 0x6A:
+            case 0x6B:
+            case 0x6C:
+            case 0x6D:
+            case 0x6E:
+            case 0x6F:
+            case 0x70:
+            case 0x71:
+            case 0x72:
+            case 0x73:
+            case 0x74:
+            case 0x75:
+            case 0x76:
+            case 0x77:
+            case 0x78:
+            case 0x79:
+            case 0x7A:
+            case 0x7B:
+            case 0x7C:
+            case 0x7D:
+            case 0x7E:
+            case 0x7F:
+                return sax->number_unsigned(static_cast<number_unsigned_t>(current));
+
+            // fixmap
+            case 0x80:
+            case 0x81:
+            case 0x82:
+            case 0x83:
+            case 0x84:
+            case 0x85:
+            case 0x86:
+            case 0x87:
+            case 0x88:
+            case 0x89:
+            case 0x8A:
+            case 0x8B:
+            case 0x8C:
+            case 0x8D:
+            case 0x8E:
+            case 0x8F:
+                return get_msgpack_object(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));
+
+            // fixarray
+            case 0x90:
+            case 0x91:
+            case 0x92:
+            case 0x93:
+            case 0x94:
+            case 0x95:
+            case 0x96:
+            case 0x97:
+            case 0x98:
+            case 0x99:
+            case 0x9A:
+            case 0x9B:
+            case 0x9C:
+            case 0x9D:
+            case 0x9E:
+            case 0x9F:
+                return get_msgpack_array(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));
+
+            // fixstr
+            case 0xA0:
+            case 0xA1:
+            case 0xA2:
+            case 0xA3:
+            case 0xA4:
+            case 0xA5:
+            case 0xA6:
+            case 0xA7:
+            case 0xA8:
+            case 0xA9:
+            case 0xAA:
+            case 0xAB:
+            case 0xAC:
+            case 0xAD:
+            case 0xAE:
+            case 0xAF:
+            case 0xB0:
+            case 0xB1:
+            case 0xB2:
+            case 0xB3:
+            case 0xB4:
+            case 0xB5:
+            case 0xB6:
+            case 0xB7:
+            case 0xB8:
+            case 0xB9:
+            case 0xBA:
+            case 0xBB:
+            case 0xBC:
+            case 0xBD:
+            case 0xBE:
+            case 0xBF:
+            case 0xD9: // str 8
+            case 0xDA: // str 16
+            case 0xDB: // str 32
+            {
+                string_t s;
+                return get_msgpack_string(s) and sax->string(s);
+            }
+
+            case 0xC0: // nil
+                return sax->null();
+
+            case 0xC2: // false
+                return sax->boolean(false);
+
+            case 0xC3: // true
+                return sax->boolean(true);
+
+            case 0xCA: // float 32
+            {
+                float number;
+                return get_number(input_format_t::msgpack, number) and sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 0xCB: // float 64
+            {
+                double number;
+                return get_number(input_format_t::msgpack, number) and sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 0xCC: // uint 8
+            {
+                std::uint8_t number;
+                return get_number(input_format_t::msgpack, number) and sax->number_unsigned(number);
+            }
+
+            case 0xCD: // uint 16
+            {
+                std::uint16_t number;
+                return get_number(input_format_t::msgpack, number) and sax->number_unsigned(number);
+            }
+
+            case 0xCE: // uint 32
+            {
+                std::uint32_t number;
+                return get_number(input_format_t::msgpack, number) and sax->number_unsigned(number);
+            }
+
+            case 0xCF: // uint 64
+            {
+                std::uint64_t number;
+                return get_number(input_format_t::msgpack, number) and sax->number_unsigned(number);
+            }
+
+            case 0xD0: // int 8
+            {
+                std::int8_t number;
+                return get_number(input_format_t::msgpack, number) and sax->number_integer(number);
+            }
+
+            case 0xD1: // int 16
+            {
+                std::int16_t number;
+                return get_number(input_format_t::msgpack, number) and sax->number_integer(number);
+            }
+
+            case 0xD2: // int 32
+            {
+                std::int32_t number;
+                return get_number(input_format_t::msgpack, number) and sax->number_integer(number);
+            }
+
+            case 0xD3: // int 64
+            {
+                std::int64_t number;
+                return get_number(input_format_t::msgpack, number) and sax->number_integer(number);
+            }
+
+            case 0xDC: // array 16
+            {
+                std::uint16_t len;
+                return get_number(input_format_t::msgpack, len) and get_msgpack_array(static_cast<std::size_t>(len));
+            }
+
+            case 0xDD: // array 32
+            {
+                std::uint32_t len;
+                return get_number(input_format_t::msgpack, len) and get_msgpack_array(static_cast<std::size_t>(len));
+            }
+
+            case 0xDE: // map 16
+            {
+                std::uint16_t len;
+                return get_number(input_format_t::msgpack, len) and get_msgpack_object(static_cast<std::size_t>(len));
+            }
+
+            case 0xDF: // map 32
+            {
+                std::uint32_t len;
+                return get_number(input_format_t::msgpack, len) and get_msgpack_object(static_cast<std::size_t>(len));
+            }
+
+            // negative fixint
+            case 0xE0:
+            case 0xE1:
+            case 0xE2:
+            case 0xE3:
+            case 0xE4:
+            case 0xE5:
+            case 0xE6:
+            case 0xE7:
+            case 0xE8:
+            case 0xE9:
+            case 0xEA:
+            case 0xEB:
+            case 0xEC:
+            case 0xED:
+            case 0xEE:
+            case 0xEF:
+            case 0xF0:
+            case 0xF1:
+            case 0xF2:
+            case 0xF3:
+            case 0xF4:
+            case 0xF5:
+            case 0xF6:
+            case 0xF7:
+            case 0xF8:
+            case 0xF9:
+            case 0xFA:
+            case 0xFB:
+            case 0xFC:
+            case 0xFD:
+            case 0xFE:
+            case 0xFF:
+                return sax->number_integer(static_cast<std::int8_t>(current));
+
+            default: // anything else
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::msgpack, "invalid byte: 0x" + last_token, "value")));
+            }
+        }
+    }
+
+    /*!
+    @brief reads a MessagePack string
+
+    This function first reads starting bytes to determine the expected
+    string length and then copies this number of bytes into a string.
+
+    @param[out] result  created string
+
+    @return whether string creation completed
+    */
+    bool get_msgpack_string(string_t& result)
+    {
+        if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::msgpack, "string")))
+        {
+            return false;
+        }
+
+        switch (current)
+        {
+            // fixstr
+            case 0xA0:
+            case 0xA1:
+            case 0xA2:
+            case 0xA3:
+            case 0xA4:
+            case 0xA5:
+            case 0xA6:
+            case 0xA7:
+            case 0xA8:
+            case 0xA9:
+            case 0xAA:
+            case 0xAB:
+            case 0xAC:
+            case 0xAD:
+            case 0xAE:
+            case 0xAF:
+            case 0xB0:
+            case 0xB1:
+            case 0xB2:
+            case 0xB3:
+            case 0xB4:
+            case 0xB5:
+            case 0xB6:
+            case 0xB7:
+            case 0xB8:
+            case 0xB9:
+            case 0xBA:
+            case 0xBB:
+            case 0xBC:
+            case 0xBD:
+            case 0xBE:
+            case 0xBF:
+            {
+                return get_string(input_format_t::msgpack, static_cast<unsigned int>(current) & 0x1Fu, result);
+            }
+
+            case 0xD9: // str 8
+            {
+                std::uint8_t len;
+                return get_number(input_format_t::msgpack, len) and get_string(input_format_t::msgpack, len, result);
+            }
+
+            case 0xDA: // str 16
+            {
+                std::uint16_t len;
+                return get_number(input_format_t::msgpack, len) and get_string(input_format_t::msgpack, len, result);
+            }
+
+            case 0xDB: // str 32
+            {
+                std::uint32_t len;
+                return get_number(input_format_t::msgpack, len) and get_string(input_format_t::msgpack, len, result);
+            }
+
+            default:
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::msgpack, "expected length specification (0xA0-0xBF, 0xD9-0xDB); last byte: 0x" + last_token, "string")));
+            }
+        }
+    }
+
+    /*!
+    @param[in] len  the length of the array
+    @return whether array creation completed
+    */
+    bool get_msgpack_array(const std::size_t len)
+    {
+        if (JSON_HEDLEY_UNLIKELY(not sax->start_array(len)))
+        {
+            return false;
+        }
+
+        for (std::size_t i = 0; i < len; ++i)
+        {
+            if (JSON_HEDLEY_UNLIKELY(not parse_msgpack_internal()))
+            {
+                return false;
+            }
+        }
+
+        return sax->end_array();
+    }
+
+    /*!
+    @param[in] len  the length of the object
+    @return whether object creation completed
+    */
+    bool get_msgpack_object(const std::size_t len)
+    {
+        if (JSON_HEDLEY_UNLIKELY(not sax->start_object(len)))
+        {
+            return false;
+        }
+
+        string_t key;
+        for (std::size_t i = 0; i < len; ++i)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(not get_msgpack_string(key) or not sax->key(key)))
+            {
+                return false;
+            }
+
+            if (JSON_HEDLEY_UNLIKELY(not parse_msgpack_internal()))
+            {
+                return false;
+            }
+            key.clear();
+        }
+
+        return sax->end_object();
+    }
+
+    ////////////
+    // UBJSON //
+    ////////////
+
+    /*!
+    @param[in] get_char  whether a new character should be retrieved from the
+                         input (true, default) or whether the last read
+                         character should be considered instead
+
+    @return whether a valid UBJSON value was passed to the SAX parser
+    */
+    bool parse_ubjson_internal(const bool get_char = true)
+    {
+        return get_ubjson_value(get_char ? get_ignore_noop() : current);
+    }
+
+    /*!
+    @brief reads a UBJSON string
+
+    This function is either called after reading the 'S' byte explicitly
+    indicating a string, or in case of an object key where the 'S' byte can be
+    left out.
+
+    @param[out] result   created string
+    @param[in] get_char  whether a new character should be retrieved from the
+                         input (true, default) or whether the last read
+                         character should be considered instead
+
+    @return whether string creation completed
+    */
+    bool get_ubjson_string(string_t& result, const bool get_char = true)
+    {
+        if (get_char)
+        {
+            get();  // TODO(niels): may we ignore N here?
+        }
+
+        if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::ubjson, "value")))
+        {
+            return false;
+        }
+
+        switch (current)
+        {
+            case 'U':
+            {
+                std::uint8_t len;
+                return get_number(input_format_t::ubjson, len) and get_string(input_format_t::ubjson, len, result);
+            }
+
+            case 'i':
+            {
+                std::int8_t len;
+                return get_number(input_format_t::ubjson, len) and get_string(input_format_t::ubjson, len, result);
+            }
+
+            case 'I':
+            {
+                std::int16_t len;
+                return get_number(input_format_t::ubjson, len) and get_string(input_format_t::ubjson, len, result);
+            }
+
+            case 'l':
+            {
+                std::int32_t len;
+                return get_number(input_format_t::ubjson, len) and get_string(input_format_t::ubjson, len, result);
+            }
+
+            case 'L':
+            {
+                std::int64_t len;
+                return get_number(input_format_t::ubjson, len) and get_string(input_format_t::ubjson, len, result);
+            }
+
+            default:
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::ubjson, "expected length type specification (U, i, I, l, L); last byte: 0x" + last_token, "string")));
+        }
+    }
+
+    /*!
+    @param[out] result  determined size
+    @return whether size determination completed
+    */
+    bool get_ubjson_size_value(std::size_t& result)
+    {
+        switch (get_ignore_noop())
+        {
+            case 'U':
+            {
+                std::uint8_t number;
+                if (JSON_HEDLEY_UNLIKELY(not get_number(input_format_t::ubjson, number)))
+                {
+                    return false;
+                }
+                result = static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case 'i':
+            {
+                std::int8_t number;
+                if (JSON_HEDLEY_UNLIKELY(not get_number(input_format_t::ubjson, number)))
+                {
+                    return false;
+                }
+                result = static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case 'I':
+            {
+                std::int16_t number;
+                if (JSON_HEDLEY_UNLIKELY(not get_number(input_format_t::ubjson, number)))
+                {
+                    return false;
+                }
+                result = static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case 'l':
+            {
+                std::int32_t number;
+                if (JSON_HEDLEY_UNLIKELY(not get_number(input_format_t::ubjson, number)))
+                {
+                    return false;
+                }
+                result = static_cast<std::size_t>(number);
+                return true;
+            }
+
+            case 'L':
+            {
+                std::int64_t number;
+                if (JSON_HEDLEY_UNLIKELY(not get_number(input_format_t::ubjson, number)))
+                {
+                    return false;
+                }
+                result = static_cast<std::size_t>(number);
+                return true;
+            }
+
+            default:
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::ubjson, "expected length type specification (U, i, I, l, L) after '#'; last byte: 0x" + last_token, "size")));
+            }
+        }
+    }
+
+    /*!
+    @brief determine the type and size for a container
+
+    In the optimized UBJSON format, a type and a size can be provided to allow
+    for a more compact representation.
+
+    @param[out] result  pair of the size and the type
+
+    @return whether pair creation completed
+    */
+    bool get_ubjson_size_type(std::pair<std::size_t, int>& result)
+    {
+        result.first = string_t::npos; // size
+        result.second = 0; // type
+
+        get_ignore_noop();
+
+        if (current == '$')
+        {
+            result.second = get();  // must not ignore 'N', because 'N' maybe the type
+            if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::ubjson, "type")))
+            {
+                return false;
+            }
+
+            get_ignore_noop();
+            if (JSON_HEDLEY_UNLIKELY(current != '#'))
+            {
+                if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::ubjson, "value")))
+                {
+                    return false;
+                }
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::ubjson, "expected '#' after type information; last byte: 0x" + last_token, "size")));
+            }
+
+            return get_ubjson_size_value(result.first);
+        }
+
+        if (current == '#')
+        {
+            return get_ubjson_size_value(result.first);
+        }
+
+        return true;
+    }
+
+    /*!
+    @param prefix  the previously read or set type prefix
+    @return whether value creation completed
+    */
+    bool get_ubjson_value(const int prefix)
+    {
+        switch (prefix)
+        {
+            case std::char_traits<char>::eof():  // EOF
+                return unexpect_eof(input_format_t::ubjson, "value");
+
+            case 'T':  // true
+                return sax->boolean(true);
+            case 'F':  // false
+                return sax->boolean(false);
+
+            case 'Z':  // null
+                return sax->null();
+
+            case 'U':
+            {
+                std::uint8_t number;
+                return get_number(input_format_t::ubjson, number) and sax->number_unsigned(number);
+            }
+
+            case 'i':
+            {
+                std::int8_t number;
+                return get_number(input_format_t::ubjson, number) and sax->number_integer(number);
+            }
+
+            case 'I':
+            {
+                std::int16_t number;
+                return get_number(input_format_t::ubjson, number) and sax->number_integer(number);
+            }
+
+            case 'l':
+            {
+                std::int32_t number;
+                return get_number(input_format_t::ubjson, number) and sax->number_integer(number);
+            }
+
+            case 'L':
+            {
+                std::int64_t number;
+                return get_number(input_format_t::ubjson, number) and sax->number_integer(number);
+            }
+
+            case 'd':
+            {
+                float number;
+                return get_number(input_format_t::ubjson, number) and sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 'D':
+            {
+                double number;
+                return get_number(input_format_t::ubjson, number) and sax->number_float(static_cast<number_float_t>(number), "");
+            }
+
+            case 'C':  // char
+            {
+                get();
+                if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(input_format_t::ubjson, "char")))
+                {
+                    return false;
+                }
+                if (JSON_HEDLEY_UNLIKELY(current > 127))
+                {
+                    auto last_token = get_token_string();
+                    return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::ubjson, "byte after 'C' must be in range 0x00..0x7F; last byte: 0x" + last_token, "char")));
+                }
+                string_t s(1, static_cast<char>(current));
+                return sax->string(s);
+            }
+
+            case 'S':  // string
+            {
+                string_t s;
+                return get_ubjson_string(s) and sax->string(s);
+            }
+
+            case '[':  // array
+                return get_ubjson_array();
+
+            case '{':  // object
+                return get_ubjson_object();
+
+            default: // anything else
+            {
+                auto last_token = get_token_string();
+                return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::ubjson, "invalid byte: 0x" + last_token, "value")));
+            }
+        }
+    }
+
+    /*!
+    @return whether array creation completed
+    */
+    bool get_ubjson_array()
+    {
+        std::pair<std::size_t, int> size_and_type;
+        if (JSON_HEDLEY_UNLIKELY(not get_ubjson_size_type(size_and_type)))
+        {
+            return false;
+        }
+
+        if (size_and_type.first != string_t::npos)
+        {
+            if (JSON_HEDLEY_UNLIKELY(not sax->start_array(size_and_type.first)))
+            {
+                return false;
+            }
+
+            if (size_and_type.second != 0)
+            {
+                if (size_and_type.second != 'N')
+                {
+                    for (std::size_t i = 0; i < size_and_type.first; ++i)
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(not get_ubjson_value(size_and_type.second)))
+                        {
+                            return false;
+                        }
+                    }
+                }
+            }
+            else
+            {
+                for (std::size_t i = 0; i < size_and_type.first; ++i)
+                {
+                    if (JSON_HEDLEY_UNLIKELY(not parse_ubjson_internal()))
+                    {
+                        return false;
+                    }
+                }
+            }
+        }
+        else
+        {
+            if (JSON_HEDLEY_UNLIKELY(not sax->start_array(std::size_t(-1))))
+            {
+                return false;
+            }
+
+            while (current != ']')
+            {
+                if (JSON_HEDLEY_UNLIKELY(not parse_ubjson_internal(false)))
+                {
+                    return false;
+                }
+                get_ignore_noop();
+            }
+        }
+
+        return sax->end_array();
+    }
+
+    /*!
+    @return whether object creation completed
+    */
+    bool get_ubjson_object()
+    {
+        std::pair<std::size_t, int> size_and_type;
+        if (JSON_HEDLEY_UNLIKELY(not get_ubjson_size_type(size_and_type)))
+        {
+            return false;
+        }
+
+        string_t key;
+        if (size_and_type.first != string_t::npos)
+        {
+            if (JSON_HEDLEY_UNLIKELY(not sax->start_object(size_and_type.first)))
+            {
+                return false;
+            }
+
+            if (size_and_type.second != 0)
+            {
+                for (std::size_t i = 0; i < size_and_type.first; ++i)
+                {
+                    if (JSON_HEDLEY_UNLIKELY(not get_ubjson_string(key) or not sax->key(key)))
+                    {
+                        return false;
+                    }
+                    if (JSON_HEDLEY_UNLIKELY(not get_ubjson_value(size_and_type.second)))
+                    {
+                        return false;
+                    }
+                    key.clear();
+                }
+            }
+            else
+            {
+                for (std::size_t i = 0; i < size_and_type.first; ++i)
+                {
+                    if (JSON_HEDLEY_UNLIKELY(not get_ubjson_string(key) or not sax->key(key)))
+                    {
+                        return false;
+                    }
+                    if (JSON_HEDLEY_UNLIKELY(not parse_ubjson_internal()))
+                    {
+                        return false;
+                    }
+                    key.clear();
+                }
+            }
+        }
+        else
+        {
+            if (JSON_HEDLEY_UNLIKELY(not sax->start_object(std::size_t(-1))))
+            {
+                return false;
+            }
+
+            while (current != '}')
+            {
+                if (JSON_HEDLEY_UNLIKELY(not get_ubjson_string(key, false) or not sax->key(key)))
+                {
+                    return false;
+                }
+                if (JSON_HEDLEY_UNLIKELY(not parse_ubjson_internal()))
+                {
+                    return false;
+                }
+                get_ignore_noop();
+                key.clear();
+            }
+        }
+
+        return sax->end_object();
+    }
+
+    ///////////////////////
+    // Utility functions //
+    ///////////////////////
+
+    /*!
+    @brief get next character from the input
+
+    This function provides the interface to the used input adapter. It does
+    not throw in case the input reached EOF, but returns a -'ve valued
+    `std::char_traits<char>::eof()` in that case.
+
+    @return character read from the input
+    */
+    int get()
+    {
+        ++chars_read;
+        return current = ia->get_character();
+    }
+
+    /*!
+    @return character read from the input after ignoring all 'N' entries
+    */
+    int get_ignore_noop()
+    {
+        do
+        {
+            get();
+        }
+        while (current == 'N');
+
+        return current;
+    }
+
+    /*
+    @brief read a number from the input
+
+    @tparam NumberType the type of the number
+    @param[in] format   the current format (for diagnostics)
+    @param[out] result  number of type @a NumberType
+
+    @return whether conversion completed
+
+    @note This function needs to respect the system's endianess, because
+          bytes in CBOR, MessagePack, and UBJSON are stored in network order
+          (big endian) and therefore need reordering on little endian systems.
+    */
+    template<typename NumberType, bool InputIsLittleEndian = false>
+    bool get_number(const input_format_t format, NumberType& result)
+    {
+        // step 1: read input into array with system's byte order
+        std::array<std::uint8_t, sizeof(NumberType)> vec;
+        for (std::size_t i = 0; i < sizeof(NumberType); ++i)
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(format, "number")))
+            {
+                return false;
+            }
+
+            // reverse byte order prior to conversion if necessary
+            if (is_little_endian != InputIsLittleEndian)
+            {
+                vec[sizeof(NumberType) - i - 1] = static_cast<std::uint8_t>(current);
+            }
+            else
+            {
+                vec[i] = static_cast<std::uint8_t>(current); // LCOV_EXCL_LINE
+            }
+        }
+
+        // step 2: convert array into number of type T and return
+        std::memcpy(&result, vec.data(), sizeof(NumberType));
+        return true;
+    }
+
+    /*!
+    @brief create a string by reading characters from the input
+
+    @tparam NumberType the type of the number
+    @param[in] format the current format (for diagnostics)
+    @param[in] len number of characters to read
+    @param[out] result string created by reading @a len bytes
+
+    @return whether string creation completed
+
+    @note We can not reserve @a len bytes for the result, because @a len
+          may be too large. Usually, @ref unexpect_eof() detects the end of
+          the input before we run out of string memory.
+    */
+    template<typename NumberType>
+    bool get_string(const input_format_t format,
+                    const NumberType len,
+                    string_t& result)
+    {
+        bool success = true;
+        std::generate_n(std::back_inserter(result), len, [this, &success, &format]()
+        {
+            get();
+            if (JSON_HEDLEY_UNLIKELY(not unexpect_eof(format, "string")))
+            {
+                success = false;
+            }
+            return static_cast<char>(current);
+        });
+        return success;
+    }
+
+    /*!
+    @param[in] format   the current format (for diagnostics)
+    @param[in] context  further context information (for diagnostics)
+    @return whether the last read character is not EOF
+    */
+    JSON_HEDLEY_NON_NULL(3)
+    bool unexpect_eof(const input_format_t format, const char* context) const
+    {
+        if (JSON_HEDLEY_UNLIKELY(current == std::char_traits<char>::eof()))
+        {
+            return sax->parse_error(chars_read, "<end of file>",
+                                    parse_error::create(110, chars_read, exception_message(format, "unexpected end of input", context)));
+        }
+        return true;
+    }
+
+    /*!
+    @return a string representation of the last read byte
+    */
+    std::string get_token_string() const
+    {
+        std::array<char, 3> cr{{}};
+        (std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(current));
+        return std::string{cr.data()};
+    }
+
+    /*!
+    @param[in] format   the current format
+    @param[in] detail   a detailed error message
+    @param[in] context  further contect information
+    @return a message string to use in the parse_error exceptions
+    */
+    std::string exception_message(const input_format_t format,
+                                  const std::string& detail,
+                                  const std::string& context) const
+    {
+        std::string error_msg = "syntax error while parsing ";
+
+        switch (format)
+        {
+            case input_format_t::cbor:
+                error_msg += "CBOR";
+                break;
+
+            case input_format_t::msgpack:
+                error_msg += "MessagePack";
+                break;
+
+            case input_format_t::ubjson:
+                error_msg += "UBJSON";
+                break;
+
+            case input_format_t::bson:
+                error_msg += "BSON";
+                break;
+
+            default:            // LCOV_EXCL_LINE
+                assert(false);  // LCOV_EXCL_LINE
+        }
+
+        return error_msg + " " + context + ": " + detail;
+    }
+
+  private:
+    /// input adapter
+    input_adapter_t ia = nullptr;
+
+    /// the current character
+    int current = std::char_traits<char>::eof();
+
+    /// the number of characters read
+    std::size_t chars_read = 0;
+
+    /// whether we can assume little endianess
+    const bool is_little_endian = little_endianess();
+
+    /// the SAX parser
+    json_sax_t* sax = nullptr;
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/input/input_adapters.hpp>
+
+// #include <nlohmann/detail/input/lexer.hpp>
+
+
+#include <array> // array
+#include <clocale> // localeconv
+#include <cstddef> // size_t
+#include <cstdio> // snprintf
+#include <cstdlib> // strtof, strtod, strtold, strtoll, strtoull
+#include <initializer_list> // initializer_list
+#include <string> // char_traits, string
+#include <utility> // move
+#include <vector> // vector
+
+// #include <nlohmann/detail/input/input_adapters.hpp>
+
+// #include <nlohmann/detail/input/position_t.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+///////////
+// lexer //
+///////////
+
+/*!
+@brief lexical analysis
+
+This class organizes the lexical analysis during JSON deserialization.
+*/
+template<typename BasicJsonType>
+class lexer
+{
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+
+  public:
+    /// token types for the parser
+    enum class token_type
+    {
+        uninitialized,    ///< indicating the scanner is uninitialized
+        literal_true,     ///< the `true` literal
+        literal_false,    ///< the `false` literal
+        literal_null,     ///< the `null` literal
+        value_string,     ///< a string -- use get_string() for actual value
+        value_unsigned,   ///< an unsigned integer -- use get_number_unsigned() for actual value
+        value_integer,    ///< a signed integer -- use get_number_integer() for actual value
+        value_float,      ///< an floating point number -- use get_number_float() for actual value
+        begin_array,      ///< the character for array begin `[`
+        begin_object,     ///< the character for object begin `{`
+        end_array,        ///< the character for array end `]`
+        end_object,       ///< the character for object end `}`
+        name_separator,   ///< the name separator `:`
+        value_separator,  ///< the value separator `,`
+        parse_error,      ///< indicating a parse error
+        end_of_input,     ///< indicating the end of the input buffer
+        literal_or_value  ///< a literal or the begin of a value (only for diagnostics)
+    };
+
+    /// return name of values of type token_type (only used for errors)
+    JSON_HEDLEY_RETURNS_NON_NULL
+    JSON_HEDLEY_CONST
+    static const char* token_type_name(const token_type t) noexcept
+    {
+        switch (t)
+        {
+            case token_type::uninitialized:
+                return "<uninitialized>";
+            case token_type::literal_true:
+                return "true literal";
+            case token_type::literal_false:
+                return "false literal";
+            case token_type::literal_null:
+                return "null literal";
+            case token_type::value_string:
+                return "string literal";
+            case lexer::token_type::value_unsigned:
+            case lexer::token_type::value_integer:
+            case lexer::token_type::value_float:
+                return "number literal";
+            case token_type::begin_array:
+                return "'['";
+            case token_type::begin_object:
+                return "'{'";
+            case token_type::end_array:
+                return "']'";
+            case token_type::end_object:
+                return "'}'";
+            case token_type::name_separator:
+                return "':'";
+            case token_type::value_separator:
+                return "','";
+            case token_type::parse_error:
+                return "<parse error>";
+            case token_type::end_of_input:
+                return "end of input";
+            case token_type::literal_or_value:
+                return "'[', '{', or a literal";
+            // LCOV_EXCL_START
+            default: // catch non-enum values
+                return "unknown token";
+                // LCOV_EXCL_STOP
+        }
+    }
+
+    explicit lexer(detail::input_adapter_t&& adapter)
+        : ia(std::move(adapter)), decimal_point_char(get_decimal_point()) {}
+
+    // delete because of pointer members
+    lexer(const lexer&) = delete;
+    lexer(lexer&&) = delete;
+    lexer& operator=(lexer&) = delete;
+    lexer& operator=(lexer&&) = delete;
+    ~lexer() = default;
+
+  private:
+    /////////////////////
+    // locales
+    /////////////////////
+
+    /// return the locale-dependent decimal point
+    JSON_HEDLEY_PURE
+    static char get_decimal_point() noexcept
+    {
+        const auto loc = localeconv();
+        assert(loc != nullptr);
+        return (loc->decimal_point == nullptr) ? '.' : *(loc->decimal_point);
+    }
+
+    /////////////////////
+    // scan functions
+    /////////////////////
+
+    /*!
+    @brief get codepoint from 4 hex characters following `\u`
+
+    For input "\u c1 c2 c3 c4" the codepoint is:
+      (c1 * 0x1000) + (c2 * 0x0100) + (c3 * 0x0010) + c4
+    = (c1 << 12) + (c2 << 8) + (c3 << 4) + (c4 << 0)
+
+    Furthermore, the possible characters '0'..'9', 'A'..'F', and 'a'..'f'
+    must be converted to the integers 0x0..0x9, 0xA..0xF, 0xA..0xF, resp. The
+    conversion is done by subtracting the offset (0x30, 0x37, and 0x57)
+    between the ASCII value of the character and the desired integer value.
+
+    @return codepoint (0x0000..0xFFFF) or -1 in case of an error (e.g. EOF or
+            non-hex character)
+    */
+    int get_codepoint()
+    {
+        // this function only makes sense after reading `\u`
+        assert(current == 'u');
+        int codepoint = 0;
+
+        const auto factors = { 12u, 8u, 4u, 0u };
+        for (const auto factor : factors)
+        {
+            get();
+
+            if (current >= '0' and current <= '9')
+            {
+                codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x30u) << factor);
+            }
+            else if (current >= 'A' and current <= 'F')
+            {
+                codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x37u) << factor);
+            }
+            else if (current >= 'a' and current <= 'f')
+            {
+                codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x57u) << factor);
+            }
+            else
+            {
+                return -1;
+            }
+        }
+
+        assert(0x0000 <= codepoint and codepoint <= 0xFFFF);
+        return codepoint;
+    }
+
+    /*!
+    @brief check if the next byte(s) are inside a given range
+
+    Adds the current byte and, for each passed range, reads a new byte and
+    checks if it is inside the range. If a violation was detected, set up an
+    error message and return false. Otherwise, return true.
+
+    @param[in] ranges  list of integers; interpreted as list of pairs of
+                       inclusive lower and upper bound, respectively
+
+    @pre The passed list @a ranges must have 2, 4, or 6 elements; that is,
+         1, 2, or 3 pairs. This precondition is enforced by an assertion.
+
+    @return true if and only if no range violation was detected
+    */
+    bool next_byte_in_range(std::initializer_list<int> ranges)
+    {
+        assert(ranges.size() == 2 or ranges.size() == 4 or ranges.size() == 6);
+        add(current);
+
+        for (auto range = ranges.begin(); range != ranges.end(); ++range)
+        {
+            get();
+            if (JSON_HEDLEY_LIKELY(*range <= current and current <= *(++range)))
+            {
+                add(current);
+            }
+            else
+            {
+                error_message = "invalid string: ill-formed UTF-8 byte";
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /*!
+    @brief scan a string literal
+
+    This function scans a string according to Sect. 7 of RFC 7159. While
+    scanning, bytes are escaped and copied into buffer token_buffer. Then the
+    function returns successfully, token_buffer is *not* null-terminated (as it
+    may contain \0 bytes), and token_buffer.size() is the number of bytes in the
+    string.
+
+    @return token_type::value_string if string could be successfully scanned,
+            token_type::parse_error otherwise
+
+    @note In case of errors, variable error_message contains a textual
+          description.
+    */
+    token_type scan_string()
+    {
+        // reset token_buffer (ignore opening quote)
+        reset();
+
+        // we entered the function by reading an open quote
+        assert(current == '\"');
+
+        while (true)
+        {
+            // get next character
+            switch (get())
+            {
+                // end of file while parsing string
+                case std::char_traits<char>::eof():
+                {
+                    error_message = "invalid string: missing closing quote";
+                    return token_type::parse_error;
+                }
+
+                // closing quote
+                case '\"':
+                {
+                    return token_type::value_string;
+                }
+
+                // escapes
+                case '\\':
+                {
+                    switch (get())
+                    {
+                        // quotation mark
+                        case '\"':
+                            add('\"');
+                            break;
+                        // reverse solidus
+                        case '\\':
+                            add('\\');
+                            break;
+                        // solidus
+                        case '/':
+                            add('/');
+                            break;
+                        // backspace
+                        case 'b':
+                            add('\b');
+                            break;
+                        // form feed
+                        case 'f':
+                            add('\f');
+                            break;
+                        // line feed
+                        case 'n':
+                            add('\n');
+                            break;
+                        // carriage return
+                        case 'r':
+                            add('\r');
+                            break;
+                        // tab
+                        case 't':
+                            add('\t');
+                            break;
+
+                        // unicode escapes
+                        case 'u':
+                        {
+                            const int codepoint1 = get_codepoint();
+                            int codepoint = codepoint1; // start with codepoint1
+
+                            if (JSON_HEDLEY_UNLIKELY(codepoint1 == -1))
+                            {
+                                error_message = "invalid string: '\\u' must be followed by 4 hex digits";
+                                return token_type::parse_error;
+                            }
+
+                            // check if code point is a high surrogate
+                            if (0xD800 <= codepoint1 and codepoint1 <= 0xDBFF)
+                            {
+                                // expect next \uxxxx entry
+                                if (JSON_HEDLEY_LIKELY(get() == '\\' and get() == 'u'))
+                                {
+                                    const int codepoint2 = get_codepoint();
+
+                                    if (JSON_HEDLEY_UNLIKELY(codepoint2 == -1))
+                                    {
+                                        error_message = "invalid string: '\\u' must be followed by 4 hex digits";
+                                        return token_type::parse_error;
+                                    }
+
+                                    // check if codepoint2 is a low surrogate
+                                    if (JSON_HEDLEY_LIKELY(0xDC00 <= codepoint2 and codepoint2 <= 0xDFFF))
+                                    {
+                                        // overwrite codepoint
+                                        codepoint = static_cast<int>(
+                                                        // high surrogate occupies the most significant 22 bits
+                                                        (static_cast<unsigned int>(codepoint1) << 10u)
+                                                        // low surrogate occupies the least significant 15 bits
+                                                        + static_cast<unsigned int>(codepoint2)
+                                                        // there is still the 0xD800, 0xDC00 and 0x10000 noise
+                                                        // in the result so we have to subtract with:
+                                                        // (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00
+                                                        - 0x35FDC00u);
+                                    }
+                                    else
+                                    {
+                                        error_message = "invalid string: surrogate U+DC00..U+DFFF must be followed by U+DC00..U+DFFF";
+                                        return token_type::parse_error;
+                                    }
+                                }
+                                else
+                                {
+                                    error_message = "invalid string: surrogate U+DC00..U+DFFF must be followed by U+DC00..U+DFFF";
+                                    return token_type::parse_error;
+                                }
+                            }
+                            else
+                            {
+                                if (JSON_HEDLEY_UNLIKELY(0xDC00 <= codepoint1 and codepoint1 <= 0xDFFF))
+                                {
+                                    error_message = "invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";
+                                    return token_type::parse_error;
+                                }
+                            }
+
+                            // result of the above calculation yields a proper codepoint
+                            assert(0x00 <= codepoint and codepoint <= 0x10FFFF);
+
+                            // translate codepoint into bytes
+                            if (codepoint < 0x80)
+                            {
+                                // 1-byte characters: 0xxxxxxx (ASCII)
+                                add(codepoint);
+                            }
+                            else if (codepoint <= 0x7FF)
+                            {
+                                // 2-byte characters: 110xxxxx 10xxxxxx
+                                add(static_cast<int>(0xC0u | (static_cast<unsigned int>(codepoint) >> 6u)));
+                                add(static_cast<int>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
+                            }
+                            else if (codepoint <= 0xFFFF)
+                            {
+                                // 3-byte characters: 1110xxxx 10xxxxxx 10xxxxxx
+                                add(static_cast<int>(0xE0u | (static_cast<unsigned int>(codepoint) >> 12u)));
+                                add(static_cast<int>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
+                                add(static_cast<int>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
+                            }
+                            else
+                            {
+                                // 4-byte characters: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+                                add(static_cast<int>(0xF0u | (static_cast<unsigned int>(codepoint) >> 18u)));
+                                add(static_cast<int>(0x80u | ((static_cast<unsigned int>(codepoint) >> 12u) & 0x3Fu)));
+                                add(static_cast<int>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
+                                add(static_cast<int>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
+                            }
+
+                            break;
+                        }
+
+                        // other characters after escape
+                        default:
+                            error_message = "invalid string: forbidden character after backslash";
+                            return token_type::parse_error;
+                    }
+
+                    break;
+                }
+
+                // invalid control characters
+                case 0x00:
+                {
+                    error_message = "invalid string: control character U+0000 (NUL) must be escaped to \\u0000";
+                    return token_type::parse_error;
+                }
+
+                case 0x01:
+                {
+                    error_message = "invalid string: control character U+0001 (SOH) must be escaped to \\u0001";
+                    return token_type::parse_error;
+                }
+
+                case 0x02:
+                {
+                    error_message = "invalid string: control character U+0002 (STX) must be escaped to \\u0002";
+                    return token_type::parse_error;
+                }
+
+                case 0x03:
+                {
+                    error_message = "invalid string: control character U+0003 (ETX) must be escaped to \\u0003";
+                    return token_type::parse_error;
+                }
+
+                case 0x04:
+                {
+                    error_message = "invalid string: control character U+0004 (EOT) must be escaped to \\u0004";
+                    return token_type::parse_error;
+                }
+
+                case 0x05:
+                {
+                    error_message = "invalid string: control character U+0005 (ENQ) must be escaped to \\u0005";
+                    return token_type::parse_error;
+                }
+
+                case 0x06:
+                {
+                    error_message = "invalid string: control character U+0006 (ACK) must be escaped to \\u0006";
+                    return token_type::parse_error;
+                }
+
+                case 0x07:
+                {
+                    error_message = "invalid string: control character U+0007 (BEL) must be escaped to \\u0007";
+                    return token_type::parse_error;
+                }
+
+                case 0x08:
+                {
+                    error_message = "invalid string: control character U+0008 (BS) must be escaped to \\u0008 or \\b";
+                    return token_type::parse_error;
+                }
+
+                case 0x09:
+                {
+                    error_message = "invalid string: control character U+0009 (HT) must be escaped to \\u0009 or \\t";
+                    return token_type::parse_error;
+                }
+
+                case 0x0A:
+                {
+                    error_message = "invalid string: control character U+000A (LF) must be escaped to \\u000A or \\n";
+                    return token_type::parse_error;
+                }
+
+                case 0x0B:
+                {
+                    error_message = "invalid string: control character U+000B (VT) must be escaped to \\u000B";
+                    return token_type::parse_error;
+                }
+
+                case 0x0C:
+                {
+                    error_message = "invalid string: control character U+000C (FF) must be escaped to \\u000C or \\f";
+                    return token_type::parse_error;
+                }
+
+                case 0x0D:
+                {
+                    error_message = "invalid string: control character U+000D (CR) must be escaped to \\u000D or \\r";
+                    return token_type::parse_error;
+                }
+
+                case 0x0E:
+                {
+                    error_message = "invalid string: control character U+000E (SO) must be escaped to \\u000E";
+                    return token_type::parse_error;
+                }
+
+                case 0x0F:
+                {
+                    error_message = "invalid string: control character U+000F (SI) must be escaped to \\u000F";
+                    return token_type::parse_error;
+                }
+
+                case 0x10:
+                {
+                    error_message = "invalid string: control character U+0010 (DLE) must be escaped to \\u0010";
+                    return token_type::parse_error;
+                }
+
+                case 0x11:
+                {
+                    error_message = "invalid string: control character U+0011 (DC1) must be escaped to \\u0011";
+                    return token_type::parse_error;
+                }
+
+                case 0x12:
+                {
+                    error_message = "invalid string: control character U+0012 (DC2) must be escaped to \\u0012";
+                    return token_type::parse_error;
+                }
+
+                case 0x13:
+                {
+                    error_message = "invalid string: control character U+0013 (DC3) must be escaped to \\u0013";
+                    return token_type::parse_error;
+                }
+
+                case 0x14:
+                {
+                    error_message = "invalid string: control character U+0014 (DC4) must be escaped to \\u0014";
+                    return token_type::parse_error;
+                }
+
+                case 0x15:
+                {
+                    error_message = "invalid string: control character U+0015 (NAK) must be escaped to \\u0015";
+                    return token_type::parse_error;
+                }
+
+                case 0x16:
+                {
+                    error_message = "invalid string: control character U+0016 (SYN) must be escaped to \\u0016";
+                    return token_type::parse_error;
+                }
+
+                case 0x17:
+                {
+                    error_message = "invalid string: control character U+0017 (ETB) must be escaped to \\u0017";
+                    return token_type::parse_error;
+                }
+
+                case 0x18:
+                {
+                    error_message = "invalid string: control character U+0018 (CAN) must be escaped to \\u0018";
+                    return token_type::parse_error;
+                }
+
+                case 0x19:
+                {
+                    error_message = "invalid string: control character U+0019 (EM) must be escaped to \\u0019";
+                    return token_type::parse_error;
+                }
+
+                case 0x1A:
+                {
+                    error_message = "invalid string: control character U+001A (SUB) must be escaped to \\u001A";
+                    return token_type::parse_error;
+                }
+
+                case 0x1B:
+                {
+                    error_message = "invalid string: control character U+001B (ESC) must be escaped to \\u001B";
+                    return token_type::parse_error;
+                }
+
+                case 0x1C:
+                {
+                    error_message = "invalid string: control character U+001C (FS) must be escaped to \\u001C";
+                    return token_type::parse_error;
+                }
+
+                case 0x1D:
+                {
+                    error_message = "invalid string: control character U+001D (GS) must be escaped to \\u001D";
+                    return token_type::parse_error;
+                }
+
+                case 0x1E:
+                {
+                    error_message = "invalid string: control character U+001E (RS) must be escaped to \\u001E";
+                    return token_type::parse_error;
+                }
+
+                case 0x1F:
+                {
+                    error_message = "invalid string: control character U+001F (US) must be escaped to \\u001F";
+                    return token_type::parse_error;
+                }
+
+                // U+0020..U+007F (except U+0022 (quote) and U+005C (backspace))
+                case 0x20:
+                case 0x21:
+                case 0x23:
+                case 0x24:
+                case 0x25:
+                case 0x26:
+                case 0x27:
+                case 0x28:
+                case 0x29:
+                case 0x2A:
+                case 0x2B:
+                case 0x2C:
+                case 0x2D:
+                case 0x2E:
+                case 0x2F:
+                case 0x30:
+                case 0x31:
+                case 0x32:
+                case 0x33:
+                case 0x34:
+                case 0x35:
+                case 0x36:
+                case 0x37:
+                case 0x38:
+                case 0x39:
+                case 0x3A:
+                case 0x3B:
+                case 0x3C:
+                case 0x3D:
+                case 0x3E:
+                case 0x3F:
+                case 0x40:
+                case 0x41:
+                case 0x42:
+                case 0x43:
+                case 0x44:
+                case 0x45:
+                case 0x46:
+                case 0x47:
+                case 0x48:
+                case 0x49:
+                case 0x4A:
+                case 0x4B:
+                case 0x4C:
+                case 0x4D:
+                case 0x4E:
+                case 0x4F:
+                case 0x50:
+                case 0x51:
+                case 0x52:
+                case 0x53:
+                case 0x54:
+                case 0x55:
+                case 0x56:
+                case 0x57:
+                case 0x58:
+                case 0x59:
+                case 0x5A:
+                case 0x5B:
+                case 0x5D:
+                case 0x5E:
+                case 0x5F:
+                case 0x60:
+                case 0x61:
+                case 0x62:
+                case 0x63:
+                case 0x64:
+                case 0x65:
+                case 0x66:
+                case 0x67:
+                case 0x68:
+                case 0x69:
+                case 0x6A:
+                case 0x6B:
+                case 0x6C:
+                case 0x6D:
+                case 0x6E:
+                case 0x6F:
+                case 0x70:
+                case 0x71:
+                case 0x72:
+                case 0x73:
+                case 0x74:
+                case 0x75:
+                case 0x76:
+                case 0x77:
+                case 0x78:
+                case 0x79:
+                case 0x7A:
+                case 0x7B:
+                case 0x7C:
+                case 0x7D:
+                case 0x7E:
+                case 0x7F:
+                {
+                    add(current);
+                    break;
+                }
+
+                // U+0080..U+07FF: bytes C2..DF 80..BF
+                case 0xC2:
+                case 0xC3:
+                case 0xC4:
+                case 0xC5:
+                case 0xC6:
+                case 0xC7:
+                case 0xC8:
+                case 0xC9:
+                case 0xCA:
+                case 0xCB:
+                case 0xCC:
+                case 0xCD:
+                case 0xCE:
+                case 0xCF:
+                case 0xD0:
+                case 0xD1:
+                case 0xD2:
+                case 0xD3:
+                case 0xD4:
+                case 0xD5:
+                case 0xD6:
+                case 0xD7:
+                case 0xD8:
+                case 0xD9:
+                case 0xDA:
+                case 0xDB:
+                case 0xDC:
+                case 0xDD:
+                case 0xDE:
+                case 0xDF:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(not next_byte_in_range({0x80, 0xBF})))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+0800..U+0FFF: bytes E0 A0..BF 80..BF
+                case 0xE0:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(not (next_byte_in_range({0xA0, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+1000..U+CFFF: bytes E1..EC 80..BF 80..BF
+                // U+E000..U+FFFF: bytes EE..EF 80..BF 80..BF
+                case 0xE1:
+                case 0xE2:
+                case 0xE3:
+                case 0xE4:
+                case 0xE5:
+                case 0xE6:
+                case 0xE7:
+                case 0xE8:
+                case 0xE9:
+                case 0xEA:
+                case 0xEB:
+                case 0xEC:
+                case 0xEE:
+                case 0xEF:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(not (next_byte_in_range({0x80, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+D000..U+D7FF: bytes ED 80..9F 80..BF
+                case 0xED:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(not (next_byte_in_range({0x80, 0x9F, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+10000..U+3FFFF F0 90..BF 80..BF 80..BF
+                case 0xF0:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(not (next_byte_in_range({0x90, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+40000..U+FFFFF F1..F3 80..BF 80..BF 80..BF
+                case 0xF1:
+                case 0xF2:
+                case 0xF3:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(not (next_byte_in_range({0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // U+100000..U+10FFFF F4 80..8F 80..BF 80..BF
+                case 0xF4:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(not (next_byte_in_range({0x80, 0x8F, 0x80, 0xBF, 0x80, 0xBF}))))
+                    {
+                        return token_type::parse_error;
+                    }
+                    break;
+                }
+
+                // remaining bytes (80..C1 and F5..FF) are ill-formed
+                default:
+                {
+                    error_message = "invalid string: ill-formed UTF-8 byte";
+                    return token_type::parse_error;
+                }
+            }
+        }
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    static void strtof(float& f, const char* str, char** endptr) noexcept
+    {
+        f = std::strtof(str, endptr);
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    static void strtof(double& f, const char* str, char** endptr) noexcept
+    {
+        f = std::strtod(str, endptr);
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    static void strtof(long double& f, const char* str, char** endptr) noexcept
+    {
+        f = std::strtold(str, endptr);
+    }
+
+    /*!
+    @brief scan a number literal
+
+    This function scans a string according to Sect. 6 of RFC 7159.
+
+    The function is realized with a deterministic finite state machine derived
+    from the grammar described in RFC 7159. Starting in state "init", the
+    input is read and used to determined the next state. Only state "done"
+    accepts the number. State "error" is a trap state to model errors. In the
+    table below, "anything" means any character but the ones listed before.
+
+    state    | 0        | 1-9      | e E      | +       | -       | .        | anything
+    ---------|----------|----------|----------|---------|---------|----------|-----------
+    init     | zero     | any1     | [error]  | [error] | minus   | [error]  | [error]
+    minus    | zero     | any1     | [error]  | [error] | [error] | [error]  | [error]
+    zero     | done     | done     | exponent | done    | done    | decimal1 | done
+    any1     | any1     | any1     | exponent | done    | done    | decimal1 | done
+    decimal1 | decimal2 | [error]  | [error]  | [error] | [error] | [error]  | [error]
+    decimal2 | decimal2 | decimal2 | exponent | done    | done    | done     | done
+    exponent | any2     | any2     | [error]  | sign    | sign    | [error]  | [error]
+    sign     | any2     | any2     | [error]  | [error] | [error] | [error]  | [error]
+    any2     | any2     | any2     | done     | done    | done    | done     | done
+
+    The state machine is realized with one label per state (prefixed with
+    "scan_number_") and `goto` statements between them. The state machine
+    contains cycles, but any cycle can be left when EOF is read. Therefore,
+    the function is guaranteed to terminate.
+
+    During scanning, the read bytes are stored in token_buffer. This string is
+    then converted to a signed integer, an unsigned integer, or a
+    floating-point number.
+
+    @return token_type::value_unsigned, token_type::value_integer, or
+            token_type::value_float if number could be successfully scanned,
+            token_type::parse_error otherwise
+
+    @note The scanner is independent of the current locale. Internally, the
+          locale's decimal point is used instead of `.` to work with the
+          locale-dependent converters.
+    */
+    token_type scan_number()  // lgtm [cpp/use-of-goto]
+    {
+        // reset token_buffer to store the number's bytes
+        reset();
+
+        // the type of the parsed number; initially set to unsigned; will be
+        // changed if minus sign, decimal point or exponent is read
+        token_type number_type = token_type::value_unsigned;
+
+        // state (init): we just found out we need to scan a number
+        switch (current)
+        {
+            case '-':
+            {
+                add(current);
+                goto scan_number_minus;
+            }
+
+            case '0':
+            {
+                add(current);
+                goto scan_number_zero;
+            }
+
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any1;
+            }
+
+            // all other characters are rejected outside scan_number()
+            default:            // LCOV_EXCL_LINE
+                assert(false);  // LCOV_EXCL_LINE
+        }
+
+scan_number_minus:
+        // state: we just parsed a leading minus sign
+        number_type = token_type::value_integer;
+        switch (get())
+        {
+            case '0':
+            {
+                add(current);
+                goto scan_number_zero;
+            }
+
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any1;
+            }
+
+            default:
+            {
+                error_message = "invalid number; expected digit after '-'";
+                return token_type::parse_error;
+            }
+        }
+
+scan_number_zero:
+        // state: we just parse a zero (maybe with a leading minus sign)
+        switch (get())
+        {
+            case '.':
+            {
+                add(decimal_point_char);
+                goto scan_number_decimal1;
+            }
+
+            case 'e':
+            case 'E':
+            {
+                add(current);
+                goto scan_number_exponent;
+            }
+
+            default:
+                goto scan_number_done;
+        }
+
+scan_number_any1:
+        // state: we just parsed a number 0-9 (maybe with a leading minus sign)
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any1;
+            }
+
+            case '.':
+            {
+                add(decimal_point_char);
+                goto scan_number_decimal1;
+            }
+
+            case 'e':
+            case 'E':
+            {
+                add(current);
+                goto scan_number_exponent;
+            }
+
+            default:
+                goto scan_number_done;
+        }
+
+scan_number_decimal1:
+        // state: we just parsed a decimal point
+        number_type = token_type::value_float;
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_decimal2;
+            }
+
+            default:
+            {
+                error_message = "invalid number; expected digit after '.'";
+                return token_type::parse_error;
+            }
+        }
+
+scan_number_decimal2:
+        // we just parsed at least one number after a decimal point
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_decimal2;
+            }
+
+            case 'e':
+            case 'E':
+            {
+                add(current);
+                goto scan_number_exponent;
+            }
+
+            default:
+                goto scan_number_done;
+        }
+
+scan_number_exponent:
+        // we just parsed an exponent
+        number_type = token_type::value_float;
+        switch (get())
+        {
+            case '+':
+            case '-':
+            {
+                add(current);
+                goto scan_number_sign;
+            }
+
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any2;
+            }
+
+            default:
+            {
+                error_message =
+                    "invalid number; expected '+', '-', or digit after exponent";
+                return token_type::parse_error;
+            }
+        }
+
+scan_number_sign:
+        // we just parsed an exponent sign
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any2;
+            }
+
+            default:
+            {
+                error_message = "invalid number; expected digit after exponent sign";
+                return token_type::parse_error;
+            }
+        }
+
+scan_number_any2:
+        // we just parsed a number after the exponent or exponent sign
+        switch (get())
+        {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+            {
+                add(current);
+                goto scan_number_any2;
+            }
+
+            default:
+                goto scan_number_done;
+        }
+
+scan_number_done:
+        // unget the character after the number (we only read it to know that
+        // we are done scanning a number)
+        unget();
+
+        char* endptr = nullptr;
+        errno = 0;
+
+        // try to parse integers first and fall back to floats
+        if (number_type == token_type::value_unsigned)
+        {
+            const auto x = std::strtoull(token_buffer.data(), &endptr, 10);
+
+            // we checked the number format before
+            assert(endptr == token_buffer.data() + token_buffer.size());
+
+            if (errno == 0)
+            {
+                value_unsigned = static_cast<number_unsigned_t>(x);
+                if (value_unsigned == x)
+                {
+                    return token_type::value_unsigned;
+                }
+            }
+        }
+        else if (number_type == token_type::value_integer)
+        {
+            const auto x = std::strtoll(token_buffer.data(), &endptr, 10);
+
+            // we checked the number format before
+            assert(endptr == token_buffer.data() + token_buffer.size());
+
+            if (errno == 0)
+            {
+                value_integer = static_cast<number_integer_t>(x);
+                if (value_integer == x)
+                {
+                    return token_type::value_integer;
+                }
+            }
+        }
+
+        // this code is reached if we parse a floating-point number or if an
+        // integer conversion above failed
+        strtof(value_float, token_buffer.data(), &endptr);
+
+        // we checked the number format before
+        assert(endptr == token_buffer.data() + token_buffer.size());
+
+        return token_type::value_float;
+    }
+
+    /*!
+    @param[in] literal_text  the literal text to expect
+    @param[in] length        the length of the passed literal text
+    @param[in] return_type   the token type to return on success
+    */
+    JSON_HEDLEY_NON_NULL(2)
+    token_type scan_literal(const char* literal_text, const std::size_t length,
+                            token_type return_type)
+    {
+        assert(current == literal_text[0]);
+        for (std::size_t i = 1; i < length; ++i)
+        {
+            if (JSON_HEDLEY_UNLIKELY(get() != literal_text[i]))
+            {
+                error_message = "invalid literal";
+                return token_type::parse_error;
+            }
+        }
+        return return_type;
+    }
+
+    /////////////////////
+    // input management
+    /////////////////////
+
+    /// reset token_buffer; current character is beginning of token
+    void reset() noexcept
+    {
+        token_buffer.clear();
+        token_string.clear();
+        token_string.push_back(std::char_traits<char>::to_char_type(current));
+    }
+
+    /*
+    @brief get next character from the input
+
+    This function provides the interface to the used input adapter. It does
+    not throw in case the input reached EOF, but returns a
+    `std::char_traits<char>::eof()` in that case.  Stores the scanned characters
+    for use in error messages.
+
+    @return character read from the input
+    */
+    std::char_traits<char>::int_type get()
+    {
+        ++position.chars_read_total;
+        ++position.chars_read_current_line;
+
+        if (next_unget)
+        {
+            // just reset the next_unget variable and work with current
+            next_unget = false;
+        }
+        else
+        {
+            current = ia->get_character();
+        }
+
+        if (JSON_HEDLEY_LIKELY(current != std::char_traits<char>::eof()))
+        {
+            token_string.push_back(std::char_traits<char>::to_char_type(current));
+        }
+
+        if (current == '\n')
+        {
+            ++position.lines_read;
+            position.chars_read_current_line = 0;
+        }
+
+        return current;
+    }
+
+    /*!
+    @brief unget current character (read it again on next get)
+
+    We implement unget by setting variable next_unget to true. The input is not
+    changed - we just simulate ungetting by modifying chars_read_total,
+    chars_read_current_line, and token_string. The next call to get() will
+    behave as if the unget character is read again.
+    */
+    void unget()
+    {
+        next_unget = true;
+
+        --position.chars_read_total;
+
+        // in case we "unget" a newline, we have to also decrement the lines_read
+        if (position.chars_read_current_line == 0)
+        {
+            if (position.lines_read > 0)
+            {
+                --position.lines_read;
+            }
+        }
+        else
+        {
+            --position.chars_read_current_line;
+        }
+
+        if (JSON_HEDLEY_LIKELY(current != std::char_traits<char>::eof()))
+        {
+            assert(not token_string.empty());
+            token_string.pop_back();
+        }
+    }
+
+    /// add a character to token_buffer
+    void add(int c)
+    {
+        token_buffer.push_back(std::char_traits<char>::to_char_type(c));
+    }
+
+  public:
+    /////////////////////
+    // value getters
+    /////////////////////
+
+    /// return integer value
+    constexpr number_integer_t get_number_integer() const noexcept
+    {
+        return value_integer;
+    }
+
+    /// return unsigned integer value
+    constexpr number_unsigned_t get_number_unsigned() const noexcept
+    {
+        return value_unsigned;
+    }
+
+    /// return floating-point value
+    constexpr number_float_t get_number_float() const noexcept
+    {
+        return value_float;
+    }
+
+    /// return current string value (implicitly resets the token; useful only once)
+    string_t& get_string()
+    {
+        return token_buffer;
+    }
+
+    /////////////////////
+    // diagnostics
+    /////////////////////
+
+    /// return position of last read token
+    constexpr position_t get_position() const noexcept
+    {
+        return position;
+    }
+
+    /// return the last read token (for errors only).  Will never contain EOF
+    /// (an arbitrary value that is not a valid char value, often -1), because
+    /// 255 may legitimately occur.  May contain NUL, which should be escaped.
+    std::string get_token_string() const
+    {
+        // escape control characters
+        std::string result;
+        for (const auto c : token_string)
+        {
+            if ('\x00' <= c and c <= '\x1F')
+            {
+                // escape control characters
+                std::array<char, 9> cs{{}};
+                (std::snprintf)(cs.data(), cs.size(), "<U+%.4X>", static_cast<unsigned char>(c));
+                result += cs.data();
+            }
+            else
+            {
+                // add character as is
+                result.push_back(c);
+            }
+        }
+
+        return result;
+    }
+
+    /// return syntax error message
+    JSON_HEDLEY_RETURNS_NON_NULL
+    constexpr const char* get_error_message() const noexcept
+    {
+        return error_message;
+    }
+
+    /////////////////////
+    // actual scanner
+    /////////////////////
+
+    /*!
+    @brief skip the UTF-8 byte order mark
+    @return true iff there is no BOM or the correct BOM has been skipped
+    */
+    bool skip_bom()
+    {
+        if (get() == 0xEF)
+        {
+            // check if we completely parse the BOM
+            return get() == 0xBB and get() == 0xBF;
+        }
+
+        // the first character is not the beginning of the BOM; unget it to
+        // process is later
+        unget();
+        return true;
+    }
+
+    token_type scan()
+    {
+        // initially, skip the BOM
+        if (position.chars_read_total == 0 and not skip_bom())
+        {
+            error_message = "invalid BOM; must be 0xEF 0xBB 0xBF if given";
+            return token_type::parse_error;
+        }
+
+        // read next character and ignore whitespace
+        do
+        {
+            get();
+        }
+        while (current == ' ' or current == '\t' or current == '\n' or current == '\r');
+
+        switch (current)
+        {
+            // structural characters
+            case '[':
+                return token_type::begin_array;
+            case ']':
+                return token_type::end_array;
+            case '{':
+                return token_type::begin_object;
+            case '}':
+                return token_type::end_object;
+            case ':':
+                return token_type::name_separator;
+            case ',':
+                return token_type::value_separator;
+
+            // literals
+            case 't':
+                return scan_literal("true", 4, token_type::literal_true);
+            case 'f':
+                return scan_literal("false", 5, token_type::literal_false);
+            case 'n':
+                return scan_literal("null", 4, token_type::literal_null);
+
+            // string
+            case '\"':
+                return scan_string();
+
+            // number
+            case '-':
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+                return scan_number();
+
+            // end of input (the null byte is needed when parsing from
+            // string literals)
+            case '\0':
+            case std::char_traits<char>::eof():
+                return token_type::end_of_input;
+
+            // error
+            default:
+                error_message = "invalid literal";
+                return token_type::parse_error;
+        }
+    }
+
+  private:
+    /// input adapter
+    detail::input_adapter_t ia = nullptr;
+
+    /// the current character
+    std::char_traits<char>::int_type current = std::char_traits<char>::eof();
+
+    /// whether the next get() call should just return current
+    bool next_unget = false;
+
+    /// the start position of the current token
+    position_t position {};
+
+    /// raw input token string (for error messages)
+    std::vector<char> token_string {};
+
+    /// buffer for variable-length tokens (numbers, strings)
+    string_t token_buffer {};
+
+    /// a description of occurred lexer errors
+    const char* error_message = "";
+
+    // number values
+    number_integer_t value_integer = 0;
+    number_unsigned_t value_unsigned = 0;
+    number_float_t value_float = 0;
+
+    /// the decimal point
+    const char decimal_point_char = '.';
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/input/parser.hpp>
+
+
+#include <cassert> // assert
+#include <cmath> // isfinite
+#include <cstdint> // uint8_t
+#include <functional> // function
+#include <string> // string
+#include <utility> // move
+#include <vector> // vector
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/input/input_adapters.hpp>
+
+// #include <nlohmann/detail/input/json_sax.hpp>
+
+// #include <nlohmann/detail/input/lexer.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/is_sax.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+////////////
+// parser //
+////////////
+
+/*!
+@brief syntax analysis
+
+This class implements a recursive decent parser.
+*/
+template<typename BasicJsonType>
+class parser
+{
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using string_t = typename BasicJsonType::string_t;
+    using lexer_t = lexer<BasicJsonType>;
+    using token_type = typename lexer_t::token_type;
+
+  public:
+    enum class parse_event_t : uint8_t
+    {
+        /// the parser read `{` and started to process a JSON object
+        object_start,
+        /// the parser read `}` and finished processing a JSON object
+        object_end,
+        /// the parser read `[` and started to process a JSON array
+        array_start,
+        /// the parser read `]` and finished processing a JSON array
+        array_end,
+        /// the parser read a key of a value in an object
+        key,
+        /// the parser finished reading a JSON value
+        value
+    };
+
+    using parser_callback_t =
+        std::function<bool(int depth, parse_event_t event, BasicJsonType& parsed)>;
+
+    /// a parser reading from an input adapter
+    explicit parser(detail::input_adapter_t&& adapter,
+                    const parser_callback_t cb = nullptr,
+                    const bool allow_exceptions_ = true)
+        : callback(cb), m_lexer(std::move(adapter)), allow_exceptions(allow_exceptions_)
+    {
+        // read first token
+        get_token();
+    }
+
+    /*!
+    @brief public parser interface
+
+    @param[in] strict      whether to expect the last token to be EOF
+    @param[in,out] result  parsed JSON value
+
+    @throw parse_error.101 in case of an unexpected token
+    @throw parse_error.102 if to_unicode fails or surrogate error
+    @throw parse_error.103 if to_unicode fails
+    */
+    void parse(const bool strict, BasicJsonType& result)
+    {
+        if (callback)
+        {
+            json_sax_dom_callback_parser<BasicJsonType> sdp(result, callback, allow_exceptions);
+            sax_parse_internal(&sdp);
+            result.assert_invariant();
+
+            // in strict mode, input must be completely read
+            if (strict and (get_token() != token_type::end_of_input))
+            {
+                sdp.parse_error(m_lexer.get_position(),
+                                m_lexer.get_token_string(),
+                                parse_error::create(101, m_lexer.get_position(),
+                                                    exception_message(token_type::end_of_input, "value")));
+            }
+
+            // in case of an error, return discarded value
+            if (sdp.is_errored())
+            {
+                result = value_t::discarded;
+                return;
+            }
+
+            // set top-level value to null if it was discarded by the callback
+            // function
+            if (result.is_discarded())
+            {
+                result = nullptr;
+            }
+        }
+        else
+        {
+            json_sax_dom_parser<BasicJsonType> sdp(result, allow_exceptions);
+            sax_parse_internal(&sdp);
+            result.assert_invariant();
+
+            // in strict mode, input must be completely read
+            if (strict and (get_token() != token_type::end_of_input))
+            {
+                sdp.parse_error(m_lexer.get_position(),
+                                m_lexer.get_token_string(),
+                                parse_error::create(101, m_lexer.get_position(),
+                                                    exception_message(token_type::end_of_input, "value")));
+            }
+
+            // in case of an error, return discarded value
+            if (sdp.is_errored())
+            {
+                result = value_t::discarded;
+                return;
+            }
+        }
+    }
+
+    /*!
+    @brief public accept interface
+
+    @param[in] strict  whether to expect the last token to be EOF
+    @return whether the input is a proper JSON text
+    */
+    bool accept(const bool strict = true)
+    {
+        json_sax_acceptor<BasicJsonType> sax_acceptor;
+        return sax_parse(&sax_acceptor, strict);
+    }
+
+    template <typename SAX>
+    JSON_HEDLEY_NON_NULL(2)
+    bool sax_parse(SAX* sax, const bool strict = true)
+    {
+        (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
+        const bool result = sax_parse_internal(sax);
+
+        // strict mode: next byte must be EOF
+        if (result and strict and (get_token() != token_type::end_of_input))
+        {
+            return sax->parse_error(m_lexer.get_position(),
+                                    m_lexer.get_token_string(),
+                                    parse_error::create(101, m_lexer.get_position(),
+                                            exception_message(token_type::end_of_input, "value")));
+        }
+
+        return result;
+    }
+
+  private:
+    template <typename SAX>
+    JSON_HEDLEY_NON_NULL(2)
+    bool sax_parse_internal(SAX* sax)
+    {
+        // stack to remember the hierarchy of structured values we are parsing
+        // true = array; false = object
+        std::vector<bool> states;
+        // value to avoid a goto (see comment where set to true)
+        bool skip_to_state_evaluation = false;
+
+        while (true)
+        {
+            if (not skip_to_state_evaluation)
+            {
+                // invariant: get_token() was called before each iteration
+                switch (last_token)
+                {
+                    case token_type::begin_object:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(not sax->start_object(std::size_t(-1))))
+                        {
+                            return false;
+                        }
+
+                        // closing } -> we are done
+                        if (get_token() == token_type::end_object)
+                        {
+                            if (JSON_HEDLEY_UNLIKELY(not sax->end_object()))
+                            {
+                                return false;
+                            }
+                            break;
+                        }
+
+                        // parse key
+                        if (JSON_HEDLEY_UNLIKELY(last_token != token_type::value_string))
+                        {
+                            return sax->parse_error(m_lexer.get_position(),
+                                                    m_lexer.get_token_string(),
+                                                    parse_error::create(101, m_lexer.get_position(),
+                                                            exception_message(token_type::value_string, "object key")));
+                        }
+                        if (JSON_HEDLEY_UNLIKELY(not sax->key(m_lexer.get_string())))
+                        {
+                            return false;
+                        }
+
+                        // parse separator (:)
+                        if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
+                        {
+                            return sax->parse_error(m_lexer.get_position(),
+                                                    m_lexer.get_token_string(),
+                                                    parse_error::create(101, m_lexer.get_position(),
+                                                            exception_message(token_type::name_separator, "object separator")));
+                        }
+
+                        // remember we are now inside an object
+                        states.push_back(false);
+
+                        // parse values
+                        get_token();
+                        continue;
+                    }
+
+                    case token_type::begin_array:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(not sax->start_array(std::size_t(-1))))
+                        {
+                            return false;
+                        }
+
+                        // closing ] -> we are done
+                        if (get_token() == token_type::end_array)
+                        {
+                            if (JSON_HEDLEY_UNLIKELY(not sax->end_array()))
+                            {
+                                return false;
+                            }
+                            break;
+                        }
+
+                        // remember we are now inside an array
+                        states.push_back(true);
+
+                        // parse values (no need to call get_token)
+                        continue;
+                    }
+
+                    case token_type::value_float:
+                    {
+                        const auto res = m_lexer.get_number_float();
+
+                        if (JSON_HEDLEY_UNLIKELY(not std::isfinite(res)))
+                        {
+                            return sax->parse_error(m_lexer.get_position(),
+                                                    m_lexer.get_token_string(),
+                                                    out_of_range::create(406, "number overflow parsing '" + m_lexer.get_token_string() + "'"));
+                        }
+
+                        if (JSON_HEDLEY_UNLIKELY(not sax->number_float(res, m_lexer.get_string())))
+                        {
+                            return false;
+                        }
+
+                        break;
+                    }
+
+                    case token_type::literal_false:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(not sax->boolean(false)))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::literal_null:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(not sax->null()))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::literal_true:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(not sax->boolean(true)))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::value_integer:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(not sax->number_integer(m_lexer.get_number_integer())))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::value_string:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(not sax->string(m_lexer.get_string())))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::value_unsigned:
+                    {
+                        if (JSON_HEDLEY_UNLIKELY(not sax->number_unsigned(m_lexer.get_number_unsigned())))
+                        {
+                            return false;
+                        }
+                        break;
+                    }
+
+                    case token_type::parse_error:
+                    {
+                        // using "uninitialized" to avoid "expected" message
+                        return sax->parse_error(m_lexer.get_position(),
+                                                m_lexer.get_token_string(),
+                                                parse_error::create(101, m_lexer.get_position(),
+                                                        exception_message(token_type::uninitialized, "value")));
+                    }
+
+                    default: // the last token was unexpected
+                    {
+                        return sax->parse_error(m_lexer.get_position(),
+                                                m_lexer.get_token_string(),
+                                                parse_error::create(101, m_lexer.get_position(),
+                                                        exception_message(token_type::literal_or_value, "value")));
+                    }
+                }
+            }
+            else
+            {
+                skip_to_state_evaluation = false;
+            }
+
+            // we reached this line after we successfully parsed a value
+            if (states.empty())
+            {
+                // empty stack: we reached the end of the hierarchy: done
+                return true;
+            }
+
+            if (states.back())  // array
+            {
+                // comma -> next value
+                if (get_token() == token_type::value_separator)
+                {
+                    // parse a new value
+                    get_token();
+                    continue;
+                }
+
+                // closing ]
+                if (JSON_HEDLEY_LIKELY(last_token == token_type::end_array))
+                {
+                    if (JSON_HEDLEY_UNLIKELY(not sax->end_array()))
+                    {
+                        return false;
+                    }
+
+                    // We are done with this array. Before we can parse a
+                    // new value, we need to evaluate the new state first.
+                    // By setting skip_to_state_evaluation to false, we
+                    // are effectively jumping to the beginning of this if.
+                    assert(not states.empty());
+                    states.pop_back();
+                    skip_to_state_evaluation = true;
+                    continue;
+                }
+
+                return sax->parse_error(m_lexer.get_position(),
+                                        m_lexer.get_token_string(),
+                                        parse_error::create(101, m_lexer.get_position(),
+                                                exception_message(token_type::end_array, "array")));
+            }
+            else  // object
+            {
+                // comma -> next value
+                if (get_token() == token_type::value_separator)
+                {
+                    // parse key
+                    if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::value_string))
+                    {
+                        return sax->parse_error(m_lexer.get_position(),
+                                                m_lexer.get_token_string(),
+                                                parse_error::create(101, m_lexer.get_position(),
+                                                        exception_message(token_type::value_string, "object key")));
+                    }
+
+                    if (JSON_HEDLEY_UNLIKELY(not sax->key(m_lexer.get_string())))
+                    {
+                        return false;
+                    }
+
+                    // parse separator (:)
+                    if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
+                    {
+                        return sax->parse_error(m_lexer.get_position(),
+                                                m_lexer.get_token_string(),
+                                                parse_error::create(101, m_lexer.get_position(),
+                                                        exception_message(token_type::name_separator, "object separator")));
+                    }
+
+                    // parse values
+                    get_token();
+                    continue;
+                }
+
+                // closing }
+                if (JSON_HEDLEY_LIKELY(last_token == token_type::end_object))
+                {
+                    if (JSON_HEDLEY_UNLIKELY(not sax->end_object()))
+                    {
+                        return false;
+                    }
+
+                    // We are done with this object. Before we can parse a
+                    // new value, we need to evaluate the new state first.
+                    // By setting skip_to_state_evaluation to false, we
+                    // are effectively jumping to the beginning of this if.
+                    assert(not states.empty());
+                    states.pop_back();
+                    skip_to_state_evaluation = true;
+                    continue;
+                }
+
+                return sax->parse_error(m_lexer.get_position(),
+                                        m_lexer.get_token_string(),
+                                        parse_error::create(101, m_lexer.get_position(),
+                                                exception_message(token_type::end_object, "object")));
+            }
+        }
+    }
+
+    /// get next token from lexer
+    token_type get_token()
+    {
+        return last_token = m_lexer.scan();
+    }
+
+    std::string exception_message(const token_type expected, const std::string& context)
+    {
+        std::string error_msg = "syntax error ";
+
+        if (not context.empty())
+        {
+            error_msg += "while parsing " + context + " ";
+        }
+
+        error_msg += "- ";
+
+        if (last_token == token_type::parse_error)
+        {
+            error_msg += std::string(m_lexer.get_error_message()) + "; last read: '" +
+                         m_lexer.get_token_string() + "'";
+        }
+        else
+        {
+            error_msg += "unexpected " + std::string(lexer_t::token_type_name(last_token));
+        }
+
+        if (expected != token_type::uninitialized)
+        {
+            error_msg += "; expected " + std::string(lexer_t::token_type_name(expected));
+        }
+
+        return error_msg;
+    }
+
+  private:
+    /// callback function
+    const parser_callback_t callback = nullptr;
+    /// the type of the last read token
+    token_type last_token = token_type::uninitialized;
+    /// the lexer
+    lexer_t m_lexer;
+    /// whether to throw exceptions in case of errors
+    const bool allow_exceptions = true;
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/iterators/internal_iterator.hpp>
+
+
+// #include <nlohmann/detail/iterators/primitive_iterator.hpp>
+
+
+#include <cstddef> // ptrdiff_t
+#include <limits>  // numeric_limits
+
+namespace nlohmann
+{
+namespace detail
+{
+/*
+@brief an iterator for primitive JSON types
+
+This class models an iterator for primitive JSON types (boolean, number,
+string). It's only purpose is to allow the iterator/const_iterator classes
+to "iterate" over primitive values. Internally, the iterator is modeled by
+a `difference_type` variable. Value begin_value (`0`) models the begin,
+end_value (`1`) models past the end.
+*/
+class primitive_iterator_t
+{
+  private:
+    using difference_type = std::ptrdiff_t;
+    static constexpr difference_type begin_value = 0;
+    static constexpr difference_type end_value = begin_value + 1;
+
+    /// iterator as signed integer type
+    difference_type m_it = (std::numeric_limits<std::ptrdiff_t>::min)();
+
+  public:
+    constexpr difference_type get_value() const noexcept
+    {
+        return m_it;
+    }
+
+    /// set iterator to a defined beginning
+    void set_begin() noexcept
+    {
+        m_it = begin_value;
+    }
+
+    /// set iterator to a defined past the end
+    void set_end() noexcept
+    {
+        m_it = end_value;
+    }
+
+    /// return whether the iterator can be dereferenced
+    constexpr bool is_begin() const noexcept
+    {
+        return m_it == begin_value;
+    }
+
+    /// return whether the iterator is at end
+    constexpr bool is_end() const noexcept
+    {
+        return m_it == end_value;
+    }
+
+    friend constexpr bool operator==(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
+    {
+        return lhs.m_it == rhs.m_it;
+    }
+
+    friend constexpr bool operator<(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
+    {
+        return lhs.m_it < rhs.m_it;
+    }
+
+    primitive_iterator_t operator+(difference_type n) noexcept
+    {
+        auto result = *this;
+        result += n;
+        return result;
+    }
+
+    friend constexpr difference_type operator-(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
+    {
+        return lhs.m_it - rhs.m_it;
+    }
+
+    primitive_iterator_t& operator++() noexcept
+    {
+        ++m_it;
+        return *this;
+    }
+
+    primitive_iterator_t const operator++(int) noexcept
+    {
+        auto result = *this;
+        ++m_it;
+        return result;
+    }
+
+    primitive_iterator_t& operator--() noexcept
+    {
+        --m_it;
+        return *this;
+    }
+
+    primitive_iterator_t const operator--(int) noexcept
+    {
+        auto result = *this;
+        --m_it;
+        return result;
+    }
+
+    primitive_iterator_t& operator+=(difference_type n) noexcept
+    {
+        m_it += n;
+        return *this;
+    }
+
+    primitive_iterator_t& operator-=(difference_type n) noexcept
+    {
+        m_it -= n;
+        return *this;
+    }
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+
+namespace nlohmann
+{
+namespace detail
+{
+/*!
+@brief an iterator value
+
+@note This structure could easily be a union, but MSVC currently does not allow
+unions members with complex constructors, see https://github.com/nlohmann/json/pull/105.
+*/
+template<typename BasicJsonType> struct internal_iterator
+{
+    /// iterator for JSON objects
+    typename BasicJsonType::object_t::iterator object_iterator {};
+    /// iterator for JSON arrays
+    typename BasicJsonType::array_t::iterator array_iterator {};
+    /// generic iterator for all other types
+    primitive_iterator_t primitive_iterator {};
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/iterators/iter_impl.hpp>
+
+
+#include <ciso646> // not
+#include <iterator> // iterator, random_access_iterator_tag, bidirectional_iterator_tag, advance, next
+#include <type_traits> // conditional, is_const, remove_const
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/iterators/internal_iterator.hpp>
+
+// #include <nlohmann/detail/iterators/primitive_iterator.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+// forward declare, to be able to friend it later on
+template<typename IteratorType> class iteration_proxy;
+template<typename IteratorType> class iteration_proxy_value;
+
+/*!
+@brief a template for a bidirectional iterator for the @ref basic_json class
+This class implements a both iterators (iterator and const_iterator) for the
+@ref basic_json class.
+@note An iterator is called *initialized* when a pointer to a JSON value has
+      been set (e.g., by a constructor or a copy assignment). If the iterator is
+      default-constructed, it is *uninitialized* and most methods are undefined.
+      **The library uses assertions to detect calls on uninitialized iterators.**
+@requirement The class satisfies the following concept requirements:
+-
+[BidirectionalIterator](https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator):
+  The iterator that can be moved can be moved in both directions (i.e.
+  incremented and decremented).
+@since version 1.0.0, simplified in version 2.0.9, change to bidirectional
+       iterators in version 3.0.0 (see https://github.com/nlohmann/json/issues/593)
+*/
+template<typename BasicJsonType>
+class iter_impl
+{
+    /// allow basic_json to access private members
+    friend iter_impl<typename std::conditional<std::is_const<BasicJsonType>::value, typename std::remove_const<BasicJsonType>::type, const BasicJsonType>::type>;
+    friend BasicJsonType;
+    friend iteration_proxy<iter_impl>;
+    friend iteration_proxy_value<iter_impl>;
+
+    using object_t = typename BasicJsonType::object_t;
+    using array_t = typename BasicJsonType::array_t;
+    // make sure BasicJsonType is basic_json or const basic_json
+    static_assert(is_basic_json<typename std::remove_const<BasicJsonType>::type>::value,
+                  "iter_impl only accepts (const) basic_json");
+
+  public:
+
+    /// The std::iterator class template (used as a base class to provide typedefs) is deprecated in C++17.
+    /// The C++ Standard has never required user-defined iterators to derive from std::iterator.
+    /// A user-defined iterator should provide publicly accessible typedefs named
+    /// iterator_category, value_type, difference_type, pointer, and reference.
+    /// Note that value_type is required to be non-const, even for constant iterators.
+    using iterator_category = std::bidirectional_iterator_tag;
+
+    /// the type of the values when the iterator is dereferenced
+    using value_type = typename BasicJsonType::value_type;
+    /// a type to represent differences between iterators
+    using difference_type = typename BasicJsonType::difference_type;
+    /// defines a pointer to the type iterated over (value_type)
+    using pointer = typename std::conditional<std::is_const<BasicJsonType>::value,
+          typename BasicJsonType::const_pointer,
+          typename BasicJsonType::pointer>::type;
+    /// defines a reference to the type iterated over (value_type)
+    using reference =
+        typename std::conditional<std::is_const<BasicJsonType>::value,
+        typename BasicJsonType::const_reference,
+        typename BasicJsonType::reference>::type;
+
+    /// default constructor
+    iter_impl() = default;
+
+    /*!
+    @brief constructor for a given JSON instance
+    @param[in] object  pointer to a JSON object for this iterator
+    @pre object != nullptr
+    @post The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    explicit iter_impl(pointer object) noexcept : m_object(object)
+    {
+        assert(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+            {
+                m_it.object_iterator = typename object_t::iterator();
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_it.array_iterator = typename array_t::iterator();
+                break;
+            }
+
+            default:
+            {
+                m_it.primitive_iterator = primitive_iterator_t();
+                break;
+            }
+        }
+    }
+
+    /*!
+    @note The conventional copy constructor and copy assignment are implicitly
+          defined. Combined with the following converting constructor and
+          assignment, they support: (1) copy from iterator to iterator, (2)
+          copy from const iterator to const iterator, and (3) conversion from
+          iterator to const iterator. However conversion from const iterator
+          to iterator is not defined.
+    */
+
+    /*!
+    @brief const copy constructor
+    @param[in] other const iterator to copy from
+    @note This copy constuctor had to be defined explicitely to circumvent a bug
+          occuring on msvc v19.0 compiler (VS 2015) debug build. For more
+          information refer to: https://github.com/nlohmann/json/issues/1608
+    */
+    iter_impl(const iter_impl<const BasicJsonType>& other) noexcept
+        : m_object(other.m_object), m_it(other.m_it)
+    {}
+
+    /*!
+    @brief converting assignment
+    @param[in] other const iterator to copy from
+    @return const/non-const iterator
+    @note It is not checked whether @a other is initialized.
+    */
+    iter_impl& operator=(const iter_impl<const BasicJsonType>& other) noexcept
+    {
+        m_object = other.m_object;
+        m_it = other.m_it;
+        return *this;
+    }
+
+    /*!
+    @brief converting constructor
+    @param[in] other  non-const iterator to copy from
+    @note It is not checked whether @a other is initialized.
+    */
+    iter_impl(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept
+        : m_object(other.m_object), m_it(other.m_it)
+    {}
+
+    /*!
+    @brief converting assignment
+    @param[in] other  non-const iterator to copy from
+    @return const/non-const iterator
+    @note It is not checked whether @a other is initialized.
+    */
+    iter_impl& operator=(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept
+    {
+        m_object = other.m_object;
+        m_it = other.m_it;
+        return *this;
+    }
+
+  private:
+    /*!
+    @brief set the iterator to the first value
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    void set_begin() noexcept
+    {
+        assert(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+            {
+                m_it.object_iterator = m_object->m_value.object->begin();
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_it.array_iterator = m_object->m_value.array->begin();
+                break;
+            }
+
+            case value_t::null:
+            {
+                // set to end so begin()==end() is true: null is empty
+                m_it.primitive_iterator.set_end();
+                break;
+            }
+
+            default:
+            {
+                m_it.primitive_iterator.set_begin();
+                break;
+            }
+        }
+    }
+
+    /*!
+    @brief set the iterator past the last value
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    void set_end() noexcept
+    {
+        assert(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+            {
+                m_it.object_iterator = m_object->m_value.object->end();
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_it.array_iterator = m_object->m_value.array->end();
+                break;
+            }
+
+            default:
+            {
+                m_it.primitive_iterator.set_end();
+                break;
+            }
+        }
+    }
+
+  public:
+    /*!
+    @brief return a reference to the value pointed to by the iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    reference operator*() const
+    {
+        assert(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+            {
+                assert(m_it.object_iterator != m_object->m_value.object->end());
+                return m_it.object_iterator->second;
+            }
+
+            case value_t::array:
+            {
+                assert(m_it.array_iterator != m_object->m_value.array->end());
+                return *m_it.array_iterator;
+            }
+
+            case value_t::null:
+                JSON_THROW(invalid_iterator::create(214, "cannot get value"));
+
+            default:
+            {
+                if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
+                {
+                    return *m_object;
+                }
+
+                JSON_THROW(invalid_iterator::create(214, "cannot get value"));
+            }
+        }
+    }
+
+    /*!
+    @brief dereference the iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    pointer operator->() const
+    {
+        assert(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+            {
+                assert(m_it.object_iterator != m_object->m_value.object->end());
+                return &(m_it.object_iterator->second);
+            }
+
+            case value_t::array:
+            {
+                assert(m_it.array_iterator != m_object->m_value.array->end());
+                return &*m_it.array_iterator;
+            }
+
+            default:
+            {
+                if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
+                {
+                    return m_object;
+                }
+
+                JSON_THROW(invalid_iterator::create(214, "cannot get value"));
+            }
+        }
+    }
+
+    /*!
+    @brief post-increment (it++)
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl const operator++(int)
+    {
+        auto result = *this;
+        ++(*this);
+        return result;
+    }
+
+    /*!
+    @brief pre-increment (++it)
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl& operator++()
+    {
+        assert(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+            {
+                std::advance(m_it.object_iterator, 1);
+                break;
+            }
+
+            case value_t::array:
+            {
+                std::advance(m_it.array_iterator, 1);
+                break;
+            }
+
+            default:
+            {
+                ++m_it.primitive_iterator;
+                break;
+            }
+        }
+
+        return *this;
+    }
+
+    /*!
+    @brief post-decrement (it--)
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl const operator--(int)
+    {
+        auto result = *this;
+        --(*this);
+        return result;
+    }
+
+    /*!
+    @brief pre-decrement (--it)
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl& operator--()
+    {
+        assert(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+            {
+                std::advance(m_it.object_iterator, -1);
+                break;
+            }
+
+            case value_t::array:
+            {
+                std::advance(m_it.array_iterator, -1);
+                break;
+            }
+
+            default:
+            {
+                --m_it.primitive_iterator;
+                break;
+            }
+        }
+
+        return *this;
+    }
+
+    /*!
+    @brief  comparison: equal
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator==(const iter_impl& other) const
+    {
+        // if objects are not the same, the comparison is undefined
+        if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers"));
+        }
+
+        assert(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+                return (m_it.object_iterator == other.m_it.object_iterator);
+
+            case value_t::array:
+                return (m_it.array_iterator == other.m_it.array_iterator);
+
+            default:
+                return (m_it.primitive_iterator == other.m_it.primitive_iterator);
+        }
+    }
+
+    /*!
+    @brief  comparison: not equal
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator!=(const iter_impl& other) const
+    {
+        return not operator==(other);
+    }
+
+    /*!
+    @brief  comparison: smaller
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator<(const iter_impl& other) const
+    {
+        // if objects are not the same, the comparison is undefined
+        if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers"));
+        }
+
+        assert(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+                JSON_THROW(invalid_iterator::create(213, "cannot compare order of object iterators"));
+
+            case value_t::array:
+                return (m_it.array_iterator < other.m_it.array_iterator);
+
+            default:
+                return (m_it.primitive_iterator < other.m_it.primitive_iterator);
+        }
+    }
+
+    /*!
+    @brief  comparison: less than or equal
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator<=(const iter_impl& other) const
+    {
+        return not other.operator < (*this);
+    }
+
+    /*!
+    @brief  comparison: greater than
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator>(const iter_impl& other) const
+    {
+        return not operator<=(other);
+    }
+
+    /*!
+    @brief  comparison: greater than or equal
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    bool operator>=(const iter_impl& other) const
+    {
+        return not operator<(other);
+    }
+
+    /*!
+    @brief  add to iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl& operator+=(difference_type i)
+    {
+        assert(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+                JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators"));
+
+            case value_t::array:
+            {
+                std::advance(m_it.array_iterator, i);
+                break;
+            }
+
+            default:
+            {
+                m_it.primitive_iterator += i;
+                break;
+            }
+        }
+
+        return *this;
+    }
+
+    /*!
+    @brief  subtract from iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl& operator-=(difference_type i)
+    {
+        return operator+=(-i);
+    }
+
+    /*!
+    @brief  add to iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl operator+(difference_type i) const
+    {
+        auto result = *this;
+        result += i;
+        return result;
+    }
+
+    /*!
+    @brief  addition of distance and iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    friend iter_impl operator+(difference_type i, const iter_impl& it)
+    {
+        auto result = it;
+        result += i;
+        return result;
+    }
+
+    /*!
+    @brief  subtract from iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    iter_impl operator-(difference_type i) const
+    {
+        auto result = *this;
+        result -= i;
+        return result;
+    }
+
+    /*!
+    @brief  return difference
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    difference_type operator-(const iter_impl& other) const
+    {
+        assert(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+                JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators"));
+
+            case value_t::array:
+                return m_it.array_iterator - other.m_it.array_iterator;
+
+            default:
+                return m_it.primitive_iterator - other.m_it.primitive_iterator;
+        }
+    }
+
+    /*!
+    @brief  access to successor
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    reference operator[](difference_type n) const
+    {
+        assert(m_object != nullptr);
+
+        switch (m_object->m_type)
+        {
+            case value_t::object:
+                JSON_THROW(invalid_iterator::create(208, "cannot use operator[] for object iterators"));
+
+            case value_t::array:
+                return *std::next(m_it.array_iterator, n);
+
+            case value_t::null:
+                JSON_THROW(invalid_iterator::create(214, "cannot get value"));
+
+            default:
+            {
+                if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.get_value() == -n))
+                {
+                    return *m_object;
+                }
+
+                JSON_THROW(invalid_iterator::create(214, "cannot get value"));
+            }
+        }
+    }
+
+    /*!
+    @brief  return the key of an object iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    const typename object_t::key_type& key() const
+    {
+        assert(m_object != nullptr);
+
+        if (JSON_HEDLEY_LIKELY(m_object->is_object()))
+        {
+            return m_it.object_iterator->first;
+        }
+
+        JSON_THROW(invalid_iterator::create(207, "cannot use key() for non-object iterators"));
+    }
+
+    /*!
+    @brief  return the value of an iterator
+    @pre The iterator is initialized; i.e. `m_object != nullptr`.
+    */
+    reference value() const
+    {
+        return operator*();
+    }
+
+  private:
+    /// associated JSON instance
+    pointer m_object = nullptr;
+    /// the actual iterator of the associated instance
+    internal_iterator<typename std::remove_const<BasicJsonType>::type> m_it {};
+};
+} // namespace detail
+} // namespace nlohmann
+
+// #include <nlohmann/detail/iterators/iteration_proxy.hpp>
+
+// #include <nlohmann/detail/iterators/json_reverse_iterator.hpp>
+
+
+#include <cstddef> // ptrdiff_t
+#include <iterator> // reverse_iterator
+#include <utility> // declval
+
+namespace nlohmann
+{
+namespace detail
+{
+//////////////////////
+// reverse_iterator //
+//////////////////////
+
+/*!
+@brief a template for a reverse iterator class
+
+@tparam Base the base iterator type to reverse. Valid types are @ref
+iterator (to create @ref reverse_iterator) and @ref const_iterator (to
+create @ref const_reverse_iterator).
+
+@requirement The class satisfies the following concept requirements:
+-
+[BidirectionalIterator](https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator):
+  The iterator that can be moved can be moved in both directions (i.e.
+  incremented and decremented).
+- [OutputIterator](https://en.cppreference.com/w/cpp/named_req/OutputIterator):
+  It is possible to write to the pointed-to element (only if @a Base is
+  @ref iterator).
+
+@since version 1.0.0
+*/
+template<typename Base>
+class json_reverse_iterator : public std::reverse_iterator<Base>
+{
+  public:
+    using difference_type = std::ptrdiff_t;
+    /// shortcut to the reverse iterator adapter
+    using base_iterator = std::reverse_iterator<Base>;
+    /// the reference type for the pointed-to element
+    using reference = typename Base::reference;
+
+    /// create reverse iterator from iterator
+    explicit json_reverse_iterator(const typename base_iterator::iterator_type& it) noexcept
+        : base_iterator(it) {}
+
+    /// create reverse iterator from base class
+    explicit json_reverse_iterator(const base_iterator& it) noexcept : base_iterator(it) {}
+
+    /// post-increment (it++)
+    json_reverse_iterator const operator++(int)
+    {
+        return static_cast<json_reverse_iterator>(base_iterator::operator++(1));
+    }
+
+    /// pre-increment (++it)
+    json_reverse_iterator& operator++()
+    {
+        return static_cast<json_reverse_iterator&>(base_iterator::operator++());
+    }
+
+    /// post-decrement (it--)
+    json_reverse_iterator const operator--(int)
+    {
+        return static_cast<json_reverse_iterator>(base_iterator::operator--(1));
+    }
+
+    /// pre-decrement (--it)
+    json_reverse_iterator& operator--()
+    {
+        return static_cast<json_reverse_iterator&>(base_iterator::operator--());
+    }
+
+    /// add to iterator
+    json_reverse_iterator& operator+=(difference_type i)
+    {
+        return static_cast<json_reverse_iterator&>(base_iterator::operator+=(i));
+    }
+
+    /// add to iterator
+    json_reverse_iterator operator+(difference_type i) const
+    {
+        return static_cast<json_reverse_iterator>(base_iterator::operator+(i));
+    }
+
+    /// subtract from iterator
+    json_reverse_iterator operator-(difference_type i) const
+    {
+        return static_cast<json_reverse_iterator>(base_iterator::operator-(i));
+    }
+
+    /// return difference
+    difference_type operator-(const json_reverse_iterator& other) const
+    {
+        return base_iterator(*this) - base_iterator(other);
+    }
+
+    /// access to successor
+    reference operator[](difference_type n) const
+    {
+        return *(this->operator+(n));
+    }
+
+    /// return the key of an object iterator
+    auto key() const -> decltype(std::declval<Base>().key())
+    {
+        auto it = --this->base();
+        return it.key();
+    }
+
+    /// return the value of an iterator
+    reference value() const
+    {
+        auto it = --this->base();
+        return it.operator * ();
+    }
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/iterators/primitive_iterator.hpp>
+
+// #include <nlohmann/detail/json_pointer.hpp>
+
+
+#include <algorithm> // all_of
+#include <cassert> // assert
+#include <cctype> // isdigit
+#include <numeric> // accumulate
+#include <string> // string
+#include <utility> // move
+#include <vector> // vector
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+namespace nlohmann
+{
+template<typename BasicJsonType>
+class json_pointer
+{
+    // allow basic_json to access private members
+    NLOHMANN_BASIC_JSON_TPL_DECLARATION
+    friend class basic_json;
+
+  public:
+    /*!
+    @brief create JSON pointer
+
+    Create a JSON pointer according to the syntax described in
+    [Section 3 of RFC6901](https://tools.ietf.org/html/rfc6901#section-3).
+
+    @param[in] s  string representing the JSON pointer; if omitted, the empty
+                  string is assumed which references the whole JSON value
+
+    @throw parse_error.107 if the given JSON pointer @a s is nonempty and does
+                           not begin with a slash (`/`); see example below
+
+    @throw parse_error.108 if a tilde (`~`) in the given JSON pointer @a s is
+    not followed by `0` (representing `~`) or `1` (representing `/`); see
+    example below
+
+    @liveexample{The example shows the construction several valid JSON pointers
+    as well as the exceptional behavior.,json_pointer}
+
+    @since version 2.0.0
+    */
+    explicit json_pointer(const std::string& s = "")
+        : reference_tokens(split(s))
+    {}
+
+    /*!
+    @brief return a string representation of the JSON pointer
+
+    @invariant For each JSON pointer `ptr`, it holds:
+    @code {.cpp}
+    ptr == json_pointer(ptr.to_string());
+    @endcode
+
+    @return a string representation of the JSON pointer
+
+    @liveexample{The example shows the result of `to_string`.,json_pointer__to_string}
+
+    @since version 2.0.0
+    */
+    std::string to_string() const
+    {
+        return std::accumulate(reference_tokens.begin(), reference_tokens.end(),
+                               std::string{},
+                               [](const std::string & a, const std::string & b)
+        {
+            return a + "/" + escape(b);
+        });
+    }
+
+    /// @copydoc to_string()
+    operator std::string() const
+    {
+        return to_string();
+    }
+
+    /*!
+    @brief append another JSON pointer at the end of this JSON pointer
+
+    @param[in] ptr  JSON pointer to append
+    @return JSON pointer with @a ptr appended
+
+    @liveexample{The example shows the usage of `operator/=`.,json_pointer__operator_add}
+
+    @complexity Linear in the length of @a ptr.
+
+    @sa @ref operator/=(std::string) to append a reference token
+    @sa @ref operator/=(std::size_t) to append an array index
+    @sa @ref operator/(const json_pointer&, const json_pointer&) for a binary operator
+
+    @since version 3.6.0
+    */
+    json_pointer& operator/=(const json_pointer& ptr)
+    {
+        reference_tokens.insert(reference_tokens.end(),
+                                ptr.reference_tokens.begin(),
+                                ptr.reference_tokens.end());
+        return *this;
+    }
+
+    /*!
+    @brief append an unescaped reference token at the end of this JSON pointer
+
+    @param[in] token  reference token to append
+    @return JSON pointer with @a token appended without escaping @a token
+
+    @liveexample{The example shows the usage of `operator/=`.,json_pointer__operator_add}
+
+    @complexity Amortized constant.
+
+    @sa @ref operator/=(const json_pointer&) to append a JSON pointer
+    @sa @ref operator/=(std::size_t) to append an array index
+    @sa @ref operator/(const json_pointer&, std::size_t) for a binary operator
+
+    @since version 3.6.0
+    */
+    json_pointer& operator/=(std::string token)
+    {
+        push_back(std::move(token));
+        return *this;
+    }
+
+    /*!
+    @brief append an array index at the end of this JSON pointer
+
+    @param[in] array_index  array index ot append
+    @return JSON pointer with @a array_index appended
+
+    @liveexample{The example shows the usage of `operator/=`.,json_pointer__operator_add}
+
+    @complexity Amortized constant.
+
+    @sa @ref operator/=(const json_pointer&) to append a JSON pointer
+    @sa @ref operator/=(std::string) to append a reference token
+    @sa @ref operator/(const json_pointer&, std::string) for a binary operator
+
+    @since version 3.6.0
+    */
+    json_pointer& operator/=(std::size_t array_index)
+    {
+        return *this /= std::to_string(array_index);
+    }
+
+    /*!
+    @brief create a new JSON pointer by appending the right JSON pointer at the end of the left JSON pointer
+
+    @param[in] lhs  JSON pointer
+    @param[in] rhs  JSON pointer
+    @return a new JSON pointer with @a rhs appended to @a lhs
+
+    @liveexample{The example shows the usage of `operator/`.,json_pointer__operator_add_binary}
+
+    @complexity Linear in the length of @a lhs and @a rhs.
+
+    @sa @ref operator/=(const json_pointer&) to append a JSON pointer
+
+    @since version 3.6.0
+    */
+    friend json_pointer operator/(const json_pointer& lhs,
+                                  const json_pointer& rhs)
+    {
+        return json_pointer(lhs) /= rhs;
+    }
+
+    /*!
+    @brief create a new JSON pointer by appending the unescaped token at the end of the JSON pointer
+
+    @param[in] ptr  JSON pointer
+    @param[in] token  reference token
+    @return a new JSON pointer with unescaped @a token appended to @a ptr
+
+    @liveexample{The example shows the usage of `operator/`.,json_pointer__operator_add_binary}
+
+    @complexity Linear in the length of @a ptr.
+
+    @sa @ref operator/=(std::string) to append a reference token
+
+    @since version 3.6.0
+    */
+    friend json_pointer operator/(const json_pointer& ptr, std::string token)
+    {
+        return json_pointer(ptr) /= std::move(token);
+    }
+
+    /*!
+    @brief create a new JSON pointer by appending the array-index-token at the end of the JSON pointer
+
+    @param[in] ptr  JSON pointer
+    @param[in] array_index  array index
+    @return a new JSON pointer with @a array_index appended to @a ptr
+
+    @liveexample{The example shows the usage of `operator/`.,json_pointer__operator_add_binary}
+
+    @complexity Linear in the length of @a ptr.
+
+    @sa @ref operator/=(std::size_t) to append an array index
+
+    @since version 3.6.0
+    */
+    friend json_pointer operator/(const json_pointer& ptr, std::size_t array_index)
+    {
+        return json_pointer(ptr) /= array_index;
+    }
+
+    /*!
+    @brief returns the parent of this JSON pointer
+
+    @return parent of this JSON pointer; in case this JSON pointer is the root,
+            the root itself is returned
+
+    @complexity Linear in the length of the JSON pointer.
+
+    @liveexample{The example shows the result of `parent_pointer` for different
+    JSON Pointers.,json_pointer__parent_pointer}
+
+    @since version 3.6.0
+    */
+    json_pointer parent_pointer() const
+    {
+        if (empty())
+        {
+            return *this;
+        }
+
+        json_pointer res = *this;
+        res.pop_back();
+        return res;
+    }
+
+    /*!
+    @brief remove last reference token
+
+    @pre not `empty()`
+
+    @liveexample{The example shows the usage of `pop_back`.,json_pointer__pop_back}
+
+    @complexity Constant.
+
+    @throw out_of_range.405 if JSON pointer has no parent
+
+    @since version 3.6.0
+    */
+    void pop_back()
+    {
+        if (JSON_HEDLEY_UNLIKELY(empty()))
+        {
+            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent"));
+        }
+
+        reference_tokens.pop_back();
+    }
+
+    /*!
+    @brief return last reference token
+
+    @pre not `empty()`
+    @return last reference token
+
+    @liveexample{The example shows the usage of `back`.,json_pointer__back}
+
+    @complexity Constant.
+
+    @throw out_of_range.405 if JSON pointer has no parent
+
+    @since version 3.6.0
+    */
+    const std::string& back()
+    {
+        if (JSON_HEDLEY_UNLIKELY(empty()))
+        {
+            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent"));
+        }
+
+        return reference_tokens.back();
+    }
+
+    /*!
+    @brief append an unescaped token at the end of the reference pointer
+
+    @param[in] token  token to add
+
+    @complexity Amortized constant.
+
+    @liveexample{The example shows the result of `push_back` for different
+    JSON Pointers.,json_pointer__push_back}
+
+    @since version 3.6.0
+    */
+    void push_back(const std::string& token)
+    {
+        reference_tokens.push_back(token);
+    }
+
+    /// @copydoc push_back(const std::string&)
+    void push_back(std::string&& token)
+    {
+        reference_tokens.push_back(std::move(token));
+    }
+
+    /*!
+    @brief return whether pointer points to the root document
+
+    @return true iff the JSON pointer points to the root document
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+
+    @liveexample{The example shows the result of `empty` for different JSON
+    Pointers.,json_pointer__empty}
+
+    @since version 3.6.0
+    */
+    bool empty() const noexcept
+    {
+        return reference_tokens.empty();
+    }
+
+  private:
+    /*!
+    @param[in] s  reference token to be converted into an array index
+
+    @return integer representation of @a s
+
+    @throw out_of_range.404 if string @a s could not be converted to an integer
+    */
+    static int array_index(const std::string& s)
+    {
+        std::size_t processed_chars = 0;
+        const int res = std::stoi(s, &processed_chars);
+
+        // check if the string was completely read
+        if (JSON_HEDLEY_UNLIKELY(processed_chars != s.size()))
+        {
+            JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + s + "'"));
+        }
+
+        return res;
+    }
+
+    json_pointer top() const
+    {
+        if (JSON_HEDLEY_UNLIKELY(empty()))
+        {
+            JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent"));
+        }
+
+        json_pointer result = *this;
+        result.reference_tokens = {reference_tokens[0]};
+        return result;
+    }
+
+    /*!
+    @brief create and return a reference to the pointed to value
+
+    @complexity Linear in the number of reference tokens.
+
+    @throw parse_error.109 if array index is not a number
+    @throw type_error.313 if value cannot be unflattened
+    */
+    BasicJsonType& get_and_create(BasicJsonType& j) const
+    {
+        using size_type = typename BasicJsonType::size_type;
+        auto result = &j;
+
+        // in case no reference tokens exist, return a reference to the JSON value
+        // j which will be overwritten by a primitive value
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (result->type())
+            {
+                case detail::value_t::null:
+                {
+                    if (reference_token == "0")
+                    {
+                        // start a new array if reference token is 0
+                        result = &result->operator[](0);
+                    }
+                    else
+                    {
+                        // start a new object otherwise
+                        result = &result->operator[](reference_token);
+                    }
+                    break;
+                }
+
+                case detail::value_t::object:
+                {
+                    // create an entry in the object
+                    result = &result->operator[](reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    // create an entry in the array
+                    JSON_TRY
+                    {
+                        result = &result->operator[](static_cast<size_type>(array_index(reference_token)));
+                    }
+                    JSON_CATCH(std::invalid_argument&)
+                    {
+                        JSON_THROW(detail::parse_error::create(109, 0, "array index '" + reference_token + "' is not a number"));
+                    }
+                    break;
+                }
+
+                /*
+                The following code is only reached if there exists a reference
+                token _and_ the current value is primitive. In this case, we have
+                an error situation, because primitive values may only occur as
+                single value; that is, with an empty list of reference tokens.
+                */
+                default:
+                    JSON_THROW(detail::type_error::create(313, "invalid value to unflatten"));
+            }
+        }
+
+        return *result;
+    }
+
+    /*!
+    @brief return a reference to the pointed to value
+
+    @note This version does not throw if a value is not present, but tries to
+          create nested values instead. For instance, calling this function
+          with pointer `"/this/that"` on a null value is equivalent to calling
+          `operator[]("this").operator[]("that")` on that value, effectively
+          changing the null value to an object.
+
+    @param[in] ptr  a JSON value
+
+    @return reference to the JSON value pointed to by the JSON pointer
+
+    @complexity Linear in the length of the JSON pointer.
+
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    @throw out_of_range.404  if the JSON pointer can not be resolved
+    */
+    BasicJsonType& get_unchecked(BasicJsonType* ptr) const
+    {
+        using size_type = typename BasicJsonType::size_type;
+        for (const auto& reference_token : reference_tokens)
+        {
+            // convert null values to arrays or objects before continuing
+            if (ptr->is_null())
+            {
+                // check if reference token is a number
+                const bool nums =
+                    std::all_of(reference_token.begin(), reference_token.end(),
+                                [](const unsigned char x)
+                {
+                    return std::isdigit(x);
+                });
+
+                // change value to array for numbers or "-" or to object otherwise
+                *ptr = (nums or reference_token == "-")
+                       ? detail::value_t::array
+                       : detail::value_t::object;
+            }
+
+            switch (ptr->type())
+            {
+                case detail::value_t::object:
+                {
+                    // use unchecked object access
+                    ptr = &ptr->operator[](reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    // error condition (cf. RFC 6901, Sect. 4)
+                    if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))
+                    {
+                        JSON_THROW(detail::parse_error::create(106, 0,
+                                                               "array index '" + reference_token +
+                                                               "' must not begin with '0'"));
+                    }
+
+                    if (reference_token == "-")
+                    {
+                        // explicitly treat "-" as index beyond the end
+                        ptr = &ptr->operator[](ptr->m_value.array->size());
+                    }
+                    else
+                    {
+                        // convert array index to number; unchecked access
+                        JSON_TRY
+                        {
+                            ptr = &ptr->operator[](
+                                static_cast<size_type>(array_index(reference_token)));
+                        }
+                        JSON_CATCH(std::invalid_argument&)
+                        {
+                            JSON_THROW(detail::parse_error::create(109, 0, "array index '" + reference_token + "' is not a number"));
+                        }
+                    }
+                    break;
+                }
+
+                default:
+                    JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
+            }
+        }
+
+        return *ptr;
+    }
+
+    /*!
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    @throw out_of_range.402  if the array index '-' is used
+    @throw out_of_range.404  if the JSON pointer can not be resolved
+    */
+    BasicJsonType& get_checked(BasicJsonType* ptr) const
+    {
+        using size_type = typename BasicJsonType::size_type;
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (ptr->type())
+            {
+                case detail::value_t::object:
+                {
+                    // note: at performs range check
+                    ptr = &ptr->at(reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
+                    {
+                        // "-" always fails the range check
+                        JSON_THROW(detail::out_of_range::create(402,
+                                                                "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
+                                                                ") is out of range"));
+                    }
+
+                    // error condition (cf. RFC 6901, Sect. 4)
+                    if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))
+                    {
+                        JSON_THROW(detail::parse_error::create(106, 0,
+                                                               "array index '" + reference_token +
+                                                               "' must not begin with '0'"));
+                    }
+
+                    // note: at performs range check
+                    JSON_TRY
+                    {
+                        ptr = &ptr->at(static_cast<size_type>(array_index(reference_token)));
+                    }
+                    JSON_CATCH(std::invalid_argument&)
+                    {
+                        JSON_THROW(detail::parse_error::create(109, 0, "array index '" + reference_token + "' is not a number"));
+                    }
+                    break;
+                }
+
+                default:
+                    JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
+            }
+        }
+
+        return *ptr;
+    }
+
+    /*!
+    @brief return a const reference to the pointed to value
+
+    @param[in] ptr  a JSON value
+
+    @return const reference to the JSON value pointed to by the JSON
+    pointer
+
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    @throw out_of_range.402  if the array index '-' is used
+    @throw out_of_range.404  if the JSON pointer can not be resolved
+    */
+    const BasicJsonType& get_unchecked(const BasicJsonType* ptr) const
+    {
+        using size_type = typename BasicJsonType::size_type;
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (ptr->type())
+            {
+                case detail::value_t::object:
+                {
+                    // use unchecked object access
+                    ptr = &ptr->operator[](reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
+                    {
+                        // "-" cannot be used for const access
+                        JSON_THROW(detail::out_of_range::create(402,
+                                                                "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
+                                                                ") is out of range"));
+                    }
+
+                    // error condition (cf. RFC 6901, Sect. 4)
+                    if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))
+                    {
+                        JSON_THROW(detail::parse_error::create(106, 0,
+                                                               "array index '" + reference_token +
+                                                               "' must not begin with '0'"));
+                    }
+
+                    // use unchecked array access
+                    JSON_TRY
+                    {
+                        ptr = &ptr->operator[](
+                            static_cast<size_type>(array_index(reference_token)));
+                    }
+                    JSON_CATCH(std::invalid_argument&)
+                    {
+                        JSON_THROW(detail::parse_error::create(109, 0, "array index '" + reference_token + "' is not a number"));
+                    }
+                    break;
+                }
+
+                default:
+                    JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
+            }
+        }
+
+        return *ptr;
+    }
+
+    /*!
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    @throw out_of_range.402  if the array index '-' is used
+    @throw out_of_range.404  if the JSON pointer can not be resolved
+    */
+    const BasicJsonType& get_checked(const BasicJsonType* ptr) const
+    {
+        using size_type = typename BasicJsonType::size_type;
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (ptr->type())
+            {
+                case detail::value_t::object:
+                {
+                    // note: at performs range check
+                    ptr = &ptr->at(reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
+                    {
+                        // "-" always fails the range check
+                        JSON_THROW(detail::out_of_range::create(402,
+                                                                "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
+                                                                ") is out of range"));
+                    }
+
+                    // error condition (cf. RFC 6901, Sect. 4)
+                    if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))
+                    {
+                        JSON_THROW(detail::parse_error::create(106, 0,
+                                                               "array index '" + reference_token +
+                                                               "' must not begin with '0'"));
+                    }
+
+                    // note: at performs range check
+                    JSON_TRY
+                    {
+                        ptr = &ptr->at(static_cast<size_type>(array_index(reference_token)));
+                    }
+                    JSON_CATCH(std::invalid_argument&)
+                    {
+                        JSON_THROW(detail::parse_error::create(109, 0, "array index '" + reference_token + "' is not a number"));
+                    }
+                    break;
+                }
+
+                default:
+                    JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
+            }
+        }
+
+        return *ptr;
+    }
+
+    /*!
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    */
+    bool contains(const BasicJsonType* ptr) const
+    {
+        using size_type = typename BasicJsonType::size_type;
+        for (const auto& reference_token : reference_tokens)
+        {
+            switch (ptr->type())
+            {
+                case detail::value_t::object:
+                {
+                    if (not ptr->contains(reference_token))
+                    {
+                        // we did not find the key in the object
+                        return false;
+                    }
+
+                    ptr = &ptr->operator[](reference_token);
+                    break;
+                }
+
+                case detail::value_t::array:
+                {
+                    if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
+                    {
+                        // "-" always fails the range check
+                        return false;
+                    }
+
+                    // error condition (cf. RFC 6901, Sect. 4)
+                    if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))
+                    {
+                        JSON_THROW(detail::parse_error::create(106, 0,
+                                                               "array index '" + reference_token +
+                                                               "' must not begin with '0'"));
+                    }
+
+                    JSON_TRY
+                    {
+                        const auto idx = static_cast<size_type>(array_index(reference_token));
+                        if (idx >= ptr->size())
+                        {
+                            // index out of range
+                            return false;
+                        }
+
+                        ptr = &ptr->operator[](idx);
+                        break;
+                    }
+                    JSON_CATCH(std::invalid_argument&)
+                    {
+                        JSON_THROW(detail::parse_error::create(109, 0, "array index '" + reference_token + "' is not a number"));
+                    }
+                    break;
+                }
+
+                default:
+                {
+                    // we do not expect primitive values if there is still a
+                    // reference token to process
+                    return false;
+                }
+            }
+        }
+
+        // no reference token left means we found a primitive value
+        return true;
+    }
+
+    /*!
+    @brief split the string input to reference tokens
+
+    @note This function is only called by the json_pointer constructor.
+          All exceptions below are documented there.
+
+    @throw parse_error.107  if the pointer is not empty or begins with '/'
+    @throw parse_error.108  if character '~' is not followed by '0' or '1'
+    */
+    static std::vector<std::string> split(const std::string& reference_string)
+    {
+        std::vector<std::string> result;
+
+        // special case: empty reference string -> no reference tokens
+        if (reference_string.empty())
+        {
+            return result;
+        }
+
+        // check if nonempty reference string begins with slash
+        if (JSON_HEDLEY_UNLIKELY(reference_string[0] != '/'))
+        {
+            JSON_THROW(detail::parse_error::create(107, 1,
+                                                   "JSON pointer must be empty or begin with '/' - was: '" +
+                                                   reference_string + "'"));
+        }
+
+        // extract the reference tokens:
+        // - slash: position of the last read slash (or end of string)
+        // - start: position after the previous slash
+        for (
+            // search for the first slash after the first character
+            std::size_t slash = reference_string.find_first_of('/', 1),
+            // set the beginning of the first reference token
+            start = 1;
+            // we can stop if start == 0 (if slash == std::string::npos)
+            start != 0;
+            // set the beginning of the next reference token
+            // (will eventually be 0 if slash == std::string::npos)
+            start = (slash == std::string::npos) ? 0 : slash + 1,
+            // find next slash
+            slash = reference_string.find_first_of('/', start))
+        {
+            // use the text between the beginning of the reference token
+            // (start) and the last slash (slash).
+            auto reference_token = reference_string.substr(start, slash - start);
+
+            // check reference tokens are properly escaped
+            for (std::size_t pos = reference_token.find_first_of('~');
+                    pos != std::string::npos;
+                    pos = reference_token.find_first_of('~', pos + 1))
+            {
+                assert(reference_token[pos] == '~');
+
+                // ~ must be followed by 0 or 1
+                if (JSON_HEDLEY_UNLIKELY(pos == reference_token.size() - 1 or
+                                         (reference_token[pos + 1] != '0' and
+                                          reference_token[pos + 1] != '1')))
+                {
+                    JSON_THROW(detail::parse_error::create(108, 0, "escape character '~' must be followed with '0' or '1'"));
+                }
+            }
+
+            // finally, store the reference token
+            unescape(reference_token);
+            result.push_back(reference_token);
+        }
+
+        return result;
+    }
+
+    /*!
+    @brief replace all occurrences of a substring by another string
+
+    @param[in,out] s  the string to manipulate; changed so that all
+                   occurrences of @a f are replaced with @a t
+    @param[in]     f  the substring to replace with @a t
+    @param[in]     t  the string to replace @a f
+
+    @pre The search string @a f must not be empty. **This precondition is
+    enforced with an assertion.**
+
+    @since version 2.0.0
+    */
+    static void replace_substring(std::string& s, const std::string& f,
+                                  const std::string& t)
+    {
+        assert(not f.empty());
+        for (auto pos = s.find(f);                // find first occurrence of f
+                pos != std::string::npos;         // make sure f was found
+                s.replace(pos, f.size(), t),      // replace with t, and
+                pos = s.find(f, pos + t.size()))  // find next occurrence of f
+        {}
+    }
+
+    /// escape "~" to "~0" and "/" to "~1"
+    static std::string escape(std::string s)
+    {
+        replace_substring(s, "~", "~0");
+        replace_substring(s, "/", "~1");
+        return s;
+    }
+
+    /// unescape "~1" to tilde and "~0" to slash (order is important!)
+    static void unescape(std::string& s)
+    {
+        replace_substring(s, "~1", "/");
+        replace_substring(s, "~0", "~");
+    }
+
+    /*!
+    @param[in] reference_string  the reference string to the current value
+    @param[in] value             the value to consider
+    @param[in,out] result        the result object to insert values to
+
+    @note Empty objects or arrays are flattened to `null`.
+    */
+    static void flatten(const std::string& reference_string,
+                        const BasicJsonType& value,
+                        BasicJsonType& result)
+    {
+        switch (value.type())
+        {
+            case detail::value_t::array:
+            {
+                if (value.m_value.array->empty())
+                {
+                    // flatten empty array as null
+                    result[reference_string] = nullptr;
+                }
+                else
+                {
+                    // iterate array and use index as reference string
+                    for (std::size_t i = 0; i < value.m_value.array->size(); ++i)
+                    {
+                        flatten(reference_string + "/" + std::to_string(i),
+                                value.m_value.array->operator[](i), result);
+                    }
+                }
+                break;
+            }
+
+            case detail::value_t::object:
+            {
+                if (value.m_value.object->empty())
+                {
+                    // flatten empty object as null
+                    result[reference_string] = nullptr;
+                }
+                else
+                {
+                    // iterate object and use keys as reference string
+                    for (const auto& element : *value.m_value.object)
+                    {
+                        flatten(reference_string + "/" + escape(element.first), element.second, result);
+                    }
+                }
+                break;
+            }
+
+            default:
+            {
+                // add primitive value with its reference string
+                result[reference_string] = value;
+                break;
+            }
+        }
+    }
+
+    /*!
+    @param[in] value  flattened JSON
+
+    @return unflattened JSON
+
+    @throw parse_error.109 if array index is not a number
+    @throw type_error.314  if value is not an object
+    @throw type_error.315  if object values are not primitive
+    @throw type_error.313  if value cannot be unflattened
+    */
+    static BasicJsonType
+    unflatten(const BasicJsonType& value)
+    {
+        if (JSON_HEDLEY_UNLIKELY(not value.is_object()))
+        {
+            JSON_THROW(detail::type_error::create(314, "only objects can be unflattened"));
+        }
+
+        BasicJsonType result;
+
+        // iterate the JSON object values
+        for (const auto& element : *value.m_value.object)
+        {
+            if (JSON_HEDLEY_UNLIKELY(not element.second.is_primitive()))
+            {
+                JSON_THROW(detail::type_error::create(315, "values in object must be primitive"));
+            }
+
+            // assign value to reference pointed to by JSON pointer; Note that if
+            // the JSON pointer is "" (i.e., points to the whole value), function
+            // get_and_create returns a reference to result itself. An assignment
+            // will then create a primitive value.
+            json_pointer(element.first).get_and_create(result) = element.second;
+        }
+
+        return result;
+    }
+
+    /*!
+    @brief compares two JSON pointers for equality
+
+    @param[in] lhs  JSON pointer to compare
+    @param[in] rhs  JSON pointer to compare
+    @return whether @a lhs is equal to @a rhs
+
+    @complexity Linear in the length of the JSON pointer
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+    */
+    friend bool operator==(json_pointer const& lhs,
+                           json_pointer const& rhs) noexcept
+    {
+        return lhs.reference_tokens == rhs.reference_tokens;
+    }
+
+    /*!
+    @brief compares two JSON pointers for inequality
+
+    @param[in] lhs  JSON pointer to compare
+    @param[in] rhs  JSON pointer to compare
+    @return whether @a lhs is not equal @a rhs
+
+    @complexity Linear in the length of the JSON pointer
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+    */
+    friend bool operator!=(json_pointer const& lhs,
+                           json_pointer const& rhs) noexcept
+    {
+        return not (lhs == rhs);
+    }
+
+    /// the reference tokens
+    std::vector<std::string> reference_tokens;
+};
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/json_ref.hpp>
+
+
+#include <initializer_list>
+#include <utility>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+template<typename BasicJsonType>
+class json_ref
+{
+  public:
+    using value_type = BasicJsonType;
+
+    json_ref(value_type&& value)
+        : owned_value(std::move(value)), value_ref(&owned_value), is_rvalue(true)
+    {}
+
+    json_ref(const value_type& value)
+        : value_ref(const_cast<value_type*>(&value)), is_rvalue(false)
+    {}
+
+    json_ref(std::initializer_list<json_ref> init)
+        : owned_value(init), value_ref(&owned_value), is_rvalue(true)
+    {}
+
+    template <
+        class... Args,
+        enable_if_t<std::is_constructible<value_type, Args...>::value, int> = 0 >
+    json_ref(Args && ... args)
+        : owned_value(std::forward<Args>(args)...), value_ref(&owned_value),
+          is_rvalue(true) {}
+
+    // class should be movable only
+    json_ref(json_ref&&) = default;
+    json_ref(const json_ref&) = delete;
+    json_ref& operator=(const json_ref&) = delete;
+    json_ref& operator=(json_ref&&) = delete;
+    ~json_ref() = default;
+
+    value_type moved_or_copied() const
+    {
+        if (is_rvalue)
+        {
+            return std::move(*value_ref);
+        }
+        return *value_ref;
+    }
+
+    value_type const& operator*() const
+    {
+        return *static_cast<value_type const*>(value_ref);
+    }
+
+    value_type const* operator->() const
+    {
+        return static_cast<value_type const*>(value_ref);
+    }
+
+  private:
+    mutable value_type owned_value = nullptr;
+    value_type* value_ref = nullptr;
+    const bool is_rvalue;
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/meta/type_traits.hpp>
+
+// #include <nlohmann/detail/output/binary_writer.hpp>
+
+
+#include <algorithm> // reverse
+#include <array> // array
+#include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
+#include <cstring> // memcpy
+#include <limits> // numeric_limits
+#include <string> // string
+
+// #include <nlohmann/detail/input/binary_reader.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/output/output_adapters.hpp>
+
+
+#include <algorithm> // copy
+#include <cstddef> // size_t
+#include <ios> // streamsize
+#include <iterator> // back_inserter
+#include <memory> // shared_ptr, make_shared
+#include <ostream> // basic_ostream
+#include <string> // basic_string
+#include <vector> // vector
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+/// abstract output adapter interface
+template<typename CharType> struct output_adapter_protocol
+{
+    virtual void write_character(CharType c) = 0;
+    virtual void write_characters(const CharType* s, std::size_t length) = 0;
+    virtual ~output_adapter_protocol() = default;
+};
+
+/// a type to simplify interfaces
+template<typename CharType>
+using output_adapter_t = std::shared_ptr<output_adapter_protocol<CharType>>;
+
+/// output adapter for byte vectors
+template<typename CharType>
+class output_vector_adapter : public output_adapter_protocol<CharType>
+{
+  public:
+    explicit output_vector_adapter(std::vector<CharType>& vec) noexcept
+        : v(vec)
+    {}
+
+    void write_character(CharType c) override
+    {
+        v.push_back(c);
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    void write_characters(const CharType* s, std::size_t length) override
+    {
+        std::copy(s, s + length, std::back_inserter(v));
+    }
+
+  private:
+    std::vector<CharType>& v;
+};
+
+/// output adapter for output streams
+template<typename CharType>
+class output_stream_adapter : public output_adapter_protocol<CharType>
+{
+  public:
+    explicit output_stream_adapter(std::basic_ostream<CharType>& s) noexcept
+        : stream(s)
+    {}
+
+    void write_character(CharType c) override
+    {
+        stream.put(c);
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    void write_characters(const CharType* s, std::size_t length) override
+    {
+        stream.write(s, static_cast<std::streamsize>(length));
+    }
+
+  private:
+    std::basic_ostream<CharType>& stream;
+};
+
+/// output adapter for basic_string
+template<typename CharType, typename StringType = std::basic_string<CharType>>
+class output_string_adapter : public output_adapter_protocol<CharType>
+{
+  public:
+    explicit output_string_adapter(StringType& s) noexcept
+        : str(s)
+    {}
+
+    void write_character(CharType c) override
+    {
+        str.push_back(c);
+    }
+
+    JSON_HEDLEY_NON_NULL(2)
+    void write_characters(const CharType* s, std::size_t length) override
+    {
+        str.append(s, length);
+    }
+
+  private:
+    StringType& str;
+};
+
+template<typename CharType, typename StringType = std::basic_string<CharType>>
+class output_adapter
+{
+  public:
+    output_adapter(std::vector<CharType>& vec)
+        : oa(std::make_shared<output_vector_adapter<CharType>>(vec)) {}
+
+    output_adapter(std::basic_ostream<CharType>& s)
+        : oa(std::make_shared<output_stream_adapter<CharType>>(s)) {}
+
+    output_adapter(StringType& s)
+        : oa(std::make_shared<output_string_adapter<CharType, StringType>>(s)) {}
+
+    operator output_adapter_t<CharType>()
+    {
+        return oa;
+    }
+
+  private:
+    output_adapter_t<CharType> oa = nullptr;
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+
+namespace nlohmann
+{
+namespace detail
+{
+///////////////////
+// binary writer //
+///////////////////
+
+/*!
+@brief serialization to CBOR and MessagePack values
+*/
+template<typename BasicJsonType, typename CharType>
+class binary_writer
+{
+    using string_t = typename BasicJsonType::string_t;
+
+  public:
+    /*!
+    @brief create a binary writer
+
+    @param[in] adapter  output adapter to write to
+    */
+    explicit binary_writer(output_adapter_t<CharType> adapter) : oa(adapter)
+    {
+        assert(oa);
+    }
+
+    /*!
+    @param[in] j  JSON value to serialize
+    @pre       j.type() == value_t::object
+    */
+    void write_bson(const BasicJsonType& j)
+    {
+        switch (j.type())
+        {
+            case value_t::object:
+            {
+                write_bson_object(*j.m_value.object);
+                break;
+            }
+
+            default:
+            {
+                JSON_THROW(type_error::create(317, "to serialize to BSON, top-level type must be object, but is " + std::string(j.type_name())));
+            }
+        }
+    }
+
+    /*!
+    @param[in] j  JSON value to serialize
+    */
+    void write_cbor(const BasicJsonType& j)
+    {
+        switch (j.type())
+        {
+            case value_t::null:
+            {
+                oa->write_character(to_char_type(0xF6));
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                oa->write_character(j.m_value.boolean
+                                    ? to_char_type(0xF5)
+                                    : to_char_type(0xF4));
+                break;
+            }
+
+            case value_t::number_integer:
+            {
+                if (j.m_value.number_integer >= 0)
+                {
+                    // CBOR does not differentiate between positive signed
+                    // integers and unsigned integers. Therefore, we used the
+                    // code from the value_t::number_unsigned case here.
+                    if (j.m_value.number_integer <= 0x17)
+                    {
+                        write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x18));
+                        write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_integer <= (std::numeric_limits<std::uint16_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x19));
+                        write_number(static_cast<std::uint16_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_integer <= (std::numeric_limits<std::uint32_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x1A));
+                        write_number(static_cast<std::uint32_t>(j.m_value.number_integer));
+                    }
+                    else
+                    {
+                        oa->write_character(to_char_type(0x1B));
+                        write_number(static_cast<std::uint64_t>(j.m_value.number_integer));
+                    }
+                }
+                else
+                {
+                    // The conversions below encode the sign in the first
+                    // byte, and the value is converted to a positive number.
+                    const auto positive_number = -1 - j.m_value.number_integer;
+                    if (j.m_value.number_integer >= -24)
+                    {
+                        write_number(static_cast<std::uint8_t>(0x20 + positive_number));
+                    }
+                    else if (positive_number <= (std::numeric_limits<std::uint8_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x38));
+                        write_number(static_cast<std::uint8_t>(positive_number));
+                    }
+                    else if (positive_number <= (std::numeric_limits<std::uint16_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x39));
+                        write_number(static_cast<std::uint16_t>(positive_number));
+                    }
+                    else if (positive_number <= (std::numeric_limits<std::uint32_t>::max)())
+                    {
+                        oa->write_character(to_char_type(0x3A));
+                        write_number(static_cast<std::uint32_t>(positive_number));
+                    }
+                    else
+                    {
+                        oa->write_character(to_char_type(0x3B));
+                        write_number(static_cast<std::uint64_t>(positive_number));
+                    }
+                }
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                if (j.m_value.number_unsigned <= 0x17)
+                {
+                    write_number(static_cast<std::uint8_t>(j.m_value.number_unsigned));
+                }
+                else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x18));
+                    write_number(static_cast<std::uint8_t>(j.m_value.number_unsigned));
+                }
+                else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x19));
+                    write_number(static_cast<std::uint16_t>(j.m_value.number_unsigned));
+                }
+                else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x1A));
+                    write_number(static_cast<std::uint32_t>(j.m_value.number_unsigned));
+                }
+                else
+                {
+                    oa->write_character(to_char_type(0x1B));
+                    write_number(static_cast<std::uint64_t>(j.m_value.number_unsigned));
+                }
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                oa->write_character(get_cbor_float_prefix(j.m_value.number_float));
+                write_number(j.m_value.number_float);
+                break;
+            }
+
+            case value_t::string:
+            {
+                // step 1: write control byte and the string length
+                const auto N = j.m_value.string->size();
+                if (N <= 0x17)
+                {
+                    write_number(static_cast<std::uint8_t>(0x60 + N));
+                }
+                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x78));
+                    write_number(static_cast<std::uint8_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x79));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x7A));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+                // LCOV_EXCL_START
+                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x7B));
+                    write_number(static_cast<std::uint64_t>(N));
+                }
+                // LCOV_EXCL_STOP
+
+                // step 2: write the string
+                oa->write_characters(
+                    reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
+                    j.m_value.string->size());
+                break;
+            }
+
+            case value_t::array:
+            {
+                // step 1: write control byte and the array size
+                const auto N = j.m_value.array->size();
+                if (N <= 0x17)
+                {
+                    write_number(static_cast<std::uint8_t>(0x80 + N));
+                }
+                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x98));
+                    write_number(static_cast<std::uint8_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x99));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x9A));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+                // LCOV_EXCL_START
+                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
+                {
+                    oa->write_character(to_char_type(0x9B));
+                    write_number(static_cast<std::uint64_t>(N));
+                }
+                // LCOV_EXCL_STOP
+
+                // step 2: write each element
+                for (const auto& el : *j.m_value.array)
+                {
+                    write_cbor(el);
+                }
+                break;
+            }
+
+            case value_t::object:
+            {
+                // step 1: write control byte and the object size
+                const auto N = j.m_value.object->size();
+                if (N <= 0x17)
+                {
+                    write_number(static_cast<std::uint8_t>(0xA0 + N));
+                }
+                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    oa->write_character(to_char_type(0xB8));
+                    write_number(static_cast<std::uint8_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    oa->write_character(to_char_type(0xB9));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    oa->write_character(to_char_type(0xBA));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+                // LCOV_EXCL_START
+                else if (N <= (std::numeric_limits<std::uint64_t>::max)())
+                {
+                    oa->write_character(to_char_type(0xBB));
+                    write_number(static_cast<std::uint64_t>(N));
+                }
+                // LCOV_EXCL_STOP
+
+                // step 2: write each element
+                for (const auto& el : *j.m_value.object)
+                {
+                    write_cbor(el.first);
+                    write_cbor(el.second);
+                }
+                break;
+            }
+
+            default:
+                break;
+        }
+    }
+
+    /*!
+    @param[in] j  JSON value to serialize
+    */
+    void write_msgpack(const BasicJsonType& j)
+    {
+        switch (j.type())
+        {
+            case value_t::null: // nil
+            {
+                oa->write_character(to_char_type(0xC0));
+                break;
+            }
+
+            case value_t::boolean: // true and false
+            {
+                oa->write_character(j.m_value.boolean
+                                    ? to_char_type(0xC3)
+                                    : to_char_type(0xC2));
+                break;
+            }
+
+            case value_t::number_integer:
+            {
+                if (j.m_value.number_integer >= 0)
+                {
+                    // MessagePack does not differentiate between positive
+                    // signed integers and unsigned integers. Therefore, we used
+                    // the code from the value_t::number_unsigned case here.
+                    if (j.m_value.number_unsigned < 128)
+                    {
+                        // positive fixnum
+                        write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
+                    {
+                        // uint 8
+                        oa->write_character(to_char_type(0xCC));
+                        write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
+                    {
+                        // uint 16
+                        oa->write_character(to_char_type(0xCD));
+                        write_number(static_cast<std::uint16_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
+                    {
+                        // uint 32
+                        oa->write_character(to_char_type(0xCE));
+                        write_number(static_cast<std::uint32_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
+                    {
+                        // uint 64
+                        oa->write_character(to_char_type(0xCF));
+                        write_number(static_cast<std::uint64_t>(j.m_value.number_integer));
+                    }
+                }
+                else
+                {
+                    if (j.m_value.number_integer >= -32)
+                    {
+                        // negative fixnum
+                        write_number(static_cast<std::int8_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_integer >= (std::numeric_limits<std::int8_t>::min)() and
+                             j.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
+                    {
+                        // int 8
+                        oa->write_character(to_char_type(0xD0));
+                        write_number(static_cast<std::int8_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_integer >= (std::numeric_limits<std::int16_t>::min)() and
+                             j.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
+                    {
+                        // int 16
+                        oa->write_character(to_char_type(0xD1));
+                        write_number(static_cast<std::int16_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_integer >= (std::numeric_limits<std::int32_t>::min)() and
+                             j.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
+                    {
+                        // int 32
+                        oa->write_character(to_char_type(0xD2));
+                        write_number(static_cast<std::int32_t>(j.m_value.number_integer));
+                    }
+                    else if (j.m_value.number_integer >= (std::numeric_limits<std::int64_t>::min)() and
+                             j.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
+                    {
+                        // int 64
+                        oa->write_character(to_char_type(0xD3));
+                        write_number(static_cast<std::int64_t>(j.m_value.number_integer));
+                    }
+                }
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                if (j.m_value.number_unsigned < 128)
+                {
+                    // positive fixnum
+                    write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
+                }
+                else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    // uint 8
+                    oa->write_character(to_char_type(0xCC));
+                    write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
+                }
+                else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    // uint 16
+                    oa->write_character(to_char_type(0xCD));
+                    write_number(static_cast<std::uint16_t>(j.m_value.number_integer));
+                }
+                else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    // uint 32
+                    oa->write_character(to_char_type(0xCE));
+                    write_number(static_cast<std::uint32_t>(j.m_value.number_integer));
+                }
+                else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
+                {
+                    // uint 64
+                    oa->write_character(to_char_type(0xCF));
+                    write_number(static_cast<std::uint64_t>(j.m_value.number_integer));
+                }
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                oa->write_character(get_msgpack_float_prefix(j.m_value.number_float));
+                write_number(j.m_value.number_float);
+                break;
+            }
+
+            case value_t::string:
+            {
+                // step 1: write control byte and the string length
+                const auto N = j.m_value.string->size();
+                if (N <= 31)
+                {
+                    // fixstr
+                    write_number(static_cast<std::uint8_t>(0xA0 | N));
+                }
+                else if (N <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    // str 8
+                    oa->write_character(to_char_type(0xD9));
+                    write_number(static_cast<std::uint8_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    // str 16
+                    oa->write_character(to_char_type(0xDA));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    // str 32
+                    oa->write_character(to_char_type(0xDB));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+
+                // step 2: write the string
+                oa->write_characters(
+                    reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
+                    j.m_value.string->size());
+                break;
+            }
+
+            case value_t::array:
+            {
+                // step 1: write control byte and the array size
+                const auto N = j.m_value.array->size();
+                if (N <= 15)
+                {
+                    // fixarray
+                    write_number(static_cast<std::uint8_t>(0x90 | N));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    // array 16
+                    oa->write_character(to_char_type(0xDC));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    // array 32
+                    oa->write_character(to_char_type(0xDD));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+
+                // step 2: write each element
+                for (const auto& el : *j.m_value.array)
+                {
+                    write_msgpack(el);
+                }
+                break;
+            }
+
+            case value_t::object:
+            {
+                // step 1: write control byte and the object size
+                const auto N = j.m_value.object->size();
+                if (N <= 15)
+                {
+                    // fixmap
+                    write_number(static_cast<std::uint8_t>(0x80 | (N & 0xF)));
+                }
+                else if (N <= (std::numeric_limits<std::uint16_t>::max)())
+                {
+                    // map 16
+                    oa->write_character(to_char_type(0xDE));
+                    write_number(static_cast<std::uint16_t>(N));
+                }
+                else if (N <= (std::numeric_limits<std::uint32_t>::max)())
+                {
+                    // map 32
+                    oa->write_character(to_char_type(0xDF));
+                    write_number(static_cast<std::uint32_t>(N));
+                }
+
+                // step 2: write each element
+                for (const auto& el : *j.m_value.object)
+                {
+                    write_msgpack(el.first);
+                    write_msgpack(el.second);
+                }
+                break;
+            }
+
+            default:
+                break;
+        }
+    }
+
+    /*!
+    @param[in] j  JSON value to serialize
+    @param[in] use_count   whether to use '#' prefixes (optimized format)
+    @param[in] use_type    whether to use '$' prefixes (optimized format)
+    @param[in] add_prefix  whether prefixes need to be used for this value
+    */
+    void write_ubjson(const BasicJsonType& j, const bool use_count,
+                      const bool use_type, const bool add_prefix = true)
+    {
+        switch (j.type())
+        {
+            case value_t::null:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(to_char_type('Z'));
+                }
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(j.m_value.boolean
+                                        ? to_char_type('T')
+                                        : to_char_type('F'));
+                }
+                break;
+            }
+
+            case value_t::number_integer:
+            {
+                write_number_with_ubjson_prefix(j.m_value.number_integer, add_prefix);
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                write_number_with_ubjson_prefix(j.m_value.number_unsigned, add_prefix);
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                write_number_with_ubjson_prefix(j.m_value.number_float, add_prefix);
+                break;
+            }
+
+            case value_t::string:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(to_char_type('S'));
+                }
+                write_number_with_ubjson_prefix(j.m_value.string->size(), true);
+                oa->write_characters(
+                    reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
+                    j.m_value.string->size());
+                break;
+            }
+
+            case value_t::array:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(to_char_type('['));
+                }
+
+                bool prefix_required = true;
+                if (use_type and not j.m_value.array->empty())
+                {
+                    assert(use_count);
+                    const CharType first_prefix = ubjson_prefix(j.front());
+                    const bool same_prefix = std::all_of(j.begin() + 1, j.end(),
+                                                         [this, first_prefix](const BasicJsonType & v)
+                    {
+                        return ubjson_prefix(v) == first_prefix;
+                    });
+
+                    if (same_prefix)
+                    {
+                        prefix_required = false;
+                        oa->write_character(to_char_type('$'));
+                        oa->write_character(first_prefix);
+                    }
+                }
+
+                if (use_count)
+                {
+                    oa->write_character(to_char_type('#'));
+                    write_number_with_ubjson_prefix(j.m_value.array->size(), true);
+                }
+
+                for (const auto& el : *j.m_value.array)
+                {
+                    write_ubjson(el, use_count, use_type, prefix_required);
+                }
+
+                if (not use_count)
+                {
+                    oa->write_character(to_char_type(']'));
+                }
+
+                break;
+            }
+
+            case value_t::object:
+            {
+                if (add_prefix)
+                {
+                    oa->write_character(to_char_type('{'));
+                }
+
+                bool prefix_required = true;
+                if (use_type and not j.m_value.object->empty())
+                {
+                    assert(use_count);
+                    const CharType first_prefix = ubjson_prefix(j.front());
+                    const bool same_prefix = std::all_of(j.begin(), j.end(),
+                                                         [this, first_prefix](const BasicJsonType & v)
+                    {
+                        return ubjson_prefix(v) == first_prefix;
+                    });
+
+                    if (same_prefix)
+                    {
+                        prefix_required = false;
+                        oa->write_character(to_char_type('$'));
+                        oa->write_character(first_prefix);
+                    }
+                }
+
+                if (use_count)
+                {
+                    oa->write_character(to_char_type('#'));
+                    write_number_with_ubjson_prefix(j.m_value.object->size(), true);
+                }
+
+                for (const auto& el : *j.m_value.object)
+                {
+                    write_number_with_ubjson_prefix(el.first.size(), true);
+                    oa->write_characters(
+                        reinterpret_cast<const CharType*>(el.first.c_str()),
+                        el.first.size());
+                    write_ubjson(el.second, use_count, use_type, prefix_required);
+                }
+
+                if (not use_count)
+                {
+                    oa->write_character(to_char_type('}'));
+                }
+
+                break;
+            }
+
+            default:
+                break;
+        }
+    }
+
+  private:
+    //////////
+    // BSON //
+    //////////
+
+    /*!
+    @return The size of a BSON document entry header, including the id marker
+            and the entry name size (and its null-terminator).
+    */
+    static std::size_t calc_bson_entry_header_size(const string_t& name)
+    {
+        const auto it = name.find(static_cast<typename string_t::value_type>(0));
+        if (JSON_HEDLEY_UNLIKELY(it != BasicJsonType::string_t::npos))
+        {
+            JSON_THROW(out_of_range::create(409,
+                                            "BSON key cannot contain code point U+0000 (at byte " + std::to_string(it) + ")"));
+        }
+
+        return /*id*/ 1ul + name.size() + /*zero-terminator*/1u;
+    }
+
+    /*!
+    @brief Writes the given @a element_type and @a name to the output adapter
+    */
+    void write_bson_entry_header(const string_t& name,
+                                 const std::uint8_t element_type)
+    {
+        oa->write_character(to_char_type(element_type)); // boolean
+        oa->write_characters(
+            reinterpret_cast<const CharType*>(name.c_str()),
+            name.size() + 1u);
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and boolean value @a value
+    */
+    void write_bson_boolean(const string_t& name,
+                            const bool value)
+    {
+        write_bson_entry_header(name, 0x08);
+        oa->write_character(value ? to_char_type(0x01) : to_char_type(0x00));
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and double value @a value
+    */
+    void write_bson_double(const string_t& name,
+                           const double value)
+    {
+        write_bson_entry_header(name, 0x01);
+        write_number<double, true>(value);
+    }
+
+    /*!
+    @return The size of the BSON-encoded string in @a value
+    */
+    static std::size_t calc_bson_string_size(const string_t& value)
+    {
+        return sizeof(std::int32_t) + value.size() + 1ul;
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and string value @a value
+    */
+    void write_bson_string(const string_t& name,
+                           const string_t& value)
+    {
+        write_bson_entry_header(name, 0x02);
+
+        write_number<std::int32_t, true>(static_cast<std::int32_t>(value.size() + 1ul));
+        oa->write_characters(
+            reinterpret_cast<const CharType*>(value.c_str()),
+            value.size() + 1);
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and null value
+    */
+    void write_bson_null(const string_t& name)
+    {
+        write_bson_entry_header(name, 0x0A);
+    }
+
+    /*!
+    @return The size of the BSON-encoded integer @a value
+    */
+    static std::size_t calc_bson_integer_size(const std::int64_t value)
+    {
+        return (std::numeric_limits<std::int32_t>::min)() <= value and value <= (std::numeric_limits<std::int32_t>::max)()
+               ? sizeof(std::int32_t)
+               : sizeof(std::int64_t);
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and integer @a value
+    */
+    void write_bson_integer(const string_t& name,
+                            const std::int64_t value)
+    {
+        if ((std::numeric_limits<std::int32_t>::min)() <= value and value <= (std::numeric_limits<std::int32_t>::max)())
+        {
+            write_bson_entry_header(name, 0x10); // int32
+            write_number<std::int32_t, true>(static_cast<std::int32_t>(value));
+        }
+        else
+        {
+            write_bson_entry_header(name, 0x12); // int64
+            write_number<std::int64_t, true>(static_cast<std::int64_t>(value));
+        }
+    }
+
+    /*!
+    @return The size of the BSON-encoded unsigned integer in @a j
+    */
+    static constexpr std::size_t calc_bson_unsigned_size(const std::uint64_t value) noexcept
+    {
+        return (value <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
+               ? sizeof(std::int32_t)
+               : sizeof(std::int64_t);
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and unsigned @a value
+    */
+    void write_bson_unsigned(const string_t& name,
+                             const std::uint64_t value)
+    {
+        if (value <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
+        {
+            write_bson_entry_header(name, 0x10 /* int32 */);
+            write_number<std::int32_t, true>(static_cast<std::int32_t>(value));
+        }
+        else if (value <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
+        {
+            write_bson_entry_header(name, 0x12 /* int64 */);
+            write_number<std::int64_t, true>(static_cast<std::int64_t>(value));
+        }
+        else
+        {
+            JSON_THROW(out_of_range::create(407, "integer number " + std::to_string(value) + " cannot be represented by BSON as it does not fit int64"));
+        }
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and object @a value
+    */
+    void write_bson_object_entry(const string_t& name,
+                                 const typename BasicJsonType::object_t& value)
+    {
+        write_bson_entry_header(name, 0x03); // object
+        write_bson_object(value);
+    }
+
+    /*!
+    @return The size of the BSON-encoded array @a value
+    */
+    static std::size_t calc_bson_array_size(const typename BasicJsonType::array_t& value)
+    {
+        std::size_t embedded_document_size = 0ul;
+        std::size_t array_index = 0ul;
+
+        for (const auto& el : value)
+        {
+            embedded_document_size += calc_bson_element_size(std::to_string(array_index++), el);
+        }
+
+        return sizeof(std::int32_t) + embedded_document_size + 1ul;
+    }
+
+    /*!
+    @brief Writes a BSON element with key @a name and array @a value
+    */
+    void write_bson_array(const string_t& name,
+                          const typename BasicJsonType::array_t& value)
+    {
+        write_bson_entry_header(name, 0x04); // array
+        write_number<std::int32_t, true>(static_cast<std::int32_t>(calc_bson_array_size(value)));
+
+        std::size_t array_index = 0ul;
+
+        for (const auto& el : value)
+        {
+            write_bson_element(std::to_string(array_index++), el);
+        }
+
+        oa->write_character(to_char_type(0x00));
+    }
+
+    /*!
+    @brief Calculates the size necessary to serialize the JSON value @a j with its @a name
+    @return The calculated size for the BSON document entry for @a j with the given @a name.
+    */
+    static std::size_t calc_bson_element_size(const string_t& name,
+            const BasicJsonType& j)
+    {
+        const auto header_size = calc_bson_entry_header_size(name);
+        switch (j.type())
+        {
+            case value_t::object:
+                return header_size + calc_bson_object_size(*j.m_value.object);
+
+            case value_t::array:
+                return header_size + calc_bson_array_size(*j.m_value.array);
+
+            case value_t::boolean:
+                return header_size + 1ul;
+
+            case value_t::number_float:
+                return header_size + 8ul;
+
+            case value_t::number_integer:
+                return header_size + calc_bson_integer_size(j.m_value.number_integer);
+
+            case value_t::number_unsigned:
+                return header_size + calc_bson_unsigned_size(j.m_value.number_unsigned);
+
+            case value_t::string:
+                return header_size + calc_bson_string_size(*j.m_value.string);
+
+            case value_t::null:
+                return header_size + 0ul;
+
+            // LCOV_EXCL_START
+            default:
+                assert(false);
+                return 0ul;
+                // LCOV_EXCL_STOP
+        }
+    }
+
+    /*!
+    @brief Serializes the JSON value @a j to BSON and associates it with the
+           key @a name.
+    @param name The name to associate with the JSON entity @a j within the
+                current BSON document
+    @return The size of the BSON entry
+    */
+    void write_bson_element(const string_t& name,
+                            const BasicJsonType& j)
+    {
+        switch (j.type())
+        {
+            case value_t::object:
+                return write_bson_object_entry(name, *j.m_value.object);
+
+            case value_t::array:
+                return write_bson_array(name, *j.m_value.array);
+
+            case value_t::boolean:
+                return write_bson_boolean(name, j.m_value.boolean);
+
+            case value_t::number_float:
+                return write_bson_double(name, j.m_value.number_float);
+
+            case value_t::number_integer:
+                return write_bson_integer(name, j.m_value.number_integer);
+
+            case value_t::number_unsigned:
+                return write_bson_unsigned(name, j.m_value.number_unsigned);
+
+            case value_t::string:
+                return write_bson_string(name, *j.m_value.string);
+
+            case value_t::null:
+                return write_bson_null(name);
+
+            // LCOV_EXCL_START
+            default:
+                assert(false);
+                return;
+                // LCOV_EXCL_STOP
+        }
+    }
+
+    /*!
+    @brief Calculates the size of the BSON serialization of the given
+           JSON-object @a j.
+    @param[in] j  JSON value to serialize
+    @pre       j.type() == value_t::object
+    */
+    static std::size_t calc_bson_object_size(const typename BasicJsonType::object_t& value)
+    {
+        std::size_t document_size = std::accumulate(value.begin(), value.end(), 0ul,
+                                    [](size_t result, const typename BasicJsonType::object_t::value_type & el)
+        {
+            return result += calc_bson_element_size(el.first, el.second);
+        });
+
+        return sizeof(std::int32_t) + document_size + 1ul;
+    }
+
+    /*!
+    @param[in] j  JSON value to serialize
+    @pre       j.type() == value_t::object
+    */
+    void write_bson_object(const typename BasicJsonType::object_t& value)
+    {
+        write_number<std::int32_t, true>(static_cast<std::int32_t>(calc_bson_object_size(value)));
+
+        for (const auto& el : value)
+        {
+            write_bson_element(el.first, el.second);
+        }
+
+        oa->write_character(to_char_type(0x00));
+    }
+
+    //////////
+    // CBOR //
+    //////////
+
+    static constexpr CharType get_cbor_float_prefix(float /*unused*/)
+    {
+        return to_char_type(0xFA);  // Single-Precision Float
+    }
+
+    static constexpr CharType get_cbor_float_prefix(double /*unused*/)
+    {
+        return to_char_type(0xFB);  // Double-Precision Float
+    }
+
+    /////////////
+    // MsgPack //
+    /////////////
+
+    static constexpr CharType get_msgpack_float_prefix(float /*unused*/)
+    {
+        return to_char_type(0xCA);  // float 32
+    }
+
+    static constexpr CharType get_msgpack_float_prefix(double /*unused*/)
+    {
+        return to_char_type(0xCB);  // float 64
+    }
+
+    ////////////
+    // UBJSON //
+    ////////////
+
+    // UBJSON: write number (floating point)
+    template<typename NumberType, typename std::enable_if<
+                 std::is_floating_point<NumberType>::value, int>::type = 0>
+    void write_number_with_ubjson_prefix(const NumberType n,
+                                         const bool add_prefix)
+    {
+        if (add_prefix)
+        {
+            oa->write_character(get_ubjson_float_prefix(n));
+        }
+        write_number(n);
+    }
+
+    // UBJSON: write number (unsigned integer)
+    template<typename NumberType, typename std::enable_if<
+                 std::is_unsigned<NumberType>::value, int>::type = 0>
+    void write_number_with_ubjson_prefix(const NumberType n,
+                                         const bool add_prefix)
+    {
+        if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('i'));  // int8
+            }
+            write_number(static_cast<std::uint8_t>(n));
+        }
+        else if (n <= (std::numeric_limits<std::uint8_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('U'));  // uint8
+            }
+            write_number(static_cast<std::uint8_t>(n));
+        }
+        else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('I'));  // int16
+            }
+            write_number(static_cast<std::int16_t>(n));
+        }
+        else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('l'));  // int32
+            }
+            write_number(static_cast<std::int32_t>(n));
+        }
+        else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('L'));  // int64
+            }
+            write_number(static_cast<std::int64_t>(n));
+        }
+        else
+        {
+            JSON_THROW(out_of_range::create(407, "integer number " + std::to_string(n) + " cannot be represented by UBJSON as it does not fit int64"));
+        }
+    }
+
+    // UBJSON: write number (signed integer)
+    template<typename NumberType, typename std::enable_if<
+                 std::is_signed<NumberType>::value and
+                 not std::is_floating_point<NumberType>::value, int>::type = 0>
+    void write_number_with_ubjson_prefix(const NumberType n,
+                                         const bool add_prefix)
+    {
+        if ((std::numeric_limits<std::int8_t>::min)() <= n and n <= (std::numeric_limits<std::int8_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('i'));  // int8
+            }
+            write_number(static_cast<std::int8_t>(n));
+        }
+        else if (static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::min)()) <= n and n <= static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::max)()))
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('U'));  // uint8
+            }
+            write_number(static_cast<std::uint8_t>(n));
+        }
+        else if ((std::numeric_limits<std::int16_t>::min)() <= n and n <= (std::numeric_limits<std::int16_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('I'));  // int16
+            }
+            write_number(static_cast<std::int16_t>(n));
+        }
+        else if ((std::numeric_limits<std::int32_t>::min)() <= n and n <= (std::numeric_limits<std::int32_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('l'));  // int32
+            }
+            write_number(static_cast<std::int32_t>(n));
+        }
+        else if ((std::numeric_limits<std::int64_t>::min)() <= n and n <= (std::numeric_limits<std::int64_t>::max)())
+        {
+            if (add_prefix)
+            {
+                oa->write_character(to_char_type('L'));  // int64
+            }
+            write_number(static_cast<std::int64_t>(n));
+        }
+        // LCOV_EXCL_START
+        else
+        {
+            JSON_THROW(out_of_range::create(407, "integer number " + std::to_string(n) + " cannot be represented by UBJSON as it does not fit int64"));
+        }
+        // LCOV_EXCL_STOP
+    }
+
+    /*!
+    @brief determine the type prefix of container values
+
+    @note This function does not need to be 100% accurate when it comes to
+          integer limits. In case a number exceeds the limits of int64_t,
+          this will be detected by a later call to function
+          write_number_with_ubjson_prefix. Therefore, we return 'L' for any
+          value that does not fit the previous limits.
+    */
+    CharType ubjson_prefix(const BasicJsonType& j) const noexcept
+    {
+        switch (j.type())
+        {
+            case value_t::null:
+                return 'Z';
+
+            case value_t::boolean:
+                return j.m_value.boolean ? 'T' : 'F';
+
+            case value_t::number_integer:
+            {
+                if ((std::numeric_limits<std::int8_t>::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
+                {
+                    return 'i';
+                }
+                if ((std::numeric_limits<std::uint8_t>::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
+                {
+                    return 'U';
+                }
+                if ((std::numeric_limits<std::int16_t>::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
+                {
+                    return 'I';
+                }
+                if ((std::numeric_limits<std::int32_t>::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
+                {
+                    return 'l';
+                }
+                // no check and assume int64_t (see note above)
+                return 'L';
+            }
+
+            case value_t::number_unsigned:
+            {
+                if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)()))
+                {
+                    return 'i';
+                }
+                if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint8_t>::max)()))
+                {
+                    return 'U';
+                }
+                if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)()))
+                {
+                    return 'I';
+                }
+                if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
+                {
+                    return 'l';
+                }
+                // no check and assume int64_t (see note above)
+                return 'L';
+            }
+
+            case value_t::number_float:
+                return get_ubjson_float_prefix(j.m_value.number_float);
+
+            case value_t::string:
+                return 'S';
+
+            case value_t::array:
+                return '[';
+
+            case value_t::object:
+                return '{';
+
+            default:  // discarded values
+                return 'N';
+        }
+    }
+
+    static constexpr CharType get_ubjson_float_prefix(float /*unused*/)
+    {
+        return 'd';  // float 32
+    }
+
+    static constexpr CharType get_ubjson_float_prefix(double /*unused*/)
+    {
+        return 'D';  // float 64
+    }
+
+    ///////////////////////
+    // Utility functions //
+    ///////////////////////
+
+    /*
+    @brief write a number to output input
+    @param[in] n number of type @a NumberType
+    @tparam NumberType the type of the number
+    @tparam OutputIsLittleEndian Set to true if output data is
+                                 required to be little endian
+
+    @note This function needs to respect the system's endianess, because bytes
+          in CBOR, MessagePack, and UBJSON are stored in network order (big
+          endian) and therefore need reordering on little endian systems.
+    */
+    template<typename NumberType, bool OutputIsLittleEndian = false>
+    void write_number(const NumberType n)
+    {
+        // step 1: write number to array of length NumberType
+        std::array<CharType, sizeof(NumberType)> vec;
+        std::memcpy(vec.data(), &n, sizeof(NumberType));
+
+        // step 2: write array to output (with possible reordering)
+        if (is_little_endian != OutputIsLittleEndian)
+        {
+            // reverse byte order prior to conversion if necessary
+            std::reverse(vec.begin(), vec.end());
+        }
+
+        oa->write_characters(vec.data(), sizeof(NumberType));
+    }
+
+  public:
+    // The following to_char_type functions are implement the conversion
+    // between uint8_t and CharType. In case CharType is not unsigned,
+    // such a conversion is required to allow values greater than 128.
+    // See <https://github.com/nlohmann/json/issues/1286> for a discussion.
+    template < typename C = CharType,
+               enable_if_t < std::is_signed<C>::value and std::is_signed<char>::value > * = nullptr >
+    static constexpr CharType to_char_type(std::uint8_t x) noexcept
+    {
+        return *reinterpret_cast<char*>(&x);
+    }
+
+    template < typename C = CharType,
+               enable_if_t < std::is_signed<C>::value and std::is_unsigned<char>::value > * = nullptr >
+    static CharType to_char_type(std::uint8_t x) noexcept
+    {
+        static_assert(sizeof(std::uint8_t) == sizeof(CharType), "size of CharType must be equal to std::uint8_t");
+        static_assert(std::is_pod<CharType>::value, "CharType must be POD");
+        CharType result;
+        std::memcpy(&result, &x, sizeof(x));
+        return result;
+    }
+
+    template<typename C = CharType,
+             enable_if_t<std::is_unsigned<C>::value>* = nullptr>
+    static constexpr CharType to_char_type(std::uint8_t x) noexcept
+    {
+        return x;
+    }
+
+    template < typename InputCharType, typename C = CharType,
+               enable_if_t <
+                   std::is_signed<C>::value and
+                   std::is_signed<char>::value and
+                   std::is_same<char, typename std::remove_cv<InputCharType>::type>::value
+                   > * = nullptr >
+    static constexpr CharType to_char_type(InputCharType x) noexcept
+    {
+        return x;
+    }
+
+  private:
+    /// whether we can assume little endianess
+    const bool is_little_endian = binary_reader<BasicJsonType>::little_endianess();
+
+    /// the output
+    output_adapter_t<CharType> oa = nullptr;
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/output/output_adapters.hpp>
+
+// #include <nlohmann/detail/output/serializer.hpp>
+
+
+#include <algorithm> // reverse, remove, fill, find, none_of
+#include <array> // array
+#include <cassert> // assert
+#include <ciso646> // and, or
+#include <clocale> // localeconv, lconv
+#include <cmath> // labs, isfinite, isnan, signbit
+#include <cstddef> // size_t, ptrdiff_t
+#include <cstdint> // uint8_t
+#include <cstdio> // snprintf
+#include <limits> // numeric_limits
+#include <string> // string
+#include <type_traits> // is_same
+#include <utility> // move
+
+// #include <nlohmann/detail/conversions/to_chars.hpp>
+
+
+#include <array> // array
+#include <cassert> // assert
+#include <ciso646> // or, and, not
+#include <cmath>   // signbit, isfinite
+#include <cstdint> // intN_t, uintN_t
+#include <cstring> // memcpy, memmove
+#include <limits> // numeric_limits
+#include <type_traits> // conditional
+// #include <nlohmann/detail/macro_scope.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+
+/*!
+@brief implements the Grisu2 algorithm for binary to decimal floating-point
+conversion.
+
+This implementation is a slightly modified version of the reference
+implementation which may be obtained from
+http://florian.loitsch.com/publications (bench.tar.gz).
+
+The code is distributed under the MIT license, Copyright (c) 2009 Florian Loitsch.
+
+For a detailed description of the algorithm see:
+
+[1] Loitsch, "Printing Floating-Point Numbers Quickly and Accurately with
+    Integers", Proceedings of the ACM SIGPLAN 2010 Conference on Programming
+    Language Design and Implementation, PLDI 2010
+[2] Burger, Dybvig, "Printing Floating-Point Numbers Quickly and Accurately",
+    Proceedings of the ACM SIGPLAN 1996 Conference on Programming Language
+    Design and Implementation, PLDI 1996
+*/
+namespace dtoa_impl
+{
+
+template <typename Target, typename Source>
+Target reinterpret_bits(const Source source)
+{
+    static_assert(sizeof(Target) == sizeof(Source), "size mismatch");
+
+    Target target;
+    std::memcpy(&target, &source, sizeof(Source));
+    return target;
+}
+
+struct diyfp // f * 2^e
+{
+    static constexpr int kPrecision = 64; // = q
+
+    std::uint64_t f = 0;
+    int e = 0;
+
+    constexpr diyfp(std::uint64_t f_, int e_) noexcept : f(f_), e(e_) {}
+
+    /*!
+    @brief returns x - y
+    @pre x.e == y.e and x.f >= y.f
+    */
+    static diyfp sub(const diyfp& x, const diyfp& y) noexcept
+    {
+        assert(x.e == y.e);
+        assert(x.f >= y.f);
+
+        return {x.f - y.f, x.e};
+    }
+
+    /*!
+    @brief returns x * y
+    @note The result is rounded. (Only the upper q bits are returned.)
+    */
+    static diyfp mul(const diyfp& x, const diyfp& y) noexcept
+    {
+        static_assert(kPrecision == 64, "internal error");
+
+        // Computes:
+        //  f = round((x.f * y.f) / 2^q)
+        //  e = x.e + y.e + q
+
+        // Emulate the 64-bit * 64-bit multiplication:
+        //
+        // p = u * v
+        //   = (u_lo + 2^32 u_hi) (v_lo + 2^32 v_hi)
+        //   = (u_lo v_lo         ) + 2^32 ((u_lo v_hi         ) + (u_hi v_lo         )) + 2^64 (u_hi v_hi         )
+        //   = (p0                ) + 2^32 ((p1                ) + (p2                )) + 2^64 (p3                )
+        //   = (p0_lo + 2^32 p0_hi) + 2^32 ((p1_lo + 2^32 p1_hi) + (p2_lo + 2^32 p2_hi)) + 2^64 (p3                )
+        //   = (p0_lo             ) + 2^32 (p0_hi + p1_lo + p2_lo                      ) + 2^64 (p1_hi + p2_hi + p3)
+        //   = (p0_lo             ) + 2^32 (Q                                          ) + 2^64 (H                 )
+        //   = (p0_lo             ) + 2^32 (Q_lo + 2^32 Q_hi                           ) + 2^64 (H                 )
+        //
+        // (Since Q might be larger than 2^32 - 1)
+        //
+        //   = (p0_lo + 2^32 Q_lo) + 2^64 (Q_hi + H)
+        //
+        // (Q_hi + H does not overflow a 64-bit int)
+        //
+        //   = p_lo + 2^64 p_hi
+
+        const std::uint64_t u_lo = x.f & 0xFFFFFFFFu;
+        const std::uint64_t u_hi = x.f >> 32u;
+        const std::uint64_t v_lo = y.f & 0xFFFFFFFFu;
+        const std::uint64_t v_hi = y.f >> 32u;
+
+        const std::uint64_t p0 = u_lo * v_lo;
+        const std::uint64_t p1 = u_lo * v_hi;
+        const std::uint64_t p2 = u_hi * v_lo;
+        const std::uint64_t p3 = u_hi * v_hi;
+
+        const std::uint64_t p0_hi = p0 >> 32u;
+        const std::uint64_t p1_lo = p1 & 0xFFFFFFFFu;
+        const std::uint64_t p1_hi = p1 >> 32u;
+        const std::uint64_t p2_lo = p2 & 0xFFFFFFFFu;
+        const std::uint64_t p2_hi = p2 >> 32u;
+
+        std::uint64_t Q = p0_hi + p1_lo + p2_lo;
+
+        // The full product might now be computed as
+        //
+        // p_hi = p3 + p2_hi + p1_hi + (Q >> 32)
+        // p_lo = p0_lo + (Q << 32)
+        //
+        // But in this particular case here, the full p_lo is not required.
+        // Effectively we only need to add the highest bit in p_lo to p_hi (and
+        // Q_hi + 1 does not overflow).
+
+        Q += std::uint64_t{1} << (64u - 32u - 1u); // round, ties up
+
+        const std::uint64_t h = p3 + p2_hi + p1_hi + (Q >> 32u);
+
+        return {h, x.e + y.e + 64};
+    }
+
+    /*!
+    @brief normalize x such that the significand is >= 2^(q-1)
+    @pre x.f != 0
+    */
+    static diyfp normalize(diyfp x) noexcept
+    {
+        assert(x.f != 0);
+
+        while ((x.f >> 63u) == 0)
+        {
+            x.f <<= 1u;
+            x.e--;
+        }
+
+        return x;
+    }
+
+    /*!
+    @brief normalize x such that the result has the exponent E
+    @pre e >= x.e and the upper e - x.e bits of x.f must be zero.
+    */
+    static diyfp normalize_to(const diyfp& x, const int target_exponent) noexcept
+    {
+        const int delta = x.e - target_exponent;
+
+        assert(delta >= 0);
+        assert(((x.f << delta) >> delta) == x.f);
+
+        return {x.f << delta, target_exponent};
+    }
+};
+
+struct boundaries
+{
+    diyfp w;
+    diyfp minus;
+    diyfp plus;
+};
+
+/*!
+Compute the (normalized) diyfp representing the input number 'value' and its
+boundaries.
+
+@pre value must be finite and positive
+*/
+template <typename FloatType>
+boundaries compute_boundaries(FloatType value)
+{
+    assert(std::isfinite(value));
+    assert(value > 0);
+
+    // Convert the IEEE representation into a diyfp.
+    //
+    // If v is denormal:
+    //      value = 0.F * 2^(1 - bias) = (          F) * 2^(1 - bias - (p-1))
+    // If v is normalized:
+    //      value = 1.F * 2^(E - bias) = (2^(p-1) + F) * 2^(E - bias - (p-1))
+
+    static_assert(std::numeric_limits<FloatType>::is_iec559,
+                  "internal error: dtoa_short requires an IEEE-754 floating-point implementation");
+
+    constexpr int      kPrecision = std::numeric_limits<FloatType>::digits; // = p (includes the hidden bit)
+    constexpr int      kBias      = std::numeric_limits<FloatType>::max_exponent - 1 + (kPrecision - 1);
+    constexpr int      kMinExp    = 1 - kBias;
+    constexpr std::uint64_t kHiddenBit = std::uint64_t{1} << (kPrecision - 1); // = 2^(p-1)
+
+    using bits_type = typename std::conditional<kPrecision == 24, std::uint32_t, std::uint64_t >::type;
+
+    const std::uint64_t bits = reinterpret_bits<bits_type>(value);
+    const std::uint64_t E = bits >> (kPrecision - 1);
+    const std::uint64_t F = bits & (kHiddenBit - 1);
+
+    const bool is_denormal = E == 0;
+    const diyfp v = is_denormal
+                    ? diyfp(F, kMinExp)
+                    : diyfp(F + kHiddenBit, static_cast<int>(E) - kBias);
+
+    // Compute the boundaries m- and m+ of the floating-point value
+    // v = f * 2^e.
+    //
+    // Determine v- and v+, the floating-point predecessor and successor if v,
+    // respectively.
+    //
+    //      v- = v - 2^e        if f != 2^(p-1) or e == e_min                (A)
+    //         = v - 2^(e-1)    if f == 2^(p-1) and e > e_min                (B)
+    //
+    //      v+ = v + 2^e
+    //
+    // Let m- = (v- + v) / 2 and m+ = (v + v+) / 2. All real numbers _strictly_
+    // between m- and m+ round to v, regardless of how the input rounding
+    // algorithm breaks ties.
+    //
+    //      ---+-------------+-------------+-------------+-------------+---  (A)
+    //         v-            m-            v             m+            v+
+    //
+    //      -----------------+------+------+-------------+-------------+---  (B)
+    //                       v-     m-     v             m+            v+
+
+    const bool lower_boundary_is_closer = F == 0 and E > 1;
+    const diyfp m_plus = diyfp(2 * v.f + 1, v.e - 1);
+    const diyfp m_minus = lower_boundary_is_closer
+                          ? diyfp(4 * v.f - 1, v.e - 2)  // (B)
+                          : diyfp(2 * v.f - 1, v.e - 1); // (A)
+
+    // Determine the normalized w+ = m+.
+    const diyfp w_plus = diyfp::normalize(m_plus);
+
+    // Determine w- = m- such that e_(w-) = e_(w+).
+    const diyfp w_minus = diyfp::normalize_to(m_minus, w_plus.e);
+
+    return {diyfp::normalize(v), w_minus, w_plus};
+}
+
+// Given normalized diyfp w, Grisu needs to find a (normalized) cached
+// power-of-ten c, such that the exponent of the product c * w = f * 2^e lies
+// within a certain range [alpha, gamma] (Definition 3.2 from [1])
+//
+//      alpha <= e = e_c + e_w + q <= gamma
+//
+// or
+//
+//      f_c * f_w * 2^alpha <= f_c 2^(e_c) * f_w 2^(e_w) * 2^q
+//                          <= f_c * f_w * 2^gamma
+//
+// Since c and w are normalized, i.e. 2^(q-1) <= f < 2^q, this implies
+//
+//      2^(q-1) * 2^(q-1) * 2^alpha <= c * w * 2^q < 2^q * 2^q * 2^gamma
+//
+// or
+//
+//      2^(q - 2 + alpha) <= c * w < 2^(q + gamma)
+//
+// The choice of (alpha,gamma) determines the size of the table and the form of
+// the digit generation procedure. Using (alpha,gamma)=(-60,-32) works out well
+// in practice:
+//
+// The idea is to cut the number c * w = f * 2^e into two parts, which can be
+// processed independently: An integral part p1, and a fractional part p2:
+//
+//      f * 2^e = ( (f div 2^-e) * 2^-e + (f mod 2^-e) ) * 2^e
+//              = (f div 2^-e) + (f mod 2^-e) * 2^e
+//              = p1 + p2 * 2^e
+//
+// The conversion of p1 into decimal form requires a series of divisions and
+// modulos by (a power of) 10. These operations are faster for 32-bit than for
+// 64-bit integers, so p1 should ideally fit into a 32-bit integer. This can be
+// achieved by choosing
+//
+//      -e >= 32   or   e <= -32 := gamma
+//
+// In order to convert the fractional part
+//
+//      p2 * 2^e = p2 / 2^-e = d[-1] / 10^1 + d[-2] / 10^2 + ...
+//
+// into decimal form, the fraction is repeatedly multiplied by 10 and the digits
+// d[-i] are extracted in order:
+//
+//      (10 * p2) div 2^-e = d[-1]
+//      (10 * p2) mod 2^-e = d[-2] / 10^1 + ...
+//
+// The multiplication by 10 must not overflow. It is sufficient to choose
+//
+//      10 * p2 < 16 * p2 = 2^4 * p2 <= 2^64.
+//
+// Since p2 = f mod 2^-e < 2^-e,
+//
+//      -e <= 60   or   e >= -60 := alpha
+
+constexpr int kAlpha = -60;
+constexpr int kGamma = -32;
+
+struct cached_power // c = f * 2^e ~= 10^k
+{
+    std::uint64_t f;
+    int e;
+    int k;
+};
+
+/*!
+For a normalized diyfp w = f * 2^e, this function returns a (normalized) cached
+power-of-ten c = f_c * 2^e_c, such that the exponent of the product w * c
+satisfies (Definition 3.2 from [1])
+
+     alpha <= e_c + e + q <= gamma.
+*/
+inline cached_power get_cached_power_for_binary_exponent(int e)
+{
+    // Now
+    //
+    //      alpha <= e_c + e + q <= gamma                                    (1)
+    //      ==> f_c * 2^alpha <= c * 2^e * 2^q
+    //
+    // and since the c's are normalized, 2^(q-1) <= f_c,
+    //
+    //      ==> 2^(q - 1 + alpha) <= c * 2^(e + q)
+    //      ==> 2^(alpha - e - 1) <= c
+    //
+    // If c were an exakt power of ten, i.e. c = 10^k, one may determine k as
+    //
+    //      k = ceil( log_10( 2^(alpha - e - 1) ) )
+    //        = ceil( (alpha - e - 1) * log_10(2) )
+    //
+    // From the paper:
+    // "In theory the result of the procedure could be wrong since c is rounded,
+    //  and the computation itself is approximated [...]. In practice, however,
+    //  this simple function is sufficient."
+    //
+    // For IEEE double precision floating-point numbers converted into
+    // normalized diyfp's w = f * 2^e, with q = 64,
+    //
+    //      e >= -1022      (min IEEE exponent)
+    //           -52        (p - 1)
+    //           -52        (p - 1, possibly normalize denormal IEEE numbers)
+    //           -11        (normalize the diyfp)
+    //         = -1137
+    //
+    // and
+    //
+    //      e <= +1023      (max IEEE exponent)
+    //           -52        (p - 1)
+    //           -11        (normalize the diyfp)
+    //         = 960
+    //
+    // This binary exponent range [-1137,960] results in a decimal exponent
+    // range [-307,324]. One does not need to store a cached power for each
+    // k in this range. For each such k it suffices to find a cached power
+    // such that the exponent of the product lies in [alpha,gamma].
+    // This implies that the difference of the decimal exponents of adjacent
+    // table entries must be less than or equal to
+    //
+    //      floor( (gamma - alpha) * log_10(2) ) = 8.
+    //
+    // (A smaller distance gamma-alpha would require a larger table.)
+
+    // NB:
+    // Actually this function returns c, such that -60 <= e_c + e + 64 <= -34.
+
+    constexpr int kCachedPowersMinDecExp = -300;
+    constexpr int kCachedPowersDecStep = 8;
+
+    static constexpr std::array<cached_power, 79> kCachedPowers =
+    {
+        {
+            { 0xAB70FE17C79AC6CA, -1060, -300 },
+            { 0xFF77B1FCBEBCDC4F, -1034, -292 },
+            { 0xBE5691EF416BD60C, -1007, -284 },
+            { 0x8DD01FAD907FFC3C,  -980, -276 },
+            { 0xD3515C2831559A83,  -954, -268 },
+            { 0x9D71AC8FADA6C9B5,  -927, -260 },
+            { 0xEA9C227723EE8BCB,  -901, -252 },
+            { 0xAECC49914078536D,  -874, -244 },
+            { 0x823C12795DB6CE57,  -847, -236 },
+            { 0xC21094364DFB5637,  -821, -228 },
+            { 0x9096EA6F3848984F,  -794, -220 },
+            { 0xD77485CB25823AC7,  -768, -212 },
+            { 0xA086CFCD97BF97F4,  -741, -204 },
+            { 0xEF340A98172AACE5,  -715, -196 },
+            { 0xB23867FB2A35B28E,  -688, -188 },
+            { 0x84C8D4DFD2C63F3B,  -661, -180 },
+            { 0xC5DD44271AD3CDBA,  -635, -172 },
+            { 0x936B9FCEBB25C996,  -608, -164 },
+            { 0xDBAC6C247D62A584,  -582, -156 },
+            { 0xA3AB66580D5FDAF6,  -555, -148 },
+            { 0xF3E2F893DEC3F126,  -529, -140 },
+            { 0xB5B5ADA8AAFF80B8,  -502, -132 },
+            { 0x87625F056C7C4A8B,  -475, -124 },
+            { 0xC9BCFF6034C13053,  -449, -116 },
+            { 0x964E858C91BA2655,  -422, -108 },
+            { 0xDFF9772470297EBD,  -396, -100 },
+            { 0xA6DFBD9FB8E5B88F,  -369,  -92 },
+            { 0xF8A95FCF88747D94,  -343,  -84 },
+            { 0xB94470938FA89BCF,  -316,  -76 },
+            { 0x8A08F0F8BF0F156B,  -289,  -68 },
+            { 0xCDB02555653131B6,  -263,  -60 },
+            { 0x993FE2C6D07B7FAC,  -236,  -52 },
+            { 0xE45C10C42A2B3B06,  -210,  -44 },
+            { 0xAA242499697392D3,  -183,  -36 },
+            { 0xFD87B5F28300CA0E,  -157,  -28 },
+            { 0xBCE5086492111AEB,  -130,  -20 },
+            { 0x8CBCCC096F5088CC,  -103,  -12 },
+            { 0xD1B71758E219652C,   -77,   -4 },
+            { 0x9C40000000000000,   -50,    4 },
+            { 0xE8D4A51000000000,   -24,   12 },
+            { 0xAD78EBC5AC620000,     3,   20 },
+            { 0x813F3978F8940984,    30,   28 },
+            { 0xC097CE7BC90715B3,    56,   36 },
+            { 0x8F7E32CE7BEA5C70,    83,   44 },
+            { 0xD5D238A4ABE98068,   109,   52 },
+            { 0x9F4F2726179A2245,   136,   60 },
+            { 0xED63A231D4C4FB27,   162,   68 },
+            { 0xB0DE65388CC8ADA8,   189,   76 },
+            { 0x83C7088E1AAB65DB,   216,   84 },
+            { 0xC45D1DF942711D9A,   242,   92 },
+            { 0x924D692CA61BE758,   269,  100 },
+            { 0xDA01EE641A708DEA,   295,  108 },
+            { 0xA26DA3999AEF774A,   322,  116 },
+            { 0xF209787BB47D6B85,   348,  124 },
+            { 0xB454E4A179DD1877,   375,  132 },
+            { 0x865B86925B9BC5C2,   402,  140 },
+            { 0xC83553C5C8965D3D,   428,  148 },
+            { 0x952AB45CFA97A0B3,   455,  156 },
+            { 0xDE469FBD99A05FE3,   481,  164 },
+            { 0xA59BC234DB398C25,   508,  172 },
+            { 0xF6C69A72A3989F5C,   534,  180 },
+            { 0xB7DCBF5354E9BECE,   561,  188 },
+            { 0x88FCF317F22241E2,   588,  196 },
+            { 0xCC20CE9BD35C78A5,   614,  204 },
+            { 0x98165AF37B2153DF,   641,  212 },
+            { 0xE2A0B5DC971F303A,   667,  220 },
+            { 0xA8D9D1535CE3B396,   694,  228 },
+            { 0xFB9B7CD9A4A7443C,   720,  236 },
+            { 0xBB764C4CA7A44410,   747,  244 },
+            { 0x8BAB8EEFB6409C1A,   774,  252 },
+            { 0xD01FEF10A657842C,   800,  260 },
+            { 0x9B10A4E5E9913129,   827,  268 },
+            { 0xE7109BFBA19C0C9D,   853,  276 },
+            { 0xAC2820D9623BF429,   880,  284 },
+            { 0x80444B5E7AA7CF85,   907,  292 },
+            { 0xBF21E44003ACDD2D,   933,  300 },
+            { 0x8E679C2F5E44FF8F,   960,  308 },
+            { 0xD433179D9C8CB841,   986,  316 },
+            { 0x9E19DB92B4E31BA9,  1013,  324 },
+        }
+    };
+
+    // This computation gives exactly the same results for k as
+    //      k = ceil((kAlpha - e - 1) * 0.30102999566398114)
+    // for |e| <= 1500, but doesn't require floating-point operations.
+    // NB: log_10(2) ~= 78913 / 2^18
+    assert(e >= -1500);
+    assert(e <=  1500);
+    const int f = kAlpha - e - 1;
+    const int k = (f * 78913) / (1 << 18) + static_cast<int>(f > 0);
+
+    const int index = (-kCachedPowersMinDecExp + k + (kCachedPowersDecStep - 1)) / kCachedPowersDecStep;
+    assert(index >= 0);
+    assert(static_cast<std::size_t>(index) < kCachedPowers.size());
+
+    const cached_power cached = kCachedPowers[static_cast<std::size_t>(index)];
+    assert(kAlpha <= cached.e + e + 64);
+    assert(kGamma >= cached.e + e + 64);
+
+    return cached;
+}
+
+/*!
+For n != 0, returns k, such that pow10 := 10^(k-1) <= n < 10^k.
+For n == 0, returns 1 and sets pow10 := 1.
+*/
+inline int find_largest_pow10(const std::uint32_t n, std::uint32_t& pow10)
+{
+    // LCOV_EXCL_START
+    if (n >= 1000000000)
+    {
+        pow10 = 1000000000;
+        return 10;
+    }
+    // LCOV_EXCL_STOP
+    else if (n >= 100000000)
+    {
+        pow10 = 100000000;
+        return  9;
+    }
+    else if (n >= 10000000)
+    {
+        pow10 = 10000000;
+        return  8;
+    }
+    else if (n >= 1000000)
+    {
+        pow10 = 1000000;
+        return  7;
+    }
+    else if (n >= 100000)
+    {
+        pow10 = 100000;
+        return  6;
+    }
+    else if (n >= 10000)
+    {
+        pow10 = 10000;
+        return  5;
+    }
+    else if (n >= 1000)
+    {
+        pow10 = 1000;
+        return  4;
+    }
+    else if (n >= 100)
+    {
+        pow10 = 100;
+        return  3;
+    }
+    else if (n >= 10)
+    {
+        pow10 = 10;
+        return  2;
+    }
+    else
+    {
+        pow10 = 1;
+        return 1;
+    }
+}
+
+inline void grisu2_round(char* buf, int len, std::uint64_t dist, std::uint64_t delta,
+                         std::uint64_t rest, std::uint64_t ten_k)
+{
+    assert(len >= 1);
+    assert(dist <= delta);
+    assert(rest <= delta);
+    assert(ten_k > 0);
+
+    //               <--------------------------- delta ---->
+    //                                  <---- dist --------->
+    // --------------[------------------+-------------------]--------------
+    //               M-                 w                   M+
+    //
+    //                                  ten_k
+    //                                <------>
+    //                                       <---- rest ---->
+    // --------------[------------------+----+--------------]--------------
+    //                                  w    V
+    //                                       = buf * 10^k
+    //
+    // ten_k represents a unit-in-the-last-place in the decimal representation
+    // stored in buf.
+    // Decrement buf by ten_k while this takes buf closer to w.
+
+    // The tests are written in this order to avoid overflow in unsigned
+    // integer arithmetic.
+
+    while (rest < dist
+            and delta - rest >= ten_k
+            and (rest + ten_k < dist or dist - rest > rest + ten_k - dist))
+    {
+        assert(buf[len - 1] != '0');
+        buf[len - 1]--;
+        rest += ten_k;
+    }
+}
+
+/*!
+Generates V = buffer * 10^decimal_exponent, such that M- <= V <= M+.
+M- and M+ must be normalized and share the same exponent -60 <= e <= -32.
+*/
+inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
+                             diyfp M_minus, diyfp w, diyfp M_plus)
+{
+    static_assert(kAlpha >= -60, "internal error");
+    static_assert(kGamma <= -32, "internal error");
+
+    // Generates the digits (and the exponent) of a decimal floating-point
+    // number V = buffer * 10^decimal_exponent in the range [M-, M+]. The diyfp's
+    // w, M- and M+ share the same exponent e, which satisfies alpha <= e <= gamma.
+    //
+    //               <--------------------------- delta ---->
+    //                                  <---- dist --------->
+    // --------------[------------------+-------------------]--------------
+    //               M-                 w                   M+
+    //
+    // Grisu2 generates the digits of M+ from left to right and stops as soon as
+    // V is in [M-,M+].
+
+    assert(M_plus.e >= kAlpha);
+    assert(M_plus.e <= kGamma);
+
+    std::uint64_t delta = diyfp::sub(M_plus, M_minus).f; // (significand of (M+ - M-), implicit exponent is e)
+    std::uint64_t dist  = diyfp::sub(M_plus, w      ).f; // (significand of (M+ - w ), implicit exponent is e)
+
+    // Split M+ = f * 2^e into two parts p1 and p2 (note: e < 0):
+    //
+    //      M+ = f * 2^e
+    //         = ((f div 2^-e) * 2^-e + (f mod 2^-e)) * 2^e
+    //         = ((p1        ) * 2^-e + (p2        )) * 2^e
+    //         = p1 + p2 * 2^e
+
+    const diyfp one(std::uint64_t{1} << -M_plus.e, M_plus.e);
+
+    auto p1 = static_cast<std::uint32_t>(M_plus.f >> -one.e); // p1 = f div 2^-e (Since -e >= 32, p1 fits into a 32-bit int.)
+    std::uint64_t p2 = M_plus.f & (one.f - 1);                    // p2 = f mod 2^-e
+
+    // 1)
+    //
+    // Generate the digits of the integral part p1 = d[n-1]...d[1]d[0]
+
+    assert(p1 > 0);
+
+    std::uint32_t pow10;
+    const int k = find_largest_pow10(p1, pow10);
+
+    //      10^(k-1) <= p1 < 10^k, pow10 = 10^(k-1)
+    //
+    //      p1 = (p1 div 10^(k-1)) * 10^(k-1) + (p1 mod 10^(k-1))
+    //         = (d[k-1]         ) * 10^(k-1) + (p1 mod 10^(k-1))
+    //
+    //      M+ = p1                                             + p2 * 2^e
+    //         = d[k-1] * 10^(k-1) + (p1 mod 10^(k-1))          + p2 * 2^e
+    //         = d[k-1] * 10^(k-1) + ((p1 mod 10^(k-1)) * 2^-e + p2) * 2^e
+    //         = d[k-1] * 10^(k-1) + (                         rest) * 2^e
+    //
+    // Now generate the digits d[n] of p1 from left to right (n = k-1,...,0)
+    //
+    //      p1 = d[k-1]...d[n] * 10^n + d[n-1]...d[0]
+    //
+    // but stop as soon as
+    //
+    //      rest * 2^e = (d[n-1]...d[0] * 2^-e + p2) * 2^e <= delta * 2^e
+
+    int n = k;
+    while (n > 0)
+    {
+        // Invariants:
+        //      M+ = buffer * 10^n + (p1 + p2 * 2^e)    (buffer = 0 for n = k)
+        //      pow10 = 10^(n-1) <= p1 < 10^n
+        //
+        const std::uint32_t d = p1 / pow10;  // d = p1 div 10^(n-1)
+        const std::uint32_t r = p1 % pow10;  // r = p1 mod 10^(n-1)
+        //
+        //      M+ = buffer * 10^n + (d * 10^(n-1) + r) + p2 * 2^e
+        //         = (buffer * 10 + d) * 10^(n-1) + (r + p2 * 2^e)
+        //
+        assert(d <= 9);
+        buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
+        //
+        //      M+ = buffer * 10^(n-1) + (r + p2 * 2^e)
+        //
+        p1 = r;
+        n--;
+        //
+        //      M+ = buffer * 10^n + (p1 + p2 * 2^e)
+        //      pow10 = 10^n
+        //
+
+        // Now check if enough digits have been generated.
+        // Compute
+        //
+        //      p1 + p2 * 2^e = (p1 * 2^-e + p2) * 2^e = rest * 2^e
+        //
+        // Note:
+        // Since rest and delta share the same exponent e, it suffices to
+        // compare the significands.
+        const std::uint64_t rest = (std::uint64_t{p1} << -one.e) + p2;
+        if (rest <= delta)
+        {
+            // V = buffer * 10^n, with M- <= V <= M+.
+
+            decimal_exponent += n;
+
+            // We may now just stop. But instead look if the buffer could be
+            // decremented to bring V closer to w.
+            //
+            // pow10 = 10^n is now 1 ulp in the decimal representation V.
+            // The rounding procedure works with diyfp's with an implicit
+            // exponent of e.
+            //
+            //      10^n = (10^n * 2^-e) * 2^e = ulp * 2^e
+            //
+            const std::uint64_t ten_n = std::uint64_t{pow10} << -one.e;
+            grisu2_round(buffer, length, dist, delta, rest, ten_n);
+
+            return;
+        }
+
+        pow10 /= 10;
+        //
+        //      pow10 = 10^(n-1) <= p1 < 10^n
+        // Invariants restored.
+    }
+
+    // 2)
+    //
+    // The digits of the integral part have been generated:
+    //
+    //      M+ = d[k-1]...d[1]d[0] + p2 * 2^e
+    //         = buffer            + p2 * 2^e
+    //
+    // Now generate the digits of the fractional part p2 * 2^e.
+    //
+    // Note:
+    // No decimal point is generated: the exponent is adjusted instead.
+    //
+    // p2 actually represents the fraction
+    //
+    //      p2 * 2^e
+    //          = p2 / 2^-e
+    //          = d[-1] / 10^1 + d[-2] / 10^2 + ...
+    //
+    // Now generate the digits d[-m] of p1 from left to right (m = 1,2,...)
+    //
+    //      p2 * 2^e = d[-1]d[-2]...d[-m] * 10^-m
+    //                      + 10^-m * (d[-m-1] / 10^1 + d[-m-2] / 10^2 + ...)
+    //
+    // using
+    //
+    //      10^m * p2 = ((10^m * p2) div 2^-e) * 2^-e + ((10^m * p2) mod 2^-e)
+    //                = (                   d) * 2^-e + (                   r)
+    //
+    // or
+    //      10^m * p2 * 2^e = d + r * 2^e
+    //
+    // i.e.
+    //
+    //      M+ = buffer + p2 * 2^e
+    //         = buffer + 10^-m * (d + r * 2^e)
+    //         = (buffer * 10^m + d) * 10^-m + 10^-m * r * 2^e
+    //
+    // and stop as soon as 10^-m * r * 2^e <= delta * 2^e
+
+    assert(p2 > delta);
+
+    int m = 0;
+    for (;;)
+    {
+        // Invariant:
+        //      M+ = buffer * 10^-m + 10^-m * (d[-m-1] / 10 + d[-m-2] / 10^2 + ...) * 2^e
+        //         = buffer * 10^-m + 10^-m * (p2                                 ) * 2^e
+        //         = buffer * 10^-m + 10^-m * (1/10 * (10 * p2)                   ) * 2^e
+        //         = buffer * 10^-m + 10^-m * (1/10 * ((10*p2 div 2^-e) * 2^-e + (10*p2 mod 2^-e)) * 2^e
+        //
+        assert(p2 <= (std::numeric_limits<std::uint64_t>::max)() / 10);
+        p2 *= 10;
+        const std::uint64_t d = p2 >> -one.e;     // d = (10 * p2) div 2^-e
+        const std::uint64_t r = p2 & (one.f - 1); // r = (10 * p2) mod 2^-e
+        //
+        //      M+ = buffer * 10^-m + 10^-m * (1/10 * (d * 2^-e + r) * 2^e
+        //         = buffer * 10^-m + 10^-m * (1/10 * (d + r * 2^e))
+        //         = (buffer * 10 + d) * 10^(-m-1) + 10^(-m-1) * r * 2^e
+        //
+        assert(d <= 9);
+        buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
+        //
+        //      M+ = buffer * 10^(-m-1) + 10^(-m-1) * r * 2^e
+        //
+        p2 = r;
+        m++;
+        //
+        //      M+ = buffer * 10^-m + 10^-m * p2 * 2^e
+        // Invariant restored.
+
+        // Check if enough digits have been generated.
+        //
+        //      10^-m * p2 * 2^e <= delta * 2^e
+        //              p2 * 2^e <= 10^m * delta * 2^e
+        //                    p2 <= 10^m * delta
+        delta *= 10;
+        dist  *= 10;
+        if (p2 <= delta)
+        {
+            break;
+        }
+    }
+
+    // V = buffer * 10^-m, with M- <= V <= M+.
+
+    decimal_exponent -= m;
+
+    // 1 ulp in the decimal representation is now 10^-m.
+    // Since delta and dist are now scaled by 10^m, we need to do the
+    // same with ulp in order to keep the units in sync.
+    //
+    //      10^m * 10^-m = 1 = 2^-e * 2^e = ten_m * 2^e
+    //
+    const std::uint64_t ten_m = one.f;
+    grisu2_round(buffer, length, dist, delta, p2, ten_m);
+
+    // By construction this algorithm generates the shortest possible decimal
+    // number (Loitsch, Theorem 6.2) which rounds back to w.
+    // For an input number of precision p, at least
+    //
+    //      N = 1 + ceil(p * log_10(2))
+    //
+    // decimal digits are sufficient to identify all binary floating-point
+    // numbers (Matula, "In-and-Out conversions").
+    // This implies that the algorithm does not produce more than N decimal
+    // digits.
+    //
+    //      N = 17 for p = 53 (IEEE double precision)
+    //      N = 9  for p = 24 (IEEE single precision)
+}
+
+/*!
+v = buf * 10^decimal_exponent
+len is the length of the buffer (number of decimal digits)
+The buffer must be large enough, i.e. >= max_digits10.
+*/
+JSON_HEDLEY_NON_NULL(1)
+inline void grisu2(char* buf, int& len, int& decimal_exponent,
+                   diyfp m_minus, diyfp v, diyfp m_plus)
+{
+    assert(m_plus.e == m_minus.e);
+    assert(m_plus.e == v.e);
+
+    //  --------(-----------------------+-----------------------)--------    (A)
+    //          m-                      v                       m+
+    //
+    //  --------------------(-----------+-----------------------)--------    (B)
+    //                      m-          v                       m+
+    //
+    // First scale v (and m- and m+) such that the exponent is in the range
+    // [alpha, gamma].
+
+    const cached_power cached = get_cached_power_for_binary_exponent(m_plus.e);
+
+    const diyfp c_minus_k(cached.f, cached.e); // = c ~= 10^-k
+
+    // The exponent of the products is = v.e + c_minus_k.e + q and is in the range [alpha,gamma]
+    const diyfp w       = diyfp::mul(v,       c_minus_k);
+    const diyfp w_minus = diyfp::mul(m_minus, c_minus_k);
+    const diyfp w_plus  = diyfp::mul(m_plus,  c_minus_k);
+
+    //  ----(---+---)---------------(---+---)---------------(---+---)----
+    //          w-                      w                       w+
+    //          = c*m-                  = c*v                   = c*m+
+    //
+    // diyfp::mul rounds its result and c_minus_k is approximated too. w, w- and
+    // w+ are now off by a small amount.
+    // In fact:
+    //
+    //      w - v * 10^k < 1 ulp
+    //
+    // To account for this inaccuracy, add resp. subtract 1 ulp.
+    //
+    //  --------+---[---------------(---+---)---------------]---+--------
+    //          w-  M-                  w                   M+  w+
+    //
+    // Now any number in [M-, M+] (bounds included) will round to w when input,
+    // regardless of how the input rounding algorithm breaks ties.
+    //
+    // And digit_gen generates the shortest possible such number in [M-, M+].
+    // Note that this does not mean that Grisu2 always generates the shortest
+    // possible number in the interval (m-, m+).
+    const diyfp M_minus(w_minus.f + 1, w_minus.e);
+    const diyfp M_plus (w_plus.f  - 1, w_plus.e );
+
+    decimal_exponent = -cached.k; // = -(-k) = k
+
+    grisu2_digit_gen(buf, len, decimal_exponent, M_minus, w, M_plus);
+}
+
+/*!
+v = buf * 10^decimal_exponent
+len is the length of the buffer (number of decimal digits)
+The buffer must be large enough, i.e. >= max_digits10.
+*/
+template <typename FloatType>
+JSON_HEDLEY_NON_NULL(1)
+void grisu2(char* buf, int& len, int& decimal_exponent, FloatType value)
+{
+    static_assert(diyfp::kPrecision >= std::numeric_limits<FloatType>::digits + 3,
+                  "internal error: not enough precision");
+
+    assert(std::isfinite(value));
+    assert(value > 0);
+
+    // If the neighbors (and boundaries) of 'value' are always computed for double-precision
+    // numbers, all float's can be recovered using strtod (and strtof). However, the resulting
+    // decimal representations are not exactly "short".
+    //
+    // The documentation for 'std::to_chars' (https://en.cppreference.com/w/cpp/utility/to_chars)
+    // says "value is converted to a string as if by std::sprintf in the default ("C") locale"
+    // and since sprintf promotes float's to double's, I think this is exactly what 'std::to_chars'
+    // does.
+    // On the other hand, the documentation for 'std::to_chars' requires that "parsing the
+    // representation using the corresponding std::from_chars function recovers value exactly". That
+    // indicates that single precision floating-point numbers should be recovered using
+    // 'std::strtof'.
+    //
+    // NB: If the neighbors are computed for single-precision numbers, there is a single float
+    //     (7.0385307e-26f) which can't be recovered using strtod. The resulting double precision
+    //     value is off by 1 ulp.
+#if 0
+    const boundaries w = compute_boundaries(static_cast<double>(value));
+#else
+    const boundaries w = compute_boundaries(value);
+#endif
+
+    grisu2(buf, len, decimal_exponent, w.minus, w.w, w.plus);
+}
+
+/*!
+@brief appends a decimal representation of e to buf
+@return a pointer to the element following the exponent.
+@pre -1000 < e < 1000
+*/
+JSON_HEDLEY_NON_NULL(1)
+JSON_HEDLEY_RETURNS_NON_NULL
+inline char* append_exponent(char* buf, int e)
+{
+    assert(e > -1000);
+    assert(e <  1000);
+
+    if (e < 0)
+    {
+        e = -e;
+        *buf++ = '-';
+    }
+    else
+    {
+        *buf++ = '+';
+    }
+
+    auto k = static_cast<std::uint32_t>(e);
+    if (k < 10)
+    {
+        // Always print at least two digits in the exponent.
+        // This is for compatibility with printf("%g").
+        *buf++ = '0';
+        *buf++ = static_cast<char>('0' + k);
+    }
+    else if (k < 100)
+    {
+        *buf++ = static_cast<char>('0' + k / 10);
+        k %= 10;
+        *buf++ = static_cast<char>('0' + k);
+    }
+    else
+    {
+        *buf++ = static_cast<char>('0' + k / 100);
+        k %= 100;
+        *buf++ = static_cast<char>('0' + k / 10);
+        k %= 10;
+        *buf++ = static_cast<char>('0' + k);
+    }
+
+    return buf;
+}
+
+/*!
+@brief prettify v = buf * 10^decimal_exponent
+
+If v is in the range [10^min_exp, 10^max_exp) it will be printed in fixed-point
+notation. Otherwise it will be printed in exponential notation.
+
+@pre min_exp < 0
+@pre max_exp > 0
+*/
+JSON_HEDLEY_NON_NULL(1)
+JSON_HEDLEY_RETURNS_NON_NULL
+inline char* format_buffer(char* buf, int len, int decimal_exponent,
+                           int min_exp, int max_exp)
+{
+    assert(min_exp < 0);
+    assert(max_exp > 0);
+
+    const int k = len;
+    const int n = len + decimal_exponent;
+
+    // v = buf * 10^(n-k)
+    // k is the length of the buffer (number of decimal digits)
+    // n is the position of the decimal point relative to the start of the buffer.
+
+    if (k <= n and n <= max_exp)
+    {
+        // digits[000]
+        // len <= max_exp + 2
+
+        std::memset(buf + k, '0', static_cast<size_t>(n - k));
+        // Make it look like a floating-point number (#362, #378)
+        buf[n + 0] = '.';
+        buf[n + 1] = '0';
+        return buf + (n + 2);
+    }
+
+    if (0 < n and n <= max_exp)
+    {
+        // dig.its
+        // len <= max_digits10 + 1
+
+        assert(k > n);
+
+        std::memmove(buf + (n + 1), buf + n, static_cast<size_t>(k - n));
+        buf[n] = '.';
+        return buf + (k + 1);
+    }
+
+    if (min_exp < n and n <= 0)
+    {
+        // 0.[000]digits
+        // len <= 2 + (-min_exp - 1) + max_digits10
+
+        std::memmove(buf + (2 + -n), buf, static_cast<size_t>(k));
+        buf[0] = '0';
+        buf[1] = '.';
+        std::memset(buf + 2, '0', static_cast<size_t>(-n));
+        return buf + (2 + (-n) + k);
+    }
+
+    if (k == 1)
+    {
+        // dE+123
+        // len <= 1 + 5
+
+        buf += 1;
+    }
+    else
+    {
+        // d.igitsE+123
+        // len <= max_digits10 + 1 + 5
+
+        std::memmove(buf + 2, buf + 1, static_cast<size_t>(k - 1));
+        buf[1] = '.';
+        buf += 1 + k;
+    }
+
+    *buf++ = 'e';
+    return append_exponent(buf, n - 1);
+}
+
+} // namespace dtoa_impl
+
+/*!
+@brief generates a decimal representation of the floating-point number value in [first, last).
+
+The format of the resulting decimal representation is similar to printf's %g
+format. Returns an iterator pointing past-the-end of the decimal representation.
+
+@note The input number must be finite, i.e. NaN's and Inf's are not supported.
+@note The buffer must be large enough.
+@note The result is NOT null-terminated.
+*/
+template <typename FloatType>
+JSON_HEDLEY_NON_NULL(1, 2)
+JSON_HEDLEY_RETURNS_NON_NULL
+char* to_chars(char* first, const char* last, FloatType value)
+{
+    static_cast<void>(last); // maybe unused - fix warning
+    assert(std::isfinite(value));
+
+    // Use signbit(value) instead of (value < 0) since signbit works for -0.
+    if (std::signbit(value))
+    {
+        value = -value;
+        *first++ = '-';
+    }
+
+    if (value == 0) // +-0
+    {
+        *first++ = '0';
+        // Make it look like a floating-point number (#362, #378)
+        *first++ = '.';
+        *first++ = '0';
+        return first;
+    }
+
+    assert(last - first >= std::numeric_limits<FloatType>::max_digits10);
+
+    // Compute v = buffer * 10^decimal_exponent.
+    // The decimal digits are stored in the buffer, which needs to be interpreted
+    // as an unsigned decimal integer.
+    // len is the length of the buffer, i.e. the number of decimal digits.
+    int len = 0;
+    int decimal_exponent = 0;
+    dtoa_impl::grisu2(first, len, decimal_exponent, value);
+
+    assert(len <= std::numeric_limits<FloatType>::max_digits10);
+
+    // Format the buffer like printf("%.*g", prec, value)
+    constexpr int kMinExp = -4;
+    // Use digits10 here to increase compatibility with version 2.
+    constexpr int kMaxExp = std::numeric_limits<FloatType>::digits10;
+
+    assert(last - first >= kMaxExp + 2);
+    assert(last - first >= 2 + (-kMinExp - 1) + std::numeric_limits<FloatType>::max_digits10);
+    assert(last - first >= std::numeric_limits<FloatType>::max_digits10 + 6);
+
+    return dtoa_impl::format_buffer(first, len, decimal_exponent, kMinExp, kMaxExp);
+}
+
+} // namespace detail
+} // namespace nlohmann
+
+// #include <nlohmann/detail/exceptions.hpp>
+
+// #include <nlohmann/detail/macro_scope.hpp>
+
+// #include <nlohmann/detail/meta/cpp_future.hpp>
+
+// #include <nlohmann/detail/output/binary_writer.hpp>
+
+// #include <nlohmann/detail/output/output_adapters.hpp>
+
+// #include <nlohmann/detail/value_t.hpp>
+
+
+namespace nlohmann
+{
+namespace detail
+{
+///////////////////
+// serialization //
+///////////////////
+
+/// how to treat decoding errors
+enum class error_handler_t
+{
+    strict,  ///< throw a type_error exception in case of invalid UTF-8
+    replace, ///< replace invalid UTF-8 sequences with U+FFFD
+    ignore   ///< ignore invalid UTF-8 sequences
+};
+
+template<typename BasicJsonType>
+class serializer
+{
+    using string_t = typename BasicJsonType::string_t;
+    using number_float_t = typename BasicJsonType::number_float_t;
+    using number_integer_t = typename BasicJsonType::number_integer_t;
+    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+    static constexpr std::uint8_t UTF8_ACCEPT = 0;
+    static constexpr std::uint8_t UTF8_REJECT = 1;
+
+  public:
+    /*!
+    @param[in] s  output stream to serialize to
+    @param[in] ichar  indentation character to use
+    @param[in] error_handler_  how to react on decoding errors
+    */
+    serializer(output_adapter_t<char> s, const char ichar,
+               error_handler_t error_handler_ = error_handler_t::strict)
+        : o(std::move(s))
+        , loc(std::localeconv())
+        , thousands_sep(loc->thousands_sep == nullptr ? '\0' : * (loc->thousands_sep))
+        , decimal_point(loc->decimal_point == nullptr ? '\0' : * (loc->decimal_point))
+        , indent_char(ichar)
+        , indent_string(512, indent_char)
+        , error_handler(error_handler_)
+    {}
+
+    // delete because of pointer members
+    serializer(const serializer&) = delete;
+    serializer& operator=(const serializer&) = delete;
+    serializer(serializer&&) = delete;
+    serializer& operator=(serializer&&) = delete;
+    ~serializer() = default;
+
+    /*!
+    @brief internal implementation of the serialization function
+
+    This function is called by the public member function dump and organizes
+    the serialization internally. The indentation level is propagated as
+    additional parameter. In case of arrays and objects, the function is
+    called recursively.
+
+    - strings and object keys are escaped using `escape_string()`
+    - integer numbers are converted implicitly via `operator<<`
+    - floating-point numbers are converted to a string using `"%g"` format
+
+    @param[in] val             value to serialize
+    @param[in] pretty_print    whether the output shall be pretty-printed
+    @param[in] indent_step     the indent level
+    @param[in] current_indent  the current indent level (only used internally)
+    */
+    void dump(const BasicJsonType& val, const bool pretty_print,
+              const bool ensure_ascii,
+              const unsigned int indent_step,
+              const unsigned int current_indent = 0)
+    {
+        switch (val.m_type)
+        {
+            case value_t::object:
+            {
+                if (val.m_value.object->empty())
+                {
+                    o->write_characters("{}", 2);
+                    return;
+                }
+
+                if (pretty_print)
+                {
+                    o->write_characters("{\n", 2);
+
+                    // variable to hold indentation for recursive calls
+                    const auto new_indent = current_indent + indent_step;
+                    if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
+                    {
+                        indent_string.resize(indent_string.size() * 2, ' ');
+                    }
+
+                    // first n-1 elements
+                    auto i = val.m_value.object->cbegin();
+                    for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i)
+                    {
+                        o->write_characters(indent_string.c_str(), new_indent);
+                        o->write_character('\"');
+                        dump_escaped(i->first, ensure_ascii);
+                        o->write_characters("\": ", 3);
+                        dump(i->second, true, ensure_ascii, indent_step, new_indent);
+                        o->write_characters(",\n", 2);
+                    }
+
+                    // last element
+                    assert(i != val.m_value.object->cend());
+                    assert(std::next(i) == val.m_value.object->cend());
+                    o->write_characters(indent_string.c_str(), new_indent);
+                    o->write_character('\"');
+                    dump_escaped(i->first, ensure_ascii);
+                    o->write_characters("\": ", 3);
+                    dump(i->second, true, ensure_ascii, indent_step, new_indent);
+
+                    o->write_character('\n');
+                    o->write_characters(indent_string.c_str(), current_indent);
+                    o->write_character('}');
+                }
+                else
+                {
+                    o->write_character('{');
+
+                    // first n-1 elements
+                    auto i = val.m_value.object->cbegin();
+                    for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i)
+                    {
+                        o->write_character('\"');
+                        dump_escaped(i->first, ensure_ascii);
+                        o->write_characters("\":", 2);
+                        dump(i->second, false, ensure_ascii, indent_step, current_indent);
+                        o->write_character(',');
+                    }
+
+                    // last element
+                    assert(i != val.m_value.object->cend());
+                    assert(std::next(i) == val.m_value.object->cend());
+                    o->write_character('\"');
+                    dump_escaped(i->first, ensure_ascii);
+                    o->write_characters("\":", 2);
+                    dump(i->second, false, ensure_ascii, indent_step, current_indent);
+
+                    o->write_character('}');
+                }
+
+                return;
+            }
+
+            case value_t::array:
+            {
+                if (val.m_value.array->empty())
+                {
+                    o->write_characters("[]", 2);
+                    return;
+                }
+
+                if (pretty_print)
+                {
+                    o->write_characters("[\n", 2);
+
+                    // variable to hold indentation for recursive calls
+                    const auto new_indent = current_indent + indent_step;
+                    if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
+                    {
+                        indent_string.resize(indent_string.size() * 2, ' ');
+                    }
+
+                    // first n-1 elements
+                    for (auto i = val.m_value.array->cbegin();
+                            i != val.m_value.array->cend() - 1; ++i)
+                    {
+                        o->write_characters(indent_string.c_str(), new_indent);
+                        dump(*i, true, ensure_ascii, indent_step, new_indent);
+                        o->write_characters(",\n", 2);
+                    }
+
+                    // last element
+                    assert(not val.m_value.array->empty());
+                    o->write_characters(indent_string.c_str(), new_indent);
+                    dump(val.m_value.array->back(), true, ensure_ascii, indent_step, new_indent);
+
+                    o->write_character('\n');
+                    o->write_characters(indent_string.c_str(), current_indent);
+                    o->write_character(']');
+                }
+                else
+                {
+                    o->write_character('[');
+
+                    // first n-1 elements
+                    for (auto i = val.m_value.array->cbegin();
+                            i != val.m_value.array->cend() - 1; ++i)
+                    {
+                        dump(*i, false, ensure_ascii, indent_step, current_indent);
+                        o->write_character(',');
+                    }
+
+                    // last element
+                    assert(not val.m_value.array->empty());
+                    dump(val.m_value.array->back(), false, ensure_ascii, indent_step, current_indent);
+
+                    o->write_character(']');
+                }
+
+                return;
+            }
+
+            case value_t::string:
+            {
+                o->write_character('\"');
+                dump_escaped(*val.m_value.string, ensure_ascii);
+                o->write_character('\"');
+                return;
+            }
+
+            case value_t::boolean:
+            {
+                if (val.m_value.boolean)
+                {
+                    o->write_characters("true", 4);
+                }
+                else
+                {
+                    o->write_characters("false", 5);
+                }
+                return;
+            }
+
+            case value_t::number_integer:
+            {
+                dump_integer(val.m_value.number_integer);
+                return;
+            }
+
+            case value_t::number_unsigned:
+            {
+                dump_integer(val.m_value.number_unsigned);
+                return;
+            }
+
+            case value_t::number_float:
+            {
+                dump_float(val.m_value.number_float);
+                return;
+            }
+
+            case value_t::discarded:
+            {
+                o->write_characters("<discarded>", 11);
+                return;
+            }
+
+            case value_t::null:
+            {
+                o->write_characters("null", 4);
+                return;
+            }
+
+            default:            // LCOV_EXCL_LINE
+                assert(false);  // LCOV_EXCL_LINE
+        }
+    }
+
+  private:
+    /*!
+    @brief dump escaped string
+
+    Escape a string by replacing certain special characters by a sequence of an
+    escape character (backslash) and another character and other control
+    characters by a sequence of "\u" followed by a four-digit hex
+    representation. The escaped string is written to output stream @a o.
+
+    @param[in] s  the string to escape
+    @param[in] ensure_ascii  whether to escape non-ASCII characters with
+                             \uXXXX sequences
+
+    @complexity Linear in the length of string @a s.
+    */
+    void dump_escaped(const string_t& s, const bool ensure_ascii)
+    {
+        std::uint32_t codepoint;
+        std::uint8_t state = UTF8_ACCEPT;
+        std::size_t bytes = 0;  // number of bytes written to string_buffer
+
+        // number of bytes written at the point of the last valid byte
+        std::size_t bytes_after_last_accept = 0;
+        std::size_t undumped_chars = 0;
+
+        for (std::size_t i = 0; i < s.size(); ++i)
+        {
+            const auto byte = static_cast<uint8_t>(s[i]);
+
+            switch (decode(state, codepoint, byte))
+            {
+                case UTF8_ACCEPT:  // decode found a new code point
+                {
+                    switch (codepoint)
+                    {
+                        case 0x08: // backspace
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 'b';
+                            break;
+                        }
+
+                        case 0x09: // horizontal tab
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 't';
+                            break;
+                        }
+
+                        case 0x0A: // newline
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 'n';
+                            break;
+                        }
+
+                        case 0x0C: // formfeed
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 'f';
+                            break;
+                        }
+
+                        case 0x0D: // carriage return
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = 'r';
+                            break;
+                        }
+
+                        case 0x22: // quotation mark
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = '\"';
+                            break;
+                        }
+
+                        case 0x5C: // reverse solidus
+                        {
+                            string_buffer[bytes++] = '\\';
+                            string_buffer[bytes++] = '\\';
+                            break;
+                        }
+
+                        default:
+                        {
+                            // escape control characters (0x00..0x1F) or, if
+                            // ensure_ascii parameter is used, non-ASCII characters
+                            if ((codepoint <= 0x1F) or (ensure_ascii and (codepoint >= 0x7F)))
+                            {
+                                if (codepoint <= 0xFFFF)
+                                {
+                                    (std::snprintf)(string_buffer.data() + bytes, 7, "\\u%04x",
+                                                    static_cast<std::uint16_t>(codepoint));
+                                    bytes += 6;
+                                }
+                                else
+                                {
+                                    (std::snprintf)(string_buffer.data() + bytes, 13, "\\u%04x\\u%04x",
+                                                    static_cast<std::uint16_t>(0xD7C0u + (codepoint >> 10u)),
+                                                    static_cast<std::uint16_t>(0xDC00u + (codepoint & 0x3FFu)));
+                                    bytes += 12;
+                                }
+                            }
+                            else
+                            {
+                                // copy byte to buffer (all previous bytes
+                                // been copied have in default case above)
+                                string_buffer[bytes++] = s[i];
+                            }
+                            break;
+                        }
+                    }
+
+                    // write buffer and reset index; there must be 13 bytes
+                    // left, as this is the maximal number of bytes to be
+                    // written ("\uxxxx\uxxxx\0") for one code point
+                    if (string_buffer.size() - bytes < 13)
+                    {
+                        o->write_characters(string_buffer.data(), bytes);
+                        bytes = 0;
+                    }
+
+                    // remember the byte position of this accept
+                    bytes_after_last_accept = bytes;
+                    undumped_chars = 0;
+                    break;
+                }
+
+                case UTF8_REJECT:  // decode found invalid UTF-8 byte
+                {
+                    switch (error_handler)
+                    {
+                        case error_handler_t::strict:
+                        {
+                            std::string sn(3, '\0');
+                            (std::snprintf)(&sn[0], sn.size(), "%.2X", byte);
+                            JSON_THROW(type_error::create(316, "invalid UTF-8 byte at index " + std::to_string(i) + ": 0x" + sn));
+                        }
+
+                        case error_handler_t::ignore:
+                        case error_handler_t::replace:
+                        {
+                            // in case we saw this character the first time, we
+                            // would like to read it again, because the byte
+                            // may be OK for itself, but just not OK for the
+                            // previous sequence
+                            if (undumped_chars > 0)
+                            {
+                                --i;
+                            }
+
+                            // reset length buffer to the last accepted index;
+                            // thus removing/ignoring the invalid characters
+                            bytes = bytes_after_last_accept;
+
+                            if (error_handler == error_handler_t::replace)
+                            {
+                                // add a replacement character
+                                if (ensure_ascii)
+                                {
+                                    string_buffer[bytes++] = '\\';
+                                    string_buffer[bytes++] = 'u';
+                                    string_buffer[bytes++] = 'f';
+                                    string_buffer[bytes++] = 'f';
+                                    string_buffer[bytes++] = 'f';
+                                    string_buffer[bytes++] = 'd';
+                                }
+                                else
+                                {
+                                    string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xEF');
+                                    string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xBF');
+                                    string_buffer[bytes++] = detail::binary_writer<BasicJsonType, char>::to_char_type('\xBD');
+                                }
+
+                                // write buffer and reset index; there must be 13 bytes
+                                // left, as this is the maximal number of bytes to be
+                                // written ("\uxxxx\uxxxx\0") for one code point
+                                if (string_buffer.size() - bytes < 13)
+                                {
+                                    o->write_characters(string_buffer.data(), bytes);
+                                    bytes = 0;
+                                }
+
+                                bytes_after_last_accept = bytes;
+                            }
+
+                            undumped_chars = 0;
+
+                            // continue processing the string
+                            state = UTF8_ACCEPT;
+                            break;
+                        }
+
+                        default:            // LCOV_EXCL_LINE
+                            assert(false);  // LCOV_EXCL_LINE
+                    }
+                    break;
+                }
+
+                default:  // decode found yet incomplete multi-byte code point
+                {
+                    if (not ensure_ascii)
+                    {
+                        // code point will not be escaped - copy byte to buffer
+                        string_buffer[bytes++] = s[i];
+                    }
+                    ++undumped_chars;
+                    break;
+                }
+            }
+        }
+
+        // we finished processing the string
+        if (JSON_HEDLEY_LIKELY(state == UTF8_ACCEPT))
+        {
+            // write buffer
+            if (bytes > 0)
+            {
+                o->write_characters(string_buffer.data(), bytes);
+            }
+        }
+        else
+        {
+            // we finish reading, but do not accept: string was incomplete
+            switch (error_handler)
+            {
+                case error_handler_t::strict:
+                {
+                    std::string sn(3, '\0');
+                    (std::snprintf)(&sn[0], sn.size(), "%.2X", static_cast<std::uint8_t>(s.back()));
+                    JSON_THROW(type_error::create(316, "incomplete UTF-8 string; last byte: 0x" + sn));
+                }
+
+                case error_handler_t::ignore:
+                {
+                    // write all accepted bytes
+                    o->write_characters(string_buffer.data(), bytes_after_last_accept);
+                    break;
+                }
+
+                case error_handler_t::replace:
+                {
+                    // write all accepted bytes
+                    o->write_characters(string_buffer.data(), bytes_after_last_accept);
+                    // add a replacement character
+                    if (ensure_ascii)
+                    {
+                        o->write_characters("\\ufffd", 6);
+                    }
+                    else
+                    {
+                        o->write_characters("\xEF\xBF\xBD", 3);
+                    }
+                    break;
+                }
+
+                default:            // LCOV_EXCL_LINE
+                    assert(false);  // LCOV_EXCL_LINE
+            }
+        }
+    }
+
+    /*!
+    @brief count digits
+
+    Count the number of decimal (base 10) digits for an input unsigned integer.
+
+    @param[in] x  unsigned integer number to count its digits
+    @return    number of decimal digits
+    */
+    inline unsigned int count_digits(number_unsigned_t x) noexcept
+    {
+        unsigned int n_digits = 1;
+        for (;;)
+        {
+            if (x < 10)
+            {
+                return n_digits;
+            }
+            if (x < 100)
+            {
+                return n_digits + 1;
+            }
+            if (x < 1000)
+            {
+                return n_digits + 2;
+            }
+            if (x < 10000)
+            {
+                return n_digits + 3;
+            }
+            x = x / 10000u;
+            n_digits += 4;
+        }
+    }
+
+    /*!
+    @brief dump an integer
+
+    Dump a given integer to output stream @a o. Works internally with
+    @a number_buffer.
+
+    @param[in] x  integer number (signed or unsigned) to dump
+    @tparam NumberType either @a number_integer_t or @a number_unsigned_t
+    */
+    template<typename NumberType, detail::enable_if_t<
+                 std::is_same<NumberType, number_unsigned_t>::value or
+                 std::is_same<NumberType, number_integer_t>::value,
+                 int> = 0>
+    void dump_integer(NumberType x)
+    {
+        static constexpr std::array<std::array<char, 2>, 100> digits_to_99
+        {
+            {
+                {{'0', '0'}}, {{'0', '1'}}, {{'0', '2'}}, {{'0', '3'}}, {{'0', '4'}}, {{'0', '5'}}, {{'0', '6'}}, {{'0', '7'}}, {{'0', '8'}}, {{'0', '9'}},
+                {{'1', '0'}}, {{'1', '1'}}, {{'1', '2'}}, {{'1', '3'}}, {{'1', '4'}}, {{'1', '5'}}, {{'1', '6'}}, {{'1', '7'}}, {{'1', '8'}}, {{'1', '9'}},
+                {{'2', '0'}}, {{'2', '1'}}, {{'2', '2'}}, {{'2', '3'}}, {{'2', '4'}}, {{'2', '5'}}, {{'2', '6'}}, {{'2', '7'}}, {{'2', '8'}}, {{'2', '9'}},
+                {{'3', '0'}}, {{'3', '1'}}, {{'3', '2'}}, {{'3', '3'}}, {{'3', '4'}}, {{'3', '5'}}, {{'3', '6'}}, {{'3', '7'}}, {{'3', '8'}}, {{'3', '9'}},
+                {{'4', '0'}}, {{'4', '1'}}, {{'4', '2'}}, {{'4', '3'}}, {{'4', '4'}}, {{'4', '5'}}, {{'4', '6'}}, {{'4', '7'}}, {{'4', '8'}}, {{'4', '9'}},
+                {{'5', '0'}}, {{'5', '1'}}, {{'5', '2'}}, {{'5', '3'}}, {{'5', '4'}}, {{'5', '5'}}, {{'5', '6'}}, {{'5', '7'}}, {{'5', '8'}}, {{'5', '9'}},
+                {{'6', '0'}}, {{'6', '1'}}, {{'6', '2'}}, {{'6', '3'}}, {{'6', '4'}}, {{'6', '5'}}, {{'6', '6'}}, {{'6', '7'}}, {{'6', '8'}}, {{'6', '9'}},
+                {{'7', '0'}}, {{'7', '1'}}, {{'7', '2'}}, {{'7', '3'}}, {{'7', '4'}}, {{'7', '5'}}, {{'7', '6'}}, {{'7', '7'}}, {{'7', '8'}}, {{'7', '9'}},
+                {{'8', '0'}}, {{'8', '1'}}, {{'8', '2'}}, {{'8', '3'}}, {{'8', '4'}}, {{'8', '5'}}, {{'8', '6'}}, {{'8', '7'}}, {{'8', '8'}}, {{'8', '9'}},
+                {{'9', '0'}}, {{'9', '1'}}, {{'9', '2'}}, {{'9', '3'}}, {{'9', '4'}}, {{'9', '5'}}, {{'9', '6'}}, {{'9', '7'}}, {{'9', '8'}}, {{'9', '9'}},
+            }
+        };
+
+        // special case for "0"
+        if (x == 0)
+        {
+            o->write_character('0');
+            return;
+        }
+
+        // use a pointer to fill the buffer
+        auto buffer_ptr = number_buffer.begin();
+
+        const bool is_negative = std::is_same<NumberType, number_integer_t>::value and not(x >= 0); // see issue #755
+        number_unsigned_t abs_value;
+
+        unsigned int n_chars;
+
+        if (is_negative)
+        {
+            *buffer_ptr = '-';
+            abs_value = static_cast<number_unsigned_t>(std::abs(static_cast<std::intmax_t>(x)));
+
+            // account one more byte for the minus sign
+            n_chars = 1 + count_digits(abs_value);
+        }
+        else
+        {
+            abs_value = static_cast<number_unsigned_t>(x);
+            n_chars = count_digits(abs_value);
+        }
+
+        // spare 1 byte for '\0'
+        assert(n_chars < number_buffer.size() - 1);
+
+        // jump to the end to generate the string from backward
+        // so we later avoid reversing the result
+        buffer_ptr += n_chars;
+
+        // Fast int2ascii implementation inspired by "Fastware" talk by Andrei Alexandrescu
+        // See: https://www.youtube.com/watch?v=o4-CwDo2zpg
+        while (abs_value >= 100)
+        {
+            const auto digits_index = static_cast<unsigned>((abs_value % 100));
+            abs_value /= 100;
+            *(--buffer_ptr) = digits_to_99[digits_index][1];
+            *(--buffer_ptr) = digits_to_99[digits_index][0];
+        }
+
+        if (abs_value >= 10)
+        {
+            const auto digits_index = static_cast<unsigned>(abs_value);
+            *(--buffer_ptr) = digits_to_99[digits_index][1];
+            *(--buffer_ptr) = digits_to_99[digits_index][0];
+        }
+        else
+        {
+            *(--buffer_ptr) = static_cast<char>('0' + abs_value);
+        }
+
+        o->write_characters(number_buffer.data(), n_chars);
+    }
+
+    /*!
+    @brief dump a floating-point number
+
+    Dump a given floating-point number to output stream @a o. Works internally
+    with @a number_buffer.
+
+    @param[in] x  floating-point number to dump
+    */
+    void dump_float(number_float_t x)
+    {
+        // NaN / inf
+        if (not std::isfinite(x))
+        {
+            o->write_characters("null", 4);
+            return;
+        }
+
+        // If number_float_t is an IEEE-754 single or double precision number,
+        // use the Grisu2 algorithm to produce short numbers which are
+        // guaranteed to round-trip, using strtof and strtod, resp.
+        //
+        // NB: The test below works if <long double> == <double>.
+        static constexpr bool is_ieee_single_or_double
+            = (std::numeric_limits<number_float_t>::is_iec559 and std::numeric_limits<number_float_t>::digits == 24 and std::numeric_limits<number_float_t>::max_exponent == 128) or
+              (std::numeric_limits<number_float_t>::is_iec559 and std::numeric_limits<number_float_t>::digits == 53 and std::numeric_limits<number_float_t>::max_exponent == 1024);
+
+        dump_float(x, std::integral_constant<bool, is_ieee_single_or_double>());
+    }
+
+    void dump_float(number_float_t x, std::true_type /*is_ieee_single_or_double*/)
+    {
+        char* begin = number_buffer.data();
+        char* end = ::nlohmann::detail::to_chars(begin, begin + number_buffer.size(), x);
+
+        o->write_characters(begin, static_cast<size_t>(end - begin));
+    }
+
+    void dump_float(number_float_t x, std::false_type /*is_ieee_single_or_double*/)
+    {
+        // get number of digits for a float -> text -> float round-trip
+        static constexpr auto d = std::numeric_limits<number_float_t>::max_digits10;
+
+        // the actual conversion
+        std::ptrdiff_t len = (std::snprintf)(number_buffer.data(), number_buffer.size(), "%.*g", d, x);
+
+        // negative value indicates an error
+        assert(len > 0);
+        // check if buffer was large enough
+        assert(static_cast<std::size_t>(len) < number_buffer.size());
+
+        // erase thousands separator
+        if (thousands_sep != '\0')
+        {
+            const auto end = std::remove(number_buffer.begin(),
+                                         number_buffer.begin() + len, thousands_sep);
+            std::fill(end, number_buffer.end(), '\0');
+            assert((end - number_buffer.begin()) <= len);
+            len = (end - number_buffer.begin());
+        }
+
+        // convert decimal point to '.'
+        if (decimal_point != '\0' and decimal_point != '.')
+        {
+            const auto dec_pos = std::find(number_buffer.begin(), number_buffer.end(), decimal_point);
+            if (dec_pos != number_buffer.end())
+            {
+                *dec_pos = '.';
+            }
+        }
+
+        o->write_characters(number_buffer.data(), static_cast<std::size_t>(len));
+
+        // determine if need to append ".0"
+        const bool value_is_int_like =
+            std::none_of(number_buffer.begin(), number_buffer.begin() + len + 1,
+                         [](char c)
+        {
+            return c == '.' or c == 'e';
+        });
+
+        if (value_is_int_like)
+        {
+            o->write_characters(".0", 2);
+        }
+    }
+
+    /*!
+    @brief check whether a string is UTF-8 encoded
+
+    The function checks each byte of a string whether it is UTF-8 encoded. The
+    result of the check is stored in the @a state parameter. The function must
+    be called initially with state 0 (accept). State 1 means the string must
+    be rejected, because the current byte is not allowed. If the string is
+    completely processed, but the state is non-zero, the string ended
+    prematurely; that is, the last byte indicated more bytes should have
+    followed.
+
+    @param[in,out] state  the state of the decoding
+    @param[in,out] codep  codepoint (valid only if resulting state is UTF8_ACCEPT)
+    @param[in] byte       next byte to decode
+    @return               new state
+
+    @note The function has been edited: a std::array is used.
+
+    @copyright Copyright (c) 2008-2009 Bjoern Hoehrmann <bjoern@hoehrmann.de>
+    @sa http://bjoern.hoehrmann.de/utf-8/decoder/dfa/
+    */
+    static std::uint8_t decode(std::uint8_t& state, std::uint32_t& codep, const std::uint8_t byte) noexcept
+    {
+        static const std::array<std::uint8_t, 400> utf8d =
+        {
+            {
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 00..1F
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 20..3F
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 40..5F
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 60..7F
+                1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, // 80..9F
+                7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // A0..BF
+                8, 8, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // C0..DF
+                0xA, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x3, // E0..EF
+                0xB, 0x6, 0x6, 0x6, 0x5, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, // F0..FF
+                0x0, 0x1, 0x2, 0x3, 0x5, 0x8, 0x7, 0x1, 0x1, 0x1, 0x4, 0x6, 0x1, 0x1, 0x1, 0x1, // s0..s0
+                1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, // s1..s2
+                1, 2, 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, // s3..s4
+                1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, // s5..s6
+                1, 3, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // s7..s8
+            }
+        };
+
+        const std::uint8_t type = utf8d[byte];
+
+        codep = (state != UTF8_ACCEPT)
+                ? (byte & 0x3fu) | (codep << 6u)
+                : (0xFFu >> type) & (byte);
+
+        state = utf8d[256u + state * 16u + type];
+        return state;
+    }
+
+  private:
+    /// the output of the serializer
+    output_adapter_t<char> o = nullptr;
+
+    /// a (hopefully) large enough character buffer
+    std::array<char, 64> number_buffer{{}};
+
+    /// the locale
+    const std::lconv* loc = nullptr;
+    /// the locale's thousand separator character
+    const char thousands_sep = '\0';
+    /// the locale's decimal point character
+    const char decimal_point = '\0';
+
+    /// string buffer
+    std::array<char, 512> string_buffer{{}};
+
+    /// the indentation character
+    const char indent_char;
+    /// the indentation string
+    string_t indent_string;
+
+    /// error_handler how to react on decoding errors
+    const error_handler_t error_handler;
+};
+}  // namespace detail
+}  // namespace nlohmann
+
+// #include <nlohmann/detail/value_t.hpp>
+
+// #include <nlohmann/json_fwd.hpp>
+
+
+/*!
+@brief namespace for Niels Lohmann
+@see https://github.com/nlohmann
+@since version 1.0.0
+*/
+namespace nlohmann
+{
+
+/*!
+@brief a class to store JSON values
+
+@tparam ObjectType type for JSON objects (`std::map` by default; will be used
+in @ref object_t)
+@tparam ArrayType type for JSON arrays (`std::vector` by default; will be used
+in @ref array_t)
+@tparam StringType type for JSON strings and object keys (`std::string` by
+default; will be used in @ref string_t)
+@tparam BooleanType type for JSON booleans (`bool` by default; will be used
+in @ref boolean_t)
+@tparam NumberIntegerType type for JSON integer numbers (`int64_t` by
+default; will be used in @ref number_integer_t)
+@tparam NumberUnsignedType type for JSON unsigned integer numbers (@c
+`uint64_t` by default; will be used in @ref number_unsigned_t)
+@tparam NumberFloatType type for JSON floating-point numbers (`double` by
+default; will be used in @ref number_float_t)
+@tparam AllocatorType type of the allocator to use (`std::allocator` by
+default)
+@tparam JSONSerializer the serializer to resolve internal calls to `to_json()`
+and `from_json()` (@ref adl_serializer by default)
+
+@requirement The class satisfies the following concept requirements:
+- Basic
+ - [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible):
+   JSON values can be default constructed. The result will be a JSON null
+   value.
+ - [MoveConstructible](https://en.cppreference.com/w/cpp/named_req/MoveConstructible):
+   A JSON value can be constructed from an rvalue argument.
+ - [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible):
+   A JSON value can be copy-constructed from an lvalue expression.
+ - [MoveAssignable](https://en.cppreference.com/w/cpp/named_req/MoveAssignable):
+   A JSON value van be assigned from an rvalue argument.
+ - [CopyAssignable](https://en.cppreference.com/w/cpp/named_req/CopyAssignable):
+   A JSON value can be copy-assigned from an lvalue expression.
+ - [Destructible](https://en.cppreference.com/w/cpp/named_req/Destructible):
+   JSON values can be destructed.
+- Layout
+ - [StandardLayoutType](https://en.cppreference.com/w/cpp/named_req/StandardLayoutType):
+   JSON values have
+   [standard layout](https://en.cppreference.com/w/cpp/language/data_members#Standard_layout):
+   All non-static data members are private and standard layout types, the
+   class has no virtual functions or (virtual) base classes.
+- Library-wide
+ - [EqualityComparable](https://en.cppreference.com/w/cpp/named_req/EqualityComparable):
+   JSON values can be compared with `==`, see @ref
+   operator==(const_reference,const_reference).
+ - [LessThanComparable](https://en.cppreference.com/w/cpp/named_req/LessThanComparable):
+   JSON values can be compared with `<`, see @ref
+   operator<(const_reference,const_reference).
+ - [Swappable](https://en.cppreference.com/w/cpp/named_req/Swappable):
+   Any JSON lvalue or rvalue of can be swapped with any lvalue or rvalue of
+   other compatible types, using unqualified function call @ref swap().
+ - [NullablePointer](https://en.cppreference.com/w/cpp/named_req/NullablePointer):
+   JSON values can be compared against `std::nullptr_t` objects which are used
+   to model the `null` value.
+- Container
+ - [Container](https://en.cppreference.com/w/cpp/named_req/Container):
+   JSON values can be used like STL containers and provide iterator access.
+ - [ReversibleContainer](https://en.cppreference.com/w/cpp/named_req/ReversibleContainer);
+   JSON values can be used like STL containers and provide reverse iterator
+   access.
+
+@invariant The member variables @a m_value and @a m_type have the following
+relationship:
+- If `m_type == value_t::object`, then `m_value.object != nullptr`.
+- If `m_type == value_t::array`, then `m_value.array != nullptr`.
+- If `m_type == value_t::string`, then `m_value.string != nullptr`.
+The invariants are checked by member function assert_invariant().
+
+@internal
+@note ObjectType trick from http://stackoverflow.com/a/9860911
+@endinternal
+
+@see [RFC 7159: The JavaScript Object Notation (JSON) Data Interchange
+Format](http://rfc7159.net/rfc7159)
+
+@since version 1.0.0
+
+@nosubgrouping
+*/
+NLOHMANN_BASIC_JSON_TPL_DECLARATION
+class basic_json
+{
+  private:
+    template<detail::value_t> friend struct detail::external_constructor;
+    friend ::nlohmann::json_pointer<basic_json>;
+    friend ::nlohmann::detail::parser<basic_json>;
+    friend ::nlohmann::detail::serializer<basic_json>;
+    template<typename BasicJsonType>
+    friend class ::nlohmann::detail::iter_impl;
+    template<typename BasicJsonType, typename CharType>
+    friend class ::nlohmann::detail::binary_writer;
+    template<typename BasicJsonType, typename SAX>
+    friend class ::nlohmann::detail::binary_reader;
+    template<typename BasicJsonType>
+    friend class ::nlohmann::detail::json_sax_dom_parser;
+    template<typename BasicJsonType>
+    friend class ::nlohmann::detail::json_sax_dom_callback_parser;
+
+    /// workaround type for MSVC
+    using basic_json_t = NLOHMANN_BASIC_JSON_TPL;
+
+    // convenience aliases for types residing in namespace detail;
+    using lexer = ::nlohmann::detail::lexer<basic_json>;
+    using parser = ::nlohmann::detail::parser<basic_json>;
+
+    using primitive_iterator_t = ::nlohmann::detail::primitive_iterator_t;
+    template<typename BasicJsonType>
+    using internal_iterator = ::nlohmann::detail::internal_iterator<BasicJsonType>;
+    template<typename BasicJsonType>
+    using iter_impl = ::nlohmann::detail::iter_impl<BasicJsonType>;
+    template<typename Iterator>
+    using iteration_proxy = ::nlohmann::detail::iteration_proxy<Iterator>;
+    template<typename Base> using json_reverse_iterator = ::nlohmann::detail::json_reverse_iterator<Base>;
+
+    template<typename CharType>
+    using output_adapter_t = ::nlohmann::detail::output_adapter_t<CharType>;
+
+    using binary_reader = ::nlohmann::detail::binary_reader<basic_json>;
+    template<typename CharType> using binary_writer = ::nlohmann::detail::binary_writer<basic_json, CharType>;
+
+    using serializer = ::nlohmann::detail::serializer<basic_json>;
+
+  public:
+    using value_t = detail::value_t;
+    /// JSON Pointer, see @ref nlohmann::json_pointer
+    using json_pointer = ::nlohmann::json_pointer<basic_json>;
+    template<typename T, typename SFINAE>
+    using json_serializer = JSONSerializer<T, SFINAE>;
+    /// how to treat decoding errors
+    using error_handler_t = detail::error_handler_t;
+    /// helper type for initializer lists of basic_json values
+    using initializer_list_t = std::initializer_list<detail::json_ref<basic_json>>;
+
+    using input_format_t = detail::input_format_t;
+    /// SAX interface type, see @ref nlohmann::json_sax
+    using json_sax_t = json_sax<basic_json>;
+
+    ////////////////
+    // exceptions //
+    ////////////////
+
+    /// @name exceptions
+    /// Classes to implement user-defined exceptions.
+    /// @{
+
+    /// @copydoc detail::exception
+    using exception = detail::exception;
+    /// @copydoc detail::parse_error
+    using parse_error = detail::parse_error;
+    /// @copydoc detail::invalid_iterator
+    using invalid_iterator = detail::invalid_iterator;
+    /// @copydoc detail::type_error
+    using type_error = detail::type_error;
+    /// @copydoc detail::out_of_range
+    using out_of_range = detail::out_of_range;
+    /// @copydoc detail::other_error
+    using other_error = detail::other_error;
+
+    /// @}
+
+
+    /////////////////////
+    // container types //
+    /////////////////////
+
+    /// @name container types
+    /// The canonic container types to use @ref basic_json like any other STL
+    /// container.
+    /// @{
+
+    /// the type of elements in a basic_json container
+    using value_type = basic_json;
+
+    /// the type of an element reference
+    using reference = value_type&;
+    /// the type of an element const reference
+    using const_reference = const value_type&;
+
+    /// a type to represent differences between iterators
+    using difference_type = std::ptrdiff_t;
+    /// a type to represent container sizes
+    using size_type = std::size_t;
+
+    /// the allocator type
+    using allocator_type = AllocatorType<basic_json>;
+
+    /// the type of an element pointer
+    using pointer = typename std::allocator_traits<allocator_type>::pointer;
+    /// the type of an element const pointer
+    using const_pointer = typename std::allocator_traits<allocator_type>::const_pointer;
+
+    /// an iterator for a basic_json container
+    using iterator = iter_impl<basic_json>;
+    /// a const iterator for a basic_json container
+    using const_iterator = iter_impl<const basic_json>;
+    /// a reverse iterator for a basic_json container
+    using reverse_iterator = json_reverse_iterator<typename basic_json::iterator>;
+    /// a const reverse iterator for a basic_json container
+    using const_reverse_iterator = json_reverse_iterator<typename basic_json::const_iterator>;
+
+    /// @}
+
+
+    /*!
+    @brief returns the allocator associated with the container
+    */
+    static allocator_type get_allocator()
+    {
+        return allocator_type();
+    }
+
+    /*!
+    @brief returns version information on the library
+
+    This function returns a JSON object with information about the library,
+    including the version number and information on the platform and compiler.
+
+    @return JSON object holding version information
+    key         | description
+    ----------- | ---------------
+    `compiler`  | Information on the used compiler. It is an object with the following keys: `c++` (the used C++ standard), `family` (the compiler family; possible values are `clang`, `icc`, `gcc`, `ilecpp`, `msvc`, `pgcpp`, `sunpro`, and `unknown`), and `version` (the compiler version).
+    `copyright` | The copyright line for the library as string.
+    `name`      | The name of the library as string.
+    `platform`  | The used platform as string. Possible values are `win32`, `linux`, `apple`, `unix`, and `unknown`.
+    `url`       | The URL of the project as string.
+    `version`   | The version of the library. It is an object with the following keys: `major`, `minor`, and `patch` as defined by [Semantic Versioning](http://semver.org), and `string` (the version string).
+
+    @liveexample{The following code shows an example output of the `meta()`
+    function.,meta}
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes to any JSON value.
+
+    @complexity Constant.
+
+    @since 2.1.0
+    */
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json meta()
+    {
+        basic_json result;
+
+        result["copyright"] = "(C) 2013-2017 Niels Lohmann";
+        result["name"] = "JSON for Modern C++";
+        result["url"] = "https://github.com/nlohmann/json";
+        result["version"]["string"] =
+            std::to_string(NLOHMANN_JSON_VERSION_MAJOR) + "." +
+            std::to_string(NLOHMANN_JSON_VERSION_MINOR) + "." +
+            std::to_string(NLOHMANN_JSON_VERSION_PATCH);
+        result["version"]["major"] = NLOHMANN_JSON_VERSION_MAJOR;
+        result["version"]["minor"] = NLOHMANN_JSON_VERSION_MINOR;
+        result["version"]["patch"] = NLOHMANN_JSON_VERSION_PATCH;
+
+#ifdef _WIN32
+        result["platform"] = "win32";
+#elif defined __linux__
+        result["platform"] = "linux";
+#elif defined __APPLE__
+        result["platform"] = "apple";
+#elif defined __unix__
+        result["platform"] = "unix";
+#else
+        result["platform"] = "unknown";
+#endif
+
+#if defined(__ICC) || defined(__INTEL_COMPILER)
+        result["compiler"] = {{"family", "icc"}, {"version", __INTEL_COMPILER}};
+#elif defined(__clang__)
+        result["compiler"] = {{"family", "clang"}, {"version", __clang_version__}};
+#elif defined(__GNUC__) || defined(__GNUG__)
+        result["compiler"] = {{"family", "gcc"}, {"version", std::to_string(__GNUC__) + "." + std::to_string(__GNUC_MINOR__) + "." + std::to_string(__GNUC_PATCHLEVEL__)}};
+#elif defined(__HP_cc) || defined(__HP_aCC)
+        result["compiler"] = "hp"
+#elif defined(__IBMCPP__)
+        result["compiler"] = {{"family", "ilecpp"}, {"version", __IBMCPP__}};
+#elif defined(_MSC_VER)
+        result["compiler"] = {{"family", "msvc"}, {"version", _MSC_VER}};
+#elif defined(__PGI)
+        result["compiler"] = {{"family", "pgcpp"}, {"version", __PGI}};
+#elif defined(__SUNPRO_CC)
+        result["compiler"] = {{"family", "sunpro"}, {"version", __SUNPRO_CC}};
+#else
+        result["compiler"] = {{"family", "unknown"}, {"version", "unknown"}};
+#endif
+
+#ifdef __cplusplus
+        result["compiler"]["c++"] = std::to_string(__cplusplus);
+#else
+        result["compiler"]["c++"] = "unknown";
+#endif
+        return result;
+    }
+
+
+    ///////////////////////////
+    // JSON value data types //
+    ///////////////////////////
+
+    /// @name JSON value data types
+    /// The data types to store a JSON value. These types are derived from
+    /// the template arguments passed to class @ref basic_json.
+    /// @{
+
+#if defined(JSON_HAS_CPP_14)
+    // Use transparent comparator if possible, combined with perfect forwarding
+    // on find() and count() calls prevents unnecessary string construction.
+    using object_comparator_t = std::less<>;
+#else
+    using object_comparator_t = std::less<StringType>;
+#endif
+
+    /*!
+    @brief a type for an object
+
+    [RFC 7159](http://rfc7159.net/rfc7159) describes JSON objects as follows:
+    > An object is an unordered collection of zero or more name/value pairs,
+    > where a name is a string and a value is a string, number, boolean, null,
+    > object, or array.
+
+    To store objects in C++, a type is defined by the template parameters
+    described below.
+
+    @tparam ObjectType  the container to store objects (e.g., `std::map` or
+    `std::unordered_map`)
+    @tparam StringType the type of the keys or names (e.g., `std::string`).
+    The comparison function `std::less<StringType>` is used to order elements
+    inside the container.
+    @tparam AllocatorType the allocator to use for objects (e.g.,
+    `std::allocator`)
+
+    #### Default type
+
+    With the default values for @a ObjectType (`std::map`), @a StringType
+    (`std::string`), and @a AllocatorType (`std::allocator`), the default
+    value for @a object_t is:
+
+    @code {.cpp}
+    std::map<
+      std::string, // key_type
+      basic_json, // value_type
+      std::less<std::string>, // key_compare
+      std::allocator<std::pair<const std::string, basic_json>> // allocator_type
+    >
+    @endcode
+
+    #### Behavior
+
+    The choice of @a object_t influences the behavior of the JSON class. With
+    the default type, objects have the following behavior:
+
+    - When all names are unique, objects will be interoperable in the sense
+      that all software implementations receiving that object will agree on
+      the name-value mappings.
+    - When the names within an object are not unique, it is unspecified which
+      one of the values for a given key will be chosen. For instance,
+      `{"key": 2, "key": 1}` could be equal to either `{"key": 1}` or
+      `{"key": 2}`.
+    - Internally, name/value pairs are stored in lexicographical order of the
+      names. Objects will also be serialized (see @ref dump) in this order.
+      For instance, `{"b": 1, "a": 2}` and `{"a": 2, "b": 1}` will be stored
+      and serialized as `{"a": 2, "b": 1}`.
+    - When comparing objects, the order of the name/value pairs is irrelevant.
+      This makes objects interoperable in the sense that they will not be
+      affected by these differences. For instance, `{"b": 1, "a": 2}` and
+      `{"a": 2, "b": 1}` will be treated as equal.
+
+    #### Limits
+
+    [RFC 7159](http://rfc7159.net/rfc7159) specifies:
+    > An implementation may set limits on the maximum depth of nesting.
+
+    In this class, the object's limit of nesting is not explicitly constrained.
+    However, a maximum depth of nesting may be introduced by the compiler or
+    runtime environment. A theoretical limit can be queried by calling the
+    @ref max_size function of a JSON object.
+
+    #### Storage
+
+    Objects are stored as pointers in a @ref basic_json type. That is, for any
+    access to object values, a pointer of type `object_t*` must be
+    dereferenced.
+
+    @sa @ref array_t -- type for an array value
+
+    @since version 1.0.0
+
+    @note The order name/value pairs are added to the object is *not*
+    preserved by the library. Therefore, iterating an object may return
+    name/value pairs in a different order than they were originally stored. In
+    fact, keys will be traversed in alphabetical order as `std::map` with
+    `std::less` is used by default. Please note this behavior conforms to [RFC
+    7159](http://rfc7159.net/rfc7159), because any order implements the
+    specified "unordered" nature of JSON objects.
+    */
+    using object_t = ObjectType<StringType,
+          basic_json,
+          object_comparator_t,
+          AllocatorType<std::pair<const StringType,
+          basic_json>>>;
+
+    /*!
+    @brief a type for an array
+
+    [RFC 7159](http://rfc7159.net/rfc7159) describes JSON arrays as follows:
+    > An array is an ordered sequence of zero or more values.
+
+    To store objects in C++, a type is defined by the template parameters
+    explained below.
+
+    @tparam ArrayType  container type to store arrays (e.g., `std::vector` or
+    `std::list`)
+    @tparam AllocatorType allocator to use for arrays (e.g., `std::allocator`)
+
+    #### Default type
+
+    With the default values for @a ArrayType (`std::vector`) and @a
+    AllocatorType (`std::allocator`), the default value for @a array_t is:
+
+    @code {.cpp}
+    std::vector<
+      basic_json, // value_type
+      std::allocator<basic_json> // allocator_type
+    >
+    @endcode
+
+    #### Limits
+
+    [RFC 7159](http://rfc7159.net/rfc7159) specifies:
+    > An implementation may set limits on the maximum depth of nesting.
+
+    In this class, the array's limit of nesting is not explicitly constrained.
+    However, a maximum depth of nesting may be introduced by the compiler or
+    runtime environment. A theoretical limit can be queried by calling the
+    @ref max_size function of a JSON array.
+
+    #### Storage
+
+    Arrays are stored as pointers in a @ref basic_json type. That is, for any
+    access to array values, a pointer of type `array_t*` must be dereferenced.
+
+    @sa @ref object_t -- type for an object value
+
+    @since version 1.0.0
+    */
+    using array_t = ArrayType<basic_json, AllocatorType<basic_json>>;
+
+    /*!
+    @brief a type for a string
+
+    [RFC 7159](http://rfc7159.net/rfc7159) describes JSON strings as follows:
+    > A string is a sequence of zero or more Unicode characters.
+
+    To store objects in C++, a type is defined by the template parameter
+    described below. Unicode values are split by the JSON class into
+    byte-sized characters during deserialization.
+
+    @tparam StringType  the container to store strings (e.g., `std::string`).
+    Note this container is used for keys/names in objects, see @ref object_t.
+
+    #### Default type
+
+    With the default values for @a StringType (`std::string`), the default
+    value for @a string_t is:
+
+    @code {.cpp}
+    std::string
+    @endcode
+
+    #### Encoding
+
+    Strings are stored in UTF-8 encoding. Therefore, functions like
+    `std::string::size()` or `std::string::length()` return the number of
+    bytes in the string rather than the number of characters or glyphs.
+
+    #### String comparison
+
+    [RFC 7159](http://rfc7159.net/rfc7159) states:
+    > Software implementations are typically required to test names of object
+    > members for equality. Implementations that transform the textual
+    > representation into sequences of Unicode code units and then perform the
+    > comparison numerically, code unit by code unit, are interoperable in the
+    > sense that implementations will agree in all cases on equality or
+    > inequality of two strings. For example, implementations that compare
+    > strings with escaped characters unconverted may incorrectly find that
+    > `"a\\b"` and `"a\u005Cb"` are not equal.
+
+    This implementation is interoperable as it does compare strings code unit
+    by code unit.
+
+    #### Storage
+
+    String values are stored as pointers in a @ref basic_json type. That is,
+    for any access to string values, a pointer of type `string_t*` must be
+    dereferenced.
+
+    @since version 1.0.0
+    */
+    using string_t = StringType;
+
+    /*!
+    @brief a type for a boolean
+
+    [RFC 7159](http://rfc7159.net/rfc7159) implicitly describes a boolean as a
+    type which differentiates the two literals `true` and `false`.
+
+    To store objects in C++, a type is defined by the template parameter @a
+    BooleanType which chooses the type to use.
+
+    #### Default type
+
+    With the default values for @a BooleanType (`bool`), the default value for
+    @a boolean_t is:
+
+    @code {.cpp}
+    bool
+    @endcode
+
+    #### Storage
+
+    Boolean values are stored directly inside a @ref basic_json type.
+
+    @since version 1.0.0
+    */
+    using boolean_t = BooleanType;
+
+    /*!
+    @brief a type for a number (integer)
+
+    [RFC 7159](http://rfc7159.net/rfc7159) describes numbers as follows:
+    > The representation of numbers is similar to that used in most
+    > programming languages. A number is represented in base 10 using decimal
+    > digits. It contains an integer component that may be prefixed with an
+    > optional minus sign, which may be followed by a fraction part and/or an
+    > exponent part. Leading zeros are not allowed. (...) Numeric values that
+    > cannot be represented in the grammar below (such as Infinity and NaN)
+    > are not permitted.
+
+    This description includes both integer and floating-point numbers.
+    However, C++ allows more precise storage if it is known whether the number
+    is a signed integer, an unsigned integer or a floating-point number.
+    Therefore, three different types, @ref number_integer_t, @ref
+    number_unsigned_t and @ref number_float_t are used.
+
+    To store integer numbers in C++, a type is defined by the template
+    parameter @a NumberIntegerType which chooses the type to use.
+
+    #### Default type
+
+    With the default values for @a NumberIntegerType (`int64_t`), the default
+    value for @a number_integer_t is:
+
+    @code {.cpp}
+    int64_t
+    @endcode
+
+    #### Default behavior
+
+    - The restrictions about leading zeros is not enforced in C++. Instead,
+      leading zeros in integer literals lead to an interpretation as octal
+      number. Internally, the value will be stored as decimal number. For
+      instance, the C++ integer literal `010` will be serialized to `8`.
+      During deserialization, leading zeros yield an error.
+    - Not-a-number (NaN) values will be serialized to `null`.
+
+    #### Limits
+
+    [RFC 7159](http://rfc7159.net/rfc7159) specifies:
+    > An implementation may set limits on the range and precision of numbers.
+
+    When the default type is used, the maximal integer number that can be
+    stored is `9223372036854775807` (INT64_MAX) and the minimal integer number
+    that can be stored is `-9223372036854775808` (INT64_MIN). Integer numbers
+    that are out of range will yield over/underflow when used in a
+    constructor. During deserialization, too large or small integer numbers
+    will be automatically be stored as @ref number_unsigned_t or @ref
+    number_float_t.
+
+    [RFC 7159](http://rfc7159.net/rfc7159) further states:
+    > Note that when such software is used, numbers that are integers and are
+    > in the range \f$[-2^{53}+1, 2^{53}-1]\f$ are interoperable in the sense
+    > that implementations will agree exactly on their numeric values.
+
+    As this range is a subrange of the exactly supported range [INT64_MIN,
+    INT64_MAX], this class's integer type is interoperable.
+
+    #### Storage
+
+    Integer number values are stored directly inside a @ref basic_json type.
+
+    @sa @ref number_float_t -- type for number values (floating-point)
+
+    @sa @ref number_unsigned_t -- type for number values (unsigned integer)
+
+    @since version 1.0.0
+    */
+    using number_integer_t = NumberIntegerType;
+
+    /*!
+    @brief a type for a number (unsigned)
+
+    [RFC 7159](http://rfc7159.net/rfc7159) describes numbers as follows:
+    > The representation of numbers is similar to that used in most
+    > programming languages. A number is represented in base 10 using decimal
+    > digits. It contains an integer component that may be prefixed with an
+    > optional minus sign, which may be followed by a fraction part and/or an
+    > exponent part. Leading zeros are not allowed. (...) Numeric values that
+    > cannot be represented in the grammar below (such as Infinity and NaN)
+    > are not permitted.
+
+    This description includes both integer and floating-point numbers.
+    However, C++ allows more precise storage if it is known whether the number
+    is a signed integer, an unsigned integer or a floating-point number.
+    Therefore, three different types, @ref number_integer_t, @ref
+    number_unsigned_t and @ref number_float_t are used.
+
+    To store unsigned integer numbers in C++, a type is defined by the
+    template parameter @a NumberUnsignedType which chooses the type to use.
+
+    #### Default type
+
+    With the default values for @a NumberUnsignedType (`uint64_t`), the
+    default value for @a number_unsigned_t is:
+
+    @code {.cpp}
+    uint64_t
+    @endcode
+
+    #### Default behavior
+
+    - The restrictions about leading zeros is not enforced in C++. Instead,
+      leading zeros in integer literals lead to an interpretation as octal
+      number. Internally, the value will be stored as decimal number. For
+      instance, the C++ integer literal `010` will be serialized to `8`.
+      During deserialization, leading zeros yield an error.
+    - Not-a-number (NaN) values will be serialized to `null`.
+
+    #### Limits
+
+    [RFC 7159](http://rfc7159.net/rfc7159) specifies:
+    > An implementation may set limits on the range and precision of numbers.
+
+    When the default type is used, the maximal integer number that can be
+    stored is `18446744073709551615` (UINT64_MAX) and the minimal integer
+    number that can be stored is `0`. Integer numbers that are out of range
+    will yield over/underflow when used in a constructor. During
+    deserialization, too large or small integer numbers will be automatically
+    be stored as @ref number_integer_t or @ref number_float_t.
+
+    [RFC 7159](http://rfc7159.net/rfc7159) further states:
+    > Note that when such software is used, numbers that are integers and are
+    > in the range \f$[-2^{53}+1, 2^{53}-1]\f$ are interoperable in the sense
+    > that implementations will agree exactly on their numeric values.
+
+    As this range is a subrange (when considered in conjunction with the
+    number_integer_t type) of the exactly supported range [0, UINT64_MAX],
+    this class's integer type is interoperable.
+
+    #### Storage
+
+    Integer number values are stored directly inside a @ref basic_json type.
+
+    @sa @ref number_float_t -- type for number values (floating-point)
+    @sa @ref number_integer_t -- type for number values (integer)
+
+    @since version 2.0.0
+    */
+    using number_unsigned_t = NumberUnsignedType;
+
+    /*!
+    @brief a type for a number (floating-point)
+
+    [RFC 7159](http://rfc7159.net/rfc7159) describes numbers as follows:
+    > The representation of numbers is similar to that used in most
+    > programming languages. A number is represented in base 10 using decimal
+    > digits. It contains an integer component that may be prefixed with an
+    > optional minus sign, which may be followed by a fraction part and/or an
+    > exponent part. Leading zeros are not allowed. (...) Numeric values that
+    > cannot be represented in the grammar below (such as Infinity and NaN)
+    > are not permitted.
+
+    This description includes both integer and floating-point numbers.
+    However, C++ allows more precise storage if it is known whether the number
+    is a signed integer, an unsigned integer or a floating-point number.
+    Therefore, three different types, @ref number_integer_t, @ref
+    number_unsigned_t and @ref number_float_t are used.
+
+    To store floating-point numbers in C++, a type is defined by the template
+    parameter @a NumberFloatType which chooses the type to use.
+
+    #### Default type
+
+    With the default values for @a NumberFloatType (`double`), the default
+    value for @a number_float_t is:
+
+    @code {.cpp}
+    double
+    @endcode
+
+    #### Default behavior
+
+    - The restrictions about leading zeros is not enforced in C++. Instead,
+      leading zeros in floating-point literals will be ignored. Internally,
+      the value will be stored as decimal number. For instance, the C++
+      floating-point literal `01.2` will be serialized to `1.2`. During
+      deserialization, leading zeros yield an error.
+    - Not-a-number (NaN) values will be serialized to `null`.
+
+    #### Limits
+
+    [RFC 7159](http://rfc7159.net/rfc7159) states:
+    > This specification allows implementations to set limits on the range and
+    > precision of numbers accepted. Since software that implements IEEE
+    > 754-2008 binary64 (double precision) numbers is generally available and
+    > widely used, good interoperability can be achieved by implementations
+    > that expect no more precision or range than these provide, in the sense
+    > that implementations will approximate JSON numbers within the expected
+    > precision.
+
+    This implementation does exactly follow this approach, as it uses double
+    precision floating-point numbers. Note values smaller than
+    `-1.79769313486232e+308` and values greater than `1.79769313486232e+308`
+    will be stored as NaN internally and be serialized to `null`.
+
+    #### Storage
+
+    Floating-point number values are stored directly inside a @ref basic_json
+    type.
+
+    @sa @ref number_integer_t -- type for number values (integer)
+
+    @sa @ref number_unsigned_t -- type for number values (unsigned integer)
+
+    @since version 1.0.0
+    */
+    using number_float_t = NumberFloatType;
+
+    /// @}
+
+  private:
+
+    /// helper for exception-safe object creation
+    template<typename T, typename... Args>
+    JSON_HEDLEY_RETURNS_NON_NULL
+    static T* create(Args&& ... args)
+    {
+        AllocatorType<T> alloc;
+        using AllocatorTraits = std::allocator_traits<AllocatorType<T>>;
+
+        auto deleter = [&](T * object)
+        {
+            AllocatorTraits::deallocate(alloc, object, 1);
+        };
+        std::unique_ptr<T, decltype(deleter)> object(AllocatorTraits::allocate(alloc, 1), deleter);
+        AllocatorTraits::construct(alloc, object.get(), std::forward<Args>(args)...);
+        assert(object != nullptr);
+        return object.release();
+    }
+
+    ////////////////////////
+    // JSON value storage //
+    ////////////////////////
+
+    /*!
+    @brief a JSON value
+
+    The actual storage for a JSON value of the @ref basic_json class. This
+    union combines the different storage types for the JSON value types
+    defined in @ref value_t.
+
+    JSON type | value_t type    | used type
+    --------- | --------------- | ------------------------
+    object    | object          | pointer to @ref object_t
+    array     | array           | pointer to @ref array_t
+    string    | string          | pointer to @ref string_t
+    boolean   | boolean         | @ref boolean_t
+    number    | number_integer  | @ref number_integer_t
+    number    | number_unsigned | @ref number_unsigned_t
+    number    | number_float    | @ref number_float_t
+    null      | null            | *no value is stored*
+
+    @note Variable-length types (objects, arrays, and strings) are stored as
+    pointers. The size of the union should not exceed 64 bits if the default
+    value types are used.
+
+    @since version 1.0.0
+    */
+    union json_value
+    {
+        /// object (stored with pointer to save storage)
+        object_t* object;
+        /// array (stored with pointer to save storage)
+        array_t* array;
+        /// string (stored with pointer to save storage)
+        string_t* string;
+        /// boolean
+        boolean_t boolean;
+        /// number (integer)
+        number_integer_t number_integer;
+        /// number (unsigned integer)
+        number_unsigned_t number_unsigned;
+        /// number (floating-point)
+        number_float_t number_float;
+
+        /// default constructor (for null values)
+        json_value() = default;
+        /// constructor for booleans
+        json_value(boolean_t v) noexcept : boolean(v) {}
+        /// constructor for numbers (integer)
+        json_value(number_integer_t v) noexcept : number_integer(v) {}
+        /// constructor for numbers (unsigned)
+        json_value(number_unsigned_t v) noexcept : number_unsigned(v) {}
+        /// constructor for numbers (floating-point)
+        json_value(number_float_t v) noexcept : number_float(v) {}
+        /// constructor for empty values of a given type
+        json_value(value_t t)
+        {
+            switch (t)
+            {
+                case value_t::object:
+                {
+                    object = create<object_t>();
+                    break;
+                }
+
+                case value_t::array:
+                {
+                    array = create<array_t>();
+                    break;
+                }
+
+                case value_t::string:
+                {
+                    string = create<string_t>("");
+                    break;
+                }
+
+                case value_t::boolean:
+                {
+                    boolean = boolean_t(false);
+                    break;
+                }
+
+                case value_t::number_integer:
+                {
+                    number_integer = number_integer_t(0);
+                    break;
+                }
+
+                case value_t::number_unsigned:
+                {
+                    number_unsigned = number_unsigned_t(0);
+                    break;
+                }
+
+                case value_t::number_float:
+                {
+                    number_float = number_float_t(0.0);
+                    break;
+                }
+
+                case value_t::null:
+                {
+                    object = nullptr;  // silence warning, see #821
+                    break;
+                }
+
+                default:
+                {
+                    object = nullptr;  // silence warning, see #821
+                    if (JSON_HEDLEY_UNLIKELY(t == value_t::null))
+                    {
+                        JSON_THROW(other_error::create(500, "961c151d2e87f2686a955a9be24d316f1362bf21 3.7.0")); // LCOV_EXCL_LINE
+                    }
+                    break;
+                }
+            }
+        }
+
+        /// constructor for strings
+        json_value(const string_t& value)
+        {
+            string = create<string_t>(value);
+        }
+
+        /// constructor for rvalue strings
+        json_value(string_t&& value)
+        {
+            string = create<string_t>(std::move(value));
+        }
+
+        /// constructor for objects
+        json_value(const object_t& value)
+        {
+            object = create<object_t>(value);
+        }
+
+        /// constructor for rvalue objects
+        json_value(object_t&& value)
+        {
+            object = create<object_t>(std::move(value));
+        }
+
+        /// constructor for arrays
+        json_value(const array_t& value)
+        {
+            array = create<array_t>(value);
+        }
+
+        /// constructor for rvalue arrays
+        json_value(array_t&& value)
+        {
+            array = create<array_t>(std::move(value));
+        }
+
+        void destroy(value_t t) noexcept
+        {
+            switch (t)
+            {
+                case value_t::object:
+                {
+                    AllocatorType<object_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, object);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, object, 1);
+                    break;
+                }
+
+                case value_t::array:
+                {
+                    AllocatorType<array_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, array);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, array, 1);
+                    break;
+                }
+
+                case value_t::string:
+                {
+                    AllocatorType<string_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, string);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, string, 1);
+                    break;
+                }
+
+                default:
+                {
+                    break;
+                }
+            }
+        }
+    };
+
+    /*!
+    @brief checks the class invariants
+
+    This function asserts the class invariants. It needs to be called at the
+    end of every constructor to make sure that created objects respect the
+    invariant. Furthermore, it has to be called each time the type of a JSON
+    value is changed, because the invariant expresses a relationship between
+    @a m_type and @a m_value.
+    */
+    void assert_invariant() const noexcept
+    {
+        assert(m_type != value_t::object or m_value.object != nullptr);
+        assert(m_type != value_t::array or m_value.array != nullptr);
+        assert(m_type != value_t::string or m_value.string != nullptr);
+    }
+
+  public:
+    //////////////////////////
+    // JSON parser callback //
+    //////////////////////////
+
+    /*!
+    @brief parser event types
+
+    The parser callback distinguishes the following events:
+    - `object_start`: the parser read `{` and started to process a JSON object
+    - `key`: the parser read a key of a value in an object
+    - `object_end`: the parser read `}` and finished processing a JSON object
+    - `array_start`: the parser read `[` and started to process a JSON array
+    - `array_end`: the parser read `]` and finished processing a JSON array
+    - `value`: the parser finished reading a JSON value
+
+    @image html callback_events.png "Example when certain parse events are triggered"
+
+    @sa @ref parser_callback_t for more information and examples
+    */
+    using parse_event_t = typename parser::parse_event_t;
+
+    /*!
+    @brief per-element parser callback type
+
+    With a parser callback function, the result of parsing a JSON text can be
+    influenced. When passed to @ref parse, it is called on certain events
+    (passed as @ref parse_event_t via parameter @a event) with a set recursion
+    depth @a depth and context JSON value @a parsed. The return value of the
+    callback function is a boolean indicating whether the element that emitted
+    the callback shall be kept or not.
+
+    We distinguish six scenarios (determined by the event type) in which the
+    callback function can be called. The following table describes the values
+    of the parameters @a depth, @a event, and @a parsed.
+
+    parameter @a event | description | parameter @a depth | parameter @a parsed
+    ------------------ | ----------- | ------------------ | -------------------
+    parse_event_t::object_start | the parser read `{` and started to process a JSON object | depth of the parent of the JSON object | a JSON value with type discarded
+    parse_event_t::key | the parser read a key of a value in an object | depth of the currently parsed JSON object | a JSON string containing the key
+    parse_event_t::object_end | the parser read `}` and finished processing a JSON object | depth of the parent of the JSON object | the parsed JSON object
+    parse_event_t::array_start | the parser read `[` and started to process a JSON array | depth of the parent of the JSON array | a JSON value with type discarded
+    parse_event_t::array_end | the parser read `]` and finished processing a JSON array | depth of the parent of the JSON array | the parsed JSON array
+    parse_event_t::value | the parser finished reading a JSON value | depth of the value | the parsed JSON value
+
+    @image html callback_events.png "Example when certain parse events are triggered"
+
+    Discarding a value (i.e., returning `false`) has different effects
+    depending on the context in which function was called:
+
+    - Discarded values in structured types are skipped. That is, the parser
+      will behave as if the discarded value was never read.
+    - In case a value outside a structured type is skipped, it is replaced
+      with `null`. This case happens if the top-level element is skipped.
+
+    @param[in] depth  the depth of the recursion during parsing
+
+    @param[in] event  an event of type parse_event_t indicating the context in
+    the callback function has been called
+
+    @param[in,out] parsed  the current intermediate parse result; note that
+    writing to this value has no effect for parse_event_t::key events
+
+    @return Whether the JSON value which called the function during parsing
+    should be kept (`true`) or not (`false`). In the latter case, it is either
+    skipped completely or replaced by an empty discarded object.
+
+    @sa @ref parse for examples
+
+    @since version 1.0.0
+    */
+    using parser_callback_t = typename parser::parser_callback_t;
+
+    //////////////////
+    // constructors //
+    //////////////////
+
+    /// @name constructors and destructors
+    /// Constructors of class @ref basic_json, copy/move constructor, copy
+    /// assignment, static functions creating objects, and the destructor.
+    /// @{
+
+    /*!
+    @brief create an empty value with a given type
+
+    Create an empty JSON value with a given type. The value will be default
+    initialized with an empty value which depends on the type:
+
+    Value type  | initial value
+    ----------- | -------------
+    null        | `null`
+    boolean     | `false`
+    string      | `""`
+    number      | `0`
+    object      | `{}`
+    array       | `[]`
+
+    @param[in] v  the type of the value to create
+
+    @complexity Constant.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes to any JSON value.
+
+    @liveexample{The following code shows the constructor for different @ref
+    value_t values,basic_json__value_t}
+
+    @sa @ref clear() -- restores the postcondition of this constructor
+
+    @since version 1.0.0
+    */
+    basic_json(const value_t v)
+        : m_type(v), m_value(v)
+    {
+        assert_invariant();
+    }
+
+    /*!
+    @brief create a null object
+
+    Create a `null` JSON value. It either takes a null pointer as parameter
+    (explicitly creating `null`) or no parameter (implicitly creating `null`).
+    The passed null pointer itself is not read -- it is only used to choose
+    the right constructor.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this constructor never throws
+    exceptions.
+
+    @liveexample{The following code shows the constructor with and without a
+    null pointer parameter.,basic_json__nullptr_t}
+
+    @since version 1.0.0
+    */
+    basic_json(std::nullptr_t = nullptr) noexcept
+        : basic_json(value_t::null)
+    {
+        assert_invariant();
+    }
+
+    /*!
+    @brief create a JSON value
+
+    This is a "catch all" constructor for all compatible JSON types; that is,
+    types for which a `to_json()` method exists. The constructor forwards the
+    parameter @a val to that method (to `json_serializer<U>::to_json` method
+    with `U = uncvref_t<CompatibleType>`, to be exact).
+
+    Template type @a CompatibleType includes, but is not limited to, the
+    following types:
+    - **arrays**: @ref array_t and all kinds of compatible containers such as
+      `std::vector`, `std::deque`, `std::list`, `std::forward_list`,
+      `std::array`, `std::valarray`, `std::set`, `std::unordered_set`,
+      `std::multiset`, and `std::unordered_multiset` with a `value_type` from
+      which a @ref basic_json value can be constructed.
+    - **objects**: @ref object_t and all kinds of compatible associative
+      containers such as `std::map`, `std::unordered_map`, `std::multimap`,
+      and `std::unordered_multimap` with a `key_type` compatible to
+      @ref string_t and a `value_type` from which a @ref basic_json value can
+      be constructed.
+    - **strings**: @ref string_t, string literals, and all compatible string
+      containers can be used.
+    - **numbers**: @ref number_integer_t, @ref number_unsigned_t,
+      @ref number_float_t, and all convertible number types such as `int`,
+      `size_t`, `int64_t`, `float` or `double` can be used.
+    - **boolean**: @ref boolean_t / `bool` can be used.
+
+    See the examples below.
+
+    @tparam CompatibleType a type such that:
+    - @a CompatibleType is not derived from `std::istream`,
+    - @a CompatibleType is not @ref basic_json (to avoid hijacking copy/move
+         constructors),
+    - @a CompatibleType is not a different @ref basic_json type (i.e. with different template arguments)
+    - @a CompatibleType is not a @ref basic_json nested type (e.g.,
+         @ref json_pointer, @ref iterator, etc ...)
+    - @ref @ref json_serializer<U> has a
+         `to_json(basic_json_t&, CompatibleType&&)` method
+
+    @tparam U = `uncvref_t<CompatibleType>`
+
+    @param[in] val the value to be forwarded to the respective constructor
+
+    @complexity Usually linear in the size of the passed @a val, also
+                depending on the implementation of the called `to_json()`
+                method.
+
+    @exceptionsafety Depends on the called constructor. For types directly
+    supported by the library (i.e., all types for which no `to_json()` function
+    was provided), strong guarantee holds: if an exception is thrown, there are
+    no changes to any JSON value.
+
+    @liveexample{The following code shows the constructor with several
+    compatible types.,basic_json__CompatibleType}
+
+    @since version 2.1.0
+    */
+    template <typename CompatibleType,
+              typename U = detail::uncvref_t<CompatibleType>,
+              detail::enable_if_t<
+                  not detail::is_basic_json<U>::value and detail::is_compatible_type<basic_json_t, U>::value, int> = 0>
+    basic_json(CompatibleType && val) noexcept(noexcept(
+                JSONSerializer<U>::to_json(std::declval<basic_json_t&>(),
+                                           std::forward<CompatibleType>(val))))
+    {
+        JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));
+        assert_invariant();
+    }
+
+    /*!
+    @brief create a JSON value from an existing one
+
+    This is a constructor for existing @ref basic_json types.
+    It does not hijack copy/move constructors, since the parameter has different
+    template arguments than the current ones.
+
+    The constructor tries to convert the internal @ref m_value of the parameter.
+
+    @tparam BasicJsonType a type such that:
+    - @a BasicJsonType is a @ref basic_json type.
+    - @a BasicJsonType has different template arguments than @ref basic_json_t.
+
+    @param[in] val the @ref basic_json value to be converted.
+
+    @complexity Usually linear in the size of the passed @a val, also
+                depending on the implementation of the called `to_json()`
+                method.
+
+    @exceptionsafety Depends on the called constructor. For types directly
+    supported by the library (i.e., all types for which no `to_json()` function
+    was provided), strong guarantee holds: if an exception is thrown, there are
+    no changes to any JSON value.
+
+    @since version 3.2.0
+    */
+    template <typename BasicJsonType,
+              detail::enable_if_t<
+                  detail::is_basic_json<BasicJsonType>::value and not std::is_same<basic_json, BasicJsonType>::value, int> = 0>
+    basic_json(const BasicJsonType& val)
+    {
+        using other_boolean_t = typename BasicJsonType::boolean_t;
+        using other_number_float_t = typename BasicJsonType::number_float_t;
+        using other_number_integer_t = typename BasicJsonType::number_integer_t;
+        using other_number_unsigned_t = typename BasicJsonType::number_unsigned_t;
+        using other_string_t = typename BasicJsonType::string_t;
+        using other_object_t = typename BasicJsonType::object_t;
+        using other_array_t = typename BasicJsonType::array_t;
+
+        switch (val.type())
+        {
+            case value_t::boolean:
+                JSONSerializer<other_boolean_t>::to_json(*this, val.template get<other_boolean_t>());
+                break;
+            case value_t::number_float:
+                JSONSerializer<other_number_float_t>::to_json(*this, val.template get<other_number_float_t>());
+                break;
+            case value_t::number_integer:
+                JSONSerializer<other_number_integer_t>::to_json(*this, val.template get<other_number_integer_t>());
+                break;
+            case value_t::number_unsigned:
+                JSONSerializer<other_number_unsigned_t>::to_json(*this, val.template get<other_number_unsigned_t>());
+                break;
+            case value_t::string:
+                JSONSerializer<other_string_t>::to_json(*this, val.template get_ref<const other_string_t&>());
+                break;
+            case value_t::object:
+                JSONSerializer<other_object_t>::to_json(*this, val.template get_ref<const other_object_t&>());
+                break;
+            case value_t::array:
+                JSONSerializer<other_array_t>::to_json(*this, val.template get_ref<const other_array_t&>());
+                break;
+            case value_t::null:
+                *this = nullptr;
+                break;
+            case value_t::discarded:
+                m_type = value_t::discarded;
+                break;
+            default:            // LCOV_EXCL_LINE
+                assert(false);  // LCOV_EXCL_LINE
+        }
+        assert_invariant();
+    }
+
+    /*!
+    @brief create a container (array or object) from an initializer list
+
+    Creates a JSON value of type array or object from the passed initializer
+    list @a init. In case @a type_deduction is `true` (default), the type of
+    the JSON value to be created is deducted from the initializer list @a init
+    according to the following rules:
+
+    1. If the list is empty, an empty JSON object value `{}` is created.
+    2. If the list consists of pairs whose first element is a string, a JSON
+       object value is created where the first elements of the pairs are
+       treated as keys and the second elements are as values.
+    3. In all other cases, an array is created.
+
+    The rules aim to create the best fit between a C++ initializer list and
+    JSON values. The rationale is as follows:
+
+    1. The empty initializer list is written as `{}` which is exactly an empty
+       JSON object.
+    2. C++ has no way of describing mapped types other than to list a list of
+       pairs. As JSON requires that keys must be of type string, rule 2 is the
+       weakest constraint one can pose on initializer lists to interpret them
+       as an object.
+    3. In all other cases, the initializer list could not be interpreted as
+       JSON object type, so interpreting it as JSON array type is safe.
+
+    With the rules described above, the following JSON values cannot be
+    expressed by an initializer list:
+
+    - the empty array (`[]`): use @ref array(initializer_list_t)
+      with an empty initializer list in this case
+    - arrays whose elements satisfy rule 2: use @ref
+      array(initializer_list_t) with the same initializer list
+      in this case
+
+    @note When used without parentheses around an empty initializer list, @ref
+    basic_json() is called instead of this function, yielding the JSON null
+    value.
+
+    @param[in] init  initializer list with JSON values
+
+    @param[in] type_deduction internal parameter; when set to `true`, the type
+    of the JSON value is deducted from the initializer list @a init; when set
+    to `false`, the type provided via @a manual_type is forced. This mode is
+    used by the functions @ref array(initializer_list_t) and
+    @ref object(initializer_list_t).
+
+    @param[in] manual_type internal parameter; when @a type_deduction is set
+    to `false`, the created JSON value will use the provided type (only @ref
+    value_t::array and @ref value_t::object are valid); when @a type_deduction
+    is set to `true`, this parameter has no effect
+
+    @throw type_error.301 if @a type_deduction is `false`, @a manual_type is
+    `value_t::object`, but @a init contains an element which is not a pair
+    whose first element is a string. In this case, the constructor could not
+    create an object. If @a type_deduction would have be `true`, an array
+    would have been created. See @ref object(initializer_list_t)
+    for an example.
+
+    @complexity Linear in the size of the initializer list @a init.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes to any JSON value.
+
+    @liveexample{The example below shows how JSON values are created from
+    initializer lists.,basic_json__list_init_t}
+
+    @sa @ref array(initializer_list_t) -- create a JSON array
+    value from an initializer list
+    @sa @ref object(initializer_list_t) -- create a JSON object
+    value from an initializer list
+
+    @since version 1.0.0
+    */
+    basic_json(initializer_list_t init,
+               bool type_deduction = true,
+               value_t manual_type = value_t::array)
+    {
+        // check if each element is an array with two elements whose first
+        // element is a string
+        bool is_an_object = std::all_of(init.begin(), init.end(),
+                                        [](const detail::json_ref<basic_json>& element_ref)
+        {
+            return element_ref->is_array() and element_ref->size() == 2 and (*element_ref)[0].is_string();
+        });
+
+        // adjust type if type deduction is not wanted
+        if (not type_deduction)
+        {
+            // if array is wanted, do not create an object though possible
+            if (manual_type == value_t::array)
+            {
+                is_an_object = false;
+            }
+
+            // if object is wanted but impossible, throw an exception
+            if (JSON_HEDLEY_UNLIKELY(manual_type == value_t::object and not is_an_object))
+            {
+                JSON_THROW(type_error::create(301, "cannot create object from initializer list"));
+            }
+        }
+
+        if (is_an_object)
+        {
+            // the initializer list is a list of pairs -> create object
+            m_type = value_t::object;
+            m_value = value_t::object;
+
+            std::for_each(init.begin(), init.end(), [this](const detail::json_ref<basic_json>& element_ref)
+            {
+                auto element = element_ref.moved_or_copied();
+                m_value.object->emplace(
+                    std::move(*((*element.m_value.array)[0].m_value.string)),
+                    std::move((*element.m_value.array)[1]));
+            });
+        }
+        else
+        {
+            // the initializer list describes an array -> create array
+            m_type = value_t::array;
+            m_value.array = create<array_t>(init.begin(), init.end());
+        }
+
+        assert_invariant();
+    }
+
+    /*!
+    @brief explicitly create an array from an initializer list
+
+    Creates a JSON array value from a given initializer list. That is, given a
+    list of values `a, b, c`, creates the JSON value `[a, b, c]`. If the
+    initializer list is empty, the empty array `[]` is created.
+
+    @note This function is only needed to express two edge cases that cannot
+    be realized with the initializer list constructor (@ref
+    basic_json(initializer_list_t, bool, value_t)). These cases
+    are:
+    1. creating an array whose elements are all pairs whose first element is a
+    string -- in this case, the initializer list constructor would create an
+    object, taking the first elements as keys
+    2. creating an empty array -- passing the empty initializer list to the
+    initializer list constructor yields an empty object
+
+    @param[in] init  initializer list with JSON values to create an array from
+    (optional)
+
+    @return JSON array value
+
+    @complexity Linear in the size of @a init.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes to any JSON value.
+
+    @liveexample{The following code shows an example for the `array`
+    function.,array}
+
+    @sa @ref basic_json(initializer_list_t, bool, value_t) --
+    create a JSON value from an initializer list
+    @sa @ref object(initializer_list_t) -- create a JSON object
+    value from an initializer list
+
+    @since version 1.0.0
+    */
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json array(initializer_list_t init = {})
+    {
+        return basic_json(init, false, value_t::array);
+    }
+
+    /*!
+    @brief explicitly create an object from an initializer list
+
+    Creates a JSON object value from a given initializer list. The initializer
+    lists elements must be pairs, and their first elements must be strings. If
+    the initializer list is empty, the empty object `{}` is created.
+
+    @note This function is only added for symmetry reasons. In contrast to the
+    related function @ref array(initializer_list_t), there are
+    no cases which can only be expressed by this function. That is, any
+    initializer list @a init can also be passed to the initializer list
+    constructor @ref basic_json(initializer_list_t, bool, value_t).
+
+    @param[in] init  initializer list to create an object from (optional)
+
+    @return JSON object value
+
+    @throw type_error.301 if @a init is not a list of pairs whose first
+    elements are strings. In this case, no object can be created. When such a
+    value is passed to @ref basic_json(initializer_list_t, bool, value_t),
+    an array would have been created from the passed initializer list @a init.
+    See example below.
+
+    @complexity Linear in the size of @a init.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes to any JSON value.
+
+    @liveexample{The following code shows an example for the `object`
+    function.,object}
+
+    @sa @ref basic_json(initializer_list_t, bool, value_t) --
+    create a JSON value from an initializer list
+    @sa @ref array(initializer_list_t) -- create a JSON array
+    value from an initializer list
+
+    @since version 1.0.0
+    */
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json object(initializer_list_t init = {})
+    {
+        return basic_json(init, false, value_t::object);
+    }
+
+    /*!
+    @brief construct an array with count copies of given value
+
+    Constructs a JSON array value by creating @a cnt copies of a passed value.
+    In case @a cnt is `0`, an empty array is created.
+
+    @param[in] cnt  the number of JSON copies of @a val to create
+    @param[in] val  the JSON value to copy
+
+    @post `std::distance(begin(),end()) == cnt` holds.
+
+    @complexity Linear in @a cnt.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes to any JSON value.
+
+    @liveexample{The following code shows examples for the @ref
+    basic_json(size_type\, const basic_json&)
+    constructor.,basic_json__size_type_basic_json}
+
+    @since version 1.0.0
+    */
+    basic_json(size_type cnt, const basic_json& val)
+        : m_type(value_t::array)
+    {
+        m_value.array = create<array_t>(cnt, val);
+        assert_invariant();
+    }
+
+    /*!
+    @brief construct a JSON container given an iterator range
+
+    Constructs the JSON value with the contents of the range `[first, last)`.
+    The semantics depends on the different types a JSON value can have:
+    - In case of a null type, invalid_iterator.206 is thrown.
+    - In case of other primitive types (number, boolean, or string), @a first
+      must be `begin()` and @a last must be `end()`. In this case, the value is
+      copied. Otherwise, invalid_iterator.204 is thrown.
+    - In case of structured types (array, object), the constructor behaves as
+      similar versions for `std::vector` or `std::map`; that is, a JSON array
+      or object is constructed from the values in the range.
+
+    @tparam InputIT an input iterator type (@ref iterator or @ref
+    const_iterator)
+
+    @param[in] first begin of the range to copy from (included)
+    @param[in] last end of the range to copy from (excluded)
+
+    @pre Iterators @a first and @a last must be initialized. **This
+         precondition is enforced with an assertion (see warning).** If
+         assertions are switched off, a violation of this precondition yields
+         undefined behavior.
+
+    @pre Range `[first, last)` is valid. Usually, this precondition cannot be
+         checked efficiently. Only certain edge cases are detected; see the
+         description of the exceptions below. A violation of this precondition
+         yields undefined behavior.
+
+    @warning A precondition is enforced with a runtime assertion that will
+             result in calling `std::abort` if this precondition is not met.
+             Assertions can be disabled by defining `NDEBUG` at compile time.
+             See https://en.cppreference.com/w/cpp/error/assert for more
+             information.
+
+    @throw invalid_iterator.201 if iterators @a first and @a last are not
+    compatible (i.e., do not belong to the same JSON value). In this case,
+    the range `[first, last)` is undefined.
+    @throw invalid_iterator.204 if iterators @a first and @a last belong to a
+    primitive type (number, boolean, or string), but @a first does not point
+    to the first element any more. In this case, the range `[first, last)` is
+    undefined. See example code below.
+    @throw invalid_iterator.206 if iterators @a first and @a last belong to a
+    null value. In this case, the range `[first, last)` is undefined.
+
+    @complexity Linear in distance between @a first and @a last.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes to any JSON value.
+
+    @liveexample{The example below shows several ways to create JSON values by
+    specifying a subrange with iterators.,basic_json__InputIt_InputIt}
+
+    @since version 1.0.0
+    */
+    template<class InputIT, typename std::enable_if<
+                 std::is_same<InputIT, typename basic_json_t::iterator>::value or
+                 std::is_same<InputIT, typename basic_json_t::const_iterator>::value, int>::type = 0>
+    basic_json(InputIT first, InputIT last)
+    {
+        assert(first.m_object != nullptr);
+        assert(last.m_object != nullptr);
+
+        // make sure iterator fits the current value
+        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(201, "iterators are not compatible"));
+        }
+
+        // copy type from first iterator
+        m_type = first.m_object->m_type;
+
+        // check if iterator range is complete for primitive values
+        switch (m_type)
+        {
+            case value_t::boolean:
+            case value_t::number_float:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::string:
+            {
+                if (JSON_HEDLEY_UNLIKELY(not first.m_it.primitive_iterator.is_begin()
+                                         or not last.m_it.primitive_iterator.is_end()))
+                {
+                    JSON_THROW(invalid_iterator::create(204, "iterators out of range"));
+                }
+                break;
+            }
+
+            default:
+                break;
+        }
+
+        switch (m_type)
+        {
+            case value_t::number_integer:
+            {
+                m_value.number_integer = first.m_object->m_value.number_integer;
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                m_value.number_unsigned = first.m_object->m_value.number_unsigned;
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                m_value.number_float = first.m_object->m_value.number_float;
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                m_value.boolean = first.m_object->m_value.boolean;
+                break;
+            }
+
+            case value_t::string:
+            {
+                m_value = *first.m_object->m_value.string;
+                break;
+            }
+
+            case value_t::object:
+            {
+                m_value.object = create<object_t>(first.m_it.object_iterator,
+                                                  last.m_it.object_iterator);
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_value.array = create<array_t>(first.m_it.array_iterator,
+                                                last.m_it.array_iterator);
+                break;
+            }
+
+            default:
+                JSON_THROW(invalid_iterator::create(206, "cannot construct with iterators from " +
+                                                    std::string(first.m_object->type_name())));
+        }
+
+        assert_invariant();
+    }
+
+
+    ///////////////////////////////////////
+    // other constructors and destructor //
+    ///////////////////////////////////////
+
+    /// @private
+    basic_json(const detail::json_ref<basic_json>& ref)
+        : basic_json(ref.moved_or_copied())
+    {}
+
+    /*!
+    @brief copy constructor
+
+    Creates a copy of a given JSON value.
+
+    @param[in] other  the JSON value to copy
+
+    @post `*this == other`
+
+    @complexity Linear in the size of @a other.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes to any JSON value.
+
+    @requirement This function helps `basic_json` satisfying the
+    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
+    requirements:
+    - The complexity is linear.
+    - As postcondition, it holds: `other == basic_json(other)`.
+
+    @liveexample{The following code shows an example for the copy
+    constructor.,basic_json__basic_json}
+
+    @since version 1.0.0
+    */
+    basic_json(const basic_json& other)
+        : m_type(other.m_type)
+    {
+        // check of passed value is valid
+        other.assert_invariant();
+
+        switch (m_type)
+        {
+            case value_t::object:
+            {
+                m_value = *other.m_value.object;
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_value = *other.m_value.array;
+                break;
+            }
+
+            case value_t::string:
+            {
+                m_value = *other.m_value.string;
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                m_value = other.m_value.boolean;
+                break;
+            }
+
+            case value_t::number_integer:
+            {
+                m_value = other.m_value.number_integer;
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                m_value = other.m_value.number_unsigned;
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                m_value = other.m_value.number_float;
+                break;
+            }
+
+            default:
+                break;
+        }
+
+        assert_invariant();
+    }
+
+    /*!
+    @brief move constructor
+
+    Move constructor. Constructs a JSON value with the contents of the given
+    value @a other using move semantics. It "steals" the resources from @a
+    other and leaves it as JSON null value.
+
+    @param[in,out] other  value to move to this object
+
+    @post `*this` has the same value as @a other before the call.
+    @post @a other is a JSON null value.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this constructor never throws
+    exceptions.
+
+    @requirement This function helps `basic_json` satisfying the
+    [MoveConstructible](https://en.cppreference.com/w/cpp/named_req/MoveConstructible)
+    requirements.
+
+    @liveexample{The code below shows the move constructor explicitly called
+    via std::move.,basic_json__moveconstructor}
+
+    @since version 1.0.0
+    */
+    basic_json(basic_json&& other) noexcept
+        : m_type(std::move(other.m_type)),
+          m_value(std::move(other.m_value))
+    {
+        // check that passed value is valid
+        other.assert_invariant();
+
+        // invalidate payload
+        other.m_type = value_t::null;
+        other.m_value = {};
+
+        assert_invariant();
+    }
+
+    /*!
+    @brief copy assignment
+
+    Copy assignment operator. Copies a JSON value via the "copy and swap"
+    strategy: It is expressed in terms of the copy constructor, destructor,
+    and the `swap()` member function.
+
+    @param[in] other  value to copy from
+
+    @complexity Linear.
+
+    @requirement This function helps `basic_json` satisfying the
+    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
+    requirements:
+    - The complexity is linear.
+
+    @liveexample{The code below shows and example for the copy assignment. It
+    creates a copy of value `a` which is then swapped with `b`. Finally\, the
+    copy of `a` (which is the null value after the swap) is
+    destroyed.,basic_json__copyassignment}
+
+    @since version 1.0.0
+    */
+    basic_json& operator=(basic_json other) noexcept (
+        std::is_nothrow_move_constructible<value_t>::value and
+        std::is_nothrow_move_assignable<value_t>::value and
+        std::is_nothrow_move_constructible<json_value>::value and
+        std::is_nothrow_move_assignable<json_value>::value
+    )
+    {
+        // check that passed value is valid
+        other.assert_invariant();
+
+        using std::swap;
+        swap(m_type, other.m_type);
+        swap(m_value, other.m_value);
+
+        assert_invariant();
+        return *this;
+    }
+
+    /*!
+    @brief destructor
+
+    Destroys the JSON value and frees all allocated memory.
+
+    @complexity Linear.
+
+    @requirement This function helps `basic_json` satisfying the
+    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
+    requirements:
+    - The complexity is linear.
+    - All stored elements are destroyed and all memory is freed.
+
+    @since version 1.0.0
+    */
+    ~basic_json() noexcept
+    {
+        assert_invariant();
+        m_value.destroy(m_type);
+    }
+
+    /// @}
+
+  public:
+    ///////////////////////
+    // object inspection //
+    ///////////////////////
+
+    /// @name object inspection
+    /// Functions to inspect the type of a JSON value.
+    /// @{
+
+    /*!
+    @brief serialization
+
+    Serialization function for JSON values. The function tries to mimic
+    Python's `json.dumps()` function, and currently supports its @a indent
+    and @a ensure_ascii parameters.
+
+    @param[in] indent If indent is nonnegative, then array elements and object
+    members will be pretty-printed with that indent level. An indent level of
+    `0` will only insert newlines. `-1` (the default) selects the most compact
+    representation.
+    @param[in] indent_char The character to use for indentation if @a indent is
+    greater than `0`. The default is ` ` (space).
+    @param[in] ensure_ascii If @a ensure_ascii is true, all non-ASCII characters
+    in the output are escaped with `\uXXXX` sequences, and the result consists
+    of ASCII characters only.
+    @param[in] error_handler  how to react on decoding errors; there are three
+    possible values: `strict` (throws and exception in case a decoding error
+    occurs; default), `replace` (replace invalid UTF-8 sequences with U+FFFD),
+    and `ignore` (ignore invalid UTF-8 sequences during serialization).
+
+    @return string containing the serialization of the JSON value
+
+    @throw type_error.316 if a string stored inside the JSON value is not
+                          UTF-8 encoded
+
+    @complexity Linear.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes in the JSON value.
+
+    @liveexample{The following example shows the effect of different @a indent\,
+    @a indent_char\, and @a ensure_ascii parameters to the result of the
+    serialization.,dump}
+
+    @see https://docs.python.org/2/library/json.html#json.dump
+
+    @since version 1.0.0; indentation character @a indent_char, option
+           @a ensure_ascii and exceptions added in version 3.0.0; error
+           handlers added in version 3.4.0.
+    */
+    string_t dump(const int indent = -1,
+                  const char indent_char = ' ',
+                  const bool ensure_ascii = false,
+                  const error_handler_t error_handler = error_handler_t::strict) const
+    {
+        string_t result;
+        serializer s(detail::output_adapter<char, string_t>(result), indent_char, error_handler);
+
+        if (indent >= 0)
+        {
+            s.dump(*this, true, ensure_ascii, static_cast<unsigned int>(indent));
+        }
+        else
+        {
+            s.dump(*this, false, ensure_ascii, 0);
+        }
+
+        return result;
+    }
+
+    /*!
+    @brief return the type of the JSON value (explicit)
+
+    Return the type of the JSON value as a value from the @ref value_t
+    enumeration.
+
+    @return the type of the JSON value
+            Value type                | return value
+            ------------------------- | -------------------------
+            null                      | value_t::null
+            boolean                   | value_t::boolean
+            string                    | value_t::string
+            number (integer)          | value_t::number_integer
+            number (unsigned integer) | value_t::number_unsigned
+            number (floating-point)   | value_t::number_float
+            object                    | value_t::object
+            array                     | value_t::array
+            discarded                 | value_t::discarded
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `type()` for all JSON
+    types.,type}
+
+    @sa @ref operator value_t() -- return the type of the JSON value (implicit)
+    @sa @ref type_name() -- return the type as string
+
+    @since version 1.0.0
+    */
+    constexpr value_t type() const noexcept
+    {
+        return m_type;
+    }
+
+    /*!
+    @brief return whether type is primitive
+
+    This function returns true if and only if the JSON type is primitive
+    (string, number, boolean, or null).
+
+    @return `true` if type is primitive (string, number, boolean, or null),
+    `false` otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_primitive()` for all JSON
+    types.,is_primitive}
+
+    @sa @ref is_structured() -- returns whether JSON value is structured
+    @sa @ref is_null() -- returns whether JSON value is `null`
+    @sa @ref is_string() -- returns whether JSON value is a string
+    @sa @ref is_boolean() -- returns whether JSON value is a boolean
+    @sa @ref is_number() -- returns whether JSON value is a number
+
+    @since version 1.0.0
+    */
+    constexpr bool is_primitive() const noexcept
+    {
+        return is_null() or is_string() or is_boolean() or is_number();
+    }
+
+    /*!
+    @brief return whether type is structured
+
+    This function returns true if and only if the JSON type is structured
+    (array or object).
+
+    @return `true` if type is structured (array or object), `false` otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_structured()` for all JSON
+    types.,is_structured}
+
+    @sa @ref is_primitive() -- returns whether value is primitive
+    @sa @ref is_array() -- returns whether value is an array
+    @sa @ref is_object() -- returns whether value is an object
+
+    @since version 1.0.0
+    */
+    constexpr bool is_structured() const noexcept
+    {
+        return is_array() or is_object();
+    }
+
+    /*!
+    @brief return whether value is null
+
+    This function returns true if and only if the JSON value is null.
+
+    @return `true` if type is null, `false` otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_null()` for all JSON
+    types.,is_null}
+
+    @since version 1.0.0
+    */
+    constexpr bool is_null() const noexcept
+    {
+        return m_type == value_t::null;
+    }
+
+    /*!
+    @brief return whether value is a boolean
+
+    This function returns true if and only if the JSON value is a boolean.
+
+    @return `true` if type is boolean, `false` otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_boolean()` for all JSON
+    types.,is_boolean}
+
+    @since version 1.0.0
+    */
+    constexpr bool is_boolean() const noexcept
+    {
+        return m_type == value_t::boolean;
+    }
+
+    /*!
+    @brief return whether value is a number
+
+    This function returns true if and only if the JSON value is a number. This
+    includes both integer (signed and unsigned) and floating-point values.
+
+    @return `true` if type is number (regardless whether integer, unsigned
+    integer or floating-type), `false` otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_number()` for all JSON
+    types.,is_number}
+
+    @sa @ref is_number_integer() -- check if value is an integer or unsigned
+    integer number
+    @sa @ref is_number_unsigned() -- check if value is an unsigned integer
+    number
+    @sa @ref is_number_float() -- check if value is a floating-point number
+
+    @since version 1.0.0
+    */
+    constexpr bool is_number() const noexcept
+    {
+        return is_number_integer() or is_number_float();
+    }
+
+    /*!
+    @brief return whether value is an integer number
+
+    This function returns true if and only if the JSON value is a signed or
+    unsigned integer number. This excludes floating-point values.
+
+    @return `true` if type is an integer or unsigned integer number, `false`
+    otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_number_integer()` for all
+    JSON types.,is_number_integer}
+
+    @sa @ref is_number() -- check if value is a number
+    @sa @ref is_number_unsigned() -- check if value is an unsigned integer
+    number
+    @sa @ref is_number_float() -- check if value is a floating-point number
+
+    @since version 1.0.0
+    */
+    constexpr bool is_number_integer() const noexcept
+    {
+        return m_type == value_t::number_integer or m_type == value_t::number_unsigned;
+    }
+
+    /*!
+    @brief return whether value is an unsigned integer number
+
+    This function returns true if and only if the JSON value is an unsigned
+    integer number. This excludes floating-point and signed integer values.
+
+    @return `true` if type is an unsigned integer number, `false` otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_number_unsigned()` for all
+    JSON types.,is_number_unsigned}
+
+    @sa @ref is_number() -- check if value is a number
+    @sa @ref is_number_integer() -- check if value is an integer or unsigned
+    integer number
+    @sa @ref is_number_float() -- check if value is a floating-point number
+
+    @since version 2.0.0
+    */
+    constexpr bool is_number_unsigned() const noexcept
+    {
+        return m_type == value_t::number_unsigned;
+    }
+
+    /*!
+    @brief return whether value is a floating-point number
+
+    This function returns true if and only if the JSON value is a
+    floating-point number. This excludes signed and unsigned integer values.
+
+    @return `true` if type is a floating-point number, `false` otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_number_float()` for all
+    JSON types.,is_number_float}
+
+    @sa @ref is_number() -- check if value is number
+    @sa @ref is_number_integer() -- check if value is an integer number
+    @sa @ref is_number_unsigned() -- check if value is an unsigned integer
+    number
+
+    @since version 1.0.0
+    */
+    constexpr bool is_number_float() const noexcept
+    {
+        return m_type == value_t::number_float;
+    }
+
+    /*!
+    @brief return whether value is an object
+
+    This function returns true if and only if the JSON value is an object.
+
+    @return `true` if type is object, `false` otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_object()` for all JSON
+    types.,is_object}
+
+    @since version 1.0.0
+    */
+    constexpr bool is_object() const noexcept
+    {
+        return m_type == value_t::object;
+    }
+
+    /*!
+    @brief return whether value is an array
+
+    This function returns true if and only if the JSON value is an array.
+
+    @return `true` if type is array, `false` otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_array()` for all JSON
+    types.,is_array}
+
+    @since version 1.0.0
+    */
+    constexpr bool is_array() const noexcept
+    {
+        return m_type == value_t::array;
+    }
+
+    /*!
+    @brief return whether value is a string
+
+    This function returns true if and only if the JSON value is a string.
+
+    @return `true` if type is string, `false` otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_string()` for all JSON
+    types.,is_string}
+
+    @since version 1.0.0
+    */
+    constexpr bool is_string() const noexcept
+    {
+        return m_type == value_t::string;
+    }
+
+    /*!
+    @brief return whether value is discarded
+
+    This function returns true if and only if the JSON value was discarded
+    during parsing with a callback function (see @ref parser_callback_t).
+
+    @note This function will always be `false` for JSON values after parsing.
+    That is, discarded values can only occur during parsing, but will be
+    removed when inside a structured value or replaced by null in other cases.
+
+    @return `true` if type is discarded, `false` otherwise.
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies `is_discarded()` for all JSON
+    types.,is_discarded}
+
+    @since version 1.0.0
+    */
+    constexpr bool is_discarded() const noexcept
+    {
+        return m_type == value_t::discarded;
+    }
+
+    /*!
+    @brief return the type of the JSON value (implicit)
+
+    Implicitly return the type of the JSON value as a value from the @ref
+    value_t enumeration.
+
+    @return the type of the JSON value
+
+    @complexity Constant.
+
+    @exceptionsafety No-throw guarantee: this member function never throws
+    exceptions.
+
+    @liveexample{The following code exemplifies the @ref value_t operator for
+    all JSON types.,operator__value_t}
+
+    @sa @ref type() -- return the type of the JSON value (explicit)
+    @sa @ref type_name() -- return the type as string
+
+    @since version 1.0.0
+    */
+    constexpr operator value_t() const noexcept
+    {
+        return m_type;
+    }
+
+    /// @}
+
+  private:
+    //////////////////
+    // value access //
+    //////////////////
+
+    /// get a boolean (explicit)
+    boolean_t get_impl(boolean_t* /*unused*/) const
+    {
+        if (JSON_HEDLEY_LIKELY(is_boolean()))
+        {
+            return m_value.boolean;
+        }
+
+        JSON_THROW(type_error::create(302, "type must be boolean, but is " + std::string(type_name())));
+    }
+
+    /// get a pointer to the value (object)
+    object_t* get_impl_ptr(object_t* /*unused*/) noexcept
+    {
+        return is_object() ? m_value.object : nullptr;
+    }
+
+    /// get a pointer to the value (object)
+    constexpr const object_t* get_impl_ptr(const object_t* /*unused*/) const noexcept
+    {
+        return is_object() ? m_value.object : nullptr;
+    }
+
+    /// get a pointer to the value (array)
+    array_t* get_impl_ptr(array_t* /*unused*/) noexcept
+    {
+        return is_array() ? m_value.array : nullptr;
+    }
+
+    /// get a pointer to the value (array)
+    constexpr const array_t* get_impl_ptr(const array_t* /*unused*/) const noexcept
+    {
+        return is_array() ? m_value.array : nullptr;
+    }
+
+    /// get a pointer to the value (string)
+    string_t* get_impl_ptr(string_t* /*unused*/) noexcept
+    {
+        return is_string() ? m_value.string : nullptr;
+    }
+
+    /// get a pointer to the value (string)
+    constexpr const string_t* get_impl_ptr(const string_t* /*unused*/) const noexcept
+    {
+        return is_string() ? m_value.string : nullptr;
+    }
+
+    /// get a pointer to the value (boolean)
+    boolean_t* get_impl_ptr(boolean_t* /*unused*/) noexcept
+    {
+        return is_boolean() ? &m_value.boolean : nullptr;
+    }
+
+    /// get a pointer to the value (boolean)
+    constexpr const boolean_t* get_impl_ptr(const boolean_t* /*unused*/) const noexcept
+    {
+        return is_boolean() ? &m_value.boolean : nullptr;
+    }
+
+    /// get a pointer to the value (integer number)
+    number_integer_t* get_impl_ptr(number_integer_t* /*unused*/) noexcept
+    {
+        return is_number_integer() ? &m_value.number_integer : nullptr;
+    }
+
+    /// get a pointer to the value (integer number)
+    constexpr const number_integer_t* get_impl_ptr(const number_integer_t* /*unused*/) const noexcept
+    {
+        return is_number_integer() ? &m_value.number_integer : nullptr;
+    }
+
+    /// get a pointer to the value (unsigned number)
+    number_unsigned_t* get_impl_ptr(number_unsigned_t* /*unused*/) noexcept
+    {
+        return is_number_unsigned() ? &m_value.number_unsigned : nullptr;
+    }
+
+    /// get a pointer to the value (unsigned number)
+    constexpr const number_unsigned_t* get_impl_ptr(const number_unsigned_t* /*unused*/) const noexcept
+    {
+        return is_number_unsigned() ? &m_value.number_unsigned : nullptr;
+    }
+
+    /// get a pointer to the value (floating-point number)
+    number_float_t* get_impl_ptr(number_float_t* /*unused*/) noexcept
+    {
+        return is_number_float() ? &m_value.number_float : nullptr;
+    }
+
+    /// get a pointer to the value (floating-point number)
+    constexpr const number_float_t* get_impl_ptr(const number_float_t* /*unused*/) const noexcept
+    {
+        return is_number_float() ? &m_value.number_float : nullptr;
+    }
+
+    /*!
+    @brief helper function to implement get_ref()
+
+    This function helps to implement get_ref() without code duplication for
+    const and non-const overloads
+
+    @tparam ThisType will be deduced as `basic_json` or `const basic_json`
+
+    @throw type_error.303 if ReferenceType does not match underlying value
+    type of the current JSON
+    */
+    template<typename ReferenceType, typename ThisType>
+    static ReferenceType get_ref_impl(ThisType& obj)
+    {
+        // delegate the call to get_ptr<>()
+        auto ptr = obj.template get_ptr<typename std::add_pointer<ReferenceType>::type>();
+
+        if (JSON_HEDLEY_LIKELY(ptr != nullptr))
+        {
+            return *ptr;
+        }
+
+        JSON_THROW(type_error::create(303, "incompatible ReferenceType for get_ref, actual type is " + std::string(obj.type_name())));
+    }
+
+  public:
+    /// @name value access
+    /// Direct access to the stored value of a JSON value.
+    /// @{
+
+    /*!
+    @brief get special-case overload
+
+    This overloads avoids a lot of template boilerplate, it can be seen as the
+    identity method
+
+    @tparam BasicJsonType == @ref basic_json
+
+    @return a copy of *this
+
+    @complexity Constant.
+
+    @since version 2.1.0
+    */
+    template<typename BasicJsonType, detail::enable_if_t<
+                 std::is_same<typename std::remove_const<BasicJsonType>::type, basic_json_t>::value,
+                 int> = 0>
+    basic_json get() const
+    {
+        return *this;
+    }
+
+    /*!
+    @brief get special-case overload
+
+    This overloads converts the current @ref basic_json in a different
+    @ref basic_json type
+
+    @tparam BasicJsonType == @ref basic_json
+
+    @return a copy of *this, converted into @tparam BasicJsonType
+
+    @complexity Depending on the implementation of the called `from_json()`
+                method.
+
+    @since version 3.2.0
+    */
+    template<typename BasicJsonType, detail::enable_if_t<
+                 not std::is_same<BasicJsonType, basic_json>::value and
+                 detail::is_basic_json<BasicJsonType>::value, int> = 0>
+    BasicJsonType get() const
+    {
+        return *this;
+    }
+
+    /*!
+    @brief get a value (explicit)
+
+    Explicit type conversion between the JSON value and a compatible value
+    which is [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible)
+    and [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible).
+    The value is converted by calling the @ref json_serializer<ValueType>
+    `from_json()` method.
+
+    The function is equivalent to executing
+    @code {.cpp}
+    ValueType ret;
+    JSONSerializer<ValueType>::from_json(*this, ret);
+    return ret;
+    @endcode
+
+    This overloads is chosen if:
+    - @a ValueType is not @ref basic_json,
+    - @ref json_serializer<ValueType> has a `from_json()` method of the form
+      `void from_json(const basic_json&, ValueType&)`, and
+    - @ref json_serializer<ValueType> does not have a `from_json()` method of
+      the form `ValueType from_json(const basic_json&)`
+
+    @tparam ValueTypeCV the provided value type
+    @tparam ValueType the returned value type
+
+    @return copy of the JSON value, converted to @a ValueType
+
+    @throw what @ref json_serializer<ValueType> `from_json()` method throws
+
+    @liveexample{The example below shows several conversions from JSON values
+    to other types. There a few things to note: (1) Floating-point numbers can
+    be converted to integers\, (2) A JSON array can be converted to a standard
+    `std::vector<short>`\, (3) A JSON object can be converted to C++
+    associative containers such as `std::unordered_map<std::string\,
+    json>`.,get__ValueType_const}
+
+    @since version 2.1.0
+    */
+    template<typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>,
+             detail::enable_if_t <
+                 not detail::is_basic_json<ValueType>::value and
+                 detail::has_from_json<basic_json_t, ValueType>::value and
+                 not detail::has_non_default_from_json<basic_json_t, ValueType>::value,
+                 int> = 0>
+    ValueType get() const noexcept(noexcept(
+                                       JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>())))
+    {
+        // we cannot static_assert on ValueTypeCV being non-const, because
+        // there is support for get<const basic_json_t>(), which is why we
+        // still need the uncvref
+        static_assert(not std::is_reference<ValueTypeCV>::value,
+                      "get() cannot be used with reference types, you might want to use get_ref()");
+        static_assert(std::is_default_constructible<ValueType>::value,
+                      "types must be DefaultConstructible when used with get()");
+
+        ValueType ret;
+        JSONSerializer<ValueType>::from_json(*this, ret);
+        return ret;
+    }
+
+    /*!
+    @brief get a value (explicit); special case
+
+    Explicit type conversion between the JSON value and a compatible value
+    which is **not** [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible)
+    and **not** [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible).
+    The value is converted by calling the @ref json_serializer<ValueType>
+    `from_json()` method.
+
+    The function is equivalent to executing
+    @code {.cpp}
+    return JSONSerializer<ValueTypeCV>::from_json(*this);
+    @endcode
+
+    This overloads is chosen if:
+    - @a ValueType is not @ref basic_json and
+    - @ref json_serializer<ValueType> has a `from_json()` method of the form
+      `ValueType from_json(const basic_json&)`
+
+    @note If @ref json_serializer<ValueType> has both overloads of
+    `from_json()`, this one is chosen.
+
+    @tparam ValueTypeCV the provided value type
+    @tparam ValueType the returned value type
+
+    @return copy of the JSON value, converted to @a ValueType
+
+    @throw what @ref json_serializer<ValueType> `from_json()` method throws
+
+    @since version 2.1.0
+    */
+    template<typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>,
+             detail::enable_if_t<not std::is_same<basic_json_t, ValueType>::value and
+                                 detail::has_non_default_from_json<basic_json_t, ValueType>::value,
+                                 int> = 0>
+    ValueType get() const noexcept(noexcept(
+                                       JSONSerializer<ValueTypeCV>::from_json(std::declval<const basic_json_t&>())))
+    {
+        static_assert(not std::is_reference<ValueTypeCV>::value,
+                      "get() cannot be used with reference types, you might want to use get_ref()");
+        return JSONSerializer<ValueTypeCV>::from_json(*this);
+    }
+
+    /*!
+    @brief get a value (explicit)
+
+    Explicit type conversion between the JSON value and a compatible value.
+    The value is filled into the input parameter by calling the @ref json_serializer<ValueType>
+    `from_json()` method.
+
+    The function is equivalent to executing
+    @code {.cpp}
+    ValueType v;
+    JSONSerializer<ValueType>::from_json(*this, v);
+    @endcode
+
+    This overloads is chosen if:
+    - @a ValueType is not @ref basic_json,
+    - @ref json_serializer<ValueType> has a `from_json()` method of the form
+      `void from_json(const basic_json&, ValueType&)`, and
+
+    @tparam ValueType the input parameter type.
+
+    @return the input parameter, allowing chaining calls.
+
+    @throw what @ref json_serializer<ValueType> `from_json()` method throws
+
+    @liveexample{The example below shows several conversions from JSON values
+    to other types. There a few things to note: (1) Floating-point numbers can
+    be converted to integers\, (2) A JSON array can be converted to a standard
+    `std::vector<short>`\, (3) A JSON object can be converted to C++
+    associative containers such as `std::unordered_map<std::string\,
+    json>`.,get_to}
+
+    @since version 3.3.0
+    */
+    template<typename ValueType,
+             detail::enable_if_t <
+                 not detail::is_basic_json<ValueType>::value and
+                 detail::has_from_json<basic_json_t, ValueType>::value,
+                 int> = 0>
+    ValueType & get_to(ValueType& v) const noexcept(noexcept(
+                JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), v)))
+    {
+        JSONSerializer<ValueType>::from_json(*this, v);
+        return v;
+    }
+
+    template <
+        typename T, std::size_t N,
+        typename Array = T (&)[N],
+        detail::enable_if_t <
+            detail::has_from_json<basic_json_t, Array>::value, int > = 0 >
+    Array get_to(T (&v)[N]) const
+    noexcept(noexcept(JSONSerializer<Array>::from_json(
+                          std::declval<const basic_json_t&>(), v)))
+    {
+        JSONSerializer<Array>::from_json(*this, v);
+        return v;
+    }
+
+
+    /*!
+    @brief get a pointer value (implicit)
+
+    Implicit pointer access to the internally stored JSON value. No copies are
+    made.
+
+    @warning Writing data to the pointee of the result yields an undefined
+    state.
+
+    @tparam PointerType pointer type; must be a pointer to @ref array_t, @ref
+    object_t, @ref string_t, @ref boolean_t, @ref number_integer_t,
+    @ref number_unsigned_t, or @ref number_float_t. Enforced by a static
+    assertion.
+
+    @return pointer to the internally stored JSON value if the requested
+    pointer type @a PointerType fits to the JSON value; `nullptr` otherwise
+
+    @complexity Constant.
+
+    @liveexample{The example below shows how pointers to internal values of a
+    JSON value can be requested. Note that no type conversions are made and a
+    `nullptr` is returned if the value and the requested pointer type does not
+    match.,get_ptr}
+
+    @since version 1.0.0
+    */
+    template<typename PointerType, typename std::enable_if<
+                 std::is_pointer<PointerType>::value, int>::type = 0>
+    auto get_ptr() noexcept -> decltype(std::declval<basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
+    {
+        // delegate the call to get_impl_ptr<>()
+        return get_impl_ptr(static_cast<PointerType>(nullptr));
+    }
+
+    /*!
+    @brief get a pointer value (implicit)
+    @copydoc get_ptr()
+    */
+    template<typename PointerType, typename std::enable_if<
+                 std::is_pointer<PointerType>::value and
+                 std::is_const<typename std::remove_pointer<PointerType>::type>::value, int>::type = 0>
+    constexpr auto get_ptr() const noexcept -> decltype(std::declval<const basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
+    {
+        // delegate the call to get_impl_ptr<>() const
+        return get_impl_ptr(static_cast<PointerType>(nullptr));
+    }
+
+    /*!
+    @brief get a pointer value (explicit)
+
+    Explicit pointer access to the internally stored JSON value. No copies are
+    made.
+
+    @warning The pointer becomes invalid if the underlying JSON object
+    changes.
+
+    @tparam PointerType pointer type; must be a pointer to @ref array_t, @ref
+    object_t, @ref string_t, @ref boolean_t, @ref number_integer_t,
+    @ref number_unsigned_t, or @ref number_float_t.
+
+    @return pointer to the internally stored JSON value if the requested
+    pointer type @a PointerType fits to the JSON value; `nullptr` otherwise
+
+    @complexity Constant.
+
+    @liveexample{The example below shows how pointers to internal values of a
+    JSON value can be requested. Note that no type conversions are made and a
+    `nullptr` is returned if the value and the requested pointer type does not
+    match.,get__PointerType}
+
+    @sa @ref get_ptr() for explicit pointer-member access
+
+    @since version 1.0.0
+    */
+    template<typename PointerType, typename std::enable_if<
+                 std::is_pointer<PointerType>::value, int>::type = 0>
+    auto get() noexcept -> decltype(std::declval<basic_json_t&>().template get_ptr<PointerType>())
+    {
+        // delegate the call to get_ptr
+        return get_ptr<PointerType>();
+    }
+
+    /*!
+    @brief get a pointer value (explicit)
+    @copydoc get()
+    */
+    template<typename PointerType, typename std::enable_if<
+                 std::is_pointer<PointerType>::value, int>::type = 0>
+    constexpr auto get() const noexcept -> decltype(std::declval<const basic_json_t&>().template get_ptr<PointerType>())
+    {
+        // delegate the call to get_ptr
+        return get_ptr<PointerType>();
+    }
+
+    /*!
+    @brief get a reference value (implicit)
+
+    Implicit reference access to the internally stored JSON value. No copies
+    are made.
+
+    @warning Writing data to the referee of the result yields an undefined
+    state.
+
+    @tparam ReferenceType reference type; must be a reference to @ref array_t,
+    @ref object_t, @ref string_t, @ref boolean_t, @ref number_integer_t, or
+    @ref number_float_t. Enforced by static assertion.
+
+    @return reference to the internally stored JSON value if the requested
+    reference type @a ReferenceType fits to the JSON value; throws
+    type_error.303 otherwise
+
+    @throw type_error.303 in case passed type @a ReferenceType is incompatible
+    with the stored JSON value; see example below
+
+    @complexity Constant.
+
+    @liveexample{The example shows several calls to `get_ref()`.,get_ref}
+
+    @since version 1.1.0
+    */
+    template<typename ReferenceType, typename std::enable_if<
+                 std::is_reference<ReferenceType>::value, int>::type = 0>
+    ReferenceType get_ref()
+    {
+        // delegate call to get_ref_impl
+        return get_ref_impl<ReferenceType>(*this);
+    }
+
+    /*!
+    @brief get a reference value (implicit)
+    @copydoc get_ref()
+    */
+    template<typename ReferenceType, typename std::enable_if<
+                 std::is_reference<ReferenceType>::value and
+                 std::is_const<typename std::remove_reference<ReferenceType>::type>::value, int>::type = 0>
+    ReferenceType get_ref() const
+    {
+        // delegate call to get_ref_impl
+        return get_ref_impl<ReferenceType>(*this);
+    }
+
+    /*!
+    @brief get a value (implicit)
+
+    Implicit type conversion between the JSON value and a compatible value.
+    The call is realized by calling @ref get() const.
+
+    @tparam ValueType non-pointer type compatible to the JSON value, for
+    instance `int` for JSON integer numbers, `bool` for JSON booleans, or
+    `std::vector` types for JSON arrays. The character type of @ref string_t
+    as well as an initializer list of this type is excluded to avoid
+    ambiguities as these types implicitly convert to `std::string`.
+
+    @return copy of the JSON value, converted to type @a ValueType
+
+    @throw type_error.302 in case passed type @a ValueType is incompatible
+    to the JSON value type (e.g., the JSON value is of type boolean, but a
+    string is requested); see example below
+
+    @complexity Linear in the size of the JSON value.
+
+    @liveexample{The example below shows several conversions from JSON values
+    to other types. There a few things to note: (1) Floating-point numbers can
+    be converted to integers\, (2) A JSON array can be converted to a standard
+    `std::vector<short>`\, (3) A JSON object can be converted to C++
+    associative containers such as `std::unordered_map<std::string\,
+    json>`.,operator__ValueType}
+
+    @since version 1.0.0
+    */
+    template < typename ValueType, typename std::enable_if <
+                   not std::is_pointer<ValueType>::value and
+                   not std::is_same<ValueType, detail::json_ref<basic_json>>::value and
+                   not std::is_same<ValueType, typename string_t::value_type>::value and
+                   not detail::is_basic_json<ValueType>::value
+
+#ifndef _MSC_VER  // fix for issue #167 operator<< ambiguity under VS2015
+                   and not std::is_same<ValueType, std::initializer_list<typename string_t::value_type>>::value
+#if defined(JSON_HAS_CPP_17) && (defined(__GNUC__) || (defined(_MSC_VER) and _MSC_VER <= 1914))
+                   and not std::is_same<ValueType, typename std::string_view>::value
+#endif
+#endif
+                   and detail::is_detected<detail::get_template_function, const basic_json_t&, ValueType>::value
+                   , int >::type = 0 >
+    operator ValueType() const
+    {
+        // delegate the call to get<>() const
+        return get<ValueType>();
+    }
+
+    /// @}
+
+
+    ////////////////////
+    // element access //
+    ////////////////////
+
+    /// @name element access
+    /// Access to the JSON value.
+    /// @{
+
+    /*!
+    @brief access specified array element with bounds checking
+
+    Returns a reference to the element at specified location @a idx, with
+    bounds checking.
+
+    @param[in] idx  index of the element to access
+
+    @return reference to the element at index @a idx
+
+    @throw type_error.304 if the JSON value is not an array; in this case,
+    calling `at` with an index makes no sense. See example below.
+    @throw out_of_range.401 if the index @a idx is out of range of the array;
+    that is, `idx >= size()`. See example below.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes in the JSON value.
+
+    @complexity Constant.
+
+    @since version 1.0.0
+
+    @liveexample{The example below shows how array elements can be read and
+    written using `at()`. It also demonstrates the different exceptions that
+    can be thrown.,at__size_type}
+    */
+    reference at(size_type idx)
+    {
+        // at only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            JSON_TRY
+            {
+                return m_value.array->at(idx);
+            }
+            JSON_CATCH (std::out_of_range&)
+            {
+                // create better exception explanation
+                JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));
+            }
+        }
+        else
+        {
+            JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name())));
+        }
+    }
+
+    /*!
+    @brief access specified array element with bounds checking
+
+    Returns a const reference to the element at specified location @a idx,
+    with bounds checking.
+
+    @param[in] idx  index of the element to access
+
+    @return const reference to the element at index @a idx
+
+    @throw type_error.304 if the JSON value is not an array; in this case,
+    calling `at` with an index makes no sense. See example below.
+    @throw out_of_range.401 if the index @a idx is out of range of the array;
+    that is, `idx >= size()`. See example below.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes in the JSON value.
+
+    @complexity Constant.
+
+    @since version 1.0.0
+
+    @liveexample{The example below shows how array elements can be read using
+    `at()`. It also demonstrates the different exceptions that can be thrown.,
+    at__size_type_const}
+    */
+    const_reference at(size_type idx) const
+    {
+        // at only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            JSON_TRY
+            {
+                return m_value.array->at(idx);
+            }
+            JSON_CATCH (std::out_of_range&)
+            {
+                // create better exception explanation
+                JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));
+            }
+        }
+        else
+        {
+            JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name())));
+        }
+    }
+
+    /*!
+    @brief access specified object element with bounds checking
+
+    Returns a reference to the element at with specified key @a key, with
+    bounds checking.
+
+    @param[in] key  key of the element to access
+
+    @return reference to the element at key @a key
+
+    @throw type_error.304 if the JSON value is not an object; in this case,
+    calling `at` with a key makes no sense. See example below.
+    @throw out_of_range.403 if the key @a key is is not stored in the object;
+    that is, `find(key) == end()`. See example below.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes in the JSON value.
+
+    @complexity Logarithmic in the size of the container.
+
+    @sa @ref operator[](const typename object_t::key_type&) for unchecked
+    access by reference
+    @sa @ref value() for access by value with a default value
+
+    @since version 1.0.0
+
+    @liveexample{The example below shows how object elements can be read and
+    written using `at()`. It also demonstrates the different exceptions that
+    can be thrown.,at__object_t_key_type}
+    */
+    reference at(const typename object_t::key_type& key)
+    {
+        // at only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            JSON_TRY
+            {
+                return m_value.object->at(key);
+            }
+            JSON_CATCH (std::out_of_range&)
+            {
+                // create better exception explanation
+                JSON_THROW(out_of_range::create(403, "key '" + key + "' not found"));
+            }
+        }
+        else
+        {
+            JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name())));
+        }
+    }
+
+    /*!
+    @brief access specified object element with bounds checking
+
+    Returns a const reference to the element at with specified key @a key,
+    with bounds checking.
+
+    @param[in] key  key of the element to access
+
+    @return const reference to the element at key @a key
+
+    @throw type_error.304 if the JSON value is not an object; in this case,
+    calling `at` with a key makes no sense. See example below.
+    @throw out_of_range.403 if the key @a key is is not stored in the object;
+    that is, `find(key) == end()`. See example below.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes in the JSON value.
+
+    @complexity Logarithmic in the size of the container.
+
+    @sa @ref operator[](const typename object_t::key_type&) for unchecked
+    access by reference
+    @sa @ref value() for access by value with a default value
+
+    @since version 1.0.0
+
+    @liveexample{The example below shows how object elements can be read using
+    `at()`. It also demonstrates the different exceptions that can be thrown.,
+    at__object_t_key_type_const}
+    */
+    const_reference at(const typename object_t::key_type& key) const
+    {
+        // at only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            JSON_TRY
+            {
+                return m_value.object->at(key);
+            }
+            JSON_CATCH (std::out_of_range&)
+            {
+                // create better exception explanation
+                JSON_THROW(out_of_range::create(403, "key '" + key + "' not found"));
+            }
+        }
+        else
+        {
+            JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name())));
+        }
+    }
+
+    /*!
+    @brief access specified array element
+
+    Returns a reference to the element at specified location @a idx.
+
+    @note If @a idx is beyond the range of the array (i.e., `idx >= size()`),
+    then the array is silently filled up with `null` values to make `idx` a
+    valid reference to the last stored element.
+
+    @param[in] idx  index of the element to access
+
+    @return reference to the element at index @a idx
+
+    @throw type_error.305 if the JSON value is not an array or null; in that
+    cases, using the [] operator with an index makes no sense.
+
+    @complexity Constant if @a idx is in the range of the array. Otherwise
+    linear in `idx - size()`.
+
+    @liveexample{The example below shows how array elements can be read and
+    written using `[]` operator. Note the addition of `null`
+    values.,operatorarray__size_type}
+
+    @since version 1.0.0
+    */
+    reference operator[](size_type idx)
+    {
+        // implicitly convert null value to an empty array
+        if (is_null())
+        {
+            m_type = value_t::array;
+            m_value.array = create<array_t>();
+            assert_invariant();
+        }
+
+        // operator[] only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            // fill up array with null values if given idx is outside range
+            if (idx >= m_value.array->size())
+            {
+                m_value.array->insert(m_value.array->end(),
+                                      idx - m_value.array->size() + 1,
+                                      basic_json());
+            }
+
+            return m_value.array->operator[](idx);
+        }
+
+        JSON_THROW(type_error::create(305, "cannot use operator[] with a numeric argument with " + std::string(type_name())));
+    }
+
+    /*!
+    @brief access specified array element
+
+    Returns a const reference to the element at specified location @a idx.
+
+    @param[in] idx  index of the element to access
+
+    @return const reference to the element at index @a idx
+
+    @throw type_error.305 if the JSON value is not an array; in that case,
+    using the [] operator with an index makes no sense.
+
+    @complexity Constant.
+
+    @liveexample{The example below shows how array elements can be read using
+    the `[]` operator.,operatorarray__size_type_const}
+
+    @since version 1.0.0
+    */
+    const_reference operator[](size_type idx) const
+    {
+        // const operator[] only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            return m_value.array->operator[](idx);
+        }
+
+        JSON_THROW(type_error::create(305, "cannot use operator[] with a numeric argument with " + std::string(type_name())));
+    }
+
+    /*!
+    @brief access specified object element
+
+    Returns a reference to the element at with specified key @a key.
+
+    @note If @a key is not found in the object, then it is silently added to
+    the object and filled with a `null` value to make `key` a valid reference.
+    In case the value was `null` before, it is converted to an object.
+
+    @param[in] key  key of the element to access
+
+    @return reference to the element at key @a key
+
+    @throw type_error.305 if the JSON value is not an object or null; in that
+    cases, using the [] operator with a key makes no sense.
+
+    @complexity Logarithmic in the size of the container.
+
+    @liveexample{The example below shows how object elements can be read and
+    written using the `[]` operator.,operatorarray__key_type}
+
+    @sa @ref at(const typename object_t::key_type&) for access by reference
+    with range checking
+    @sa @ref value() for access by value with a default value
+
+    @since version 1.0.0
+    */
+    reference operator[](const typename object_t::key_type& key)
+    {
+        // implicitly convert null value to an empty object
+        if (is_null())
+        {
+            m_type = value_t::object;
+            m_value.object = create<object_t>();
+            assert_invariant();
+        }
+
+        // operator[] only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            return m_value.object->operator[](key);
+        }
+
+        JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name())));
+    }
+
+    /*!
+    @brief read-only access specified object element
+
+    Returns a const reference to the element at with specified key @a key. No
+    bounds checking is performed.
+
+    @warning If the element with key @a key does not exist, the behavior is
+    undefined.
+
+    @param[in] key  key of the element to access
+
+    @return const reference to the element at key @a key
+
+    @pre The element with key @a key must exist. **This precondition is
+         enforced with an assertion.**
+
+    @throw type_error.305 if the JSON value is not an object; in that case,
+    using the [] operator with a key makes no sense.
+
+    @complexity Logarithmic in the size of the container.
+
+    @liveexample{The example below shows how object elements can be read using
+    the `[]` operator.,operatorarray__key_type_const}
+
+    @sa @ref at(const typename object_t::key_type&) for access by reference
+    with range checking
+    @sa @ref value() for access by value with a default value
+
+    @since version 1.0.0
+    */
+    const_reference operator[](const typename object_t::key_type& key) const
+    {
+        // const operator[] only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            assert(m_value.object->find(key) != m_value.object->end());
+            return m_value.object->find(key)->second;
+        }
+
+        JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name())));
+    }
+
+    /*!
+    @brief access specified object element
+
+    Returns a reference to the element at with specified key @a key.
+
+    @note If @a key is not found in the object, then it is silently added to
+    the object and filled with a `null` value to make `key` a valid reference.
+    In case the value was `null` before, it is converted to an object.
+
+    @param[in] key  key of the element to access
+
+    @return reference to the element at key @a key
+
+    @throw type_error.305 if the JSON value is not an object or null; in that
+    cases, using the [] operator with a key makes no sense.
+
+    @complexity Logarithmic in the size of the container.
+
+    @liveexample{The example below shows how object elements can be read and
+    written using the `[]` operator.,operatorarray__key_type}
+
+    @sa @ref at(const typename object_t::key_type&) for access by reference
+    with range checking
+    @sa @ref value() for access by value with a default value
+
+    @since version 1.1.0
+    */
+    template<typename T>
+    JSON_HEDLEY_NON_NULL(2)
+    reference operator[](T* key)
+    {
+        // implicitly convert null to object
+        if (is_null())
+        {
+            m_type = value_t::object;
+            m_value = value_t::object;
+            assert_invariant();
+        }
+
+        // at only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            return m_value.object->operator[](key);
+        }
+
+        JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name())));
+    }
+
+    /*!
+    @brief read-only access specified object element
+
+    Returns a const reference to the element at with specified key @a key. No
+    bounds checking is performed.
+
+    @warning If the element with key @a key does not exist, the behavior is
+    undefined.
+
+    @param[in] key  key of the element to access
+
+    @return const reference to the element at key @a key
+
+    @pre The element with key @a key must exist. **This precondition is
+         enforced with an assertion.**
+
+    @throw type_error.305 if the JSON value is not an object; in that case,
+    using the [] operator with a key makes no sense.
+
+    @complexity Logarithmic in the size of the container.
+
+    @liveexample{The example below shows how object elements can be read using
+    the `[]` operator.,operatorarray__key_type_const}
+
+    @sa @ref at(const typename object_t::key_type&) for access by reference
+    with range checking
+    @sa @ref value() for access by value with a default value
+
+    @since version 1.1.0
+    */
+    template<typename T>
+    JSON_HEDLEY_NON_NULL(2)
+    const_reference operator[](T* key) const
+    {
+        // at only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            assert(m_value.object->find(key) != m_value.object->end());
+            return m_value.object->find(key)->second;
+        }
+
+        JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name())));
+    }
+
+    /*!
+    @brief access specified object element with default value
+
+    Returns either a copy of an object's element at the specified key @a key
+    or a given default value if no element with key @a key exists.
+
+    The function is basically equivalent to executing
+    @code {.cpp}
+    try {
+        return at(key);
+    } catch(out_of_range) {
+        return default_value;
+    }
+    @endcode
+
+    @note Unlike @ref at(const typename object_t::key_type&), this function
+    does not throw if the given key @a key was not found.
+
+    @note Unlike @ref operator[](const typename object_t::key_type& key), this
+    function does not implicitly add an element to the position defined by @a
+    key. This function is furthermore also applicable to const objects.
+
+    @param[in] key  key of the element to access
+    @param[in] default_value  the value to return if @a key is not found
+
+    @tparam ValueType type compatible to JSON values, for instance `int` for
+    JSON integer numbers, `bool` for JSON booleans, or `std::vector` types for
+    JSON arrays. Note the type of the expected value at @a key and the default
+    value @a default_value must be compatible.
+
+    @return copy of the element at key @a key or @a default_value if @a key
+    is not found
+
+    @throw type_error.302 if @a default_value does not match the type of the
+    value at @a key
+    @throw type_error.306 if the JSON value is not an object; in that case,
+    using `value()` with a key makes no sense.
+
+    @complexity Logarithmic in the size of the container.
+
+    @liveexample{The example below shows how object elements can be queried
+    with a default value.,basic_json__value}
+
+    @sa @ref at(const typename object_t::key_type&) for access by reference
+    with range checking
+    @sa @ref operator[](const typename object_t::key_type&) for unchecked
+    access by reference
+
+    @since version 1.0.0
+    */
+    template<class ValueType, typename std::enable_if<
+                 std::is_convertible<basic_json_t, ValueType>::value, int>::type = 0>
+    ValueType value(const typename object_t::key_type& key, const ValueType& default_value) const
+    {
+        // at only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            // if key is found, return value and given default value otherwise
+            const auto it = find(key);
+            if (it != end())
+            {
+                return *it;
+            }
+
+            return default_value;
+        }
+
+        JSON_THROW(type_error::create(306, "cannot use value() with " + std::string(type_name())));
+    }
+
+    /*!
+    @brief overload for a default value of type const char*
+    @copydoc basic_json::value(const typename object_t::key_type&, const ValueType&) const
+    */
+    string_t value(const typename object_t::key_type& key, const char* default_value) const
+    {
+        return value(key, string_t(default_value));
+    }
+
+    /*!
+    @brief access specified object element via JSON Pointer with default value
+
+    Returns either a copy of an object's element at the specified key @a key
+    or a given default value if no element with key @a key exists.
+
+    The function is basically equivalent to executing
+    @code {.cpp}
+    try {
+        return at(ptr);
+    } catch(out_of_range) {
+        return default_value;
+    }
+    @endcode
+
+    @note Unlike @ref at(const json_pointer&), this function does not throw
+    if the given key @a key was not found.
+
+    @param[in] ptr  a JSON pointer to the element to access
+    @param[in] default_value  the value to return if @a ptr found no value
+
+    @tparam ValueType type compatible to JSON values, for instance `int` for
+    JSON integer numbers, `bool` for JSON booleans, or `std::vector` types for
+    JSON arrays. Note the type of the expected value at @a key and the default
+    value @a default_value must be compatible.
+
+    @return copy of the element at key @a key or @a default_value if @a key
+    is not found
+
+    @throw type_error.302 if @a default_value does not match the type of the
+    value at @a ptr
+    @throw type_error.306 if the JSON value is not an object; in that case,
+    using `value()` with a key makes no sense.
+
+    @complexity Logarithmic in the size of the container.
+
+    @liveexample{The example below shows how object elements can be queried
+    with a default value.,basic_json__value_ptr}
+
+    @sa @ref operator[](const json_pointer&) for unchecked access by reference
+
+    @since version 2.0.2
+    */
+    template<class ValueType, typename std::enable_if<
+                 std::is_convertible<basic_json_t, ValueType>::value, int>::type = 0>
+    ValueType value(const json_pointer& ptr, const ValueType& default_value) const
+    {
+        // at only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            // if pointer resolves a value, return it or use default value
+            JSON_TRY
+            {
+                return ptr.get_checked(this);
+            }
+            JSON_INTERNAL_CATCH (out_of_range&)
+            {
+                return default_value;
+            }
+        }
+
+        JSON_THROW(type_error::create(306, "cannot use value() with " + std::string(type_name())));
+    }
+
+    /*!
+    @brief overload for a default value of type const char*
+    @copydoc basic_json::value(const json_pointer&, ValueType) const
+    */
+    JSON_HEDLEY_NON_NULL(3)
+    string_t value(const json_pointer& ptr, const char* default_value) const
+    {
+        return value(ptr, string_t(default_value));
+    }
+
+    /*!
+    @brief access the first element
+
+    Returns a reference to the first element in the container. For a JSON
+    container `c`, the expression `c.front()` is equivalent to `*c.begin()`.
+
+    @return In case of a structured type (array or object), a reference to the
+    first element is returned. In case of number, string, or boolean values, a
+    reference to the value is returned.
+
+    @complexity Constant.
+
+    @pre The JSON value must not be `null` (would throw `std::out_of_range`)
+    or an empty array or object (undefined behavior, **guarded by
+    assertions**).
+    @post The JSON value remains unchanged.
+
+    @throw invalid_iterator.214 when called on `null` value
+
+    @liveexample{The following code shows an example for `front()`.,front}
+
+    @sa @ref back() -- access the last element
+
+    @since version 1.0.0
+    */
+    reference front()
+    {
+        return *begin();
+    }
+
+    /*!
+    @copydoc basic_json::front()
+    */
+    const_reference front() const
+    {
+        return *cbegin();
+    }
+
+    /*!
+    @brief access the last element
+
+    Returns a reference to the last element in the container. For a JSON
+    container `c`, the expression `c.back()` is equivalent to
+    @code {.cpp}
+    auto tmp = c.end();
+    --tmp;
+    return *tmp;
+    @endcode
+
+    @return In case of a structured type (array or object), a reference to the
+    last element is returned. In case of number, string, or boolean values, a
+    reference to the value is returned.
+
+    @complexity Constant.
+
+    @pre The JSON value must not be `null` (would throw `std::out_of_range`)
+    or an empty array or object (undefined behavior, **guarded by
+    assertions**).
+    @post The JSON value remains unchanged.
+
+    @throw invalid_iterator.214 when called on a `null` value. See example
+    below.
+
+    @liveexample{The following code shows an example for `back()`.,back}
+
+    @sa @ref front() -- access the first element
+
+    @since version 1.0.0
+    */
+    reference back()
+    {
+        auto tmp = end();
+        --tmp;
+        return *tmp;
+    }
+
+    /*!
+    @copydoc basic_json::back()
+    */
+    const_reference back() const
+    {
+        auto tmp = cend();
+        --tmp;
+        return *tmp;
+    }
+
+    /*!
+    @brief remove element given an iterator
+
+    Removes the element specified by iterator @a pos. The iterator @a pos must
+    be valid and dereferenceable. Thus the `end()` iterator (which is valid,
+    but is not dereferenceable) cannot be used as a value for @a pos.
+
+    If called on a primitive type other than `null`, the resulting JSON value
+    will be `null`.
+
+    @param[in] pos iterator to the element to remove
+    @return Iterator following the last removed element. If the iterator @a
+    pos refers to the last element, the `end()` iterator is returned.
+
+    @tparam IteratorType an @ref iterator or @ref const_iterator
+
+    @post Invalidates iterators and references at or after the point of the
+    erase, including the `end()` iterator.
+
+    @throw type_error.307 if called on a `null` value; example: `"cannot use
+    erase() with null"`
+    @throw invalid_iterator.202 if called on an iterator which does not belong
+    to the current JSON value; example: `"iterator does not fit current
+    value"`
+    @throw invalid_iterator.205 if called on a primitive type with invalid
+    iterator (i.e., any iterator which is not `begin()`); example: `"iterator
+    out of range"`
+
+    @complexity The complexity depends on the type:
+    - objects: amortized constant
+    - arrays: linear in distance between @a pos and the end of the container
+    - strings: linear in the length of the string
+    - other types: constant
+
+    @liveexample{The example shows the result of `erase()` for different JSON
+    types.,erase__IteratorType}
+
+    @sa @ref erase(IteratorType, IteratorType) -- removes the elements in
+    the given range
+    @sa @ref erase(const typename object_t::key_type&) -- removes the element
+    from an object at the given key
+    @sa @ref erase(const size_type) -- removes the element from an array at
+    the given index
+
+    @since version 1.0.0
+    */
+    template<class IteratorType, typename std::enable_if<
+                 std::is_same<IteratorType, typename basic_json_t::iterator>::value or
+                 std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int>::type
+             = 0>
+    IteratorType erase(IteratorType pos)
+    {
+        // make sure iterator fits the current value
+        if (JSON_HEDLEY_UNLIKELY(this != pos.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
+        }
+
+        IteratorType result = end();
+
+        switch (m_type)
+        {
+            case value_t::boolean:
+            case value_t::number_float:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::string:
+            {
+                if (JSON_HEDLEY_UNLIKELY(not pos.m_it.primitive_iterator.is_begin()))
+                {
+                    JSON_THROW(invalid_iterator::create(205, "iterator out of range"));
+                }
+
+                if (is_string())
+                {
+                    AllocatorType<string_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.string);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.string, 1);
+                    m_value.string = nullptr;
+                }
+
+                m_type = value_t::null;
+                assert_invariant();
+                break;
+            }
+
+            case value_t::object:
+            {
+                result.m_it.object_iterator = m_value.object->erase(pos.m_it.object_iterator);
+                break;
+            }
+
+            case value_t::array:
+            {
+                result.m_it.array_iterator = m_value.array->erase(pos.m_it.array_iterator);
+                break;
+            }
+
+            default:
+                JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));
+        }
+
+        return result;
+    }
+
+    /*!
+    @brief remove elements given an iterator range
+
+    Removes the element specified by the range `[first; last)`. The iterator
+    @a first does not need to be dereferenceable if `first == last`: erasing
+    an empty range is a no-op.
+
+    If called on a primitive type other than `null`, the resulting JSON value
+    will be `null`.
+
+    @param[in] first iterator to the beginning of the range to remove
+    @param[in] last iterator past the end of the range to remove
+    @return Iterator following the last removed element. If the iterator @a
+    second refers to the last element, the `end()` iterator is returned.
+
+    @tparam IteratorType an @ref iterator or @ref const_iterator
+
+    @post Invalidates iterators and references at or after the point of the
+    erase, including the `end()` iterator.
+
+    @throw type_error.307 if called on a `null` value; example: `"cannot use
+    erase() with null"`
+    @throw invalid_iterator.203 if called on iterators which does not belong
+    to the current JSON value; example: `"iterators do not fit current value"`
+    @throw invalid_iterator.204 if called on a primitive type with invalid
+    iterators (i.e., if `first != begin()` and `last != end()`); example:
+    `"iterators out of range"`
+
+    @complexity The complexity depends on the type:
+    - objects: `log(size()) + std::distance(first, last)`
+    - arrays: linear in the distance between @a first and @a last, plus linear
+      in the distance between @a last and end of the container
+    - strings: linear in the length of the string
+    - other types: constant
+
+    @liveexample{The example shows the result of `erase()` for different JSON
+    types.,erase__IteratorType_IteratorType}
+
+    @sa @ref erase(IteratorType) -- removes the element at a given position
+    @sa @ref erase(const typename object_t::key_type&) -- removes the element
+    from an object at the given key
+    @sa @ref erase(const size_type) -- removes the element from an array at
+    the given index
+
+    @since version 1.0.0
+    */
+    template<class IteratorType, typename std::enable_if<
+                 std::is_same<IteratorType, typename basic_json_t::iterator>::value or
+                 std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int>::type
+             = 0>
+    IteratorType erase(IteratorType first, IteratorType last)
+    {
+        // make sure iterator fits the current value
+        if (JSON_HEDLEY_UNLIKELY(this != first.m_object or this != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(203, "iterators do not fit current value"));
+        }
+
+        IteratorType result = end();
+
+        switch (m_type)
+        {
+            case value_t::boolean:
+            case value_t::number_float:
+            case value_t::number_integer:
+            case value_t::number_unsigned:
+            case value_t::string:
+            {
+                if (JSON_HEDLEY_LIKELY(not first.m_it.primitive_iterator.is_begin()
+                                       or not last.m_it.primitive_iterator.is_end()))
+                {
+                    JSON_THROW(invalid_iterator::create(204, "iterators out of range"));
+                }
+
+                if (is_string())
+                {
+                    AllocatorType<string_t> alloc;
+                    std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.string);
+                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.string, 1);
+                    m_value.string = nullptr;
+                }
+
+                m_type = value_t::null;
+                assert_invariant();
+                break;
+            }
+
+            case value_t::object:
+            {
+                result.m_it.object_iterator = m_value.object->erase(first.m_it.object_iterator,
+                                              last.m_it.object_iterator);
+                break;
+            }
+
+            case value_t::array:
+            {
+                result.m_it.array_iterator = m_value.array->erase(first.m_it.array_iterator,
+                                             last.m_it.array_iterator);
+                break;
+            }
+
+            default:
+                JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));
+        }
+
+        return result;
+    }
+
+    /*!
+    @brief remove element from a JSON object given a key
+
+    Removes elements from a JSON object with the key value @a key.
+
+    @param[in] key value of the elements to remove
+
+    @return Number of elements removed. If @a ObjectType is the default
+    `std::map` type, the return value will always be `0` (@a key was not
+    found) or `1` (@a key was found).
+
+    @post References and iterators to the erased elements are invalidated.
+    Other references and iterators are not affected.
+
+    @throw type_error.307 when called on a type other than JSON object;
+    example: `"cannot use erase() with null"`
+
+    @complexity `log(size()) + count(key)`
+
+    @liveexample{The example shows the effect of `erase()`.,erase__key_type}
+
+    @sa @ref erase(IteratorType) -- removes the element at a given position
+    @sa @ref erase(IteratorType, IteratorType) -- removes the elements in
+    the given range
+    @sa @ref erase(const size_type) -- removes the element from an array at
+    the given index
+
+    @since version 1.0.0
+    */
+    size_type erase(const typename object_t::key_type& key)
+    {
+        // this erase only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            return m_value.object->erase(key);
+        }
+
+        JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));
+    }
+
+    /*!
+    @brief remove element from a JSON array given an index
+
+    Removes element from a JSON array at the index @a idx.
+
+    @param[in] idx index of the element to remove
+
+    @throw type_error.307 when called on a type other than JSON object;
+    example: `"cannot use erase() with null"`
+    @throw out_of_range.401 when `idx >= size()`; example: `"array index 17
+    is out of range"`
+
+    @complexity Linear in distance between @a idx and the end of the container.
+
+    @liveexample{The example shows the effect of `erase()`.,erase__size_type}
+
+    @sa @ref erase(IteratorType) -- removes the element at a given position
+    @sa @ref erase(IteratorType, IteratorType) -- removes the elements in
+    the given range
+    @sa @ref erase(const typename object_t::key_type&) -- removes the element
+    from an object at the given key
+
+    @since version 1.0.0
+    */
+    void erase(const size_type idx)
+    {
+        // this erase only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            if (JSON_HEDLEY_UNLIKELY(idx >= size()))
+            {
+                JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));
+            }
+
+            m_value.array->erase(m_value.array->begin() + static_cast<difference_type>(idx));
+        }
+        else
+        {
+            JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));
+        }
+    }
+
+    /// @}
+
+
+    ////////////
+    // lookup //
+    ////////////
+
+    /// @name lookup
+    /// @{
+
+    /*!
+    @brief find an element in a JSON object
+
+    Finds an element in a JSON object with key equivalent to @a key. If the
+    element is not found or the JSON value is not an object, end() is
+    returned.
+
+    @note This method always returns @ref end() when executed on a JSON type
+          that is not an object.
+
+    @param[in] key key value of the element to search for.
+
+    @return Iterator to an element with key equivalent to @a key. If no such
+    element is found or the JSON value is not an object, past-the-end (see
+    @ref end()) iterator is returned.
+
+    @complexity Logarithmic in the size of the JSON object.
+
+    @liveexample{The example shows how `find()` is used.,find__key_type}
+
+    @sa @ref contains(KeyT&&) const -- checks whether a key exists
+
+    @since version 1.0.0
+    */
+    template<typename KeyT>
+    iterator find(KeyT&& key)
+    {
+        auto result = end();
+
+        if (is_object())
+        {
+            result.m_it.object_iterator = m_value.object->find(std::forward<KeyT>(key));
+        }
+
+        return result;
+    }
+
+    /*!
+    @brief find an element in a JSON object
+    @copydoc find(KeyT&&)
+    */
+    template<typename KeyT>
+    const_iterator find(KeyT&& key) const
+    {
+        auto result = cend();
+
+        if (is_object())
+        {
+            result.m_it.object_iterator = m_value.object->find(std::forward<KeyT>(key));
+        }
+
+        return result;
+    }
+
+    /*!
+    @brief returns the number of occurrences of a key in a JSON object
+
+    Returns the number of elements with key @a key. If ObjectType is the
+    default `std::map` type, the return value will always be `0` (@a key was
+    not found) or `1` (@a key was found).
+
+    @note This method always returns `0` when executed on a JSON type that is
+          not an object.
+
+    @param[in] key key value of the element to count
+
+    @return Number of elements with key @a key. If the JSON value is not an
+    object, the return value will be `0`.
+
+    @complexity Logarithmic in the size of the JSON object.
+
+    @liveexample{The example shows how `count()` is used.,count}
+
+    @since version 1.0.0
+    */
+    template<typename KeyT>
+    size_type count(KeyT&& key) const
+    {
+        // return 0 for all nonobject types
+        return is_object() ? m_value.object->count(std::forward<KeyT>(key)) : 0;
+    }
+
+    /*!
+    @brief check the existence of an element in a JSON object
+
+    Check whether an element exists in a JSON object with key equivalent to
+    @a key. If the element is not found or the JSON value is not an object,
+    false is returned.
+
+    @note This method always returns false when executed on a JSON type
+          that is not an object.
+
+    @param[in] key key value to check its existence.
+
+    @return true if an element with specified @a key exists. If no such
+    element with such key is found or the JSON value is not an object,
+    false is returned.
+
+    @complexity Logarithmic in the size of the JSON object.
+
+    @liveexample{The following code shows an example for `contains()`.,contains}
+
+    @sa @ref find(KeyT&&) -- returns an iterator to an object element
+    @sa @ref contains(const json_pointer&) const -- checks the existence for a JSON pointer
+
+    @since version 3.6.0
+    */
+    template<typename KeyT, typename std::enable_if<
+                 not std::is_same<KeyT, json_pointer>::value, int>::type = 0>
+    bool contains(KeyT && key) const
+    {
+        return is_object() and m_value.object->find(std::forward<KeyT>(key)) != m_value.object->end();
+    }
+
+    /*!
+    @brief check the existence of an element in a JSON object given a JSON pointer
+
+    Check wehther the given JSON pointer @a ptr can be resolved in the current
+    JSON value.
+
+    @note This method can be executed on any JSON value type.
+
+    @param[in] ptr JSON pointer to check its existence.
+
+    @return true if the JSON pointer can be resolved to a stored value, false
+    otherwise.
+
+    @post If `j.contains(ptr)` returns true, it is safe to call `j[ptr]`.
+
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+
+    @complexity Logarithmic in the size of the JSON object.
+
+    @liveexample{The following code shows an example for `contains()`.,contains_json_pointer}
+
+    @sa @ref contains(KeyT &&) const -- checks the existence of a key
+
+    @since version 3.7.0
+    */
+    bool contains(const json_pointer& ptr) const
+    {
+        return ptr.contains(this);
+    }
+
+    /// @}
+
+
+    ///////////////
+    // iterators //
+    ///////////////
+
+    /// @name iterators
+    /// @{
+
+    /*!
+    @brief returns an iterator to the first element
+
+    Returns an iterator to the first element.
+
+    @image html range-begin-end.svg "Illustration from cppreference.com"
+
+    @return iterator to the first element
+
+    @complexity Constant.
+
+    @requirement This function helps `basic_json` satisfying the
+    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
+    requirements:
+    - The complexity is constant.
+
+    @liveexample{The following code shows an example for `begin()`.,begin}
+
+    @sa @ref cbegin() -- returns a const iterator to the beginning
+    @sa @ref end() -- returns an iterator to the end
+    @sa @ref cend() -- returns a const iterator to the end
+
+    @since version 1.0.0
+    */
+    iterator begin() noexcept
+    {
+        iterator result(this);
+        result.set_begin();
+        return result;
+    }
+
+    /*!
+    @copydoc basic_json::cbegin()
+    */
+    const_iterator begin() const noexcept
+    {
+        return cbegin();
+    }
+
+    /*!
+    @brief returns a const iterator to the first element
+
+    Returns a const iterator to the first element.
+
+    @image html range-begin-end.svg "Illustration from cppreference.com"
+
+    @return const iterator to the first element
+
+    @complexity Constant.
+
+    @requirement This function helps `basic_json` satisfying the
+    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
+    requirements:
+    - The complexity is constant.
+    - Has the semantics of `const_cast<const basic_json&>(*this).begin()`.
+
+    @liveexample{The following code shows an example for `cbegin()`.,cbegin}
+
+    @sa @ref begin() -- returns an iterator to the beginning
+    @sa @ref end() -- returns an iterator to the end
+    @sa @ref cend() -- returns a const iterator to the end
+
+    @since version 1.0.0
+    */
+    const_iterator cbegin() const noexcept
+    {
+        const_iterator result(this);
+        result.set_begin();
+        return result;
+    }
+
+    /*!
+    @brief returns an iterator to one past the last element
+
+    Returns an iterator to one past the last element.
+
+    @image html range-begin-end.svg "Illustration from cppreference.com"
+
+    @return iterator one past the last element
+
+    @complexity Constant.
+
+    @requirement This function helps `basic_json` satisfying the
+    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
+    requirements:
+    - The complexity is constant.
+
+    @liveexample{The following code shows an example for `end()`.,end}
+
+    @sa @ref cend() -- returns a const iterator to the end
+    @sa @ref begin() -- returns an iterator to the beginning
+    @sa @ref cbegin() -- returns a const iterator to the beginning
+
+    @since version 1.0.0
+    */
+    iterator end() noexcept
+    {
+        iterator result(this);
+        result.set_end();
+        return result;
+    }
+
+    /*!
+    @copydoc basic_json::cend()
+    */
+    const_iterator end() const noexcept
+    {
+        return cend();
+    }
+
+    /*!
+    @brief returns a const iterator to one past the last element
+
+    Returns a const iterator to one past the last element.
+
+    @image html range-begin-end.svg "Illustration from cppreference.com"
+
+    @return const iterator one past the last element
+
+    @complexity Constant.
+
+    @requirement This function helps `basic_json` satisfying the
+    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
+    requirements:
+    - The complexity is constant.
+    - Has the semantics of `const_cast<const basic_json&>(*this).end()`.
+
+    @liveexample{The following code shows an example for `cend()`.,cend}
+
+    @sa @ref end() -- returns an iterator to the end
+    @sa @ref begin() -- returns an iterator to the beginning
+    @sa @ref cbegin() -- returns a const iterator to the beginning
+
+    @since version 1.0.0
+    */
+    const_iterator cend() const noexcept
+    {
+        const_iterator result(this);
+        result.set_end();
+        return result;
+    }
+
+    /*!
+    @brief returns an iterator to the reverse-beginning
+
+    Returns an iterator to the reverse-beginning; that is, the last element.
+
+    @image html range-rbegin-rend.svg "Illustration from cppreference.com"
+
+    @complexity Constant.
+
+    @requirement This function helps `basic_json` satisfying the
+    [ReversibleContainer](https://en.cppreference.com/w/cpp/named_req/ReversibleContainer)
+    requirements:
+    - The complexity is constant.
+    - Has the semantics of `reverse_iterator(end())`.
+
+    @liveexample{The following code shows an example for `rbegin()`.,rbegin}
+
+    @sa @ref crbegin() -- returns a const reverse iterator to the beginning
+    @sa @ref rend() -- returns a reverse iterator to the end
+    @sa @ref crend() -- returns a const reverse iterator to the end
+
+    @since version 1.0.0
+    */
+    reverse_iterator rbegin() noexcept
+    {
+        return reverse_iterator(end());
+    }
+
+    /*!
+    @copydoc basic_json::crbegin()
+    */
+    const_reverse_iterator rbegin() const noexcept
+    {
+        return crbegin();
+    }
+
+    /*!
+    @brief returns an iterator to the reverse-end
+
+    Returns an iterator to the reverse-end; that is, one before the first
+    element.
+
+    @image html range-rbegin-rend.svg "Illustration from cppreference.com"
+
+    @complexity Constant.
+
+    @requirement This function helps `basic_json` satisfying the
+    [ReversibleContainer](https://en.cppreference.com/w/cpp/named_req/ReversibleContainer)
+    requirements:
+    - The complexity is constant.
+    - Has the semantics of `reverse_iterator(begin())`.
+
+    @liveexample{The following code shows an example for `rend()`.,rend}
+
+    @sa @ref crend() -- returns a const reverse iterator to the end
+    @sa @ref rbegin() -- returns a reverse iterator to the beginning
+    @sa @ref crbegin() -- returns a const reverse iterator to the beginning
+
+    @since version 1.0.0
+    */
+    reverse_iterator rend() noexcept
+    {
+        return reverse_iterator(begin());
+    }
+
+    /*!
+    @copydoc basic_json::crend()
+    */
+    const_reverse_iterator rend() const noexcept
+    {
+        return crend();
+    }
+
+    /*!
+    @brief returns a const reverse iterator to the last element
+
+    Returns a const iterator to the reverse-beginning; that is, the last
+    element.
+
+    @image html range-rbegin-rend.svg "Illustration from cppreference.com"
+
+    @complexity Constant.
+
+    @requirement This function helps `basic_json` satisfying the
+    [ReversibleContainer](https://en.cppreference.com/w/cpp/named_req/ReversibleContainer)
+    requirements:
+    - The complexity is constant.
+    - Has the semantics of `const_cast<const basic_json&>(*this).rbegin()`.
+
+    @liveexample{The following code shows an example for `crbegin()`.,crbegin}
+
+    @sa @ref rbegin() -- returns a reverse iterator to the beginning
+    @sa @ref rend() -- returns a reverse iterator to the end
+    @sa @ref crend() -- returns a const reverse iterator to the end
+
+    @since version 1.0.0
+    */
+    const_reverse_iterator crbegin() const noexcept
+    {
+        return const_reverse_iterator(cend());
+    }
+
+    /*!
+    @brief returns a const reverse iterator to one before the first
+
+    Returns a const reverse iterator to the reverse-end; that is, one before
+    the first element.
+
+    @image html range-rbegin-rend.svg "Illustration from cppreference.com"
+
+    @complexity Constant.
+
+    @requirement This function helps `basic_json` satisfying the
+    [ReversibleContainer](https://en.cppreference.com/w/cpp/named_req/ReversibleContainer)
+    requirements:
+    - The complexity is constant.
+    - Has the semantics of `const_cast<const basic_json&>(*this).rend()`.
+
+    @liveexample{The following code shows an example for `crend()`.,crend}
+
+    @sa @ref rend() -- returns a reverse iterator to the end
+    @sa @ref rbegin() -- returns a reverse iterator to the beginning
+    @sa @ref crbegin() -- returns a const reverse iterator to the beginning
+
+    @since version 1.0.0
+    */
+    const_reverse_iterator crend() const noexcept
+    {
+        return const_reverse_iterator(cbegin());
+    }
+
+  public:
+    /*!
+    @brief wrapper to access iterator member functions in range-based for
+
+    This function allows to access @ref iterator::key() and @ref
+    iterator::value() during range-based for loops. In these loops, a
+    reference to the JSON values is returned, so there is no access to the
+    underlying iterator.
+
+    For loop without iterator_wrapper:
+
+    @code{cpp}
+    for (auto it = j_object.begin(); it != j_object.end(); ++it)
+    {
+        std::cout << "key: " << it.key() << ", value:" << it.value() << '\n';
+    }
+    @endcode
+
+    Range-based for loop without iterator proxy:
+
+    @code{cpp}
+    for (auto it : j_object)
+    {
+        // "it" is of type json::reference and has no key() member
+        std::cout << "value: " << it << '\n';
+    }
+    @endcode
+
+    Range-based for loop with iterator proxy:
+
+    @code{cpp}
+    for (auto it : json::iterator_wrapper(j_object))
+    {
+        std::cout << "key: " << it.key() << ", value:" << it.value() << '\n';
+    }
+    @endcode
+
+    @note When iterating over an array, `key()` will return the index of the
+          element as string (see example).
+
+    @param[in] ref  reference to a JSON value
+    @return iteration proxy object wrapping @a ref with an interface to use in
+            range-based for loops
+
+    @liveexample{The following code shows how the wrapper is used,iterator_wrapper}
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes in the JSON value.
+
+    @complexity Constant.
+
+    @note The name of this function is not yet final and may change in the
+    future.
+
+    @deprecated This stream operator is deprecated and will be removed in
+                future 4.0.0 of the library. Please use @ref items() instead;
+                that is, replace `json::iterator_wrapper(j)` with `j.items()`.
+    */
+    JSON_HEDLEY_DEPRECATED(3.1.0)
+    static iteration_proxy<iterator> iterator_wrapper(reference ref) noexcept
+    {
+        return ref.items();
+    }
+
+    /*!
+    @copydoc iterator_wrapper(reference)
+    */
+    JSON_HEDLEY_DEPRECATED(3.1.0)
+    static iteration_proxy<const_iterator> iterator_wrapper(const_reference ref) noexcept
+    {
+        return ref.items();
+    }
+
+    /*!
+    @brief helper to access iterator member functions in range-based for
+
+    This function allows to access @ref iterator::key() and @ref
+    iterator::value() during range-based for loops. In these loops, a
+    reference to the JSON values is returned, so there is no access to the
+    underlying iterator.
+
+    For loop without `items()` function:
+
+    @code{cpp}
+    for (auto it = j_object.begin(); it != j_object.end(); ++it)
+    {
+        std::cout << "key: " << it.key() << ", value:" << it.value() << '\n';
+    }
+    @endcode
+
+    Range-based for loop without `items()` function:
+
+    @code{cpp}
+    for (auto it : j_object)
+    {
+        // "it" is of type json::reference and has no key() member
+        std::cout << "value: " << it << '\n';
+    }
+    @endcode
+
+    Range-based for loop with `items()` function:
+
+    @code{cpp}
+    for (auto& el : j_object.items())
+    {
+        std::cout << "key: " << el.key() << ", value:" << el.value() << '\n';
+    }
+    @endcode
+
+    The `items()` function also allows to use
+    [structured bindings](https://en.cppreference.com/w/cpp/language/structured_binding)
+    (C++17):
+
+    @code{cpp}
+    for (auto& [key, val] : j_object.items())
+    {
+        std::cout << "key: " << key << ", value:" << val << '\n';
+    }
+    @endcode
+
+    @note When iterating over an array, `key()` will return the index of the
+          element as string (see example). For primitive types (e.g., numbers),
+          `key()` returns an empty string.
+
+    @return iteration proxy object wrapping @a ref with an interface to use in
+            range-based for loops
+
+    @liveexample{The following code shows how the function is used.,items}
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes in the JSON value.
+
+    @complexity Constant.
+
+    @since version 3.1.0, structured bindings support since 3.5.0.
+    */
+    iteration_proxy<iterator> items() noexcept
+    {
+        return iteration_proxy<iterator>(*this);
+    }
+
+    /*!
+    @copydoc items()
+    */
+    iteration_proxy<const_iterator> items() const noexcept
+    {
+        return iteration_proxy<const_iterator>(*this);
+    }
+
+    /// @}
+
+
+    //////////////
+    // capacity //
+    //////////////
+
+    /// @name capacity
+    /// @{
+
+    /*!
+    @brief checks whether the container is empty.
+
+    Checks if a JSON value has no elements (i.e. whether its @ref size is `0`).
+
+    @return The return value depends on the different types and is
+            defined as follows:
+            Value type  | return value
+            ----------- | -------------
+            null        | `true`
+            boolean     | `false`
+            string      | `false`
+            number      | `false`
+            object      | result of function `object_t::empty()`
+            array       | result of function `array_t::empty()`
+
+    @liveexample{The following code uses `empty()` to check if a JSON
+    object contains any elements.,empty}
+
+    @complexity Constant, as long as @ref array_t and @ref object_t satisfy
+    the Container concept; that is, their `empty()` functions have constant
+    complexity.
+
+    @iterators No changes.
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+
+    @note This function does not return whether a string stored as JSON value
+    is empty - it returns whether the JSON container itself is empty which is
+    false in the case of a string.
+
+    @requirement This function helps `basic_json` satisfying the
+    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
+    requirements:
+    - The complexity is constant.
+    - Has the semantics of `begin() == end()`.
+
+    @sa @ref size() -- returns the number of elements
+
+    @since version 1.0.0
+    */
+    bool empty() const noexcept
+    {
+        switch (m_type)
+        {
+            case value_t::null:
+            {
+                // null values are empty
+                return true;
+            }
+
+            case value_t::array:
+            {
+                // delegate call to array_t::empty()
+                return m_value.array->empty();
+            }
+
+            case value_t::object:
+            {
+                // delegate call to object_t::empty()
+                return m_value.object->empty();
+            }
+
+            default:
+            {
+                // all other types are nonempty
+                return false;
+            }
+        }
+    }
+
+    /*!
+    @brief returns the number of elements
+
+    Returns the number of elements in a JSON value.
+
+    @return The return value depends on the different types and is
+            defined as follows:
+            Value type  | return value
+            ----------- | -------------
+            null        | `0`
+            boolean     | `1`
+            string      | `1`
+            number      | `1`
+            object      | result of function object_t::size()
+            array       | result of function array_t::size()
+
+    @liveexample{The following code calls `size()` on the different value
+    types.,size}
+
+    @complexity Constant, as long as @ref array_t and @ref object_t satisfy
+    the Container concept; that is, their size() functions have constant
+    complexity.
+
+    @iterators No changes.
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+
+    @note This function does not return the length of a string stored as JSON
+    value - it returns the number of elements in the JSON value which is 1 in
+    the case of a string.
+
+    @requirement This function helps `basic_json` satisfying the
+    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
+    requirements:
+    - The complexity is constant.
+    - Has the semantics of `std::distance(begin(), end())`.
+
+    @sa @ref empty() -- checks whether the container is empty
+    @sa @ref max_size() -- returns the maximal number of elements
+
+    @since version 1.0.0
+    */
+    size_type size() const noexcept
+    {
+        switch (m_type)
+        {
+            case value_t::null:
+            {
+                // null values are empty
+                return 0;
+            }
+
+            case value_t::array:
+            {
+                // delegate call to array_t::size()
+                return m_value.array->size();
+            }
+
+            case value_t::object:
+            {
+                // delegate call to object_t::size()
+                return m_value.object->size();
+            }
+
+            default:
+            {
+                // all other types have size 1
+                return 1;
+            }
+        }
+    }
+
+    /*!
+    @brief returns the maximum possible number of elements
+
+    Returns the maximum number of elements a JSON value is able to hold due to
+    system or library implementation limitations, i.e. `std::distance(begin(),
+    end())` for the JSON value.
+
+    @return The return value depends on the different types and is
+            defined as follows:
+            Value type  | return value
+            ----------- | -------------
+            null        | `0` (same as `size()`)
+            boolean     | `1` (same as `size()`)
+            string      | `1` (same as `size()`)
+            number      | `1` (same as `size()`)
+            object      | result of function `object_t::max_size()`
+            array       | result of function `array_t::max_size()`
+
+    @liveexample{The following code calls `max_size()` on the different value
+    types. Note the output is implementation specific.,max_size}
+
+    @complexity Constant, as long as @ref array_t and @ref object_t satisfy
+    the Container concept; that is, their `max_size()` functions have constant
+    complexity.
+
+    @iterators No changes.
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+
+    @requirement This function helps `basic_json` satisfying the
+    [Container](https://en.cppreference.com/w/cpp/named_req/Container)
+    requirements:
+    - The complexity is constant.
+    - Has the semantics of returning `b.size()` where `b` is the largest
+      possible JSON value.
+
+    @sa @ref size() -- returns the number of elements
+
+    @since version 1.0.0
+    */
+    size_type max_size() const noexcept
+    {
+        switch (m_type)
+        {
+            case value_t::array:
+            {
+                // delegate call to array_t::max_size()
+                return m_value.array->max_size();
+            }
+
+            case value_t::object:
+            {
+                // delegate call to object_t::max_size()
+                return m_value.object->max_size();
+            }
+
+            default:
+            {
+                // all other types have max_size() == size()
+                return size();
+            }
+        }
+    }
+
+    /// @}
+
+
+    ///////////////
+    // modifiers //
+    ///////////////
+
+    /// @name modifiers
+    /// @{
+
+    /*!
+    @brief clears the contents
+
+    Clears the content of a JSON value and resets it to the default value as
+    if @ref basic_json(value_t) would have been called with the current value
+    type from @ref type():
+
+    Value type  | initial value
+    ----------- | -------------
+    null        | `null`
+    boolean     | `false`
+    string      | `""`
+    number      | `0`
+    object      | `{}`
+    array       | `[]`
+
+    @post Has the same effect as calling
+    @code {.cpp}
+    *this = basic_json(type());
+    @endcode
+
+    @liveexample{The example below shows the effect of `clear()` to different
+    JSON types.,clear}
+
+    @complexity Linear in the size of the JSON value.
+
+    @iterators All iterators, pointers and references related to this container
+               are invalidated.
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+
+    @sa @ref basic_json(value_t) -- constructor that creates an object with the
+        same value than calling `clear()`
+
+    @since version 1.0.0
+    */
+    void clear() noexcept
+    {
+        switch (m_type)
+        {
+            case value_t::number_integer:
+            {
+                m_value.number_integer = 0;
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                m_value.number_unsigned = 0;
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                m_value.number_float = 0.0;
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                m_value.boolean = false;
+                break;
+            }
+
+            case value_t::string:
+            {
+                m_value.string->clear();
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_value.array->clear();
+                break;
+            }
+
+            case value_t::object:
+            {
+                m_value.object->clear();
+                break;
+            }
+
+            default:
+                break;
+        }
+    }
+
+    /*!
+    @brief add an object to an array
+
+    Appends the given element @a val to the end of the JSON value. If the
+    function is called on a JSON null value, an empty array is created before
+    appending @a val.
+
+    @param[in] val the value to add to the JSON array
+
+    @throw type_error.308 when called on a type other than JSON array or
+    null; example: `"cannot use push_back() with number"`
+
+    @complexity Amortized constant.
+
+    @liveexample{The example shows how `push_back()` and `+=` can be used to
+    add elements to a JSON array. Note how the `null` value was silently
+    converted to a JSON array.,push_back}
+
+    @since version 1.0.0
+    */
+    void push_back(basic_json&& val)
+    {
+        // push_back only works for null objects or arrays
+        if (JSON_HEDLEY_UNLIKELY(not(is_null() or is_array())))
+        {
+            JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));
+        }
+
+        // transform null object into an array
+        if (is_null())
+        {
+            m_type = value_t::array;
+            m_value = value_t::array;
+            assert_invariant();
+        }
+
+        // add element to array (move semantics)
+        m_value.array->push_back(std::move(val));
+        // invalidate object: mark it null so we do not call the destructor
+        // cppcheck-suppress accessMoved
+        val.m_type = value_t::null;
+    }
+
+    /*!
+    @brief add an object to an array
+    @copydoc push_back(basic_json&&)
+    */
+    reference operator+=(basic_json&& val)
+    {
+        push_back(std::move(val));
+        return *this;
+    }
+
+    /*!
+    @brief add an object to an array
+    @copydoc push_back(basic_json&&)
+    */
+    void push_back(const basic_json& val)
+    {
+        // push_back only works for null objects or arrays
+        if (JSON_HEDLEY_UNLIKELY(not(is_null() or is_array())))
+        {
+            JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));
+        }
+
+        // transform null object into an array
+        if (is_null())
+        {
+            m_type = value_t::array;
+            m_value = value_t::array;
+            assert_invariant();
+        }
+
+        // add element to array
+        m_value.array->push_back(val);
+    }
+
+    /*!
+    @brief add an object to an array
+    @copydoc push_back(basic_json&&)
+    */
+    reference operator+=(const basic_json& val)
+    {
+        push_back(val);
+        return *this;
+    }
+
+    /*!
+    @brief add an object to an object
+
+    Inserts the given element @a val to the JSON object. If the function is
+    called on a JSON null value, an empty object is created before inserting
+    @a val.
+
+    @param[in] val the value to add to the JSON object
+
+    @throw type_error.308 when called on a type other than JSON object or
+    null; example: `"cannot use push_back() with number"`
+
+    @complexity Logarithmic in the size of the container, O(log(`size()`)).
+
+    @liveexample{The example shows how `push_back()` and `+=` can be used to
+    add elements to a JSON object. Note how the `null` value was silently
+    converted to a JSON object.,push_back__object_t__value}
+
+    @since version 1.0.0
+    */
+    void push_back(const typename object_t::value_type& val)
+    {
+        // push_back only works for null objects or objects
+        if (JSON_HEDLEY_UNLIKELY(not(is_null() or is_object())))
+        {
+            JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));
+        }
+
+        // transform null object into an object
+        if (is_null())
+        {
+            m_type = value_t::object;
+            m_value = value_t::object;
+            assert_invariant();
+        }
+
+        // add element to array
+        m_value.object->insert(val);
+    }
+
+    /*!
+    @brief add an object to an object
+    @copydoc push_back(const typename object_t::value_type&)
+    */
+    reference operator+=(const typename object_t::value_type& val)
+    {
+        push_back(val);
+        return *this;
+    }
+
+    /*!
+    @brief add an object to an object
+
+    This function allows to use `push_back` with an initializer list. In case
+
+    1. the current value is an object,
+    2. the initializer list @a init contains only two elements, and
+    3. the first element of @a init is a string,
+
+    @a init is converted into an object element and added using
+    @ref push_back(const typename object_t::value_type&). Otherwise, @a init
+    is converted to a JSON value and added using @ref push_back(basic_json&&).
+
+    @param[in] init  an initializer list
+
+    @complexity Linear in the size of the initializer list @a init.
+
+    @note This function is required to resolve an ambiguous overload error,
+          because pairs like `{"key", "value"}` can be both interpreted as
+          `object_t::value_type` or `std::initializer_list<basic_json>`, see
+          https://github.com/nlohmann/json/issues/235 for more information.
+
+    @liveexample{The example shows how initializer lists are treated as
+    objects when possible.,push_back__initializer_list}
+    */
+    void push_back(initializer_list_t init)
+    {
+        if (is_object() and init.size() == 2 and (*init.begin())->is_string())
+        {
+            basic_json&& key = init.begin()->moved_or_copied();
+            push_back(typename object_t::value_type(
+                          std::move(key.get_ref<string_t&>()), (init.begin() + 1)->moved_or_copied()));
+        }
+        else
+        {
+            push_back(basic_json(init));
+        }
+    }
+
+    /*!
+    @brief add an object to an object
+    @copydoc push_back(initializer_list_t)
+    */
+    reference operator+=(initializer_list_t init)
+    {
+        push_back(init);
+        return *this;
+    }
+
+    /*!
+    @brief add an object to an array
+
+    Creates a JSON value from the passed parameters @a args to the end of the
+    JSON value. If the function is called on a JSON null value, an empty array
+    is created before appending the value created from @a args.
+
+    @param[in] args arguments to forward to a constructor of @ref basic_json
+    @tparam Args compatible types to create a @ref basic_json object
+
+    @return reference to the inserted element
+
+    @throw type_error.311 when called on a type other than JSON array or
+    null; example: `"cannot use emplace_back() with number"`
+
+    @complexity Amortized constant.
+
+    @liveexample{The example shows how `push_back()` can be used to add
+    elements to a JSON array. Note how the `null` value was silently converted
+    to a JSON array.,emplace_back}
+
+    @since version 2.0.8, returns reference since 3.7.0
+    */
+    template<class... Args>
+    reference emplace_back(Args&& ... args)
+    {
+        // emplace_back only works for null objects or arrays
+        if (JSON_HEDLEY_UNLIKELY(not(is_null() or is_array())))
+        {
+            JSON_THROW(type_error::create(311, "cannot use emplace_back() with " + std::string(type_name())));
+        }
+
+        // transform null object into an array
+        if (is_null())
+        {
+            m_type = value_t::array;
+            m_value = value_t::array;
+            assert_invariant();
+        }
+
+        // add element to array (perfect forwarding)
+#ifdef JSON_HAS_CPP_17
+        return m_value.array->emplace_back(std::forward<Args>(args)...);
+#else
+        m_value.array->emplace_back(std::forward<Args>(args)...);
+        return m_value.array->back();
+#endif
+    }
+
+    /*!
+    @brief add an object to an object if key does not exist
+
+    Inserts a new element into a JSON object constructed in-place with the
+    given @a args if there is no element with the key in the container. If the
+    function is called on a JSON null value, an empty object is created before
+    appending the value created from @a args.
+
+    @param[in] args arguments to forward to a constructor of @ref basic_json
+    @tparam Args compatible types to create a @ref basic_json object
+
+    @return a pair consisting of an iterator to the inserted element, or the
+            already-existing element if no insertion happened, and a bool
+            denoting whether the insertion took place.
+
+    @throw type_error.311 when called on a type other than JSON object or
+    null; example: `"cannot use emplace() with number"`
+
+    @complexity Logarithmic in the size of the container, O(log(`size()`)).
+
+    @liveexample{The example shows how `emplace()` can be used to add elements
+    to a JSON object. Note how the `null` value was silently converted to a
+    JSON object. Further note how no value is added if there was already one
+    value stored with the same key.,emplace}
+
+    @since version 2.0.8
+    */
+    template<class... Args>
+    std::pair<iterator, bool> emplace(Args&& ... args)
+    {
+        // emplace only works for null objects or arrays
+        if (JSON_HEDLEY_UNLIKELY(not(is_null() or is_object())))
+        {
+            JSON_THROW(type_error::create(311, "cannot use emplace() with " + std::string(type_name())));
+        }
+
+        // transform null object into an object
+        if (is_null())
+        {
+            m_type = value_t::object;
+            m_value = value_t::object;
+            assert_invariant();
+        }
+
+        // add element to array (perfect forwarding)
+        auto res = m_value.object->emplace(std::forward<Args>(args)...);
+        // create result iterator and set iterator to the result of emplace
+        auto it = begin();
+        it.m_it.object_iterator = res.first;
+
+        // return pair of iterator and boolean
+        return {it, res.second};
+    }
+
+    /// Helper for insertion of an iterator
+    /// @note: This uses std::distance to support GCC 4.8,
+    ///        see https://github.com/nlohmann/json/pull/1257
+    template<typename... Args>
+    iterator insert_iterator(const_iterator pos, Args&& ... args)
+    {
+        iterator result(this);
+        assert(m_value.array != nullptr);
+
+        auto insert_pos = std::distance(m_value.array->begin(), pos.m_it.array_iterator);
+        m_value.array->insert(pos.m_it.array_iterator, std::forward<Args>(args)...);
+        result.m_it.array_iterator = m_value.array->begin() + insert_pos;
+
+        // This could have been written as:
+        // result.m_it.array_iterator = m_value.array->insert(pos.m_it.array_iterator, cnt, val);
+        // but the return value of insert is missing in GCC 4.8, so it is written this way instead.
+
+        return result;
+    }
+
+    /*!
+    @brief inserts element
+
+    Inserts element @a val before iterator @a pos.
+
+    @param[in] pos iterator before which the content will be inserted; may be
+    the end() iterator
+    @param[in] val element to insert
+    @return iterator pointing to the inserted @a val.
+
+    @throw type_error.309 if called on JSON values other than arrays;
+    example: `"cannot use insert() with string"`
+    @throw invalid_iterator.202 if @a pos is not an iterator of *this;
+    example: `"iterator does not fit current value"`
+
+    @complexity Constant plus linear in the distance between @a pos and end of
+    the container.
+
+    @liveexample{The example shows how `insert()` is used.,insert}
+
+    @since version 1.0.0
+    */
+    iterator insert(const_iterator pos, const basic_json& val)
+    {
+        // insert only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            // check if iterator pos fits to this JSON value
+            if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
+            {
+                JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
+            }
+
+            // insert to array and return iterator
+            return insert_iterator(pos, val);
+        }
+
+        JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
+    }
+
+    /*!
+    @brief inserts element
+    @copydoc insert(const_iterator, const basic_json&)
+    */
+    iterator insert(const_iterator pos, basic_json&& val)
+    {
+        return insert(pos, val);
+    }
+
+    /*!
+    @brief inserts elements
+
+    Inserts @a cnt copies of @a val before iterator @a pos.
+
+    @param[in] pos iterator before which the content will be inserted; may be
+    the end() iterator
+    @param[in] cnt number of copies of @a val to insert
+    @param[in] val element to insert
+    @return iterator pointing to the first element inserted, or @a pos if
+    `cnt==0`
+
+    @throw type_error.309 if called on JSON values other than arrays; example:
+    `"cannot use insert() with string"`
+    @throw invalid_iterator.202 if @a pos is not an iterator of *this;
+    example: `"iterator does not fit current value"`
+
+    @complexity Linear in @a cnt plus linear in the distance between @a pos
+    and end of the container.
+
+    @liveexample{The example shows how `insert()` is used.,insert__count}
+
+    @since version 1.0.0
+    */
+    iterator insert(const_iterator pos, size_type cnt, const basic_json& val)
+    {
+        // insert only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            // check if iterator pos fits to this JSON value
+            if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
+            {
+                JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
+            }
+
+            // insert to array and return iterator
+            return insert_iterator(pos, cnt, val);
+        }
+
+        JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
+    }
+
+    /*!
+    @brief inserts elements
+
+    Inserts elements from range `[first, last)` before iterator @a pos.
+
+    @param[in] pos iterator before which the content will be inserted; may be
+    the end() iterator
+    @param[in] first begin of the range of elements to insert
+    @param[in] last end of the range of elements to insert
+
+    @throw type_error.309 if called on JSON values other than arrays; example:
+    `"cannot use insert() with string"`
+    @throw invalid_iterator.202 if @a pos is not an iterator of *this;
+    example: `"iterator does not fit current value"`
+    @throw invalid_iterator.210 if @a first and @a last do not belong to the
+    same JSON value; example: `"iterators do not fit"`
+    @throw invalid_iterator.211 if @a first or @a last are iterators into
+    container for which insert is called; example: `"passed iterators may not
+    belong to container"`
+
+    @return iterator pointing to the first element inserted, or @a pos if
+    `first==last`
+
+    @complexity Linear in `std::distance(first, last)` plus linear in the
+    distance between @a pos and end of the container.
+
+    @liveexample{The example shows how `insert()` is used.,insert__range}
+
+    @since version 1.0.0
+    */
+    iterator insert(const_iterator pos, const_iterator first, const_iterator last)
+    {
+        // insert only works for arrays
+        if (JSON_HEDLEY_UNLIKELY(not is_array()))
+        {
+            JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
+        }
+
+        // check if iterator pos fits to this JSON value
+        if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
+        {
+            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
+        }
+
+        // check if range iterators belong to the same JSON object
+        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(210, "iterators do not fit"));
+        }
+
+        if (JSON_HEDLEY_UNLIKELY(first.m_object == this))
+        {
+            JSON_THROW(invalid_iterator::create(211, "passed iterators may not belong to container"));
+        }
+
+        // insert to array and return iterator
+        return insert_iterator(pos, first.m_it.array_iterator, last.m_it.array_iterator);
+    }
+
+    /*!
+    @brief inserts elements
+
+    Inserts elements from initializer list @a ilist before iterator @a pos.
+
+    @param[in] pos iterator before which the content will be inserted; may be
+    the end() iterator
+    @param[in] ilist initializer list to insert the values from
+
+    @throw type_error.309 if called on JSON values other than arrays; example:
+    `"cannot use insert() with string"`
+    @throw invalid_iterator.202 if @a pos is not an iterator of *this;
+    example: `"iterator does not fit current value"`
+
+    @return iterator pointing to the first element inserted, or @a pos if
+    `ilist` is empty
+
+    @complexity Linear in `ilist.size()` plus linear in the distance between
+    @a pos and end of the container.
+
+    @liveexample{The example shows how `insert()` is used.,insert__ilist}
+
+    @since version 1.0.0
+    */
+    iterator insert(const_iterator pos, initializer_list_t ilist)
+    {
+        // insert only works for arrays
+        if (JSON_HEDLEY_UNLIKELY(not is_array()))
+        {
+            JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
+        }
+
+        // check if iterator pos fits to this JSON value
+        if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
+        {
+            JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
+        }
+
+        // insert to array and return iterator
+        return insert_iterator(pos, ilist.begin(), ilist.end());
+    }
+
+    /*!
+    @brief inserts elements
+
+    Inserts elements from range `[first, last)`.
+
+    @param[in] first begin of the range of elements to insert
+    @param[in] last end of the range of elements to insert
+
+    @throw type_error.309 if called on JSON values other than objects; example:
+    `"cannot use insert() with string"`
+    @throw invalid_iterator.202 if iterator @a first or @a last does does not
+    point to an object; example: `"iterators first and last must point to
+    objects"`
+    @throw invalid_iterator.210 if @a first and @a last do not belong to the
+    same JSON value; example: `"iterators do not fit"`
+
+    @complexity Logarithmic: `O(N*log(size() + N))`, where `N` is the number
+    of elements to insert.
+
+    @liveexample{The example shows how `insert()` is used.,insert__range_object}
+
+    @since version 3.0.0
+    */
+    void insert(const_iterator first, const_iterator last)
+    {
+        // insert only works for objects
+        if (JSON_HEDLEY_UNLIKELY(not is_object()))
+        {
+            JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
+        }
+
+        // check if range iterators belong to the same JSON object
+        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(210, "iterators do not fit"));
+        }
+
+        // passed iterators must belong to objects
+        if (JSON_HEDLEY_UNLIKELY(not first.m_object->is_object()))
+        {
+            JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects"));
+        }
+
+        m_value.object->insert(first.m_it.object_iterator, last.m_it.object_iterator);
+    }
+
+    /*!
+    @brief updates a JSON object from another object, overwriting existing keys
+
+    Inserts all values from JSON object @a j and overwrites existing keys.
+
+    @param[in] j  JSON object to read values from
+
+    @throw type_error.312 if called on JSON values other than objects; example:
+    `"cannot use update() with string"`
+
+    @complexity O(N*log(size() + N)), where N is the number of elements to
+                insert.
+
+    @liveexample{The example shows how `update()` is used.,update}
+
+    @sa https://docs.python.org/3.6/library/stdtypes.html#dict.update
+
+    @since version 3.0.0
+    */
+    void update(const_reference j)
+    {
+        // implicitly convert null value to an empty object
+        if (is_null())
+        {
+            m_type = value_t::object;
+            m_value.object = create<object_t>();
+            assert_invariant();
+        }
+
+        if (JSON_HEDLEY_UNLIKELY(not is_object()))
+        {
+            JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(type_name())));
+        }
+        if (JSON_HEDLEY_UNLIKELY(not j.is_object()))
+        {
+            JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(j.type_name())));
+        }
+
+        for (auto it = j.cbegin(); it != j.cend(); ++it)
+        {
+            m_value.object->operator[](it.key()) = it.value();
+        }
+    }
+
+    /*!
+    @brief updates a JSON object from another object, overwriting existing keys
+
+    Inserts all values from from range `[first, last)` and overwrites existing
+    keys.
+
+    @param[in] first begin of the range of elements to insert
+    @param[in] last end of the range of elements to insert
+
+    @throw type_error.312 if called on JSON values other than objects; example:
+    `"cannot use update() with string"`
+    @throw invalid_iterator.202 if iterator @a first or @a last does does not
+    point to an object; example: `"iterators first and last must point to
+    objects"`
+    @throw invalid_iterator.210 if @a first and @a last do not belong to the
+    same JSON value; example: `"iterators do not fit"`
+
+    @complexity O(N*log(size() + N)), where N is the number of elements to
+                insert.
+
+    @liveexample{The example shows how `update()` is used__range.,update}
+
+    @sa https://docs.python.org/3.6/library/stdtypes.html#dict.update
+
+    @since version 3.0.0
+    */
+    void update(const_iterator first, const_iterator last)
+    {
+        // implicitly convert null value to an empty object
+        if (is_null())
+        {
+            m_type = value_t::object;
+            m_value.object = create<object_t>();
+            assert_invariant();
+        }
+
+        if (JSON_HEDLEY_UNLIKELY(not is_object()))
+        {
+            JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(type_name())));
+        }
+
+        // check if range iterators belong to the same JSON object
+        if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
+        {
+            JSON_THROW(invalid_iterator::create(210, "iterators do not fit"));
+        }
+
+        // passed iterators must belong to objects
+        if (JSON_HEDLEY_UNLIKELY(not first.m_object->is_object()
+                                 or not last.m_object->is_object()))
+        {
+            JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects"));
+        }
+
+        for (auto it = first; it != last; ++it)
+        {
+            m_value.object->operator[](it.key()) = it.value();
+        }
+    }
+
+    /*!
+    @brief exchanges the values
+
+    Exchanges the contents of the JSON value with those of @a other. Does not
+    invoke any move, copy, or swap operations on individual elements. All
+    iterators and references remain valid. The past-the-end iterator is
+    invalidated.
+
+    @param[in,out] other JSON value to exchange the contents with
+
+    @complexity Constant.
+
+    @liveexample{The example below shows how JSON values can be swapped with
+    `swap()`.,swap__reference}
+
+    @since version 1.0.0
+    */
+    void swap(reference other) noexcept (
+        std::is_nothrow_move_constructible<value_t>::value and
+        std::is_nothrow_move_assignable<value_t>::value and
+        std::is_nothrow_move_constructible<json_value>::value and
+        std::is_nothrow_move_assignable<json_value>::value
+    )
+    {
+        std::swap(m_type, other.m_type);
+        std::swap(m_value, other.m_value);
+        assert_invariant();
+    }
+
+    /*!
+    @brief exchanges the values
+
+    Exchanges the contents of a JSON array with those of @a other. Does not
+    invoke any move, copy, or swap operations on individual elements. All
+    iterators and references remain valid. The past-the-end iterator is
+    invalidated.
+
+    @param[in,out] other array to exchange the contents with
+
+    @throw type_error.310 when JSON value is not an array; example: `"cannot
+    use swap() with string"`
+
+    @complexity Constant.
+
+    @liveexample{The example below shows how arrays can be swapped with
+    `swap()`.,swap__array_t}
+
+    @since version 1.0.0
+    */
+    void swap(array_t& other)
+    {
+        // swap only works for arrays
+        if (JSON_HEDLEY_LIKELY(is_array()))
+        {
+            std::swap(*(m_value.array), other);
+        }
+        else
+        {
+            JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name())));
+        }
+    }
+
+    /*!
+    @brief exchanges the values
+
+    Exchanges the contents of a JSON object with those of @a other. Does not
+    invoke any move, copy, or swap operations on individual elements. All
+    iterators and references remain valid. The past-the-end iterator is
+    invalidated.
+
+    @param[in,out] other object to exchange the contents with
+
+    @throw type_error.310 when JSON value is not an object; example:
+    `"cannot use swap() with string"`
+
+    @complexity Constant.
+
+    @liveexample{The example below shows how objects can be swapped with
+    `swap()`.,swap__object_t}
+
+    @since version 1.0.0
+    */
+    void swap(object_t& other)
+    {
+        // swap only works for objects
+        if (JSON_HEDLEY_LIKELY(is_object()))
+        {
+            std::swap(*(m_value.object), other);
+        }
+        else
+        {
+            JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name())));
+        }
+    }
+
+    /*!
+    @brief exchanges the values
+
+    Exchanges the contents of a JSON string with those of @a other. Does not
+    invoke any move, copy, or swap operations on individual elements. All
+    iterators and references remain valid. The past-the-end iterator is
+    invalidated.
+
+    @param[in,out] other string to exchange the contents with
+
+    @throw type_error.310 when JSON value is not a string; example: `"cannot
+    use swap() with boolean"`
+
+    @complexity Constant.
+
+    @liveexample{The example below shows how strings can be swapped with
+    `swap()`.,swap__string_t}
+
+    @since version 1.0.0
+    */
+    void swap(string_t& other)
+    {
+        // swap only works for strings
+        if (JSON_HEDLEY_LIKELY(is_string()))
+        {
+            std::swap(*(m_value.string), other);
+        }
+        else
+        {
+            JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name())));
+        }
+    }
+
+    /// @}
+
+  public:
+    //////////////////////////////////////////
+    // lexicographical comparison operators //
+    //////////////////////////////////////////
+
+    /// @name lexicographical comparison operators
+    /// @{
+
+    /*!
+    @brief comparison: equal
+
+    Compares two JSON values for equality according to the following rules:
+    - Two JSON values are equal if (1) they are from the same type and (2)
+      their stored values are the same according to their respective
+      `operator==`.
+    - Integer and floating-point numbers are automatically converted before
+      comparison. Note than two NaN values are always treated as unequal.
+    - Two JSON null values are equal.
+
+    @note Floating-point inside JSON values numbers are compared with
+    `json::number_float_t::operator==` which is `double::operator==` by
+    default. To compare floating-point while respecting an epsilon, an alternative
+    [comparison function](https://github.com/mariokonrad/marnav/blob/master/src/marnav/math/floatingpoint.hpp#L34-#L39)
+    could be used, for instance
+    @code {.cpp}
+    template<typename T, typename = typename std::enable_if<std::is_floating_point<T>::value, T>::type>
+    inline bool is_same(T a, T b, T epsilon = std::numeric_limits<T>::epsilon()) noexcept
+    {
+        return std::abs(a - b) <= epsilon;
+    }
+    @endcode
+
+    @note NaN values never compare equal to themselves or to other NaN values.
+
+    @param[in] lhs  first JSON value to consider
+    @param[in] rhs  second JSON value to consider
+    @return whether the values @a lhs and @a rhs are equal
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+
+    @complexity Linear.
+
+    @liveexample{The example demonstrates comparing several JSON
+    types.,operator__equal}
+
+    @since version 1.0.0
+    */
+    friend bool operator==(const_reference lhs, const_reference rhs) noexcept
+    {
+        const auto lhs_type = lhs.type();
+        const auto rhs_type = rhs.type();
+
+        if (lhs_type == rhs_type)
+        {
+            switch (lhs_type)
+            {
+                case value_t::array:
+                    return *lhs.m_value.array == *rhs.m_value.array;
+
+                case value_t::object:
+                    return *lhs.m_value.object == *rhs.m_value.object;
+
+                case value_t::null:
+                    return true;
+
+                case value_t::string:
+                    return *lhs.m_value.string == *rhs.m_value.string;
+
+                case value_t::boolean:
+                    return lhs.m_value.boolean == rhs.m_value.boolean;
+
+                case value_t::number_integer:
+                    return lhs.m_value.number_integer == rhs.m_value.number_integer;
+
+                case value_t::number_unsigned:
+                    return lhs.m_value.number_unsigned == rhs.m_value.number_unsigned;
+
+                case value_t::number_float:
+                    return lhs.m_value.number_float == rhs.m_value.number_float;
+
+                default:
+                    return false;
+            }
+        }
+        else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_float)
+        {
+            return static_cast<number_float_t>(lhs.m_value.number_integer) == rhs.m_value.number_float;
+        }
+        else if (lhs_type == value_t::number_float and rhs_type == value_t::number_integer)
+        {
+            return lhs.m_value.number_float == static_cast<number_float_t>(rhs.m_value.number_integer);
+        }
+        else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_float)
+        {
+            return static_cast<number_float_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_float;
+        }
+        else if (lhs_type == value_t::number_float and rhs_type == value_t::number_unsigned)
+        {
+            return lhs.m_value.number_float == static_cast<number_float_t>(rhs.m_value.number_unsigned);
+        }
+        else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_integer)
+        {
+            return static_cast<number_integer_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_integer;
+        }
+        else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_unsigned)
+        {
+            return lhs.m_value.number_integer == static_cast<number_integer_t>(rhs.m_value.number_unsigned);
+        }
+
+        return false;
+    }
+
+    /*!
+    @brief comparison: equal
+    @copydoc operator==(const_reference, const_reference)
+    */
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator==(const_reference lhs, const ScalarType rhs) noexcept
+    {
+        return lhs == basic_json(rhs);
+    }
+
+    /*!
+    @brief comparison: equal
+    @copydoc operator==(const_reference, const_reference)
+    */
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator==(const ScalarType lhs, const_reference rhs) noexcept
+    {
+        return basic_json(lhs) == rhs;
+    }
+
+    /*!
+    @brief comparison: not equal
+
+    Compares two JSON values for inequality by calculating `not (lhs == rhs)`.
+
+    @param[in] lhs  first JSON value to consider
+    @param[in] rhs  second JSON value to consider
+    @return whether the values @a lhs and @a rhs are not equal
+
+    @complexity Linear.
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+
+    @liveexample{The example demonstrates comparing several JSON
+    types.,operator__notequal}
+
+    @since version 1.0.0
+    */
+    friend bool operator!=(const_reference lhs, const_reference rhs) noexcept
+    {
+        return not (lhs == rhs);
+    }
+
+    /*!
+    @brief comparison: not equal
+    @copydoc operator!=(const_reference, const_reference)
+    */
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator!=(const_reference lhs, const ScalarType rhs) noexcept
+    {
+        return lhs != basic_json(rhs);
+    }
+
+    /*!
+    @brief comparison: not equal
+    @copydoc operator!=(const_reference, const_reference)
+    */
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator!=(const ScalarType lhs, const_reference rhs) noexcept
+    {
+        return basic_json(lhs) != rhs;
+    }
+
+    /*!
+    @brief comparison: less than
+
+    Compares whether one JSON value @a lhs is less than another JSON value @a
+    rhs according to the following rules:
+    - If @a lhs and @a rhs have the same type, the values are compared using
+      the default `<` operator.
+    - Integer and floating-point numbers are automatically converted before
+      comparison
+    - In case @a lhs and @a rhs have different types, the values are ignored
+      and the order of the types is considered, see
+      @ref operator<(const value_t, const value_t).
+
+    @param[in] lhs  first JSON value to consider
+    @param[in] rhs  second JSON value to consider
+    @return whether @a lhs is less than @a rhs
+
+    @complexity Linear.
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+
+    @liveexample{The example demonstrates comparing several JSON
+    types.,operator__less}
+
+    @since version 1.0.0
+    */
+    friend bool operator<(const_reference lhs, const_reference rhs) noexcept
+    {
+        const auto lhs_type = lhs.type();
+        const auto rhs_type = rhs.type();
+
+        if (lhs_type == rhs_type)
+        {
+            switch (lhs_type)
+            {
+                case value_t::array:
+                    // note parentheses are necessary, see
+                    // https://github.com/nlohmann/json/issues/1530
+                    return (*lhs.m_value.array) < (*rhs.m_value.array);
+
+                case value_t::object:
+                    return (*lhs.m_value.object) < (*rhs.m_value.object);
+
+                case value_t::null:
+                    return false;
+
+                case value_t::string:
+                    return (*lhs.m_value.string) < (*rhs.m_value.string);
+
+                case value_t::boolean:
+                    return (lhs.m_value.boolean) < (rhs.m_value.boolean);
+
+                case value_t::number_integer:
+                    return (lhs.m_value.number_integer) < (rhs.m_value.number_integer);
+
+                case value_t::number_unsigned:
+                    return (lhs.m_value.number_unsigned) < (rhs.m_value.number_unsigned);
+
+                case value_t::number_float:
+                    return (lhs.m_value.number_float) < (rhs.m_value.number_float);
+
+                default:
+                    return false;
+            }
+        }
+        else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_float)
+        {
+            return static_cast<number_float_t>(lhs.m_value.number_integer) < rhs.m_value.number_float;
+        }
+        else if (lhs_type == value_t::number_float and rhs_type == value_t::number_integer)
+        {
+            return lhs.m_value.number_float < static_cast<number_float_t>(rhs.m_value.number_integer);
+        }
+        else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_float)
+        {
+            return static_cast<number_float_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_float;
+        }
+        else if (lhs_type == value_t::number_float and rhs_type == value_t::number_unsigned)
+        {
+            return lhs.m_value.number_float < static_cast<number_float_t>(rhs.m_value.number_unsigned);
+        }
+        else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_unsigned)
+        {
+            return lhs.m_value.number_integer < static_cast<number_integer_t>(rhs.m_value.number_unsigned);
+        }
+        else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_integer)
+        {
+            return static_cast<number_integer_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_integer;
+        }
+
+        // We only reach this line if we cannot compare values. In that case,
+        // we compare types. Note we have to call the operator explicitly,
+        // because MSVC has problems otherwise.
+        return operator<(lhs_type, rhs_type);
+    }
+
+    /*!
+    @brief comparison: less than
+    @copydoc operator<(const_reference, const_reference)
+    */
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator<(const_reference lhs, const ScalarType rhs) noexcept
+    {
+        return lhs < basic_json(rhs);
+    }
+
+    /*!
+    @brief comparison: less than
+    @copydoc operator<(const_reference, const_reference)
+    */
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator<(const ScalarType lhs, const_reference rhs) noexcept
+    {
+        return basic_json(lhs) < rhs;
+    }
+
+    /*!
+    @brief comparison: less than or equal
+
+    Compares whether one JSON value @a lhs is less than or equal to another
+    JSON value by calculating `not (rhs < lhs)`.
+
+    @param[in] lhs  first JSON value to consider
+    @param[in] rhs  second JSON value to consider
+    @return whether @a lhs is less than or equal to @a rhs
+
+    @complexity Linear.
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+
+    @liveexample{The example demonstrates comparing several JSON
+    types.,operator__greater}
+
+    @since version 1.0.0
+    */
+    friend bool operator<=(const_reference lhs, const_reference rhs) noexcept
+    {
+        return not (rhs < lhs);
+    }
+
+    /*!
+    @brief comparison: less than or equal
+    @copydoc operator<=(const_reference, const_reference)
+    */
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator<=(const_reference lhs, const ScalarType rhs) noexcept
+    {
+        return lhs <= basic_json(rhs);
+    }
+
+    /*!
+    @brief comparison: less than or equal
+    @copydoc operator<=(const_reference, const_reference)
+    */
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator<=(const ScalarType lhs, const_reference rhs) noexcept
+    {
+        return basic_json(lhs) <= rhs;
+    }
+
+    /*!
+    @brief comparison: greater than
+
+    Compares whether one JSON value @a lhs is greater than another
+    JSON value by calculating `not (lhs <= rhs)`.
+
+    @param[in] lhs  first JSON value to consider
+    @param[in] rhs  second JSON value to consider
+    @return whether @a lhs is greater than to @a rhs
+
+    @complexity Linear.
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+
+    @liveexample{The example demonstrates comparing several JSON
+    types.,operator__lessequal}
+
+    @since version 1.0.0
+    */
+    friend bool operator>(const_reference lhs, const_reference rhs) noexcept
+    {
+        return not (lhs <= rhs);
+    }
+
+    /*!
+    @brief comparison: greater than
+    @copydoc operator>(const_reference, const_reference)
+    */
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator>(const_reference lhs, const ScalarType rhs) noexcept
+    {
+        return lhs > basic_json(rhs);
+    }
+
+    /*!
+    @brief comparison: greater than
+    @copydoc operator>(const_reference, const_reference)
+    */
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator>(const ScalarType lhs, const_reference rhs) noexcept
+    {
+        return basic_json(lhs) > rhs;
+    }
+
+    /*!
+    @brief comparison: greater than or equal
+
+    Compares whether one JSON value @a lhs is greater than or equal to another
+    JSON value by calculating `not (lhs < rhs)`.
+
+    @param[in] lhs  first JSON value to consider
+    @param[in] rhs  second JSON value to consider
+    @return whether @a lhs is greater than or equal to @a rhs
+
+    @complexity Linear.
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+
+    @liveexample{The example demonstrates comparing several JSON
+    types.,operator__greaterequal}
+
+    @since version 1.0.0
+    */
+    friend bool operator>=(const_reference lhs, const_reference rhs) noexcept
+    {
+        return not (lhs < rhs);
+    }
+
+    /*!
+    @brief comparison: greater than or equal
+    @copydoc operator>=(const_reference, const_reference)
+    */
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator>=(const_reference lhs, const ScalarType rhs) noexcept
+    {
+        return lhs >= basic_json(rhs);
+    }
+
+    /*!
+    @brief comparison: greater than or equal
+    @copydoc operator>=(const_reference, const_reference)
+    */
+    template<typename ScalarType, typename std::enable_if<
+                 std::is_scalar<ScalarType>::value, int>::type = 0>
+    friend bool operator>=(const ScalarType lhs, const_reference rhs) noexcept
+    {
+        return basic_json(lhs) >= rhs;
+    }
+
+    /// @}
+
+    ///////////////////
+    // serialization //
+    ///////////////////
+
+    /// @name serialization
+    /// @{
+
+    /*!
+    @brief serialize to stream
+
+    Serialize the given JSON value @a j to the output stream @a o. The JSON
+    value will be serialized using the @ref dump member function.
+
+    - The indentation of the output can be controlled with the member variable
+      `width` of the output stream @a o. For instance, using the manipulator
+      `std::setw(4)` on @a o sets the indentation level to `4` and the
+      serialization result is the same as calling `dump(4)`.
+
+    - The indentation character can be controlled with the member variable
+      `fill` of the output stream @a o. For instance, the manipulator
+      `std::setfill('\\t')` sets indentation to use a tab character rather than
+      the default space character.
+
+    @param[in,out] o  stream to serialize to
+    @param[in] j  JSON value to serialize
+
+    @return the stream @a o
+
+    @throw type_error.316 if a string stored inside the JSON value is not
+                          UTF-8 encoded
+
+    @complexity Linear.
+
+    @liveexample{The example below shows the serialization with different
+    parameters to `width` to adjust the indentation level.,operator_serialize}
+
+    @since version 1.0.0; indentation character added in version 3.0.0
+    */
+    friend std::ostream& operator<<(std::ostream& o, const basic_json& j)
+    {
+        // read width member and use it as indentation parameter if nonzero
+        const bool pretty_print = o.width() > 0;
+        const auto indentation = pretty_print ? o.width() : 0;
+
+        // reset width to 0 for subsequent calls to this stream
+        o.width(0);
+
+        // do the actual serialization
+        serializer s(detail::output_adapter<char>(o), o.fill());
+        s.dump(j, pretty_print, false, static_cast<unsigned int>(indentation));
+        return o;
+    }
+
+    /*!
+    @brief serialize to stream
+    @deprecated This stream operator is deprecated and will be removed in
+                future 4.0.0 of the library. Please use
+                @ref operator<<(std::ostream&, const basic_json&)
+                instead; that is, replace calls like `j >> o;` with `o << j;`.
+    @since version 1.0.0; deprecated since version 3.0.0
+    */
+    JSON_HEDLEY_DEPRECATED(3.0.0)
+    friend std::ostream& operator>>(const basic_json& j, std::ostream& o)
+    {
+        return o << j;
+    }
+
+    /// @}
+
+
+    /////////////////////
+    // deserialization //
+    /////////////////////
+
+    /// @name deserialization
+    /// @{
+
+    /*!
+    @brief deserialize from a compatible input
+
+    This function reads from a compatible input. Examples are:
+    - an array of 1-byte values
+    - strings with character/literal type with size of 1 byte
+    - input streams
+    - container with contiguous storage of 1-byte values. Compatible container
+      types include `std::vector`, `std::string`, `std::array`,
+      `std::valarray`, and `std::initializer_list`. Furthermore, C-style
+      arrays can be used with `std::begin()`/`std::end()`. User-defined
+      containers can be used as long as they implement random-access iterators
+      and a contiguous storage.
+
+    @pre Each element of the container has a size of 1 byte. Violating this
+    precondition yields undefined behavior. **This precondition is enforced
+    with a static assertion.**
+
+    @pre The container storage is contiguous. Violating this precondition
+    yields undefined behavior. **This precondition is enforced with an
+    assertion.**
+
+    @warning There is no way to enforce all preconditions at compile-time. If
+             the function is called with a noncompliant container and with
+             assertions switched off, the behavior is undefined and will most
+             likely yield segmentation violation.
+
+    @param[in] i  input to read from
+    @param[in] cb  a parser callback function of type @ref parser_callback_t
+    which is used to control the deserialization by filtering unwanted values
+    (optional)
+    @param[in] allow_exceptions  whether to throw exceptions in case of a
+    parse error (optional, true by default)
+
+    @return deserialized JSON value; in case of a parse error and
+            @a allow_exceptions set to `false`, the return value will be
+            value_t::discarded.
+
+    @throw parse_error.101 if a parse error occurs; example: `""unexpected end
+    of input; expected string literal""`
+    @throw parse_error.102 if to_unicode fails or surrogate error
+    @throw parse_error.103 if to_unicode fails
+
+    @complexity Linear in the length of the input. The parser is a predictive
+    LL(1) parser. The complexity can be higher if the parser callback function
+    @a cb has a super-linear complexity.
+
+    @note A UTF-8 byte order mark is silently ignored.
+
+    @liveexample{The example below demonstrates the `parse()` function reading
+    from an array.,parse__array__parser_callback_t}
+
+    @liveexample{The example below demonstrates the `parse()` function with
+    and without callback function.,parse__string__parser_callback_t}
+
+    @liveexample{The example below demonstrates the `parse()` function with
+    and without callback function.,parse__istream__parser_callback_t}
+
+    @liveexample{The example below demonstrates the `parse()` function reading
+    from a contiguous container.,parse__contiguouscontainer__parser_callback_t}
+
+    @since version 2.0.3 (contiguous containers)
+    */
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json parse(detail::input_adapter&& i,
+                            const parser_callback_t cb = nullptr,
+                            const bool allow_exceptions = true)
+    {
+        basic_json result;
+        parser(i, cb, allow_exceptions).parse(true, result);
+        return result;
+    }
+
+    static bool accept(detail::input_adapter&& i)
+    {
+        return parser(i).accept(true);
+    }
+
+    /*!
+    @brief generate SAX events
+
+    The SAX event lister must follow the interface of @ref json_sax.
+
+    This function reads from a compatible input. Examples are:
+    - an array of 1-byte values
+    - strings with character/literal type with size of 1 byte
+    - input streams
+    - container with contiguous storage of 1-byte values. Compatible container
+      types include `std::vector`, `std::string`, `std::array`,
+      `std::valarray`, and `std::initializer_list`. Furthermore, C-style
+      arrays can be used with `std::begin()`/`std::end()`. User-defined
+      containers can be used as long as they implement random-access iterators
+      and a contiguous storage.
+
+    @pre Each element of the container has a size of 1 byte. Violating this
+    precondition yields undefined behavior. **This precondition is enforced
+    with a static assertion.**
+
+    @pre The container storage is contiguous. Violating this precondition
+    yields undefined behavior. **This precondition is enforced with an
+    assertion.**
+
+    @warning There is no way to enforce all preconditions at compile-time. If
+             the function is called with a noncompliant container and with
+             assertions switched off, the behavior is undefined and will most
+             likely yield segmentation violation.
+
+    @param[in] i  input to read from
+    @param[in,out] sax  SAX event listener
+    @param[in] format  the format to parse (JSON, CBOR, MessagePack, or UBJSON)
+    @param[in] strict  whether the input has to be consumed completely
+
+    @return return value of the last processed SAX event
+
+    @throw parse_error.101 if a parse error occurs; example: `""unexpected end
+    of input; expected string literal""`
+    @throw parse_error.102 if to_unicode fails or surrogate error
+    @throw parse_error.103 if to_unicode fails
+
+    @complexity Linear in the length of the input. The parser is a predictive
+    LL(1) parser. The complexity can be higher if the SAX consumer @a sax has
+    a super-linear complexity.
+
+    @note A UTF-8 byte order mark is silently ignored.
+
+    @liveexample{The example below demonstrates the `sax_parse()` function
+    reading from string and processing the events with a user-defined SAX
+    event consumer.,sax_parse}
+
+    @since version 3.2.0
+    */
+    template <typename SAX>
+    JSON_HEDLEY_NON_NULL(2)
+    static bool sax_parse(detail::input_adapter&& i, SAX* sax,
+                          input_format_t format = input_format_t::json,
+                          const bool strict = true)
+    {
+        assert(sax);
+        return format == input_format_t::json
+               ? parser(std::move(i)).sax_parse(sax, strict)
+               : detail::binary_reader<basic_json, SAX>(std::move(i)).sax_parse(format, sax, strict);
+    }
+
+    /*!
+    @brief deserialize from an iterator range with contiguous storage
+
+    This function reads from an iterator range of a container with contiguous
+    storage of 1-byte values. Compatible container types include
+    `std::vector`, `std::string`, `std::array`, `std::valarray`, and
+    `std::initializer_list`. Furthermore, C-style arrays can be used with
+    `std::begin()`/`std::end()`. User-defined containers can be used as long
+    as they implement random-access iterators and a contiguous storage.
+
+    @pre The iterator range is contiguous. Violating this precondition yields
+    undefined behavior. **This precondition is enforced with an assertion.**
+    @pre Each element in the range has a size of 1 byte. Violating this
+    precondition yields undefined behavior. **This precondition is enforced
+    with a static assertion.**
+
+    @warning There is no way to enforce all preconditions at compile-time. If
+             the function is called with noncompliant iterators and with
+             assertions switched off, the behavior is undefined and will most
+             likely yield segmentation violation.
+
+    @tparam IteratorType iterator of container with contiguous storage
+    @param[in] first  begin of the range to parse (included)
+    @param[in] last  end of the range to parse (excluded)
+    @param[in] cb  a parser callback function of type @ref parser_callback_t
+    which is used to control the deserialization by filtering unwanted values
+    (optional)
+    @param[in] allow_exceptions  whether to throw exceptions in case of a
+    parse error (optional, true by default)
+
+    @return deserialized JSON value; in case of a parse error and
+            @a allow_exceptions set to `false`, the return value will be
+            value_t::discarded.
+
+    @throw parse_error.101 in case of an unexpected token
+    @throw parse_error.102 if to_unicode fails or surrogate error
+    @throw parse_error.103 if to_unicode fails
+
+    @complexity Linear in the length of the input. The parser is a predictive
+    LL(1) parser. The complexity can be higher if the parser callback function
+    @a cb has a super-linear complexity.
+
+    @note A UTF-8 byte order mark is silently ignored.
+
+    @liveexample{The example below demonstrates the `parse()` function reading
+    from an iterator range.,parse__iteratortype__parser_callback_t}
+
+    @since version 2.0.3
+    */
+    template<class IteratorType, typename std::enable_if<
+                 std::is_base_of<
+                     std::random_access_iterator_tag,
+                     typename std::iterator_traits<IteratorType>::iterator_category>::value, int>::type = 0>
+    static basic_json parse(IteratorType first, IteratorType last,
+                            const parser_callback_t cb = nullptr,
+                            const bool allow_exceptions = true)
+    {
+        basic_json result;
+        parser(detail::input_adapter(first, last), cb, allow_exceptions).parse(true, result);
+        return result;
+    }
+
+    template<class IteratorType, typename std::enable_if<
+                 std::is_base_of<
+                     std::random_access_iterator_tag,
+                     typename std::iterator_traits<IteratorType>::iterator_category>::value, int>::type = 0>
+    static bool accept(IteratorType first, IteratorType last)
+    {
+        return parser(detail::input_adapter(first, last)).accept(true);
+    }
+
+    template<class IteratorType, class SAX, typename std::enable_if<
+                 std::is_base_of<
+                     std::random_access_iterator_tag,
+                     typename std::iterator_traits<IteratorType>::iterator_category>::value, int>::type = 0>
+    JSON_HEDLEY_NON_NULL(3)
+    static bool sax_parse(IteratorType first, IteratorType last, SAX* sax)
+    {
+        return parser(detail::input_adapter(first, last)).sax_parse(sax);
+    }
+
+    /*!
+    @brief deserialize from stream
+    @deprecated This stream operator is deprecated and will be removed in
+                version 4.0.0 of the library. Please use
+                @ref operator>>(std::istream&, basic_json&)
+                instead; that is, replace calls like `j << i;` with `i >> j;`.
+    @since version 1.0.0; deprecated since version 3.0.0
+    */
+    JSON_HEDLEY_DEPRECATED(3.0.0)
+    friend std::istream& operator<<(basic_json& j, std::istream& i)
+    {
+        return operator>>(i, j);
+    }
+
+    /*!
+    @brief deserialize from stream
+
+    Deserializes an input stream to a JSON value.
+
+    @param[in,out] i  input stream to read a serialized JSON value from
+    @param[in,out] j  JSON value to write the deserialized input to
+
+    @throw parse_error.101 in case of an unexpected token
+    @throw parse_error.102 if to_unicode fails or surrogate error
+    @throw parse_error.103 if to_unicode fails
+
+    @complexity Linear in the length of the input. The parser is a predictive
+    LL(1) parser.
+
+    @note A UTF-8 byte order mark is silently ignored.
+
+    @liveexample{The example below shows how a JSON value is constructed by
+    reading a serialization from a stream.,operator_deserialize}
+
+    @sa parse(std::istream&, const parser_callback_t) for a variant with a
+    parser callback function to filter values while parsing
+
+    @since version 1.0.0
+    */
+    friend std::istream& operator>>(std::istream& i, basic_json& j)
+    {
+        parser(detail::input_adapter(i)).parse(false, j);
+        return i;
+    }
+
+    /// @}
+
+    ///////////////////////////
+    // convenience functions //
+    ///////////////////////////
+
+    /*!
+    @brief return the type as string
+
+    Returns the type name as string to be used in error messages - usually to
+    indicate that a function was called on a wrong JSON type.
+
+    @return a string representation of a the @a m_type member:
+            Value type  | return value
+            ----------- | -------------
+            null        | `"null"`
+            boolean     | `"boolean"`
+            string      | `"string"`
+            number      | `"number"` (for all number types)
+            object      | `"object"`
+            array       | `"array"`
+            discarded   | `"discarded"`
+
+    @exceptionsafety No-throw guarantee: this function never throws exceptions.
+
+    @complexity Constant.
+
+    @liveexample{The following code exemplifies `type_name()` for all JSON
+    types.,type_name}
+
+    @sa @ref type() -- return the type of the JSON value
+    @sa @ref operator value_t() -- return the type of the JSON value (implicit)
+
+    @since version 1.0.0, public since 2.1.0, `const char*` and `noexcept`
+    since 3.0.0
+    */
+    JSON_HEDLEY_RETURNS_NON_NULL
+    const char* type_name() const noexcept
+    {
+        {
+            switch (m_type)
+            {
+                case value_t::null:
+                    return "null";
+                case value_t::object:
+                    return "object";
+                case value_t::array:
+                    return "array";
+                case value_t::string:
+                    return "string";
+                case value_t::boolean:
+                    return "boolean";
+                case value_t::discarded:
+                    return "discarded";
+                default:
+                    return "number";
+            }
+        }
+    }
+
+
+  private:
+    //////////////////////
+    // member variables //
+    //////////////////////
+
+    /// the type of the current element
+    value_t m_type = value_t::null;
+
+    /// the value of the current element
+    json_value m_value = {};
+
+    //////////////////////////////////////////
+    // binary serialization/deserialization //
+    //////////////////////////////////////////
+
+    /// @name binary serialization/deserialization support
+    /// @{
+
+  public:
+    /*!
+    @brief create a CBOR serialization of a given JSON value
+
+    Serializes a given JSON value @a j to a byte vector using the CBOR (Concise
+    Binary Object Representation) serialization format. CBOR is a binary
+    serialization format which aims to be more compact than JSON itself, yet
+    more efficient to parse.
+
+    The library uses the following mapping from JSON values types to
+    CBOR types according to the CBOR specification (RFC 7049):
+
+    JSON value type | value/range                                | CBOR type                          | first byte
+    --------------- | ------------------------------------------ | ---------------------------------- | ---------------
+    null            | `null`                                     | Null                               | 0xF6
+    boolean         | `true`                                     | True                               | 0xF5
+    boolean         | `false`                                    | False                              | 0xF4
+    number_integer  | -9223372036854775808..-2147483649          | Negative integer (8 bytes follow)  | 0x3B
+    number_integer  | -2147483648..-32769                        | Negative integer (4 bytes follow)  | 0x3A
+    number_integer  | -32768..-129                               | Negative integer (2 bytes follow)  | 0x39
+    number_integer  | -128..-25                                  | Negative integer (1 byte follow)   | 0x38
+    number_integer  | -24..-1                                    | Negative integer                   | 0x20..0x37
+    number_integer  | 0..23                                      | Integer                            | 0x00..0x17
+    number_integer  | 24..255                                    | Unsigned integer (1 byte follow)   | 0x18
+    number_integer  | 256..65535                                 | Unsigned integer (2 bytes follow)  | 0x19
+    number_integer  | 65536..4294967295                          | Unsigned integer (4 bytes follow)  | 0x1A
+    number_integer  | 4294967296..18446744073709551615           | Unsigned integer (8 bytes follow)  | 0x1B
+    number_unsigned | 0..23                                      | Integer                            | 0x00..0x17
+    number_unsigned | 24..255                                    | Unsigned integer (1 byte follow)   | 0x18
+    number_unsigned | 256..65535                                 | Unsigned integer (2 bytes follow)  | 0x19
+    number_unsigned | 65536..4294967295                          | Unsigned integer (4 bytes follow)  | 0x1A
+    number_unsigned | 4294967296..18446744073709551615           | Unsigned integer (8 bytes follow)  | 0x1B
+    number_float    | *any value*                                | Double-Precision Float             | 0xFB
+    string          | *length*: 0..23                            | UTF-8 string                       | 0x60..0x77
+    string          | *length*: 23..255                          | UTF-8 string (1 byte follow)       | 0x78
+    string          | *length*: 256..65535                       | UTF-8 string (2 bytes follow)      | 0x79
+    string          | *length*: 65536..4294967295                | UTF-8 string (4 bytes follow)      | 0x7A
+    string          | *length*: 4294967296..18446744073709551615 | UTF-8 string (8 bytes follow)      | 0x7B
+    array           | *size*: 0..23                              | array                              | 0x80..0x97
+    array           | *size*: 23..255                            | array (1 byte follow)              | 0x98
+    array           | *size*: 256..65535                         | array (2 bytes follow)             | 0x99
+    array           | *size*: 65536..4294967295                  | array (4 bytes follow)             | 0x9A
+    array           | *size*: 4294967296..18446744073709551615   | array (8 bytes follow)             | 0x9B
+    object          | *size*: 0..23                              | map                                | 0xA0..0xB7
+    object          | *size*: 23..255                            | map (1 byte follow)                | 0xB8
+    object          | *size*: 256..65535                         | map (2 bytes follow)               | 0xB9
+    object          | *size*: 65536..4294967295                  | map (4 bytes follow)               | 0xBA
+    object          | *size*: 4294967296..18446744073709551615   | map (8 bytes follow)               | 0xBB
+
+    @note The mapping is **complete** in the sense that any JSON value type
+          can be converted to a CBOR value.
+
+    @note If NaN or Infinity are stored inside a JSON number, they are
+          serialized properly. This behavior differs from the @ref dump()
+          function which serializes NaN or Infinity to `null`.
+
+    @note The following CBOR types are not used in the conversion:
+          - byte strings (0x40..0x5F)
+          - UTF-8 strings terminated by "break" (0x7F)
+          - arrays terminated by "break" (0x9F)
+          - maps terminated by "break" (0xBF)
+          - date/time (0xC0..0xC1)
+          - bignum (0xC2..0xC3)
+          - decimal fraction (0xC4)
+          - bigfloat (0xC5)
+          - tagged items (0xC6..0xD4, 0xD8..0xDB)
+          - expected conversions (0xD5..0xD7)
+          - simple values (0xE0..0xF3, 0xF8)
+          - undefined (0xF7)
+          - half and single-precision floats (0xF9-0xFA)
+          - break (0xFF)
+
+    @param[in] j  JSON value to serialize
+    @return MessagePack serialization as byte vector
+
+    @complexity Linear in the size of the JSON value @a j.
+
+    @liveexample{The example shows the serialization of a JSON value to a byte
+    vector in CBOR format.,to_cbor}
+
+    @sa http://cbor.io
+    @sa @ref from_cbor(detail::input_adapter&&, const bool, const bool) for the
+        analogous deserialization
+    @sa @ref to_msgpack(const basic_json&) for the related MessagePack format
+    @sa @ref to_ubjson(const basic_json&, const bool, const bool) for the
+             related UBJSON format
+
+    @since version 2.0.9
+    */
+    static std::vector<uint8_t> to_cbor(const basic_json& j)
+    {
+        std::vector<uint8_t> result;
+        to_cbor(j, result);
+        return result;
+    }
+
+    static void to_cbor(const basic_json& j, detail::output_adapter<uint8_t> o)
+    {
+        binary_writer<uint8_t>(o).write_cbor(j);
+    }
+
+    static void to_cbor(const basic_json& j, detail::output_adapter<char> o)
+    {
+        binary_writer<char>(o).write_cbor(j);
+    }
+
+    /*!
+    @brief create a MessagePack serialization of a given JSON value
+
+    Serializes a given JSON value @a j to a byte vector using the MessagePack
+    serialization format. MessagePack is a binary serialization format which
+    aims to be more compact than JSON itself, yet more efficient to parse.
+
+    The library uses the following mapping from JSON values types to
+    MessagePack types according to the MessagePack specification:
+
+    JSON value type | value/range                       | MessagePack type | first byte
+    --------------- | --------------------------------- | ---------------- | ----------
+    null            | `null`                            | nil              | 0xC0
+    boolean         | `true`                            | true             | 0xC3
+    boolean         | `false`                           | false            | 0xC2
+    number_integer  | -9223372036854775808..-2147483649 | int64            | 0xD3
+    number_integer  | -2147483648..-32769               | int32            | 0xD2
+    number_integer  | -32768..-129                      | int16            | 0xD1
+    number_integer  | -128..-33                         | int8             | 0xD0
+    number_integer  | -32..-1                           | negative fixint  | 0xE0..0xFF
+    number_integer  | 0..127                            | positive fixint  | 0x00..0x7F
+    number_integer  | 128..255                          | uint 8           | 0xCC
+    number_integer  | 256..65535                        | uint 16          | 0xCD
+    number_integer  | 65536..4294967295                 | uint 32          | 0xCE
+    number_integer  | 4294967296..18446744073709551615  | uint 64          | 0xCF
+    number_unsigned | 0..127                            | positive fixint  | 0x00..0x7F
+    number_unsigned | 128..255                          | uint 8           | 0xCC
+    number_unsigned | 256..65535                        | uint 16          | 0xCD
+    number_unsigned | 65536..4294967295                 | uint 32          | 0xCE
+    number_unsigned | 4294967296..18446744073709551615  | uint 64          | 0xCF
+    number_float    | *any value*                       | float 64         | 0xCB
+    string          | *length*: 0..31                   | fixstr           | 0xA0..0xBF
+    string          | *length*: 32..255                 | str 8            | 0xD9
+    string          | *length*: 256..65535              | str 16           | 0xDA
+    string          | *length*: 65536..4294967295       | str 32           | 0xDB
+    array           | *size*: 0..15                     | fixarray         | 0x90..0x9F
+    array           | *size*: 16..65535                 | array 16         | 0xDC
+    array           | *size*: 65536..4294967295         | array 32         | 0xDD
+    object          | *size*: 0..15                     | fix map          | 0x80..0x8F
+    object          | *size*: 16..65535                 | map 16           | 0xDE
+    object          | *size*: 65536..4294967295         | map 32           | 0xDF
+
+    @note The mapping is **complete** in the sense that any JSON value type
+          can be converted to a MessagePack value.
+
+    @note The following values can **not** be converted to a MessagePack value:
+          - strings with more than 4294967295 bytes
+          - arrays with more than 4294967295 elements
+          - objects with more than 4294967295 elements
+
+    @note The following MessagePack types are not used in the conversion:
+          - bin 8 - bin 32 (0xC4..0xC6)
+          - ext 8 - ext 32 (0xC7..0xC9)
+          - float 32 (0xCA)
+          - fixext 1 - fixext 16 (0xD4..0xD8)
+
+    @note Any MessagePack output created @ref to_msgpack can be successfully
+          parsed by @ref from_msgpack.
+
+    @note If NaN or Infinity are stored inside a JSON number, they are
+          serialized properly. This behavior differs from the @ref dump()
+          function which serializes NaN or Infinity to `null`.
+
+    @param[in] j  JSON value to serialize
+    @return MessagePack serialization as byte vector
+
+    @complexity Linear in the size of the JSON value @a j.
+
+    @liveexample{The example shows the serialization of a JSON value to a byte
+    vector in MessagePack format.,to_msgpack}
+
+    @sa http://msgpack.org
+    @sa @ref from_msgpack for the analogous deserialization
+    @sa @ref to_cbor(const basic_json& for the related CBOR format
+    @sa @ref to_ubjson(const basic_json&, const bool, const bool) for the
+             related UBJSON format
+
+    @since version 2.0.9
+    */
+    static std::vector<uint8_t> to_msgpack(const basic_json& j)
+    {
+        std::vector<uint8_t> result;
+        to_msgpack(j, result);
+        return result;
+    }
+
+    static void to_msgpack(const basic_json& j, detail::output_adapter<uint8_t> o)
+    {
+        binary_writer<uint8_t>(o).write_msgpack(j);
+    }
+
+    static void to_msgpack(const basic_json& j, detail::output_adapter<char> o)
+    {
+        binary_writer<char>(o).write_msgpack(j);
+    }
+
+    /*!
+    @brief create a UBJSON serialization of a given JSON value
+
+    Serializes a given JSON value @a j to a byte vector using the UBJSON
+    (Universal Binary JSON) serialization format. UBJSON aims to be more compact
+    than JSON itself, yet more efficient to parse.
+
+    The library uses the following mapping from JSON values types to
+    UBJSON types according to the UBJSON specification:
+
+    JSON value type | value/range                       | UBJSON type | marker
+    --------------- | --------------------------------- | ----------- | ------
+    null            | `null`                            | null        | `Z`
+    boolean         | `true`                            | true        | `T`
+    boolean         | `false`                           | false       | `F`
+    number_integer  | -9223372036854775808..-2147483649 | int64       | `L`
+    number_integer  | -2147483648..-32769               | int32       | `l`
+    number_integer  | -32768..-129                      | int16       | `I`
+    number_integer  | -128..127                         | int8        | `i`
+    number_integer  | 128..255                          | uint8       | `U`
+    number_integer  | 256..32767                        | int16       | `I`
+    number_integer  | 32768..2147483647                 | int32       | `l`
+    number_integer  | 2147483648..9223372036854775807   | int64       | `L`
+    number_unsigned | 0..127                            | int8        | `i`
+    number_unsigned | 128..255                          | uint8       | `U`
+    number_unsigned | 256..32767                        | int16       | `I`
+    number_unsigned | 32768..2147483647                 | int32       | `l`
+    number_unsigned | 2147483648..9223372036854775807   | int64       | `L`
+    number_float    | *any value*                       | float64     | `D`
+    string          | *with shortest length indicator*  | string      | `S`
+    array           | *see notes on optimized format*   | array       | `[`
+    object          | *see notes on optimized format*   | map         | `{`
+
+    @note The mapping is **complete** in the sense that any JSON value type
+          can be converted to a UBJSON value.
+
+    @note The following values can **not** be converted to a UBJSON value:
+          - strings with more than 9223372036854775807 bytes (theoretical)
+          - unsigned integer numbers above 9223372036854775807
+
+    @note The following markers are not used in the conversion:
+          - `Z`: no-op values are not created.
+          - `C`: single-byte strings are serialized with `S` markers.
+
+    @note Any UBJSON output created @ref to_ubjson can be successfully parsed
+          by @ref from_ubjson.
+
+    @note If NaN or Infinity are stored inside a JSON number, they are
+          serialized properly. This behavior differs from the @ref dump()
+          function which serializes NaN or Infinity to `null`.
+
+    @note The optimized formats for containers are supported: Parameter
+          @a use_size adds size information to the beginning of a container and
+          removes the closing marker. Parameter @a use_type further checks
+          whether all elements of a container have the same type and adds the
+          type marker to the beginning of the container. The @a use_type
+          parameter must only be used together with @a use_size = true. Note
+          that @a use_size = true alone may result in larger representations -
+          the benefit of this parameter is that the receiving side is
+          immediately informed on the number of elements of the container.
+
+    @param[in] j  JSON value to serialize
+    @param[in] use_size  whether to add size annotations to container types
+    @param[in] use_type  whether to add type annotations to container types
+                         (must be combined with @a use_size = true)
+    @return UBJSON serialization as byte vector
+
+    @complexity Linear in the size of the JSON value @a j.
+
+    @liveexample{The example shows the serialization of a JSON value to a byte
+    vector in UBJSON format.,to_ubjson}
+
+    @sa http://ubjson.org
+    @sa @ref from_ubjson(detail::input_adapter&&, const bool, const bool) for the
+        analogous deserialization
+    @sa @ref to_cbor(const basic_json& for the related CBOR format
+    @sa @ref to_msgpack(const basic_json&) for the related MessagePack format
+
+    @since version 3.1.0
+    */
+    static std::vector<uint8_t> to_ubjson(const basic_json& j,
+                                          const bool use_size = false,
+                                          const bool use_type = false)
+    {
+        std::vector<uint8_t> result;
+        to_ubjson(j, result, use_size, use_type);
+        return result;
+    }
+
+    static void to_ubjson(const basic_json& j, detail::output_adapter<uint8_t> o,
+                          const bool use_size = false, const bool use_type = false)
+    {
+        binary_writer<uint8_t>(o).write_ubjson(j, use_size, use_type);
+    }
+
+    static void to_ubjson(const basic_json& j, detail::output_adapter<char> o,
+                          const bool use_size = false, const bool use_type = false)
+    {
+        binary_writer<char>(o).write_ubjson(j, use_size, use_type);
+    }
+
+
+    /*!
+    @brief Serializes the given JSON object `j` to BSON and returns a vector
+           containing the corresponding BSON-representation.
+
+    BSON (Binary JSON) is a binary format in which zero or more ordered key/value pairs are
+    stored as a single entity (a so-called document).
+
+    The library uses the following mapping from JSON values types to BSON types:
+
+    JSON value type | value/range                       | BSON type   | marker
+    --------------- | --------------------------------- | ----------- | ------
+    null            | `null`                            | null        | 0x0A
+    boolean         | `true`, `false`                   | boolean     | 0x08
+    number_integer  | -9223372036854775808..-2147483649 | int64       | 0x12
+    number_integer  | -2147483648..2147483647           | int32       | 0x10
+    number_integer  | 2147483648..9223372036854775807   | int64       | 0x12
+    number_unsigned | 0..2147483647                     | int32       | 0x10
+    number_unsigned | 2147483648..9223372036854775807   | int64       | 0x12
+    number_unsigned | 9223372036854775808..18446744073709551615| --   | --
+    number_float    | *any value*                       | double      | 0x01
+    string          | *any value*                       | string      | 0x02
+    array           | *any value*                       | document    | 0x04
+    object          | *any value*                       | document    | 0x03
+
+    @warning The mapping is **incomplete**, since only JSON-objects (and things
+    contained therein) can be serialized to BSON.
+    Also, integers larger than 9223372036854775807 cannot be serialized to BSON,
+    and the keys may not contain U+0000, since they are serialized a
+    zero-terminated c-strings.
+
+    @throw out_of_range.407  if `j.is_number_unsigned() && j.get<std::uint64_t>() > 9223372036854775807`
+    @throw out_of_range.409  if a key in `j` contains a NULL (U+0000)
+    @throw type_error.317    if `!j.is_object()`
+
+    @pre The input `j` is required to be an object: `j.is_object() == true`.
+
+    @note Any BSON output created via @ref to_bson can be successfully parsed
+          by @ref from_bson.
+
+    @param[in] j  JSON value to serialize
+    @return BSON serialization as byte vector
+
+    @complexity Linear in the size of the JSON value @a j.
+
+    @liveexample{The example shows the serialization of a JSON value to a byte
+    vector in BSON format.,to_bson}
+
+    @sa http://bsonspec.org/spec.html
+    @sa @ref from_bson(detail::input_adapter&&, const bool strict) for the
+        analogous deserialization
+    @sa @ref to_ubjson(const basic_json&, const bool, const bool) for the
+             related UBJSON format
+    @sa @ref to_cbor(const basic_json&) for the related CBOR format
+    @sa @ref to_msgpack(const basic_json&) for the related MessagePack format
+    */
+    static std::vector<uint8_t> to_bson(const basic_json& j)
+    {
+        std::vector<uint8_t> result;
+        to_bson(j, result);
+        return result;
+    }
+
+    /*!
+    @brief Serializes the given JSON object `j` to BSON and forwards the
+           corresponding BSON-representation to the given output_adapter `o`.
+    @param j The JSON object to convert to BSON.
+    @param o The output adapter that receives the binary BSON representation.
+    @pre The input `j` shall be an object: `j.is_object() == true`
+    @sa @ref to_bson(const basic_json&)
+    */
+    static void to_bson(const basic_json& j, detail::output_adapter<uint8_t> o)
+    {
+        binary_writer<uint8_t>(o).write_bson(j);
+    }
+
+    /*!
+    @copydoc to_bson(const basic_json&, detail::output_adapter<uint8_t>)
+    */
+    static void to_bson(const basic_json& j, detail::output_adapter<char> o)
+    {
+        binary_writer<char>(o).write_bson(j);
+    }
+
+
+    /*!
+    @brief create a JSON value from an input in CBOR format
+
+    Deserializes a given input @a i to a JSON value using the CBOR (Concise
+    Binary Object Representation) serialization format.
+
+    The library maps CBOR types to JSON value types as follows:
+
+    CBOR type              | JSON value type | first byte
+    ---------------------- | --------------- | ----------
+    Integer                | number_unsigned | 0x00..0x17
+    Unsigned integer       | number_unsigned | 0x18
+    Unsigned integer       | number_unsigned | 0x19
+    Unsigned integer       | number_unsigned | 0x1A
+    Unsigned integer       | number_unsigned | 0x1B
+    Negative integer       | number_integer  | 0x20..0x37
+    Negative integer       | number_integer  | 0x38
+    Negative integer       | number_integer  | 0x39
+    Negative integer       | number_integer  | 0x3A
+    Negative integer       | number_integer  | 0x3B
+    Negative integer       | number_integer  | 0x40..0x57
+    UTF-8 string           | string          | 0x60..0x77
+    UTF-8 string           | string          | 0x78
+    UTF-8 string           | string          | 0x79
+    UTF-8 string           | string          | 0x7A
+    UTF-8 string           | string          | 0x7B
+    UTF-8 string           | string          | 0x7F
+    array                  | array           | 0x80..0x97
+    array                  | array           | 0x98
+    array                  | array           | 0x99
+    array                  | array           | 0x9A
+    array                  | array           | 0x9B
+    array                  | array           | 0x9F
+    map                    | object          | 0xA0..0xB7
+    map                    | object          | 0xB8
+    map                    | object          | 0xB9
+    map                    | object          | 0xBA
+    map                    | object          | 0xBB
+    map                    | object          | 0xBF
+    False                  | `false`         | 0xF4
+    True                   | `true`          | 0xF5
+    Null                   | `null`          | 0xF6
+    Half-Precision Float   | number_float    | 0xF9
+    Single-Precision Float | number_float    | 0xFA
+    Double-Precision Float | number_float    | 0xFB
+
+    @warning The mapping is **incomplete** in the sense that not all CBOR
+             types can be converted to a JSON value. The following CBOR types
+             are not supported and will yield parse errors (parse_error.112):
+             - byte strings (0x40..0x5F)
+             - date/time (0xC0..0xC1)
+             - bignum (0xC2..0xC3)
+             - decimal fraction (0xC4)
+             - bigfloat (0xC5)
+             - tagged items (0xC6..0xD4, 0xD8..0xDB)
+             - expected conversions (0xD5..0xD7)
+             - simple values (0xE0..0xF3, 0xF8)
+             - undefined (0xF7)
+
+    @warning CBOR allows map keys of any type, whereas JSON only allows
+             strings as keys in object values. Therefore, CBOR maps with keys
+             other than UTF-8 strings are rejected (parse_error.113).
+
+    @note Any CBOR output created @ref to_cbor can be successfully parsed by
+          @ref from_cbor.
+
+    @param[in] i  an input in CBOR format convertible to an input adapter
+    @param[in] strict  whether to expect the input to be consumed until EOF
+                       (true by default)
+    @param[in] allow_exceptions  whether to throw exceptions in case of a
+    parse error (optional, true by default)
+
+    @return deserialized JSON value; in case of a parse error and
+            @a allow_exceptions set to `false`, the return value will be
+            value_t::discarded.
+
+    @throw parse_error.110 if the given input ends prematurely or the end of
+    file was not reached when @a strict was set to true
+    @throw parse_error.112 if unsupported features from CBOR were
+    used in the given input @a v or if the input is not valid CBOR
+    @throw parse_error.113 if a string was expected as map key, but not found
+
+    @complexity Linear in the size of the input @a i.
+
+    @liveexample{The example shows the deserialization of a byte vector in CBOR
+    format to a JSON value.,from_cbor}
+
+    @sa http://cbor.io
+    @sa @ref to_cbor(const basic_json&) for the analogous serialization
+    @sa @ref from_msgpack(detail::input_adapter&&, const bool, const bool) for the
+        related MessagePack format
+    @sa @ref from_ubjson(detail::input_adapter&&, const bool, const bool) for the
+        related UBJSON format
+
+    @since version 2.0.9; parameter @a start_index since 2.1.1; changed to
+           consume input adapters, removed start_index parameter, and added
+           @a strict parameter since 3.0.0; added @a allow_exceptions parameter
+           since 3.2.0
+    */
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_cbor(detail::input_adapter&& i,
+                                const bool strict = true,
+                                const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        const bool res = binary_reader(detail::input_adapter(i)).sax_parse(input_format_t::cbor, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /*!
+    @copydoc from_cbor(detail::input_adapter&&, const bool, const bool)
+    */
+    template<typename A1, typename A2,
+             detail::enable_if_t<std::is_constructible<detail::input_adapter, A1, A2>::value, int> = 0>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_cbor(A1 && a1, A2 && a2,
+                                const bool strict = true,
+                                const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        const bool res = binary_reader(detail::input_adapter(std::forward<A1>(a1), std::forward<A2>(a2))).sax_parse(input_format_t::cbor, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /*!
+    @brief create a JSON value from an input in MessagePack format
+
+    Deserializes a given input @a i to a JSON value using the MessagePack
+    serialization format.
+
+    The library maps MessagePack types to JSON value types as follows:
+
+    MessagePack type | JSON value type | first byte
+    ---------------- | --------------- | ----------
+    positive fixint  | number_unsigned | 0x00..0x7F
+    fixmap           | object          | 0x80..0x8F
+    fixarray         | array           | 0x90..0x9F
+    fixstr           | string          | 0xA0..0xBF
+    nil              | `null`          | 0xC0
+    false            | `false`         | 0xC2
+    true             | `true`          | 0xC3
+    float 32         | number_float    | 0xCA
+    float 64         | number_float    | 0xCB
+    uint 8           | number_unsigned | 0xCC
+    uint 16          | number_unsigned | 0xCD
+    uint 32          | number_unsigned | 0xCE
+    uint 64          | number_unsigned | 0xCF
+    int 8            | number_integer  | 0xD0
+    int 16           | number_integer  | 0xD1
+    int 32           | number_integer  | 0xD2
+    int 64           | number_integer  | 0xD3
+    str 8            | string          | 0xD9
+    str 16           | string          | 0xDA
+    str 32           | string          | 0xDB
+    array 16         | array           | 0xDC
+    array 32         | array           | 0xDD
+    map 16           | object          | 0xDE
+    map 32           | object          | 0xDF
+    negative fixint  | number_integer  | 0xE0-0xFF
+
+    @warning The mapping is **incomplete** in the sense that not all
+             MessagePack types can be converted to a JSON value. The following
+             MessagePack types are not supported and will yield parse errors:
+              - bin 8 - bin 32 (0xC4..0xC6)
+              - ext 8 - ext 32 (0xC7..0xC9)
+              - fixext 1 - fixext 16 (0xD4..0xD8)
+
+    @note Any MessagePack output created @ref to_msgpack can be successfully
+          parsed by @ref from_msgpack.
+
+    @param[in] i  an input in MessagePack format convertible to an input
+                  adapter
+    @param[in] strict  whether to expect the input to be consumed until EOF
+                       (true by default)
+    @param[in] allow_exceptions  whether to throw exceptions in case of a
+    parse error (optional, true by default)
+
+    @return deserialized JSON value; in case of a parse error and
+            @a allow_exceptions set to `false`, the return value will be
+            value_t::discarded.
+
+    @throw parse_error.110 if the given input ends prematurely or the end of
+    file was not reached when @a strict was set to true
+    @throw parse_error.112 if unsupported features from MessagePack were
+    used in the given input @a i or if the input is not valid MessagePack
+    @throw parse_error.113 if a string was expected as map key, but not found
+
+    @complexity Linear in the size of the input @a i.
+
+    @liveexample{The example shows the deserialization of a byte vector in
+    MessagePack format to a JSON value.,from_msgpack}
+
+    @sa http://msgpack.org
+    @sa @ref to_msgpack(const basic_json&) for the analogous serialization
+    @sa @ref from_cbor(detail::input_adapter&&, const bool, const bool) for the
+        related CBOR format
+    @sa @ref from_ubjson(detail::input_adapter&&, const bool, const bool) for
+        the related UBJSON format
+    @sa @ref from_bson(detail::input_adapter&&, const bool, const bool) for
+        the related BSON format
+
+    @since version 2.0.9; parameter @a start_index since 2.1.1; changed to
+           consume input adapters, removed start_index parameter, and added
+           @a strict parameter since 3.0.0; added @a allow_exceptions parameter
+           since 3.2.0
+    */
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_msgpack(detail::input_adapter&& i,
+                                   const bool strict = true,
+                                   const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        const bool res = binary_reader(detail::input_adapter(i)).sax_parse(input_format_t::msgpack, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /*!
+    @copydoc from_msgpack(detail::input_adapter&&, const bool, const bool)
+    */
+    template<typename A1, typename A2,
+             detail::enable_if_t<std::is_constructible<detail::input_adapter, A1, A2>::value, int> = 0>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_msgpack(A1 && a1, A2 && a2,
+                                   const bool strict = true,
+                                   const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        const bool res = binary_reader(detail::input_adapter(std::forward<A1>(a1), std::forward<A2>(a2))).sax_parse(input_format_t::msgpack, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /*!
+    @brief create a JSON value from an input in UBJSON format
+
+    Deserializes a given input @a i to a JSON value using the UBJSON (Universal
+    Binary JSON) serialization format.
+
+    The library maps UBJSON types to JSON value types as follows:
+
+    UBJSON type | JSON value type                         | marker
+    ----------- | --------------------------------------- | ------
+    no-op       | *no value, next value is read*          | `N`
+    null        | `null`                                  | `Z`
+    false       | `false`                                 | `F`
+    true        | `true`                                  | `T`
+    float32     | number_float                            | `d`
+    float64     | number_float                            | `D`
+    uint8       | number_unsigned                         | `U`
+    int8        | number_integer                          | `i`
+    int16       | number_integer                          | `I`
+    int32       | number_integer                          | `l`
+    int64       | number_integer                          | `L`
+    string      | string                                  | `S`
+    char        | string                                  | `C`
+    array       | array (optimized values are supported)  | `[`
+    object      | object (optimized values are supported) | `{`
+
+    @note The mapping is **complete** in the sense that any UBJSON value can
+          be converted to a JSON value.
+
+    @param[in] i  an input in UBJSON format convertible to an input adapter
+    @param[in] strict  whether to expect the input to be consumed until EOF
+                       (true by default)
+    @param[in] allow_exceptions  whether to throw exceptions in case of a
+    parse error (optional, true by default)
+
+    @return deserialized JSON value; in case of a parse error and
+            @a allow_exceptions set to `false`, the return value will be
+            value_t::discarded.
+
+    @throw parse_error.110 if the given input ends prematurely or the end of
+    file was not reached when @a strict was set to true
+    @throw parse_error.112 if a parse error occurs
+    @throw parse_error.113 if a string could not be parsed successfully
+
+    @complexity Linear in the size of the input @a i.
+
+    @liveexample{The example shows the deserialization of a byte vector in
+    UBJSON format to a JSON value.,from_ubjson}
+
+    @sa http://ubjson.org
+    @sa @ref to_ubjson(const basic_json&, const bool, const bool) for the
+             analogous serialization
+    @sa @ref from_cbor(detail::input_adapter&&, const bool, const bool) for the
+        related CBOR format
+    @sa @ref from_msgpack(detail::input_adapter&&, const bool, const bool) for
+        the related MessagePack format
+    @sa @ref from_bson(detail::input_adapter&&, const bool, const bool) for
+        the related BSON format
+
+    @since version 3.1.0; added @a allow_exceptions parameter since 3.2.0
+    */
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_ubjson(detail::input_adapter&& i,
+                                  const bool strict = true,
+                                  const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        const bool res = binary_reader(detail::input_adapter(i)).sax_parse(input_format_t::ubjson, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /*!
+    @copydoc from_ubjson(detail::input_adapter&&, const bool, const bool)
+    */
+    template<typename A1, typename A2,
+             detail::enable_if_t<std::is_constructible<detail::input_adapter, A1, A2>::value, int> = 0>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_ubjson(A1 && a1, A2 && a2,
+                                  const bool strict = true,
+                                  const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        const bool res = binary_reader(detail::input_adapter(std::forward<A1>(a1), std::forward<A2>(a2))).sax_parse(input_format_t::ubjson, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /*!
+    @brief Create a JSON value from an input in BSON format
+
+    Deserializes a given input @a i to a JSON value using the BSON (Binary JSON)
+    serialization format.
+
+    The library maps BSON record types to JSON value types as follows:
+
+    BSON type       | BSON marker byte | JSON value type
+    --------------- | ---------------- | ---------------------------
+    double          | 0x01             | number_float
+    string          | 0x02             | string
+    document        | 0x03             | object
+    array           | 0x04             | array
+    binary          | 0x05             | still unsupported
+    undefined       | 0x06             | still unsupported
+    ObjectId        | 0x07             | still unsupported
+    boolean         | 0x08             | boolean
+    UTC Date-Time   | 0x09             | still unsupported
+    null            | 0x0A             | null
+    Regular Expr.   | 0x0B             | still unsupported
+    DB Pointer      | 0x0C             | still unsupported
+    JavaScript Code | 0x0D             | still unsupported
+    Symbol          | 0x0E             | still unsupported
+    JavaScript Code | 0x0F             | still unsupported
+    int32           | 0x10             | number_integer
+    Timestamp       | 0x11             | still unsupported
+    128-bit decimal float | 0x13       | still unsupported
+    Max Key         | 0x7F             | still unsupported
+    Min Key         | 0xFF             | still unsupported
+
+    @warning The mapping is **incomplete**. The unsupported mappings
+             are indicated in the table above.
+
+    @param[in] i  an input in BSON format convertible to an input adapter
+    @param[in] strict  whether to expect the input to be consumed until EOF
+                       (true by default)
+    @param[in] allow_exceptions  whether to throw exceptions in case of a
+    parse error (optional, true by default)
+
+    @return deserialized JSON value; in case of a parse error and
+            @a allow_exceptions set to `false`, the return value will be
+            value_t::discarded.
+
+    @throw parse_error.114 if an unsupported BSON record type is encountered
+
+    @complexity Linear in the size of the input @a i.
+
+    @liveexample{The example shows the deserialization of a byte vector in
+    BSON format to a JSON value.,from_bson}
+
+    @sa http://bsonspec.org/spec.html
+    @sa @ref to_bson(const basic_json&) for the analogous serialization
+    @sa @ref from_cbor(detail::input_adapter&&, const bool, const bool) for the
+        related CBOR format
+    @sa @ref from_msgpack(detail::input_adapter&&, const bool, const bool) for
+        the related MessagePack format
+    @sa @ref from_ubjson(detail::input_adapter&&, const bool, const bool) for the
+        related UBJSON format
+    */
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_bson(detail::input_adapter&& i,
+                                const bool strict = true,
+                                const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        const bool res = binary_reader(detail::input_adapter(i)).sax_parse(input_format_t::bson, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+    /*!
+    @copydoc from_bson(detail::input_adapter&&, const bool, const bool)
+    */
+    template<typename A1, typename A2,
+             detail::enable_if_t<std::is_constructible<detail::input_adapter, A1, A2>::value, int> = 0>
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json from_bson(A1 && a1, A2 && a2,
+                                const bool strict = true,
+                                const bool allow_exceptions = true)
+    {
+        basic_json result;
+        detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
+        const bool res = binary_reader(detail::input_adapter(std::forward<A1>(a1), std::forward<A2>(a2))).sax_parse(input_format_t::bson, &sdp, strict);
+        return res ? result : basic_json(value_t::discarded);
+    }
+
+
+
+    /// @}
+
+    //////////////////////////
+    // JSON Pointer support //
+    //////////////////////////
+
+    /// @name JSON Pointer functions
+    /// @{
+
+    /*!
+    @brief access specified element via JSON Pointer
+
+    Uses a JSON pointer to retrieve a reference to the respective JSON value.
+    No bound checking is performed. Similar to @ref operator[](const typename
+    object_t::key_type&), `null` values are created in arrays and objects if
+    necessary.
+
+    In particular:
+    - If the JSON pointer points to an object key that does not exist, it
+      is created an filled with a `null` value before a reference to it
+      is returned.
+    - If the JSON pointer points to an array index that does not exist, it
+      is created an filled with a `null` value before a reference to it
+      is returned. All indices between the current maximum and the given
+      index are also filled with `null`.
+    - The special value `-` is treated as a synonym for the index past the
+      end.
+
+    @param[in] ptr  a JSON pointer
+
+    @return reference to the element pointed to by @a ptr
+
+    @complexity Constant.
+
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    @throw out_of_range.404  if the JSON pointer can not be resolved
+
+    @liveexample{The behavior is shown in the example.,operatorjson_pointer}
+
+    @since version 2.0.0
+    */
+    reference operator[](const json_pointer& ptr)
+    {
+        return ptr.get_unchecked(this);
+    }
+
+    /*!
+    @brief access specified element via JSON Pointer
+
+    Uses a JSON pointer to retrieve a reference to the respective JSON value.
+    No bound checking is performed. The function does not change the JSON
+    value; no `null` values are created. In particular, the the special value
+    `-` yields an exception.
+
+    @param[in] ptr  JSON pointer to the desired element
+
+    @return const reference to the element pointed to by @a ptr
+
+    @complexity Constant.
+
+    @throw parse_error.106   if an array index begins with '0'
+    @throw parse_error.109   if an array index was not a number
+    @throw out_of_range.402  if the array index '-' is used
+    @throw out_of_range.404  if the JSON pointer can not be resolved
+
+    @liveexample{The behavior is shown in the example.,operatorjson_pointer_const}
+
+    @since version 2.0.0
+    */
+    const_reference operator[](const json_pointer& ptr) const
+    {
+        return ptr.get_unchecked(this);
+    }
+
+    /*!
+    @brief access specified element via JSON Pointer
+
+    Returns a reference to the element at with specified JSON pointer @a ptr,
+    with bounds checking.
+
+    @param[in] ptr  JSON pointer to the desired element
+
+    @return reference to the element pointed to by @a ptr
+
+    @throw parse_error.106 if an array index in the passed JSON pointer @a ptr
+    begins with '0'. See example below.
+
+    @throw parse_error.109 if an array index in the passed JSON pointer @a ptr
+    is not a number. See example below.
+
+    @throw out_of_range.401 if an array index in the passed JSON pointer @a ptr
+    is out of range. See example below.
+
+    @throw out_of_range.402 if the array index '-' is used in the passed JSON
+    pointer @a ptr. As `at` provides checked access (and no elements are
+    implicitly inserted), the index '-' is always invalid. See example below.
+
+    @throw out_of_range.403 if the JSON pointer describes a key of an object
+    which cannot be found. See example below.
+
+    @throw out_of_range.404 if the JSON pointer @a ptr can not be resolved.
+    See example below.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes in the JSON value.
+
+    @complexity Constant.
+
+    @since version 2.0.0
+
+    @liveexample{The behavior is shown in the example.,at_json_pointer}
+    */
+    reference at(const json_pointer& ptr)
+    {
+        return ptr.get_checked(this);
+    }
+
+    /*!
+    @brief access specified element via JSON Pointer
+
+    Returns a const reference to the element at with specified JSON pointer @a
+    ptr, with bounds checking.
+
+    @param[in] ptr  JSON pointer to the desired element
+
+    @return reference to the element pointed to by @a ptr
+
+    @throw parse_error.106 if an array index in the passed JSON pointer @a ptr
+    begins with '0'. See example below.
+
+    @throw parse_error.109 if an array index in the passed JSON pointer @a ptr
+    is not a number. See example below.
+
+    @throw out_of_range.401 if an array index in the passed JSON pointer @a ptr
+    is out of range. See example below.
+
+    @throw out_of_range.402 if the array index '-' is used in the passed JSON
+    pointer @a ptr. As `at` provides checked access (and no elements are
+    implicitly inserted), the index '-' is always invalid. See example below.
+
+    @throw out_of_range.403 if the JSON pointer describes a key of an object
+    which cannot be found. See example below.
+
+    @throw out_of_range.404 if the JSON pointer @a ptr can not be resolved.
+    See example below.
+
+    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
+    changes in the JSON value.
+
+    @complexity Constant.
+
+    @since version 2.0.0
+
+    @liveexample{The behavior is shown in the example.,at_json_pointer_const}
+    */
+    const_reference at(const json_pointer& ptr) const
+    {
+        return ptr.get_checked(this);
+    }
+
+    /*!
+    @brief return flattened JSON value
+
+    The function creates a JSON object whose keys are JSON pointers (see [RFC
+    6901](https://tools.ietf.org/html/rfc6901)) and whose values are all
+    primitive. The original JSON value can be restored using the @ref
+    unflatten() function.
+
+    @return an object that maps JSON pointers to primitive values
+
+    @note Empty objects and arrays are flattened to `null` and will not be
+          reconstructed correctly by the @ref unflatten() function.
+
+    @complexity Linear in the size the JSON value.
+
+    @liveexample{The following code shows how a JSON object is flattened to an
+    object whose keys consist of JSON pointers.,flatten}
+
+    @sa @ref unflatten() for the reverse function
+
+    @since version 2.0.0
+    */
+    basic_json flatten() const
+    {
+        basic_json result(value_t::object);
+        json_pointer::flatten("", *this, result);
+        return result;
+    }
+
+    /*!
+    @brief unflatten a previously flattened JSON value
+
+    The function restores the arbitrary nesting of a JSON value that has been
+    flattened before using the @ref flatten() function. The JSON value must
+    meet certain constraints:
+    1. The value must be an object.
+    2. The keys must be JSON pointers (see
+       [RFC 6901](https://tools.ietf.org/html/rfc6901))
+    3. The mapped values must be primitive JSON types.
+
+    @return the original JSON from a flattened version
+
+    @note Empty objects and arrays are flattened by @ref flatten() to `null`
+          values and can not unflattened to their original type. Apart from
+          this example, for a JSON value `j`, the following is always true:
+          `j == j.flatten().unflatten()`.
+
+    @complexity Linear in the size the JSON value.
+
+    @throw type_error.314  if value is not an object
+    @throw type_error.315  if object values are not primitive
+
+    @liveexample{The following code shows how a flattened JSON object is
+    unflattened into the original nested JSON object.,unflatten}
+
+    @sa @ref flatten() for the reverse function
+
+    @since version 2.0.0
+    */
+    basic_json unflatten() const
+    {
+        return json_pointer::unflatten(*this);
+    }
+
+    /// @}
+
+    //////////////////////////
+    // JSON Patch functions //
+    //////////////////////////
+
+    /// @name JSON Patch functions
+    /// @{
+
+    /*!
+    @brief applies a JSON patch
+
+    [JSON Patch](http://jsonpatch.com) defines a JSON document structure for
+    expressing a sequence of operations to apply to a JSON) document. With
+    this function, a JSON Patch is applied to the current JSON value by
+    executing all operations from the patch.
+
+    @param[in] json_patch  JSON patch document
+    @return patched document
+
+    @note The application of a patch is atomic: Either all operations succeed
+          and the patched document is returned or an exception is thrown. In
+          any case, the original value is not changed: the patch is applied
+          to a copy of the value.
+
+    @throw parse_error.104 if the JSON patch does not consist of an array of
+    objects
+
+    @throw parse_error.105 if the JSON patch is malformed (e.g., mandatory
+    attributes are missing); example: `"operation add must have member path"`
+
+    @throw out_of_range.401 if an array index is out of range.
+
+    @throw out_of_range.403 if a JSON pointer inside the patch could not be
+    resolved successfully in the current JSON value; example: `"key baz not
+    found"`
+
+    @throw out_of_range.405 if JSON pointer has no parent ("add", "remove",
+    "move")
+
+    @throw other_error.501 if "test" operation was unsuccessful
+
+    @complexity Linear in the size of the JSON value and the length of the
+    JSON patch. As usually only a fraction of the JSON value is affected by
+    the patch, the complexity can usually be neglected.
+
+    @liveexample{The following code shows how a JSON patch is applied to a
+    value.,patch}
+
+    @sa @ref diff -- create a JSON patch by comparing two JSON values
+
+    @sa [RFC 6902 (JSON Patch)](https://tools.ietf.org/html/rfc6902)
+    @sa [RFC 6901 (JSON Pointer)](https://tools.ietf.org/html/rfc6901)
+
+    @since version 2.0.0
+    */
+    basic_json patch(const basic_json& json_patch) const
+    {
+        // make a working copy to apply the patch to
+        basic_json result = *this;
+
+        // the valid JSON Patch operations
+        enum class patch_operations {add, remove, replace, move, copy, test, invalid};
+
+        const auto get_op = [](const std::string & op)
+        {
+            if (op == "add")
+            {
+                return patch_operations::add;
+            }
+            if (op == "remove")
+            {
+                return patch_operations::remove;
+            }
+            if (op == "replace")
+            {
+                return patch_operations::replace;
+            }
+            if (op == "move")
+            {
+                return patch_operations::move;
+            }
+            if (op == "copy")
+            {
+                return patch_operations::copy;
+            }
+            if (op == "test")
+            {
+                return patch_operations::test;
+            }
+
+            return patch_operations::invalid;
+        };
+
+        // wrapper for "add" operation; add value at ptr
+        const auto operation_add = [&result](json_pointer & ptr, basic_json val)
+        {
+            // adding to the root of the target document means replacing it
+            if (ptr.empty())
+            {
+                result = val;
+                return;
+            }
+
+            // make sure the top element of the pointer exists
+            json_pointer top_pointer = ptr.top();
+            if (top_pointer != ptr)
+            {
+                result.at(top_pointer);
+            }
+
+            // get reference to parent of JSON pointer ptr
+            const auto last_path = ptr.back();
+            ptr.pop_back();
+            basic_json& parent = result[ptr];
+
+            switch (parent.m_type)
+            {
+                case value_t::null:
+                case value_t::object:
+                {
+                    // use operator[] to add value
+                    parent[last_path] = val;
+                    break;
+                }
+
+                case value_t::array:
+                {
+                    if (last_path == "-")
+                    {
+                        // special case: append to back
+                        parent.push_back(val);
+                    }
+                    else
+                    {
+                        const auto idx = json_pointer::array_index(last_path);
+                        if (JSON_HEDLEY_UNLIKELY(static_cast<size_type>(idx) > parent.size()))
+                        {
+                            // avoid undefined behavior
+                            JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));
+                        }
+
+                        // default case: insert add offset
+                        parent.insert(parent.begin() + static_cast<difference_type>(idx), val);
+                    }
+                    break;
+                }
+
+                // if there exists a parent it cannot be primitive
+                default:            // LCOV_EXCL_LINE
+                    assert(false);  // LCOV_EXCL_LINE
+            }
+        };
+
+        // wrapper for "remove" operation; remove value at ptr
+        const auto operation_remove = [&result](json_pointer & ptr)
+        {
+            // get reference to parent of JSON pointer ptr
+            const auto last_path = ptr.back();
+            ptr.pop_back();
+            basic_json& parent = result.at(ptr);
+
+            // remove child
+            if (parent.is_object())
+            {
+                // perform range check
+                auto it = parent.find(last_path);
+                if (JSON_HEDLEY_LIKELY(it != parent.end()))
+                {
+                    parent.erase(it);
+                }
+                else
+                {
+                    JSON_THROW(out_of_range::create(403, "key '" + last_path + "' not found"));
+                }
+            }
+            else if (parent.is_array())
+            {
+                // note erase performs range check
+                parent.erase(static_cast<size_type>(json_pointer::array_index(last_path)));
+            }
+        };
+
+        // type check: top level value must be an array
+        if (JSON_HEDLEY_UNLIKELY(not json_patch.is_array()))
+        {
+            JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects"));
+        }
+
+        // iterate and apply the operations
+        for (const auto& val : json_patch)
+        {
+            // wrapper to get a value for an operation
+            const auto get_value = [&val](const std::string & op,
+                                          const std::string & member,
+                                          bool string_type) -> basic_json &
+            {
+                // find value
+                auto it = val.m_value.object->find(member);
+
+                // context-sensitive error message
+                const auto error_msg = (op == "op") ? "operation" : "operation '" + op + "'";
+
+                // check if desired value is present
+                if (JSON_HEDLEY_UNLIKELY(it == val.m_value.object->end()))
+                {
+                    JSON_THROW(parse_error::create(105, 0, error_msg + " must have member '" + member + "'"));
+                }
+
+                // check if result is of type string
+                if (JSON_HEDLEY_UNLIKELY(string_type and not it->second.is_string()))
+                {
+                    JSON_THROW(parse_error::create(105, 0, error_msg + " must have string member '" + member + "'"));
+                }
+
+                // no error: return value
+                return it->second;
+            };
+
+            // type check: every element of the array must be an object
+            if (JSON_HEDLEY_UNLIKELY(not val.is_object()))
+            {
+                JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects"));
+            }
+
+            // collect mandatory members
+            const std::string op = get_value("op", "op", true);
+            const std::string path = get_value(op, "path", true);
+            json_pointer ptr(path);
+
+            switch (get_op(op))
+            {
+                case patch_operations::add:
+                {
+                    operation_add(ptr, get_value("add", "value", false));
+                    break;
+                }
+
+                case patch_operations::remove:
+                {
+                    operation_remove(ptr);
+                    break;
+                }
+
+                case patch_operations::replace:
+                {
+                    // the "path" location must exist - use at()
+                    result.at(ptr) = get_value("replace", "value", false);
+                    break;
+                }
+
+                case patch_operations::move:
+                {
+                    const std::string from_path = get_value("move", "from", true);
+                    json_pointer from_ptr(from_path);
+
+                    // the "from" location must exist - use at()
+                    basic_json v = result.at(from_ptr);
+
+                    // The move operation is functionally identical to a
+                    // "remove" operation on the "from" location, followed
+                    // immediately by an "add" operation at the target
+                    // location with the value that was just removed.
+                    operation_remove(from_ptr);
+                    operation_add(ptr, v);
+                    break;
+                }
+
+                case patch_operations::copy:
+                {
+                    const std::string from_path = get_value("copy", "from", true);
+                    const json_pointer from_ptr(from_path);
+
+                    // the "from" location must exist - use at()
+                    basic_json v = result.at(from_ptr);
+
+                    // The copy is functionally identical to an "add"
+                    // operation at the target location using the value
+                    // specified in the "from" member.
+                    operation_add(ptr, v);
+                    break;
+                }
+
+                case patch_operations::test:
+                {
+                    bool success = false;
+                    JSON_TRY
+                    {
+                        // check if "value" matches the one at "path"
+                        // the "path" location must exist - use at()
+                        success = (result.at(ptr) == get_value("test", "value", false));
+                    }
+                    JSON_INTERNAL_CATCH (out_of_range&)
+                    {
+                        // ignore out of range errors: success remains false
+                    }
+
+                    // throw an exception if test fails
+                    if (JSON_HEDLEY_UNLIKELY(not success))
+                    {
+                        JSON_THROW(other_error::create(501, "unsuccessful: " + val.dump()));
+                    }
+
+                    break;
+                }
+
+                default:
+                {
+                    // op must be "add", "remove", "replace", "move", "copy", or
+                    // "test"
+                    JSON_THROW(parse_error::create(105, 0, "operation value '" + op + "' is invalid"));
+                }
+            }
+        }
+
+        return result;
+    }
+
+    /*!
+    @brief creates a diff as a JSON patch
+
+    Creates a [JSON Patch](http://jsonpatch.com) so that value @a source can
+    be changed into the value @a target by calling @ref patch function.
+
+    @invariant For two JSON values @a source and @a target, the following code
+    yields always `true`:
+    @code {.cpp}
+    source.patch(diff(source, target)) == target;
+    @endcode
+
+    @note Currently, only `remove`, `add`, and `replace` operations are
+          generated.
+
+    @param[in] source  JSON value to compare from
+    @param[in] target  JSON value to compare against
+    @param[in] path    helper value to create JSON pointers
+
+    @return a JSON patch to convert the @a source to @a target
+
+    @complexity Linear in the lengths of @a source and @a target.
+
+    @liveexample{The following code shows how a JSON patch is created as a
+    diff for two JSON values.,diff}
+
+    @sa @ref patch -- apply a JSON patch
+    @sa @ref merge_patch -- apply a JSON Merge Patch
+
+    @sa [RFC 6902 (JSON Patch)](https://tools.ietf.org/html/rfc6902)
+
+    @since version 2.0.0
+    */
+    JSON_HEDLEY_WARN_UNUSED_RESULT
+    static basic_json diff(const basic_json& source, const basic_json& target,
+                           const std::string& path = "")
+    {
+        // the patch
+        basic_json result(value_t::array);
+
+        // if the values are the same, return empty patch
+        if (source == target)
+        {
+            return result;
+        }
+
+        if (source.type() != target.type())
+        {
+            // different types: replace value
+            result.push_back(
+            {
+                {"op", "replace"}, {"path", path}, {"value", target}
+            });
+            return result;
+        }
+
+        switch (source.type())
+        {
+            case value_t::array:
+            {
+                // first pass: traverse common elements
+                std::size_t i = 0;
+                while (i < source.size() and i < target.size())
+                {
+                    // recursive call to compare array values at index i
+                    auto temp_diff = diff(source[i], target[i], path + "/" + std::to_string(i));
+                    result.insert(result.end(), temp_diff.begin(), temp_diff.end());
+                    ++i;
+                }
+
+                // i now reached the end of at least one array
+                // in a second pass, traverse the remaining elements
+
+                // remove my remaining elements
+                const auto end_index = static_cast<difference_type>(result.size());
+                while (i < source.size())
+                {
+                    // add operations in reverse order to avoid invalid
+                    // indices
+                    result.insert(result.begin() + end_index, object(
+                    {
+                        {"op", "remove"},
+                        {"path", path + "/" + std::to_string(i)}
+                    }));
+                    ++i;
+                }
+
+                // add other remaining elements
+                while (i < target.size())
+                {
+                    result.push_back(
+                    {
+                        {"op", "add"},
+                        {"path", path + "/" + std::to_string(i)},
+                        {"value", target[i]}
+                    });
+                    ++i;
+                }
+
+                break;
+            }
+
+            case value_t::object:
+            {
+                // first pass: traverse this object's elements
+                for (auto it = source.cbegin(); it != source.cend(); ++it)
+                {
+                    // escape the key name to be used in a JSON patch
+                    const auto key = json_pointer::escape(it.key());
+
+                    if (target.find(it.key()) != target.end())
+                    {
+                        // recursive call to compare object values at key it
+                        auto temp_diff = diff(it.value(), target[it.key()], path + "/" + key);
+                        result.insert(result.end(), temp_diff.begin(), temp_diff.end());
+                    }
+                    else
+                    {
+                        // found a key that is not in o -> remove it
+                        result.push_back(object(
+                        {
+                            {"op", "remove"}, {"path", path + "/" + key}
+                        }));
+                    }
+                }
+
+                // second pass: traverse other object's elements
+                for (auto it = target.cbegin(); it != target.cend(); ++it)
+                {
+                    if (source.find(it.key()) == source.end())
+                    {
+                        // found a key that is not in this -> add it
+                        const auto key = json_pointer::escape(it.key());
+                        result.push_back(
+                        {
+                            {"op", "add"}, {"path", path + "/" + key},
+                            {"value", it.value()}
+                        });
+                    }
+                }
+
+                break;
+            }
+
+            default:
+            {
+                // both primitive type: replace value
+                result.push_back(
+                {
+                    {"op", "replace"}, {"path", path}, {"value", target}
+                });
+                break;
+            }
+        }
+
+        return result;
+    }
+
+    /// @}
+
+    ////////////////////////////////
+    // JSON Merge Patch functions //
+    ////////////////////////////////
+
+    /// @name JSON Merge Patch functions
+    /// @{
+
+    /*!
+    @brief applies a JSON Merge Patch
+
+    The merge patch format is primarily intended for use with the HTTP PATCH
+    method as a means of describing a set of modifications to a target
+    resource's content. This function applies a merge patch to the current
+    JSON value.
+
+    The function implements the following algorithm from Section 2 of
+    [RFC 7396 (JSON Merge Patch)](https://tools.ietf.org/html/rfc7396):
+
+    ```
+    define MergePatch(Target, Patch):
+      if Patch is an Object:
+        if Target is not an Object:
+          Target = {} // Ignore the contents and set it to an empty Object
+        for each Name/Value pair in Patch:
+          if Value is null:
+            if Name exists in Target:
+              remove the Name/Value pair from Target
+          else:
+            Target[Name] = MergePatch(Target[Name], Value)
+        return Target
+      else:
+        return Patch
+    ```
+
+    Thereby, `Target` is the current object; that is, the patch is applied to
+    the current value.
+
+    @param[in] apply_patch  the patch to apply
+
+    @complexity Linear in the lengths of @a patch.
+
+    @liveexample{The following code shows how a JSON Merge Patch is applied to
+    a JSON document.,merge_patch}
+
+    @sa @ref patch -- apply a JSON patch
+    @sa [RFC 7396 (JSON Merge Patch)](https://tools.ietf.org/html/rfc7396)
+
+    @since version 3.0.0
+    */
+    void merge_patch(const basic_json& apply_patch)
+    {
+        if (apply_patch.is_object())
+        {
+            if (not is_object())
+            {
+                *this = object();
+            }
+            for (auto it = apply_patch.begin(); it != apply_patch.end(); ++it)
+            {
+                if (it.value().is_null())
+                {
+                    erase(it.key());
+                }
+                else
+                {
+                    operator[](it.key()).merge_patch(it.value());
+                }
+            }
+        }
+        else
+        {
+            *this = apply_patch;
+        }
+    }
+
+    /// @}
+};
+
+/*!
+@brief user-defined to_string function for JSON values
+
+This function implements a user-defined to_string  for JSON objects.
+
+@param[in] j  a JSON object
+@return a std::string object
+*/
+
+NLOHMANN_BASIC_JSON_TPL_DECLARATION
+std::string to_string(const NLOHMANN_BASIC_JSON_TPL& j)
+{
+    return j.dump();
+}
+} // namespace nlohmann
+
+///////////////////////
+// nonmember support //
+///////////////////////
+
+// specialization of std::swap, and std::hash
+namespace std
+{
+
+/// hash value for JSON objects
+template<>
+struct hash<nlohmann::json>
+{
+    /*!
+    @brief return a hash value for a JSON object
+
+    @since version 1.0.0
+    */
+    std::size_t operator()(const nlohmann::json& j) const
+    {
+        // a naive hashing via the string representation
+        const auto& h = hash<nlohmann::json::string_t>();
+        return h(j.dump());
+    }
+};
+
+/// specialization for std::less<value_t>
+/// @note: do not remove the space after '<',
+///        see https://github.com/nlohmann/json/pull/679
+template<>
+struct less< ::nlohmann::detail::value_t>
+{
+    /*!
+    @brief compare two value_t enum values
+    @since version 3.0.0
+    */
+    bool operator()(nlohmann::detail::value_t lhs,
+                    nlohmann::detail::value_t rhs) const noexcept
+    {
+        return nlohmann::detail::operator<(lhs, rhs);
+    }
+};
+
+/*!
+@brief exchanges the values of two JSON objects
+
+@since version 1.0.0
+*/
+template<>
+inline void swap<nlohmann::json>(nlohmann::json& j1, nlohmann::json& j2) noexcept(
+    is_nothrow_move_constructible<nlohmann::json>::value and
+    is_nothrow_move_assignable<nlohmann::json>::value
+)
+{
+    j1.swap(j2);
+}
+
+} // namespace std
+
+/*!
+@brief user-defined string literal for JSON values
+
+This operator implements a user-defined string literal for JSON objects. It
+can be used by adding `"_json"` to a string literal and returns a JSON object
+if no parse error occurred.
+
+@param[in] s  a string representation of a JSON object
+@param[in] n  the length of string @a s
+@return a JSON object
+
+@since version 1.0.0
+*/
+JSON_HEDLEY_NON_NULL(1)
+inline nlohmann::json operator "" _json(const char* s, std::size_t n)
+{
+    return nlohmann::json::parse(s, s + n);
+}
+
+/*!
+@brief user-defined string literal for JSON pointer
+
+This operator implements a user-defined string literal for JSON Pointers. It
+can be used by adding `"_json_pointer"` to a string literal and returns a JSON pointer
+object if no parse error occurred.
+
+@param[in] s  a string representation of a JSON Pointer
+@param[in] n  the length of string @a s
+@return a JSON pointer object
+
+@since version 2.0.0
+*/
+JSON_HEDLEY_NON_NULL(1)
+inline nlohmann::json::json_pointer operator "" _json_pointer(const char* s, std::size_t n)
+{
+    return nlohmann::json::json_pointer(std::string(s, n));
+}
+
+// #include <nlohmann/detail/macro_unscope.hpp>
+
+
+// restore GCC/clang diagnostic settings
+#if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
+    #pragma GCC diagnostic pop
+#endif
+#if defined(__clang__)
+    #pragma GCC diagnostic pop
+#endif
+
+// clean up
+#undef JSON_INTERNAL_CATCH
+#undef JSON_CATCH
+#undef JSON_THROW
+#undef JSON_TRY
+#undef JSON_HAS_CPP_14
+#undef JSON_HAS_CPP_17
+#undef NLOHMANN_BASIC_JSON_TPL_DECLARATION
+#undef NLOHMANN_BASIC_JSON_TPL
+
+// #include <nlohmann/thirdparty/hedley/hedley_undef.hpp>
+#undef JSON_HEDLEY_ALWAYS_INLINE
+#undef JSON_HEDLEY_ARM_VERSION
+#undef JSON_HEDLEY_ARM_VERSION_CHECK
+#undef JSON_HEDLEY_ARRAY_PARAM
+#undef JSON_HEDLEY_ASSUME
+#undef JSON_HEDLEY_BEGIN_C_DECLS
+#undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
+#undef JSON_HEDLEY_CLANG_HAS_BUILTIN
+#undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
+#undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
+#undef JSON_HEDLEY_CLANG_HAS_EXTENSION
+#undef JSON_HEDLEY_CLANG_HAS_FEATURE
+#undef JSON_HEDLEY_CLANG_HAS_WARNING
+#undef JSON_HEDLEY_COMPCERT_VERSION
+#undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
+#undef JSON_HEDLEY_CONCAT
+#undef JSON_HEDLEY_CONCAT_EX
+#undef JSON_HEDLEY_CONST
+#undef JSON_HEDLEY_CONSTEXPR
+#undef JSON_HEDLEY_CONST_CAST
+#undef JSON_HEDLEY_CPP_CAST
+#undef JSON_HEDLEY_CRAY_VERSION
+#undef JSON_HEDLEY_CRAY_VERSION_CHECK
+#undef JSON_HEDLEY_C_DECL
+#undef JSON_HEDLEY_DEPRECATED
+#undef JSON_HEDLEY_DEPRECATED_FOR
+#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
+#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
+#undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
+#undef JSON_HEDLEY_DIAGNOSTIC_POP
+#undef JSON_HEDLEY_DIAGNOSTIC_PUSH
+#undef JSON_HEDLEY_DMC_VERSION
+#undef JSON_HEDLEY_DMC_VERSION_CHECK
+#undef JSON_HEDLEY_EMSCRIPTEN_VERSION
+#undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
+#undef JSON_HEDLEY_END_C_DECLS
+#undef JSON_HEDLEY_FALL_THROUGH
+#undef JSON_HEDLEY_FLAGS
+#undef JSON_HEDLEY_FLAGS_CAST
+#undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
+#undef JSON_HEDLEY_GCC_HAS_BUILTIN
+#undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
+#undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
+#undef JSON_HEDLEY_GCC_HAS_EXTENSION
+#undef JSON_HEDLEY_GCC_HAS_FEATURE
+#undef JSON_HEDLEY_GCC_HAS_WARNING
+#undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
+#undef JSON_HEDLEY_GCC_VERSION
+#undef JSON_HEDLEY_GCC_VERSION_CHECK
+#undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
+#undef JSON_HEDLEY_GNUC_HAS_BUILTIN
+#undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
+#undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
+#undef JSON_HEDLEY_GNUC_HAS_EXTENSION
+#undef JSON_HEDLEY_GNUC_HAS_FEATURE
+#undef JSON_HEDLEY_GNUC_HAS_WARNING
+#undef JSON_HEDLEY_GNUC_VERSION
+#undef JSON_HEDLEY_GNUC_VERSION_CHECK
+#undef JSON_HEDLEY_HAS_ATTRIBUTE
+#undef JSON_HEDLEY_HAS_BUILTIN
+#undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
+#undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
+#undef JSON_HEDLEY_HAS_EXTENSION
+#undef JSON_HEDLEY_HAS_FEATURE
+#undef JSON_HEDLEY_HAS_WARNING
+#undef JSON_HEDLEY_IAR_VERSION
+#undef JSON_HEDLEY_IAR_VERSION_CHECK
+#undef JSON_HEDLEY_IBM_VERSION
+#undef JSON_HEDLEY_IBM_VERSION_CHECK
+#undef JSON_HEDLEY_IMPORT
+#undef JSON_HEDLEY_INLINE
+#undef JSON_HEDLEY_INTEL_VERSION
+#undef JSON_HEDLEY_INTEL_VERSION_CHECK
+#undef JSON_HEDLEY_IS_CONSTANT
+#undef JSON_HEDLEY_LIKELY
+#undef JSON_HEDLEY_MALLOC
+#undef JSON_HEDLEY_MESSAGE
+#undef JSON_HEDLEY_MSVC_VERSION
+#undef JSON_HEDLEY_MSVC_VERSION_CHECK
+#undef JSON_HEDLEY_NEVER_INLINE
+#undef JSON_HEDLEY_NON_NULL
+#undef JSON_HEDLEY_NO_RETURN
+#undef JSON_HEDLEY_NO_THROW
+#undef JSON_HEDLEY_PELLES_VERSION
+#undef JSON_HEDLEY_PELLES_VERSION_CHECK
+#undef JSON_HEDLEY_PGI_VERSION
+#undef JSON_HEDLEY_PGI_VERSION_CHECK
+#undef JSON_HEDLEY_PREDICT
+#undef JSON_HEDLEY_PRINTF_FORMAT
+#undef JSON_HEDLEY_PRIVATE
+#undef JSON_HEDLEY_PUBLIC
+#undef JSON_HEDLEY_PURE
+#undef JSON_HEDLEY_REINTERPRET_CAST
+#undef JSON_HEDLEY_REQUIRE
+#undef JSON_HEDLEY_REQUIRE_CONSTEXPR
+#undef JSON_HEDLEY_REQUIRE_MSG
+#undef JSON_HEDLEY_RESTRICT
+#undef JSON_HEDLEY_RETURNS_NON_NULL
+#undef JSON_HEDLEY_SENTINEL
+#undef JSON_HEDLEY_STATIC_ASSERT
+#undef JSON_HEDLEY_STATIC_CAST
+#undef JSON_HEDLEY_STRINGIFY
+#undef JSON_HEDLEY_STRINGIFY_EX
+#undef JSON_HEDLEY_SUNPRO_VERSION
+#undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
+#undef JSON_HEDLEY_TINYC_VERSION
+#undef JSON_HEDLEY_TINYC_VERSION_CHECK
+#undef JSON_HEDLEY_TI_VERSION
+#undef JSON_HEDLEY_TI_VERSION_CHECK
+#undef JSON_HEDLEY_UNAVAILABLE
+#undef JSON_HEDLEY_UNLIKELY
+#undef JSON_HEDLEY_UNPREDICTABLE
+#undef JSON_HEDLEY_UNREACHABLE
+#undef JSON_HEDLEY_UNREACHABLE_RETURN
+#undef JSON_HEDLEY_VERSION
+#undef JSON_HEDLEY_VERSION_DECODE_MAJOR
+#undef JSON_HEDLEY_VERSION_DECODE_MINOR
+#undef JSON_HEDLEY_VERSION_DECODE_REVISION
+#undef JSON_HEDLEY_VERSION_ENCODE
+#undef JSON_HEDLEY_WARNING
+#undef JSON_HEDLEY_WARN_UNUSED_RESULT
+
+
+
+#endif  // INCLUDE_NLOHMANN_JSON_HPP_
diff --git a/core/src/grpc/cpp_gen.sh b/core/src/grpc/cpp_gen.sh
new file mode 100644
index 0000000000..62b9d95728
--- /dev/null
+++ b/core/src/grpc/cpp_gen.sh
@@ -0,0 +1,9 @@
+#!/bin/bash
+
+../../cmake-build-debug/grpc_ep-prefix/src/grpc_ep/bins/opt/protobuf/protoc -I . --grpc_out=./gen-status --plugin=protoc-gen-grpc="../../cmake-build-debug/grpc_ep-prefix/src/grpc_ep/bins/opt/grpc_cpp_plugin" status.proto
+
+../../cmake-build-debug/grpc_ep-prefix/src/grpc_ep/bins/opt/protobuf/protoc -I . --cpp_out=./gen-status status.proto
+
+../../cmake-build-debug/grpc_ep-prefix/src/grpc_ep/bins/opt/protobuf/protoc -I . --grpc_out=./gen-milvus --plugin=protoc-gen-grpc="../../cmake-build-debug/grpc_ep-prefix/src/grpc_ep/bins/opt/grpc_cpp_plugin" milvus.proto
+
+../../cmake-build-debug/grpc_ep-prefix/src/grpc_ep/bins/opt/protobuf/protoc -I . --cpp_out=./gen-milvus milvus.proto
\ No newline at end of file
diff --git a/core/src/grpc/gen-milvus/milvus.grpc.pb.cc b/core/src/grpc/gen-milvus/milvus.grpc.pb.cc
new file mode 100644
index 0000000000..82a1b99162
--- /dev/null
+++ b/core/src/grpc/gen-milvus/milvus.grpc.pb.cc
@@ -0,0 +1,673 @@
+// Generated by the gRPC C++ plugin.
+// If you make any local change, they will be lost.
+// source: milvus.proto
+
+#include "milvus.pb.h"
+#include "milvus.grpc.pb.h"
+
+#include <functional>
+#include <grpcpp/impl/codegen/async_stream.h>
+#include <grpcpp/impl/codegen/async_unary_call.h>
+#include <grpcpp/impl/codegen/channel_interface.h>
+#include <grpcpp/impl/codegen/client_unary_call.h>
+#include <grpcpp/impl/codegen/client_callback.h>
+#include <grpcpp/impl/codegen/method_handler_impl.h>
+#include <grpcpp/impl/codegen/rpc_service_method.h>
+#include <grpcpp/impl/codegen/server_callback.h>
+#include <grpcpp/impl/codegen/service_type.h>
+#include <grpcpp/impl/codegen/sync_stream.h>
+namespace milvus {
+namespace grpc {
+
+static const char* MilvusService_method_names[] = {
+  "/milvus.grpc.MilvusService/CreateTable",
+  "/milvus.grpc.MilvusService/HasTable",
+  "/milvus.grpc.MilvusService/DropTable",
+  "/milvus.grpc.MilvusService/CreateIndex",
+  "/milvus.grpc.MilvusService/Insert",
+  "/milvus.grpc.MilvusService/Search",
+  "/milvus.grpc.MilvusService/SearchInFiles",
+  "/milvus.grpc.MilvusService/DescribeTable",
+  "/milvus.grpc.MilvusService/CountTable",
+  "/milvus.grpc.MilvusService/ShowTables",
+  "/milvus.grpc.MilvusService/Cmd",
+  "/milvus.grpc.MilvusService/DeleteByRange",
+  "/milvus.grpc.MilvusService/PreloadTable",
+  "/milvus.grpc.MilvusService/DescribeIndex",
+  "/milvus.grpc.MilvusService/DropIndex",
+};
+
+std::unique_ptr< MilvusService::Stub> MilvusService::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) {
+  (void)options;
+  std::unique_ptr< MilvusService::Stub> stub(new MilvusService::Stub(channel));
+  return stub;
+}
+
+MilvusService::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel)
+  : channel_(channel), rpcmethod_CreateTable_(MilvusService_method_names[0], ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
+  , rpcmethod_HasTable_(MilvusService_method_names[1], ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
+  , rpcmethod_DropTable_(MilvusService_method_names[2], ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
+  , rpcmethod_CreateIndex_(MilvusService_method_names[3], ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
+  , rpcmethod_Insert_(MilvusService_method_names[4], ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
+  , rpcmethod_Search_(MilvusService_method_names[5], ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
+  , rpcmethod_SearchInFiles_(MilvusService_method_names[6], ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
+  , rpcmethod_DescribeTable_(MilvusService_method_names[7], ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
+  , rpcmethod_CountTable_(MilvusService_method_names[8], ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
+  , rpcmethod_ShowTables_(MilvusService_method_names[9], ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
+  , rpcmethod_Cmd_(MilvusService_method_names[10], ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
+  , rpcmethod_DeleteByRange_(MilvusService_method_names[11], ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
+  , rpcmethod_PreloadTable_(MilvusService_method_names[12], ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
+  , rpcmethod_DescribeIndex_(MilvusService_method_names[13], ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
+  , rpcmethod_DropIndex_(MilvusService_method_names[14], ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
+  {}
+
+::grpc::Status MilvusService::Stub::CreateTable(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema& request, ::milvus::grpc::Status* response) {
+  return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_CreateTable_, context, request, response);
+}
+
+void MilvusService::Stub::experimental_async::CreateTable(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)> f) {
+  ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_CreateTable_, context, request, response, std::move(f));
+}
+
+void MilvusService::Stub::experimental_async::CreateTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)> f) {
+  ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_CreateTable_, context, request, response, std::move(f));
+}
+
+void MilvusService::Stub::experimental_async::CreateTable(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_CreateTable_, context, request, response, reactor);
+}
+
+void MilvusService::Stub::experimental_async::CreateTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_CreateTable_, context, request, response, reactor);
+}
+
+::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::AsyncCreateTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_CreateTable_, context, request, true);
+}
+
+::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::PrepareAsyncCreateTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_CreateTable_, context, request, false);
+}
+
+::grpc::Status MilvusService::Stub::HasTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::BoolReply* response) {
+  return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_HasTable_, context, request, response);
+}
+
+void MilvusService::Stub::experimental_async::HasTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::BoolReply* response, std::function<void(::grpc::Status)> f) {
+  ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_HasTable_, context, request, response, std::move(f));
+}
+
+void MilvusService::Stub::experimental_async::HasTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::BoolReply* response, std::function<void(::grpc::Status)> f) {
+  ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_HasTable_, context, request, response, std::move(f));
+}
+
+void MilvusService::Stub::experimental_async::HasTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_HasTable_, context, request, response, reactor);
+}
+
+void MilvusService::Stub::experimental_async::HasTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_HasTable_, context, request, response, reactor);
+}
+
+::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>* MilvusService::Stub::AsyncHasTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::BoolReply>::Create(channel_.get(), cq, rpcmethod_HasTable_, context, request, true);
+}
+
+::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>* MilvusService::Stub::PrepareAsyncHasTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::BoolReply>::Create(channel_.get(), cq, rpcmethod_HasTable_, context, request, false);
+}
+
+::grpc::Status MilvusService::Stub::DropTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::Status* response) {
+  return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_DropTable_, context, request, response);
+}
+
+void MilvusService::Stub::experimental_async::DropTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)> f) {
+  ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DropTable_, context, request, response, std::move(f));
+}
+
+void MilvusService::Stub::experimental_async::DropTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)> f) {
+  ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DropTable_, context, request, response, std::move(f));
+}
+
+void MilvusService::Stub::experimental_async::DropTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DropTable_, context, request, response, reactor);
+}
+
+void MilvusService::Stub::experimental_async::DropTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DropTable_, context, request, response, reactor);
+}
+
+::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::AsyncDropTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_DropTable_, context, request, true);
+}
+
+::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::PrepareAsyncDropTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_DropTable_, context, request, false);
+}
+
+::grpc::Status MilvusService::Stub::CreateIndex(::grpc::ClientContext* context, const ::milvus::grpc::IndexParam& request, ::milvus::grpc::Status* response) {
+  return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_CreateIndex_, context, request, response);
+}
+
+void MilvusService::Stub::experimental_async::CreateIndex(::grpc::ClientContext* context, const ::milvus::grpc::IndexParam* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)> f) {
+  ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_CreateIndex_, context, request, response, std::move(f));
+}
+
+void MilvusService::Stub::experimental_async::CreateIndex(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)> f) {
+  ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_CreateIndex_, context, request, response, std::move(f));
+}
+
+void MilvusService::Stub::experimental_async::CreateIndex(::grpc::ClientContext* context, const ::milvus::grpc::IndexParam* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_CreateIndex_, context, request, response, reactor);
+}
+
+void MilvusService::Stub::experimental_async::CreateIndex(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_CreateIndex_, context, request, response, reactor);
+}
+
+::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::AsyncCreateIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::IndexParam& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_CreateIndex_, context, request, true);
+}
+
+::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::PrepareAsyncCreateIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::IndexParam& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_CreateIndex_, context, request, false);
+}
+
+::grpc::Status MilvusService::Stub::Insert(::grpc::ClientContext* context, const ::milvus::grpc::InsertParam& request, ::milvus::grpc::VectorIds* response) {
+  return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_Insert_, context, request, response);
+}
+
+void MilvusService::Stub::experimental_async::Insert(::grpc::ClientContext* context, const ::milvus::grpc::InsertParam* request, ::milvus::grpc::VectorIds* response, std::function<void(::grpc::Status)> f) {
+  ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_Insert_, context, request, response, std::move(f));
+}
+
+void MilvusService::Stub::experimental_async::Insert(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::VectorIds* response, std::function<void(::grpc::Status)> f) {
+  ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_Insert_, context, request, response, std::move(f));
+}
+
+void MilvusService::Stub::experimental_async::Insert(::grpc::ClientContext* context, const ::milvus::grpc::InsertParam* request, ::milvus::grpc::VectorIds* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_Insert_, context, request, response, reactor);
+}
+
+void MilvusService::Stub::experimental_async::Insert(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::VectorIds* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_Insert_, context, request, response, reactor);
+}
+
+::grpc::ClientAsyncResponseReader< ::milvus::grpc::VectorIds>* MilvusService::Stub::AsyncInsertRaw(::grpc::ClientContext* context, const ::milvus::grpc::InsertParam& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::VectorIds>::Create(channel_.get(), cq, rpcmethod_Insert_, context, request, true);
+}
+
+::grpc::ClientAsyncResponseReader< ::milvus::grpc::VectorIds>* MilvusService::Stub::PrepareAsyncInsertRaw(::grpc::ClientContext* context, const ::milvus::grpc::InsertParam& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::VectorIds>::Create(channel_.get(), cq, rpcmethod_Insert_, context, request, false);
+}
+
+::grpc::Status MilvusService::Stub::Search(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam& request, ::milvus::grpc::TopKQueryResultList* response) {
+  return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_Search_, context, request, response);
+}
+
+void MilvusService::Stub::experimental_async::Search(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam* request, ::milvus::grpc::TopKQueryResultList* response, std::function<void(::grpc::Status)> f) {
+  ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_Search_, context, request, response, std::move(f));
+}
+
+void MilvusService::Stub::experimental_async::Search(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResultList* response, std::function<void(::grpc::Status)> f) {
+  ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_Search_, context, request, response, std::move(f));
+}
+
+void MilvusService::Stub::experimental_async::Search(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam* request, ::milvus::grpc::TopKQueryResultList* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_Search_, context, request, response, reactor);
+}
+
+void MilvusService::Stub::experimental_async::Search(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResultList* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_Search_, context, request, response, reactor);
+}
+
+::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResultList>* MilvusService::Stub::AsyncSearchRaw(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TopKQueryResultList>::Create(channel_.get(), cq, rpcmethod_Search_, context, request, true);
+}
+
+::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResultList>* MilvusService::Stub::PrepareAsyncSearchRaw(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TopKQueryResultList>::Create(channel_.get(), cq, rpcmethod_Search_, context, request, false);
+}
+
+::grpc::Status MilvusService::Stub::SearchInFiles(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam& request, ::milvus::grpc::TopKQueryResultList* response) {
+  return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_SearchInFiles_, context, request, response);
+}
+
+void MilvusService::Stub::experimental_async::SearchInFiles(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam* request, ::milvus::grpc::TopKQueryResultList* response, std::function<void(::grpc::Status)> f) {
+  ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_SearchInFiles_, context, request, response, std::move(f));
+}
+
+void MilvusService::Stub::experimental_async::SearchInFiles(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResultList* response, std::function<void(::grpc::Status)> f) {
+  ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_SearchInFiles_, context, request, response, std::move(f));
+}
+
+void MilvusService::Stub::experimental_async::SearchInFiles(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam* request, ::milvus::grpc::TopKQueryResultList* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_SearchInFiles_, context, request, response, reactor);
+}
+
+void MilvusService::Stub::experimental_async::SearchInFiles(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResultList* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_SearchInFiles_, context, request, response, reactor);
+}
+
+::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResultList>* MilvusService::Stub::AsyncSearchInFilesRaw(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TopKQueryResultList>::Create(channel_.get(), cq, rpcmethod_SearchInFiles_, context, request, true);
+}
+
+::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResultList>* MilvusService::Stub::PrepareAsyncSearchInFilesRaw(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TopKQueryResultList>::Create(channel_.get(), cq, rpcmethod_SearchInFiles_, context, request, false);
+}
+
+::grpc::Status MilvusService::Stub::DescribeTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::TableSchema* response) {
+  return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_DescribeTable_, context, request, response);
+}
+
+void MilvusService::Stub::experimental_async::DescribeTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableSchema* response, std::function<void(::grpc::Status)> f) {
+  ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DescribeTable_, context, request, response, std::move(f));
+}
+
+void MilvusService::Stub::experimental_async::DescribeTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableSchema* response, std::function<void(::grpc::Status)> f) {
+  ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DescribeTable_, context, request, response, std::move(f));
+}
+
+void MilvusService::Stub::experimental_async::DescribeTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableSchema* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DescribeTable_, context, request, response, reactor);
+}
+
+void MilvusService::Stub::experimental_async::DescribeTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableSchema* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DescribeTable_, context, request, response, reactor);
+}
+
+::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableSchema>* MilvusService::Stub::AsyncDescribeTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TableSchema>::Create(channel_.get(), cq, rpcmethod_DescribeTable_, context, request, true);
+}
+
+::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableSchema>* MilvusService::Stub::PrepareAsyncDescribeTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TableSchema>::Create(channel_.get(), cq, rpcmethod_DescribeTable_, context, request, false);
+}
+
+::grpc::Status MilvusService::Stub::CountTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::TableRowCount* response) {
+  return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_CountTable_, context, request, response);
+}
+
+void MilvusService::Stub::experimental_async::CountTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableRowCount* response, std::function<void(::grpc::Status)> f) {
+  ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_CountTable_, context, request, response, std::move(f));
+}
+
+void MilvusService::Stub::experimental_async::CountTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableRowCount* response, std::function<void(::grpc::Status)> f) {
+  ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_CountTable_, context, request, response, std::move(f));
+}
+
+void MilvusService::Stub::experimental_async::CountTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_CountTable_, context, request, response, reactor);
+}
+
+void MilvusService::Stub::experimental_async::CountTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_CountTable_, context, request, response, reactor);
+}
+
+::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableRowCount>* MilvusService::Stub::AsyncCountTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TableRowCount>::Create(channel_.get(), cq, rpcmethod_CountTable_, context, request, true);
+}
+
+::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableRowCount>* MilvusService::Stub::PrepareAsyncCountTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TableRowCount>::Create(channel_.get(), cq, rpcmethod_CountTable_, context, request, false);
+}
+
+::grpc::Status MilvusService::Stub::ShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::milvus::grpc::TableNameList* response) {
+  return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_ShowTables_, context, request, response);
+}
+
+void MilvusService::Stub::experimental_async::ShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::TableNameList* response, std::function<void(::grpc::Status)> f) {
+  ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_ShowTables_, context, request, response, std::move(f));
+}
+
+void MilvusService::Stub::experimental_async::ShowTables(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableNameList* response, std::function<void(::grpc::Status)> f) {
+  ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_ShowTables_, context, request, response, std::move(f));
+}
+
+void MilvusService::Stub::experimental_async::ShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::TableNameList* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_ShowTables_, context, request, response, reactor);
+}
+
+void MilvusService::Stub::experimental_async::ShowTables(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableNameList* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_ShowTables_, context, request, response, reactor);
+}
+
+::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableNameList>* MilvusService::Stub::AsyncShowTablesRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TableNameList>::Create(channel_.get(), cq, rpcmethod_ShowTables_, context, request, true);
+}
+
+::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableNameList>* MilvusService::Stub::PrepareAsyncShowTablesRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::TableNameList>::Create(channel_.get(), cq, rpcmethod_ShowTables_, context, request, false);
+}
+
+::grpc::Status MilvusService::Stub::Cmd(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::milvus::grpc::StringReply* response) {
+  return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_Cmd_, context, request, response);
+}
+
+void MilvusService::Stub::experimental_async::Cmd(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::StringReply* response, std::function<void(::grpc::Status)> f) {
+  ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_Cmd_, context, request, response, std::move(f));
+}
+
+void MilvusService::Stub::experimental_async::Cmd(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::StringReply* response, std::function<void(::grpc::Status)> f) {
+  ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_Cmd_, context, request, response, std::move(f));
+}
+
+void MilvusService::Stub::experimental_async::Cmd(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::StringReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_Cmd_, context, request, response, reactor);
+}
+
+void MilvusService::Stub::experimental_async::Cmd(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::StringReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_Cmd_, context, request, response, reactor);
+}
+
+::grpc::ClientAsyncResponseReader< ::milvus::grpc::StringReply>* MilvusService::Stub::AsyncCmdRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::StringReply>::Create(channel_.get(), cq, rpcmethod_Cmd_, context, request, true);
+}
+
+::grpc::ClientAsyncResponseReader< ::milvus::grpc::StringReply>* MilvusService::Stub::PrepareAsyncCmdRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::StringReply>::Create(channel_.get(), cq, rpcmethod_Cmd_, context, request, false);
+}
+
+::grpc::Status MilvusService::Stub::DeleteByRange(::grpc::ClientContext* context, const ::milvus::grpc::DeleteByRangeParam& request, ::milvus::grpc::Status* response) {
+  return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_DeleteByRange_, context, request, response);
+}
+
+void MilvusService::Stub::experimental_async::DeleteByRange(::grpc::ClientContext* context, const ::milvus::grpc::DeleteByRangeParam* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)> f) {
+  ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DeleteByRange_, context, request, response, std::move(f));
+}
+
+void MilvusService::Stub::experimental_async::DeleteByRange(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)> f) {
+  ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DeleteByRange_, context, request, response, std::move(f));
+}
+
+void MilvusService::Stub::experimental_async::DeleteByRange(::grpc::ClientContext* context, const ::milvus::grpc::DeleteByRangeParam* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DeleteByRange_, context, request, response, reactor);
+}
+
+void MilvusService::Stub::experimental_async::DeleteByRange(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DeleteByRange_, context, request, response, reactor);
+}
+
+::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::AsyncDeleteByRangeRaw(::grpc::ClientContext* context, const ::milvus::grpc::DeleteByRangeParam& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_DeleteByRange_, context, request, true);
+}
+
+::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::PrepareAsyncDeleteByRangeRaw(::grpc::ClientContext* context, const ::milvus::grpc::DeleteByRangeParam& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_DeleteByRange_, context, request, false);
+}
+
+::grpc::Status MilvusService::Stub::PreloadTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::Status* response) {
+  return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_PreloadTable_, context, request, response);
+}
+
+void MilvusService::Stub::experimental_async::PreloadTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)> f) {
+  ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_PreloadTable_, context, request, response, std::move(f));
+}
+
+void MilvusService::Stub::experimental_async::PreloadTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)> f) {
+  ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_PreloadTable_, context, request, response, std::move(f));
+}
+
+void MilvusService::Stub::experimental_async::PreloadTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_PreloadTable_, context, request, response, reactor);
+}
+
+void MilvusService::Stub::experimental_async::PreloadTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_PreloadTable_, context, request, response, reactor);
+}
+
+::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::AsyncPreloadTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_PreloadTable_, context, request, true);
+}
+
+::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::PrepareAsyncPreloadTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_PreloadTable_, context, request, false);
+}
+
+::grpc::Status MilvusService::Stub::DescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::IndexParam* response) {
+  return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_DescribeIndex_, context, request, response);
+}
+
+void MilvusService::Stub::experimental_async::DescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::IndexParam* response, std::function<void(::grpc::Status)> f) {
+  ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DescribeIndex_, context, request, response, std::move(f));
+}
+
+void MilvusService::Stub::experimental_async::DescribeIndex(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::IndexParam* response, std::function<void(::grpc::Status)> f) {
+  ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DescribeIndex_, context, request, response, std::move(f));
+}
+
+void MilvusService::Stub::experimental_async::DescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::IndexParam* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DescribeIndex_, context, request, response, reactor);
+}
+
+void MilvusService::Stub::experimental_async::DescribeIndex(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::IndexParam* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DescribeIndex_, context, request, response, reactor);
+}
+
+::grpc::ClientAsyncResponseReader< ::milvus::grpc::IndexParam>* MilvusService::Stub::AsyncDescribeIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::IndexParam>::Create(channel_.get(), cq, rpcmethod_DescribeIndex_, context, request, true);
+}
+
+::grpc::ClientAsyncResponseReader< ::milvus::grpc::IndexParam>* MilvusService::Stub::PrepareAsyncDescribeIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::IndexParam>::Create(channel_.get(), cq, rpcmethod_DescribeIndex_, context, request, false);
+}
+
+::grpc::Status MilvusService::Stub::DropIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::Status* response) {
+  return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_DropIndex_, context, request, response);
+}
+
+void MilvusService::Stub::experimental_async::DropIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)> f) {
+  ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DropIndex_, context, request, response, std::move(f));
+}
+
+void MilvusService::Stub::experimental_async::DropIndex(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)> f) {
+  ::grpc_impl::internal::CallbackUnaryCall(stub_->channel_.get(), stub_->rpcmethod_DropIndex_, context, request, response, std::move(f));
+}
+
+void MilvusService::Stub::experimental_async::DropIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DropIndex_, context, request, response, reactor);
+}
+
+void MilvusService::Stub::experimental_async::DropIndex(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc_impl::internal::ClientCallbackUnaryFactory::Create(stub_->channel_.get(), stub_->rpcmethod_DropIndex_, context, request, response, reactor);
+}
+
+::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::AsyncDropIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_DropIndex_, context, request, true);
+}
+
+::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* MilvusService::Stub::PrepareAsyncDropIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc_impl::internal::ClientAsyncResponseReaderFactory< ::milvus::grpc::Status>::Create(channel_.get(), cq, rpcmethod_DropIndex_, context, request, false);
+}
+
+MilvusService::Service::Service() {
+  AddMethod(new ::grpc::internal::RpcServiceMethod(
+      MilvusService_method_names[0],
+      ::grpc::internal::RpcMethod::NORMAL_RPC,
+      new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::TableSchema, ::milvus::grpc::Status>(
+          std::mem_fn(&MilvusService::Service::CreateTable), this)));
+  AddMethod(new ::grpc::internal::RpcServiceMethod(
+      MilvusService_method_names[1],
+      ::grpc::internal::RpcMethod::NORMAL_RPC,
+      new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::TableName, ::milvus::grpc::BoolReply>(
+          std::mem_fn(&MilvusService::Service::HasTable), this)));
+  AddMethod(new ::grpc::internal::RpcServiceMethod(
+      MilvusService_method_names[2],
+      ::grpc::internal::RpcMethod::NORMAL_RPC,
+      new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::TableName, ::milvus::grpc::Status>(
+          std::mem_fn(&MilvusService::Service::DropTable), this)));
+  AddMethod(new ::grpc::internal::RpcServiceMethod(
+      MilvusService_method_names[3],
+      ::grpc::internal::RpcMethod::NORMAL_RPC,
+      new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::IndexParam, ::milvus::grpc::Status>(
+          std::mem_fn(&MilvusService::Service::CreateIndex), this)));
+  AddMethod(new ::grpc::internal::RpcServiceMethod(
+      MilvusService_method_names[4],
+      ::grpc::internal::RpcMethod::NORMAL_RPC,
+      new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::InsertParam, ::milvus::grpc::VectorIds>(
+          std::mem_fn(&MilvusService::Service::Insert), this)));
+  AddMethod(new ::grpc::internal::RpcServiceMethod(
+      MilvusService_method_names[5],
+      ::grpc::internal::RpcMethod::NORMAL_RPC,
+      new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::SearchParam, ::milvus::grpc::TopKQueryResultList>(
+          std::mem_fn(&MilvusService::Service::Search), this)));
+  AddMethod(new ::grpc::internal::RpcServiceMethod(
+      MilvusService_method_names[6],
+      ::grpc::internal::RpcMethod::NORMAL_RPC,
+      new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::SearchInFilesParam, ::milvus::grpc::TopKQueryResultList>(
+          std::mem_fn(&MilvusService::Service::SearchInFiles), this)));
+  AddMethod(new ::grpc::internal::RpcServiceMethod(
+      MilvusService_method_names[7],
+      ::grpc::internal::RpcMethod::NORMAL_RPC,
+      new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::TableName, ::milvus::grpc::TableSchema>(
+          std::mem_fn(&MilvusService::Service::DescribeTable), this)));
+  AddMethod(new ::grpc::internal::RpcServiceMethod(
+      MilvusService_method_names[8],
+      ::grpc::internal::RpcMethod::NORMAL_RPC,
+      new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::TableName, ::milvus::grpc::TableRowCount>(
+          std::mem_fn(&MilvusService::Service::CountTable), this)));
+  AddMethod(new ::grpc::internal::RpcServiceMethod(
+      MilvusService_method_names[9],
+      ::grpc::internal::RpcMethod::NORMAL_RPC,
+      new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::Command, ::milvus::grpc::TableNameList>(
+          std::mem_fn(&MilvusService::Service::ShowTables), this)));
+  AddMethod(new ::grpc::internal::RpcServiceMethod(
+      MilvusService_method_names[10],
+      ::grpc::internal::RpcMethod::NORMAL_RPC,
+      new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::Command, ::milvus::grpc::StringReply>(
+          std::mem_fn(&MilvusService::Service::Cmd), this)));
+  AddMethod(new ::grpc::internal::RpcServiceMethod(
+      MilvusService_method_names[11],
+      ::grpc::internal::RpcMethod::NORMAL_RPC,
+      new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::DeleteByRangeParam, ::milvus::grpc::Status>(
+          std::mem_fn(&MilvusService::Service::DeleteByRange), this)));
+  AddMethod(new ::grpc::internal::RpcServiceMethod(
+      MilvusService_method_names[12],
+      ::grpc::internal::RpcMethod::NORMAL_RPC,
+      new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::TableName, ::milvus::grpc::Status>(
+          std::mem_fn(&MilvusService::Service::PreloadTable), this)));
+  AddMethod(new ::grpc::internal::RpcServiceMethod(
+      MilvusService_method_names[13],
+      ::grpc::internal::RpcMethod::NORMAL_RPC,
+      new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::TableName, ::milvus::grpc::IndexParam>(
+          std::mem_fn(&MilvusService::Service::DescribeIndex), this)));
+  AddMethod(new ::grpc::internal::RpcServiceMethod(
+      MilvusService_method_names[14],
+      ::grpc::internal::RpcMethod::NORMAL_RPC,
+      new ::grpc::internal::RpcMethodHandler< MilvusService::Service, ::milvus::grpc::TableName, ::milvus::grpc::Status>(
+          std::mem_fn(&MilvusService::Service::DropIndex), this)));
+}
+
+MilvusService::Service::~Service() {
+}
+
+::grpc::Status MilvusService::Service::CreateTable(::grpc::ServerContext* context, const ::milvus::grpc::TableSchema* request, ::milvus::grpc::Status* response) {
+  (void) context;
+  (void) request;
+  (void) response;
+  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+}
+
+::grpc::Status MilvusService::Service::HasTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::BoolReply* response) {
+  (void) context;
+  (void) request;
+  (void) response;
+  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+}
+
+::grpc::Status MilvusService::Service::DropTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response) {
+  (void) context;
+  (void) request;
+  (void) response;
+  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+}
+
+::grpc::Status MilvusService::Service::CreateIndex(::grpc::ServerContext* context, const ::milvus::grpc::IndexParam* request, ::milvus::grpc::Status* response) {
+  (void) context;
+  (void) request;
+  (void) response;
+  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+}
+
+::grpc::Status MilvusService::Service::Insert(::grpc::ServerContext* context, const ::milvus::grpc::InsertParam* request, ::milvus::grpc::VectorIds* response) {
+  (void) context;
+  (void) request;
+  (void) response;
+  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+}
+
+::grpc::Status MilvusService::Service::Search(::grpc::ServerContext* context, const ::milvus::grpc::SearchParam* request, ::milvus::grpc::TopKQueryResultList* response) {
+  (void) context;
+  (void) request;
+  (void) response;
+  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+}
+
+::grpc::Status MilvusService::Service::SearchInFiles(::grpc::ServerContext* context, const ::milvus::grpc::SearchInFilesParam* request, ::milvus::grpc::TopKQueryResultList* response) {
+  (void) context;
+  (void) request;
+  (void) response;
+  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+}
+
+::grpc::Status MilvusService::Service::DescribeTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableSchema* response) {
+  (void) context;
+  (void) request;
+  (void) response;
+  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+}
+
+::grpc::Status MilvusService::Service::CountTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableRowCount* response) {
+  (void) context;
+  (void) request;
+  (void) response;
+  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+}
+
+::grpc::Status MilvusService::Service::ShowTables(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::TableNameList* response) {
+  (void) context;
+  (void) request;
+  (void) response;
+  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+}
+
+::grpc::Status MilvusService::Service::Cmd(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::StringReply* response) {
+  (void) context;
+  (void) request;
+  (void) response;
+  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+}
+
+::grpc::Status MilvusService::Service::DeleteByRange(::grpc::ServerContext* context, const ::milvus::grpc::DeleteByRangeParam* request, ::milvus::grpc::Status* response) {
+  (void) context;
+  (void) request;
+  (void) response;
+  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+}
+
+::grpc::Status MilvusService::Service::PreloadTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response) {
+  (void) context;
+  (void) request;
+  (void) response;
+  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+}
+
+::grpc::Status MilvusService::Service::DescribeIndex(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::IndexParam* response) {
+  (void) context;
+  (void) request;
+  (void) response;
+  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+}
+
+::grpc::Status MilvusService::Service::DropIndex(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response) {
+  (void) context;
+  (void) request;
+  (void) response;
+  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+}
+
+
+}  // namespace milvus
+}  // namespace grpc
+
diff --git a/core/src/grpc/gen-milvus/milvus.grpc.pb.h b/core/src/grpc/gen-milvus/milvus.grpc.pb.h
new file mode 100644
index 0000000000..8ea2d13c80
--- /dev/null
+++ b/core/src/grpc/gen-milvus/milvus.grpc.pb.h
@@ -0,0 +1,2844 @@
+// Generated by the gRPC C++ plugin.
+// If you make any local change, they will be lost.
+// source: milvus.proto
+#ifndef GRPC_milvus_2eproto__INCLUDED
+#define GRPC_milvus_2eproto__INCLUDED
+
+#include "milvus.pb.h"
+
+#include <functional>
+#include <grpcpp/impl/codegen/async_generic_service.h>
+#include <grpcpp/impl/codegen/async_stream.h>
+#include <grpcpp/impl/codegen/async_unary_call.h>
+#include <grpcpp/impl/codegen/client_callback.h>
+#include <grpcpp/impl/codegen/client_context.h>
+#include <grpcpp/impl/codegen/completion_queue.h>
+#include <grpcpp/impl/codegen/method_handler_impl.h>
+#include <grpcpp/impl/codegen/proto_utils.h>
+#include <grpcpp/impl/codegen/rpc_method.h>
+#include <grpcpp/impl/codegen/server_callback.h>
+#include <grpcpp/impl/codegen/server_context.h>
+#include <grpcpp/impl/codegen/service_type.h>
+#include <grpcpp/impl/codegen/status.h>
+#include <grpcpp/impl/codegen/stub_options.h>
+#include <grpcpp/impl/codegen/sync_stream.h>
+
+namespace grpc_impl {
+class CompletionQueue;
+class ServerCompletionQueue;
+class ServerContext;
+}  // namespace grpc_impl
+
+namespace grpc {
+namespace experimental {
+template <typename RequestT, typename ResponseT>
+class MessageAllocator;
+}  // namespace experimental
+}  // namespace grpc
+
+namespace milvus {
+namespace grpc {
+
+class MilvusService final {
+ public:
+  static constexpr char const* service_full_name() {
+    return "milvus.grpc.MilvusService";
+  }
+  class StubInterface {
+   public:
+    virtual ~StubInterface() {}
+    // *
+    // @brief Create table method
+    //
+    // This method is used to create table
+    //
+    // @param param, use to provide table information to be created.
+    //
+    virtual ::grpc::Status CreateTable(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema& request, ::milvus::grpc::Status* response) = 0;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> AsyncCreateTable(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(AsyncCreateTableRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> PrepareAsyncCreateTable(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(PrepareAsyncCreateTableRaw(context, request, cq));
+    }
+    // *
+    // @brief Test table existence method
+    //
+    // This method is used to test table existence.
+    //
+    // @param table_name, table name is going to be tested.
+    //
+    virtual ::grpc::Status HasTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::BoolReply* response) = 0;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::BoolReply>> AsyncHasTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::BoolReply>>(AsyncHasTableRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::BoolReply>> PrepareAsyncHasTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::BoolReply>>(PrepareAsyncHasTableRaw(context, request, cq));
+    }
+    // *
+    // @brief Delete table method
+    //
+    // This method is used to delete table.
+    //
+    // @param table_name, table name is going to be deleted.
+    //
+    virtual ::grpc::Status DropTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::Status* response) = 0;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> AsyncDropTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(AsyncDropTableRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> PrepareAsyncDropTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(PrepareAsyncDropTableRaw(context, request, cq));
+    }
+    // *
+    // @brief Build index by table method
+    //
+    // This method is used to build index by table in sync mode.
+    //
+    // @param table_name, table is going to be built index.
+    //
+    virtual ::grpc::Status CreateIndex(::grpc::ClientContext* context, const ::milvus::grpc::IndexParam& request, ::milvus::grpc::Status* response) = 0;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> AsyncCreateIndex(::grpc::ClientContext* context, const ::milvus::grpc::IndexParam& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(AsyncCreateIndexRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> PrepareAsyncCreateIndex(::grpc::ClientContext* context, const ::milvus::grpc::IndexParam& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(PrepareAsyncCreateIndexRaw(context, request, cq));
+    }
+    // *
+    // @brief Add vector array to table
+    //
+    // This method is used to add vector array to table.
+    //
+    // @param table_name, table_name is inserted.
+    // @param record_array, vector array is inserted.
+    //
+    // @return vector id array
+    virtual ::grpc::Status Insert(::grpc::ClientContext* context, const ::milvus::grpc::InsertParam& request, ::milvus::grpc::VectorIds* response) = 0;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::VectorIds>> AsyncInsert(::grpc::ClientContext* context, const ::milvus::grpc::InsertParam& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::VectorIds>>(AsyncInsertRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::VectorIds>> PrepareAsyncInsert(::grpc::ClientContext* context, const ::milvus::grpc::InsertParam& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::VectorIds>>(PrepareAsyncInsertRaw(context, request, cq));
+    }
+    // *
+    // @brief Query vector
+    //
+    // This method is used to query vector in table.
+    //
+    // @param table_name, table_name is queried.
+    // @param query_record_array, all vector are going to be queried.
+    // @param query_range_array, optional ranges for conditional search. If not specified, search whole table
+    // @param topk, how many similarity vectors will be searched.
+    //
+    // @return query result array.
+    virtual ::grpc::Status Search(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam& request, ::milvus::grpc::TopKQueryResultList* response) = 0;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResultList>> AsyncSearch(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResultList>>(AsyncSearchRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResultList>> PrepareAsyncSearch(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResultList>>(PrepareAsyncSearchRaw(context, request, cq));
+    }
+    // *
+    // @brief Internal use query interface
+    //
+    // This method is used to query vector in specified files.
+    //
+    // @param file_id_array, specified files id array, queried.
+    // @param query_record_array, all vector are going to be queried.
+    // @param query_range_array, optional ranges for conditional search. If not specified, search whole table
+    // @param topk, how many similarity vectors will be searched.
+    //
+    // @return query result array.
+    virtual ::grpc::Status SearchInFiles(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam& request, ::milvus::grpc::TopKQueryResultList* response) = 0;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResultList>> AsyncSearchInFiles(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResultList>>(AsyncSearchInFilesRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResultList>> PrepareAsyncSearchInFiles(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResultList>>(PrepareAsyncSearchInFilesRaw(context, request, cq));
+    }
+    // *
+    // @brief Get table schema
+    //
+    // This method is used to get table schema.
+    //
+    // @param table_name, target table name.
+    //
+    // @return table schema
+    virtual ::grpc::Status DescribeTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::TableSchema* response) = 0;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableSchema>> AsyncDescribeTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableSchema>>(AsyncDescribeTableRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableSchema>> PrepareAsyncDescribeTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableSchema>>(PrepareAsyncDescribeTableRaw(context, request, cq));
+    }
+    // *
+    // @brief Get table schema
+    //
+    // This method is used to get table schema.
+    //
+    // @param table_name, target table name.
+    //
+    // @return table schema
+    virtual ::grpc::Status CountTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::TableRowCount* response) = 0;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableRowCount>> AsyncCountTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableRowCount>>(AsyncCountTableRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableRowCount>> PrepareAsyncCountTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableRowCount>>(PrepareAsyncCountTableRaw(context, request, cq));
+    }
+    // *
+    // @brief List all tables in database
+    //
+    // This method is used to list all tables.
+    //
+    //
+    // @return table names.
+    virtual ::grpc::Status ShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::milvus::grpc::TableNameList* response) = 0;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableNameList>> AsyncShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableNameList>>(AsyncShowTablesRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableNameList>> PrepareAsyncShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableNameList>>(PrepareAsyncShowTablesRaw(context, request, cq));
+    }
+    // *
+    // @brief Give the server status
+    //
+    // This method is used to give the server status.
+    //
+    // @return Server status.
+    virtual ::grpc::Status Cmd(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::milvus::grpc::StringReply* response) = 0;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::StringReply>> AsyncCmd(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::StringReply>>(AsyncCmdRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::StringReply>> PrepareAsyncCmd(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::StringReply>>(PrepareAsyncCmdRaw(context, request, cq));
+    }
+    // *
+    // @brief delete table by range
+    //
+    // This method is used to delete vector by range
+    //
+    // @return rpc status.
+    virtual ::grpc::Status DeleteByRange(::grpc::ClientContext* context, const ::milvus::grpc::DeleteByRangeParam& request, ::milvus::grpc::Status* response) = 0;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> AsyncDeleteByRange(::grpc::ClientContext* context, const ::milvus::grpc::DeleteByRangeParam& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(AsyncDeleteByRangeRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> PrepareAsyncDeleteByRange(::grpc::ClientContext* context, const ::milvus::grpc::DeleteByRangeParam& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(PrepareAsyncDeleteByRangeRaw(context, request, cq));
+    }
+    // *
+    // @brief preload table
+    //
+    // This method is used to preload table
+    //
+    // @return Status.
+    virtual ::grpc::Status PreloadTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::Status* response) = 0;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> AsyncPreloadTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(AsyncPreloadTableRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> PrepareAsyncPreloadTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(PrepareAsyncPreloadTableRaw(context, request, cq));
+    }
+    // *
+    // @brief describe index
+    //
+    // This method is used to describe index
+    //
+    // @return Status.
+    virtual ::grpc::Status DescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::IndexParam* response) = 0;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::IndexParam>> AsyncDescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::IndexParam>>(AsyncDescribeIndexRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::IndexParam>> PrepareAsyncDescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::IndexParam>>(PrepareAsyncDescribeIndexRaw(context, request, cq));
+    }
+    // *
+    // @brief drop index
+    //
+    // This method is used to drop index
+    //
+    // @return Status.
+    virtual ::grpc::Status DropIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::Status* response) = 0;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> AsyncDropIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(AsyncDropIndexRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>> PrepareAsyncDropIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>>(PrepareAsyncDropIndexRaw(context, request, cq));
+    }
+    class experimental_async_interface {
+     public:
+      virtual ~experimental_async_interface() {}
+      // *
+      // @brief Create table method
+      //
+      // This method is used to create table
+      //
+      // @param param, use to provide table information to be created.
+      //
+      virtual void CreateTable(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void CreateTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void CreateTable(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+      virtual void CreateTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+      // *
+      // @brief Test table existence method
+      //
+      // This method is used to test table existence.
+      //
+      // @param table_name, table name is going to be tested.
+      //
+      virtual void HasTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::BoolReply* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void HasTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::BoolReply* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void HasTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+      virtual void HasTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+      // *
+      // @brief Delete table method
+      //
+      // This method is used to delete table.
+      //
+      // @param table_name, table name is going to be deleted.
+      //
+      virtual void DropTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void DropTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void DropTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+      virtual void DropTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+      // *
+      // @brief Build index by table method
+      //
+      // This method is used to build index by table in sync mode.
+      //
+      // @param table_name, table is going to be built index.
+      //
+      virtual void CreateIndex(::grpc::ClientContext* context, const ::milvus::grpc::IndexParam* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void CreateIndex(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void CreateIndex(::grpc::ClientContext* context, const ::milvus::grpc::IndexParam* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+      virtual void CreateIndex(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+      // *
+      // @brief Add vector array to table
+      //
+      // This method is used to add vector array to table.
+      //
+      // @param table_name, table_name is inserted.
+      // @param record_array, vector array is inserted.
+      //
+      // @return vector id array
+      virtual void Insert(::grpc::ClientContext* context, const ::milvus::grpc::InsertParam* request, ::milvus::grpc::VectorIds* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void Insert(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::VectorIds* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void Insert(::grpc::ClientContext* context, const ::milvus::grpc::InsertParam* request, ::milvus::grpc::VectorIds* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+      virtual void Insert(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::VectorIds* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+      // *
+      // @brief Query vector
+      //
+      // This method is used to query vector in table.
+      //
+      // @param table_name, table_name is queried.
+      // @param query_record_array, all vector are going to be queried.
+      // @param query_range_array, optional ranges for conditional search. If not specified, search whole table
+      // @param topk, how many similarity vectors will be searched.
+      //
+      // @return query result array.
+      virtual void Search(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam* request, ::milvus::grpc::TopKQueryResultList* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void Search(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResultList* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void Search(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam* request, ::milvus::grpc::TopKQueryResultList* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+      virtual void Search(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResultList* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+      // *
+      // @brief Internal use query interface
+      //
+      // This method is used to query vector in specified files.
+      //
+      // @param file_id_array, specified files id array, queried.
+      // @param query_record_array, all vector are going to be queried.
+      // @param query_range_array, optional ranges for conditional search. If not specified, search whole table
+      // @param topk, how many similarity vectors will be searched.
+      //
+      // @return query result array.
+      virtual void SearchInFiles(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam* request, ::milvus::grpc::TopKQueryResultList* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void SearchInFiles(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResultList* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void SearchInFiles(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam* request, ::milvus::grpc::TopKQueryResultList* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+      virtual void SearchInFiles(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResultList* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+      // *
+      // @brief Get table schema
+      //
+      // This method is used to get table schema.
+      //
+      // @param table_name, target table name.
+      //
+      // @return table schema
+      virtual void DescribeTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableSchema* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void DescribeTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableSchema* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void DescribeTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableSchema* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+      virtual void DescribeTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableSchema* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+      // *
+      // @brief Get table schema
+      //
+      // This method is used to get table schema.
+      //
+      // @param table_name, target table name.
+      //
+      // @return table schema
+      virtual void CountTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableRowCount* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void CountTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableRowCount* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void CountTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+      virtual void CountTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+      // *
+      // @brief List all tables in database
+      //
+      // This method is used to list all tables.
+      //
+      //
+      // @return table names.
+      virtual void ShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::TableNameList* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void ShowTables(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableNameList* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void ShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::TableNameList* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+      virtual void ShowTables(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableNameList* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+      // *
+      // @brief Give the server status
+      //
+      // This method is used to give the server status.
+      //
+      // @return Server status.
+      virtual void Cmd(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::StringReply* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void Cmd(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::StringReply* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void Cmd(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::StringReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+      virtual void Cmd(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::StringReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+      // *
+      // @brief delete table by range
+      //
+      // This method is used to delete vector by range
+      //
+      // @return rpc status.
+      virtual void DeleteByRange(::grpc::ClientContext* context, const ::milvus::grpc::DeleteByRangeParam* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void DeleteByRange(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void DeleteByRange(::grpc::ClientContext* context, const ::milvus::grpc::DeleteByRangeParam* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+      virtual void DeleteByRange(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+      // *
+      // @brief preload table
+      //
+      // This method is used to preload table
+      //
+      // @return Status.
+      virtual void PreloadTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void PreloadTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void PreloadTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+      virtual void PreloadTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+      // *
+      // @brief describe index
+      //
+      // This method is used to describe index
+      //
+      // @return Status.
+      virtual void DescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::IndexParam* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void DescribeIndex(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::IndexParam* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void DescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::IndexParam* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+      virtual void DescribeIndex(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::IndexParam* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+      // *
+      // @brief drop index
+      //
+      // This method is used to drop index
+      //
+      // @return Status.
+      virtual void DropIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void DropIndex(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)>) = 0;
+      virtual void DropIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+      virtual void DropIndex(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+    };
+    virtual class experimental_async_interface* experimental_async() { return nullptr; }
+  private:
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncCreateTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncCreateTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::BoolReply>* AsyncHasTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::BoolReply>* PrepareAsyncHasTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncDropTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncDropTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncCreateIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::IndexParam& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncCreateIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::IndexParam& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::VectorIds>* AsyncInsertRaw(::grpc::ClientContext* context, const ::milvus::grpc::InsertParam& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::VectorIds>* PrepareAsyncInsertRaw(::grpc::ClientContext* context, const ::milvus::grpc::InsertParam& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResultList>* AsyncSearchRaw(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResultList>* PrepareAsyncSearchRaw(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResultList>* AsyncSearchInFilesRaw(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TopKQueryResultList>* PrepareAsyncSearchInFilesRaw(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableSchema>* AsyncDescribeTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableSchema>* PrepareAsyncDescribeTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableRowCount>* AsyncCountTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableRowCount>* PrepareAsyncCountTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableNameList>* AsyncShowTablesRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::TableNameList>* PrepareAsyncShowTablesRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::StringReply>* AsyncCmdRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::StringReply>* PrepareAsyncCmdRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncDeleteByRangeRaw(::grpc::ClientContext* context, const ::milvus::grpc::DeleteByRangeParam& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncDeleteByRangeRaw(::grpc::ClientContext* context, const ::milvus::grpc::DeleteByRangeParam& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncPreloadTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncPreloadTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::IndexParam>* AsyncDescribeIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::IndexParam>* PrepareAsyncDescribeIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* AsyncDropIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::milvus::grpc::Status>* PrepareAsyncDropIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) = 0;
+  };
+  class Stub final : public StubInterface {
+   public:
+    Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel);
+    ::grpc::Status CreateTable(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema& request, ::milvus::grpc::Status* response) override;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> AsyncCreateTable(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(AsyncCreateTableRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> PrepareAsyncCreateTable(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(PrepareAsyncCreateTableRaw(context, request, cq));
+    }
+    ::grpc::Status HasTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::BoolReply* response) override;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>> AsyncHasTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>>(AsyncHasTableRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>> PrepareAsyncHasTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>>(PrepareAsyncHasTableRaw(context, request, cq));
+    }
+    ::grpc::Status DropTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::Status* response) override;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> AsyncDropTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(AsyncDropTableRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> PrepareAsyncDropTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(PrepareAsyncDropTableRaw(context, request, cq));
+    }
+    ::grpc::Status CreateIndex(::grpc::ClientContext* context, const ::milvus::grpc::IndexParam& request, ::milvus::grpc::Status* response) override;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> AsyncCreateIndex(::grpc::ClientContext* context, const ::milvus::grpc::IndexParam& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(AsyncCreateIndexRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> PrepareAsyncCreateIndex(::grpc::ClientContext* context, const ::milvus::grpc::IndexParam& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(PrepareAsyncCreateIndexRaw(context, request, cq));
+    }
+    ::grpc::Status Insert(::grpc::ClientContext* context, const ::milvus::grpc::InsertParam& request, ::milvus::grpc::VectorIds* response) override;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::VectorIds>> AsyncInsert(::grpc::ClientContext* context, const ::milvus::grpc::InsertParam& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::VectorIds>>(AsyncInsertRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::VectorIds>> PrepareAsyncInsert(::grpc::ClientContext* context, const ::milvus::grpc::InsertParam& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::VectorIds>>(PrepareAsyncInsertRaw(context, request, cq));
+    }
+    ::grpc::Status Search(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam& request, ::milvus::grpc::TopKQueryResultList* response) override;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResultList>> AsyncSearch(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResultList>>(AsyncSearchRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResultList>> PrepareAsyncSearch(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResultList>>(PrepareAsyncSearchRaw(context, request, cq));
+    }
+    ::grpc::Status SearchInFiles(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam& request, ::milvus::grpc::TopKQueryResultList* response) override;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResultList>> AsyncSearchInFiles(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResultList>>(AsyncSearchInFilesRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResultList>> PrepareAsyncSearchInFiles(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResultList>>(PrepareAsyncSearchInFilesRaw(context, request, cq));
+    }
+    ::grpc::Status DescribeTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::TableSchema* response) override;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableSchema>> AsyncDescribeTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableSchema>>(AsyncDescribeTableRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableSchema>> PrepareAsyncDescribeTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableSchema>>(PrepareAsyncDescribeTableRaw(context, request, cq));
+    }
+    ::grpc::Status CountTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::TableRowCount* response) override;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableRowCount>> AsyncCountTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableRowCount>>(AsyncCountTableRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableRowCount>> PrepareAsyncCountTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableRowCount>>(PrepareAsyncCountTableRaw(context, request, cq));
+    }
+    ::grpc::Status ShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::milvus::grpc::TableNameList* response) override;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableNameList>> AsyncShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableNameList>>(AsyncShowTablesRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableNameList>> PrepareAsyncShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableNameList>>(PrepareAsyncShowTablesRaw(context, request, cq));
+    }
+    ::grpc::Status Cmd(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::milvus::grpc::StringReply* response) override;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::StringReply>> AsyncCmd(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::StringReply>>(AsyncCmdRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::StringReply>> PrepareAsyncCmd(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::StringReply>>(PrepareAsyncCmdRaw(context, request, cq));
+    }
+    ::grpc::Status DeleteByRange(::grpc::ClientContext* context, const ::milvus::grpc::DeleteByRangeParam& request, ::milvus::grpc::Status* response) override;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> AsyncDeleteByRange(::grpc::ClientContext* context, const ::milvus::grpc::DeleteByRangeParam& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(AsyncDeleteByRangeRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> PrepareAsyncDeleteByRange(::grpc::ClientContext* context, const ::milvus::grpc::DeleteByRangeParam& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(PrepareAsyncDeleteByRangeRaw(context, request, cq));
+    }
+    ::grpc::Status PreloadTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::Status* response) override;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> AsyncPreloadTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(AsyncPreloadTableRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> PrepareAsyncPreloadTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(PrepareAsyncPreloadTableRaw(context, request, cq));
+    }
+    ::grpc::Status DescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::IndexParam* response) override;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::IndexParam>> AsyncDescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::IndexParam>>(AsyncDescribeIndexRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::IndexParam>> PrepareAsyncDescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::IndexParam>>(PrepareAsyncDescribeIndexRaw(context, request, cq));
+    }
+    ::grpc::Status DropIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::milvus::grpc::Status* response) override;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> AsyncDropIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(AsyncDropIndexRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>> PrepareAsyncDropIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>>(PrepareAsyncDropIndexRaw(context, request, cq));
+    }
+    class experimental_async final :
+      public StubInterface::experimental_async_interface {
+     public:
+      void CreateTable(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)>) override;
+      void CreateTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)>) override;
+      void CreateTable(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+      void CreateTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+      void HasTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::BoolReply* response, std::function<void(::grpc::Status)>) override;
+      void HasTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::BoolReply* response, std::function<void(::grpc::Status)>) override;
+      void HasTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+      void HasTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+      void DropTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)>) override;
+      void DropTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)>) override;
+      void DropTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+      void DropTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+      void CreateIndex(::grpc::ClientContext* context, const ::milvus::grpc::IndexParam* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)>) override;
+      void CreateIndex(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)>) override;
+      void CreateIndex(::grpc::ClientContext* context, const ::milvus::grpc::IndexParam* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+      void CreateIndex(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+      void Insert(::grpc::ClientContext* context, const ::milvus::grpc::InsertParam* request, ::milvus::grpc::VectorIds* response, std::function<void(::grpc::Status)>) override;
+      void Insert(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::VectorIds* response, std::function<void(::grpc::Status)>) override;
+      void Insert(::grpc::ClientContext* context, const ::milvus::grpc::InsertParam* request, ::milvus::grpc::VectorIds* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+      void Insert(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::VectorIds* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+      void Search(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam* request, ::milvus::grpc::TopKQueryResultList* response, std::function<void(::grpc::Status)>) override;
+      void Search(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResultList* response, std::function<void(::grpc::Status)>) override;
+      void Search(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam* request, ::milvus::grpc::TopKQueryResultList* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+      void Search(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResultList* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+      void SearchInFiles(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam* request, ::milvus::grpc::TopKQueryResultList* response, std::function<void(::grpc::Status)>) override;
+      void SearchInFiles(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResultList* response, std::function<void(::grpc::Status)>) override;
+      void SearchInFiles(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam* request, ::milvus::grpc::TopKQueryResultList* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+      void SearchInFiles(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TopKQueryResultList* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+      void DescribeTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableSchema* response, std::function<void(::grpc::Status)>) override;
+      void DescribeTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableSchema* response, std::function<void(::grpc::Status)>) override;
+      void DescribeTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableSchema* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+      void DescribeTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableSchema* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+      void CountTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableRowCount* response, std::function<void(::grpc::Status)>) override;
+      void CountTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableRowCount* response, std::function<void(::grpc::Status)>) override;
+      void CountTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+      void CountTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableRowCount* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+      void ShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::TableNameList* response, std::function<void(::grpc::Status)>) override;
+      void ShowTables(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableNameList* response, std::function<void(::grpc::Status)>) override;
+      void ShowTables(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::TableNameList* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+      void ShowTables(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::TableNameList* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+      void Cmd(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::StringReply* response, std::function<void(::grpc::Status)>) override;
+      void Cmd(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::StringReply* response, std::function<void(::grpc::Status)>) override;
+      void Cmd(::grpc::ClientContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::StringReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+      void Cmd(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::StringReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+      void DeleteByRange(::grpc::ClientContext* context, const ::milvus::grpc::DeleteByRangeParam* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)>) override;
+      void DeleteByRange(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)>) override;
+      void DeleteByRange(::grpc::ClientContext* context, const ::milvus::grpc::DeleteByRangeParam* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+      void DeleteByRange(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+      void PreloadTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)>) override;
+      void PreloadTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)>) override;
+      void PreloadTable(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+      void PreloadTable(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+      void DescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::IndexParam* response, std::function<void(::grpc::Status)>) override;
+      void DescribeIndex(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::IndexParam* response, std::function<void(::grpc::Status)>) override;
+      void DescribeIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::IndexParam* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+      void DescribeIndex(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::IndexParam* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+      void DropIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)>) override;
+      void DropIndex(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, std::function<void(::grpc::Status)>) override;
+      void DropIndex(::grpc::ClientContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+      void DropIndex(::grpc::ClientContext* context, const ::grpc::ByteBuffer* request, ::milvus::grpc::Status* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+     private:
+      friend class Stub;
+      explicit experimental_async(Stub* stub): stub_(stub) { }
+      Stub* stub() { return stub_; }
+      Stub* stub_;
+    };
+    class experimental_async_interface* experimental_async() override { return &async_stub_; }
+
+   private:
+    std::shared_ptr< ::grpc::ChannelInterface> channel_;
+    class experimental_async async_stub_{this};
+    ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncCreateTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncCreateTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableSchema& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>* AsyncHasTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::milvus::grpc::BoolReply>* PrepareAsyncHasTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncDropTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncDropTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncCreateIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::IndexParam& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncCreateIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::IndexParam& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::milvus::grpc::VectorIds>* AsyncInsertRaw(::grpc::ClientContext* context, const ::milvus::grpc::InsertParam& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::milvus::grpc::VectorIds>* PrepareAsyncInsertRaw(::grpc::ClientContext* context, const ::milvus::grpc::InsertParam& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResultList>* AsyncSearchRaw(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResultList>* PrepareAsyncSearchRaw(::grpc::ClientContext* context, const ::milvus::grpc::SearchParam& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResultList>* AsyncSearchInFilesRaw(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TopKQueryResultList>* PrepareAsyncSearchInFilesRaw(::grpc::ClientContext* context, const ::milvus::grpc::SearchInFilesParam& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableSchema>* AsyncDescribeTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableSchema>* PrepareAsyncDescribeTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableRowCount>* AsyncCountTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableRowCount>* PrepareAsyncCountTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableNameList>* AsyncShowTablesRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::milvus::grpc::TableNameList>* PrepareAsyncShowTablesRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::milvus::grpc::StringReply>* AsyncCmdRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::milvus::grpc::StringReply>* PrepareAsyncCmdRaw(::grpc::ClientContext* context, const ::milvus::grpc::Command& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncDeleteByRangeRaw(::grpc::ClientContext* context, const ::milvus::grpc::DeleteByRangeParam& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncDeleteByRangeRaw(::grpc::ClientContext* context, const ::milvus::grpc::DeleteByRangeParam& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncPreloadTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncPreloadTableRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::milvus::grpc::IndexParam>* AsyncDescribeIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::milvus::grpc::IndexParam>* PrepareAsyncDescribeIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* AsyncDropIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::milvus::grpc::Status>* PrepareAsyncDropIndexRaw(::grpc::ClientContext* context, const ::milvus::grpc::TableName& request, ::grpc::CompletionQueue* cq) override;
+    const ::grpc::internal::RpcMethod rpcmethod_CreateTable_;
+    const ::grpc::internal::RpcMethod rpcmethod_HasTable_;
+    const ::grpc::internal::RpcMethod rpcmethod_DropTable_;
+    const ::grpc::internal::RpcMethod rpcmethod_CreateIndex_;
+    const ::grpc::internal::RpcMethod rpcmethod_Insert_;
+    const ::grpc::internal::RpcMethod rpcmethod_Search_;
+    const ::grpc::internal::RpcMethod rpcmethod_SearchInFiles_;
+    const ::grpc::internal::RpcMethod rpcmethod_DescribeTable_;
+    const ::grpc::internal::RpcMethod rpcmethod_CountTable_;
+    const ::grpc::internal::RpcMethod rpcmethod_ShowTables_;
+    const ::grpc::internal::RpcMethod rpcmethod_Cmd_;
+    const ::grpc::internal::RpcMethod rpcmethod_DeleteByRange_;
+    const ::grpc::internal::RpcMethod rpcmethod_PreloadTable_;
+    const ::grpc::internal::RpcMethod rpcmethod_DescribeIndex_;
+    const ::grpc::internal::RpcMethod rpcmethod_DropIndex_;
+  };
+  static std::unique_ptr<Stub> NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
+
+  class Service : public ::grpc::Service {
+   public:
+    Service();
+    virtual ~Service();
+    // *
+    // @brief Create table method
+    //
+    // This method is used to create table
+    //
+    // @param param, use to provide table information to be created.
+    //
+    virtual ::grpc::Status CreateTable(::grpc::ServerContext* context, const ::milvus::grpc::TableSchema* request, ::milvus::grpc::Status* response);
+    // *
+    // @brief Test table existence method
+    //
+    // This method is used to test table existence.
+    //
+    // @param table_name, table name is going to be tested.
+    //
+    virtual ::grpc::Status HasTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::BoolReply* response);
+    // *
+    // @brief Delete table method
+    //
+    // This method is used to delete table.
+    //
+    // @param table_name, table name is going to be deleted.
+    //
+    virtual ::grpc::Status DropTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response);
+    // *
+    // @brief Build index by table method
+    //
+    // This method is used to build index by table in sync mode.
+    //
+    // @param table_name, table is going to be built index.
+    //
+    virtual ::grpc::Status CreateIndex(::grpc::ServerContext* context, const ::milvus::grpc::IndexParam* request, ::milvus::grpc::Status* response);
+    // *
+    // @brief Add vector array to table
+    //
+    // This method is used to add vector array to table.
+    //
+    // @param table_name, table_name is inserted.
+    // @param record_array, vector array is inserted.
+    //
+    // @return vector id array
+    virtual ::grpc::Status Insert(::grpc::ServerContext* context, const ::milvus::grpc::InsertParam* request, ::milvus::grpc::VectorIds* response);
+    // *
+    // @brief Query vector
+    //
+    // This method is used to query vector in table.
+    //
+    // @param table_name, table_name is queried.
+    // @param query_record_array, all vector are going to be queried.
+    // @param query_range_array, optional ranges for conditional search. If not specified, search whole table
+    // @param topk, how many similarity vectors will be searched.
+    //
+    // @return query result array.
+    virtual ::grpc::Status Search(::grpc::ServerContext* context, const ::milvus::grpc::SearchParam* request, ::milvus::grpc::TopKQueryResultList* response);
+    // *
+    // @brief Internal use query interface
+    //
+    // This method is used to query vector in specified files.
+    //
+    // @param file_id_array, specified files id array, queried.
+    // @param query_record_array, all vector are going to be queried.
+    // @param query_range_array, optional ranges for conditional search. If not specified, search whole table
+    // @param topk, how many similarity vectors will be searched.
+    //
+    // @return query result array.
+    virtual ::grpc::Status SearchInFiles(::grpc::ServerContext* context, const ::milvus::grpc::SearchInFilesParam* request, ::milvus::grpc::TopKQueryResultList* response);
+    // *
+    // @brief Get table schema
+    //
+    // This method is used to get table schema.
+    //
+    // @param table_name, target table name.
+    //
+    // @return table schema
+    virtual ::grpc::Status DescribeTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableSchema* response);
+    // *
+    // @brief Get table schema
+    //
+    // This method is used to get table schema.
+    //
+    // @param table_name, target table name.
+    //
+    // @return table schema
+    virtual ::grpc::Status CountTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableRowCount* response);
+    // *
+    // @brief List all tables in database
+    //
+    // This method is used to list all tables.
+    //
+    //
+    // @return table names.
+    virtual ::grpc::Status ShowTables(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::TableNameList* response);
+    // *
+    // @brief Give the server status
+    //
+    // This method is used to give the server status.
+    //
+    // @return Server status.
+    virtual ::grpc::Status Cmd(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::StringReply* response);
+    // *
+    // @brief delete table by range
+    //
+    // This method is used to delete vector by range
+    //
+    // @return rpc status.
+    virtual ::grpc::Status DeleteByRange(::grpc::ServerContext* context, const ::milvus::grpc::DeleteByRangeParam* request, ::milvus::grpc::Status* response);
+    // *
+    // @brief preload table
+    //
+    // This method is used to preload table
+    //
+    // @return Status.
+    virtual ::grpc::Status PreloadTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response);
+    // *
+    // @brief describe index
+    //
+    // This method is used to describe index
+    //
+    // @return Status.
+    virtual ::grpc::Status DescribeIndex(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::IndexParam* response);
+    // *
+    // @brief drop index
+    //
+    // This method is used to drop index
+    //
+    // @return Status.
+    virtual ::grpc::Status DropIndex(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response);
+  };
+  template <class BaseClass>
+  class WithAsyncMethod_CreateTable : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithAsyncMethod_CreateTable() {
+      ::grpc::Service::MarkMethodAsync(0);
+    }
+    ~WithAsyncMethod_CreateTable() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status CreateTable(::grpc::ServerContext* context, const ::milvus::grpc::TableSchema* request, ::milvus::grpc::Status* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestCreateTable(::grpc::ServerContext* context, ::milvus::grpc::TableSchema* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Status>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
+  class WithAsyncMethod_HasTable : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithAsyncMethod_HasTable() {
+      ::grpc::Service::MarkMethodAsync(1);
+    }
+    ~WithAsyncMethod_HasTable() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status HasTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::BoolReply* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestHasTable(::grpc::ServerContext* context, ::milvus::grpc::TableName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::BoolReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
+  class WithAsyncMethod_DropTable : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithAsyncMethod_DropTable() {
+      ::grpc::Service::MarkMethodAsync(2);
+    }
+    ~WithAsyncMethod_DropTable() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status DropTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestDropTable(::grpc::ServerContext* context, ::milvus::grpc::TableName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Status>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(2, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
+  class WithAsyncMethod_CreateIndex : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithAsyncMethod_CreateIndex() {
+      ::grpc::Service::MarkMethodAsync(3);
+    }
+    ~WithAsyncMethod_CreateIndex() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status CreateIndex(::grpc::ServerContext* context, const ::milvus::grpc::IndexParam* request, ::milvus::grpc::Status* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestCreateIndex(::grpc::ServerContext* context, ::milvus::grpc::IndexParam* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Status>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(3, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
+  class WithAsyncMethod_Insert : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithAsyncMethod_Insert() {
+      ::grpc::Service::MarkMethodAsync(4);
+    }
+    ~WithAsyncMethod_Insert() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status Insert(::grpc::ServerContext* context, const ::milvus::grpc::InsertParam* request, ::milvus::grpc::VectorIds* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestInsert(::grpc::ServerContext* context, ::milvus::grpc::InsertParam* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::VectorIds>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(4, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
+  class WithAsyncMethod_Search : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithAsyncMethod_Search() {
+      ::grpc::Service::MarkMethodAsync(5);
+    }
+    ~WithAsyncMethod_Search() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status Search(::grpc::ServerContext* context, const ::milvus::grpc::SearchParam* request, ::milvus::grpc::TopKQueryResultList* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestSearch(::grpc::ServerContext* context, ::milvus::grpc::SearchParam* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::TopKQueryResultList>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(5, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
+  class WithAsyncMethod_SearchInFiles : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithAsyncMethod_SearchInFiles() {
+      ::grpc::Service::MarkMethodAsync(6);
+    }
+    ~WithAsyncMethod_SearchInFiles() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status SearchInFiles(::grpc::ServerContext* context, const ::milvus::grpc::SearchInFilesParam* request, ::milvus::grpc::TopKQueryResultList* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestSearchInFiles(::grpc::ServerContext* context, ::milvus::grpc::SearchInFilesParam* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::TopKQueryResultList>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(6, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
+  class WithAsyncMethod_DescribeTable : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithAsyncMethod_DescribeTable() {
+      ::grpc::Service::MarkMethodAsync(7);
+    }
+    ~WithAsyncMethod_DescribeTable() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status DescribeTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableSchema* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestDescribeTable(::grpc::ServerContext* context, ::milvus::grpc::TableName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::TableSchema>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(7, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
+  class WithAsyncMethod_CountTable : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithAsyncMethod_CountTable() {
+      ::grpc::Service::MarkMethodAsync(8);
+    }
+    ~WithAsyncMethod_CountTable() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status CountTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableRowCount* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestCountTable(::grpc::ServerContext* context, ::milvus::grpc::TableName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::TableRowCount>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(8, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
+  class WithAsyncMethod_ShowTables : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithAsyncMethod_ShowTables() {
+      ::grpc::Service::MarkMethodAsync(9);
+    }
+    ~WithAsyncMethod_ShowTables() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status ShowTables(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::TableNameList* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestShowTables(::grpc::ServerContext* context, ::milvus::grpc::Command* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::TableNameList>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(9, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
+  class WithAsyncMethod_Cmd : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithAsyncMethod_Cmd() {
+      ::grpc::Service::MarkMethodAsync(10);
+    }
+    ~WithAsyncMethod_Cmd() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status Cmd(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::StringReply* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestCmd(::grpc::ServerContext* context, ::milvus::grpc::Command* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::StringReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(10, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
+  class WithAsyncMethod_DeleteByRange : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithAsyncMethod_DeleteByRange() {
+      ::grpc::Service::MarkMethodAsync(11);
+    }
+    ~WithAsyncMethod_DeleteByRange() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status DeleteByRange(::grpc::ServerContext* context, const ::milvus::grpc::DeleteByRangeParam* request, ::milvus::grpc::Status* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestDeleteByRange(::grpc::ServerContext* context, ::milvus::grpc::DeleteByRangeParam* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Status>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(11, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
+  class WithAsyncMethod_PreloadTable : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithAsyncMethod_PreloadTable() {
+      ::grpc::Service::MarkMethodAsync(12);
+    }
+    ~WithAsyncMethod_PreloadTable() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status PreloadTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestPreloadTable(::grpc::ServerContext* context, ::milvus::grpc::TableName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Status>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(12, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
+  class WithAsyncMethod_DescribeIndex : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithAsyncMethod_DescribeIndex() {
+      ::grpc::Service::MarkMethodAsync(13);
+    }
+    ~WithAsyncMethod_DescribeIndex() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status DescribeIndex(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::IndexParam* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestDescribeIndex(::grpc::ServerContext* context, ::milvus::grpc::TableName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::IndexParam>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(13, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
+  class WithAsyncMethod_DropIndex : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithAsyncMethod_DropIndex() {
+      ::grpc::Service::MarkMethodAsync(14);
+    }
+    ~WithAsyncMethod_DropIndex() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status DropIndex(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestDropIndex(::grpc::ServerContext* context, ::milvus::grpc::TableName* request, ::grpc::ServerAsyncResponseWriter< ::milvus::grpc::Status>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(14, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  typedef WithAsyncMethod_CreateTable<WithAsyncMethod_HasTable<WithAsyncMethod_DropTable<WithAsyncMethod_CreateIndex<WithAsyncMethod_Insert<WithAsyncMethod_Search<WithAsyncMethod_SearchInFiles<WithAsyncMethod_DescribeTable<WithAsyncMethod_CountTable<WithAsyncMethod_ShowTables<WithAsyncMethod_Cmd<WithAsyncMethod_DeleteByRange<WithAsyncMethod_PreloadTable<WithAsyncMethod_DescribeIndex<WithAsyncMethod_DropIndex<Service > > > > > > > > > > > > > > > AsyncService;
+  template <class BaseClass>
+  class ExperimentalWithCallbackMethod_CreateTable : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    ExperimentalWithCallbackMethod_CreateTable() {
+      ::grpc::Service::experimental().MarkMethodCallback(0,
+        new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableSchema, ::milvus::grpc::Status>(
+          [this](::grpc::ServerContext* context,
+                 const ::milvus::grpc::TableSchema* request,
+                 ::milvus::grpc::Status* response,
+                 ::grpc::experimental::ServerCallbackRpcController* controller) {
+                   return this->CreateTable(context, request, response, controller);
+                 }));
+    }
+    void SetMessageAllocatorFor_CreateTable(
+        ::grpc::experimental::MessageAllocator< ::milvus::grpc::TableSchema, ::milvus::grpc::Status>* allocator) {
+      static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableSchema, ::milvus::grpc::Status>*>(
+          ::grpc::Service::experimental().GetHandler(0))
+              ->SetMessageAllocator(allocator);
+    }
+    ~ExperimentalWithCallbackMethod_CreateTable() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status CreateTable(::grpc::ServerContext* context, const ::milvus::grpc::TableSchema* request, ::milvus::grpc::Status* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    virtual void CreateTable(::grpc::ServerContext* context, const ::milvus::grpc::TableSchema* request, ::milvus::grpc::Status* response, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); }
+  };
+  template <class BaseClass>
+  class ExperimentalWithCallbackMethod_HasTable : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    ExperimentalWithCallbackMethod_HasTable() {
+      ::grpc::Service::experimental().MarkMethodCallback(1,
+        new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::BoolReply>(
+          [this](::grpc::ServerContext* context,
+                 const ::milvus::grpc::TableName* request,
+                 ::milvus::grpc::BoolReply* response,
+                 ::grpc::experimental::ServerCallbackRpcController* controller) {
+                   return this->HasTable(context, request, response, controller);
+                 }));
+    }
+    void SetMessageAllocatorFor_HasTable(
+        ::grpc::experimental::MessageAllocator< ::milvus::grpc::TableName, ::milvus::grpc::BoolReply>* allocator) {
+      static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::BoolReply>*>(
+          ::grpc::Service::experimental().GetHandler(1))
+              ->SetMessageAllocator(allocator);
+    }
+    ~ExperimentalWithCallbackMethod_HasTable() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status HasTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::BoolReply* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    virtual void HasTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::BoolReply* response, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); }
+  };
+  template <class BaseClass>
+  class ExperimentalWithCallbackMethod_DropTable : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    ExperimentalWithCallbackMethod_DropTable() {
+      ::grpc::Service::experimental().MarkMethodCallback(2,
+        new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::Status>(
+          [this](::grpc::ServerContext* context,
+                 const ::milvus::grpc::TableName* request,
+                 ::milvus::grpc::Status* response,
+                 ::grpc::experimental::ServerCallbackRpcController* controller) {
+                   return this->DropTable(context, request, response, controller);
+                 }));
+    }
+    void SetMessageAllocatorFor_DropTable(
+        ::grpc::experimental::MessageAllocator< ::milvus::grpc::TableName, ::milvus::grpc::Status>* allocator) {
+      static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::Status>*>(
+          ::grpc::Service::experimental().GetHandler(2))
+              ->SetMessageAllocator(allocator);
+    }
+    ~ExperimentalWithCallbackMethod_DropTable() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status DropTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    virtual void DropTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); }
+  };
+  template <class BaseClass>
+  class ExperimentalWithCallbackMethod_CreateIndex : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    ExperimentalWithCallbackMethod_CreateIndex() {
+      ::grpc::Service::experimental().MarkMethodCallback(3,
+        new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::IndexParam, ::milvus::grpc::Status>(
+          [this](::grpc::ServerContext* context,
+                 const ::milvus::grpc::IndexParam* request,
+                 ::milvus::grpc::Status* response,
+                 ::grpc::experimental::ServerCallbackRpcController* controller) {
+                   return this->CreateIndex(context, request, response, controller);
+                 }));
+    }
+    void SetMessageAllocatorFor_CreateIndex(
+        ::grpc::experimental::MessageAllocator< ::milvus::grpc::IndexParam, ::milvus::grpc::Status>* allocator) {
+      static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::IndexParam, ::milvus::grpc::Status>*>(
+          ::grpc::Service::experimental().GetHandler(3))
+              ->SetMessageAllocator(allocator);
+    }
+    ~ExperimentalWithCallbackMethod_CreateIndex() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status CreateIndex(::grpc::ServerContext* context, const ::milvus::grpc::IndexParam* request, ::milvus::grpc::Status* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    virtual void CreateIndex(::grpc::ServerContext* context, const ::milvus::grpc::IndexParam* request, ::milvus::grpc::Status* response, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); }
+  };
+  template <class BaseClass>
+  class ExperimentalWithCallbackMethod_Insert : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    ExperimentalWithCallbackMethod_Insert() {
+      ::grpc::Service::experimental().MarkMethodCallback(4,
+        new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::InsertParam, ::milvus::grpc::VectorIds>(
+          [this](::grpc::ServerContext* context,
+                 const ::milvus::grpc::InsertParam* request,
+                 ::milvus::grpc::VectorIds* response,
+                 ::grpc::experimental::ServerCallbackRpcController* controller) {
+                   return this->Insert(context, request, response, controller);
+                 }));
+    }
+    void SetMessageAllocatorFor_Insert(
+        ::grpc::experimental::MessageAllocator< ::milvus::grpc::InsertParam, ::milvus::grpc::VectorIds>* allocator) {
+      static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::InsertParam, ::milvus::grpc::VectorIds>*>(
+          ::grpc::Service::experimental().GetHandler(4))
+              ->SetMessageAllocator(allocator);
+    }
+    ~ExperimentalWithCallbackMethod_Insert() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status Insert(::grpc::ServerContext* context, const ::milvus::grpc::InsertParam* request, ::milvus::grpc::VectorIds* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    virtual void Insert(::grpc::ServerContext* context, const ::milvus::grpc::InsertParam* request, ::milvus::grpc::VectorIds* response, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); }
+  };
+  template <class BaseClass>
+  class ExperimentalWithCallbackMethod_Search : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    ExperimentalWithCallbackMethod_Search() {
+      ::grpc::Service::experimental().MarkMethodCallback(5,
+        new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::SearchParam, ::milvus::grpc::TopKQueryResultList>(
+          [this](::grpc::ServerContext* context,
+                 const ::milvus::grpc::SearchParam* request,
+                 ::milvus::grpc::TopKQueryResultList* response,
+                 ::grpc::experimental::ServerCallbackRpcController* controller) {
+                   return this->Search(context, request, response, controller);
+                 }));
+    }
+    void SetMessageAllocatorFor_Search(
+        ::grpc::experimental::MessageAllocator< ::milvus::grpc::SearchParam, ::milvus::grpc::TopKQueryResultList>* allocator) {
+      static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::SearchParam, ::milvus::grpc::TopKQueryResultList>*>(
+          ::grpc::Service::experimental().GetHandler(5))
+              ->SetMessageAllocator(allocator);
+    }
+    ~ExperimentalWithCallbackMethod_Search() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status Search(::grpc::ServerContext* context, const ::milvus::grpc::SearchParam* request, ::milvus::grpc::TopKQueryResultList* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    virtual void Search(::grpc::ServerContext* context, const ::milvus::grpc::SearchParam* request, ::milvus::grpc::TopKQueryResultList* response, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); }
+  };
+  template <class BaseClass>
+  class ExperimentalWithCallbackMethod_SearchInFiles : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    ExperimentalWithCallbackMethod_SearchInFiles() {
+      ::grpc::Service::experimental().MarkMethodCallback(6,
+        new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::SearchInFilesParam, ::milvus::grpc::TopKQueryResultList>(
+          [this](::grpc::ServerContext* context,
+                 const ::milvus::grpc::SearchInFilesParam* request,
+                 ::milvus::grpc::TopKQueryResultList* response,
+                 ::grpc::experimental::ServerCallbackRpcController* controller) {
+                   return this->SearchInFiles(context, request, response, controller);
+                 }));
+    }
+    void SetMessageAllocatorFor_SearchInFiles(
+        ::grpc::experimental::MessageAllocator< ::milvus::grpc::SearchInFilesParam, ::milvus::grpc::TopKQueryResultList>* allocator) {
+      static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::SearchInFilesParam, ::milvus::grpc::TopKQueryResultList>*>(
+          ::grpc::Service::experimental().GetHandler(6))
+              ->SetMessageAllocator(allocator);
+    }
+    ~ExperimentalWithCallbackMethod_SearchInFiles() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status SearchInFiles(::grpc::ServerContext* context, const ::milvus::grpc::SearchInFilesParam* request, ::milvus::grpc::TopKQueryResultList* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    virtual void SearchInFiles(::grpc::ServerContext* context, const ::milvus::grpc::SearchInFilesParam* request, ::milvus::grpc::TopKQueryResultList* response, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); }
+  };
+  template <class BaseClass>
+  class ExperimentalWithCallbackMethod_DescribeTable : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    ExperimentalWithCallbackMethod_DescribeTable() {
+      ::grpc::Service::experimental().MarkMethodCallback(7,
+        new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::TableSchema>(
+          [this](::grpc::ServerContext* context,
+                 const ::milvus::grpc::TableName* request,
+                 ::milvus::grpc::TableSchema* response,
+                 ::grpc::experimental::ServerCallbackRpcController* controller) {
+                   return this->DescribeTable(context, request, response, controller);
+                 }));
+    }
+    void SetMessageAllocatorFor_DescribeTable(
+        ::grpc::experimental::MessageAllocator< ::milvus::grpc::TableName, ::milvus::grpc::TableSchema>* allocator) {
+      static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::TableSchema>*>(
+          ::grpc::Service::experimental().GetHandler(7))
+              ->SetMessageAllocator(allocator);
+    }
+    ~ExperimentalWithCallbackMethod_DescribeTable() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status DescribeTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableSchema* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    virtual void DescribeTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableSchema* response, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); }
+  };
+  template <class BaseClass>
+  class ExperimentalWithCallbackMethod_CountTable : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    ExperimentalWithCallbackMethod_CountTable() {
+      ::grpc::Service::experimental().MarkMethodCallback(8,
+        new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::TableRowCount>(
+          [this](::grpc::ServerContext* context,
+                 const ::milvus::grpc::TableName* request,
+                 ::milvus::grpc::TableRowCount* response,
+                 ::grpc::experimental::ServerCallbackRpcController* controller) {
+                   return this->CountTable(context, request, response, controller);
+                 }));
+    }
+    void SetMessageAllocatorFor_CountTable(
+        ::grpc::experimental::MessageAllocator< ::milvus::grpc::TableName, ::milvus::grpc::TableRowCount>* allocator) {
+      static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::TableRowCount>*>(
+          ::grpc::Service::experimental().GetHandler(8))
+              ->SetMessageAllocator(allocator);
+    }
+    ~ExperimentalWithCallbackMethod_CountTable() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status CountTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableRowCount* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    virtual void CountTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableRowCount* response, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); }
+  };
+  template <class BaseClass>
+  class ExperimentalWithCallbackMethod_ShowTables : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    ExperimentalWithCallbackMethod_ShowTables() {
+      ::grpc::Service::experimental().MarkMethodCallback(9,
+        new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::Command, ::milvus::grpc::TableNameList>(
+          [this](::grpc::ServerContext* context,
+                 const ::milvus::grpc::Command* request,
+                 ::milvus::grpc::TableNameList* response,
+                 ::grpc::experimental::ServerCallbackRpcController* controller) {
+                   return this->ShowTables(context, request, response, controller);
+                 }));
+    }
+    void SetMessageAllocatorFor_ShowTables(
+        ::grpc::experimental::MessageAllocator< ::milvus::grpc::Command, ::milvus::grpc::TableNameList>* allocator) {
+      static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::Command, ::milvus::grpc::TableNameList>*>(
+          ::grpc::Service::experimental().GetHandler(9))
+              ->SetMessageAllocator(allocator);
+    }
+    ~ExperimentalWithCallbackMethod_ShowTables() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status ShowTables(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::TableNameList* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    virtual void ShowTables(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::TableNameList* response, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); }
+  };
+  template <class BaseClass>
+  class ExperimentalWithCallbackMethod_Cmd : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    ExperimentalWithCallbackMethod_Cmd() {
+      ::grpc::Service::experimental().MarkMethodCallback(10,
+        new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::Command, ::milvus::grpc::StringReply>(
+          [this](::grpc::ServerContext* context,
+                 const ::milvus::grpc::Command* request,
+                 ::milvus::grpc::StringReply* response,
+                 ::grpc::experimental::ServerCallbackRpcController* controller) {
+                   return this->Cmd(context, request, response, controller);
+                 }));
+    }
+    void SetMessageAllocatorFor_Cmd(
+        ::grpc::experimental::MessageAllocator< ::milvus::grpc::Command, ::milvus::grpc::StringReply>* allocator) {
+      static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::Command, ::milvus::grpc::StringReply>*>(
+          ::grpc::Service::experimental().GetHandler(10))
+              ->SetMessageAllocator(allocator);
+    }
+    ~ExperimentalWithCallbackMethod_Cmd() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status Cmd(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::StringReply* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    virtual void Cmd(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::StringReply* response, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); }
+  };
+  template <class BaseClass>
+  class ExperimentalWithCallbackMethod_DeleteByRange : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    ExperimentalWithCallbackMethod_DeleteByRange() {
+      ::grpc::Service::experimental().MarkMethodCallback(11,
+        new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::DeleteByRangeParam, ::milvus::grpc::Status>(
+          [this](::grpc::ServerContext* context,
+                 const ::milvus::grpc::DeleteByRangeParam* request,
+                 ::milvus::grpc::Status* response,
+                 ::grpc::experimental::ServerCallbackRpcController* controller) {
+                   return this->DeleteByRange(context, request, response, controller);
+                 }));
+    }
+    void SetMessageAllocatorFor_DeleteByRange(
+        ::grpc::experimental::MessageAllocator< ::milvus::grpc::DeleteByRangeParam, ::milvus::grpc::Status>* allocator) {
+      static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::DeleteByRangeParam, ::milvus::grpc::Status>*>(
+          ::grpc::Service::experimental().GetHandler(11))
+              ->SetMessageAllocator(allocator);
+    }
+    ~ExperimentalWithCallbackMethod_DeleteByRange() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status DeleteByRange(::grpc::ServerContext* context, const ::milvus::grpc::DeleteByRangeParam* request, ::milvus::grpc::Status* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    virtual void DeleteByRange(::grpc::ServerContext* context, const ::milvus::grpc::DeleteByRangeParam* request, ::milvus::grpc::Status* response, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); }
+  };
+  template <class BaseClass>
+  class ExperimentalWithCallbackMethod_PreloadTable : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    ExperimentalWithCallbackMethod_PreloadTable() {
+      ::grpc::Service::experimental().MarkMethodCallback(12,
+        new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::Status>(
+          [this](::grpc::ServerContext* context,
+                 const ::milvus::grpc::TableName* request,
+                 ::milvus::grpc::Status* response,
+                 ::grpc::experimental::ServerCallbackRpcController* controller) {
+                   return this->PreloadTable(context, request, response, controller);
+                 }));
+    }
+    void SetMessageAllocatorFor_PreloadTable(
+        ::grpc::experimental::MessageAllocator< ::milvus::grpc::TableName, ::milvus::grpc::Status>* allocator) {
+      static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::Status>*>(
+          ::grpc::Service::experimental().GetHandler(12))
+              ->SetMessageAllocator(allocator);
+    }
+    ~ExperimentalWithCallbackMethod_PreloadTable() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status PreloadTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    virtual void PreloadTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); }
+  };
+  template <class BaseClass>
+  class ExperimentalWithCallbackMethod_DescribeIndex : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    ExperimentalWithCallbackMethod_DescribeIndex() {
+      ::grpc::Service::experimental().MarkMethodCallback(13,
+        new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::IndexParam>(
+          [this](::grpc::ServerContext* context,
+                 const ::milvus::grpc::TableName* request,
+                 ::milvus::grpc::IndexParam* response,
+                 ::grpc::experimental::ServerCallbackRpcController* controller) {
+                   return this->DescribeIndex(context, request, response, controller);
+                 }));
+    }
+    void SetMessageAllocatorFor_DescribeIndex(
+        ::grpc::experimental::MessageAllocator< ::milvus::grpc::TableName, ::milvus::grpc::IndexParam>* allocator) {
+      static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::IndexParam>*>(
+          ::grpc::Service::experimental().GetHandler(13))
+              ->SetMessageAllocator(allocator);
+    }
+    ~ExperimentalWithCallbackMethod_DescribeIndex() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status DescribeIndex(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::IndexParam* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    virtual void DescribeIndex(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::IndexParam* response, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); }
+  };
+  template <class BaseClass>
+  class ExperimentalWithCallbackMethod_DropIndex : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    ExperimentalWithCallbackMethod_DropIndex() {
+      ::grpc::Service::experimental().MarkMethodCallback(14,
+        new ::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::Status>(
+          [this](::grpc::ServerContext* context,
+                 const ::milvus::grpc::TableName* request,
+                 ::milvus::grpc::Status* response,
+                 ::grpc::experimental::ServerCallbackRpcController* controller) {
+                   return this->DropIndex(context, request, response, controller);
+                 }));
+    }
+    void SetMessageAllocatorFor_DropIndex(
+        ::grpc::experimental::MessageAllocator< ::milvus::grpc::TableName, ::milvus::grpc::Status>* allocator) {
+      static_cast<::grpc_impl::internal::CallbackUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::Status>*>(
+          ::grpc::Service::experimental().GetHandler(14))
+              ->SetMessageAllocator(allocator);
+    }
+    ~ExperimentalWithCallbackMethod_DropIndex() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status DropIndex(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    virtual void DropIndex(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); }
+  };
+  typedef ExperimentalWithCallbackMethod_CreateTable<ExperimentalWithCallbackMethod_HasTable<ExperimentalWithCallbackMethod_DropTable<ExperimentalWithCallbackMethod_CreateIndex<ExperimentalWithCallbackMethod_Insert<ExperimentalWithCallbackMethod_Search<ExperimentalWithCallbackMethod_SearchInFiles<ExperimentalWithCallbackMethod_DescribeTable<ExperimentalWithCallbackMethod_CountTable<ExperimentalWithCallbackMethod_ShowTables<ExperimentalWithCallbackMethod_Cmd<ExperimentalWithCallbackMethod_DeleteByRange<ExperimentalWithCallbackMethod_PreloadTable<ExperimentalWithCallbackMethod_DescribeIndex<ExperimentalWithCallbackMethod_DropIndex<Service > > > > > > > > > > > > > > > ExperimentalCallbackService;
+  template <class BaseClass>
+  class WithGenericMethod_CreateTable : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithGenericMethod_CreateTable() {
+      ::grpc::Service::MarkMethodGeneric(0);
+    }
+    ~WithGenericMethod_CreateTable() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status CreateTable(::grpc::ServerContext* context, const ::milvus::grpc::TableSchema* request, ::milvus::grpc::Status* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+  };
+  template <class BaseClass>
+  class WithGenericMethod_HasTable : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithGenericMethod_HasTable() {
+      ::grpc::Service::MarkMethodGeneric(1);
+    }
+    ~WithGenericMethod_HasTable() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status HasTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::BoolReply* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+  };
+  template <class BaseClass>
+  class WithGenericMethod_DropTable : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithGenericMethod_DropTable() {
+      ::grpc::Service::MarkMethodGeneric(2);
+    }
+    ~WithGenericMethod_DropTable() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status DropTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+  };
+  template <class BaseClass>
+  class WithGenericMethod_CreateIndex : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithGenericMethod_CreateIndex() {
+      ::grpc::Service::MarkMethodGeneric(3);
+    }
+    ~WithGenericMethod_CreateIndex() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status CreateIndex(::grpc::ServerContext* context, const ::milvus::grpc::IndexParam* request, ::milvus::grpc::Status* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+  };
+  template <class BaseClass>
+  class WithGenericMethod_Insert : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithGenericMethod_Insert() {
+      ::grpc::Service::MarkMethodGeneric(4);
+    }
+    ~WithGenericMethod_Insert() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status Insert(::grpc::ServerContext* context, const ::milvus::grpc::InsertParam* request, ::milvus::grpc::VectorIds* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+  };
+  template <class BaseClass>
+  class WithGenericMethod_Search : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithGenericMethod_Search() {
+      ::grpc::Service::MarkMethodGeneric(5);
+    }
+    ~WithGenericMethod_Search() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status Search(::grpc::ServerContext* context, const ::milvus::grpc::SearchParam* request, ::milvus::grpc::TopKQueryResultList* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+  };
+  template <class BaseClass>
+  class WithGenericMethod_SearchInFiles : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithGenericMethod_SearchInFiles() {
+      ::grpc::Service::MarkMethodGeneric(6);
+    }
+    ~WithGenericMethod_SearchInFiles() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status SearchInFiles(::grpc::ServerContext* context, const ::milvus::grpc::SearchInFilesParam* request, ::milvus::grpc::TopKQueryResultList* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+  };
+  template <class BaseClass>
+  class WithGenericMethod_DescribeTable : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithGenericMethod_DescribeTable() {
+      ::grpc::Service::MarkMethodGeneric(7);
+    }
+    ~WithGenericMethod_DescribeTable() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status DescribeTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableSchema* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+  };
+  template <class BaseClass>
+  class WithGenericMethod_CountTable : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithGenericMethod_CountTable() {
+      ::grpc::Service::MarkMethodGeneric(8);
+    }
+    ~WithGenericMethod_CountTable() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status CountTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableRowCount* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+  };
+  template <class BaseClass>
+  class WithGenericMethod_ShowTables : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithGenericMethod_ShowTables() {
+      ::grpc::Service::MarkMethodGeneric(9);
+    }
+    ~WithGenericMethod_ShowTables() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status ShowTables(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::TableNameList* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+  };
+  template <class BaseClass>
+  class WithGenericMethod_Cmd : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithGenericMethod_Cmd() {
+      ::grpc::Service::MarkMethodGeneric(10);
+    }
+    ~WithGenericMethod_Cmd() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status Cmd(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::StringReply* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+  };
+  template <class BaseClass>
+  class WithGenericMethod_DeleteByRange : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithGenericMethod_DeleteByRange() {
+      ::grpc::Service::MarkMethodGeneric(11);
+    }
+    ~WithGenericMethod_DeleteByRange() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status DeleteByRange(::grpc::ServerContext* context, const ::milvus::grpc::DeleteByRangeParam* request, ::milvus::grpc::Status* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+  };
+  template <class BaseClass>
+  class WithGenericMethod_PreloadTable : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithGenericMethod_PreloadTable() {
+      ::grpc::Service::MarkMethodGeneric(12);
+    }
+    ~WithGenericMethod_PreloadTable() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status PreloadTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+  };
+  template <class BaseClass>
+  class WithGenericMethod_DescribeIndex : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithGenericMethod_DescribeIndex() {
+      ::grpc::Service::MarkMethodGeneric(13);
+    }
+    ~WithGenericMethod_DescribeIndex() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status DescribeIndex(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::IndexParam* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+  };
+  template <class BaseClass>
+  class WithGenericMethod_DropIndex : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithGenericMethod_DropIndex() {
+      ::grpc::Service::MarkMethodGeneric(14);
+    }
+    ~WithGenericMethod_DropIndex() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status DropIndex(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+  };
+  template <class BaseClass>
+  class WithRawMethod_CreateTable : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithRawMethod_CreateTable() {
+      ::grpc::Service::MarkMethodRaw(0);
+    }
+    ~WithRawMethod_CreateTable() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status CreateTable(::grpc::ServerContext* context, const ::milvus::grpc::TableSchema* request, ::milvus::grpc::Status* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestCreateTable(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
+  class WithRawMethod_HasTable : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithRawMethod_HasTable() {
+      ::grpc::Service::MarkMethodRaw(1);
+    }
+    ~WithRawMethod_HasTable() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status HasTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::BoolReply* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestHasTable(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
+  class WithRawMethod_DropTable : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithRawMethod_DropTable() {
+      ::grpc::Service::MarkMethodRaw(2);
+    }
+    ~WithRawMethod_DropTable() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status DropTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestDropTable(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(2, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
+  class WithRawMethod_CreateIndex : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithRawMethod_CreateIndex() {
+      ::grpc::Service::MarkMethodRaw(3);
+    }
+    ~WithRawMethod_CreateIndex() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status CreateIndex(::grpc::ServerContext* context, const ::milvus::grpc::IndexParam* request, ::milvus::grpc::Status* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestCreateIndex(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(3, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
+  class WithRawMethod_Insert : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithRawMethod_Insert() {
+      ::grpc::Service::MarkMethodRaw(4);
+    }
+    ~WithRawMethod_Insert() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status Insert(::grpc::ServerContext* context, const ::milvus::grpc::InsertParam* request, ::milvus::grpc::VectorIds* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestInsert(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(4, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
+  class WithRawMethod_Search : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithRawMethod_Search() {
+      ::grpc::Service::MarkMethodRaw(5);
+    }
+    ~WithRawMethod_Search() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status Search(::grpc::ServerContext* context, const ::milvus::grpc::SearchParam* request, ::milvus::grpc::TopKQueryResultList* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestSearch(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(5, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
+  class WithRawMethod_SearchInFiles : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithRawMethod_SearchInFiles() {
+      ::grpc::Service::MarkMethodRaw(6);
+    }
+    ~WithRawMethod_SearchInFiles() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status SearchInFiles(::grpc::ServerContext* context, const ::milvus::grpc::SearchInFilesParam* request, ::milvus::grpc::TopKQueryResultList* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestSearchInFiles(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(6, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
+  class WithRawMethod_DescribeTable : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithRawMethod_DescribeTable() {
+      ::grpc::Service::MarkMethodRaw(7);
+    }
+    ~WithRawMethod_DescribeTable() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status DescribeTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableSchema* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestDescribeTable(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(7, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
+  class WithRawMethod_CountTable : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithRawMethod_CountTable() {
+      ::grpc::Service::MarkMethodRaw(8);
+    }
+    ~WithRawMethod_CountTable() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status CountTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableRowCount* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestCountTable(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(8, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
+  class WithRawMethod_ShowTables : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithRawMethod_ShowTables() {
+      ::grpc::Service::MarkMethodRaw(9);
+    }
+    ~WithRawMethod_ShowTables() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status ShowTables(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::TableNameList* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestShowTables(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(9, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
+  class WithRawMethod_Cmd : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithRawMethod_Cmd() {
+      ::grpc::Service::MarkMethodRaw(10);
+    }
+    ~WithRawMethod_Cmd() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status Cmd(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::StringReply* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestCmd(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(10, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
+  class WithRawMethod_DeleteByRange : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithRawMethod_DeleteByRange() {
+      ::grpc::Service::MarkMethodRaw(11);
+    }
+    ~WithRawMethod_DeleteByRange() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status DeleteByRange(::grpc::ServerContext* context, const ::milvus::grpc::DeleteByRangeParam* request, ::milvus::grpc::Status* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestDeleteByRange(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(11, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
+  class WithRawMethod_PreloadTable : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithRawMethod_PreloadTable() {
+      ::grpc::Service::MarkMethodRaw(12);
+    }
+    ~WithRawMethod_PreloadTable() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status PreloadTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestPreloadTable(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(12, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
+  class WithRawMethod_DescribeIndex : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithRawMethod_DescribeIndex() {
+      ::grpc::Service::MarkMethodRaw(13);
+    }
+    ~WithRawMethod_DescribeIndex() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status DescribeIndex(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::IndexParam* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestDescribeIndex(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(13, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
+  class WithRawMethod_DropIndex : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithRawMethod_DropIndex() {
+      ::grpc::Service::MarkMethodRaw(14);
+    }
+    ~WithRawMethod_DropIndex() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status DropIndex(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void RequestDropIndex(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(14, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
+  class ExperimentalWithRawCallbackMethod_CreateTable : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    ExperimentalWithRawCallbackMethod_CreateTable() {
+      ::grpc::Service::experimental().MarkMethodRawCallback(0,
+        new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
+          [this](::grpc::ServerContext* context,
+                 const ::grpc::ByteBuffer* request,
+                 ::grpc::ByteBuffer* response,
+                 ::grpc::experimental::ServerCallbackRpcController* controller) {
+                   this->CreateTable(context, request, response, controller);
+                 }));
+    }
+    ~ExperimentalWithRawCallbackMethod_CreateTable() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status CreateTable(::grpc::ServerContext* context, const ::milvus::grpc::TableSchema* request, ::milvus::grpc::Status* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    virtual void CreateTable(::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); }
+  };
+  template <class BaseClass>
+  class ExperimentalWithRawCallbackMethod_HasTable : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    ExperimentalWithRawCallbackMethod_HasTable() {
+      ::grpc::Service::experimental().MarkMethodRawCallback(1,
+        new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
+          [this](::grpc::ServerContext* context,
+                 const ::grpc::ByteBuffer* request,
+                 ::grpc::ByteBuffer* response,
+                 ::grpc::experimental::ServerCallbackRpcController* controller) {
+                   this->HasTable(context, request, response, controller);
+                 }));
+    }
+    ~ExperimentalWithRawCallbackMethod_HasTable() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status HasTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::BoolReply* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    virtual void HasTable(::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); }
+  };
+  template <class BaseClass>
+  class ExperimentalWithRawCallbackMethod_DropTable : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    ExperimentalWithRawCallbackMethod_DropTable() {
+      ::grpc::Service::experimental().MarkMethodRawCallback(2,
+        new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
+          [this](::grpc::ServerContext* context,
+                 const ::grpc::ByteBuffer* request,
+                 ::grpc::ByteBuffer* response,
+                 ::grpc::experimental::ServerCallbackRpcController* controller) {
+                   this->DropTable(context, request, response, controller);
+                 }));
+    }
+    ~ExperimentalWithRawCallbackMethod_DropTable() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status DropTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    virtual void DropTable(::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); }
+  };
+  template <class BaseClass>
+  class ExperimentalWithRawCallbackMethod_CreateIndex : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    ExperimentalWithRawCallbackMethod_CreateIndex() {
+      ::grpc::Service::experimental().MarkMethodRawCallback(3,
+        new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
+          [this](::grpc::ServerContext* context,
+                 const ::grpc::ByteBuffer* request,
+                 ::grpc::ByteBuffer* response,
+                 ::grpc::experimental::ServerCallbackRpcController* controller) {
+                   this->CreateIndex(context, request, response, controller);
+                 }));
+    }
+    ~ExperimentalWithRawCallbackMethod_CreateIndex() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status CreateIndex(::grpc::ServerContext* context, const ::milvus::grpc::IndexParam* request, ::milvus::grpc::Status* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    virtual void CreateIndex(::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); }
+  };
+  template <class BaseClass>
+  class ExperimentalWithRawCallbackMethod_Insert : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    ExperimentalWithRawCallbackMethod_Insert() {
+      ::grpc::Service::experimental().MarkMethodRawCallback(4,
+        new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
+          [this](::grpc::ServerContext* context,
+                 const ::grpc::ByteBuffer* request,
+                 ::grpc::ByteBuffer* response,
+                 ::grpc::experimental::ServerCallbackRpcController* controller) {
+                   this->Insert(context, request, response, controller);
+                 }));
+    }
+    ~ExperimentalWithRawCallbackMethod_Insert() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status Insert(::grpc::ServerContext* context, const ::milvus::grpc::InsertParam* request, ::milvus::grpc::VectorIds* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    virtual void Insert(::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); }
+  };
+  template <class BaseClass>
+  class ExperimentalWithRawCallbackMethod_Search : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    ExperimentalWithRawCallbackMethod_Search() {
+      ::grpc::Service::experimental().MarkMethodRawCallback(5,
+        new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
+          [this](::grpc::ServerContext* context,
+                 const ::grpc::ByteBuffer* request,
+                 ::grpc::ByteBuffer* response,
+                 ::grpc::experimental::ServerCallbackRpcController* controller) {
+                   this->Search(context, request, response, controller);
+                 }));
+    }
+    ~ExperimentalWithRawCallbackMethod_Search() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status Search(::grpc::ServerContext* context, const ::milvus::grpc::SearchParam* request, ::milvus::grpc::TopKQueryResultList* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    virtual void Search(::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); }
+  };
+  template <class BaseClass>
+  class ExperimentalWithRawCallbackMethod_SearchInFiles : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    ExperimentalWithRawCallbackMethod_SearchInFiles() {
+      ::grpc::Service::experimental().MarkMethodRawCallback(6,
+        new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
+          [this](::grpc::ServerContext* context,
+                 const ::grpc::ByteBuffer* request,
+                 ::grpc::ByteBuffer* response,
+                 ::grpc::experimental::ServerCallbackRpcController* controller) {
+                   this->SearchInFiles(context, request, response, controller);
+                 }));
+    }
+    ~ExperimentalWithRawCallbackMethod_SearchInFiles() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status SearchInFiles(::grpc::ServerContext* context, const ::milvus::grpc::SearchInFilesParam* request, ::milvus::grpc::TopKQueryResultList* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    virtual void SearchInFiles(::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); }
+  };
+  template <class BaseClass>
+  class ExperimentalWithRawCallbackMethod_DescribeTable : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    ExperimentalWithRawCallbackMethod_DescribeTable() {
+      ::grpc::Service::experimental().MarkMethodRawCallback(7,
+        new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
+          [this](::grpc::ServerContext* context,
+                 const ::grpc::ByteBuffer* request,
+                 ::grpc::ByteBuffer* response,
+                 ::grpc::experimental::ServerCallbackRpcController* controller) {
+                   this->DescribeTable(context, request, response, controller);
+                 }));
+    }
+    ~ExperimentalWithRawCallbackMethod_DescribeTable() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status DescribeTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableSchema* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    virtual void DescribeTable(::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); }
+  };
+  template <class BaseClass>
+  class ExperimentalWithRawCallbackMethod_CountTable : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    ExperimentalWithRawCallbackMethod_CountTable() {
+      ::grpc::Service::experimental().MarkMethodRawCallback(8,
+        new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
+          [this](::grpc::ServerContext* context,
+                 const ::grpc::ByteBuffer* request,
+                 ::grpc::ByteBuffer* response,
+                 ::grpc::experimental::ServerCallbackRpcController* controller) {
+                   this->CountTable(context, request, response, controller);
+                 }));
+    }
+    ~ExperimentalWithRawCallbackMethod_CountTable() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status CountTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableRowCount* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    virtual void CountTable(::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); }
+  };
+  template <class BaseClass>
+  class ExperimentalWithRawCallbackMethod_ShowTables : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    ExperimentalWithRawCallbackMethod_ShowTables() {
+      ::grpc::Service::experimental().MarkMethodRawCallback(9,
+        new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
+          [this](::grpc::ServerContext* context,
+                 const ::grpc::ByteBuffer* request,
+                 ::grpc::ByteBuffer* response,
+                 ::grpc::experimental::ServerCallbackRpcController* controller) {
+                   this->ShowTables(context, request, response, controller);
+                 }));
+    }
+    ~ExperimentalWithRawCallbackMethod_ShowTables() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status ShowTables(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::TableNameList* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    virtual void ShowTables(::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); }
+  };
+  template <class BaseClass>
+  class ExperimentalWithRawCallbackMethod_Cmd : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    ExperimentalWithRawCallbackMethod_Cmd() {
+      ::grpc::Service::experimental().MarkMethodRawCallback(10,
+        new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
+          [this](::grpc::ServerContext* context,
+                 const ::grpc::ByteBuffer* request,
+                 ::grpc::ByteBuffer* response,
+                 ::grpc::experimental::ServerCallbackRpcController* controller) {
+                   this->Cmd(context, request, response, controller);
+                 }));
+    }
+    ~ExperimentalWithRawCallbackMethod_Cmd() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status Cmd(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::StringReply* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    virtual void Cmd(::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); }
+  };
+  template <class BaseClass>
+  class ExperimentalWithRawCallbackMethod_DeleteByRange : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    ExperimentalWithRawCallbackMethod_DeleteByRange() {
+      ::grpc::Service::experimental().MarkMethodRawCallback(11,
+        new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
+          [this](::grpc::ServerContext* context,
+                 const ::grpc::ByteBuffer* request,
+                 ::grpc::ByteBuffer* response,
+                 ::grpc::experimental::ServerCallbackRpcController* controller) {
+                   this->DeleteByRange(context, request, response, controller);
+                 }));
+    }
+    ~ExperimentalWithRawCallbackMethod_DeleteByRange() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status DeleteByRange(::grpc::ServerContext* context, const ::milvus::grpc::DeleteByRangeParam* request, ::milvus::grpc::Status* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    virtual void DeleteByRange(::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); }
+  };
+  template <class BaseClass>
+  class ExperimentalWithRawCallbackMethod_PreloadTable : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    ExperimentalWithRawCallbackMethod_PreloadTable() {
+      ::grpc::Service::experimental().MarkMethodRawCallback(12,
+        new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
+          [this](::grpc::ServerContext* context,
+                 const ::grpc::ByteBuffer* request,
+                 ::grpc::ByteBuffer* response,
+                 ::grpc::experimental::ServerCallbackRpcController* controller) {
+                   this->PreloadTable(context, request, response, controller);
+                 }));
+    }
+    ~ExperimentalWithRawCallbackMethod_PreloadTable() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status PreloadTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    virtual void PreloadTable(::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); }
+  };
+  template <class BaseClass>
+  class ExperimentalWithRawCallbackMethod_DescribeIndex : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    ExperimentalWithRawCallbackMethod_DescribeIndex() {
+      ::grpc::Service::experimental().MarkMethodRawCallback(13,
+        new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
+          [this](::grpc::ServerContext* context,
+                 const ::grpc::ByteBuffer* request,
+                 ::grpc::ByteBuffer* response,
+                 ::grpc::experimental::ServerCallbackRpcController* controller) {
+                   this->DescribeIndex(context, request, response, controller);
+                 }));
+    }
+    ~ExperimentalWithRawCallbackMethod_DescribeIndex() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status DescribeIndex(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::IndexParam* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    virtual void DescribeIndex(::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); }
+  };
+  template <class BaseClass>
+  class ExperimentalWithRawCallbackMethod_DropIndex : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    ExperimentalWithRawCallbackMethod_DropIndex() {
+      ::grpc::Service::experimental().MarkMethodRawCallback(14,
+        new ::grpc_impl::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
+          [this](::grpc::ServerContext* context,
+                 const ::grpc::ByteBuffer* request,
+                 ::grpc::ByteBuffer* response,
+                 ::grpc::experimental::ServerCallbackRpcController* controller) {
+                   this->DropIndex(context, request, response, controller);
+                 }));
+    }
+    ~ExperimentalWithRawCallbackMethod_DropIndex() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status DropIndex(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    virtual void DropIndex(::grpc::ServerContext* context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response, ::grpc::experimental::ServerCallbackRpcController* controller) { controller->Finish(::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "")); }
+  };
+  template <class BaseClass>
+  class WithStreamedUnaryMethod_CreateTable : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithStreamedUnaryMethod_CreateTable() {
+      ::grpc::Service::MarkMethodStreamed(0,
+        new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::TableSchema, ::milvus::grpc::Status>(std::bind(&WithStreamedUnaryMethod_CreateTable<BaseClass>::StreamedCreateTable, this, std::placeholders::_1, std::placeholders::_2)));
+    }
+    ~WithStreamedUnaryMethod_CreateTable() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable regular version of this method
+    ::grpc::Status CreateTable(::grpc::ServerContext* context, const ::milvus::grpc::TableSchema* request, ::milvus::grpc::Status* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    // replace default version of method with streamed unary
+    virtual ::grpc::Status StreamedCreateTable(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::TableSchema,::milvus::grpc::Status>* server_unary_streamer) = 0;
+  };
+  template <class BaseClass>
+  class WithStreamedUnaryMethod_HasTable : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithStreamedUnaryMethod_HasTable() {
+      ::grpc::Service::MarkMethodStreamed(1,
+        new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::BoolReply>(std::bind(&WithStreamedUnaryMethod_HasTable<BaseClass>::StreamedHasTable, this, std::placeholders::_1, std::placeholders::_2)));
+    }
+    ~WithStreamedUnaryMethod_HasTable() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable regular version of this method
+    ::grpc::Status HasTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::BoolReply* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    // replace default version of method with streamed unary
+    virtual ::grpc::Status StreamedHasTable(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::TableName,::milvus::grpc::BoolReply>* server_unary_streamer) = 0;
+  };
+  template <class BaseClass>
+  class WithStreamedUnaryMethod_DropTable : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithStreamedUnaryMethod_DropTable() {
+      ::grpc::Service::MarkMethodStreamed(2,
+        new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::Status>(std::bind(&WithStreamedUnaryMethod_DropTable<BaseClass>::StreamedDropTable, this, std::placeholders::_1, std::placeholders::_2)));
+    }
+    ~WithStreamedUnaryMethod_DropTable() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable regular version of this method
+    ::grpc::Status DropTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    // replace default version of method with streamed unary
+    virtual ::grpc::Status StreamedDropTable(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::TableName,::milvus::grpc::Status>* server_unary_streamer) = 0;
+  };
+  template <class BaseClass>
+  class WithStreamedUnaryMethod_CreateIndex : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithStreamedUnaryMethod_CreateIndex() {
+      ::grpc::Service::MarkMethodStreamed(3,
+        new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::IndexParam, ::milvus::grpc::Status>(std::bind(&WithStreamedUnaryMethod_CreateIndex<BaseClass>::StreamedCreateIndex, this, std::placeholders::_1, std::placeholders::_2)));
+    }
+    ~WithStreamedUnaryMethod_CreateIndex() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable regular version of this method
+    ::grpc::Status CreateIndex(::grpc::ServerContext* context, const ::milvus::grpc::IndexParam* request, ::milvus::grpc::Status* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    // replace default version of method with streamed unary
+    virtual ::grpc::Status StreamedCreateIndex(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::IndexParam,::milvus::grpc::Status>* server_unary_streamer) = 0;
+  };
+  template <class BaseClass>
+  class WithStreamedUnaryMethod_Insert : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithStreamedUnaryMethod_Insert() {
+      ::grpc::Service::MarkMethodStreamed(4,
+        new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::InsertParam, ::milvus::grpc::VectorIds>(std::bind(&WithStreamedUnaryMethod_Insert<BaseClass>::StreamedInsert, this, std::placeholders::_1, std::placeholders::_2)));
+    }
+    ~WithStreamedUnaryMethod_Insert() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable regular version of this method
+    ::grpc::Status Insert(::grpc::ServerContext* context, const ::milvus::grpc::InsertParam* request, ::milvus::grpc::VectorIds* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    // replace default version of method with streamed unary
+    virtual ::grpc::Status StreamedInsert(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::InsertParam,::milvus::grpc::VectorIds>* server_unary_streamer) = 0;
+  };
+  template <class BaseClass>
+  class WithStreamedUnaryMethod_Search : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithStreamedUnaryMethod_Search() {
+      ::grpc::Service::MarkMethodStreamed(5,
+        new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::SearchParam, ::milvus::grpc::TopKQueryResultList>(std::bind(&WithStreamedUnaryMethod_Search<BaseClass>::StreamedSearch, this, std::placeholders::_1, std::placeholders::_2)));
+    }
+    ~WithStreamedUnaryMethod_Search() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable regular version of this method
+    ::grpc::Status Search(::grpc::ServerContext* context, const ::milvus::grpc::SearchParam* request, ::milvus::grpc::TopKQueryResultList* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    // replace default version of method with streamed unary
+    virtual ::grpc::Status StreamedSearch(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::SearchParam,::milvus::grpc::TopKQueryResultList>* server_unary_streamer) = 0;
+  };
+  template <class BaseClass>
+  class WithStreamedUnaryMethod_SearchInFiles : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithStreamedUnaryMethod_SearchInFiles() {
+      ::grpc::Service::MarkMethodStreamed(6,
+        new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::SearchInFilesParam, ::milvus::grpc::TopKQueryResultList>(std::bind(&WithStreamedUnaryMethod_SearchInFiles<BaseClass>::StreamedSearchInFiles, this, std::placeholders::_1, std::placeholders::_2)));
+    }
+    ~WithStreamedUnaryMethod_SearchInFiles() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable regular version of this method
+    ::grpc::Status SearchInFiles(::grpc::ServerContext* context, const ::milvus::grpc::SearchInFilesParam* request, ::milvus::grpc::TopKQueryResultList* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    // replace default version of method with streamed unary
+    virtual ::grpc::Status StreamedSearchInFiles(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::SearchInFilesParam,::milvus::grpc::TopKQueryResultList>* server_unary_streamer) = 0;
+  };
+  template <class BaseClass>
+  class WithStreamedUnaryMethod_DescribeTable : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithStreamedUnaryMethod_DescribeTable() {
+      ::grpc::Service::MarkMethodStreamed(7,
+        new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::TableSchema>(std::bind(&WithStreamedUnaryMethod_DescribeTable<BaseClass>::StreamedDescribeTable, this, std::placeholders::_1, std::placeholders::_2)));
+    }
+    ~WithStreamedUnaryMethod_DescribeTable() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable regular version of this method
+    ::grpc::Status DescribeTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableSchema* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    // replace default version of method with streamed unary
+    virtual ::grpc::Status StreamedDescribeTable(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::TableName,::milvus::grpc::TableSchema>* server_unary_streamer) = 0;
+  };
+  template <class BaseClass>
+  class WithStreamedUnaryMethod_CountTable : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithStreamedUnaryMethod_CountTable() {
+      ::grpc::Service::MarkMethodStreamed(8,
+        new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::TableRowCount>(std::bind(&WithStreamedUnaryMethod_CountTable<BaseClass>::StreamedCountTable, this, std::placeholders::_1, std::placeholders::_2)));
+    }
+    ~WithStreamedUnaryMethod_CountTable() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable regular version of this method
+    ::grpc::Status CountTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::TableRowCount* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    // replace default version of method with streamed unary
+    virtual ::grpc::Status StreamedCountTable(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::TableName,::milvus::grpc::TableRowCount>* server_unary_streamer) = 0;
+  };
+  template <class BaseClass>
+  class WithStreamedUnaryMethod_ShowTables : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithStreamedUnaryMethod_ShowTables() {
+      ::grpc::Service::MarkMethodStreamed(9,
+        new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::Command, ::milvus::grpc::TableNameList>(std::bind(&WithStreamedUnaryMethod_ShowTables<BaseClass>::StreamedShowTables, this, std::placeholders::_1, std::placeholders::_2)));
+    }
+    ~WithStreamedUnaryMethod_ShowTables() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable regular version of this method
+    ::grpc::Status ShowTables(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::TableNameList* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    // replace default version of method with streamed unary
+    virtual ::grpc::Status StreamedShowTables(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::Command,::milvus::grpc::TableNameList>* server_unary_streamer) = 0;
+  };
+  template <class BaseClass>
+  class WithStreamedUnaryMethod_Cmd : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithStreamedUnaryMethod_Cmd() {
+      ::grpc::Service::MarkMethodStreamed(10,
+        new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::Command, ::milvus::grpc::StringReply>(std::bind(&WithStreamedUnaryMethod_Cmd<BaseClass>::StreamedCmd, this, std::placeholders::_1, std::placeholders::_2)));
+    }
+    ~WithStreamedUnaryMethod_Cmd() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable regular version of this method
+    ::grpc::Status Cmd(::grpc::ServerContext* context, const ::milvus::grpc::Command* request, ::milvus::grpc::StringReply* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    // replace default version of method with streamed unary
+    virtual ::grpc::Status StreamedCmd(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::Command,::milvus::grpc::StringReply>* server_unary_streamer) = 0;
+  };
+  template <class BaseClass>
+  class WithStreamedUnaryMethod_DeleteByRange : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithStreamedUnaryMethod_DeleteByRange() {
+      ::grpc::Service::MarkMethodStreamed(11,
+        new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::DeleteByRangeParam, ::milvus::grpc::Status>(std::bind(&WithStreamedUnaryMethod_DeleteByRange<BaseClass>::StreamedDeleteByRange, this, std::placeholders::_1, std::placeholders::_2)));
+    }
+    ~WithStreamedUnaryMethod_DeleteByRange() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable regular version of this method
+    ::grpc::Status DeleteByRange(::grpc::ServerContext* context, const ::milvus::grpc::DeleteByRangeParam* request, ::milvus::grpc::Status* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    // replace default version of method with streamed unary
+    virtual ::grpc::Status StreamedDeleteByRange(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::DeleteByRangeParam,::milvus::grpc::Status>* server_unary_streamer) = 0;
+  };
+  template <class BaseClass>
+  class WithStreamedUnaryMethod_PreloadTable : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithStreamedUnaryMethod_PreloadTable() {
+      ::grpc::Service::MarkMethodStreamed(12,
+        new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::Status>(std::bind(&WithStreamedUnaryMethod_PreloadTable<BaseClass>::StreamedPreloadTable, this, std::placeholders::_1, std::placeholders::_2)));
+    }
+    ~WithStreamedUnaryMethod_PreloadTable() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable regular version of this method
+    ::grpc::Status PreloadTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    // replace default version of method with streamed unary
+    virtual ::grpc::Status StreamedPreloadTable(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::TableName,::milvus::grpc::Status>* server_unary_streamer) = 0;
+  };
+  template <class BaseClass>
+  class WithStreamedUnaryMethod_DescribeIndex : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithStreamedUnaryMethod_DescribeIndex() {
+      ::grpc::Service::MarkMethodStreamed(13,
+        new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::IndexParam>(std::bind(&WithStreamedUnaryMethod_DescribeIndex<BaseClass>::StreamedDescribeIndex, this, std::placeholders::_1, std::placeholders::_2)));
+    }
+    ~WithStreamedUnaryMethod_DescribeIndex() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable regular version of this method
+    ::grpc::Status DescribeIndex(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::IndexParam* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    // replace default version of method with streamed unary
+    virtual ::grpc::Status StreamedDescribeIndex(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::TableName,::milvus::grpc::IndexParam>* server_unary_streamer) = 0;
+  };
+  template <class BaseClass>
+  class WithStreamedUnaryMethod_DropIndex : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service *service) {}
+   public:
+    WithStreamedUnaryMethod_DropIndex() {
+      ::grpc::Service::MarkMethodStreamed(14,
+        new ::grpc::internal::StreamedUnaryHandler< ::milvus::grpc::TableName, ::milvus::grpc::Status>(std::bind(&WithStreamedUnaryMethod_DropIndex<BaseClass>::StreamedDropIndex, this, std::placeholders::_1, std::placeholders::_2)));
+    }
+    ~WithStreamedUnaryMethod_DropIndex() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable regular version of this method
+    ::grpc::Status DropIndex(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request, ::milvus::grpc::Status* response) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    // replace default version of method with streamed unary
+    virtual ::grpc::Status StreamedDropIndex(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::milvus::grpc::TableName,::milvus::grpc::Status>* server_unary_streamer) = 0;
+  };
+  typedef WithStreamedUnaryMethod_CreateTable<WithStreamedUnaryMethod_HasTable<WithStreamedUnaryMethod_DropTable<WithStreamedUnaryMethod_CreateIndex<WithStreamedUnaryMethod_Insert<WithStreamedUnaryMethod_Search<WithStreamedUnaryMethod_SearchInFiles<WithStreamedUnaryMethod_DescribeTable<WithStreamedUnaryMethod_CountTable<WithStreamedUnaryMethod_ShowTables<WithStreamedUnaryMethod_Cmd<WithStreamedUnaryMethod_DeleteByRange<WithStreamedUnaryMethod_PreloadTable<WithStreamedUnaryMethod_DescribeIndex<WithStreamedUnaryMethod_DropIndex<Service > > > > > > > > > > > > > > > StreamedUnaryService;
+  typedef Service SplitStreamedService;
+  typedef WithStreamedUnaryMethod_CreateTable<WithStreamedUnaryMethod_HasTable<WithStreamedUnaryMethod_DropTable<WithStreamedUnaryMethod_CreateIndex<WithStreamedUnaryMethod_Insert<WithStreamedUnaryMethod_Search<WithStreamedUnaryMethod_SearchInFiles<WithStreamedUnaryMethod_DescribeTable<WithStreamedUnaryMethod_CountTable<WithStreamedUnaryMethod_ShowTables<WithStreamedUnaryMethod_Cmd<WithStreamedUnaryMethod_DeleteByRange<WithStreamedUnaryMethod_PreloadTable<WithStreamedUnaryMethod_DescribeIndex<WithStreamedUnaryMethod_DropIndex<Service > > > > > > > > > > > > > > > StreamedService;
+};
+
+}  // namespace grpc
+}  // namespace milvus
+
+
+#endif  // GRPC_milvus_2eproto__INCLUDED
diff --git a/core/src/grpc/gen-milvus/milvus.pb.cc b/core/src/grpc/gen-milvus/milvus.pb.cc
new file mode 100644
index 0000000000..fe416a4773
--- /dev/null
+++ b/core/src/grpc/gen-milvus/milvus.pb.cc
@@ -0,0 +1,7082 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: milvus.proto
+
+#include "milvus.pb.h"
+
+#include <algorithm>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/wire_format_lite.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+extern PROTOBUF_INTERNAL_EXPORT_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Index_milvus_2eproto;
+extern PROTOBUF_INTERNAL_EXPORT_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_QueryResult_milvus_2eproto;
+extern PROTOBUF_INTERNAL_EXPORT_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Range_milvus_2eproto;
+extern PROTOBUF_INTERNAL_EXPORT_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_RowRecord_milvus_2eproto;
+extern PROTOBUF_INTERNAL_EXPORT_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_SearchParam_milvus_2eproto;
+extern PROTOBUF_INTERNAL_EXPORT_status_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Status_status_2eproto;
+extern PROTOBUF_INTERNAL_EXPORT_milvus_2eproto ::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_TopKQueryResult_milvus_2eproto;
+namespace milvus {
+namespace grpc {
+class TableNameDefaultTypeInternal {
+ public:
+  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<TableName> _instance;
+} _TableName_default_instance_;
+class TableNameListDefaultTypeInternal {
+ public:
+  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<TableNameList> _instance;
+} _TableNameList_default_instance_;
+class TableSchemaDefaultTypeInternal {
+ public:
+  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<TableSchema> _instance;
+} _TableSchema_default_instance_;
+class RangeDefaultTypeInternal {
+ public:
+  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<Range> _instance;
+} _Range_default_instance_;
+class RowRecordDefaultTypeInternal {
+ public:
+  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<RowRecord> _instance;
+} _RowRecord_default_instance_;
+class InsertParamDefaultTypeInternal {
+ public:
+  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<InsertParam> _instance;
+} _InsertParam_default_instance_;
+class VectorIdsDefaultTypeInternal {
+ public:
+  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<VectorIds> _instance;
+} _VectorIds_default_instance_;
+class SearchParamDefaultTypeInternal {
+ public:
+  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<SearchParam> _instance;
+} _SearchParam_default_instance_;
+class SearchInFilesParamDefaultTypeInternal {
+ public:
+  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<SearchInFilesParam> _instance;
+} _SearchInFilesParam_default_instance_;
+class QueryResultDefaultTypeInternal {
+ public:
+  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<QueryResult> _instance;
+} _QueryResult_default_instance_;
+class TopKQueryResultDefaultTypeInternal {
+ public:
+  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<TopKQueryResult> _instance;
+} _TopKQueryResult_default_instance_;
+class TopKQueryResultListDefaultTypeInternal {
+ public:
+  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<TopKQueryResultList> _instance;
+} _TopKQueryResultList_default_instance_;
+class StringReplyDefaultTypeInternal {
+ public:
+  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<StringReply> _instance;
+} _StringReply_default_instance_;
+class BoolReplyDefaultTypeInternal {
+ public:
+  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<BoolReply> _instance;
+} _BoolReply_default_instance_;
+class TableRowCountDefaultTypeInternal {
+ public:
+  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<TableRowCount> _instance;
+} _TableRowCount_default_instance_;
+class CommandDefaultTypeInternal {
+ public:
+  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<Command> _instance;
+} _Command_default_instance_;
+class IndexDefaultTypeInternal {
+ public:
+  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<Index> _instance;
+} _Index_default_instance_;
+class IndexParamDefaultTypeInternal {
+ public:
+  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<IndexParam> _instance;
+} _IndexParam_default_instance_;
+class DeleteByRangeParamDefaultTypeInternal {
+ public:
+  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<DeleteByRangeParam> _instance;
+} _DeleteByRangeParam_default_instance_;
+}  // namespace grpc
+}  // namespace milvus
+static void InitDefaultsscc_info_BoolReply_milvus_2eproto() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  {
+    void* ptr = &::milvus::grpc::_BoolReply_default_instance_;
+    new (ptr) ::milvus::grpc::BoolReply();
+    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::milvus::grpc::BoolReply::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_BoolReply_milvus_2eproto =
+    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_BoolReply_milvus_2eproto}, {
+      &scc_info_Status_status_2eproto.base,}};
+
+static void InitDefaultsscc_info_Command_milvus_2eproto() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  {
+    void* ptr = &::milvus::grpc::_Command_default_instance_;
+    new (ptr) ::milvus::grpc::Command();
+    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::milvus::grpc::Command::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Command_milvus_2eproto =
+    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_Command_milvus_2eproto}, {}};
+
+static void InitDefaultsscc_info_DeleteByRangeParam_milvus_2eproto() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  {
+    void* ptr = &::milvus::grpc::_DeleteByRangeParam_default_instance_;
+    new (ptr) ::milvus::grpc::DeleteByRangeParam();
+    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::milvus::grpc::DeleteByRangeParam::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_DeleteByRangeParam_milvus_2eproto =
+    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_DeleteByRangeParam_milvus_2eproto}, {
+      &scc_info_Range_milvus_2eproto.base,}};
+
+static void InitDefaultsscc_info_Index_milvus_2eproto() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  {
+    void* ptr = &::milvus::grpc::_Index_default_instance_;
+    new (ptr) ::milvus::grpc::Index();
+    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::milvus::grpc::Index::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Index_milvus_2eproto =
+    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_Index_milvus_2eproto}, {}};
+
+static void InitDefaultsscc_info_IndexParam_milvus_2eproto() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  {
+    void* ptr = &::milvus::grpc::_IndexParam_default_instance_;
+    new (ptr) ::milvus::grpc::IndexParam();
+    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::milvus::grpc::IndexParam::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_IndexParam_milvus_2eproto =
+    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_IndexParam_milvus_2eproto}, {
+      &scc_info_Status_status_2eproto.base,
+      &scc_info_Index_milvus_2eproto.base,}};
+
+static void InitDefaultsscc_info_InsertParam_milvus_2eproto() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  {
+    void* ptr = &::milvus::grpc::_InsertParam_default_instance_;
+    new (ptr) ::milvus::grpc::InsertParam();
+    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::milvus::grpc::InsertParam::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_InsertParam_milvus_2eproto =
+    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_InsertParam_milvus_2eproto}, {
+      &scc_info_RowRecord_milvus_2eproto.base,}};
+
+static void InitDefaultsscc_info_QueryResult_milvus_2eproto() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  {
+    void* ptr = &::milvus::grpc::_QueryResult_default_instance_;
+    new (ptr) ::milvus::grpc::QueryResult();
+    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::milvus::grpc::QueryResult::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_QueryResult_milvus_2eproto =
+    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_QueryResult_milvus_2eproto}, {}};
+
+static void InitDefaultsscc_info_Range_milvus_2eproto() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  {
+    void* ptr = &::milvus::grpc::_Range_default_instance_;
+    new (ptr) ::milvus::grpc::Range();
+    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::milvus::grpc::Range::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Range_milvus_2eproto =
+    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_Range_milvus_2eproto}, {}};
+
+static void InitDefaultsscc_info_RowRecord_milvus_2eproto() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  {
+    void* ptr = &::milvus::grpc::_RowRecord_default_instance_;
+    new (ptr) ::milvus::grpc::RowRecord();
+    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::milvus::grpc::RowRecord::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_RowRecord_milvus_2eproto =
+    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_RowRecord_milvus_2eproto}, {}};
+
+static void InitDefaultsscc_info_SearchInFilesParam_milvus_2eproto() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  {
+    void* ptr = &::milvus::grpc::_SearchInFilesParam_default_instance_;
+    new (ptr) ::milvus::grpc::SearchInFilesParam();
+    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::milvus::grpc::SearchInFilesParam::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_SearchInFilesParam_milvus_2eproto =
+    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_SearchInFilesParam_milvus_2eproto}, {
+      &scc_info_SearchParam_milvus_2eproto.base,}};
+
+static void InitDefaultsscc_info_SearchParam_milvus_2eproto() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  {
+    void* ptr = &::milvus::grpc::_SearchParam_default_instance_;
+    new (ptr) ::milvus::grpc::SearchParam();
+    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::milvus::grpc::SearchParam::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_SearchParam_milvus_2eproto =
+    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_SearchParam_milvus_2eproto}, {
+      &scc_info_RowRecord_milvus_2eproto.base,
+      &scc_info_Range_milvus_2eproto.base,}};
+
+static void InitDefaultsscc_info_StringReply_milvus_2eproto() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  {
+    void* ptr = &::milvus::grpc::_StringReply_default_instance_;
+    new (ptr) ::milvus::grpc::StringReply();
+    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::milvus::grpc::StringReply::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_StringReply_milvus_2eproto =
+    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_StringReply_milvus_2eproto}, {
+      &scc_info_Status_status_2eproto.base,}};
+
+static void InitDefaultsscc_info_TableName_milvus_2eproto() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  {
+    void* ptr = &::milvus::grpc::_TableName_default_instance_;
+    new (ptr) ::milvus::grpc::TableName();
+    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::milvus::grpc::TableName::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_TableName_milvus_2eproto =
+    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_TableName_milvus_2eproto}, {}};
+
+static void InitDefaultsscc_info_TableNameList_milvus_2eproto() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  {
+    void* ptr = &::milvus::grpc::_TableNameList_default_instance_;
+    new (ptr) ::milvus::grpc::TableNameList();
+    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::milvus::grpc::TableNameList::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_TableNameList_milvus_2eproto =
+    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_TableNameList_milvus_2eproto}, {
+      &scc_info_Status_status_2eproto.base,}};
+
+static void InitDefaultsscc_info_TableRowCount_milvus_2eproto() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  {
+    void* ptr = &::milvus::grpc::_TableRowCount_default_instance_;
+    new (ptr) ::milvus::grpc::TableRowCount();
+    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::milvus::grpc::TableRowCount::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_TableRowCount_milvus_2eproto =
+    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_TableRowCount_milvus_2eproto}, {
+      &scc_info_Status_status_2eproto.base,}};
+
+static void InitDefaultsscc_info_TableSchema_milvus_2eproto() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  {
+    void* ptr = &::milvus::grpc::_TableSchema_default_instance_;
+    new (ptr) ::milvus::grpc::TableSchema();
+    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::milvus::grpc::TableSchema::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_TableSchema_milvus_2eproto =
+    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_TableSchema_milvus_2eproto}, {
+      &scc_info_Status_status_2eproto.base,}};
+
+static void InitDefaultsscc_info_TopKQueryResult_milvus_2eproto() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  {
+    void* ptr = &::milvus::grpc::_TopKQueryResult_default_instance_;
+    new (ptr) ::milvus::grpc::TopKQueryResult();
+    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::milvus::grpc::TopKQueryResult::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_TopKQueryResult_milvus_2eproto =
+    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_TopKQueryResult_milvus_2eproto}, {
+      &scc_info_QueryResult_milvus_2eproto.base,}};
+
+static void InitDefaultsscc_info_TopKQueryResultList_milvus_2eproto() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  {
+    void* ptr = &::milvus::grpc::_TopKQueryResultList_default_instance_;
+    new (ptr) ::milvus::grpc::TopKQueryResultList();
+    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::milvus::grpc::TopKQueryResultList::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<2> scc_info_TopKQueryResultList_milvus_2eproto =
+    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 2, InitDefaultsscc_info_TopKQueryResultList_milvus_2eproto}, {
+      &scc_info_Status_status_2eproto.base,
+      &scc_info_TopKQueryResult_milvus_2eproto.base,}};
+
+static void InitDefaultsscc_info_VectorIds_milvus_2eproto() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  {
+    void* ptr = &::milvus::grpc::_VectorIds_default_instance_;
+    new (ptr) ::milvus::grpc::VectorIds();
+    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::milvus::grpc::VectorIds::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<1> scc_info_VectorIds_milvus_2eproto =
+    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 1, InitDefaultsscc_info_VectorIds_milvus_2eproto}, {
+      &scc_info_Status_status_2eproto.base,}};
+
+static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_milvus_2eproto[19];
+static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_milvus_2eproto = nullptr;
+static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_milvus_2eproto = nullptr;
+
+const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_milvus_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableName, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableName, table_name_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableNameList, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableNameList, status_),
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableNameList, table_names_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableSchema, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableSchema, status_),
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableSchema, table_name_),
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableSchema, dimension_),
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableSchema, index_file_size_),
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableSchema, metric_type_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::Range, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::Range, start_value_),
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::Range, end_value_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::RowRecord, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::RowRecord, vector_data_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::InsertParam, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::InsertParam, table_name_),
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::InsertParam, row_record_array_),
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::InsertParam, row_id_array_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorIds, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorIds, status_),
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::VectorIds, vector_id_array_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchParam, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchParam, table_name_),
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchParam, query_record_array_),
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchParam, query_range_array_),
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchParam, topk_),
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchParam, nprobe_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchInFilesParam, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchInFilesParam, file_id_array_),
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::SearchInFilesParam, search_param_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::QueryResult, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::QueryResult, id_),
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::QueryResult, distance_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::TopKQueryResult, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::TopKQueryResult, query_result_arrays_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::TopKQueryResultList, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::TopKQueryResultList, status_),
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::TopKQueryResultList, topk_query_result_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::StringReply, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::StringReply, status_),
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::StringReply, string_reply_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::BoolReply, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::BoolReply, status_),
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::BoolReply, bool_reply_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableRowCount, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableRowCount, status_),
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::TableRowCount, table_row_count_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::Command, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::Command, cmd_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::Index, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::Index, index_type_),
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::Index, nlist_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::IndexParam, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::IndexParam, status_),
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::IndexParam, table_name_),
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::IndexParam, index_),
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::DeleteByRangeParam, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::DeleteByRangeParam, range_),
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::DeleteByRangeParam, table_name_),
+};
+static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+  { 0, -1, sizeof(::milvus::grpc::TableName)},
+  { 6, -1, sizeof(::milvus::grpc::TableNameList)},
+  { 13, -1, sizeof(::milvus::grpc::TableSchema)},
+  { 23, -1, sizeof(::milvus::grpc::Range)},
+  { 30, -1, sizeof(::milvus::grpc::RowRecord)},
+  { 36, -1, sizeof(::milvus::grpc::InsertParam)},
+  { 44, -1, sizeof(::milvus::grpc::VectorIds)},
+  { 51, -1, sizeof(::milvus::grpc::SearchParam)},
+  { 61, -1, sizeof(::milvus::grpc::SearchInFilesParam)},
+  { 68, -1, sizeof(::milvus::grpc::QueryResult)},
+  { 75, -1, sizeof(::milvus::grpc::TopKQueryResult)},
+  { 81, -1, sizeof(::milvus::grpc::TopKQueryResultList)},
+  { 88, -1, sizeof(::milvus::grpc::StringReply)},
+  { 95, -1, sizeof(::milvus::grpc::BoolReply)},
+  { 102, -1, sizeof(::milvus::grpc::TableRowCount)},
+  { 109, -1, sizeof(::milvus::grpc::Command)},
+  { 115, -1, sizeof(::milvus::grpc::Index)},
+  { 122, -1, sizeof(::milvus::grpc::IndexParam)},
+  { 130, -1, sizeof(::milvus::grpc::DeleteByRangeParam)},
+};
+
+static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::milvus::grpc::_TableName_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::milvus::grpc::_TableNameList_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::milvus::grpc::_TableSchema_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::milvus::grpc::_Range_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::milvus::grpc::_RowRecord_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::milvus::grpc::_InsertParam_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::milvus::grpc::_VectorIds_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::milvus::grpc::_SearchParam_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::milvus::grpc::_SearchInFilesParam_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::milvus::grpc::_QueryResult_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::milvus::grpc::_TopKQueryResult_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::milvus::grpc::_TopKQueryResultList_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::milvus::grpc::_StringReply_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::milvus::grpc::_BoolReply_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::milvus::grpc::_TableRowCount_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::milvus::grpc::_Command_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::milvus::grpc::_Index_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::milvus::grpc::_IndexParam_default_instance_),
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::milvus::grpc::_DeleteByRangeParam_default_instance_),
+};
+
+const char descriptor_table_protodef_milvus_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
+  "\n\014milvus.proto\022\013milvus.grpc\032\014status.prot"
+  "o\"\037\n\tTableName\022\022\n\ntable_name\030\001 \001(\t\"I\n\rTa"
+  "bleNameList\022#\n\006status\030\001 \001(\0132\023.milvus.grp"
+  "c.Status\022\023\n\013table_names\030\002 \003(\t\"\207\001\n\013TableS"
+  "chema\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.Stat"
+  "us\022\022\n\ntable_name\030\002 \001(\t\022\021\n\tdimension\030\003 \001("
+  "\003\022\027\n\017index_file_size\030\004 \001(\003\022\023\n\013metric_typ"
+  "e\030\005 \001(\005\"/\n\005Range\022\023\n\013start_value\030\001 \001(\t\022\021\n"
+  "\tend_value\030\002 \001(\t\" \n\tRowRecord\022\023\n\013vector_"
+  "data\030\001 \003(\002\"i\n\013InsertParam\022\022\n\ntable_name\030"
+  "\001 \001(\t\0220\n\020row_record_array\030\002 \003(\0132\026.milvus"
+  ".grpc.RowRecord\022\024\n\014row_id_array\030\003 \003(\003\"I\n"
+  "\tVectorIds\022#\n\006status\030\001 \001(\0132\023.milvus.grpc"
+  ".Status\022\027\n\017vector_id_array\030\002 \003(\003\"\242\001\n\013Sea"
+  "rchParam\022\022\n\ntable_name\030\001 \001(\t\0222\n\022query_re"
+  "cord_array\030\002 \003(\0132\026.milvus.grpc.RowRecord"
+  "\022-\n\021query_range_array\030\003 \003(\0132\022.milvus.grp"
+  "c.Range\022\014\n\004topk\030\004 \001(\003\022\016\n\006nprobe\030\005 \001(\003\"[\n"
+  "\022SearchInFilesParam\022\025\n\rfile_id_array\030\001 \003"
+  "(\t\022.\n\014search_param\030\002 \001(\0132\030.milvus.grpc.S"
+  "earchParam\"+\n\013QueryResult\022\n\n\002id\030\001 \001(\003\022\020\n"
+  "\010distance\030\002 \001(\001\"H\n\017TopKQueryResult\0225\n\023qu"
+  "ery_result_arrays\030\001 \003(\0132\030.milvus.grpc.Qu"
+  "eryResult\"s\n\023TopKQueryResultList\022#\n\006stat"
+  "us\030\001 \001(\0132\023.milvus.grpc.Status\0227\n\021topk_qu"
+  "ery_result\030\002 \003(\0132\034.milvus.grpc.TopKQuery"
+  "Result\"H\n\013StringReply\022#\n\006status\030\001 \001(\0132\023."
+  "milvus.grpc.Status\022\024\n\014string_reply\030\002 \001(\t"
+  "\"D\n\tBoolReply\022#\n\006status\030\001 \001(\0132\023.milvus.g"
+  "rpc.Status\022\022\n\nbool_reply\030\002 \001(\010\"M\n\rTableR"
+  "owCount\022#\n\006status\030\001 \001(\0132\023.milvus.grpc.St"
+  "atus\022\027\n\017table_row_count\030\002 \001(\003\"\026\n\007Command"
+  "\022\013\n\003cmd\030\001 \001(\t\"*\n\005Index\022\022\n\nindex_type\030\001 \001"
+  "(\005\022\r\n\005nlist\030\002 \001(\005\"h\n\nIndexParam\022#\n\006statu"
+  "s\030\001 \001(\0132\023.milvus.grpc.Status\022\022\n\ntable_na"
+  "me\030\002 \001(\t\022!\n\005index\030\003 \001(\0132\022.milvus.grpc.In"
+  "dex\"K\n\022DeleteByRangeParam\022!\n\005range\030\001 \001(\013"
+  "2\022.milvus.grpc.Range\022\022\n\ntable_name\030\002 \001(\t"
+  "2\360\007\n\rMilvusService\022>\n\013CreateTable\022\030.milv"
+  "us.grpc.TableSchema\032\023.milvus.grpc.Status"
+  "\"\000\022<\n\010HasTable\022\026.milvus.grpc.TableName\032\026"
+  ".milvus.grpc.BoolReply\"\000\022:\n\tDropTable\022\026."
+  "milvus.grpc.TableName\032\023.milvus.grpc.Stat"
+  "us\"\000\022=\n\013CreateIndex\022\027.milvus.grpc.IndexP"
+  "aram\032\023.milvus.grpc.Status\"\000\022<\n\006Insert\022\030."
+  "milvus.grpc.InsertParam\032\026.milvus.grpc.Ve"
+  "ctorIds\"\000\022F\n\006Search\022\030.milvus.grpc.Search"
+  "Param\032 .milvus.grpc.TopKQueryResultList\""
+  "\000\022T\n\rSearchInFiles\022\037.milvus.grpc.SearchI"
+  "nFilesParam\032 .milvus.grpc.TopKQueryResul"
+  "tList\"\000\022C\n\rDescribeTable\022\026.milvus.grpc.T"
+  "ableName\032\030.milvus.grpc.TableSchema\"\000\022B\n\n"
+  "CountTable\022\026.milvus.grpc.TableName\032\032.mil"
+  "vus.grpc.TableRowCount\"\000\022@\n\nShowTables\022\024"
+  ".milvus.grpc.Command\032\032.milvus.grpc.Table"
+  "NameList\"\000\0227\n\003Cmd\022\024.milvus.grpc.Command\032"
+  "\030.milvus.grpc.StringReply\"\000\022G\n\rDeleteByR"
+  "ange\022\037.milvus.grpc.DeleteByRangeParam\032\023."
+  "milvus.grpc.Status\"\000\022=\n\014PreloadTable\022\026.m"
+  "ilvus.grpc.TableName\032\023.milvus.grpc.Statu"
+  "s\"\000\022B\n\rDescribeIndex\022\026.milvus.grpc.Table"
+  "Name\032\027.milvus.grpc.IndexParam\"\000\022:\n\tDropI"
+  "ndex\022\026.milvus.grpc.TableName\032\023.milvus.gr"
+  "pc.Status\"\000b\006proto3"
+  ;
+static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_milvus_2eproto_deps[1] = {
+  &::descriptor_table_status_2eproto,
+};
+static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_milvus_2eproto_sccs[19] = {
+  &scc_info_BoolReply_milvus_2eproto.base,
+  &scc_info_Command_milvus_2eproto.base,
+  &scc_info_DeleteByRangeParam_milvus_2eproto.base,
+  &scc_info_Index_milvus_2eproto.base,
+  &scc_info_IndexParam_milvus_2eproto.base,
+  &scc_info_InsertParam_milvus_2eproto.base,
+  &scc_info_QueryResult_milvus_2eproto.base,
+  &scc_info_Range_milvus_2eproto.base,
+  &scc_info_RowRecord_milvus_2eproto.base,
+  &scc_info_SearchInFilesParam_milvus_2eproto.base,
+  &scc_info_SearchParam_milvus_2eproto.base,
+  &scc_info_StringReply_milvus_2eproto.base,
+  &scc_info_TableName_milvus_2eproto.base,
+  &scc_info_TableNameList_milvus_2eproto.base,
+  &scc_info_TableRowCount_milvus_2eproto.base,
+  &scc_info_TableSchema_milvus_2eproto.base,
+  &scc_info_TopKQueryResult_milvus_2eproto.base,
+  &scc_info_TopKQueryResultList_milvus_2eproto.base,
+  &scc_info_VectorIds_milvus_2eproto.base,
+};
+static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_milvus_2eproto_once;
+static bool descriptor_table_milvus_2eproto_initialized = false;
+const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_milvus_2eproto = {
+  &descriptor_table_milvus_2eproto_initialized, descriptor_table_protodef_milvus_2eproto, "milvus.proto", 2539,
+  &descriptor_table_milvus_2eproto_once, descriptor_table_milvus_2eproto_sccs, descriptor_table_milvus_2eproto_deps, 19, 1,
+  schemas, file_default_instances, TableStruct_milvus_2eproto::offsets,
+  file_level_metadata_milvus_2eproto, 19, file_level_enum_descriptors_milvus_2eproto, file_level_service_descriptors_milvus_2eproto,
+};
+
+// Force running AddDescriptors() at dynamic initialization time.
+static bool dynamic_init_dummy_milvus_2eproto = (  ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptors(&descriptor_table_milvus_2eproto), true);
+namespace milvus {
+namespace grpc {
+
+// ===================================================================
+
+void TableName::InitAsDefaultInstance() {
+}
+class TableName::_Internal {
+ public:
+};
+
+TableName::TableName()
+  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:milvus.grpc.TableName)
+}
+TableName::TableName(const TableName& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      _internal_metadata_(nullptr) {
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  if (!from.table_name().empty()) {
+    table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_);
+  }
+  // @@protoc_insertion_point(copy_constructor:milvus.grpc.TableName)
+}
+
+void TableName::SharedCtor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TableName_milvus_2eproto.base);
+  table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+TableName::~TableName() {
+  // @@protoc_insertion_point(destructor:milvus.grpc.TableName)
+  SharedDtor();
+}
+
+void TableName::SharedDtor() {
+  table_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void TableName::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+const TableName& TableName::default_instance() {
+  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TableName_milvus_2eproto.base);
+  return *internal_default_instance();
+}
+
+
+void TableName::Clear() {
+// @@protoc_insertion_point(message_clear_start:milvus.grpc.TableName)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  _internal_metadata_.Clear();
+}
+
+#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+const char* TableName::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    CHK_(ptr);
+    switch (tag >> 3) {
+      // string table_name = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_table_name(), ptr, ctx, "milvus.grpc.TableName.table_name");
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      default: {
+      handle_unusual:
+        if ((tag & 7) == 4 || tag == 0) {
+          ctx->SetLastTag(tag);
+          goto success;
+        }
+        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
+        CHK_(ptr != nullptr);
+        continue;
+      }
+    }  // switch
+  }  // while
+success:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto success;
+#undef CHK_
+}
+#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+bool TableName::MergePartialFromCodedStream(
+    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
+  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+  // @@protoc_insertion_point(parse_start:milvus.grpc.TableName)
+  for (;;) {
+    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // string table_name = 1;
+      case 1: {
+        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
+          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
+                input, this->mutable_table_name()));
+          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+            this->table_name().data(), static_cast<int>(this->table_name().length()),
+            ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
+            "milvus.grpc.TableName.table_name"));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0) {
+          goto success;
+        }
+        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
+              input, tag, _internal_metadata_.mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:milvus.grpc.TableName)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:milvus.grpc.TableName)
+  return false;
+#undef DO_
+}
+#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+
+void TableName::SerializeWithCachedSizes(
+    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:milvus.grpc.TableName)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // string table_name = 1;
+  if (this->table_name().size() > 0) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->table_name().data(), static_cast<int>(this->table_name().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "milvus.grpc.TableName.table_name");
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->table_name(), output);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
+        _internal_metadata_.unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:milvus.grpc.TableName)
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* TableName::InternalSerializeWithCachedSizesToArray(
+    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.TableName)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // string table_name = 1;
+  if (this->table_name().size() > 0) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->table_name().data(), static_cast<int>(this->table_name().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "milvus.grpc.TableName.table_name");
+    target =
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
+        1, this->table_name(), target);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.TableName)
+  return target;
+}
+
+size_t TableName::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.TableName)
+  size_t total_size = 0;
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
+        _internal_metadata_.unknown_fields());
+  }
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // string table_name = 1;
+  if (this->table_name().size() > 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->table_name());
+  }
+
+  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void TableName::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.TableName)
+  GOOGLE_DCHECK_NE(&from, this);
+  const TableName* source =
+      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<TableName>(
+          &from);
+  if (source == nullptr) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.TableName)
+    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.TableName)
+    MergeFrom(*source);
+  }
+}
+
+void TableName::MergeFrom(const TableName& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.TableName)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from.table_name().size() > 0) {
+
+    table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_);
+  }
+}
+
+void TableName::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.TableName)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void TableName::CopyFrom(const TableName& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.TableName)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool TableName::IsInitialized() const {
+  return true;
+}
+
+void TableName::InternalSwap(TableName* other) {
+  using std::swap;
+  _internal_metadata_.Swap(&other->_internal_metadata_);
+  table_name_.Swap(&other->table_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+    GetArenaNoVirtual());
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata TableName::GetMetadata() const {
+  return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+void TableNameList::InitAsDefaultInstance() {
+  ::milvus::grpc::_TableNameList_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>(
+      ::milvus::grpc::Status::internal_default_instance());
+}
+class TableNameList::_Internal {
+ public:
+  static const ::milvus::grpc::Status& status(const TableNameList* msg);
+};
+
+const ::milvus::grpc::Status&
+TableNameList::_Internal::status(const TableNameList* msg) {
+  return *msg->status_;
+}
+void TableNameList::clear_status() {
+  if (GetArenaNoVirtual() == nullptr && status_ != nullptr) {
+    delete status_;
+  }
+  status_ = nullptr;
+}
+TableNameList::TableNameList()
+  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:milvus.grpc.TableNameList)
+}
+TableNameList::TableNameList(const TableNameList& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      _internal_metadata_(nullptr),
+      table_names_(from.table_names_) {
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  if (from.has_status()) {
+    status_ = new ::milvus::grpc::Status(*from.status_);
+  } else {
+    status_ = nullptr;
+  }
+  // @@protoc_insertion_point(copy_constructor:milvus.grpc.TableNameList)
+}
+
+void TableNameList::SharedCtor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TableNameList_milvus_2eproto.base);
+  status_ = nullptr;
+}
+
+TableNameList::~TableNameList() {
+  // @@protoc_insertion_point(destructor:milvus.grpc.TableNameList)
+  SharedDtor();
+}
+
+void TableNameList::SharedDtor() {
+  if (this != internal_default_instance()) delete status_;
+}
+
+void TableNameList::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+const TableNameList& TableNameList::default_instance() {
+  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TableNameList_milvus_2eproto.base);
+  return *internal_default_instance();
+}
+
+
+void TableNameList::Clear() {
+// @@protoc_insertion_point(message_clear_start:milvus.grpc.TableNameList)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  table_names_.Clear();
+  if (GetArenaNoVirtual() == nullptr && status_ != nullptr) {
+    delete status_;
+  }
+  status_ = nullptr;
+  _internal_metadata_.Clear();
+}
+
+#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+const char* TableNameList::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    CHK_(ptr);
+    switch (tag >> 3) {
+      // .milvus.grpc.Status status = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+          ptr = ctx->ParseMessage(mutable_status(), ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // repeated string table_names = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(add_table_names(), ptr, ctx, "milvus.grpc.TableNameList.table_names");
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 18);
+        } else goto handle_unusual;
+        continue;
+      default: {
+      handle_unusual:
+        if ((tag & 7) == 4 || tag == 0) {
+          ctx->SetLastTag(tag);
+          goto success;
+        }
+        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
+        CHK_(ptr != nullptr);
+        continue;
+      }
+    }  // switch
+  }  // while
+success:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto success;
+#undef CHK_
+}
+#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+bool TableNameList::MergePartialFromCodedStream(
+    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
+  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+  // @@protoc_insertion_point(parse_start:milvus.grpc.TableNameList)
+  for (;;) {
+    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // .milvus.grpc.Status status = 1;
+      case 1: {
+        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
+          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
+               input, mutable_status()));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      // repeated string table_names = 2;
+      case 2: {
+        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
+          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
+                input, this->add_table_names()));
+          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+            this->table_names(this->table_names_size() - 1).data(),
+            static_cast<int>(this->table_names(this->table_names_size() - 1).length()),
+            ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
+            "milvus.grpc.TableNameList.table_names"));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0) {
+          goto success;
+        }
+        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
+              input, tag, _internal_metadata_.mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:milvus.grpc.TableNameList)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:milvus.grpc.TableNameList)
+  return false;
+#undef DO_
+}
+#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+
+void TableNameList::SerializeWithCachedSizes(
+    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:milvus.grpc.TableNameList)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .milvus.grpc.Status status = 1;
+  if (this->has_status()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, _Internal::status(this), output);
+  }
+
+  // repeated string table_names = 2;
+  for (int i = 0, n = this->table_names_size(); i < n; i++) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->table_names(i).data(), static_cast<int>(this->table_names(i).length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "milvus.grpc.TableNameList.table_names");
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteString(
+      2, this->table_names(i), output);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
+        _internal_metadata_.unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:milvus.grpc.TableNameList)
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* TableNameList::InternalSerializeWithCachedSizesToArray(
+    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.TableNameList)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .milvus.grpc.Status status = 1;
+  if (this->has_status()) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessageToArray(
+        1, _Internal::status(this), target);
+  }
+
+  // repeated string table_names = 2;
+  for (int i = 0, n = this->table_names_size(); i < n; i++) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->table_names(i).data(), static_cast<int>(this->table_names(i).length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "milvus.grpc.TableNameList.table_names");
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      WriteStringToArray(2, this->table_names(i), target);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.TableNameList)
+  return target;
+}
+
+size_t TableNameList::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.TableNameList)
+  size_t total_size = 0;
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
+        _internal_metadata_.unknown_fields());
+  }
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated string table_names = 2;
+  total_size += 1 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->table_names_size());
+  for (int i = 0, n = this->table_names_size(); i < n; i++) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+      this->table_names(i));
+  }
+
+  // .milvus.grpc.Status status = 1;
+  if (this->has_status()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *status_);
+  }
+
+  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void TableNameList::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.TableNameList)
+  GOOGLE_DCHECK_NE(&from, this);
+  const TableNameList* source =
+      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<TableNameList>(
+          &from);
+  if (source == nullptr) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.TableNameList)
+    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.TableNameList)
+    MergeFrom(*source);
+  }
+}
+
+void TableNameList::MergeFrom(const TableNameList& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.TableNameList)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  table_names_.MergeFrom(from.table_names_);
+  if (from.has_status()) {
+    mutable_status()->::milvus::grpc::Status::MergeFrom(from.status());
+  }
+}
+
+void TableNameList::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.TableNameList)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void TableNameList::CopyFrom(const TableNameList& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.TableNameList)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool TableNameList::IsInitialized() const {
+  return true;
+}
+
+void TableNameList::InternalSwap(TableNameList* other) {
+  using std::swap;
+  _internal_metadata_.Swap(&other->_internal_metadata_);
+  table_names_.InternalSwap(CastToBase(&other->table_names_));
+  swap(status_, other->status_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata TableNameList::GetMetadata() const {
+  return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+void TableSchema::InitAsDefaultInstance() {
+  ::milvus::grpc::_TableSchema_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>(
+      ::milvus::grpc::Status::internal_default_instance());
+}
+class TableSchema::_Internal {
+ public:
+  static const ::milvus::grpc::Status& status(const TableSchema* msg);
+};
+
+const ::milvus::grpc::Status&
+TableSchema::_Internal::status(const TableSchema* msg) {
+  return *msg->status_;
+}
+void TableSchema::clear_status() {
+  if (GetArenaNoVirtual() == nullptr && status_ != nullptr) {
+    delete status_;
+  }
+  status_ = nullptr;
+}
+TableSchema::TableSchema()
+  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:milvus.grpc.TableSchema)
+}
+TableSchema::TableSchema(const TableSchema& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      _internal_metadata_(nullptr) {
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  if (!from.table_name().empty()) {
+    table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_);
+  }
+  if (from.has_status()) {
+    status_ = new ::milvus::grpc::Status(*from.status_);
+  } else {
+    status_ = nullptr;
+  }
+  ::memcpy(&dimension_, &from.dimension_,
+    static_cast<size_t>(reinterpret_cast<char*>(&metric_type_) -
+    reinterpret_cast<char*>(&dimension_)) + sizeof(metric_type_));
+  // @@protoc_insertion_point(copy_constructor:milvus.grpc.TableSchema)
+}
+
+void TableSchema::SharedCtor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TableSchema_milvus_2eproto.base);
+  table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  ::memset(&status_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&metric_type_) -
+      reinterpret_cast<char*>(&status_)) + sizeof(metric_type_));
+}
+
+TableSchema::~TableSchema() {
+  // @@protoc_insertion_point(destructor:milvus.grpc.TableSchema)
+  SharedDtor();
+}
+
+void TableSchema::SharedDtor() {
+  table_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  if (this != internal_default_instance()) delete status_;
+}
+
+void TableSchema::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+const TableSchema& TableSchema::default_instance() {
+  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TableSchema_milvus_2eproto.base);
+  return *internal_default_instance();
+}
+
+
+void TableSchema::Clear() {
+// @@protoc_insertion_point(message_clear_start:milvus.grpc.TableSchema)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  if (GetArenaNoVirtual() == nullptr && status_ != nullptr) {
+    delete status_;
+  }
+  status_ = nullptr;
+  ::memset(&dimension_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&metric_type_) -
+      reinterpret_cast<char*>(&dimension_)) + sizeof(metric_type_));
+  _internal_metadata_.Clear();
+}
+
+#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+const char* TableSchema::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    CHK_(ptr);
+    switch (tag >> 3) {
+      // .milvus.grpc.Status status = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+          ptr = ctx->ParseMessage(mutable_status(), ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // string table_name = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_table_name(), ptr, ctx, "milvus.grpc.TableSchema.table_name");
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // int64 dimension = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
+          dimension_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // int64 index_file_size = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
+          index_file_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // int32 metric_type = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
+          metric_type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      default: {
+      handle_unusual:
+        if ((tag & 7) == 4 || tag == 0) {
+          ctx->SetLastTag(tag);
+          goto success;
+        }
+        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
+        CHK_(ptr != nullptr);
+        continue;
+      }
+    }  // switch
+  }  // while
+success:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto success;
+#undef CHK_
+}
+#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+bool TableSchema::MergePartialFromCodedStream(
+    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
+  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+  // @@protoc_insertion_point(parse_start:milvus.grpc.TableSchema)
+  for (;;) {
+    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // .milvus.grpc.Status status = 1;
+      case 1: {
+        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
+          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
+               input, mutable_status()));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      // string table_name = 2;
+      case 2: {
+        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
+          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
+                input, this->mutable_table_name()));
+          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+            this->table_name().data(), static_cast<int>(this->table_name().length()),
+            ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
+            "milvus.grpc.TableSchema.table_name"));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      // int64 dimension = 3;
+      case 3: {
+        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {
+
+          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
+                   ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>(
+                 input, &dimension_)));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      // int64 index_file_size = 4;
+      case 4: {
+        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (32 & 0xFF)) {
+
+          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
+                   ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>(
+                 input, &index_file_size_)));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      // int32 metric_type = 5;
+      case 5: {
+        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (40 & 0xFF)) {
+
+          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
+                   ::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>(
+                 input, &metric_type_)));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0) {
+          goto success;
+        }
+        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
+              input, tag, _internal_metadata_.mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:milvus.grpc.TableSchema)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:milvus.grpc.TableSchema)
+  return false;
+#undef DO_
+}
+#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+
+void TableSchema::SerializeWithCachedSizes(
+    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:milvus.grpc.TableSchema)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .milvus.grpc.Status status = 1;
+  if (this->has_status()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, _Internal::status(this), output);
+  }
+
+  // string table_name = 2;
+  if (this->table_name().size() > 0) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->table_name().data(), static_cast<int>(this->table_name().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "milvus.grpc.TableSchema.table_name");
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->table_name(), output);
+  }
+
+  // int64 dimension = 3;
+  if (this->dimension() != 0) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(3, this->dimension(), output);
+  }
+
+  // int64 index_file_size = 4;
+  if (this->index_file_size() != 0) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(4, this->index_file_size(), output);
+  }
+
+  // int32 metric_type = 5;
+  if (this->metric_type() != 0) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32(5, this->metric_type(), output);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
+        _internal_metadata_.unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:milvus.grpc.TableSchema)
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* TableSchema::InternalSerializeWithCachedSizesToArray(
+    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.TableSchema)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .milvus.grpc.Status status = 1;
+  if (this->has_status()) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessageToArray(
+        1, _Internal::status(this), target);
+  }
+
+  // string table_name = 2;
+  if (this->table_name().size() > 0) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->table_name().data(), static_cast<int>(this->table_name().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "milvus.grpc.TableSchema.table_name");
+    target =
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
+        2, this->table_name(), target);
+  }
+
+  // int64 dimension = 3;
+  if (this->dimension() != 0) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(3, this->dimension(), target);
+  }
+
+  // int64 index_file_size = 4;
+  if (this->index_file_size() != 0) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(4, this->index_file_size(), target);
+  }
+
+  // int32 metric_type = 5;
+  if (this->metric_type() != 0) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(5, this->metric_type(), target);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.TableSchema)
+  return target;
+}
+
+size_t TableSchema::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.TableSchema)
+  size_t total_size = 0;
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
+        _internal_metadata_.unknown_fields());
+  }
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // string table_name = 2;
+  if (this->table_name().size() > 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->table_name());
+  }
+
+  // .milvus.grpc.Status status = 1;
+  if (this->has_status()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *status_);
+  }
+
+  // int64 dimension = 3;
+  if (this->dimension() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
+        this->dimension());
+  }
+
+  // int64 index_file_size = 4;
+  if (this->index_file_size() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
+        this->index_file_size());
+  }
+
+  // int32 metric_type = 5;
+  if (this->metric_type() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+        this->metric_type());
+  }
+
+  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void TableSchema::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.TableSchema)
+  GOOGLE_DCHECK_NE(&from, this);
+  const TableSchema* source =
+      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<TableSchema>(
+          &from);
+  if (source == nullptr) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.TableSchema)
+    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.TableSchema)
+    MergeFrom(*source);
+  }
+}
+
+void TableSchema::MergeFrom(const TableSchema& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.TableSchema)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from.table_name().size() > 0) {
+
+    table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_);
+  }
+  if (from.has_status()) {
+    mutable_status()->::milvus::grpc::Status::MergeFrom(from.status());
+  }
+  if (from.dimension() != 0) {
+    set_dimension(from.dimension());
+  }
+  if (from.index_file_size() != 0) {
+    set_index_file_size(from.index_file_size());
+  }
+  if (from.metric_type() != 0) {
+    set_metric_type(from.metric_type());
+  }
+}
+
+void TableSchema::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.TableSchema)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void TableSchema::CopyFrom(const TableSchema& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.TableSchema)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool TableSchema::IsInitialized() const {
+  return true;
+}
+
+void TableSchema::InternalSwap(TableSchema* other) {
+  using std::swap;
+  _internal_metadata_.Swap(&other->_internal_metadata_);
+  table_name_.Swap(&other->table_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+    GetArenaNoVirtual());
+  swap(status_, other->status_);
+  swap(dimension_, other->dimension_);
+  swap(index_file_size_, other->index_file_size_);
+  swap(metric_type_, other->metric_type_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata TableSchema::GetMetadata() const {
+  return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+void Range::InitAsDefaultInstance() {
+}
+class Range::_Internal {
+ public:
+};
+
+Range::Range()
+  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:milvus.grpc.Range)
+}
+Range::Range(const Range& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      _internal_metadata_(nullptr) {
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  start_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  if (!from.start_value().empty()) {
+    start_value_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.start_value_);
+  }
+  end_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  if (!from.end_value().empty()) {
+    end_value_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.end_value_);
+  }
+  // @@protoc_insertion_point(copy_constructor:milvus.grpc.Range)
+}
+
+void Range::SharedCtor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Range_milvus_2eproto.base);
+  start_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  end_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+Range::~Range() {
+  // @@protoc_insertion_point(destructor:milvus.grpc.Range)
+  SharedDtor();
+}
+
+void Range::SharedDtor() {
+  start_value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  end_value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void Range::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+const Range& Range::default_instance() {
+  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Range_milvus_2eproto.base);
+  return *internal_default_instance();
+}
+
+
+void Range::Clear() {
+// @@protoc_insertion_point(message_clear_start:milvus.grpc.Range)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  start_value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  end_value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  _internal_metadata_.Clear();
+}
+
+#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+const char* Range::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    CHK_(ptr);
+    switch (tag >> 3) {
+      // string start_value = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_start_value(), ptr, ctx, "milvus.grpc.Range.start_value");
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // string end_value = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_end_value(), ptr, ctx, "milvus.grpc.Range.end_value");
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      default: {
+      handle_unusual:
+        if ((tag & 7) == 4 || tag == 0) {
+          ctx->SetLastTag(tag);
+          goto success;
+        }
+        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
+        CHK_(ptr != nullptr);
+        continue;
+      }
+    }  // switch
+  }  // while
+success:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto success;
+#undef CHK_
+}
+#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+bool Range::MergePartialFromCodedStream(
+    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
+  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+  // @@protoc_insertion_point(parse_start:milvus.grpc.Range)
+  for (;;) {
+    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // string start_value = 1;
+      case 1: {
+        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
+          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
+                input, this->mutable_start_value()));
+          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+            this->start_value().data(), static_cast<int>(this->start_value().length()),
+            ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
+            "milvus.grpc.Range.start_value"));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      // string end_value = 2;
+      case 2: {
+        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
+          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
+                input, this->mutable_end_value()));
+          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+            this->end_value().data(), static_cast<int>(this->end_value().length()),
+            ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
+            "milvus.grpc.Range.end_value"));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0) {
+          goto success;
+        }
+        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
+              input, tag, _internal_metadata_.mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:milvus.grpc.Range)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:milvus.grpc.Range)
+  return false;
+#undef DO_
+}
+#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+
+void Range::SerializeWithCachedSizes(
+    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:milvus.grpc.Range)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // string start_value = 1;
+  if (this->start_value().size() > 0) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->start_value().data(), static_cast<int>(this->start_value().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "milvus.grpc.Range.start_value");
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->start_value(), output);
+  }
+
+  // string end_value = 2;
+  if (this->end_value().size() > 0) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->end_value().data(), static_cast<int>(this->end_value().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "milvus.grpc.Range.end_value");
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->end_value(), output);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
+        _internal_metadata_.unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:milvus.grpc.Range)
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* Range::InternalSerializeWithCachedSizesToArray(
+    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.Range)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // string start_value = 1;
+  if (this->start_value().size() > 0) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->start_value().data(), static_cast<int>(this->start_value().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "milvus.grpc.Range.start_value");
+    target =
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
+        1, this->start_value(), target);
+  }
+
+  // string end_value = 2;
+  if (this->end_value().size() > 0) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->end_value().data(), static_cast<int>(this->end_value().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "milvus.grpc.Range.end_value");
+    target =
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
+        2, this->end_value(), target);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.Range)
+  return target;
+}
+
+size_t Range::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.Range)
+  size_t total_size = 0;
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
+        _internal_metadata_.unknown_fields());
+  }
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // string start_value = 1;
+  if (this->start_value().size() > 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->start_value());
+  }
+
+  // string end_value = 2;
+  if (this->end_value().size() > 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->end_value());
+  }
+
+  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void Range::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.Range)
+  GOOGLE_DCHECK_NE(&from, this);
+  const Range* source =
+      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<Range>(
+          &from);
+  if (source == nullptr) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.Range)
+    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.Range)
+    MergeFrom(*source);
+  }
+}
+
+void Range::MergeFrom(const Range& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.Range)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from.start_value().size() > 0) {
+
+    start_value_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.start_value_);
+  }
+  if (from.end_value().size() > 0) {
+
+    end_value_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.end_value_);
+  }
+}
+
+void Range::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.Range)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void Range::CopyFrom(const Range& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.Range)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Range::IsInitialized() const {
+  return true;
+}
+
+void Range::InternalSwap(Range* other) {
+  using std::swap;
+  _internal_metadata_.Swap(&other->_internal_metadata_);
+  start_value_.Swap(&other->start_value_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+    GetArenaNoVirtual());
+  end_value_.Swap(&other->end_value_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+    GetArenaNoVirtual());
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Range::GetMetadata() const {
+  return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+void RowRecord::InitAsDefaultInstance() {
+}
+class RowRecord::_Internal {
+ public:
+};
+
+RowRecord::RowRecord()
+  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:milvus.grpc.RowRecord)
+}
+RowRecord::RowRecord(const RowRecord& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      _internal_metadata_(nullptr),
+      vector_data_(from.vector_data_) {
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:milvus.grpc.RowRecord)
+}
+
+void RowRecord::SharedCtor() {
+}
+
+RowRecord::~RowRecord() {
+  // @@protoc_insertion_point(destructor:milvus.grpc.RowRecord)
+  SharedDtor();
+}
+
+void RowRecord::SharedDtor() {
+}
+
+void RowRecord::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+const RowRecord& RowRecord::default_instance() {
+  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_RowRecord_milvus_2eproto.base);
+  return *internal_default_instance();
+}
+
+
+void RowRecord::Clear() {
+// @@protoc_insertion_point(message_clear_start:milvus.grpc.RowRecord)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  vector_data_.Clear();
+  _internal_metadata_.Clear();
+}
+
+#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+const char* RowRecord::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    CHK_(ptr);
+    switch (tag >> 3) {
+      // repeated float vector_data = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedFloatParser(mutable_vector_data(), ptr, ctx);
+          CHK_(ptr);
+        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 13) {
+          add_vector_data(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr));
+          ptr += sizeof(float);
+        } else goto handle_unusual;
+        continue;
+      default: {
+      handle_unusual:
+        if ((tag & 7) == 4 || tag == 0) {
+          ctx->SetLastTag(tag);
+          goto success;
+        }
+        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
+        CHK_(ptr != nullptr);
+        continue;
+      }
+    }  // switch
+  }  // while
+success:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto success;
+#undef CHK_
+}
+#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+bool RowRecord::MergePartialFromCodedStream(
+    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
+  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+  // @@protoc_insertion_point(parse_start:milvus.grpc.RowRecord)
+  for (;;) {
+    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated float vector_data = 1;
+      case 1: {
+        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
+          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive<
+                   float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>(
+                 input, this->mutable_vector_data())));
+        } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (13 & 0xFF)) {
+          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   float, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_FLOAT>(
+                 1, 10u, input, this->mutable_vector_data())));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0) {
+          goto success;
+        }
+        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
+              input, tag, _internal_metadata_.mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:milvus.grpc.RowRecord)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:milvus.grpc.RowRecord)
+  return false;
+#undef DO_
+}
+#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+
+void RowRecord::SerializeWithCachedSizes(
+    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:milvus.grpc.RowRecord)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated float vector_data = 1;
+  if (this->vector_data_size() > 0) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(1, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_vector_data_cached_byte_size_.load(
+        std::memory_order_relaxed));
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatArray(
+      this->vector_data().data(), this->vector_data_size(), output);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
+        _internal_metadata_.unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:milvus.grpc.RowRecord)
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* RowRecord::InternalSerializeWithCachedSizesToArray(
+    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.RowRecord)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated float vector_data = 1;
+  if (this->vector_data_size() > 0) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray(
+      1,
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
+      target);
+    target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(
+        _vector_data_cached_byte_size_.load(std::memory_order_relaxed),
+         target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      WriteFloatNoTagToArray(this->vector_data_, target);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.RowRecord)
+  return target;
+}
+
+size_t RowRecord::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.RowRecord)
+  size_t total_size = 0;
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
+        _internal_metadata_.unknown_fields());
+  }
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated float vector_data = 1;
+  {
+    unsigned int count = static_cast<unsigned int>(this->vector_data_size());
+    size_t data_size = 4UL * count;
+    if (data_size > 0) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+            static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
+    }
+    int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
+    _vector_data_cached_byte_size_.store(cached_size,
+                                    std::memory_order_relaxed);
+    total_size += data_size;
+  }
+
+  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void RowRecord::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.RowRecord)
+  GOOGLE_DCHECK_NE(&from, this);
+  const RowRecord* source =
+      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<RowRecord>(
+          &from);
+  if (source == nullptr) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.RowRecord)
+    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.RowRecord)
+    MergeFrom(*source);
+  }
+}
+
+void RowRecord::MergeFrom(const RowRecord& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.RowRecord)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  vector_data_.MergeFrom(from.vector_data_);
+}
+
+void RowRecord::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.RowRecord)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void RowRecord::CopyFrom(const RowRecord& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.RowRecord)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool RowRecord::IsInitialized() const {
+  return true;
+}
+
+void RowRecord::InternalSwap(RowRecord* other) {
+  using std::swap;
+  _internal_metadata_.Swap(&other->_internal_metadata_);
+  vector_data_.InternalSwap(&other->vector_data_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata RowRecord::GetMetadata() const {
+  return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+void InsertParam::InitAsDefaultInstance() {
+}
+class InsertParam::_Internal {
+ public:
+};
+
+InsertParam::InsertParam()
+  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:milvus.grpc.InsertParam)
+}
+InsertParam::InsertParam(const InsertParam& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      _internal_metadata_(nullptr),
+      row_record_array_(from.row_record_array_),
+      row_id_array_(from.row_id_array_) {
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  if (!from.table_name().empty()) {
+    table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_);
+  }
+  // @@protoc_insertion_point(copy_constructor:milvus.grpc.InsertParam)
+}
+
+void InsertParam::SharedCtor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_InsertParam_milvus_2eproto.base);
+  table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+InsertParam::~InsertParam() {
+  // @@protoc_insertion_point(destructor:milvus.grpc.InsertParam)
+  SharedDtor();
+}
+
+void InsertParam::SharedDtor() {
+  table_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void InsertParam::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+const InsertParam& InsertParam::default_instance() {
+  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_InsertParam_milvus_2eproto.base);
+  return *internal_default_instance();
+}
+
+
+void InsertParam::Clear() {
+// @@protoc_insertion_point(message_clear_start:milvus.grpc.InsertParam)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  row_record_array_.Clear();
+  row_id_array_.Clear();
+  table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  _internal_metadata_.Clear();
+}
+
+#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+const char* InsertParam::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    CHK_(ptr);
+    switch (tag >> 3) {
+      // string table_name = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_table_name(), ptr, ctx, "milvus.grpc.InsertParam.table_name");
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // repeated .milvus.grpc.RowRecord row_record_array = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(add_row_record_array(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 18);
+        } else goto handle_unusual;
+        continue;
+      // repeated int64 row_id_array = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(mutable_row_id_array(), ptr, ctx);
+          CHK_(ptr);
+        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24) {
+          add_row_id_array(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      default: {
+      handle_unusual:
+        if ((tag & 7) == 4 || tag == 0) {
+          ctx->SetLastTag(tag);
+          goto success;
+        }
+        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
+        CHK_(ptr != nullptr);
+        continue;
+      }
+    }  // switch
+  }  // while
+success:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto success;
+#undef CHK_
+}
+#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+bool InsertParam::MergePartialFromCodedStream(
+    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
+  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+  // @@protoc_insertion_point(parse_start:milvus.grpc.InsertParam)
+  for (;;) {
+    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // string table_name = 1;
+      case 1: {
+        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
+          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
+                input, this->mutable_table_name()));
+          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+            this->table_name().data(), static_cast<int>(this->table_name().length()),
+            ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
+            "milvus.grpc.InsertParam.table_name"));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      // repeated .milvus.grpc.RowRecord row_record_array = 2;
+      case 2: {
+        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
+          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
+                input, add_row_record_array()));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      // repeated int64 row_id_array = 3;
+      case 3: {
+        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) {
+          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>(
+                 input, this->mutable_row_id_array())));
+        } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (24 & 0xFF)) {
+          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>(
+                 1, 26u, input, this->mutable_row_id_array())));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0) {
+          goto success;
+        }
+        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
+              input, tag, _internal_metadata_.mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:milvus.grpc.InsertParam)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:milvus.grpc.InsertParam)
+  return false;
+#undef DO_
+}
+#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+
+void InsertParam::SerializeWithCachedSizes(
+    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:milvus.grpc.InsertParam)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // string table_name = 1;
+  if (this->table_name().size() > 0) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->table_name().data(), static_cast<int>(this->table_name().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "milvus.grpc.InsertParam.table_name");
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->table_name(), output);
+  }
+
+  // repeated .milvus.grpc.RowRecord row_record_array = 2;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->row_record_array_size()); i < n; i++) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2,
+      this->row_record_array(static_cast<int>(i)),
+      output);
+  }
+
+  // repeated int64 row_id_array = 3;
+  if (this->row_id_array_size() > 0) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(3, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_row_id_array_cached_byte_size_.load(
+        std::memory_order_relaxed));
+  }
+  for (int i = 0, n = this->row_id_array_size(); i < n; i++) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64NoTag(
+      this->row_id_array(i), output);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
+        _internal_metadata_.unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:milvus.grpc.InsertParam)
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* InsertParam::InternalSerializeWithCachedSizesToArray(
+    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.InsertParam)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // string table_name = 1;
+  if (this->table_name().size() > 0) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->table_name().data(), static_cast<int>(this->table_name().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "milvus.grpc.InsertParam.table_name");
+    target =
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
+        1, this->table_name(), target);
+  }
+
+  // repeated .milvus.grpc.RowRecord row_record_array = 2;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->row_record_array_size()); i < n; i++) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessageToArray(
+        2, this->row_record_array(static_cast<int>(i)), target);
+  }
+
+  // repeated int64 row_id_array = 3;
+  if (this->row_id_array_size() > 0) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray(
+      3,
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
+      target);
+    target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(
+        _row_id_array_cached_byte_size_.load(std::memory_order_relaxed),
+         target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      WriteInt64NoTagToArray(this->row_id_array_, target);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.InsertParam)
+  return target;
+}
+
+size_t InsertParam::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.InsertParam)
+  size_t total_size = 0;
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
+        _internal_metadata_.unknown_fields());
+  }
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .milvus.grpc.RowRecord row_record_array = 2;
+  {
+    unsigned int count = static_cast<unsigned int>(this->row_record_array_size());
+    total_size += 1UL * count;
+    for (unsigned int i = 0; i < count; i++) {
+      total_size +=
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          this->row_record_array(static_cast<int>(i)));
+    }
+  }
+
+  // repeated int64 row_id_array = 3;
+  {
+    size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      Int64Size(this->row_id_array_);
+    if (data_size > 0) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+            static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
+    }
+    int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
+    _row_id_array_cached_byte_size_.store(cached_size,
+                                    std::memory_order_relaxed);
+    total_size += data_size;
+  }
+
+  // string table_name = 1;
+  if (this->table_name().size() > 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->table_name());
+  }
+
+  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void InsertParam::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.InsertParam)
+  GOOGLE_DCHECK_NE(&from, this);
+  const InsertParam* source =
+      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<InsertParam>(
+          &from);
+  if (source == nullptr) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.InsertParam)
+    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.InsertParam)
+    MergeFrom(*source);
+  }
+}
+
+void InsertParam::MergeFrom(const InsertParam& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.InsertParam)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  row_record_array_.MergeFrom(from.row_record_array_);
+  row_id_array_.MergeFrom(from.row_id_array_);
+  if (from.table_name().size() > 0) {
+
+    table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_);
+  }
+}
+
+void InsertParam::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.InsertParam)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void InsertParam::CopyFrom(const InsertParam& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.InsertParam)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool InsertParam::IsInitialized() const {
+  return true;
+}
+
+void InsertParam::InternalSwap(InsertParam* other) {
+  using std::swap;
+  _internal_metadata_.Swap(&other->_internal_metadata_);
+  CastToBase(&row_record_array_)->InternalSwap(CastToBase(&other->row_record_array_));
+  row_id_array_.InternalSwap(&other->row_id_array_);
+  table_name_.Swap(&other->table_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+    GetArenaNoVirtual());
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata InsertParam::GetMetadata() const {
+  return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+void VectorIds::InitAsDefaultInstance() {
+  ::milvus::grpc::_VectorIds_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>(
+      ::milvus::grpc::Status::internal_default_instance());
+}
+class VectorIds::_Internal {
+ public:
+  static const ::milvus::grpc::Status& status(const VectorIds* msg);
+};
+
+const ::milvus::grpc::Status&
+VectorIds::_Internal::status(const VectorIds* msg) {
+  return *msg->status_;
+}
+void VectorIds::clear_status() {
+  if (GetArenaNoVirtual() == nullptr && status_ != nullptr) {
+    delete status_;
+  }
+  status_ = nullptr;
+}
+VectorIds::VectorIds()
+  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:milvus.grpc.VectorIds)
+}
+VectorIds::VectorIds(const VectorIds& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      _internal_metadata_(nullptr),
+      vector_id_array_(from.vector_id_array_) {
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  if (from.has_status()) {
+    status_ = new ::milvus::grpc::Status(*from.status_);
+  } else {
+    status_ = nullptr;
+  }
+  // @@protoc_insertion_point(copy_constructor:milvus.grpc.VectorIds)
+}
+
+void VectorIds::SharedCtor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_VectorIds_milvus_2eproto.base);
+  status_ = nullptr;
+}
+
+VectorIds::~VectorIds() {
+  // @@protoc_insertion_point(destructor:milvus.grpc.VectorIds)
+  SharedDtor();
+}
+
+void VectorIds::SharedDtor() {
+  if (this != internal_default_instance()) delete status_;
+}
+
+void VectorIds::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+const VectorIds& VectorIds::default_instance() {
+  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_VectorIds_milvus_2eproto.base);
+  return *internal_default_instance();
+}
+
+
+void VectorIds::Clear() {
+// @@protoc_insertion_point(message_clear_start:milvus.grpc.VectorIds)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  vector_id_array_.Clear();
+  if (GetArenaNoVirtual() == nullptr && status_ != nullptr) {
+    delete status_;
+  }
+  status_ = nullptr;
+  _internal_metadata_.Clear();
+}
+
+#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+const char* VectorIds::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    CHK_(ptr);
+    switch (tag >> 3) {
+      // .milvus.grpc.Status status = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+          ptr = ctx->ParseMessage(mutable_status(), ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // repeated int64 vector_id_array = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(mutable_vector_id_array(), ptr, ctx);
+          CHK_(ptr);
+        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16) {
+          add_vector_id_array(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr));
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      default: {
+      handle_unusual:
+        if ((tag & 7) == 4 || tag == 0) {
+          ctx->SetLastTag(tag);
+          goto success;
+        }
+        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
+        CHK_(ptr != nullptr);
+        continue;
+      }
+    }  // switch
+  }  // while
+success:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto success;
+#undef CHK_
+}
+#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+bool VectorIds::MergePartialFromCodedStream(
+    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
+  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+  // @@protoc_insertion_point(parse_start:milvus.grpc.VectorIds)
+  for (;;) {
+    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // .milvus.grpc.Status status = 1;
+      case 1: {
+        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
+          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
+               input, mutable_status()));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      // repeated int64 vector_id_array = 2;
+      case 2: {
+        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
+          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>(
+                 input, this->mutable_vector_id_array())));
+        } else if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
+          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>(
+                 1, 18u, input, this->mutable_vector_id_array())));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0) {
+          goto success;
+        }
+        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
+              input, tag, _internal_metadata_.mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:milvus.grpc.VectorIds)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:milvus.grpc.VectorIds)
+  return false;
+#undef DO_
+}
+#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+
+void VectorIds::SerializeWithCachedSizes(
+    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:milvus.grpc.VectorIds)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .milvus.grpc.Status status = 1;
+  if (this->has_status()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, _Internal::status(this), output);
+  }
+
+  // repeated int64 vector_id_array = 2;
+  if (this->vector_id_array_size() > 0) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTag(2, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_vector_id_array_cached_byte_size_.load(
+        std::memory_order_relaxed));
+  }
+  for (int i = 0, n = this->vector_id_array_size(); i < n; i++) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64NoTag(
+      this->vector_id_array(i), output);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
+        _internal_metadata_.unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:milvus.grpc.VectorIds)
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* VectorIds::InternalSerializeWithCachedSizesToArray(
+    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.VectorIds)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .milvus.grpc.Status status = 1;
+  if (this->has_status()) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessageToArray(
+        1, _Internal::status(this), target);
+  }
+
+  // repeated int64 vector_id_array = 2;
+  if (this->vector_id_array_size() > 0) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteTagToArray(
+      2,
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
+      target);
+    target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(
+        _vector_id_array_cached_byte_size_.load(std::memory_order_relaxed),
+         target);
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      WriteInt64NoTagToArray(this->vector_id_array_, target);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.VectorIds)
+  return target;
+}
+
+size_t VectorIds::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.VectorIds)
+  size_t total_size = 0;
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
+        _internal_metadata_.unknown_fields());
+  }
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated int64 vector_id_array = 2;
+  {
+    size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      Int64Size(this->vector_id_array_);
+    if (data_size > 0) {
+      total_size += 1 +
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+            static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
+    }
+    int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
+    _vector_id_array_cached_byte_size_.store(cached_size,
+                                    std::memory_order_relaxed);
+    total_size += data_size;
+  }
+
+  // .milvus.grpc.Status status = 1;
+  if (this->has_status()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *status_);
+  }
+
+  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void VectorIds::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.VectorIds)
+  GOOGLE_DCHECK_NE(&from, this);
+  const VectorIds* source =
+      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<VectorIds>(
+          &from);
+  if (source == nullptr) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.VectorIds)
+    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.VectorIds)
+    MergeFrom(*source);
+  }
+}
+
+void VectorIds::MergeFrom(const VectorIds& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.VectorIds)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  vector_id_array_.MergeFrom(from.vector_id_array_);
+  if (from.has_status()) {
+    mutable_status()->::milvus::grpc::Status::MergeFrom(from.status());
+  }
+}
+
+void VectorIds::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.VectorIds)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void VectorIds::CopyFrom(const VectorIds& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.VectorIds)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool VectorIds::IsInitialized() const {
+  return true;
+}
+
+void VectorIds::InternalSwap(VectorIds* other) {
+  using std::swap;
+  _internal_metadata_.Swap(&other->_internal_metadata_);
+  vector_id_array_.InternalSwap(&other->vector_id_array_);
+  swap(status_, other->status_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata VectorIds::GetMetadata() const {
+  return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+void SearchParam::InitAsDefaultInstance() {
+}
+class SearchParam::_Internal {
+ public:
+};
+
+SearchParam::SearchParam()
+  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:milvus.grpc.SearchParam)
+}
+SearchParam::SearchParam(const SearchParam& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      _internal_metadata_(nullptr),
+      query_record_array_(from.query_record_array_),
+      query_range_array_(from.query_range_array_) {
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  if (!from.table_name().empty()) {
+    table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_);
+  }
+  ::memcpy(&topk_, &from.topk_,
+    static_cast<size_t>(reinterpret_cast<char*>(&nprobe_) -
+    reinterpret_cast<char*>(&topk_)) + sizeof(nprobe_));
+  // @@protoc_insertion_point(copy_constructor:milvus.grpc.SearchParam)
+}
+
+void SearchParam::SharedCtor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_SearchParam_milvus_2eproto.base);
+  table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  ::memset(&topk_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&nprobe_) -
+      reinterpret_cast<char*>(&topk_)) + sizeof(nprobe_));
+}
+
+SearchParam::~SearchParam() {
+  // @@protoc_insertion_point(destructor:milvus.grpc.SearchParam)
+  SharedDtor();
+}
+
+void SearchParam::SharedDtor() {
+  table_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void SearchParam::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+const SearchParam& SearchParam::default_instance() {
+  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_SearchParam_milvus_2eproto.base);
+  return *internal_default_instance();
+}
+
+
+void SearchParam::Clear() {
+// @@protoc_insertion_point(message_clear_start:milvus.grpc.SearchParam)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  query_record_array_.Clear();
+  query_range_array_.Clear();
+  table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  ::memset(&topk_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&nprobe_) -
+      reinterpret_cast<char*>(&topk_)) + sizeof(nprobe_));
+  _internal_metadata_.Clear();
+}
+
+#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+const char* SearchParam::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    CHK_(ptr);
+    switch (tag >> 3) {
+      // string table_name = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_table_name(), ptr, ctx, "milvus.grpc.SearchParam.table_name");
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // repeated .milvus.grpc.RowRecord query_record_array = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(add_query_record_array(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 18);
+        } else goto handle_unusual;
+        continue;
+      // repeated .milvus.grpc.Range query_range_array = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(add_query_range_array(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 26);
+        } else goto handle_unusual;
+        continue;
+      // int64 topk = 4;
+      case 4:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
+          topk_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // int64 nprobe = 5;
+      case 5:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
+          nprobe_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      default: {
+      handle_unusual:
+        if ((tag & 7) == 4 || tag == 0) {
+          ctx->SetLastTag(tag);
+          goto success;
+        }
+        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
+        CHK_(ptr != nullptr);
+        continue;
+      }
+    }  // switch
+  }  // while
+success:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto success;
+#undef CHK_
+}
+#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+bool SearchParam::MergePartialFromCodedStream(
+    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
+  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+  // @@protoc_insertion_point(parse_start:milvus.grpc.SearchParam)
+  for (;;) {
+    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // string table_name = 1;
+      case 1: {
+        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
+          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
+                input, this->mutable_table_name()));
+          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+            this->table_name().data(), static_cast<int>(this->table_name().length()),
+            ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
+            "milvus.grpc.SearchParam.table_name"));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      // repeated .milvus.grpc.RowRecord query_record_array = 2;
+      case 2: {
+        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
+          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
+                input, add_query_record_array()));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      // repeated .milvus.grpc.Range query_range_array = 3;
+      case 3: {
+        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) {
+          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
+                input, add_query_range_array()));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      // int64 topk = 4;
+      case 4: {
+        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (32 & 0xFF)) {
+
+          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
+                   ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>(
+                 input, &topk_)));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      // int64 nprobe = 5;
+      case 5: {
+        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (40 & 0xFF)) {
+
+          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
+                   ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>(
+                 input, &nprobe_)));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0) {
+          goto success;
+        }
+        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
+              input, tag, _internal_metadata_.mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:milvus.grpc.SearchParam)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:milvus.grpc.SearchParam)
+  return false;
+#undef DO_
+}
+#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+
+void SearchParam::SerializeWithCachedSizes(
+    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:milvus.grpc.SearchParam)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // string table_name = 1;
+  if (this->table_name().size() > 0) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->table_name().data(), static_cast<int>(this->table_name().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "milvus.grpc.SearchParam.table_name");
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->table_name(), output);
+  }
+
+  // repeated .milvus.grpc.RowRecord query_record_array = 2;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->query_record_array_size()); i < n; i++) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2,
+      this->query_record_array(static_cast<int>(i)),
+      output);
+  }
+
+  // repeated .milvus.grpc.Range query_range_array = 3;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->query_range_array_size()); i < n; i++) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3,
+      this->query_range_array(static_cast<int>(i)),
+      output);
+  }
+
+  // int64 topk = 4;
+  if (this->topk() != 0) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(4, this->topk(), output);
+  }
+
+  // int64 nprobe = 5;
+  if (this->nprobe() != 0) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(5, this->nprobe(), output);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
+        _internal_metadata_.unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:milvus.grpc.SearchParam)
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* SearchParam::InternalSerializeWithCachedSizesToArray(
+    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.SearchParam)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // string table_name = 1;
+  if (this->table_name().size() > 0) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->table_name().data(), static_cast<int>(this->table_name().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "milvus.grpc.SearchParam.table_name");
+    target =
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
+        1, this->table_name(), target);
+  }
+
+  // repeated .milvus.grpc.RowRecord query_record_array = 2;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->query_record_array_size()); i < n; i++) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessageToArray(
+        2, this->query_record_array(static_cast<int>(i)), target);
+  }
+
+  // repeated .milvus.grpc.Range query_range_array = 3;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->query_range_array_size()); i < n; i++) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessageToArray(
+        3, this->query_range_array(static_cast<int>(i)), target);
+  }
+
+  // int64 topk = 4;
+  if (this->topk() != 0) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(4, this->topk(), target);
+  }
+
+  // int64 nprobe = 5;
+  if (this->nprobe() != 0) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(5, this->nprobe(), target);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.SearchParam)
+  return target;
+}
+
+size_t SearchParam::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.SearchParam)
+  size_t total_size = 0;
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
+        _internal_metadata_.unknown_fields());
+  }
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .milvus.grpc.RowRecord query_record_array = 2;
+  {
+    unsigned int count = static_cast<unsigned int>(this->query_record_array_size());
+    total_size += 1UL * count;
+    for (unsigned int i = 0; i < count; i++) {
+      total_size +=
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          this->query_record_array(static_cast<int>(i)));
+    }
+  }
+
+  // repeated .milvus.grpc.Range query_range_array = 3;
+  {
+    unsigned int count = static_cast<unsigned int>(this->query_range_array_size());
+    total_size += 1UL * count;
+    for (unsigned int i = 0; i < count; i++) {
+      total_size +=
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          this->query_range_array(static_cast<int>(i)));
+    }
+  }
+
+  // string table_name = 1;
+  if (this->table_name().size() > 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->table_name());
+  }
+
+  // int64 topk = 4;
+  if (this->topk() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
+        this->topk());
+  }
+
+  // int64 nprobe = 5;
+  if (this->nprobe() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
+        this->nprobe());
+  }
+
+  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void SearchParam::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.SearchParam)
+  GOOGLE_DCHECK_NE(&from, this);
+  const SearchParam* source =
+      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<SearchParam>(
+          &from);
+  if (source == nullptr) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.SearchParam)
+    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.SearchParam)
+    MergeFrom(*source);
+  }
+}
+
+void SearchParam::MergeFrom(const SearchParam& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.SearchParam)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  query_record_array_.MergeFrom(from.query_record_array_);
+  query_range_array_.MergeFrom(from.query_range_array_);
+  if (from.table_name().size() > 0) {
+
+    table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_);
+  }
+  if (from.topk() != 0) {
+    set_topk(from.topk());
+  }
+  if (from.nprobe() != 0) {
+    set_nprobe(from.nprobe());
+  }
+}
+
+void SearchParam::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.SearchParam)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SearchParam::CopyFrom(const SearchParam& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.SearchParam)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SearchParam::IsInitialized() const {
+  return true;
+}
+
+void SearchParam::InternalSwap(SearchParam* other) {
+  using std::swap;
+  _internal_metadata_.Swap(&other->_internal_metadata_);
+  CastToBase(&query_record_array_)->InternalSwap(CastToBase(&other->query_record_array_));
+  CastToBase(&query_range_array_)->InternalSwap(CastToBase(&other->query_range_array_));
+  table_name_.Swap(&other->table_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+    GetArenaNoVirtual());
+  swap(topk_, other->topk_);
+  swap(nprobe_, other->nprobe_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SearchParam::GetMetadata() const {
+  return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+void SearchInFilesParam::InitAsDefaultInstance() {
+  ::milvus::grpc::_SearchInFilesParam_default_instance_._instance.get_mutable()->search_param_ = const_cast< ::milvus::grpc::SearchParam*>(
+      ::milvus::grpc::SearchParam::internal_default_instance());
+}
+class SearchInFilesParam::_Internal {
+ public:
+  static const ::milvus::grpc::SearchParam& search_param(const SearchInFilesParam* msg);
+};
+
+const ::milvus::grpc::SearchParam&
+SearchInFilesParam::_Internal::search_param(const SearchInFilesParam* msg) {
+  return *msg->search_param_;
+}
+SearchInFilesParam::SearchInFilesParam()
+  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:milvus.grpc.SearchInFilesParam)
+}
+SearchInFilesParam::SearchInFilesParam(const SearchInFilesParam& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      _internal_metadata_(nullptr),
+      file_id_array_(from.file_id_array_) {
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  if (from.has_search_param()) {
+    search_param_ = new ::milvus::grpc::SearchParam(*from.search_param_);
+  } else {
+    search_param_ = nullptr;
+  }
+  // @@protoc_insertion_point(copy_constructor:milvus.grpc.SearchInFilesParam)
+}
+
+void SearchInFilesParam::SharedCtor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_SearchInFilesParam_milvus_2eproto.base);
+  search_param_ = nullptr;
+}
+
+SearchInFilesParam::~SearchInFilesParam() {
+  // @@protoc_insertion_point(destructor:milvus.grpc.SearchInFilesParam)
+  SharedDtor();
+}
+
+void SearchInFilesParam::SharedDtor() {
+  if (this != internal_default_instance()) delete search_param_;
+}
+
+void SearchInFilesParam::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+const SearchInFilesParam& SearchInFilesParam::default_instance() {
+  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_SearchInFilesParam_milvus_2eproto.base);
+  return *internal_default_instance();
+}
+
+
+void SearchInFilesParam::Clear() {
+// @@protoc_insertion_point(message_clear_start:milvus.grpc.SearchInFilesParam)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  file_id_array_.Clear();
+  if (GetArenaNoVirtual() == nullptr && search_param_ != nullptr) {
+    delete search_param_;
+  }
+  search_param_ = nullptr;
+  _internal_metadata_.Clear();
+}
+
+#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+const char* SearchInFilesParam::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    CHK_(ptr);
+    switch (tag >> 3) {
+      // repeated string file_id_array = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(add_file_id_array(), ptr, ctx, "milvus.grpc.SearchInFilesParam.file_id_array");
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 10);
+        } else goto handle_unusual;
+        continue;
+      // .milvus.grpc.SearchParam search_param = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+          ptr = ctx->ParseMessage(mutable_search_param(), ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      default: {
+      handle_unusual:
+        if ((tag & 7) == 4 || tag == 0) {
+          ctx->SetLastTag(tag);
+          goto success;
+        }
+        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
+        CHK_(ptr != nullptr);
+        continue;
+      }
+    }  // switch
+  }  // while
+success:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto success;
+#undef CHK_
+}
+#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+bool SearchInFilesParam::MergePartialFromCodedStream(
+    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
+  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+  // @@protoc_insertion_point(parse_start:milvus.grpc.SearchInFilesParam)
+  for (;;) {
+    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated string file_id_array = 1;
+      case 1: {
+        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
+          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
+                input, this->add_file_id_array()));
+          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+            this->file_id_array(this->file_id_array_size() - 1).data(),
+            static_cast<int>(this->file_id_array(this->file_id_array_size() - 1).length()),
+            ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
+            "milvus.grpc.SearchInFilesParam.file_id_array"));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      // .milvus.grpc.SearchParam search_param = 2;
+      case 2: {
+        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
+          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
+               input, mutable_search_param()));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0) {
+          goto success;
+        }
+        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
+              input, tag, _internal_metadata_.mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:milvus.grpc.SearchInFilesParam)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:milvus.grpc.SearchInFilesParam)
+  return false;
+#undef DO_
+}
+#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+
+void SearchInFilesParam::SerializeWithCachedSizes(
+    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:milvus.grpc.SearchInFilesParam)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated string file_id_array = 1;
+  for (int i = 0, n = this->file_id_array_size(); i < n; i++) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->file_id_array(i).data(), static_cast<int>(this->file_id_array(i).length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "milvus.grpc.SearchInFilesParam.file_id_array");
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteString(
+      1, this->file_id_array(i), output);
+  }
+
+  // .milvus.grpc.SearchParam search_param = 2;
+  if (this->has_search_param()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, _Internal::search_param(this), output);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
+        _internal_metadata_.unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:milvus.grpc.SearchInFilesParam)
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* SearchInFilesParam::InternalSerializeWithCachedSizesToArray(
+    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.SearchInFilesParam)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated string file_id_array = 1;
+  for (int i = 0, n = this->file_id_array_size(); i < n; i++) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->file_id_array(i).data(), static_cast<int>(this->file_id_array(i).length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "milvus.grpc.SearchInFilesParam.file_id_array");
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      WriteStringToArray(1, this->file_id_array(i), target);
+  }
+
+  // .milvus.grpc.SearchParam search_param = 2;
+  if (this->has_search_param()) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessageToArray(
+        2, _Internal::search_param(this), target);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.SearchInFilesParam)
+  return target;
+}
+
+size_t SearchInFilesParam::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.SearchInFilesParam)
+  size_t total_size = 0;
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
+        _internal_metadata_.unknown_fields());
+  }
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated string file_id_array = 1;
+  total_size += 1 *
+      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->file_id_array_size());
+  for (int i = 0, n = this->file_id_array_size(); i < n; i++) {
+    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+      this->file_id_array(i));
+  }
+
+  // .milvus.grpc.SearchParam search_param = 2;
+  if (this->has_search_param()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *search_param_);
+  }
+
+  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void SearchInFilesParam::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.SearchInFilesParam)
+  GOOGLE_DCHECK_NE(&from, this);
+  const SearchInFilesParam* source =
+      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<SearchInFilesParam>(
+          &from);
+  if (source == nullptr) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.SearchInFilesParam)
+    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.SearchInFilesParam)
+    MergeFrom(*source);
+  }
+}
+
+void SearchInFilesParam::MergeFrom(const SearchInFilesParam& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.SearchInFilesParam)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  file_id_array_.MergeFrom(from.file_id_array_);
+  if (from.has_search_param()) {
+    mutable_search_param()->::milvus::grpc::SearchParam::MergeFrom(from.search_param());
+  }
+}
+
+void SearchInFilesParam::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.SearchInFilesParam)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SearchInFilesParam::CopyFrom(const SearchInFilesParam& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.SearchInFilesParam)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SearchInFilesParam::IsInitialized() const {
+  return true;
+}
+
+void SearchInFilesParam::InternalSwap(SearchInFilesParam* other) {
+  using std::swap;
+  _internal_metadata_.Swap(&other->_internal_metadata_);
+  file_id_array_.InternalSwap(CastToBase(&other->file_id_array_));
+  swap(search_param_, other->search_param_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata SearchInFilesParam::GetMetadata() const {
+  return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+void QueryResult::InitAsDefaultInstance() {
+}
+class QueryResult::_Internal {
+ public:
+};
+
+QueryResult::QueryResult()
+  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:milvus.grpc.QueryResult)
+}
+QueryResult::QueryResult(const QueryResult& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      _internal_metadata_(nullptr) {
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::memcpy(&id_, &from.id_,
+    static_cast<size_t>(reinterpret_cast<char*>(&distance_) -
+    reinterpret_cast<char*>(&id_)) + sizeof(distance_));
+  // @@protoc_insertion_point(copy_constructor:milvus.grpc.QueryResult)
+}
+
+void QueryResult::SharedCtor() {
+  ::memset(&id_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&distance_) -
+      reinterpret_cast<char*>(&id_)) + sizeof(distance_));
+}
+
+QueryResult::~QueryResult() {
+  // @@protoc_insertion_point(destructor:milvus.grpc.QueryResult)
+  SharedDtor();
+}
+
+void QueryResult::SharedDtor() {
+}
+
+void QueryResult::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+const QueryResult& QueryResult::default_instance() {
+  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_QueryResult_milvus_2eproto.base);
+  return *internal_default_instance();
+}
+
+
+void QueryResult::Clear() {
+// @@protoc_insertion_point(message_clear_start:milvus.grpc.QueryResult)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  ::memset(&id_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&distance_) -
+      reinterpret_cast<char*>(&id_)) + sizeof(distance_));
+  _internal_metadata_.Clear();
+}
+
+#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+const char* QueryResult::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    CHK_(ptr);
+    switch (tag >> 3) {
+      // int64 id = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
+          id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // double distance = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 17)) {
+          distance_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
+          ptr += sizeof(double);
+        } else goto handle_unusual;
+        continue;
+      default: {
+      handle_unusual:
+        if ((tag & 7) == 4 || tag == 0) {
+          ctx->SetLastTag(tag);
+          goto success;
+        }
+        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
+        CHK_(ptr != nullptr);
+        continue;
+      }
+    }  // switch
+  }  // while
+success:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto success;
+#undef CHK_
+}
+#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+bool QueryResult::MergePartialFromCodedStream(
+    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
+  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+  // @@protoc_insertion_point(parse_start:milvus.grpc.QueryResult)
+  for (;;) {
+    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // int64 id = 1;
+      case 1: {
+        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
+
+          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
+                   ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>(
+                 input, &id_)));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      // double distance = 2;
+      case 2: {
+        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (17 & 0xFF)) {
+
+          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
+                   double, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_DOUBLE>(
+                 input, &distance_)));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0) {
+          goto success;
+        }
+        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
+              input, tag, _internal_metadata_.mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:milvus.grpc.QueryResult)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:milvus.grpc.QueryResult)
+  return false;
+#undef DO_
+}
+#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+
+void QueryResult::SerializeWithCachedSizes(
+    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:milvus.grpc.QueryResult)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // int64 id = 1;
+  if (this->id() != 0) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(1, this->id(), output);
+  }
+
+  // double distance = 2;
+  if (!(this->distance() <= 0 && this->distance() >= 0)) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDouble(2, this->distance(), output);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
+        _internal_metadata_.unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:milvus.grpc.QueryResult)
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* QueryResult::InternalSerializeWithCachedSizesToArray(
+    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.QueryResult)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // int64 id = 1;
+  if (this->id() != 0) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->id(), target);
+  }
+
+  // double distance = 2;
+  if (!(this->distance() <= 0 && this->distance() >= 0)) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(2, this->distance(), target);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.QueryResult)
+  return target;
+}
+
+size_t QueryResult::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.QueryResult)
+  size_t total_size = 0;
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
+        _internal_metadata_.unknown_fields());
+  }
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // int64 id = 1;
+  if (this->id() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
+        this->id());
+  }
+
+  // double distance = 2;
+  if (!(this->distance() <= 0 && this->distance() >= 0)) {
+    total_size += 1 + 8;
+  }
+
+  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void QueryResult::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.QueryResult)
+  GOOGLE_DCHECK_NE(&from, this);
+  const QueryResult* source =
+      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<QueryResult>(
+          &from);
+  if (source == nullptr) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.QueryResult)
+    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.QueryResult)
+    MergeFrom(*source);
+  }
+}
+
+void QueryResult::MergeFrom(const QueryResult& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.QueryResult)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from.id() != 0) {
+    set_id(from.id());
+  }
+  if (!(from.distance() <= 0 && from.distance() >= 0)) {
+    set_distance(from.distance());
+  }
+}
+
+void QueryResult::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.QueryResult)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void QueryResult::CopyFrom(const QueryResult& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.QueryResult)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool QueryResult::IsInitialized() const {
+  return true;
+}
+
+void QueryResult::InternalSwap(QueryResult* other) {
+  using std::swap;
+  _internal_metadata_.Swap(&other->_internal_metadata_);
+  swap(id_, other->id_);
+  swap(distance_, other->distance_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata QueryResult::GetMetadata() const {
+  return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+void TopKQueryResult::InitAsDefaultInstance() {
+}
+class TopKQueryResult::_Internal {
+ public:
+};
+
+TopKQueryResult::TopKQueryResult()
+  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:milvus.grpc.TopKQueryResult)
+}
+TopKQueryResult::TopKQueryResult(const TopKQueryResult& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      _internal_metadata_(nullptr),
+      query_result_arrays_(from.query_result_arrays_) {
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  // @@protoc_insertion_point(copy_constructor:milvus.grpc.TopKQueryResult)
+}
+
+void TopKQueryResult::SharedCtor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TopKQueryResult_milvus_2eproto.base);
+}
+
+TopKQueryResult::~TopKQueryResult() {
+  // @@protoc_insertion_point(destructor:milvus.grpc.TopKQueryResult)
+  SharedDtor();
+}
+
+void TopKQueryResult::SharedDtor() {
+}
+
+void TopKQueryResult::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+const TopKQueryResult& TopKQueryResult::default_instance() {
+  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TopKQueryResult_milvus_2eproto.base);
+  return *internal_default_instance();
+}
+
+
+void TopKQueryResult::Clear() {
+// @@protoc_insertion_point(message_clear_start:milvus.grpc.TopKQueryResult)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  query_result_arrays_.Clear();
+  _internal_metadata_.Clear();
+}
+
+#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+const char* TopKQueryResult::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    CHK_(ptr);
+    switch (tag >> 3) {
+      // repeated .milvus.grpc.QueryResult query_result_arrays = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(add_query_result_arrays(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 10);
+        } else goto handle_unusual;
+        continue;
+      default: {
+      handle_unusual:
+        if ((tag & 7) == 4 || tag == 0) {
+          ctx->SetLastTag(tag);
+          goto success;
+        }
+        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
+        CHK_(ptr != nullptr);
+        continue;
+      }
+    }  // switch
+  }  // while
+success:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto success;
+#undef CHK_
+}
+#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+bool TopKQueryResult::MergePartialFromCodedStream(
+    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
+  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+  // @@protoc_insertion_point(parse_start:milvus.grpc.TopKQueryResult)
+  for (;;) {
+    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .milvus.grpc.QueryResult query_result_arrays = 1;
+      case 1: {
+        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
+          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
+                input, add_query_result_arrays()));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0) {
+          goto success;
+        }
+        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
+              input, tag, _internal_metadata_.mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:milvus.grpc.TopKQueryResult)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:milvus.grpc.TopKQueryResult)
+  return false;
+#undef DO_
+}
+#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+
+void TopKQueryResult::SerializeWithCachedSizes(
+    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:milvus.grpc.TopKQueryResult)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated .milvus.grpc.QueryResult query_result_arrays = 1;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->query_result_arrays_size()); i < n; i++) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1,
+      this->query_result_arrays(static_cast<int>(i)),
+      output);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
+        _internal_metadata_.unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:milvus.grpc.TopKQueryResult)
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* TopKQueryResult::InternalSerializeWithCachedSizesToArray(
+    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.TopKQueryResult)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // repeated .milvus.grpc.QueryResult query_result_arrays = 1;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->query_result_arrays_size()); i < n; i++) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessageToArray(
+        1, this->query_result_arrays(static_cast<int>(i)), target);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.TopKQueryResult)
+  return target;
+}
+
+size_t TopKQueryResult::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.TopKQueryResult)
+  size_t total_size = 0;
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
+        _internal_metadata_.unknown_fields());
+  }
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .milvus.grpc.QueryResult query_result_arrays = 1;
+  {
+    unsigned int count = static_cast<unsigned int>(this->query_result_arrays_size());
+    total_size += 1UL * count;
+    for (unsigned int i = 0; i < count; i++) {
+      total_size +=
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          this->query_result_arrays(static_cast<int>(i)));
+    }
+  }
+
+  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void TopKQueryResult::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.TopKQueryResult)
+  GOOGLE_DCHECK_NE(&from, this);
+  const TopKQueryResult* source =
+      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<TopKQueryResult>(
+          &from);
+  if (source == nullptr) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.TopKQueryResult)
+    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.TopKQueryResult)
+    MergeFrom(*source);
+  }
+}
+
+void TopKQueryResult::MergeFrom(const TopKQueryResult& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.TopKQueryResult)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  query_result_arrays_.MergeFrom(from.query_result_arrays_);
+}
+
+void TopKQueryResult::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.TopKQueryResult)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void TopKQueryResult::CopyFrom(const TopKQueryResult& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.TopKQueryResult)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool TopKQueryResult::IsInitialized() const {
+  return true;
+}
+
+void TopKQueryResult::InternalSwap(TopKQueryResult* other) {
+  using std::swap;
+  _internal_metadata_.Swap(&other->_internal_metadata_);
+  CastToBase(&query_result_arrays_)->InternalSwap(CastToBase(&other->query_result_arrays_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata TopKQueryResult::GetMetadata() const {
+  return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+void TopKQueryResultList::InitAsDefaultInstance() {
+  ::milvus::grpc::_TopKQueryResultList_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>(
+      ::milvus::grpc::Status::internal_default_instance());
+}
+class TopKQueryResultList::_Internal {
+ public:
+  static const ::milvus::grpc::Status& status(const TopKQueryResultList* msg);
+};
+
+const ::milvus::grpc::Status&
+TopKQueryResultList::_Internal::status(const TopKQueryResultList* msg) {
+  return *msg->status_;
+}
+void TopKQueryResultList::clear_status() {
+  if (GetArenaNoVirtual() == nullptr && status_ != nullptr) {
+    delete status_;
+  }
+  status_ = nullptr;
+}
+TopKQueryResultList::TopKQueryResultList()
+  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:milvus.grpc.TopKQueryResultList)
+}
+TopKQueryResultList::TopKQueryResultList(const TopKQueryResultList& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      _internal_metadata_(nullptr),
+      topk_query_result_(from.topk_query_result_) {
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  if (from.has_status()) {
+    status_ = new ::milvus::grpc::Status(*from.status_);
+  } else {
+    status_ = nullptr;
+  }
+  // @@protoc_insertion_point(copy_constructor:milvus.grpc.TopKQueryResultList)
+}
+
+void TopKQueryResultList::SharedCtor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TopKQueryResultList_milvus_2eproto.base);
+  status_ = nullptr;
+}
+
+TopKQueryResultList::~TopKQueryResultList() {
+  // @@protoc_insertion_point(destructor:milvus.grpc.TopKQueryResultList)
+  SharedDtor();
+}
+
+void TopKQueryResultList::SharedDtor() {
+  if (this != internal_default_instance()) delete status_;
+}
+
+void TopKQueryResultList::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+const TopKQueryResultList& TopKQueryResultList::default_instance() {
+  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TopKQueryResultList_milvus_2eproto.base);
+  return *internal_default_instance();
+}
+
+
+void TopKQueryResultList::Clear() {
+// @@protoc_insertion_point(message_clear_start:milvus.grpc.TopKQueryResultList)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  topk_query_result_.Clear();
+  if (GetArenaNoVirtual() == nullptr && status_ != nullptr) {
+    delete status_;
+  }
+  status_ = nullptr;
+  _internal_metadata_.Clear();
+}
+
+#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+const char* TopKQueryResultList::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    CHK_(ptr);
+    switch (tag >> 3) {
+      // .milvus.grpc.Status status = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+          ptr = ctx->ParseMessage(mutable_status(), ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // repeated .milvus.grpc.TopKQueryResult topk_query_result = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+          ptr -= 1;
+          do {
+            ptr += 1;
+            ptr = ctx->ParseMessage(add_topk_query_result(), ptr);
+            CHK_(ptr);
+            if (!ctx->DataAvailable(ptr)) break;
+          } while (::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint8>(ptr) == 18);
+        } else goto handle_unusual;
+        continue;
+      default: {
+      handle_unusual:
+        if ((tag & 7) == 4 || tag == 0) {
+          ctx->SetLastTag(tag);
+          goto success;
+        }
+        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
+        CHK_(ptr != nullptr);
+        continue;
+      }
+    }  // switch
+  }  // while
+success:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto success;
+#undef CHK_
+}
+#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+bool TopKQueryResultList::MergePartialFromCodedStream(
+    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
+  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+  // @@protoc_insertion_point(parse_start:milvus.grpc.TopKQueryResultList)
+  for (;;) {
+    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // .milvus.grpc.Status status = 1;
+      case 1: {
+        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
+          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
+               input, mutable_status()));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      // repeated .milvus.grpc.TopKQueryResult topk_query_result = 2;
+      case 2: {
+        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
+          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
+                input, add_topk_query_result()));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0) {
+          goto success;
+        }
+        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
+              input, tag, _internal_metadata_.mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:milvus.grpc.TopKQueryResultList)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:milvus.grpc.TopKQueryResultList)
+  return false;
+#undef DO_
+}
+#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+
+void TopKQueryResultList::SerializeWithCachedSizes(
+    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:milvus.grpc.TopKQueryResultList)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .milvus.grpc.Status status = 1;
+  if (this->has_status()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, _Internal::status(this), output);
+  }
+
+  // repeated .milvus.grpc.TopKQueryResult topk_query_result = 2;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->topk_query_result_size()); i < n; i++) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2,
+      this->topk_query_result(static_cast<int>(i)),
+      output);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
+        _internal_metadata_.unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:milvus.grpc.TopKQueryResultList)
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* TopKQueryResultList::InternalSerializeWithCachedSizesToArray(
+    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.TopKQueryResultList)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .milvus.grpc.Status status = 1;
+  if (this->has_status()) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessageToArray(
+        1, _Internal::status(this), target);
+  }
+
+  // repeated .milvus.grpc.TopKQueryResult topk_query_result = 2;
+  for (unsigned int i = 0,
+      n = static_cast<unsigned int>(this->topk_query_result_size()); i < n; i++) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessageToArray(
+        2, this->topk_query_result(static_cast<int>(i)), target);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.TopKQueryResultList)
+  return target;
+}
+
+size_t TopKQueryResultList::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.TopKQueryResultList)
+  size_t total_size = 0;
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
+        _internal_metadata_.unknown_fields());
+  }
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // repeated .milvus.grpc.TopKQueryResult topk_query_result = 2;
+  {
+    unsigned int count = static_cast<unsigned int>(this->topk_query_result_size());
+    total_size += 1UL * count;
+    for (unsigned int i = 0; i < count; i++) {
+      total_size +=
+        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+          this->topk_query_result(static_cast<int>(i)));
+    }
+  }
+
+  // .milvus.grpc.Status status = 1;
+  if (this->has_status()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *status_);
+  }
+
+  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void TopKQueryResultList::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.TopKQueryResultList)
+  GOOGLE_DCHECK_NE(&from, this);
+  const TopKQueryResultList* source =
+      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<TopKQueryResultList>(
+          &from);
+  if (source == nullptr) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.TopKQueryResultList)
+    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.TopKQueryResultList)
+    MergeFrom(*source);
+  }
+}
+
+void TopKQueryResultList::MergeFrom(const TopKQueryResultList& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.TopKQueryResultList)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  topk_query_result_.MergeFrom(from.topk_query_result_);
+  if (from.has_status()) {
+    mutable_status()->::milvus::grpc::Status::MergeFrom(from.status());
+  }
+}
+
+void TopKQueryResultList::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.TopKQueryResultList)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void TopKQueryResultList::CopyFrom(const TopKQueryResultList& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.TopKQueryResultList)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool TopKQueryResultList::IsInitialized() const {
+  return true;
+}
+
+void TopKQueryResultList::InternalSwap(TopKQueryResultList* other) {
+  using std::swap;
+  _internal_metadata_.Swap(&other->_internal_metadata_);
+  CastToBase(&topk_query_result_)->InternalSwap(CastToBase(&other->topk_query_result_));
+  swap(status_, other->status_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata TopKQueryResultList::GetMetadata() const {
+  return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+void StringReply::InitAsDefaultInstance() {
+  ::milvus::grpc::_StringReply_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>(
+      ::milvus::grpc::Status::internal_default_instance());
+}
+class StringReply::_Internal {
+ public:
+  static const ::milvus::grpc::Status& status(const StringReply* msg);
+};
+
+const ::milvus::grpc::Status&
+StringReply::_Internal::status(const StringReply* msg) {
+  return *msg->status_;
+}
+void StringReply::clear_status() {
+  if (GetArenaNoVirtual() == nullptr && status_ != nullptr) {
+    delete status_;
+  }
+  status_ = nullptr;
+}
+StringReply::StringReply()
+  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:milvus.grpc.StringReply)
+}
+StringReply::StringReply(const StringReply& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      _internal_metadata_(nullptr) {
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  string_reply_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  if (!from.string_reply().empty()) {
+    string_reply_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.string_reply_);
+  }
+  if (from.has_status()) {
+    status_ = new ::milvus::grpc::Status(*from.status_);
+  } else {
+    status_ = nullptr;
+  }
+  // @@protoc_insertion_point(copy_constructor:milvus.grpc.StringReply)
+}
+
+void StringReply::SharedCtor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_StringReply_milvus_2eproto.base);
+  string_reply_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  status_ = nullptr;
+}
+
+StringReply::~StringReply() {
+  // @@protoc_insertion_point(destructor:milvus.grpc.StringReply)
+  SharedDtor();
+}
+
+void StringReply::SharedDtor() {
+  string_reply_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  if (this != internal_default_instance()) delete status_;
+}
+
+void StringReply::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+const StringReply& StringReply::default_instance() {
+  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_StringReply_milvus_2eproto.base);
+  return *internal_default_instance();
+}
+
+
+void StringReply::Clear() {
+// @@protoc_insertion_point(message_clear_start:milvus.grpc.StringReply)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  string_reply_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  if (GetArenaNoVirtual() == nullptr && status_ != nullptr) {
+    delete status_;
+  }
+  status_ = nullptr;
+  _internal_metadata_.Clear();
+}
+
+#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+const char* StringReply::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    CHK_(ptr);
+    switch (tag >> 3) {
+      // .milvus.grpc.Status status = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+          ptr = ctx->ParseMessage(mutable_status(), ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // string string_reply = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_string_reply(), ptr, ctx, "milvus.grpc.StringReply.string_reply");
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      default: {
+      handle_unusual:
+        if ((tag & 7) == 4 || tag == 0) {
+          ctx->SetLastTag(tag);
+          goto success;
+        }
+        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
+        CHK_(ptr != nullptr);
+        continue;
+      }
+    }  // switch
+  }  // while
+success:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto success;
+#undef CHK_
+}
+#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+bool StringReply::MergePartialFromCodedStream(
+    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
+  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+  // @@protoc_insertion_point(parse_start:milvus.grpc.StringReply)
+  for (;;) {
+    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // .milvus.grpc.Status status = 1;
+      case 1: {
+        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
+          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
+               input, mutable_status()));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      // string string_reply = 2;
+      case 2: {
+        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
+          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
+                input, this->mutable_string_reply()));
+          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+            this->string_reply().data(), static_cast<int>(this->string_reply().length()),
+            ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
+            "milvus.grpc.StringReply.string_reply"));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0) {
+          goto success;
+        }
+        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
+              input, tag, _internal_metadata_.mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:milvus.grpc.StringReply)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:milvus.grpc.StringReply)
+  return false;
+#undef DO_
+}
+#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+
+void StringReply::SerializeWithCachedSizes(
+    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:milvus.grpc.StringReply)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .milvus.grpc.Status status = 1;
+  if (this->has_status()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, _Internal::status(this), output);
+  }
+
+  // string string_reply = 2;
+  if (this->string_reply().size() > 0) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->string_reply().data(), static_cast<int>(this->string_reply().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "milvus.grpc.StringReply.string_reply");
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->string_reply(), output);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
+        _internal_metadata_.unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:milvus.grpc.StringReply)
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* StringReply::InternalSerializeWithCachedSizesToArray(
+    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.StringReply)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .milvus.grpc.Status status = 1;
+  if (this->has_status()) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessageToArray(
+        1, _Internal::status(this), target);
+  }
+
+  // string string_reply = 2;
+  if (this->string_reply().size() > 0) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->string_reply().data(), static_cast<int>(this->string_reply().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "milvus.grpc.StringReply.string_reply");
+    target =
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
+        2, this->string_reply(), target);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.StringReply)
+  return target;
+}
+
+size_t StringReply::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.StringReply)
+  size_t total_size = 0;
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
+        _internal_metadata_.unknown_fields());
+  }
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // string string_reply = 2;
+  if (this->string_reply().size() > 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->string_reply());
+  }
+
+  // .milvus.grpc.Status status = 1;
+  if (this->has_status()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *status_);
+  }
+
+  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void StringReply::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.StringReply)
+  GOOGLE_DCHECK_NE(&from, this);
+  const StringReply* source =
+      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<StringReply>(
+          &from);
+  if (source == nullptr) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.StringReply)
+    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.StringReply)
+    MergeFrom(*source);
+  }
+}
+
+void StringReply::MergeFrom(const StringReply& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.StringReply)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from.string_reply().size() > 0) {
+
+    string_reply_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.string_reply_);
+  }
+  if (from.has_status()) {
+    mutable_status()->::milvus::grpc::Status::MergeFrom(from.status());
+  }
+}
+
+void StringReply::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.StringReply)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void StringReply::CopyFrom(const StringReply& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.StringReply)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool StringReply::IsInitialized() const {
+  return true;
+}
+
+void StringReply::InternalSwap(StringReply* other) {
+  using std::swap;
+  _internal_metadata_.Swap(&other->_internal_metadata_);
+  string_reply_.Swap(&other->string_reply_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+    GetArenaNoVirtual());
+  swap(status_, other->status_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata StringReply::GetMetadata() const {
+  return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+void BoolReply::InitAsDefaultInstance() {
+  ::milvus::grpc::_BoolReply_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>(
+      ::milvus::grpc::Status::internal_default_instance());
+}
+class BoolReply::_Internal {
+ public:
+  static const ::milvus::grpc::Status& status(const BoolReply* msg);
+};
+
+const ::milvus::grpc::Status&
+BoolReply::_Internal::status(const BoolReply* msg) {
+  return *msg->status_;
+}
+void BoolReply::clear_status() {
+  if (GetArenaNoVirtual() == nullptr && status_ != nullptr) {
+    delete status_;
+  }
+  status_ = nullptr;
+}
+BoolReply::BoolReply()
+  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:milvus.grpc.BoolReply)
+}
+BoolReply::BoolReply(const BoolReply& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      _internal_metadata_(nullptr) {
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  if (from.has_status()) {
+    status_ = new ::milvus::grpc::Status(*from.status_);
+  } else {
+    status_ = nullptr;
+  }
+  bool_reply_ = from.bool_reply_;
+  // @@protoc_insertion_point(copy_constructor:milvus.grpc.BoolReply)
+}
+
+void BoolReply::SharedCtor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_BoolReply_milvus_2eproto.base);
+  ::memset(&status_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&bool_reply_) -
+      reinterpret_cast<char*>(&status_)) + sizeof(bool_reply_));
+}
+
+BoolReply::~BoolReply() {
+  // @@protoc_insertion_point(destructor:milvus.grpc.BoolReply)
+  SharedDtor();
+}
+
+void BoolReply::SharedDtor() {
+  if (this != internal_default_instance()) delete status_;
+}
+
+void BoolReply::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+const BoolReply& BoolReply::default_instance() {
+  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_BoolReply_milvus_2eproto.base);
+  return *internal_default_instance();
+}
+
+
+void BoolReply::Clear() {
+// @@protoc_insertion_point(message_clear_start:milvus.grpc.BoolReply)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (GetArenaNoVirtual() == nullptr && status_ != nullptr) {
+    delete status_;
+  }
+  status_ = nullptr;
+  bool_reply_ = false;
+  _internal_metadata_.Clear();
+}
+
+#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+const char* BoolReply::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    CHK_(ptr);
+    switch (tag >> 3) {
+      // .milvus.grpc.Status status = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+          ptr = ctx->ParseMessage(mutable_status(), ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // bool bool_reply = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
+          bool_reply_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      default: {
+      handle_unusual:
+        if ((tag & 7) == 4 || tag == 0) {
+          ctx->SetLastTag(tag);
+          goto success;
+        }
+        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
+        CHK_(ptr != nullptr);
+        continue;
+      }
+    }  // switch
+  }  // while
+success:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto success;
+#undef CHK_
+}
+#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+bool BoolReply::MergePartialFromCodedStream(
+    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
+  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+  // @@protoc_insertion_point(parse_start:milvus.grpc.BoolReply)
+  for (;;) {
+    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // .milvus.grpc.Status status = 1;
+      case 1: {
+        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
+          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
+               input, mutable_status()));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      // bool bool_reply = 2;
+      case 2: {
+        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
+
+          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &bool_reply_)));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0) {
+          goto success;
+        }
+        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
+              input, tag, _internal_metadata_.mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:milvus.grpc.BoolReply)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:milvus.grpc.BoolReply)
+  return false;
+#undef DO_
+}
+#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+
+void BoolReply::SerializeWithCachedSizes(
+    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:milvus.grpc.BoolReply)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .milvus.grpc.Status status = 1;
+  if (this->has_status()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, _Internal::status(this), output);
+  }
+
+  // bool bool_reply = 2;
+  if (this->bool_reply() != 0) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBool(2, this->bool_reply(), output);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
+        _internal_metadata_.unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:milvus.grpc.BoolReply)
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* BoolReply::InternalSerializeWithCachedSizesToArray(
+    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.BoolReply)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .milvus.grpc.Status status = 1;
+  if (this->has_status()) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessageToArray(
+        1, _Internal::status(this), target);
+  }
+
+  // bool bool_reply = 2;
+  if (this->bool_reply() != 0) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->bool_reply(), target);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.BoolReply)
+  return target;
+}
+
+size_t BoolReply::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.BoolReply)
+  size_t total_size = 0;
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
+        _internal_metadata_.unknown_fields());
+  }
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .milvus.grpc.Status status = 1;
+  if (this->has_status()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *status_);
+  }
+
+  // bool bool_reply = 2;
+  if (this->bool_reply() != 0) {
+    total_size += 1 + 1;
+  }
+
+  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void BoolReply::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.BoolReply)
+  GOOGLE_DCHECK_NE(&from, this);
+  const BoolReply* source =
+      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<BoolReply>(
+          &from);
+  if (source == nullptr) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.BoolReply)
+    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.BoolReply)
+    MergeFrom(*source);
+  }
+}
+
+void BoolReply::MergeFrom(const BoolReply& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.BoolReply)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from.has_status()) {
+    mutable_status()->::milvus::grpc::Status::MergeFrom(from.status());
+  }
+  if (from.bool_reply() != 0) {
+    set_bool_reply(from.bool_reply());
+  }
+}
+
+void BoolReply::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.BoolReply)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void BoolReply::CopyFrom(const BoolReply& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.BoolReply)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool BoolReply::IsInitialized() const {
+  return true;
+}
+
+void BoolReply::InternalSwap(BoolReply* other) {
+  using std::swap;
+  _internal_metadata_.Swap(&other->_internal_metadata_);
+  swap(status_, other->status_);
+  swap(bool_reply_, other->bool_reply_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata BoolReply::GetMetadata() const {
+  return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+void TableRowCount::InitAsDefaultInstance() {
+  ::milvus::grpc::_TableRowCount_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>(
+      ::milvus::grpc::Status::internal_default_instance());
+}
+class TableRowCount::_Internal {
+ public:
+  static const ::milvus::grpc::Status& status(const TableRowCount* msg);
+};
+
+const ::milvus::grpc::Status&
+TableRowCount::_Internal::status(const TableRowCount* msg) {
+  return *msg->status_;
+}
+void TableRowCount::clear_status() {
+  if (GetArenaNoVirtual() == nullptr && status_ != nullptr) {
+    delete status_;
+  }
+  status_ = nullptr;
+}
+TableRowCount::TableRowCount()
+  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:milvus.grpc.TableRowCount)
+}
+TableRowCount::TableRowCount(const TableRowCount& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      _internal_metadata_(nullptr) {
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  if (from.has_status()) {
+    status_ = new ::milvus::grpc::Status(*from.status_);
+  } else {
+    status_ = nullptr;
+  }
+  table_row_count_ = from.table_row_count_;
+  // @@protoc_insertion_point(copy_constructor:milvus.grpc.TableRowCount)
+}
+
+void TableRowCount::SharedCtor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TableRowCount_milvus_2eproto.base);
+  ::memset(&status_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&table_row_count_) -
+      reinterpret_cast<char*>(&status_)) + sizeof(table_row_count_));
+}
+
+TableRowCount::~TableRowCount() {
+  // @@protoc_insertion_point(destructor:milvus.grpc.TableRowCount)
+  SharedDtor();
+}
+
+void TableRowCount::SharedDtor() {
+  if (this != internal_default_instance()) delete status_;
+}
+
+void TableRowCount::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+const TableRowCount& TableRowCount::default_instance() {
+  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_TableRowCount_milvus_2eproto.base);
+  return *internal_default_instance();
+}
+
+
+void TableRowCount::Clear() {
+// @@protoc_insertion_point(message_clear_start:milvus.grpc.TableRowCount)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  if (GetArenaNoVirtual() == nullptr && status_ != nullptr) {
+    delete status_;
+  }
+  status_ = nullptr;
+  table_row_count_ = PROTOBUF_LONGLONG(0);
+  _internal_metadata_.Clear();
+}
+
+#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+const char* TableRowCount::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    CHK_(ptr);
+    switch (tag >> 3) {
+      // .milvus.grpc.Status status = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+          ptr = ctx->ParseMessage(mutable_status(), ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // int64 table_row_count = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
+          table_row_count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      default: {
+      handle_unusual:
+        if ((tag & 7) == 4 || tag == 0) {
+          ctx->SetLastTag(tag);
+          goto success;
+        }
+        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
+        CHK_(ptr != nullptr);
+        continue;
+      }
+    }  // switch
+  }  // while
+success:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto success;
+#undef CHK_
+}
+#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+bool TableRowCount::MergePartialFromCodedStream(
+    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
+  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+  // @@protoc_insertion_point(parse_start:milvus.grpc.TableRowCount)
+  for (;;) {
+    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // .milvus.grpc.Status status = 1;
+      case 1: {
+        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
+          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
+               input, mutable_status()));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      // int64 table_row_count = 2;
+      case 2: {
+        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
+
+          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
+                   ::PROTOBUF_NAMESPACE_ID::int64, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64>(
+                 input, &table_row_count_)));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0) {
+          goto success;
+        }
+        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
+              input, tag, _internal_metadata_.mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:milvus.grpc.TableRowCount)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:milvus.grpc.TableRowCount)
+  return false;
+#undef DO_
+}
+#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+
+void TableRowCount::SerializeWithCachedSizes(
+    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:milvus.grpc.TableRowCount)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .milvus.grpc.Status status = 1;
+  if (this->has_status()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, _Internal::status(this), output);
+  }
+
+  // int64 table_row_count = 2;
+  if (this->table_row_count() != 0) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64(2, this->table_row_count(), output);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
+        _internal_metadata_.unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:milvus.grpc.TableRowCount)
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* TableRowCount::InternalSerializeWithCachedSizesToArray(
+    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.TableRowCount)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .milvus.grpc.Status status = 1;
+  if (this->has_status()) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessageToArray(
+        1, _Internal::status(this), target);
+  }
+
+  // int64 table_row_count = 2;
+  if (this->table_row_count() != 0) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(2, this->table_row_count(), target);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.TableRowCount)
+  return target;
+}
+
+size_t TableRowCount::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.TableRowCount)
+  size_t total_size = 0;
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
+        _internal_metadata_.unknown_fields());
+  }
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // .milvus.grpc.Status status = 1;
+  if (this->has_status()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *status_);
+  }
+
+  // int64 table_row_count = 2;
+  if (this->table_row_count() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size(
+        this->table_row_count());
+  }
+
+  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void TableRowCount::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.TableRowCount)
+  GOOGLE_DCHECK_NE(&from, this);
+  const TableRowCount* source =
+      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<TableRowCount>(
+          &from);
+  if (source == nullptr) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.TableRowCount)
+    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.TableRowCount)
+    MergeFrom(*source);
+  }
+}
+
+void TableRowCount::MergeFrom(const TableRowCount& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.TableRowCount)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from.has_status()) {
+    mutable_status()->::milvus::grpc::Status::MergeFrom(from.status());
+  }
+  if (from.table_row_count() != 0) {
+    set_table_row_count(from.table_row_count());
+  }
+}
+
+void TableRowCount::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.TableRowCount)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void TableRowCount::CopyFrom(const TableRowCount& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.TableRowCount)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool TableRowCount::IsInitialized() const {
+  return true;
+}
+
+void TableRowCount::InternalSwap(TableRowCount* other) {
+  using std::swap;
+  _internal_metadata_.Swap(&other->_internal_metadata_);
+  swap(status_, other->status_);
+  swap(table_row_count_, other->table_row_count_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata TableRowCount::GetMetadata() const {
+  return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+void Command::InitAsDefaultInstance() {
+}
+class Command::_Internal {
+ public:
+};
+
+Command::Command()
+  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:milvus.grpc.Command)
+}
+Command::Command(const Command& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      _internal_metadata_(nullptr) {
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  cmd_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  if (!from.cmd().empty()) {
+    cmd_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.cmd_);
+  }
+  // @@protoc_insertion_point(copy_constructor:milvus.grpc.Command)
+}
+
+void Command::SharedCtor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Command_milvus_2eproto.base);
+  cmd_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+Command::~Command() {
+  // @@protoc_insertion_point(destructor:milvus.grpc.Command)
+  SharedDtor();
+}
+
+void Command::SharedDtor() {
+  cmd_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void Command::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+const Command& Command::default_instance() {
+  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Command_milvus_2eproto.base);
+  return *internal_default_instance();
+}
+
+
+void Command::Clear() {
+// @@protoc_insertion_point(message_clear_start:milvus.grpc.Command)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  cmd_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  _internal_metadata_.Clear();
+}
+
+#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+const char* Command::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    CHK_(ptr);
+    switch (tag >> 3) {
+      // string cmd = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_cmd(), ptr, ctx, "milvus.grpc.Command.cmd");
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      default: {
+      handle_unusual:
+        if ((tag & 7) == 4 || tag == 0) {
+          ctx->SetLastTag(tag);
+          goto success;
+        }
+        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
+        CHK_(ptr != nullptr);
+        continue;
+      }
+    }  // switch
+  }  // while
+success:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto success;
+#undef CHK_
+}
+#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+bool Command::MergePartialFromCodedStream(
+    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
+  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+  // @@protoc_insertion_point(parse_start:milvus.grpc.Command)
+  for (;;) {
+    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // string cmd = 1;
+      case 1: {
+        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
+          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
+                input, this->mutable_cmd()));
+          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+            this->cmd().data(), static_cast<int>(this->cmd().length()),
+            ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
+            "milvus.grpc.Command.cmd"));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0) {
+          goto success;
+        }
+        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
+              input, tag, _internal_metadata_.mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:milvus.grpc.Command)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:milvus.grpc.Command)
+  return false;
+#undef DO_
+}
+#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+
+void Command::SerializeWithCachedSizes(
+    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:milvus.grpc.Command)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // string cmd = 1;
+  if (this->cmd().size() > 0) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->cmd().data(), static_cast<int>(this->cmd().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "milvus.grpc.Command.cmd");
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->cmd(), output);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
+        _internal_metadata_.unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:milvus.grpc.Command)
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* Command::InternalSerializeWithCachedSizesToArray(
+    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.Command)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // string cmd = 1;
+  if (this->cmd().size() > 0) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->cmd().data(), static_cast<int>(this->cmd().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "milvus.grpc.Command.cmd");
+    target =
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
+        1, this->cmd(), target);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.Command)
+  return target;
+}
+
+size_t Command::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.Command)
+  size_t total_size = 0;
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
+        _internal_metadata_.unknown_fields());
+  }
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // string cmd = 1;
+  if (this->cmd().size() > 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->cmd());
+  }
+
+  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void Command::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.Command)
+  GOOGLE_DCHECK_NE(&from, this);
+  const Command* source =
+      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<Command>(
+          &from);
+  if (source == nullptr) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.Command)
+    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.Command)
+    MergeFrom(*source);
+  }
+}
+
+void Command::MergeFrom(const Command& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.Command)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from.cmd().size() > 0) {
+
+    cmd_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.cmd_);
+  }
+}
+
+void Command::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.Command)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void Command::CopyFrom(const Command& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.Command)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Command::IsInitialized() const {
+  return true;
+}
+
+void Command::InternalSwap(Command* other) {
+  using std::swap;
+  _internal_metadata_.Swap(&other->_internal_metadata_);
+  cmd_.Swap(&other->cmd_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+    GetArenaNoVirtual());
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Command::GetMetadata() const {
+  return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+void Index::InitAsDefaultInstance() {
+}
+class Index::_Internal {
+ public:
+};
+
+Index::Index()
+  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:milvus.grpc.Index)
+}
+Index::Index(const Index& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      _internal_metadata_(nullptr) {
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::memcpy(&index_type_, &from.index_type_,
+    static_cast<size_t>(reinterpret_cast<char*>(&nlist_) -
+    reinterpret_cast<char*>(&index_type_)) + sizeof(nlist_));
+  // @@protoc_insertion_point(copy_constructor:milvus.grpc.Index)
+}
+
+void Index::SharedCtor() {
+  ::memset(&index_type_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&nlist_) -
+      reinterpret_cast<char*>(&index_type_)) + sizeof(nlist_));
+}
+
+Index::~Index() {
+  // @@protoc_insertion_point(destructor:milvus.grpc.Index)
+  SharedDtor();
+}
+
+void Index::SharedDtor() {
+}
+
+void Index::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+const Index& Index::default_instance() {
+  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Index_milvus_2eproto.base);
+  return *internal_default_instance();
+}
+
+
+void Index::Clear() {
+// @@protoc_insertion_point(message_clear_start:milvus.grpc.Index)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  ::memset(&index_type_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&nlist_) -
+      reinterpret_cast<char*>(&index_type_)) + sizeof(nlist_));
+  _internal_metadata_.Clear();
+}
+
+#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+const char* Index::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    CHK_(ptr);
+    switch (tag >> 3) {
+      // int32 index_type = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
+          index_type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // int32 nlist = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
+          nlist_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      default: {
+      handle_unusual:
+        if ((tag & 7) == 4 || tag == 0) {
+          ctx->SetLastTag(tag);
+          goto success;
+        }
+        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
+        CHK_(ptr != nullptr);
+        continue;
+      }
+    }  // switch
+  }  // while
+success:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto success;
+#undef CHK_
+}
+#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+bool Index::MergePartialFromCodedStream(
+    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
+  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+  // @@protoc_insertion_point(parse_start:milvus.grpc.Index)
+  for (;;) {
+    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // int32 index_type = 1;
+      case 1: {
+        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
+
+          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
+                   ::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>(
+                 input, &index_type_)));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      // int32 nlist = 2;
+      case 2: {
+        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (16 & 0xFF)) {
+
+          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
+                   ::PROTOBUF_NAMESPACE_ID::int32, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT32>(
+                 input, &nlist_)));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0) {
+          goto success;
+        }
+        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
+              input, tag, _internal_metadata_.mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:milvus.grpc.Index)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:milvus.grpc.Index)
+  return false;
+#undef DO_
+}
+#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+
+void Index::SerializeWithCachedSizes(
+    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:milvus.grpc.Index)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // int32 index_type = 1;
+  if (this->index_type() != 0) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32(1, this->index_type(), output);
+  }
+
+  // int32 nlist = 2;
+  if (this->nlist() != 0) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32(2, this->nlist(), output);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
+        _internal_metadata_.unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:milvus.grpc.Index)
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* Index::InternalSerializeWithCachedSizesToArray(
+    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.Index)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // int32 index_type = 1;
+  if (this->index_type() != 0) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->index_type(), target);
+  }
+
+  // int32 nlist = 2;
+  if (this->nlist() != 0) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->nlist(), target);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.Index)
+  return target;
+}
+
+size_t Index::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.Index)
+  size_t total_size = 0;
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
+        _internal_metadata_.unknown_fields());
+  }
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // int32 index_type = 1;
+  if (this->index_type() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+        this->index_type());
+  }
+
+  // int32 nlist = 2;
+  if (this->nlist() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+        this->nlist());
+  }
+
+  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void Index::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.Index)
+  GOOGLE_DCHECK_NE(&from, this);
+  const Index* source =
+      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<Index>(
+          &from);
+  if (source == nullptr) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.Index)
+    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.Index)
+    MergeFrom(*source);
+  }
+}
+
+void Index::MergeFrom(const Index& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.Index)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from.index_type() != 0) {
+    set_index_type(from.index_type());
+  }
+  if (from.nlist() != 0) {
+    set_nlist(from.nlist());
+  }
+}
+
+void Index::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.Index)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void Index::CopyFrom(const Index& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.Index)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Index::IsInitialized() const {
+  return true;
+}
+
+void Index::InternalSwap(Index* other) {
+  using std::swap;
+  _internal_metadata_.Swap(&other->_internal_metadata_);
+  swap(index_type_, other->index_type_);
+  swap(nlist_, other->nlist_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Index::GetMetadata() const {
+  return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+void IndexParam::InitAsDefaultInstance() {
+  ::milvus::grpc::_IndexParam_default_instance_._instance.get_mutable()->status_ = const_cast< ::milvus::grpc::Status*>(
+      ::milvus::grpc::Status::internal_default_instance());
+  ::milvus::grpc::_IndexParam_default_instance_._instance.get_mutable()->index_ = const_cast< ::milvus::grpc::Index*>(
+      ::milvus::grpc::Index::internal_default_instance());
+}
+class IndexParam::_Internal {
+ public:
+  static const ::milvus::grpc::Status& status(const IndexParam* msg);
+  static const ::milvus::grpc::Index& index(const IndexParam* msg);
+};
+
+const ::milvus::grpc::Status&
+IndexParam::_Internal::status(const IndexParam* msg) {
+  return *msg->status_;
+}
+const ::milvus::grpc::Index&
+IndexParam::_Internal::index(const IndexParam* msg) {
+  return *msg->index_;
+}
+void IndexParam::clear_status() {
+  if (GetArenaNoVirtual() == nullptr && status_ != nullptr) {
+    delete status_;
+  }
+  status_ = nullptr;
+}
+IndexParam::IndexParam()
+  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:milvus.grpc.IndexParam)
+}
+IndexParam::IndexParam(const IndexParam& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      _internal_metadata_(nullptr) {
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  if (!from.table_name().empty()) {
+    table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_);
+  }
+  if (from.has_status()) {
+    status_ = new ::milvus::grpc::Status(*from.status_);
+  } else {
+    status_ = nullptr;
+  }
+  if (from.has_index()) {
+    index_ = new ::milvus::grpc::Index(*from.index_);
+  } else {
+    index_ = nullptr;
+  }
+  // @@protoc_insertion_point(copy_constructor:milvus.grpc.IndexParam)
+}
+
+void IndexParam::SharedCtor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_IndexParam_milvus_2eproto.base);
+  table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  ::memset(&status_, 0, static_cast<size_t>(
+      reinterpret_cast<char*>(&index_) -
+      reinterpret_cast<char*>(&status_)) + sizeof(index_));
+}
+
+IndexParam::~IndexParam() {
+  // @@protoc_insertion_point(destructor:milvus.grpc.IndexParam)
+  SharedDtor();
+}
+
+void IndexParam::SharedDtor() {
+  table_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  if (this != internal_default_instance()) delete status_;
+  if (this != internal_default_instance()) delete index_;
+}
+
+void IndexParam::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+const IndexParam& IndexParam::default_instance() {
+  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_IndexParam_milvus_2eproto.base);
+  return *internal_default_instance();
+}
+
+
+void IndexParam::Clear() {
+// @@protoc_insertion_point(message_clear_start:milvus.grpc.IndexParam)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  if (GetArenaNoVirtual() == nullptr && status_ != nullptr) {
+    delete status_;
+  }
+  status_ = nullptr;
+  if (GetArenaNoVirtual() == nullptr && index_ != nullptr) {
+    delete index_;
+  }
+  index_ = nullptr;
+  _internal_metadata_.Clear();
+}
+
+#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+const char* IndexParam::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    CHK_(ptr);
+    switch (tag >> 3) {
+      // .milvus.grpc.Status status = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+          ptr = ctx->ParseMessage(mutable_status(), ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // string table_name = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_table_name(), ptr, ctx, "milvus.grpc.IndexParam.table_name");
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // .milvus.grpc.Index index = 3;
+      case 3:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
+          ptr = ctx->ParseMessage(mutable_index(), ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      default: {
+      handle_unusual:
+        if ((tag & 7) == 4 || tag == 0) {
+          ctx->SetLastTag(tag);
+          goto success;
+        }
+        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
+        CHK_(ptr != nullptr);
+        continue;
+      }
+    }  // switch
+  }  // while
+success:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto success;
+#undef CHK_
+}
+#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+bool IndexParam::MergePartialFromCodedStream(
+    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
+  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+  // @@protoc_insertion_point(parse_start:milvus.grpc.IndexParam)
+  for (;;) {
+    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // .milvus.grpc.Status status = 1;
+      case 1: {
+        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
+          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
+               input, mutable_status()));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      // string table_name = 2;
+      case 2: {
+        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
+          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
+                input, this->mutable_table_name()));
+          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+            this->table_name().data(), static_cast<int>(this->table_name().length()),
+            ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
+            "milvus.grpc.IndexParam.table_name"));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      // .milvus.grpc.Index index = 3;
+      case 3: {
+        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (26 & 0xFF)) {
+          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
+               input, mutable_index()));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0) {
+          goto success;
+        }
+        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
+              input, tag, _internal_metadata_.mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:milvus.grpc.IndexParam)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:milvus.grpc.IndexParam)
+  return false;
+#undef DO_
+}
+#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+
+void IndexParam::SerializeWithCachedSizes(
+    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:milvus.grpc.IndexParam)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .milvus.grpc.Status status = 1;
+  if (this->has_status()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, _Internal::status(this), output);
+  }
+
+  // string table_name = 2;
+  if (this->table_name().size() > 0) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->table_name().data(), static_cast<int>(this->table_name().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "milvus.grpc.IndexParam.table_name");
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->table_name(), output);
+  }
+
+  // .milvus.grpc.Index index = 3;
+  if (this->has_index()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, _Internal::index(this), output);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
+        _internal_metadata_.unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:milvus.grpc.IndexParam)
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* IndexParam::InternalSerializeWithCachedSizesToArray(
+    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.IndexParam)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .milvus.grpc.Status status = 1;
+  if (this->has_status()) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessageToArray(
+        1, _Internal::status(this), target);
+  }
+
+  // string table_name = 2;
+  if (this->table_name().size() > 0) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->table_name().data(), static_cast<int>(this->table_name().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "milvus.grpc.IndexParam.table_name");
+    target =
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
+        2, this->table_name(), target);
+  }
+
+  // .milvus.grpc.Index index = 3;
+  if (this->has_index()) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessageToArray(
+        3, _Internal::index(this), target);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.IndexParam)
+  return target;
+}
+
+size_t IndexParam::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.IndexParam)
+  size_t total_size = 0;
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
+        _internal_metadata_.unknown_fields());
+  }
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // string table_name = 2;
+  if (this->table_name().size() > 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->table_name());
+  }
+
+  // .milvus.grpc.Status status = 1;
+  if (this->has_status()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *status_);
+  }
+
+  // .milvus.grpc.Index index = 3;
+  if (this->has_index()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *index_);
+  }
+
+  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void IndexParam::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.IndexParam)
+  GOOGLE_DCHECK_NE(&from, this);
+  const IndexParam* source =
+      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<IndexParam>(
+          &from);
+  if (source == nullptr) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.IndexParam)
+    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.IndexParam)
+    MergeFrom(*source);
+  }
+}
+
+void IndexParam::MergeFrom(const IndexParam& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.IndexParam)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from.table_name().size() > 0) {
+
+    table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_);
+  }
+  if (from.has_status()) {
+    mutable_status()->::milvus::grpc::Status::MergeFrom(from.status());
+  }
+  if (from.has_index()) {
+    mutable_index()->::milvus::grpc::Index::MergeFrom(from.index());
+  }
+}
+
+void IndexParam::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.IndexParam)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void IndexParam::CopyFrom(const IndexParam& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.IndexParam)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool IndexParam::IsInitialized() const {
+  return true;
+}
+
+void IndexParam::InternalSwap(IndexParam* other) {
+  using std::swap;
+  _internal_metadata_.Swap(&other->_internal_metadata_);
+  table_name_.Swap(&other->table_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+    GetArenaNoVirtual());
+  swap(status_, other->status_);
+  swap(index_, other->index_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata IndexParam::GetMetadata() const {
+  return GetMetadataStatic();
+}
+
+
+// ===================================================================
+
+void DeleteByRangeParam::InitAsDefaultInstance() {
+  ::milvus::grpc::_DeleteByRangeParam_default_instance_._instance.get_mutable()->range_ = const_cast< ::milvus::grpc::Range*>(
+      ::milvus::grpc::Range::internal_default_instance());
+}
+class DeleteByRangeParam::_Internal {
+ public:
+  static const ::milvus::grpc::Range& range(const DeleteByRangeParam* msg);
+};
+
+const ::milvus::grpc::Range&
+DeleteByRangeParam::_Internal::range(const DeleteByRangeParam* msg) {
+  return *msg->range_;
+}
+DeleteByRangeParam::DeleteByRangeParam()
+  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:milvus.grpc.DeleteByRangeParam)
+}
+DeleteByRangeParam::DeleteByRangeParam(const DeleteByRangeParam& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      _internal_metadata_(nullptr) {
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  if (!from.table_name().empty()) {
+    table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_);
+  }
+  if (from.has_range()) {
+    range_ = new ::milvus::grpc::Range(*from.range_);
+  } else {
+    range_ = nullptr;
+  }
+  // @@protoc_insertion_point(copy_constructor:milvus.grpc.DeleteByRangeParam)
+}
+
+void DeleteByRangeParam::SharedCtor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_DeleteByRangeParam_milvus_2eproto.base);
+  table_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  range_ = nullptr;
+}
+
+DeleteByRangeParam::~DeleteByRangeParam() {
+  // @@protoc_insertion_point(destructor:milvus.grpc.DeleteByRangeParam)
+  SharedDtor();
+}
+
+void DeleteByRangeParam::SharedDtor() {
+  table_name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  if (this != internal_default_instance()) delete range_;
+}
+
+void DeleteByRangeParam::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+const DeleteByRangeParam& DeleteByRangeParam::default_instance() {
+  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_DeleteByRangeParam_milvus_2eproto.base);
+  return *internal_default_instance();
+}
+
+
+void DeleteByRangeParam::Clear() {
+// @@protoc_insertion_point(message_clear_start:milvus.grpc.DeleteByRangeParam)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  if (GetArenaNoVirtual() == nullptr && range_ != nullptr) {
+    delete range_;
+  }
+  range_ = nullptr;
+  _internal_metadata_.Clear();
+}
+
+#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+const char* DeleteByRangeParam::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    CHK_(ptr);
+    switch (tag >> 3) {
+      // .milvus.grpc.Range range = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
+          ptr = ctx->ParseMessage(mutable_range(), ptr);
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      // string table_name = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_table_name(), ptr, ctx, "milvus.grpc.DeleteByRangeParam.table_name");
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      default: {
+      handle_unusual:
+        if ((tag & 7) == 4 || tag == 0) {
+          ctx->SetLastTag(tag);
+          goto success;
+        }
+        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
+        CHK_(ptr != nullptr);
+        continue;
+      }
+    }  // switch
+  }  // while
+success:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto success;
+#undef CHK_
+}
+#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+bool DeleteByRangeParam::MergePartialFromCodedStream(
+    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
+  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+  // @@protoc_insertion_point(parse_start:milvus.grpc.DeleteByRangeParam)
+  for (;;) {
+    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // .milvus.grpc.Range range = 1;
+      case 1: {
+        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (10 & 0xFF)) {
+          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadMessage(
+               input, mutable_range()));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      // string table_name = 2;
+      case 2: {
+        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
+          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
+                input, this->mutable_table_name()));
+          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+            this->table_name().data(), static_cast<int>(this->table_name().length()),
+            ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
+            "milvus.grpc.DeleteByRangeParam.table_name"));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0) {
+          goto success;
+        }
+        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
+              input, tag, _internal_metadata_.mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:milvus.grpc.DeleteByRangeParam)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:milvus.grpc.DeleteByRangeParam)
+  return false;
+#undef DO_
+}
+#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+
+void DeleteByRangeParam::SerializeWithCachedSizes(
+    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:milvus.grpc.DeleteByRangeParam)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .milvus.grpc.Range range = 1;
+  if (this->has_range()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, _Internal::range(this), output);
+  }
+
+  // string table_name = 2;
+  if (this->table_name().size() > 0) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->table_name().data(), static_cast<int>(this->table_name().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "milvus.grpc.DeleteByRangeParam.table_name");
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->table_name(), output);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
+        _internal_metadata_.unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:milvus.grpc.DeleteByRangeParam)
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* DeleteByRangeParam::InternalSerializeWithCachedSizesToArray(
+    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.DeleteByRangeParam)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .milvus.grpc.Range range = 1;
+  if (this->has_range()) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+      InternalWriteMessageToArray(
+        1, _Internal::range(this), target);
+  }
+
+  // string table_name = 2;
+  if (this->table_name().size() > 0) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->table_name().data(), static_cast<int>(this->table_name().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "milvus.grpc.DeleteByRangeParam.table_name");
+    target =
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
+        2, this->table_name(), target);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.DeleteByRangeParam)
+  return target;
+}
+
+size_t DeleteByRangeParam::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.DeleteByRangeParam)
+  size_t total_size = 0;
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
+        _internal_metadata_.unknown_fields());
+  }
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // string table_name = 2;
+  if (this->table_name().size() > 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->table_name());
+  }
+
+  // .milvus.grpc.Range range = 1;
+  if (this->has_range()) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+        *range_);
+  }
+
+  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void DeleteByRangeParam::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.DeleteByRangeParam)
+  GOOGLE_DCHECK_NE(&from, this);
+  const DeleteByRangeParam* source =
+      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<DeleteByRangeParam>(
+          &from);
+  if (source == nullptr) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.DeleteByRangeParam)
+    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.DeleteByRangeParam)
+    MergeFrom(*source);
+  }
+}
+
+void DeleteByRangeParam::MergeFrom(const DeleteByRangeParam& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.DeleteByRangeParam)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from.table_name().size() > 0) {
+
+    table_name_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.table_name_);
+  }
+  if (from.has_range()) {
+    mutable_range()->::milvus::grpc::Range::MergeFrom(from.range());
+  }
+}
+
+void DeleteByRangeParam::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.DeleteByRangeParam)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void DeleteByRangeParam::CopyFrom(const DeleteByRangeParam& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.DeleteByRangeParam)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool DeleteByRangeParam::IsInitialized() const {
+  return true;
+}
+
+void DeleteByRangeParam::InternalSwap(DeleteByRangeParam* other) {
+  using std::swap;
+  _internal_metadata_.Swap(&other->_internal_metadata_);
+  table_name_.Swap(&other->table_name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+    GetArenaNoVirtual());
+  swap(range_, other->range_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata DeleteByRangeParam::GetMetadata() const {
+  return GetMetadataStatic();
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+}  // namespace grpc
+}  // namespace milvus
+PROTOBUF_NAMESPACE_OPEN
+template<> PROTOBUF_NOINLINE ::milvus::grpc::TableName* Arena::CreateMaybeMessage< ::milvus::grpc::TableName >(Arena* arena) {
+  return Arena::CreateInternal< ::milvus::grpc::TableName >(arena);
+}
+template<> PROTOBUF_NOINLINE ::milvus::grpc::TableNameList* Arena::CreateMaybeMessage< ::milvus::grpc::TableNameList >(Arena* arena) {
+  return Arena::CreateInternal< ::milvus::grpc::TableNameList >(arena);
+}
+template<> PROTOBUF_NOINLINE ::milvus::grpc::TableSchema* Arena::CreateMaybeMessage< ::milvus::grpc::TableSchema >(Arena* arena) {
+  return Arena::CreateInternal< ::milvus::grpc::TableSchema >(arena);
+}
+template<> PROTOBUF_NOINLINE ::milvus::grpc::Range* Arena::CreateMaybeMessage< ::milvus::grpc::Range >(Arena* arena) {
+  return Arena::CreateInternal< ::milvus::grpc::Range >(arena);
+}
+template<> PROTOBUF_NOINLINE ::milvus::grpc::RowRecord* Arena::CreateMaybeMessage< ::milvus::grpc::RowRecord >(Arena* arena) {
+  return Arena::CreateInternal< ::milvus::grpc::RowRecord >(arena);
+}
+template<> PROTOBUF_NOINLINE ::milvus::grpc::InsertParam* Arena::CreateMaybeMessage< ::milvus::grpc::InsertParam >(Arena* arena) {
+  return Arena::CreateInternal< ::milvus::grpc::InsertParam >(arena);
+}
+template<> PROTOBUF_NOINLINE ::milvus::grpc::VectorIds* Arena::CreateMaybeMessage< ::milvus::grpc::VectorIds >(Arena* arena) {
+  return Arena::CreateInternal< ::milvus::grpc::VectorIds >(arena);
+}
+template<> PROTOBUF_NOINLINE ::milvus::grpc::SearchParam* Arena::CreateMaybeMessage< ::milvus::grpc::SearchParam >(Arena* arena) {
+  return Arena::CreateInternal< ::milvus::grpc::SearchParam >(arena);
+}
+template<> PROTOBUF_NOINLINE ::milvus::grpc::SearchInFilesParam* Arena::CreateMaybeMessage< ::milvus::grpc::SearchInFilesParam >(Arena* arena) {
+  return Arena::CreateInternal< ::milvus::grpc::SearchInFilesParam >(arena);
+}
+template<> PROTOBUF_NOINLINE ::milvus::grpc::QueryResult* Arena::CreateMaybeMessage< ::milvus::grpc::QueryResult >(Arena* arena) {
+  return Arena::CreateInternal< ::milvus::grpc::QueryResult >(arena);
+}
+template<> PROTOBUF_NOINLINE ::milvus::grpc::TopKQueryResult* Arena::CreateMaybeMessage< ::milvus::grpc::TopKQueryResult >(Arena* arena) {
+  return Arena::CreateInternal< ::milvus::grpc::TopKQueryResult >(arena);
+}
+template<> PROTOBUF_NOINLINE ::milvus::grpc::TopKQueryResultList* Arena::CreateMaybeMessage< ::milvus::grpc::TopKQueryResultList >(Arena* arena) {
+  return Arena::CreateInternal< ::milvus::grpc::TopKQueryResultList >(arena);
+}
+template<> PROTOBUF_NOINLINE ::milvus::grpc::StringReply* Arena::CreateMaybeMessage< ::milvus::grpc::StringReply >(Arena* arena) {
+  return Arena::CreateInternal< ::milvus::grpc::StringReply >(arena);
+}
+template<> PROTOBUF_NOINLINE ::milvus::grpc::BoolReply* Arena::CreateMaybeMessage< ::milvus::grpc::BoolReply >(Arena* arena) {
+  return Arena::CreateInternal< ::milvus::grpc::BoolReply >(arena);
+}
+template<> PROTOBUF_NOINLINE ::milvus::grpc::TableRowCount* Arena::CreateMaybeMessage< ::milvus::grpc::TableRowCount >(Arena* arena) {
+  return Arena::CreateInternal< ::milvus::grpc::TableRowCount >(arena);
+}
+template<> PROTOBUF_NOINLINE ::milvus::grpc::Command* Arena::CreateMaybeMessage< ::milvus::grpc::Command >(Arena* arena) {
+  return Arena::CreateInternal< ::milvus::grpc::Command >(arena);
+}
+template<> PROTOBUF_NOINLINE ::milvus::grpc::Index* Arena::CreateMaybeMessage< ::milvus::grpc::Index >(Arena* arena) {
+  return Arena::CreateInternal< ::milvus::grpc::Index >(arena);
+}
+template<> PROTOBUF_NOINLINE ::milvus::grpc::IndexParam* Arena::CreateMaybeMessage< ::milvus::grpc::IndexParam >(Arena* arena) {
+  return Arena::CreateInternal< ::milvus::grpc::IndexParam >(arena);
+}
+template<> PROTOBUF_NOINLINE ::milvus::grpc::DeleteByRangeParam* Arena::CreateMaybeMessage< ::milvus::grpc::DeleteByRangeParam >(Arena* arena) {
+  return Arena::CreateInternal< ::milvus::grpc::DeleteByRangeParam >(arena);
+}
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+#include <google/protobuf/port_undef.inc>
diff --git a/core/src/grpc/gen-milvus/milvus.pb.h b/core/src/grpc/gen-milvus/milvus.pb.h
new file mode 100644
index 0000000000..5ac3fda023
--- /dev/null
+++ b/core/src/grpc/gen-milvus/milvus.pb.h
@@ -0,0 +1,4639 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: milvus.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_milvus_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_milvus_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3009000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3009000 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/inlined_string_field.h>
+#include <google/protobuf/metadata.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+#include "status.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_milvus_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_milvus_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[19]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_milvus_2eproto;
+namespace milvus {
+namespace grpc {
+class BoolReply;
+class BoolReplyDefaultTypeInternal;
+extern BoolReplyDefaultTypeInternal _BoolReply_default_instance_;
+class Command;
+class CommandDefaultTypeInternal;
+extern CommandDefaultTypeInternal _Command_default_instance_;
+class DeleteByRangeParam;
+class DeleteByRangeParamDefaultTypeInternal;
+extern DeleteByRangeParamDefaultTypeInternal _DeleteByRangeParam_default_instance_;
+class Index;
+class IndexDefaultTypeInternal;
+extern IndexDefaultTypeInternal _Index_default_instance_;
+class IndexParam;
+class IndexParamDefaultTypeInternal;
+extern IndexParamDefaultTypeInternal _IndexParam_default_instance_;
+class InsertParam;
+class InsertParamDefaultTypeInternal;
+extern InsertParamDefaultTypeInternal _InsertParam_default_instance_;
+class QueryResult;
+class QueryResultDefaultTypeInternal;
+extern QueryResultDefaultTypeInternal _QueryResult_default_instance_;
+class Range;
+class RangeDefaultTypeInternal;
+extern RangeDefaultTypeInternal _Range_default_instance_;
+class RowRecord;
+class RowRecordDefaultTypeInternal;
+extern RowRecordDefaultTypeInternal _RowRecord_default_instance_;
+class SearchInFilesParam;
+class SearchInFilesParamDefaultTypeInternal;
+extern SearchInFilesParamDefaultTypeInternal _SearchInFilesParam_default_instance_;
+class SearchParam;
+class SearchParamDefaultTypeInternal;
+extern SearchParamDefaultTypeInternal _SearchParam_default_instance_;
+class StringReply;
+class StringReplyDefaultTypeInternal;
+extern StringReplyDefaultTypeInternal _StringReply_default_instance_;
+class TableName;
+class TableNameDefaultTypeInternal;
+extern TableNameDefaultTypeInternal _TableName_default_instance_;
+class TableNameList;
+class TableNameListDefaultTypeInternal;
+extern TableNameListDefaultTypeInternal _TableNameList_default_instance_;
+class TableRowCount;
+class TableRowCountDefaultTypeInternal;
+extern TableRowCountDefaultTypeInternal _TableRowCount_default_instance_;
+class TableSchema;
+class TableSchemaDefaultTypeInternal;
+extern TableSchemaDefaultTypeInternal _TableSchema_default_instance_;
+class TopKQueryResult;
+class TopKQueryResultDefaultTypeInternal;
+extern TopKQueryResultDefaultTypeInternal _TopKQueryResult_default_instance_;
+class TopKQueryResultList;
+class TopKQueryResultListDefaultTypeInternal;
+extern TopKQueryResultListDefaultTypeInternal _TopKQueryResultList_default_instance_;
+class VectorIds;
+class VectorIdsDefaultTypeInternal;
+extern VectorIdsDefaultTypeInternal _VectorIds_default_instance_;
+}  // namespace grpc
+}  // namespace milvus
+PROTOBUF_NAMESPACE_OPEN
+template<> ::milvus::grpc::BoolReply* Arena::CreateMaybeMessage<::milvus::grpc::BoolReply>(Arena*);
+template<> ::milvus::grpc::Command* Arena::CreateMaybeMessage<::milvus::grpc::Command>(Arena*);
+template<> ::milvus::grpc::DeleteByRangeParam* Arena::CreateMaybeMessage<::milvus::grpc::DeleteByRangeParam>(Arena*);
+template<> ::milvus::grpc::Index* Arena::CreateMaybeMessage<::milvus::grpc::Index>(Arena*);
+template<> ::milvus::grpc::IndexParam* Arena::CreateMaybeMessage<::milvus::grpc::IndexParam>(Arena*);
+template<> ::milvus::grpc::InsertParam* Arena::CreateMaybeMessage<::milvus::grpc::InsertParam>(Arena*);
+template<> ::milvus::grpc::QueryResult* Arena::CreateMaybeMessage<::milvus::grpc::QueryResult>(Arena*);
+template<> ::milvus::grpc::Range* Arena::CreateMaybeMessage<::milvus::grpc::Range>(Arena*);
+template<> ::milvus::grpc::RowRecord* Arena::CreateMaybeMessage<::milvus::grpc::RowRecord>(Arena*);
+template<> ::milvus::grpc::SearchInFilesParam* Arena::CreateMaybeMessage<::milvus::grpc::SearchInFilesParam>(Arena*);
+template<> ::milvus::grpc::SearchParam* Arena::CreateMaybeMessage<::milvus::grpc::SearchParam>(Arena*);
+template<> ::milvus::grpc::StringReply* Arena::CreateMaybeMessage<::milvus::grpc::StringReply>(Arena*);
+template<> ::milvus::grpc::TableName* Arena::CreateMaybeMessage<::milvus::grpc::TableName>(Arena*);
+template<> ::milvus::grpc::TableNameList* Arena::CreateMaybeMessage<::milvus::grpc::TableNameList>(Arena*);
+template<> ::milvus::grpc::TableRowCount* Arena::CreateMaybeMessage<::milvus::grpc::TableRowCount>(Arena*);
+template<> ::milvus::grpc::TableSchema* Arena::CreateMaybeMessage<::milvus::grpc::TableSchema>(Arena*);
+template<> ::milvus::grpc::TopKQueryResult* Arena::CreateMaybeMessage<::milvus::grpc::TopKQueryResult>(Arena*);
+template<> ::milvus::grpc::TopKQueryResultList* Arena::CreateMaybeMessage<::milvus::grpc::TopKQueryResultList>(Arena*);
+template<> ::milvus::grpc::VectorIds* Arena::CreateMaybeMessage<::milvus::grpc::VectorIds>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace milvus {
+namespace grpc {
+
+// ===================================================================
+
+class TableName :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.TableName) */ {
+ public:
+  TableName();
+  virtual ~TableName();
+
+  TableName(const TableName& from);
+  TableName(TableName&& from) noexcept
+    : TableName() {
+    *this = ::std::move(from);
+  }
+
+  inline TableName& operator=(const TableName& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline TableName& operator=(TableName&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return GetMetadataStatic().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return GetMetadataStatic().reflection;
+  }
+  static const TableName& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const TableName* internal_default_instance() {
+    return reinterpret_cast<const TableName*>(
+               &_TableName_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(TableName& a, TableName& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(TableName* other) {
+    if (other == this) return;
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline TableName* New() const final {
+    return CreateMaybeMessage<TableName>(nullptr);
+  }
+
+  TableName* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<TableName>(arena);
+  }
+  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void CopyFrom(const TableName& from);
+  void MergeFrom(const TableName& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  #else
+  bool MergePartialFromCodedStream(
+      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
+  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+  void SerializeWithCachedSizes(
+      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  inline void SharedCtor();
+  inline void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(TableName* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "milvus.grpc.TableName";
+  }
+  private:
+  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
+    return nullptr;
+  }
+  inline void* MaybeArenaPtr() const {
+    return nullptr;
+  }
+  public:
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  private:
+  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_milvus_2eproto);
+    return ::descriptor_table_milvus_2eproto.file_level_metadata[kIndexInFileMessages];
+  }
+
+  public:
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTableNameFieldNumber = 1,
+  };
+  // string table_name = 1;
+  void clear_table_name();
+  const std::string& table_name() const;
+  void set_table_name(const std::string& value);
+  void set_table_name(std::string&& value);
+  void set_table_name(const char* value);
+  void set_table_name(const char* value, size_t size);
+  std::string* mutable_table_name();
+  std::string* release_table_name();
+  void set_allocated_table_name(std::string* table_name);
+
+  // @@protoc_insertion_point(class_scope:milvus.grpc.TableName)
+ private:
+  class _Internal;
+
+  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr table_name_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_milvus_2eproto;
+};
+// -------------------------------------------------------------------
+
+class TableNameList :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.TableNameList) */ {
+ public:
+  TableNameList();
+  virtual ~TableNameList();
+
+  TableNameList(const TableNameList& from);
+  TableNameList(TableNameList&& from) noexcept
+    : TableNameList() {
+    *this = ::std::move(from);
+  }
+
+  inline TableNameList& operator=(const TableNameList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline TableNameList& operator=(TableNameList&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return GetMetadataStatic().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return GetMetadataStatic().reflection;
+  }
+  static const TableNameList& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const TableNameList* internal_default_instance() {
+    return reinterpret_cast<const TableNameList*>(
+               &_TableNameList_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(TableNameList& a, TableNameList& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(TableNameList* other) {
+    if (other == this) return;
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline TableNameList* New() const final {
+    return CreateMaybeMessage<TableNameList>(nullptr);
+  }
+
+  TableNameList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<TableNameList>(arena);
+  }
+  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void CopyFrom(const TableNameList& from);
+  void MergeFrom(const TableNameList& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  #else
+  bool MergePartialFromCodedStream(
+      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
+  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+  void SerializeWithCachedSizes(
+      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  inline void SharedCtor();
+  inline void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(TableNameList* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "milvus.grpc.TableNameList";
+  }
+  private:
+  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
+    return nullptr;
+  }
+  inline void* MaybeArenaPtr() const {
+    return nullptr;
+  }
+  public:
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  private:
+  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_milvus_2eproto);
+    return ::descriptor_table_milvus_2eproto.file_level_metadata[kIndexInFileMessages];
+  }
+
+  public:
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTableNamesFieldNumber = 2,
+    kStatusFieldNumber = 1,
+  };
+  // repeated string table_names = 2;
+  int table_names_size() const;
+  void clear_table_names();
+  const std::string& table_names(int index) const;
+  std::string* mutable_table_names(int index);
+  void set_table_names(int index, const std::string& value);
+  void set_table_names(int index, std::string&& value);
+  void set_table_names(int index, const char* value);
+  void set_table_names(int index, const char* value, size_t size);
+  std::string* add_table_names();
+  void add_table_names(const std::string& value);
+  void add_table_names(std::string&& value);
+  void add_table_names(const char* value);
+  void add_table_names(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& table_names() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_table_names();
+
+  // .milvus.grpc.Status status = 1;
+  bool has_status() const;
+  void clear_status();
+  const ::milvus::grpc::Status& status() const;
+  ::milvus::grpc::Status* release_status();
+  ::milvus::grpc::Status* mutable_status();
+  void set_allocated_status(::milvus::grpc::Status* status);
+
+  // @@protoc_insertion_point(class_scope:milvus.grpc.TableNameList)
+ private:
+  class _Internal;
+
+  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> table_names_;
+  ::milvus::grpc::Status* status_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_milvus_2eproto;
+};
+// -------------------------------------------------------------------
+
+class TableSchema :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.TableSchema) */ {
+ public:
+  TableSchema();
+  virtual ~TableSchema();
+
+  TableSchema(const TableSchema& from);
+  TableSchema(TableSchema&& from) noexcept
+    : TableSchema() {
+    *this = ::std::move(from);
+  }
+
+  inline TableSchema& operator=(const TableSchema& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline TableSchema& operator=(TableSchema&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return GetMetadataStatic().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return GetMetadataStatic().reflection;
+  }
+  static const TableSchema& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const TableSchema* internal_default_instance() {
+    return reinterpret_cast<const TableSchema*>(
+               &_TableSchema_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(TableSchema& a, TableSchema& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(TableSchema* other) {
+    if (other == this) return;
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline TableSchema* New() const final {
+    return CreateMaybeMessage<TableSchema>(nullptr);
+  }
+
+  TableSchema* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<TableSchema>(arena);
+  }
+  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void CopyFrom(const TableSchema& from);
+  void MergeFrom(const TableSchema& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  #else
+  bool MergePartialFromCodedStream(
+      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
+  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+  void SerializeWithCachedSizes(
+      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  inline void SharedCtor();
+  inline void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(TableSchema* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "milvus.grpc.TableSchema";
+  }
+  private:
+  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
+    return nullptr;
+  }
+  inline void* MaybeArenaPtr() const {
+    return nullptr;
+  }
+  public:
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  private:
+  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_milvus_2eproto);
+    return ::descriptor_table_milvus_2eproto.file_level_metadata[kIndexInFileMessages];
+  }
+
+  public:
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTableNameFieldNumber = 2,
+    kStatusFieldNumber = 1,
+    kDimensionFieldNumber = 3,
+    kIndexFileSizeFieldNumber = 4,
+    kMetricTypeFieldNumber = 5,
+  };
+  // string table_name = 2;
+  void clear_table_name();
+  const std::string& table_name() const;
+  void set_table_name(const std::string& value);
+  void set_table_name(std::string&& value);
+  void set_table_name(const char* value);
+  void set_table_name(const char* value, size_t size);
+  std::string* mutable_table_name();
+  std::string* release_table_name();
+  void set_allocated_table_name(std::string* table_name);
+
+  // .milvus.grpc.Status status = 1;
+  bool has_status() const;
+  void clear_status();
+  const ::milvus::grpc::Status& status() const;
+  ::milvus::grpc::Status* release_status();
+  ::milvus::grpc::Status* mutable_status();
+  void set_allocated_status(::milvus::grpc::Status* status);
+
+  // int64 dimension = 3;
+  void clear_dimension();
+  ::PROTOBUF_NAMESPACE_ID::int64 dimension() const;
+  void set_dimension(::PROTOBUF_NAMESPACE_ID::int64 value);
+
+  // int64 index_file_size = 4;
+  void clear_index_file_size();
+  ::PROTOBUF_NAMESPACE_ID::int64 index_file_size() const;
+  void set_index_file_size(::PROTOBUF_NAMESPACE_ID::int64 value);
+
+  // int32 metric_type = 5;
+  void clear_metric_type();
+  ::PROTOBUF_NAMESPACE_ID::int32 metric_type() const;
+  void set_metric_type(::PROTOBUF_NAMESPACE_ID::int32 value);
+
+  // @@protoc_insertion_point(class_scope:milvus.grpc.TableSchema)
+ private:
+  class _Internal;
+
+  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr table_name_;
+  ::milvus::grpc::Status* status_;
+  ::PROTOBUF_NAMESPACE_ID::int64 dimension_;
+  ::PROTOBUF_NAMESPACE_ID::int64 index_file_size_;
+  ::PROTOBUF_NAMESPACE_ID::int32 metric_type_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_milvus_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Range :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.Range) */ {
+ public:
+  Range();
+  virtual ~Range();
+
+  Range(const Range& from);
+  Range(Range&& from) noexcept
+    : Range() {
+    *this = ::std::move(from);
+  }
+
+  inline Range& operator=(const Range& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Range& operator=(Range&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return GetMetadataStatic().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return GetMetadataStatic().reflection;
+  }
+  static const Range& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Range* internal_default_instance() {
+    return reinterpret_cast<const Range*>(
+               &_Range_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(Range& a, Range& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Range* other) {
+    if (other == this) return;
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Range* New() const final {
+    return CreateMaybeMessage<Range>(nullptr);
+  }
+
+  Range* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<Range>(arena);
+  }
+  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void CopyFrom(const Range& from);
+  void MergeFrom(const Range& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  #else
+  bool MergePartialFromCodedStream(
+      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
+  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+  void SerializeWithCachedSizes(
+      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  inline void SharedCtor();
+  inline void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Range* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "milvus.grpc.Range";
+  }
+  private:
+  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
+    return nullptr;
+  }
+  inline void* MaybeArenaPtr() const {
+    return nullptr;
+  }
+  public:
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  private:
+  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_milvus_2eproto);
+    return ::descriptor_table_milvus_2eproto.file_level_metadata[kIndexInFileMessages];
+  }
+
+  public:
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kStartValueFieldNumber = 1,
+    kEndValueFieldNumber = 2,
+  };
+  // string start_value = 1;
+  void clear_start_value();
+  const std::string& start_value() const;
+  void set_start_value(const std::string& value);
+  void set_start_value(std::string&& value);
+  void set_start_value(const char* value);
+  void set_start_value(const char* value, size_t size);
+  std::string* mutable_start_value();
+  std::string* release_start_value();
+  void set_allocated_start_value(std::string* start_value);
+
+  // string end_value = 2;
+  void clear_end_value();
+  const std::string& end_value() const;
+  void set_end_value(const std::string& value);
+  void set_end_value(std::string&& value);
+  void set_end_value(const char* value);
+  void set_end_value(const char* value, size_t size);
+  std::string* mutable_end_value();
+  std::string* release_end_value();
+  void set_allocated_end_value(std::string* end_value);
+
+  // @@protoc_insertion_point(class_scope:milvus.grpc.Range)
+ private:
+  class _Internal;
+
+  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr start_value_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr end_value_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_milvus_2eproto;
+};
+// -------------------------------------------------------------------
+
+class RowRecord :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.RowRecord) */ {
+ public:
+  RowRecord();
+  virtual ~RowRecord();
+
+  RowRecord(const RowRecord& from);
+  RowRecord(RowRecord&& from) noexcept
+    : RowRecord() {
+    *this = ::std::move(from);
+  }
+
+  inline RowRecord& operator=(const RowRecord& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline RowRecord& operator=(RowRecord&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return GetMetadataStatic().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return GetMetadataStatic().reflection;
+  }
+  static const RowRecord& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const RowRecord* internal_default_instance() {
+    return reinterpret_cast<const RowRecord*>(
+               &_RowRecord_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  friend void swap(RowRecord& a, RowRecord& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(RowRecord* other) {
+    if (other == this) return;
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline RowRecord* New() const final {
+    return CreateMaybeMessage<RowRecord>(nullptr);
+  }
+
+  RowRecord* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<RowRecord>(arena);
+  }
+  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void CopyFrom(const RowRecord& from);
+  void MergeFrom(const RowRecord& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  #else
+  bool MergePartialFromCodedStream(
+      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
+  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+  void SerializeWithCachedSizes(
+      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  inline void SharedCtor();
+  inline void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(RowRecord* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "milvus.grpc.RowRecord";
+  }
+  private:
+  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
+    return nullptr;
+  }
+  inline void* MaybeArenaPtr() const {
+    return nullptr;
+  }
+  public:
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  private:
+  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_milvus_2eproto);
+    return ::descriptor_table_milvus_2eproto.file_level_metadata[kIndexInFileMessages];
+  }
+
+  public:
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kVectorDataFieldNumber = 1,
+  };
+  // repeated float vector_data = 1;
+  int vector_data_size() const;
+  void clear_vector_data();
+  float vector_data(int index) const;
+  void set_vector_data(int index, float value);
+  void add_vector_data(float value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
+      vector_data() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
+      mutable_vector_data();
+
+  // @@protoc_insertion_point(class_scope:milvus.grpc.RowRecord)
+ private:
+  class _Internal;
+
+  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > vector_data_;
+  mutable std::atomic<int> _vector_data_cached_byte_size_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_milvus_2eproto;
+};
+// -------------------------------------------------------------------
+
+class InsertParam :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.InsertParam) */ {
+ public:
+  InsertParam();
+  virtual ~InsertParam();
+
+  InsertParam(const InsertParam& from);
+  InsertParam(InsertParam&& from) noexcept
+    : InsertParam() {
+    *this = ::std::move(from);
+  }
+
+  inline InsertParam& operator=(const InsertParam& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline InsertParam& operator=(InsertParam&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return GetMetadataStatic().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return GetMetadataStatic().reflection;
+  }
+  static const InsertParam& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const InsertParam* internal_default_instance() {
+    return reinterpret_cast<const InsertParam*>(
+               &_InsertParam_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    5;
+
+  friend void swap(InsertParam& a, InsertParam& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(InsertParam* other) {
+    if (other == this) return;
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline InsertParam* New() const final {
+    return CreateMaybeMessage<InsertParam>(nullptr);
+  }
+
+  InsertParam* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<InsertParam>(arena);
+  }
+  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void CopyFrom(const InsertParam& from);
+  void MergeFrom(const InsertParam& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  #else
+  bool MergePartialFromCodedStream(
+      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
+  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+  void SerializeWithCachedSizes(
+      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  inline void SharedCtor();
+  inline void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(InsertParam* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "milvus.grpc.InsertParam";
+  }
+  private:
+  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
+    return nullptr;
+  }
+  inline void* MaybeArenaPtr() const {
+    return nullptr;
+  }
+  public:
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  private:
+  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_milvus_2eproto);
+    return ::descriptor_table_milvus_2eproto.file_level_metadata[kIndexInFileMessages];
+  }
+
+  public:
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kRowRecordArrayFieldNumber = 2,
+    kRowIdArrayFieldNumber = 3,
+    kTableNameFieldNumber = 1,
+  };
+  // repeated .milvus.grpc.RowRecord row_record_array = 2;
+  int row_record_array_size() const;
+  void clear_row_record_array();
+  ::milvus::grpc::RowRecord* mutable_row_record_array(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowRecord >*
+      mutable_row_record_array();
+  const ::milvus::grpc::RowRecord& row_record_array(int index) const;
+  ::milvus::grpc::RowRecord* add_row_record_array();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowRecord >&
+      row_record_array() const;
+
+  // repeated int64 row_id_array = 3;
+  int row_id_array_size() const;
+  void clear_row_id_array();
+  ::PROTOBUF_NAMESPACE_ID::int64 row_id_array(int index) const;
+  void set_row_id_array(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
+  void add_row_id_array(::PROTOBUF_NAMESPACE_ID::int64 value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
+      row_id_array() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
+      mutable_row_id_array();
+
+  // string table_name = 1;
+  void clear_table_name();
+  const std::string& table_name() const;
+  void set_table_name(const std::string& value);
+  void set_table_name(std::string&& value);
+  void set_table_name(const char* value);
+  void set_table_name(const char* value, size_t size);
+  std::string* mutable_table_name();
+  std::string* release_table_name();
+  void set_allocated_table_name(std::string* table_name);
+
+  // @@protoc_insertion_point(class_scope:milvus.grpc.InsertParam)
+ private:
+  class _Internal;
+
+  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowRecord > row_record_array_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > row_id_array_;
+  mutable std::atomic<int> _row_id_array_cached_byte_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr table_name_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_milvus_2eproto;
+};
+// -------------------------------------------------------------------
+
+class VectorIds :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.VectorIds) */ {
+ public:
+  VectorIds();
+  virtual ~VectorIds();
+
+  VectorIds(const VectorIds& from);
+  VectorIds(VectorIds&& from) noexcept
+    : VectorIds() {
+    *this = ::std::move(from);
+  }
+
+  inline VectorIds& operator=(const VectorIds& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline VectorIds& operator=(VectorIds&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return GetMetadataStatic().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return GetMetadataStatic().reflection;
+  }
+  static const VectorIds& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const VectorIds* internal_default_instance() {
+    return reinterpret_cast<const VectorIds*>(
+               &_VectorIds_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    6;
+
+  friend void swap(VectorIds& a, VectorIds& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(VectorIds* other) {
+    if (other == this) return;
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline VectorIds* New() const final {
+    return CreateMaybeMessage<VectorIds>(nullptr);
+  }
+
+  VectorIds* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<VectorIds>(arena);
+  }
+  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void CopyFrom(const VectorIds& from);
+  void MergeFrom(const VectorIds& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  #else
+  bool MergePartialFromCodedStream(
+      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
+  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+  void SerializeWithCachedSizes(
+      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  inline void SharedCtor();
+  inline void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(VectorIds* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "milvus.grpc.VectorIds";
+  }
+  private:
+  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
+    return nullptr;
+  }
+  inline void* MaybeArenaPtr() const {
+    return nullptr;
+  }
+  public:
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  private:
+  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_milvus_2eproto);
+    return ::descriptor_table_milvus_2eproto.file_level_metadata[kIndexInFileMessages];
+  }
+
+  public:
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kVectorIdArrayFieldNumber = 2,
+    kStatusFieldNumber = 1,
+  };
+  // repeated int64 vector_id_array = 2;
+  int vector_id_array_size() const;
+  void clear_vector_id_array();
+  ::PROTOBUF_NAMESPACE_ID::int64 vector_id_array(int index) const;
+  void set_vector_id_array(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
+  void add_vector_id_array(::PROTOBUF_NAMESPACE_ID::int64 value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
+      vector_id_array() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
+      mutable_vector_id_array();
+
+  // .milvus.grpc.Status status = 1;
+  bool has_status() const;
+  void clear_status();
+  const ::milvus::grpc::Status& status() const;
+  ::milvus::grpc::Status* release_status();
+  ::milvus::grpc::Status* mutable_status();
+  void set_allocated_status(::milvus::grpc::Status* status);
+
+  // @@protoc_insertion_point(class_scope:milvus.grpc.VectorIds)
+ private:
+  class _Internal;
+
+  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > vector_id_array_;
+  mutable std::atomic<int> _vector_id_array_cached_byte_size_;
+  ::milvus::grpc::Status* status_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_milvus_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SearchParam :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.SearchParam) */ {
+ public:
+  SearchParam();
+  virtual ~SearchParam();
+
+  SearchParam(const SearchParam& from);
+  SearchParam(SearchParam&& from) noexcept
+    : SearchParam() {
+    *this = ::std::move(from);
+  }
+
+  inline SearchParam& operator=(const SearchParam& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SearchParam& operator=(SearchParam&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return GetMetadataStatic().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return GetMetadataStatic().reflection;
+  }
+  static const SearchParam& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SearchParam* internal_default_instance() {
+    return reinterpret_cast<const SearchParam*>(
+               &_SearchParam_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    7;
+
+  friend void swap(SearchParam& a, SearchParam& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SearchParam* other) {
+    if (other == this) return;
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SearchParam* New() const final {
+    return CreateMaybeMessage<SearchParam>(nullptr);
+  }
+
+  SearchParam* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<SearchParam>(arena);
+  }
+  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void CopyFrom(const SearchParam& from);
+  void MergeFrom(const SearchParam& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  #else
+  bool MergePartialFromCodedStream(
+      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
+  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+  void SerializeWithCachedSizes(
+      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  inline void SharedCtor();
+  inline void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SearchParam* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "milvus.grpc.SearchParam";
+  }
+  private:
+  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
+    return nullptr;
+  }
+  inline void* MaybeArenaPtr() const {
+    return nullptr;
+  }
+  public:
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  private:
+  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_milvus_2eproto);
+    return ::descriptor_table_milvus_2eproto.file_level_metadata[kIndexInFileMessages];
+  }
+
+  public:
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kQueryRecordArrayFieldNumber = 2,
+    kQueryRangeArrayFieldNumber = 3,
+    kTableNameFieldNumber = 1,
+    kTopkFieldNumber = 4,
+    kNprobeFieldNumber = 5,
+  };
+  // repeated .milvus.grpc.RowRecord query_record_array = 2;
+  int query_record_array_size() const;
+  void clear_query_record_array();
+  ::milvus::grpc::RowRecord* mutable_query_record_array(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowRecord >*
+      mutable_query_record_array();
+  const ::milvus::grpc::RowRecord& query_record_array(int index) const;
+  ::milvus::grpc::RowRecord* add_query_record_array();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowRecord >&
+      query_record_array() const;
+
+  // repeated .milvus.grpc.Range query_range_array = 3;
+  int query_range_array_size() const;
+  void clear_query_range_array();
+  ::milvus::grpc::Range* mutable_query_range_array(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::Range >*
+      mutable_query_range_array();
+  const ::milvus::grpc::Range& query_range_array(int index) const;
+  ::milvus::grpc::Range* add_query_range_array();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::Range >&
+      query_range_array() const;
+
+  // string table_name = 1;
+  void clear_table_name();
+  const std::string& table_name() const;
+  void set_table_name(const std::string& value);
+  void set_table_name(std::string&& value);
+  void set_table_name(const char* value);
+  void set_table_name(const char* value, size_t size);
+  std::string* mutable_table_name();
+  std::string* release_table_name();
+  void set_allocated_table_name(std::string* table_name);
+
+  // int64 topk = 4;
+  void clear_topk();
+  ::PROTOBUF_NAMESPACE_ID::int64 topk() const;
+  void set_topk(::PROTOBUF_NAMESPACE_ID::int64 value);
+
+  // int64 nprobe = 5;
+  void clear_nprobe();
+  ::PROTOBUF_NAMESPACE_ID::int64 nprobe() const;
+  void set_nprobe(::PROTOBUF_NAMESPACE_ID::int64 value);
+
+  // @@protoc_insertion_point(class_scope:milvus.grpc.SearchParam)
+ private:
+  class _Internal;
+
+  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowRecord > query_record_array_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::Range > query_range_array_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr table_name_;
+  ::PROTOBUF_NAMESPACE_ID::int64 topk_;
+  ::PROTOBUF_NAMESPACE_ID::int64 nprobe_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_milvus_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SearchInFilesParam :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.SearchInFilesParam) */ {
+ public:
+  SearchInFilesParam();
+  virtual ~SearchInFilesParam();
+
+  SearchInFilesParam(const SearchInFilesParam& from);
+  SearchInFilesParam(SearchInFilesParam&& from) noexcept
+    : SearchInFilesParam() {
+    *this = ::std::move(from);
+  }
+
+  inline SearchInFilesParam& operator=(const SearchInFilesParam& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SearchInFilesParam& operator=(SearchInFilesParam&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return GetMetadataStatic().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return GetMetadataStatic().reflection;
+  }
+  static const SearchInFilesParam& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SearchInFilesParam* internal_default_instance() {
+    return reinterpret_cast<const SearchInFilesParam*>(
+               &_SearchInFilesParam_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    8;
+
+  friend void swap(SearchInFilesParam& a, SearchInFilesParam& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SearchInFilesParam* other) {
+    if (other == this) return;
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SearchInFilesParam* New() const final {
+    return CreateMaybeMessage<SearchInFilesParam>(nullptr);
+  }
+
+  SearchInFilesParam* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<SearchInFilesParam>(arena);
+  }
+  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void CopyFrom(const SearchInFilesParam& from);
+  void MergeFrom(const SearchInFilesParam& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  #else
+  bool MergePartialFromCodedStream(
+      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
+  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+  void SerializeWithCachedSizes(
+      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  inline void SharedCtor();
+  inline void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SearchInFilesParam* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "milvus.grpc.SearchInFilesParam";
+  }
+  private:
+  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
+    return nullptr;
+  }
+  inline void* MaybeArenaPtr() const {
+    return nullptr;
+  }
+  public:
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  private:
+  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_milvus_2eproto);
+    return ::descriptor_table_milvus_2eproto.file_level_metadata[kIndexInFileMessages];
+  }
+
+  public:
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kFileIdArrayFieldNumber = 1,
+    kSearchParamFieldNumber = 2,
+  };
+  // repeated string file_id_array = 1;
+  int file_id_array_size() const;
+  void clear_file_id_array();
+  const std::string& file_id_array(int index) const;
+  std::string* mutable_file_id_array(int index);
+  void set_file_id_array(int index, const std::string& value);
+  void set_file_id_array(int index, std::string&& value);
+  void set_file_id_array(int index, const char* value);
+  void set_file_id_array(int index, const char* value, size_t size);
+  std::string* add_file_id_array();
+  void add_file_id_array(const std::string& value);
+  void add_file_id_array(std::string&& value);
+  void add_file_id_array(const char* value);
+  void add_file_id_array(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& file_id_array() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_file_id_array();
+
+  // .milvus.grpc.SearchParam search_param = 2;
+  bool has_search_param() const;
+  void clear_search_param();
+  const ::milvus::grpc::SearchParam& search_param() const;
+  ::milvus::grpc::SearchParam* release_search_param();
+  ::milvus::grpc::SearchParam* mutable_search_param();
+  void set_allocated_search_param(::milvus::grpc::SearchParam* search_param);
+
+  // @@protoc_insertion_point(class_scope:milvus.grpc.SearchInFilesParam)
+ private:
+  class _Internal;
+
+  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> file_id_array_;
+  ::milvus::grpc::SearchParam* search_param_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_milvus_2eproto;
+};
+// -------------------------------------------------------------------
+
+class QueryResult :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.QueryResult) */ {
+ public:
+  QueryResult();
+  virtual ~QueryResult();
+
+  QueryResult(const QueryResult& from);
+  QueryResult(QueryResult&& from) noexcept
+    : QueryResult() {
+    *this = ::std::move(from);
+  }
+
+  inline QueryResult& operator=(const QueryResult& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline QueryResult& operator=(QueryResult&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return GetMetadataStatic().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return GetMetadataStatic().reflection;
+  }
+  static const QueryResult& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const QueryResult* internal_default_instance() {
+    return reinterpret_cast<const QueryResult*>(
+               &_QueryResult_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    9;
+
+  friend void swap(QueryResult& a, QueryResult& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(QueryResult* other) {
+    if (other == this) return;
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline QueryResult* New() const final {
+    return CreateMaybeMessage<QueryResult>(nullptr);
+  }
+
+  QueryResult* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<QueryResult>(arena);
+  }
+  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void CopyFrom(const QueryResult& from);
+  void MergeFrom(const QueryResult& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  #else
+  bool MergePartialFromCodedStream(
+      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
+  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+  void SerializeWithCachedSizes(
+      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  inline void SharedCtor();
+  inline void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(QueryResult* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "milvus.grpc.QueryResult";
+  }
+  private:
+  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
+    return nullptr;
+  }
+  inline void* MaybeArenaPtr() const {
+    return nullptr;
+  }
+  public:
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  private:
+  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_milvus_2eproto);
+    return ::descriptor_table_milvus_2eproto.file_level_metadata[kIndexInFileMessages];
+  }
+
+  public:
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kIdFieldNumber = 1,
+    kDistanceFieldNumber = 2,
+  };
+  // int64 id = 1;
+  void clear_id();
+  ::PROTOBUF_NAMESPACE_ID::int64 id() const;
+  void set_id(::PROTOBUF_NAMESPACE_ID::int64 value);
+
+  // double distance = 2;
+  void clear_distance();
+  double distance() const;
+  void set_distance(double value);
+
+  // @@protoc_insertion_point(class_scope:milvus.grpc.QueryResult)
+ private:
+  class _Internal;
+
+  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+  ::PROTOBUF_NAMESPACE_ID::int64 id_;
+  double distance_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_milvus_2eproto;
+};
+// -------------------------------------------------------------------
+
+class TopKQueryResult :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.TopKQueryResult) */ {
+ public:
+  TopKQueryResult();
+  virtual ~TopKQueryResult();
+
+  TopKQueryResult(const TopKQueryResult& from);
+  TopKQueryResult(TopKQueryResult&& from) noexcept
+    : TopKQueryResult() {
+    *this = ::std::move(from);
+  }
+
+  inline TopKQueryResult& operator=(const TopKQueryResult& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline TopKQueryResult& operator=(TopKQueryResult&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return GetMetadataStatic().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return GetMetadataStatic().reflection;
+  }
+  static const TopKQueryResult& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const TopKQueryResult* internal_default_instance() {
+    return reinterpret_cast<const TopKQueryResult*>(
+               &_TopKQueryResult_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    10;
+
+  friend void swap(TopKQueryResult& a, TopKQueryResult& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(TopKQueryResult* other) {
+    if (other == this) return;
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline TopKQueryResult* New() const final {
+    return CreateMaybeMessage<TopKQueryResult>(nullptr);
+  }
+
+  TopKQueryResult* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<TopKQueryResult>(arena);
+  }
+  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void CopyFrom(const TopKQueryResult& from);
+  void MergeFrom(const TopKQueryResult& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  #else
+  bool MergePartialFromCodedStream(
+      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
+  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+  void SerializeWithCachedSizes(
+      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  inline void SharedCtor();
+  inline void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(TopKQueryResult* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "milvus.grpc.TopKQueryResult";
+  }
+  private:
+  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
+    return nullptr;
+  }
+  inline void* MaybeArenaPtr() const {
+    return nullptr;
+  }
+  public:
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  private:
+  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_milvus_2eproto);
+    return ::descriptor_table_milvus_2eproto.file_level_metadata[kIndexInFileMessages];
+  }
+
+  public:
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kQueryResultArraysFieldNumber = 1,
+  };
+  // repeated .milvus.grpc.QueryResult query_result_arrays = 1;
+  int query_result_arrays_size() const;
+  void clear_query_result_arrays();
+  ::milvus::grpc::QueryResult* mutable_query_result_arrays(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::QueryResult >*
+      mutable_query_result_arrays();
+  const ::milvus::grpc::QueryResult& query_result_arrays(int index) const;
+  ::milvus::grpc::QueryResult* add_query_result_arrays();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::QueryResult >&
+      query_result_arrays() const;
+
+  // @@protoc_insertion_point(class_scope:milvus.grpc.TopKQueryResult)
+ private:
+  class _Internal;
+
+  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::QueryResult > query_result_arrays_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_milvus_2eproto;
+};
+// -------------------------------------------------------------------
+
+class TopKQueryResultList :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.TopKQueryResultList) */ {
+ public:
+  TopKQueryResultList();
+  virtual ~TopKQueryResultList();
+
+  TopKQueryResultList(const TopKQueryResultList& from);
+  TopKQueryResultList(TopKQueryResultList&& from) noexcept
+    : TopKQueryResultList() {
+    *this = ::std::move(from);
+  }
+
+  inline TopKQueryResultList& operator=(const TopKQueryResultList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline TopKQueryResultList& operator=(TopKQueryResultList&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return GetMetadataStatic().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return GetMetadataStatic().reflection;
+  }
+  static const TopKQueryResultList& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const TopKQueryResultList* internal_default_instance() {
+    return reinterpret_cast<const TopKQueryResultList*>(
+               &_TopKQueryResultList_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    11;
+
+  friend void swap(TopKQueryResultList& a, TopKQueryResultList& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(TopKQueryResultList* other) {
+    if (other == this) return;
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline TopKQueryResultList* New() const final {
+    return CreateMaybeMessage<TopKQueryResultList>(nullptr);
+  }
+
+  TopKQueryResultList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<TopKQueryResultList>(arena);
+  }
+  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void CopyFrom(const TopKQueryResultList& from);
+  void MergeFrom(const TopKQueryResultList& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  #else
+  bool MergePartialFromCodedStream(
+      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
+  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+  void SerializeWithCachedSizes(
+      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  inline void SharedCtor();
+  inline void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(TopKQueryResultList* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "milvus.grpc.TopKQueryResultList";
+  }
+  private:
+  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
+    return nullptr;
+  }
+  inline void* MaybeArenaPtr() const {
+    return nullptr;
+  }
+  public:
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  private:
+  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_milvus_2eproto);
+    return ::descriptor_table_milvus_2eproto.file_level_metadata[kIndexInFileMessages];
+  }
+
+  public:
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTopkQueryResultFieldNumber = 2,
+    kStatusFieldNumber = 1,
+  };
+  // repeated .milvus.grpc.TopKQueryResult topk_query_result = 2;
+  int topk_query_result_size() const;
+  void clear_topk_query_result();
+  ::milvus::grpc::TopKQueryResult* mutable_topk_query_result(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::TopKQueryResult >*
+      mutable_topk_query_result();
+  const ::milvus::grpc::TopKQueryResult& topk_query_result(int index) const;
+  ::milvus::grpc::TopKQueryResult* add_topk_query_result();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::TopKQueryResult >&
+      topk_query_result() const;
+
+  // .milvus.grpc.Status status = 1;
+  bool has_status() const;
+  void clear_status();
+  const ::milvus::grpc::Status& status() const;
+  ::milvus::grpc::Status* release_status();
+  ::milvus::grpc::Status* mutable_status();
+  void set_allocated_status(::milvus::grpc::Status* status);
+
+  // @@protoc_insertion_point(class_scope:milvus.grpc.TopKQueryResultList)
+ private:
+  class _Internal;
+
+  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::TopKQueryResult > topk_query_result_;
+  ::milvus::grpc::Status* status_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_milvus_2eproto;
+};
+// -------------------------------------------------------------------
+
+class StringReply :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.StringReply) */ {
+ public:
+  StringReply();
+  virtual ~StringReply();
+
+  StringReply(const StringReply& from);
+  StringReply(StringReply&& from) noexcept
+    : StringReply() {
+    *this = ::std::move(from);
+  }
+
+  inline StringReply& operator=(const StringReply& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline StringReply& operator=(StringReply&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return GetMetadataStatic().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return GetMetadataStatic().reflection;
+  }
+  static const StringReply& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const StringReply* internal_default_instance() {
+    return reinterpret_cast<const StringReply*>(
+               &_StringReply_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    12;
+
+  friend void swap(StringReply& a, StringReply& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(StringReply* other) {
+    if (other == this) return;
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline StringReply* New() const final {
+    return CreateMaybeMessage<StringReply>(nullptr);
+  }
+
+  StringReply* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<StringReply>(arena);
+  }
+  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void CopyFrom(const StringReply& from);
+  void MergeFrom(const StringReply& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  #else
+  bool MergePartialFromCodedStream(
+      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
+  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+  void SerializeWithCachedSizes(
+      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  inline void SharedCtor();
+  inline void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(StringReply* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "milvus.grpc.StringReply";
+  }
+  private:
+  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
+    return nullptr;
+  }
+  inline void* MaybeArenaPtr() const {
+    return nullptr;
+  }
+  public:
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  private:
+  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_milvus_2eproto);
+    return ::descriptor_table_milvus_2eproto.file_level_metadata[kIndexInFileMessages];
+  }
+
+  public:
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kStringReplyFieldNumber = 2,
+    kStatusFieldNumber = 1,
+  };
+  // string string_reply = 2;
+  void clear_string_reply();
+  const std::string& string_reply() const;
+  void set_string_reply(const std::string& value);
+  void set_string_reply(std::string&& value);
+  void set_string_reply(const char* value);
+  void set_string_reply(const char* value, size_t size);
+  std::string* mutable_string_reply();
+  std::string* release_string_reply();
+  void set_allocated_string_reply(std::string* string_reply);
+
+  // .milvus.grpc.Status status = 1;
+  bool has_status() const;
+  void clear_status();
+  const ::milvus::grpc::Status& status() const;
+  ::milvus::grpc::Status* release_status();
+  ::milvus::grpc::Status* mutable_status();
+  void set_allocated_status(::milvus::grpc::Status* status);
+
+  // @@protoc_insertion_point(class_scope:milvus.grpc.StringReply)
+ private:
+  class _Internal;
+
+  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr string_reply_;
+  ::milvus::grpc::Status* status_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_milvus_2eproto;
+};
+// -------------------------------------------------------------------
+
+class BoolReply :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.BoolReply) */ {
+ public:
+  BoolReply();
+  virtual ~BoolReply();
+
+  BoolReply(const BoolReply& from);
+  BoolReply(BoolReply&& from) noexcept
+    : BoolReply() {
+    *this = ::std::move(from);
+  }
+
+  inline BoolReply& operator=(const BoolReply& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline BoolReply& operator=(BoolReply&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return GetMetadataStatic().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return GetMetadataStatic().reflection;
+  }
+  static const BoolReply& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const BoolReply* internal_default_instance() {
+    return reinterpret_cast<const BoolReply*>(
+               &_BoolReply_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    13;
+
+  friend void swap(BoolReply& a, BoolReply& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(BoolReply* other) {
+    if (other == this) return;
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline BoolReply* New() const final {
+    return CreateMaybeMessage<BoolReply>(nullptr);
+  }
+
+  BoolReply* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<BoolReply>(arena);
+  }
+  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void CopyFrom(const BoolReply& from);
+  void MergeFrom(const BoolReply& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  #else
+  bool MergePartialFromCodedStream(
+      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
+  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+  void SerializeWithCachedSizes(
+      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  inline void SharedCtor();
+  inline void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(BoolReply* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "milvus.grpc.BoolReply";
+  }
+  private:
+  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
+    return nullptr;
+  }
+  inline void* MaybeArenaPtr() const {
+    return nullptr;
+  }
+  public:
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  private:
+  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_milvus_2eproto);
+    return ::descriptor_table_milvus_2eproto.file_level_metadata[kIndexInFileMessages];
+  }
+
+  public:
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kStatusFieldNumber = 1,
+    kBoolReplyFieldNumber = 2,
+  };
+  // .milvus.grpc.Status status = 1;
+  bool has_status() const;
+  void clear_status();
+  const ::milvus::grpc::Status& status() const;
+  ::milvus::grpc::Status* release_status();
+  ::milvus::grpc::Status* mutable_status();
+  void set_allocated_status(::milvus::grpc::Status* status);
+
+  // bool bool_reply = 2;
+  void clear_bool_reply();
+  bool bool_reply() const;
+  void set_bool_reply(bool value);
+
+  // @@protoc_insertion_point(class_scope:milvus.grpc.BoolReply)
+ private:
+  class _Internal;
+
+  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+  ::milvus::grpc::Status* status_;
+  bool bool_reply_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_milvus_2eproto;
+};
+// -------------------------------------------------------------------
+
+class TableRowCount :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.TableRowCount) */ {
+ public:
+  TableRowCount();
+  virtual ~TableRowCount();
+
+  TableRowCount(const TableRowCount& from);
+  TableRowCount(TableRowCount&& from) noexcept
+    : TableRowCount() {
+    *this = ::std::move(from);
+  }
+
+  inline TableRowCount& operator=(const TableRowCount& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline TableRowCount& operator=(TableRowCount&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return GetMetadataStatic().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return GetMetadataStatic().reflection;
+  }
+  static const TableRowCount& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const TableRowCount* internal_default_instance() {
+    return reinterpret_cast<const TableRowCount*>(
+               &_TableRowCount_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    14;
+
+  friend void swap(TableRowCount& a, TableRowCount& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(TableRowCount* other) {
+    if (other == this) return;
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline TableRowCount* New() const final {
+    return CreateMaybeMessage<TableRowCount>(nullptr);
+  }
+
+  TableRowCount* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<TableRowCount>(arena);
+  }
+  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void CopyFrom(const TableRowCount& from);
+  void MergeFrom(const TableRowCount& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  #else
+  bool MergePartialFromCodedStream(
+      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
+  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+  void SerializeWithCachedSizes(
+      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  inline void SharedCtor();
+  inline void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(TableRowCount* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "milvus.grpc.TableRowCount";
+  }
+  private:
+  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
+    return nullptr;
+  }
+  inline void* MaybeArenaPtr() const {
+    return nullptr;
+  }
+  public:
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  private:
+  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_milvus_2eproto);
+    return ::descriptor_table_milvus_2eproto.file_level_metadata[kIndexInFileMessages];
+  }
+
+  public:
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kStatusFieldNumber = 1,
+    kTableRowCountFieldNumber = 2,
+  };
+  // .milvus.grpc.Status status = 1;
+  bool has_status() const;
+  void clear_status();
+  const ::milvus::grpc::Status& status() const;
+  ::milvus::grpc::Status* release_status();
+  ::milvus::grpc::Status* mutable_status();
+  void set_allocated_status(::milvus::grpc::Status* status);
+
+  // int64 table_row_count = 2;
+  void clear_table_row_count();
+  ::PROTOBUF_NAMESPACE_ID::int64 table_row_count() const;
+  void set_table_row_count(::PROTOBUF_NAMESPACE_ID::int64 value);
+
+  // @@protoc_insertion_point(class_scope:milvus.grpc.TableRowCount)
+ private:
+  class _Internal;
+
+  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+  ::milvus::grpc::Status* status_;
+  ::PROTOBUF_NAMESPACE_ID::int64 table_row_count_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_milvus_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Command :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.Command) */ {
+ public:
+  Command();
+  virtual ~Command();
+
+  Command(const Command& from);
+  Command(Command&& from) noexcept
+    : Command() {
+    *this = ::std::move(from);
+  }
+
+  inline Command& operator=(const Command& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Command& operator=(Command&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return GetMetadataStatic().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return GetMetadataStatic().reflection;
+  }
+  static const Command& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Command* internal_default_instance() {
+    return reinterpret_cast<const Command*>(
+               &_Command_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    15;
+
+  friend void swap(Command& a, Command& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Command* other) {
+    if (other == this) return;
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Command* New() const final {
+    return CreateMaybeMessage<Command>(nullptr);
+  }
+
+  Command* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<Command>(arena);
+  }
+  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void CopyFrom(const Command& from);
+  void MergeFrom(const Command& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  #else
+  bool MergePartialFromCodedStream(
+      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
+  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+  void SerializeWithCachedSizes(
+      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  inline void SharedCtor();
+  inline void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Command* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "milvus.grpc.Command";
+  }
+  private:
+  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
+    return nullptr;
+  }
+  inline void* MaybeArenaPtr() const {
+    return nullptr;
+  }
+  public:
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  private:
+  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_milvus_2eproto);
+    return ::descriptor_table_milvus_2eproto.file_level_metadata[kIndexInFileMessages];
+  }
+
+  public:
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kCmdFieldNumber = 1,
+  };
+  // string cmd = 1;
+  void clear_cmd();
+  const std::string& cmd() const;
+  void set_cmd(const std::string& value);
+  void set_cmd(std::string&& value);
+  void set_cmd(const char* value);
+  void set_cmd(const char* value, size_t size);
+  std::string* mutable_cmd();
+  std::string* release_cmd();
+  void set_allocated_cmd(std::string* cmd);
+
+  // @@protoc_insertion_point(class_scope:milvus.grpc.Command)
+ private:
+  class _Internal;
+
+  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr cmd_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_milvus_2eproto;
+};
+// -------------------------------------------------------------------
+
+class Index :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.Index) */ {
+ public:
+  Index();
+  virtual ~Index();
+
+  Index(const Index& from);
+  Index(Index&& from) noexcept
+    : Index() {
+    *this = ::std::move(from);
+  }
+
+  inline Index& operator=(const Index& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Index& operator=(Index&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return GetMetadataStatic().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return GetMetadataStatic().reflection;
+  }
+  static const Index& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Index* internal_default_instance() {
+    return reinterpret_cast<const Index*>(
+               &_Index_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    16;
+
+  friend void swap(Index& a, Index& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Index* other) {
+    if (other == this) return;
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Index* New() const final {
+    return CreateMaybeMessage<Index>(nullptr);
+  }
+
+  Index* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<Index>(arena);
+  }
+  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void CopyFrom(const Index& from);
+  void MergeFrom(const Index& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  #else
+  bool MergePartialFromCodedStream(
+      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
+  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+  void SerializeWithCachedSizes(
+      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  inline void SharedCtor();
+  inline void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Index* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "milvus.grpc.Index";
+  }
+  private:
+  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
+    return nullptr;
+  }
+  inline void* MaybeArenaPtr() const {
+    return nullptr;
+  }
+  public:
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  private:
+  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_milvus_2eproto);
+    return ::descriptor_table_milvus_2eproto.file_level_metadata[kIndexInFileMessages];
+  }
+
+  public:
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kIndexTypeFieldNumber = 1,
+    kNlistFieldNumber = 2,
+  };
+  // int32 index_type = 1;
+  void clear_index_type();
+  ::PROTOBUF_NAMESPACE_ID::int32 index_type() const;
+  void set_index_type(::PROTOBUF_NAMESPACE_ID::int32 value);
+
+  // int32 nlist = 2;
+  void clear_nlist();
+  ::PROTOBUF_NAMESPACE_ID::int32 nlist() const;
+  void set_nlist(::PROTOBUF_NAMESPACE_ID::int32 value);
+
+  // @@protoc_insertion_point(class_scope:milvus.grpc.Index)
+ private:
+  class _Internal;
+
+  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+  ::PROTOBUF_NAMESPACE_ID::int32 index_type_;
+  ::PROTOBUF_NAMESPACE_ID::int32 nlist_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_milvus_2eproto;
+};
+// -------------------------------------------------------------------
+
+class IndexParam :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.IndexParam) */ {
+ public:
+  IndexParam();
+  virtual ~IndexParam();
+
+  IndexParam(const IndexParam& from);
+  IndexParam(IndexParam&& from) noexcept
+    : IndexParam() {
+    *this = ::std::move(from);
+  }
+
+  inline IndexParam& operator=(const IndexParam& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline IndexParam& operator=(IndexParam&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return GetMetadataStatic().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return GetMetadataStatic().reflection;
+  }
+  static const IndexParam& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const IndexParam* internal_default_instance() {
+    return reinterpret_cast<const IndexParam*>(
+               &_IndexParam_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    17;
+
+  friend void swap(IndexParam& a, IndexParam& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(IndexParam* other) {
+    if (other == this) return;
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline IndexParam* New() const final {
+    return CreateMaybeMessage<IndexParam>(nullptr);
+  }
+
+  IndexParam* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<IndexParam>(arena);
+  }
+  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void CopyFrom(const IndexParam& from);
+  void MergeFrom(const IndexParam& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  #else
+  bool MergePartialFromCodedStream(
+      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
+  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+  void SerializeWithCachedSizes(
+      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  inline void SharedCtor();
+  inline void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(IndexParam* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "milvus.grpc.IndexParam";
+  }
+  private:
+  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
+    return nullptr;
+  }
+  inline void* MaybeArenaPtr() const {
+    return nullptr;
+  }
+  public:
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  private:
+  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_milvus_2eproto);
+    return ::descriptor_table_milvus_2eproto.file_level_metadata[kIndexInFileMessages];
+  }
+
+  public:
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTableNameFieldNumber = 2,
+    kStatusFieldNumber = 1,
+    kIndexFieldNumber = 3,
+  };
+  // string table_name = 2;
+  void clear_table_name();
+  const std::string& table_name() const;
+  void set_table_name(const std::string& value);
+  void set_table_name(std::string&& value);
+  void set_table_name(const char* value);
+  void set_table_name(const char* value, size_t size);
+  std::string* mutable_table_name();
+  std::string* release_table_name();
+  void set_allocated_table_name(std::string* table_name);
+
+  // .milvus.grpc.Status status = 1;
+  bool has_status() const;
+  void clear_status();
+  const ::milvus::grpc::Status& status() const;
+  ::milvus::grpc::Status* release_status();
+  ::milvus::grpc::Status* mutable_status();
+  void set_allocated_status(::milvus::grpc::Status* status);
+
+  // .milvus.grpc.Index index = 3;
+  bool has_index() const;
+  void clear_index();
+  const ::milvus::grpc::Index& index() const;
+  ::milvus::grpc::Index* release_index();
+  ::milvus::grpc::Index* mutable_index();
+  void set_allocated_index(::milvus::grpc::Index* index);
+
+  // @@protoc_insertion_point(class_scope:milvus.grpc.IndexParam)
+ private:
+  class _Internal;
+
+  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr table_name_;
+  ::milvus::grpc::Status* status_;
+  ::milvus::grpc::Index* index_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_milvus_2eproto;
+};
+// -------------------------------------------------------------------
+
+class DeleteByRangeParam :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.DeleteByRangeParam) */ {
+ public:
+  DeleteByRangeParam();
+  virtual ~DeleteByRangeParam();
+
+  DeleteByRangeParam(const DeleteByRangeParam& from);
+  DeleteByRangeParam(DeleteByRangeParam&& from) noexcept
+    : DeleteByRangeParam() {
+    *this = ::std::move(from);
+  }
+
+  inline DeleteByRangeParam& operator=(const DeleteByRangeParam& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DeleteByRangeParam& operator=(DeleteByRangeParam&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return GetMetadataStatic().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return GetMetadataStatic().reflection;
+  }
+  static const DeleteByRangeParam& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const DeleteByRangeParam* internal_default_instance() {
+    return reinterpret_cast<const DeleteByRangeParam*>(
+               &_DeleteByRangeParam_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    18;
+
+  friend void swap(DeleteByRangeParam& a, DeleteByRangeParam& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DeleteByRangeParam* other) {
+    if (other == this) return;
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline DeleteByRangeParam* New() const final {
+    return CreateMaybeMessage<DeleteByRangeParam>(nullptr);
+  }
+
+  DeleteByRangeParam* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<DeleteByRangeParam>(arena);
+  }
+  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void CopyFrom(const DeleteByRangeParam& from);
+  void MergeFrom(const DeleteByRangeParam& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  #else
+  bool MergePartialFromCodedStream(
+      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
+  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+  void SerializeWithCachedSizes(
+      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  inline void SharedCtor();
+  inline void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DeleteByRangeParam* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "milvus.grpc.DeleteByRangeParam";
+  }
+  private:
+  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
+    return nullptr;
+  }
+  inline void* MaybeArenaPtr() const {
+    return nullptr;
+  }
+  public:
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  private:
+  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_milvus_2eproto);
+    return ::descriptor_table_milvus_2eproto.file_level_metadata[kIndexInFileMessages];
+  }
+
+  public:
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTableNameFieldNumber = 2,
+    kRangeFieldNumber = 1,
+  };
+  // string table_name = 2;
+  void clear_table_name();
+  const std::string& table_name() const;
+  void set_table_name(const std::string& value);
+  void set_table_name(std::string&& value);
+  void set_table_name(const char* value);
+  void set_table_name(const char* value, size_t size);
+  std::string* mutable_table_name();
+  std::string* release_table_name();
+  void set_allocated_table_name(std::string* table_name);
+
+  // .milvus.grpc.Range range = 1;
+  bool has_range() const;
+  void clear_range();
+  const ::milvus::grpc::Range& range() const;
+  ::milvus::grpc::Range* release_range();
+  ::milvus::grpc::Range* mutable_range();
+  void set_allocated_range(::milvus::grpc::Range* range);
+
+  // @@protoc_insertion_point(class_scope:milvus.grpc.DeleteByRangeParam)
+ private:
+  class _Internal;
+
+  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr table_name_;
+  ::milvus::grpc::Range* range_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_milvus_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// TableName
+
+// string table_name = 1;
+inline void TableName::clear_table_name() {
+  table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline const std::string& TableName::table_name() const {
+  // @@protoc_insertion_point(field_get:milvus.grpc.TableName.table_name)
+  return table_name_.GetNoArena();
+}
+inline void TableName::set_table_name(const std::string& value) {
+  
+  table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:milvus.grpc.TableName.table_name)
+}
+inline void TableName::set_table_name(std::string&& value) {
+  
+  table_name_.SetNoArena(
+    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.TableName.table_name)
+}
+inline void TableName::set_table_name(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  
+  table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:milvus.grpc.TableName.table_name)
+}
+inline void TableName::set_table_name(const char* value, size_t size) {
+  
+  table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.TableName.table_name)
+}
+inline std::string* TableName::mutable_table_name() {
+  
+  // @@protoc_insertion_point(field_mutable:milvus.grpc.TableName.table_name)
+  return table_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline std::string* TableName::release_table_name() {
+  // @@protoc_insertion_point(field_release:milvus.grpc.TableName.table_name)
+  
+  return table_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline void TableName::set_allocated_table_name(std::string* table_name) {
+  if (table_name != nullptr) {
+    
+  } else {
+    
+  }
+  table_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), table_name);
+  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.TableName.table_name)
+}
+
+// -------------------------------------------------------------------
+
+// TableNameList
+
+// .milvus.grpc.Status status = 1;
+inline bool TableNameList::has_status() const {
+  return this != internal_default_instance() && status_ != nullptr;
+}
+inline const ::milvus::grpc::Status& TableNameList::status() const {
+  const ::milvus::grpc::Status* p = status_;
+  // @@protoc_insertion_point(field_get:milvus.grpc.TableNameList.status)
+  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::grpc::Status*>(
+      &::milvus::grpc::_Status_default_instance_);
+}
+inline ::milvus::grpc::Status* TableNameList::release_status() {
+  // @@protoc_insertion_point(field_release:milvus.grpc.TableNameList.status)
+  
+  ::milvus::grpc::Status* temp = status_;
+  status_ = nullptr;
+  return temp;
+}
+inline ::milvus::grpc::Status* TableNameList::mutable_status() {
+  
+  if (status_ == nullptr) {
+    auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual());
+    status_ = p;
+  }
+  // @@protoc_insertion_point(field_mutable:milvus.grpc.TableNameList.status)
+  return status_;
+}
+inline void TableNameList::set_allocated_status(::milvus::grpc::Status* status) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(status_);
+  }
+  if (status) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
+    if (message_arena != submessage_arena) {
+      status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, status, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  status_ = status;
+  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.TableNameList.status)
+}
+
+// repeated string table_names = 2;
+inline int TableNameList::table_names_size() const {
+  return table_names_.size();
+}
+inline void TableNameList::clear_table_names() {
+  table_names_.Clear();
+}
+inline const std::string& TableNameList::table_names(int index) const {
+  // @@protoc_insertion_point(field_get:milvus.grpc.TableNameList.table_names)
+  return table_names_.Get(index);
+}
+inline std::string* TableNameList::mutable_table_names(int index) {
+  // @@protoc_insertion_point(field_mutable:milvus.grpc.TableNameList.table_names)
+  return table_names_.Mutable(index);
+}
+inline void TableNameList::set_table_names(int index, const std::string& value) {
+  // @@protoc_insertion_point(field_set:milvus.grpc.TableNameList.table_names)
+  table_names_.Mutable(index)->assign(value);
+}
+inline void TableNameList::set_table_names(int index, std::string&& value) {
+  // @@protoc_insertion_point(field_set:milvus.grpc.TableNameList.table_names)
+  table_names_.Mutable(index)->assign(std::move(value));
+}
+inline void TableNameList::set_table_names(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  table_names_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:milvus.grpc.TableNameList.table_names)
+}
+inline void TableNameList::set_table_names(int index, const char* value, size_t size) {
+  table_names_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.TableNameList.table_names)
+}
+inline std::string* TableNameList::add_table_names() {
+  // @@protoc_insertion_point(field_add_mutable:milvus.grpc.TableNameList.table_names)
+  return table_names_.Add();
+}
+inline void TableNameList::add_table_names(const std::string& value) {
+  table_names_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:milvus.grpc.TableNameList.table_names)
+}
+inline void TableNameList::add_table_names(std::string&& value) {
+  table_names_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:milvus.grpc.TableNameList.table_names)
+}
+inline void TableNameList::add_table_names(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  table_names_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:milvus.grpc.TableNameList.table_names)
+}
+inline void TableNameList::add_table_names(const char* value, size_t size) {
+  table_names_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:milvus.grpc.TableNameList.table_names)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+TableNameList::table_names() const {
+  // @@protoc_insertion_point(field_list:milvus.grpc.TableNameList.table_names)
+  return table_names_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+TableNameList::mutable_table_names() {
+  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.TableNameList.table_names)
+  return &table_names_;
+}
+
+// -------------------------------------------------------------------
+
+// TableSchema
+
+// .milvus.grpc.Status status = 1;
+inline bool TableSchema::has_status() const {
+  return this != internal_default_instance() && status_ != nullptr;
+}
+inline const ::milvus::grpc::Status& TableSchema::status() const {
+  const ::milvus::grpc::Status* p = status_;
+  // @@protoc_insertion_point(field_get:milvus.grpc.TableSchema.status)
+  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::grpc::Status*>(
+      &::milvus::grpc::_Status_default_instance_);
+}
+inline ::milvus::grpc::Status* TableSchema::release_status() {
+  // @@protoc_insertion_point(field_release:milvus.grpc.TableSchema.status)
+  
+  ::milvus::grpc::Status* temp = status_;
+  status_ = nullptr;
+  return temp;
+}
+inline ::milvus::grpc::Status* TableSchema::mutable_status() {
+  
+  if (status_ == nullptr) {
+    auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual());
+    status_ = p;
+  }
+  // @@protoc_insertion_point(field_mutable:milvus.grpc.TableSchema.status)
+  return status_;
+}
+inline void TableSchema::set_allocated_status(::milvus::grpc::Status* status) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(status_);
+  }
+  if (status) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
+    if (message_arena != submessage_arena) {
+      status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, status, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  status_ = status;
+  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.TableSchema.status)
+}
+
+// string table_name = 2;
+inline void TableSchema::clear_table_name() {
+  table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline const std::string& TableSchema::table_name() const {
+  // @@protoc_insertion_point(field_get:milvus.grpc.TableSchema.table_name)
+  return table_name_.GetNoArena();
+}
+inline void TableSchema::set_table_name(const std::string& value) {
+  
+  table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:milvus.grpc.TableSchema.table_name)
+}
+inline void TableSchema::set_table_name(std::string&& value) {
+  
+  table_name_.SetNoArena(
+    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.TableSchema.table_name)
+}
+inline void TableSchema::set_table_name(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  
+  table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:milvus.grpc.TableSchema.table_name)
+}
+inline void TableSchema::set_table_name(const char* value, size_t size) {
+  
+  table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.TableSchema.table_name)
+}
+inline std::string* TableSchema::mutable_table_name() {
+  
+  // @@protoc_insertion_point(field_mutable:milvus.grpc.TableSchema.table_name)
+  return table_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline std::string* TableSchema::release_table_name() {
+  // @@protoc_insertion_point(field_release:milvus.grpc.TableSchema.table_name)
+  
+  return table_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline void TableSchema::set_allocated_table_name(std::string* table_name) {
+  if (table_name != nullptr) {
+    
+  } else {
+    
+  }
+  table_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), table_name);
+  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.TableSchema.table_name)
+}
+
+// int64 dimension = 3;
+inline void TableSchema::clear_dimension() {
+  dimension_ = PROTOBUF_LONGLONG(0);
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 TableSchema::dimension() const {
+  // @@protoc_insertion_point(field_get:milvus.grpc.TableSchema.dimension)
+  return dimension_;
+}
+inline void TableSchema::set_dimension(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  
+  dimension_ = value;
+  // @@protoc_insertion_point(field_set:milvus.grpc.TableSchema.dimension)
+}
+
+// int64 index_file_size = 4;
+inline void TableSchema::clear_index_file_size() {
+  index_file_size_ = PROTOBUF_LONGLONG(0);
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 TableSchema::index_file_size() const {
+  // @@protoc_insertion_point(field_get:milvus.grpc.TableSchema.index_file_size)
+  return index_file_size_;
+}
+inline void TableSchema::set_index_file_size(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  
+  index_file_size_ = value;
+  // @@protoc_insertion_point(field_set:milvus.grpc.TableSchema.index_file_size)
+}
+
+// int32 metric_type = 5;
+inline void TableSchema::clear_metric_type() {
+  metric_type_ = 0;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 TableSchema::metric_type() const {
+  // @@protoc_insertion_point(field_get:milvus.grpc.TableSchema.metric_type)
+  return metric_type_;
+}
+inline void TableSchema::set_metric_type(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  
+  metric_type_ = value;
+  // @@protoc_insertion_point(field_set:milvus.grpc.TableSchema.metric_type)
+}
+
+// -------------------------------------------------------------------
+
+// Range
+
+// string start_value = 1;
+inline void Range::clear_start_value() {
+  start_value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline const std::string& Range::start_value() const {
+  // @@protoc_insertion_point(field_get:milvus.grpc.Range.start_value)
+  return start_value_.GetNoArena();
+}
+inline void Range::set_start_value(const std::string& value) {
+  
+  start_value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:milvus.grpc.Range.start_value)
+}
+inline void Range::set_start_value(std::string&& value) {
+  
+  start_value_.SetNoArena(
+    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.Range.start_value)
+}
+inline void Range::set_start_value(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  
+  start_value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:milvus.grpc.Range.start_value)
+}
+inline void Range::set_start_value(const char* value, size_t size) {
+  
+  start_value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.Range.start_value)
+}
+inline std::string* Range::mutable_start_value() {
+  
+  // @@protoc_insertion_point(field_mutable:milvus.grpc.Range.start_value)
+  return start_value_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline std::string* Range::release_start_value() {
+  // @@protoc_insertion_point(field_release:milvus.grpc.Range.start_value)
+  
+  return start_value_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline void Range::set_allocated_start_value(std::string* start_value) {
+  if (start_value != nullptr) {
+    
+  } else {
+    
+  }
+  start_value_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), start_value);
+  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.Range.start_value)
+}
+
+// string end_value = 2;
+inline void Range::clear_end_value() {
+  end_value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline const std::string& Range::end_value() const {
+  // @@protoc_insertion_point(field_get:milvus.grpc.Range.end_value)
+  return end_value_.GetNoArena();
+}
+inline void Range::set_end_value(const std::string& value) {
+  
+  end_value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:milvus.grpc.Range.end_value)
+}
+inline void Range::set_end_value(std::string&& value) {
+  
+  end_value_.SetNoArena(
+    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.Range.end_value)
+}
+inline void Range::set_end_value(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  
+  end_value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:milvus.grpc.Range.end_value)
+}
+inline void Range::set_end_value(const char* value, size_t size) {
+  
+  end_value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.Range.end_value)
+}
+inline std::string* Range::mutable_end_value() {
+  
+  // @@protoc_insertion_point(field_mutable:milvus.grpc.Range.end_value)
+  return end_value_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline std::string* Range::release_end_value() {
+  // @@protoc_insertion_point(field_release:milvus.grpc.Range.end_value)
+  
+  return end_value_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline void Range::set_allocated_end_value(std::string* end_value) {
+  if (end_value != nullptr) {
+    
+  } else {
+    
+  }
+  end_value_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), end_value);
+  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.Range.end_value)
+}
+
+// -------------------------------------------------------------------
+
+// RowRecord
+
+// repeated float vector_data = 1;
+inline int RowRecord::vector_data_size() const {
+  return vector_data_.size();
+}
+inline void RowRecord::clear_vector_data() {
+  vector_data_.Clear();
+}
+inline float RowRecord::vector_data(int index) const {
+  // @@protoc_insertion_point(field_get:milvus.grpc.RowRecord.vector_data)
+  return vector_data_.Get(index);
+}
+inline void RowRecord::set_vector_data(int index, float value) {
+  vector_data_.Set(index, value);
+  // @@protoc_insertion_point(field_set:milvus.grpc.RowRecord.vector_data)
+}
+inline void RowRecord::add_vector_data(float value) {
+  vector_data_.Add(value);
+  // @@protoc_insertion_point(field_add:milvus.grpc.RowRecord.vector_data)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
+RowRecord::vector_data() const {
+  // @@protoc_insertion_point(field_list:milvus.grpc.RowRecord.vector_data)
+  return vector_data_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
+RowRecord::mutable_vector_data() {
+  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.RowRecord.vector_data)
+  return &vector_data_;
+}
+
+// -------------------------------------------------------------------
+
+// InsertParam
+
+// string table_name = 1;
+inline void InsertParam::clear_table_name() {
+  table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline const std::string& InsertParam::table_name() const {
+  // @@protoc_insertion_point(field_get:milvus.grpc.InsertParam.table_name)
+  return table_name_.GetNoArena();
+}
+inline void InsertParam::set_table_name(const std::string& value) {
+  
+  table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:milvus.grpc.InsertParam.table_name)
+}
+inline void InsertParam::set_table_name(std::string&& value) {
+  
+  table_name_.SetNoArena(
+    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.InsertParam.table_name)
+}
+inline void InsertParam::set_table_name(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  
+  table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:milvus.grpc.InsertParam.table_name)
+}
+inline void InsertParam::set_table_name(const char* value, size_t size) {
+  
+  table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.InsertParam.table_name)
+}
+inline std::string* InsertParam::mutable_table_name() {
+  
+  // @@protoc_insertion_point(field_mutable:milvus.grpc.InsertParam.table_name)
+  return table_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline std::string* InsertParam::release_table_name() {
+  // @@protoc_insertion_point(field_release:milvus.grpc.InsertParam.table_name)
+  
+  return table_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline void InsertParam::set_allocated_table_name(std::string* table_name) {
+  if (table_name != nullptr) {
+    
+  } else {
+    
+  }
+  table_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), table_name);
+  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.InsertParam.table_name)
+}
+
+// repeated .milvus.grpc.RowRecord row_record_array = 2;
+inline int InsertParam::row_record_array_size() const {
+  return row_record_array_.size();
+}
+inline void InsertParam::clear_row_record_array() {
+  row_record_array_.Clear();
+}
+inline ::milvus::grpc::RowRecord* InsertParam::mutable_row_record_array(int index) {
+  // @@protoc_insertion_point(field_mutable:milvus.grpc.InsertParam.row_record_array)
+  return row_record_array_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowRecord >*
+InsertParam::mutable_row_record_array() {
+  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.InsertParam.row_record_array)
+  return &row_record_array_;
+}
+inline const ::milvus::grpc::RowRecord& InsertParam::row_record_array(int index) const {
+  // @@protoc_insertion_point(field_get:milvus.grpc.InsertParam.row_record_array)
+  return row_record_array_.Get(index);
+}
+inline ::milvus::grpc::RowRecord* InsertParam::add_row_record_array() {
+  // @@protoc_insertion_point(field_add:milvus.grpc.InsertParam.row_record_array)
+  return row_record_array_.Add();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowRecord >&
+InsertParam::row_record_array() const {
+  // @@protoc_insertion_point(field_list:milvus.grpc.InsertParam.row_record_array)
+  return row_record_array_;
+}
+
+// repeated int64 row_id_array = 3;
+inline int InsertParam::row_id_array_size() const {
+  return row_id_array_.size();
+}
+inline void InsertParam::clear_row_id_array() {
+  row_id_array_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 InsertParam::row_id_array(int index) const {
+  // @@protoc_insertion_point(field_get:milvus.grpc.InsertParam.row_id_array)
+  return row_id_array_.Get(index);
+}
+inline void InsertParam::set_row_id_array(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
+  row_id_array_.Set(index, value);
+  // @@protoc_insertion_point(field_set:milvus.grpc.InsertParam.row_id_array)
+}
+inline void InsertParam::add_row_id_array(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  row_id_array_.Add(value);
+  // @@protoc_insertion_point(field_add:milvus.grpc.InsertParam.row_id_array)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
+InsertParam::row_id_array() const {
+  // @@protoc_insertion_point(field_list:milvus.grpc.InsertParam.row_id_array)
+  return row_id_array_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
+InsertParam::mutable_row_id_array() {
+  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.InsertParam.row_id_array)
+  return &row_id_array_;
+}
+
+// -------------------------------------------------------------------
+
+// VectorIds
+
+// .milvus.grpc.Status status = 1;
+inline bool VectorIds::has_status() const {
+  return this != internal_default_instance() && status_ != nullptr;
+}
+inline const ::milvus::grpc::Status& VectorIds::status() const {
+  const ::milvus::grpc::Status* p = status_;
+  // @@protoc_insertion_point(field_get:milvus.grpc.VectorIds.status)
+  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::grpc::Status*>(
+      &::milvus::grpc::_Status_default_instance_);
+}
+inline ::milvus::grpc::Status* VectorIds::release_status() {
+  // @@protoc_insertion_point(field_release:milvus.grpc.VectorIds.status)
+  
+  ::milvus::grpc::Status* temp = status_;
+  status_ = nullptr;
+  return temp;
+}
+inline ::milvus::grpc::Status* VectorIds::mutable_status() {
+  
+  if (status_ == nullptr) {
+    auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual());
+    status_ = p;
+  }
+  // @@protoc_insertion_point(field_mutable:milvus.grpc.VectorIds.status)
+  return status_;
+}
+inline void VectorIds::set_allocated_status(::milvus::grpc::Status* status) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(status_);
+  }
+  if (status) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
+    if (message_arena != submessage_arena) {
+      status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, status, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  status_ = status;
+  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.VectorIds.status)
+}
+
+// repeated int64 vector_id_array = 2;
+inline int VectorIds::vector_id_array_size() const {
+  return vector_id_array_.size();
+}
+inline void VectorIds::clear_vector_id_array() {
+  vector_id_array_.Clear();
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 VectorIds::vector_id_array(int index) const {
+  // @@protoc_insertion_point(field_get:milvus.grpc.VectorIds.vector_id_array)
+  return vector_id_array_.Get(index);
+}
+inline void VectorIds::set_vector_id_array(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
+  vector_id_array_.Set(index, value);
+  // @@protoc_insertion_point(field_set:milvus.grpc.VectorIds.vector_id_array)
+}
+inline void VectorIds::add_vector_id_array(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  vector_id_array_.Add(value);
+  // @@protoc_insertion_point(field_add:milvus.grpc.VectorIds.vector_id_array)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
+VectorIds::vector_id_array() const {
+  // @@protoc_insertion_point(field_list:milvus.grpc.VectorIds.vector_id_array)
+  return vector_id_array_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
+VectorIds::mutable_vector_id_array() {
+  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.VectorIds.vector_id_array)
+  return &vector_id_array_;
+}
+
+// -------------------------------------------------------------------
+
+// SearchParam
+
+// string table_name = 1;
+inline void SearchParam::clear_table_name() {
+  table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline const std::string& SearchParam::table_name() const {
+  // @@protoc_insertion_point(field_get:milvus.grpc.SearchParam.table_name)
+  return table_name_.GetNoArena();
+}
+inline void SearchParam::set_table_name(const std::string& value) {
+  
+  table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:milvus.grpc.SearchParam.table_name)
+}
+inline void SearchParam::set_table_name(std::string&& value) {
+  
+  table_name_.SetNoArena(
+    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.SearchParam.table_name)
+}
+inline void SearchParam::set_table_name(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  
+  table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:milvus.grpc.SearchParam.table_name)
+}
+inline void SearchParam::set_table_name(const char* value, size_t size) {
+  
+  table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.SearchParam.table_name)
+}
+inline std::string* SearchParam::mutable_table_name() {
+  
+  // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchParam.table_name)
+  return table_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline std::string* SearchParam::release_table_name() {
+  // @@protoc_insertion_point(field_release:milvus.grpc.SearchParam.table_name)
+  
+  return table_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline void SearchParam::set_allocated_table_name(std::string* table_name) {
+  if (table_name != nullptr) {
+    
+  } else {
+    
+  }
+  table_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), table_name);
+  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.SearchParam.table_name)
+}
+
+// repeated .milvus.grpc.RowRecord query_record_array = 2;
+inline int SearchParam::query_record_array_size() const {
+  return query_record_array_.size();
+}
+inline void SearchParam::clear_query_record_array() {
+  query_record_array_.Clear();
+}
+inline ::milvus::grpc::RowRecord* SearchParam::mutable_query_record_array(int index) {
+  // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchParam.query_record_array)
+  return query_record_array_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowRecord >*
+SearchParam::mutable_query_record_array() {
+  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.SearchParam.query_record_array)
+  return &query_record_array_;
+}
+inline const ::milvus::grpc::RowRecord& SearchParam::query_record_array(int index) const {
+  // @@protoc_insertion_point(field_get:milvus.grpc.SearchParam.query_record_array)
+  return query_record_array_.Get(index);
+}
+inline ::milvus::grpc::RowRecord* SearchParam::add_query_record_array() {
+  // @@protoc_insertion_point(field_add:milvus.grpc.SearchParam.query_record_array)
+  return query_record_array_.Add();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::RowRecord >&
+SearchParam::query_record_array() const {
+  // @@protoc_insertion_point(field_list:milvus.grpc.SearchParam.query_record_array)
+  return query_record_array_;
+}
+
+// repeated .milvus.grpc.Range query_range_array = 3;
+inline int SearchParam::query_range_array_size() const {
+  return query_range_array_.size();
+}
+inline void SearchParam::clear_query_range_array() {
+  query_range_array_.Clear();
+}
+inline ::milvus::grpc::Range* SearchParam::mutable_query_range_array(int index) {
+  // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchParam.query_range_array)
+  return query_range_array_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::Range >*
+SearchParam::mutable_query_range_array() {
+  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.SearchParam.query_range_array)
+  return &query_range_array_;
+}
+inline const ::milvus::grpc::Range& SearchParam::query_range_array(int index) const {
+  // @@protoc_insertion_point(field_get:milvus.grpc.SearchParam.query_range_array)
+  return query_range_array_.Get(index);
+}
+inline ::milvus::grpc::Range* SearchParam::add_query_range_array() {
+  // @@protoc_insertion_point(field_add:milvus.grpc.SearchParam.query_range_array)
+  return query_range_array_.Add();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::Range >&
+SearchParam::query_range_array() const {
+  // @@protoc_insertion_point(field_list:milvus.grpc.SearchParam.query_range_array)
+  return query_range_array_;
+}
+
+// int64 topk = 4;
+inline void SearchParam::clear_topk() {
+  topk_ = PROTOBUF_LONGLONG(0);
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 SearchParam::topk() const {
+  // @@protoc_insertion_point(field_get:milvus.grpc.SearchParam.topk)
+  return topk_;
+}
+inline void SearchParam::set_topk(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  
+  topk_ = value;
+  // @@protoc_insertion_point(field_set:milvus.grpc.SearchParam.topk)
+}
+
+// int64 nprobe = 5;
+inline void SearchParam::clear_nprobe() {
+  nprobe_ = PROTOBUF_LONGLONG(0);
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 SearchParam::nprobe() const {
+  // @@protoc_insertion_point(field_get:milvus.grpc.SearchParam.nprobe)
+  return nprobe_;
+}
+inline void SearchParam::set_nprobe(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  
+  nprobe_ = value;
+  // @@protoc_insertion_point(field_set:milvus.grpc.SearchParam.nprobe)
+}
+
+// -------------------------------------------------------------------
+
+// SearchInFilesParam
+
+// repeated string file_id_array = 1;
+inline int SearchInFilesParam::file_id_array_size() const {
+  return file_id_array_.size();
+}
+inline void SearchInFilesParam::clear_file_id_array() {
+  file_id_array_.Clear();
+}
+inline const std::string& SearchInFilesParam::file_id_array(int index) const {
+  // @@protoc_insertion_point(field_get:milvus.grpc.SearchInFilesParam.file_id_array)
+  return file_id_array_.Get(index);
+}
+inline std::string* SearchInFilesParam::mutable_file_id_array(int index) {
+  // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchInFilesParam.file_id_array)
+  return file_id_array_.Mutable(index);
+}
+inline void SearchInFilesParam::set_file_id_array(int index, const std::string& value) {
+  // @@protoc_insertion_point(field_set:milvus.grpc.SearchInFilesParam.file_id_array)
+  file_id_array_.Mutable(index)->assign(value);
+}
+inline void SearchInFilesParam::set_file_id_array(int index, std::string&& value) {
+  // @@protoc_insertion_point(field_set:milvus.grpc.SearchInFilesParam.file_id_array)
+  file_id_array_.Mutable(index)->assign(std::move(value));
+}
+inline void SearchInFilesParam::set_file_id_array(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  file_id_array_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:milvus.grpc.SearchInFilesParam.file_id_array)
+}
+inline void SearchInFilesParam::set_file_id_array(int index, const char* value, size_t size) {
+  file_id_array_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.SearchInFilesParam.file_id_array)
+}
+inline std::string* SearchInFilesParam::add_file_id_array() {
+  // @@protoc_insertion_point(field_add_mutable:milvus.grpc.SearchInFilesParam.file_id_array)
+  return file_id_array_.Add();
+}
+inline void SearchInFilesParam::add_file_id_array(const std::string& value) {
+  file_id_array_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:milvus.grpc.SearchInFilesParam.file_id_array)
+}
+inline void SearchInFilesParam::add_file_id_array(std::string&& value) {
+  file_id_array_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:milvus.grpc.SearchInFilesParam.file_id_array)
+}
+inline void SearchInFilesParam::add_file_id_array(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  file_id_array_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:milvus.grpc.SearchInFilesParam.file_id_array)
+}
+inline void SearchInFilesParam::add_file_id_array(const char* value, size_t size) {
+  file_id_array_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:milvus.grpc.SearchInFilesParam.file_id_array)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+SearchInFilesParam::file_id_array() const {
+  // @@protoc_insertion_point(field_list:milvus.grpc.SearchInFilesParam.file_id_array)
+  return file_id_array_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+SearchInFilesParam::mutable_file_id_array() {
+  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.SearchInFilesParam.file_id_array)
+  return &file_id_array_;
+}
+
+// .milvus.grpc.SearchParam search_param = 2;
+inline bool SearchInFilesParam::has_search_param() const {
+  return this != internal_default_instance() && search_param_ != nullptr;
+}
+inline void SearchInFilesParam::clear_search_param() {
+  if (GetArenaNoVirtual() == nullptr && search_param_ != nullptr) {
+    delete search_param_;
+  }
+  search_param_ = nullptr;
+}
+inline const ::milvus::grpc::SearchParam& SearchInFilesParam::search_param() const {
+  const ::milvus::grpc::SearchParam* p = search_param_;
+  // @@protoc_insertion_point(field_get:milvus.grpc.SearchInFilesParam.search_param)
+  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::grpc::SearchParam*>(
+      &::milvus::grpc::_SearchParam_default_instance_);
+}
+inline ::milvus::grpc::SearchParam* SearchInFilesParam::release_search_param() {
+  // @@protoc_insertion_point(field_release:milvus.grpc.SearchInFilesParam.search_param)
+  
+  ::milvus::grpc::SearchParam* temp = search_param_;
+  search_param_ = nullptr;
+  return temp;
+}
+inline ::milvus::grpc::SearchParam* SearchInFilesParam::mutable_search_param() {
+  
+  if (search_param_ == nullptr) {
+    auto* p = CreateMaybeMessage<::milvus::grpc::SearchParam>(GetArenaNoVirtual());
+    search_param_ = p;
+  }
+  // @@protoc_insertion_point(field_mutable:milvus.grpc.SearchInFilesParam.search_param)
+  return search_param_;
+}
+inline void SearchInFilesParam::set_allocated_search_param(::milvus::grpc::SearchParam* search_param) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == nullptr) {
+    delete search_param_;
+  }
+  if (search_param) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
+    if (message_arena != submessage_arena) {
+      search_param = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, search_param, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  search_param_ = search_param;
+  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.SearchInFilesParam.search_param)
+}
+
+// -------------------------------------------------------------------
+
+// QueryResult
+
+// int64 id = 1;
+inline void QueryResult::clear_id() {
+  id_ = PROTOBUF_LONGLONG(0);
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 QueryResult::id() const {
+  // @@protoc_insertion_point(field_get:milvus.grpc.QueryResult.id)
+  return id_;
+}
+inline void QueryResult::set_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  
+  id_ = value;
+  // @@protoc_insertion_point(field_set:milvus.grpc.QueryResult.id)
+}
+
+// double distance = 2;
+inline void QueryResult::clear_distance() {
+  distance_ = 0;
+}
+inline double QueryResult::distance() const {
+  // @@protoc_insertion_point(field_get:milvus.grpc.QueryResult.distance)
+  return distance_;
+}
+inline void QueryResult::set_distance(double value) {
+  
+  distance_ = value;
+  // @@protoc_insertion_point(field_set:milvus.grpc.QueryResult.distance)
+}
+
+// -------------------------------------------------------------------
+
+// TopKQueryResult
+
+// repeated .milvus.grpc.QueryResult query_result_arrays = 1;
+inline int TopKQueryResult::query_result_arrays_size() const {
+  return query_result_arrays_.size();
+}
+inline void TopKQueryResult::clear_query_result_arrays() {
+  query_result_arrays_.Clear();
+}
+inline ::milvus::grpc::QueryResult* TopKQueryResult::mutable_query_result_arrays(int index) {
+  // @@protoc_insertion_point(field_mutable:milvus.grpc.TopKQueryResult.query_result_arrays)
+  return query_result_arrays_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::QueryResult >*
+TopKQueryResult::mutable_query_result_arrays() {
+  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.TopKQueryResult.query_result_arrays)
+  return &query_result_arrays_;
+}
+inline const ::milvus::grpc::QueryResult& TopKQueryResult::query_result_arrays(int index) const {
+  // @@protoc_insertion_point(field_get:milvus.grpc.TopKQueryResult.query_result_arrays)
+  return query_result_arrays_.Get(index);
+}
+inline ::milvus::grpc::QueryResult* TopKQueryResult::add_query_result_arrays() {
+  // @@protoc_insertion_point(field_add:milvus.grpc.TopKQueryResult.query_result_arrays)
+  return query_result_arrays_.Add();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::QueryResult >&
+TopKQueryResult::query_result_arrays() const {
+  // @@protoc_insertion_point(field_list:milvus.grpc.TopKQueryResult.query_result_arrays)
+  return query_result_arrays_;
+}
+
+// -------------------------------------------------------------------
+
+// TopKQueryResultList
+
+// .milvus.grpc.Status status = 1;
+inline bool TopKQueryResultList::has_status() const {
+  return this != internal_default_instance() && status_ != nullptr;
+}
+inline const ::milvus::grpc::Status& TopKQueryResultList::status() const {
+  const ::milvus::grpc::Status* p = status_;
+  // @@protoc_insertion_point(field_get:milvus.grpc.TopKQueryResultList.status)
+  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::grpc::Status*>(
+      &::milvus::grpc::_Status_default_instance_);
+}
+inline ::milvus::grpc::Status* TopKQueryResultList::release_status() {
+  // @@protoc_insertion_point(field_release:milvus.grpc.TopKQueryResultList.status)
+  
+  ::milvus::grpc::Status* temp = status_;
+  status_ = nullptr;
+  return temp;
+}
+inline ::milvus::grpc::Status* TopKQueryResultList::mutable_status() {
+  
+  if (status_ == nullptr) {
+    auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual());
+    status_ = p;
+  }
+  // @@protoc_insertion_point(field_mutable:milvus.grpc.TopKQueryResultList.status)
+  return status_;
+}
+inline void TopKQueryResultList::set_allocated_status(::milvus::grpc::Status* status) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(status_);
+  }
+  if (status) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
+    if (message_arena != submessage_arena) {
+      status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, status, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  status_ = status;
+  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.TopKQueryResultList.status)
+}
+
+// repeated .milvus.grpc.TopKQueryResult topk_query_result = 2;
+inline int TopKQueryResultList::topk_query_result_size() const {
+  return topk_query_result_.size();
+}
+inline void TopKQueryResultList::clear_topk_query_result() {
+  topk_query_result_.Clear();
+}
+inline ::milvus::grpc::TopKQueryResult* TopKQueryResultList::mutable_topk_query_result(int index) {
+  // @@protoc_insertion_point(field_mutable:milvus.grpc.TopKQueryResultList.topk_query_result)
+  return topk_query_result_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::TopKQueryResult >*
+TopKQueryResultList::mutable_topk_query_result() {
+  // @@protoc_insertion_point(field_mutable_list:milvus.grpc.TopKQueryResultList.topk_query_result)
+  return &topk_query_result_;
+}
+inline const ::milvus::grpc::TopKQueryResult& TopKQueryResultList::topk_query_result(int index) const {
+  // @@protoc_insertion_point(field_get:milvus.grpc.TopKQueryResultList.topk_query_result)
+  return topk_query_result_.Get(index);
+}
+inline ::milvus::grpc::TopKQueryResult* TopKQueryResultList::add_topk_query_result() {
+  // @@protoc_insertion_point(field_add:milvus.grpc.TopKQueryResultList.topk_query_result)
+  return topk_query_result_.Add();
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::milvus::grpc::TopKQueryResult >&
+TopKQueryResultList::topk_query_result() const {
+  // @@protoc_insertion_point(field_list:milvus.grpc.TopKQueryResultList.topk_query_result)
+  return topk_query_result_;
+}
+
+// -------------------------------------------------------------------
+
+// StringReply
+
+// .milvus.grpc.Status status = 1;
+inline bool StringReply::has_status() const {
+  return this != internal_default_instance() && status_ != nullptr;
+}
+inline const ::milvus::grpc::Status& StringReply::status() const {
+  const ::milvus::grpc::Status* p = status_;
+  // @@protoc_insertion_point(field_get:milvus.grpc.StringReply.status)
+  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::grpc::Status*>(
+      &::milvus::grpc::_Status_default_instance_);
+}
+inline ::milvus::grpc::Status* StringReply::release_status() {
+  // @@protoc_insertion_point(field_release:milvus.grpc.StringReply.status)
+  
+  ::milvus::grpc::Status* temp = status_;
+  status_ = nullptr;
+  return temp;
+}
+inline ::milvus::grpc::Status* StringReply::mutable_status() {
+  
+  if (status_ == nullptr) {
+    auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual());
+    status_ = p;
+  }
+  // @@protoc_insertion_point(field_mutable:milvus.grpc.StringReply.status)
+  return status_;
+}
+inline void StringReply::set_allocated_status(::milvus::grpc::Status* status) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(status_);
+  }
+  if (status) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
+    if (message_arena != submessage_arena) {
+      status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, status, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  status_ = status;
+  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.StringReply.status)
+}
+
+// string string_reply = 2;
+inline void StringReply::clear_string_reply() {
+  string_reply_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline const std::string& StringReply::string_reply() const {
+  // @@protoc_insertion_point(field_get:milvus.grpc.StringReply.string_reply)
+  return string_reply_.GetNoArena();
+}
+inline void StringReply::set_string_reply(const std::string& value) {
+  
+  string_reply_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:milvus.grpc.StringReply.string_reply)
+}
+inline void StringReply::set_string_reply(std::string&& value) {
+  
+  string_reply_.SetNoArena(
+    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.StringReply.string_reply)
+}
+inline void StringReply::set_string_reply(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  
+  string_reply_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:milvus.grpc.StringReply.string_reply)
+}
+inline void StringReply::set_string_reply(const char* value, size_t size) {
+  
+  string_reply_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.StringReply.string_reply)
+}
+inline std::string* StringReply::mutable_string_reply() {
+  
+  // @@protoc_insertion_point(field_mutable:milvus.grpc.StringReply.string_reply)
+  return string_reply_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline std::string* StringReply::release_string_reply() {
+  // @@protoc_insertion_point(field_release:milvus.grpc.StringReply.string_reply)
+  
+  return string_reply_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline void StringReply::set_allocated_string_reply(std::string* string_reply) {
+  if (string_reply != nullptr) {
+    
+  } else {
+    
+  }
+  string_reply_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), string_reply);
+  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.StringReply.string_reply)
+}
+
+// -------------------------------------------------------------------
+
+// BoolReply
+
+// .milvus.grpc.Status status = 1;
+inline bool BoolReply::has_status() const {
+  return this != internal_default_instance() && status_ != nullptr;
+}
+inline const ::milvus::grpc::Status& BoolReply::status() const {
+  const ::milvus::grpc::Status* p = status_;
+  // @@protoc_insertion_point(field_get:milvus.grpc.BoolReply.status)
+  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::grpc::Status*>(
+      &::milvus::grpc::_Status_default_instance_);
+}
+inline ::milvus::grpc::Status* BoolReply::release_status() {
+  // @@protoc_insertion_point(field_release:milvus.grpc.BoolReply.status)
+  
+  ::milvus::grpc::Status* temp = status_;
+  status_ = nullptr;
+  return temp;
+}
+inline ::milvus::grpc::Status* BoolReply::mutable_status() {
+  
+  if (status_ == nullptr) {
+    auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual());
+    status_ = p;
+  }
+  // @@protoc_insertion_point(field_mutable:milvus.grpc.BoolReply.status)
+  return status_;
+}
+inline void BoolReply::set_allocated_status(::milvus::grpc::Status* status) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(status_);
+  }
+  if (status) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
+    if (message_arena != submessage_arena) {
+      status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, status, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  status_ = status;
+  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.BoolReply.status)
+}
+
+// bool bool_reply = 2;
+inline void BoolReply::clear_bool_reply() {
+  bool_reply_ = false;
+}
+inline bool BoolReply::bool_reply() const {
+  // @@protoc_insertion_point(field_get:milvus.grpc.BoolReply.bool_reply)
+  return bool_reply_;
+}
+inline void BoolReply::set_bool_reply(bool value) {
+  
+  bool_reply_ = value;
+  // @@protoc_insertion_point(field_set:milvus.grpc.BoolReply.bool_reply)
+}
+
+// -------------------------------------------------------------------
+
+// TableRowCount
+
+// .milvus.grpc.Status status = 1;
+inline bool TableRowCount::has_status() const {
+  return this != internal_default_instance() && status_ != nullptr;
+}
+inline const ::milvus::grpc::Status& TableRowCount::status() const {
+  const ::milvus::grpc::Status* p = status_;
+  // @@protoc_insertion_point(field_get:milvus.grpc.TableRowCount.status)
+  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::grpc::Status*>(
+      &::milvus::grpc::_Status_default_instance_);
+}
+inline ::milvus::grpc::Status* TableRowCount::release_status() {
+  // @@protoc_insertion_point(field_release:milvus.grpc.TableRowCount.status)
+  
+  ::milvus::grpc::Status* temp = status_;
+  status_ = nullptr;
+  return temp;
+}
+inline ::milvus::grpc::Status* TableRowCount::mutable_status() {
+  
+  if (status_ == nullptr) {
+    auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual());
+    status_ = p;
+  }
+  // @@protoc_insertion_point(field_mutable:milvus.grpc.TableRowCount.status)
+  return status_;
+}
+inline void TableRowCount::set_allocated_status(::milvus::grpc::Status* status) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(status_);
+  }
+  if (status) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
+    if (message_arena != submessage_arena) {
+      status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, status, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  status_ = status;
+  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.TableRowCount.status)
+}
+
+// int64 table_row_count = 2;
+inline void TableRowCount::clear_table_row_count() {
+  table_row_count_ = PROTOBUF_LONGLONG(0);
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 TableRowCount::table_row_count() const {
+  // @@protoc_insertion_point(field_get:milvus.grpc.TableRowCount.table_row_count)
+  return table_row_count_;
+}
+inline void TableRowCount::set_table_row_count(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  
+  table_row_count_ = value;
+  // @@protoc_insertion_point(field_set:milvus.grpc.TableRowCount.table_row_count)
+}
+
+// -------------------------------------------------------------------
+
+// Command
+
+// string cmd = 1;
+inline void Command::clear_cmd() {
+  cmd_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline const std::string& Command::cmd() const {
+  // @@protoc_insertion_point(field_get:milvus.grpc.Command.cmd)
+  return cmd_.GetNoArena();
+}
+inline void Command::set_cmd(const std::string& value) {
+  
+  cmd_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:milvus.grpc.Command.cmd)
+}
+inline void Command::set_cmd(std::string&& value) {
+  
+  cmd_.SetNoArena(
+    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.Command.cmd)
+}
+inline void Command::set_cmd(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  
+  cmd_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:milvus.grpc.Command.cmd)
+}
+inline void Command::set_cmd(const char* value, size_t size) {
+  
+  cmd_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.Command.cmd)
+}
+inline std::string* Command::mutable_cmd() {
+  
+  // @@protoc_insertion_point(field_mutable:milvus.grpc.Command.cmd)
+  return cmd_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline std::string* Command::release_cmd() {
+  // @@protoc_insertion_point(field_release:milvus.grpc.Command.cmd)
+  
+  return cmd_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline void Command::set_allocated_cmd(std::string* cmd) {
+  if (cmd != nullptr) {
+    
+  } else {
+    
+  }
+  cmd_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), cmd);
+  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.Command.cmd)
+}
+
+// -------------------------------------------------------------------
+
+// Index
+
+// int32 index_type = 1;
+inline void Index::clear_index_type() {
+  index_type_ = 0;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 Index::index_type() const {
+  // @@protoc_insertion_point(field_get:milvus.grpc.Index.index_type)
+  return index_type_;
+}
+inline void Index::set_index_type(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  
+  index_type_ = value;
+  // @@protoc_insertion_point(field_set:milvus.grpc.Index.index_type)
+}
+
+// int32 nlist = 2;
+inline void Index::clear_nlist() {
+  nlist_ = 0;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 Index::nlist() const {
+  // @@protoc_insertion_point(field_get:milvus.grpc.Index.nlist)
+  return nlist_;
+}
+inline void Index::set_nlist(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  
+  nlist_ = value;
+  // @@protoc_insertion_point(field_set:milvus.grpc.Index.nlist)
+}
+
+// -------------------------------------------------------------------
+
+// IndexParam
+
+// .milvus.grpc.Status status = 1;
+inline bool IndexParam::has_status() const {
+  return this != internal_default_instance() && status_ != nullptr;
+}
+inline const ::milvus::grpc::Status& IndexParam::status() const {
+  const ::milvus::grpc::Status* p = status_;
+  // @@protoc_insertion_point(field_get:milvus.grpc.IndexParam.status)
+  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::grpc::Status*>(
+      &::milvus::grpc::_Status_default_instance_);
+}
+inline ::milvus::grpc::Status* IndexParam::release_status() {
+  // @@protoc_insertion_point(field_release:milvus.grpc.IndexParam.status)
+  
+  ::milvus::grpc::Status* temp = status_;
+  status_ = nullptr;
+  return temp;
+}
+inline ::milvus::grpc::Status* IndexParam::mutable_status() {
+  
+  if (status_ == nullptr) {
+    auto* p = CreateMaybeMessage<::milvus::grpc::Status>(GetArenaNoVirtual());
+    status_ = p;
+  }
+  // @@protoc_insertion_point(field_mutable:milvus.grpc.IndexParam.status)
+  return status_;
+}
+inline void IndexParam::set_allocated_status(::milvus::grpc::Status* status) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(status_);
+  }
+  if (status) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
+    if (message_arena != submessage_arena) {
+      status = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, status, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  status_ = status;
+  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.IndexParam.status)
+}
+
+// string table_name = 2;
+inline void IndexParam::clear_table_name() {
+  table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline const std::string& IndexParam::table_name() const {
+  // @@protoc_insertion_point(field_get:milvus.grpc.IndexParam.table_name)
+  return table_name_.GetNoArena();
+}
+inline void IndexParam::set_table_name(const std::string& value) {
+  
+  table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:milvus.grpc.IndexParam.table_name)
+}
+inline void IndexParam::set_table_name(std::string&& value) {
+  
+  table_name_.SetNoArena(
+    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.IndexParam.table_name)
+}
+inline void IndexParam::set_table_name(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  
+  table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:milvus.grpc.IndexParam.table_name)
+}
+inline void IndexParam::set_table_name(const char* value, size_t size) {
+  
+  table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.IndexParam.table_name)
+}
+inline std::string* IndexParam::mutable_table_name() {
+  
+  // @@protoc_insertion_point(field_mutable:milvus.grpc.IndexParam.table_name)
+  return table_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline std::string* IndexParam::release_table_name() {
+  // @@protoc_insertion_point(field_release:milvus.grpc.IndexParam.table_name)
+  
+  return table_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline void IndexParam::set_allocated_table_name(std::string* table_name) {
+  if (table_name != nullptr) {
+    
+  } else {
+    
+  }
+  table_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), table_name);
+  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.IndexParam.table_name)
+}
+
+// .milvus.grpc.Index index = 3;
+inline bool IndexParam::has_index() const {
+  return this != internal_default_instance() && index_ != nullptr;
+}
+inline void IndexParam::clear_index() {
+  if (GetArenaNoVirtual() == nullptr && index_ != nullptr) {
+    delete index_;
+  }
+  index_ = nullptr;
+}
+inline const ::milvus::grpc::Index& IndexParam::index() const {
+  const ::milvus::grpc::Index* p = index_;
+  // @@protoc_insertion_point(field_get:milvus.grpc.IndexParam.index)
+  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::grpc::Index*>(
+      &::milvus::grpc::_Index_default_instance_);
+}
+inline ::milvus::grpc::Index* IndexParam::release_index() {
+  // @@protoc_insertion_point(field_release:milvus.grpc.IndexParam.index)
+  
+  ::milvus::grpc::Index* temp = index_;
+  index_ = nullptr;
+  return temp;
+}
+inline ::milvus::grpc::Index* IndexParam::mutable_index() {
+  
+  if (index_ == nullptr) {
+    auto* p = CreateMaybeMessage<::milvus::grpc::Index>(GetArenaNoVirtual());
+    index_ = p;
+  }
+  // @@protoc_insertion_point(field_mutable:milvus.grpc.IndexParam.index)
+  return index_;
+}
+inline void IndexParam::set_allocated_index(::milvus::grpc::Index* index) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == nullptr) {
+    delete index_;
+  }
+  if (index) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
+    if (message_arena != submessage_arena) {
+      index = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, index, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  index_ = index;
+  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.IndexParam.index)
+}
+
+// -------------------------------------------------------------------
+
+// DeleteByRangeParam
+
+// .milvus.grpc.Range range = 1;
+inline bool DeleteByRangeParam::has_range() const {
+  return this != internal_default_instance() && range_ != nullptr;
+}
+inline void DeleteByRangeParam::clear_range() {
+  if (GetArenaNoVirtual() == nullptr && range_ != nullptr) {
+    delete range_;
+  }
+  range_ = nullptr;
+}
+inline const ::milvus::grpc::Range& DeleteByRangeParam::range() const {
+  const ::milvus::grpc::Range* p = range_;
+  // @@protoc_insertion_point(field_get:milvus.grpc.DeleteByRangeParam.range)
+  return p != nullptr ? *p : *reinterpret_cast<const ::milvus::grpc::Range*>(
+      &::milvus::grpc::_Range_default_instance_);
+}
+inline ::milvus::grpc::Range* DeleteByRangeParam::release_range() {
+  // @@protoc_insertion_point(field_release:milvus.grpc.DeleteByRangeParam.range)
+  
+  ::milvus::grpc::Range* temp = range_;
+  range_ = nullptr;
+  return temp;
+}
+inline ::milvus::grpc::Range* DeleteByRangeParam::mutable_range() {
+  
+  if (range_ == nullptr) {
+    auto* p = CreateMaybeMessage<::milvus::grpc::Range>(GetArenaNoVirtual());
+    range_ = p;
+  }
+  // @@protoc_insertion_point(field_mutable:milvus.grpc.DeleteByRangeParam.range)
+  return range_;
+}
+inline void DeleteByRangeParam::set_allocated_range(::milvus::grpc::Range* range) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == nullptr) {
+    delete range_;
+  }
+  if (range) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
+    if (message_arena != submessage_arena) {
+      range = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, range, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  range_ = range;
+  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.DeleteByRangeParam.range)
+}
+
+// string table_name = 2;
+inline void DeleteByRangeParam::clear_table_name() {
+  table_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline const std::string& DeleteByRangeParam::table_name() const {
+  // @@protoc_insertion_point(field_get:milvus.grpc.DeleteByRangeParam.table_name)
+  return table_name_.GetNoArena();
+}
+inline void DeleteByRangeParam::set_table_name(const std::string& value) {
+  
+  table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:milvus.grpc.DeleteByRangeParam.table_name)
+}
+inline void DeleteByRangeParam::set_table_name(std::string&& value) {
+  
+  table_name_.SetNoArena(
+    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.DeleteByRangeParam.table_name)
+}
+inline void DeleteByRangeParam::set_table_name(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  
+  table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:milvus.grpc.DeleteByRangeParam.table_name)
+}
+inline void DeleteByRangeParam::set_table_name(const char* value, size_t size) {
+  
+  table_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.DeleteByRangeParam.table_name)
+}
+inline std::string* DeleteByRangeParam::mutable_table_name() {
+  
+  // @@protoc_insertion_point(field_mutable:milvus.grpc.DeleteByRangeParam.table_name)
+  return table_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline std::string* DeleteByRangeParam::release_table_name() {
+  // @@protoc_insertion_point(field_release:milvus.grpc.DeleteByRangeParam.table_name)
+  
+  return table_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline void DeleteByRangeParam::set_allocated_table_name(std::string* table_name) {
+  if (table_name != nullptr) {
+    
+  } else {
+    
+  }
+  table_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), table_name);
+  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.DeleteByRangeParam.table_name)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace grpc
+}  // namespace milvus
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_milvus_2eproto
diff --git a/core/src/grpc/gen-status/status.grpc.pb.cc b/core/src/grpc/gen-status/status.grpc.pb.cc
new file mode 100644
index 0000000000..de871f5413
--- /dev/null
+++ b/core/src/grpc/gen-status/status.grpc.pb.cc
@@ -0,0 +1,24 @@
+// Generated by the gRPC C++ plugin.
+// If you make any local change, they will be lost.
+// source: status.proto
+
+#include "status.pb.h"
+#include "status.grpc.pb.h"
+
+#include <functional>
+#include <grpcpp/impl/codegen/async_stream.h>
+#include <grpcpp/impl/codegen/async_unary_call.h>
+#include <grpcpp/impl/codegen/channel_interface.h>
+#include <grpcpp/impl/codegen/client_unary_call.h>
+#include <grpcpp/impl/codegen/client_callback.h>
+#include <grpcpp/impl/codegen/method_handler_impl.h>
+#include <grpcpp/impl/codegen/rpc_service_method.h>
+#include <grpcpp/impl/codegen/server_callback.h>
+#include <grpcpp/impl/codegen/service_type.h>
+#include <grpcpp/impl/codegen/sync_stream.h>
+namespace milvus {
+namespace grpc {
+
+}  // namespace milvus
+}  // namespace grpc
+
diff --git a/core/src/grpc/gen-status/status.grpc.pb.h b/core/src/grpc/gen-status/status.grpc.pb.h
new file mode 100644
index 0000000000..2dcedb74de
--- /dev/null
+++ b/core/src/grpc/gen-status/status.grpc.pb.h
@@ -0,0 +1,46 @@
+// Generated by the gRPC C++ plugin.
+// If you make any local change, they will be lost.
+// source: status.proto
+#ifndef GRPC_status_2eproto__INCLUDED
+#define GRPC_status_2eproto__INCLUDED
+
+#include "status.pb.h"
+
+#include <functional>
+#include <grpcpp/impl/codegen/async_generic_service.h>
+#include <grpcpp/impl/codegen/async_stream.h>
+#include <grpcpp/impl/codegen/async_unary_call.h>
+#include <grpcpp/impl/codegen/client_callback.h>
+#include <grpcpp/impl/codegen/client_context.h>
+#include <grpcpp/impl/codegen/completion_queue.h>
+#include <grpcpp/impl/codegen/method_handler_impl.h>
+#include <grpcpp/impl/codegen/proto_utils.h>
+#include <grpcpp/impl/codegen/rpc_method.h>
+#include <grpcpp/impl/codegen/server_callback.h>
+#include <grpcpp/impl/codegen/server_context.h>
+#include <grpcpp/impl/codegen/service_type.h>
+#include <grpcpp/impl/codegen/status.h>
+#include <grpcpp/impl/codegen/stub_options.h>
+#include <grpcpp/impl/codegen/sync_stream.h>
+
+namespace grpc_impl {
+class CompletionQueue;
+class ServerCompletionQueue;
+class ServerContext;
+}  // namespace grpc_impl
+
+namespace grpc {
+namespace experimental {
+template <typename RequestT, typename ResponseT>
+class MessageAllocator;
+}  // namespace experimental
+}  // namespace grpc
+
+namespace milvus {
+namespace grpc {
+
+}  // namespace grpc
+}  // namespace milvus
+
+
+#endif  // GRPC_status_2eproto__INCLUDED
diff --git a/core/src/grpc/gen-status/status.pb.cc b/core/src/grpc/gen-status/status.pb.cc
new file mode 100644
index 0000000000..3a9d88641c
--- /dev/null
+++ b/core/src/grpc/gen-status/status.pb.cc
@@ -0,0 +1,462 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: status.proto
+
+#include "status.pb.h"
+
+#include <algorithm>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/wire_format_lite.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+namespace milvus {
+namespace grpc {
+class StatusDefaultTypeInternal {
+ public:
+  ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<Status> _instance;
+} _Status_default_instance_;
+}  // namespace grpc
+}  // namespace milvus
+static void InitDefaultsscc_info_Status_status_2eproto() {
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  {
+    void* ptr = &::milvus::grpc::_Status_default_instance_;
+    new (ptr) ::milvus::grpc::Status();
+    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
+  }
+  ::milvus::grpc::Status::InitAsDefaultInstance();
+}
+
+::PROTOBUF_NAMESPACE_ID::internal::SCCInfo<0> scc_info_Status_status_2eproto =
+    {{ATOMIC_VAR_INIT(::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsscc_info_Status_status_2eproto}, {}};
+
+static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_status_2eproto[1];
+static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_status_2eproto[1];
+static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_status_2eproto = nullptr;
+
+const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_status_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+  ~0u,  // no _has_bits_
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::Status, _internal_metadata_),
+  ~0u,  // no _extensions_
+  ~0u,  // no _oneof_case_
+  ~0u,  // no _weak_field_map_
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::Status, error_code_),
+  PROTOBUF_FIELD_OFFSET(::milvus::grpc::Status, reason_),
+};
+static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+  { 0, -1, sizeof(::milvus::grpc::Status)},
+};
+
+static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
+  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::milvus::grpc::_Status_default_instance_),
+};
+
+const char descriptor_table_protodef_status_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
+  "\n\014status.proto\022\013milvus.grpc\"D\n\006Status\022*\n"
+  "\nerror_code\030\001 \001(\0162\026.milvus.grpc.ErrorCod"
+  "e\022\016\n\006reason\030\002 \001(\t*\253\004\n\tErrorCode\022\013\n\007SUCCE"
+  "SS\020\000\022\024\n\020UNEXPECTED_ERROR\020\001\022\022\n\016CONNECT_FA"
+  "ILED\020\002\022\025\n\021PERMISSION_DENIED\020\003\022\024\n\020TABLE_N"
+  "OT_EXISTS\020\004\022\024\n\020ILLEGAL_ARGUMENT\020\005\022\021\n\rILL"
+  "EGAL_RANGE\020\006\022\025\n\021ILLEGAL_DIMENSION\020\007\022\026\n\022I"
+  "LLEGAL_INDEX_TYPE\020\010\022\026\n\022ILLEGAL_TABLE_NAM"
+  "E\020\t\022\020\n\014ILLEGAL_TOPK\020\n\022\025\n\021ILLEGAL_ROWRECO"
+  "RD\020\013\022\025\n\021ILLEGAL_VECTOR_ID\020\014\022\031\n\025ILLEGAL_S"
+  "EARCH_RESULT\020\r\022\022\n\016FILE_NOT_FOUND\020\016\022\017\n\013ME"
+  "TA_FAILED\020\017\022\020\n\014CACHE_FAILED\020\020\022\030\n\024CANNOT_"
+  "CREATE_FOLDER\020\021\022\026\n\022CANNOT_CREATE_FILE\020\022\022"
+  "\030\n\024CANNOT_DELETE_FOLDER\020\023\022\026\n\022CANNOT_DELE"
+  "TE_FILE\020\024\022\025\n\021BUILD_INDEX_ERROR\020\025\022\021\n\rILLE"
+  "GAL_NLIST\020\026\022\027\n\023ILLEGAL_METRIC_TYPE\020\027\022\021\n\r"
+  "OUT_OF_MEMORY\020\030b\006proto3"
+  ;
+static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_status_2eproto_deps[1] = {
+};
+static ::PROTOBUF_NAMESPACE_ID::internal::SCCInfoBase*const descriptor_table_status_2eproto_sccs[1] = {
+  &scc_info_Status_status_2eproto.base,
+};
+static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_status_2eproto_once;
+static bool descriptor_table_status_2eproto_initialized = false;
+const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_status_2eproto = {
+  &descriptor_table_status_2eproto_initialized, descriptor_table_protodef_status_2eproto, "status.proto", 663,
+  &descriptor_table_status_2eproto_once, descriptor_table_status_2eproto_sccs, descriptor_table_status_2eproto_deps, 1, 0,
+  schemas, file_default_instances, TableStruct_status_2eproto::offsets,
+  file_level_metadata_status_2eproto, 1, file_level_enum_descriptors_status_2eproto, file_level_service_descriptors_status_2eproto,
+};
+
+// Force running AddDescriptors() at dynamic initialization time.
+static bool dynamic_init_dummy_status_2eproto = (  ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptors(&descriptor_table_status_2eproto), true);
+namespace milvus {
+namespace grpc {
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ErrorCode_descriptor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_status_2eproto);
+  return file_level_enum_descriptors_status_2eproto[0];
+}
+bool ErrorCode_IsValid(int value) {
+  switch (value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+    case 6:
+    case 7:
+    case 8:
+    case 9:
+    case 10:
+    case 11:
+    case 12:
+    case 13:
+    case 14:
+    case 15:
+    case 16:
+    case 17:
+    case 18:
+    case 19:
+    case 20:
+    case 21:
+    case 22:
+    case 23:
+    case 24:
+      return true;
+    default:
+      return false;
+  }
+}
+
+
+// ===================================================================
+
+void Status::InitAsDefaultInstance() {
+}
+class Status::_Internal {
+ public:
+};
+
+Status::Status()
+  : ::PROTOBUF_NAMESPACE_ID::Message(), _internal_metadata_(nullptr) {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:milvus.grpc.Status)
+}
+Status::Status(const Status& from)
+  : ::PROTOBUF_NAMESPACE_ID::Message(),
+      _internal_metadata_(nullptr) {
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  reason_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  if (!from.reason().empty()) {
+    reason_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.reason_);
+  }
+  error_code_ = from.error_code_;
+  // @@protoc_insertion_point(copy_constructor:milvus.grpc.Status)
+}
+
+void Status::SharedCtor() {
+  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_Status_status_2eproto.base);
+  reason_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  error_code_ = 0;
+}
+
+Status::~Status() {
+  // @@protoc_insertion_point(destructor:milvus.grpc.Status)
+  SharedDtor();
+}
+
+void Status::SharedDtor() {
+  reason_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void Status::SetCachedSize(int size) const {
+  _cached_size_.Set(size);
+}
+const Status& Status::default_instance() {
+  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_Status_status_2eproto.base);
+  return *internal_default_instance();
+}
+
+
+void Status::Clear() {
+// @@protoc_insertion_point(message_clear_start:milvus.grpc.Status)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  reason_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  error_code_ = 0;
+  _internal_metadata_.Clear();
+}
+
+#if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+const char* Status::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+  while (!ctx->Done(&ptr)) {
+    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+    CHK_(ptr);
+    switch (tag >> 3) {
+      // .milvus.grpc.ErrorCode error_code = 1;
+      case 1:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
+          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint(&ptr);
+          CHK_(ptr);
+          set_error_code(static_cast<::milvus::grpc::ErrorCode>(val));
+        } else goto handle_unusual;
+        continue;
+      // string reason = 2;
+      case 2:
+        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
+          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParserUTF8(mutable_reason(), ptr, ctx, "milvus.grpc.Status.reason");
+          CHK_(ptr);
+        } else goto handle_unusual;
+        continue;
+      default: {
+      handle_unusual:
+        if ((tag & 7) == 4 || tag == 0) {
+          ctx->SetLastTag(tag);
+          goto success;
+        }
+        ptr = UnknownFieldParse(tag, &_internal_metadata_, ptr, ctx);
+        CHK_(ptr != nullptr);
+        continue;
+      }
+    }  // switch
+  }  // while
+success:
+  return ptr;
+failure:
+  ptr = nullptr;
+  goto success;
+#undef CHK_
+}
+#else  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+bool Status::MergePartialFromCodedStream(
+    ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!PROTOBUF_PREDICT_TRUE(EXPRESSION)) goto failure
+  ::PROTOBUF_NAMESPACE_ID::uint32 tag;
+  // @@protoc_insertion_point(parse_start:milvus.grpc.Status)
+  for (;;) {
+    ::std::pair<::PROTOBUF_NAMESPACE_ID::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // .milvus.grpc.ErrorCode error_code = 1;
+      case 1: {
+        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (8 & 0xFF)) {
+          int value = 0;
+          DO_((::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadPrimitive<
+                   int, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          set_error_code(static_cast< ::milvus::grpc::ErrorCode >(value));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      // string reason = 2;
+      case 2: {
+        if (static_cast< ::PROTOBUF_NAMESPACE_ID::uint8>(tag) == (18 & 0xFF)) {
+          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::ReadString(
+                input, this->mutable_reason()));
+          DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+            this->reason().data(), static_cast<int>(this->reason().length()),
+            ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE,
+            "milvus.grpc.Status.reason"));
+        } else {
+          goto handle_unusual;
+        }
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0) {
+          goto success;
+        }
+        DO_(::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SkipField(
+              input, tag, _internal_metadata_.mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:milvus.grpc.Status)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:milvus.grpc.Status)
+  return false;
+#undef DO_
+}
+#endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+
+void Status::SerializeWithCachedSizes(
+    ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:milvus.grpc.Status)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .milvus.grpc.ErrorCode error_code = 1;
+  if (this->error_code() != 0) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnum(
+      1, this->error_code(), output);
+  }
+
+  // string reason = 2;
+  if (this->reason().size() > 0) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->reason().data(), static_cast<int>(this->reason().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "milvus.grpc.Status.reason");
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->reason(), output);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFields(
+        _internal_metadata_.unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:milvus.grpc.Status)
+}
+
+::PROTOBUF_NAMESPACE_ID::uint8* Status::InternalSerializeWithCachedSizesToArray(
+    ::PROTOBUF_NAMESPACE_ID::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:milvus.grpc.Status)
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  // .milvus.grpc.ErrorCode error_code = 1;
+  if (this->error_code() != 0) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
+      1, this->error_code(), target);
+  }
+
+  // string reason = 2;
+  if (this->reason().size() > 0) {
+    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+      this->reason().data(), static_cast<int>(this->reason().length()),
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+      "milvus.grpc.Status.reason");
+    target =
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteStringToArray(
+        2, this->reason(), target);
+  }
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SerializeUnknownFieldsToArray(
+        _internal_metadata_.unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:milvus.grpc.Status)
+  return target;
+}
+
+size_t Status::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:milvus.grpc.Status)
+  size_t total_size = 0;
+
+  if (_internal_metadata_.have_unknown_fields()) {
+    total_size +=
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::ComputeUnknownFieldsSize(
+        _internal_metadata_.unknown_fields());
+  }
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  // Prevent compiler warnings about cached_has_bits being unused
+  (void) cached_has_bits;
+
+  // string reason = 2;
+  if (this->reason().size() > 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+        this->reason());
+  }
+
+  // .milvus.grpc.ErrorCode error_code = 1;
+  if (this->error_code() != 0) {
+    total_size += 1 +
+      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->error_code());
+  }
+
+  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
+  SetCachedSize(cached_size);
+  return total_size;
+}
+
+void Status::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_merge_from_start:milvus.grpc.Status)
+  GOOGLE_DCHECK_NE(&from, this);
+  const Status* source =
+      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<Status>(
+          &from);
+  if (source == nullptr) {
+  // @@protoc_insertion_point(generalized_merge_from_cast_fail:milvus.grpc.Status)
+    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
+  } else {
+  // @@protoc_insertion_point(generalized_merge_from_cast_success:milvus.grpc.Status)
+    MergeFrom(*source);
+  }
+}
+
+void Status::MergeFrom(const Status& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:milvus.grpc.Status)
+  GOOGLE_DCHECK_NE(&from, this);
+  _internal_metadata_.MergeFrom(from._internal_metadata_);
+  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
+  (void) cached_has_bits;
+
+  if (from.reason().size() > 0) {
+
+    reason_.AssignWithDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), from.reason_);
+  }
+  if (from.error_code() != 0) {
+    set_error_code(from.error_code());
+  }
+}
+
+void Status::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+// @@protoc_insertion_point(generalized_copy_from_start:milvus.grpc.Status)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void Status::CopyFrom(const Status& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:milvus.grpc.Status)
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Status::IsInitialized() const {
+  return true;
+}
+
+void Status::InternalSwap(Status* other) {
+  using std::swap;
+  _internal_metadata_.Swap(&other->_internal_metadata_);
+  reason_.Swap(&other->reason_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+    GetArenaNoVirtual());
+  swap(error_code_, other->error_code_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata Status::GetMetadata() const {
+  return GetMetadataStatic();
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+}  // namespace grpc
+}  // namespace milvus
+PROTOBUF_NAMESPACE_OPEN
+template<> PROTOBUF_NOINLINE ::milvus::grpc::Status* Arena::CreateMaybeMessage< ::milvus::grpc::Status >(Arena* arena) {
+  return Arena::CreateInternal< ::milvus::grpc::Status >(arena);
+}
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+#include <google/protobuf/port_undef.inc>
diff --git a/core/src/grpc/gen-status/status.pb.h b/core/src/grpc/gen-status/status.pb.h
new file mode 100644
index 0000000000..c75dff7d27
--- /dev/null
+++ b/core/src/grpc/gen-status/status.pb.h
@@ -0,0 +1,361 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: status.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_status_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_status_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3009000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3009000 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/inlined_string_field.h>
+#include <google/protobuf/metadata.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_status_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_status_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[1]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_status_2eproto;
+namespace milvus {
+namespace grpc {
+class Status;
+class StatusDefaultTypeInternal;
+extern StatusDefaultTypeInternal _Status_default_instance_;
+}  // namespace grpc
+}  // namespace milvus
+PROTOBUF_NAMESPACE_OPEN
+template<> ::milvus::grpc::Status* Arena::CreateMaybeMessage<::milvus::grpc::Status>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace milvus {
+namespace grpc {
+
+enum ErrorCode : int {
+  SUCCESS = 0,
+  UNEXPECTED_ERROR = 1,
+  CONNECT_FAILED = 2,
+  PERMISSION_DENIED = 3,
+  TABLE_NOT_EXISTS = 4,
+  ILLEGAL_ARGUMENT = 5,
+  ILLEGAL_RANGE = 6,
+  ILLEGAL_DIMENSION = 7,
+  ILLEGAL_INDEX_TYPE = 8,
+  ILLEGAL_TABLE_NAME = 9,
+  ILLEGAL_TOPK = 10,
+  ILLEGAL_ROWRECORD = 11,
+  ILLEGAL_VECTOR_ID = 12,
+  ILLEGAL_SEARCH_RESULT = 13,
+  FILE_NOT_FOUND = 14,
+  META_FAILED = 15,
+  CACHE_FAILED = 16,
+  CANNOT_CREATE_FOLDER = 17,
+  CANNOT_CREATE_FILE = 18,
+  CANNOT_DELETE_FOLDER = 19,
+  CANNOT_DELETE_FILE = 20,
+  BUILD_INDEX_ERROR = 21,
+  ILLEGAL_NLIST = 22,
+  ILLEGAL_METRIC_TYPE = 23,
+  OUT_OF_MEMORY = 24,
+  ErrorCode_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
+  ErrorCode_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
+};
+bool ErrorCode_IsValid(int value);
+constexpr ErrorCode ErrorCode_MIN = SUCCESS;
+constexpr ErrorCode ErrorCode_MAX = OUT_OF_MEMORY;
+constexpr int ErrorCode_ARRAYSIZE = ErrorCode_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ErrorCode_descriptor();
+template<typename T>
+inline const std::string& ErrorCode_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ErrorCode>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ErrorCode_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    ErrorCode_descriptor(), enum_t_value);
+}
+inline bool ErrorCode_Parse(
+    const std::string& name, ErrorCode* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ErrorCode>(
+    ErrorCode_descriptor(), name, value);
+}
+// ===================================================================
+
+class Status :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:milvus.grpc.Status) */ {
+ public:
+  Status();
+  virtual ~Status();
+
+  Status(const Status& from);
+  Status(Status&& from) noexcept
+    : Status() {
+    *this = ::std::move(from);
+  }
+
+  inline Status& operator=(const Status& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline Status& operator=(Status&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return GetMetadataStatic().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return GetMetadataStatic().reflection;
+  }
+  static const Status& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Status* internal_default_instance() {
+    return reinterpret_cast<const Status*>(
+               &_Status_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(Status& a, Status& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(Status* other) {
+    if (other == this) return;
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Status* New() const final {
+    return CreateMaybeMessage<Status>(nullptr);
+  }
+
+  Status* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<Status>(arena);
+  }
+  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
+  void CopyFrom(const Status& from);
+  void MergeFrom(const Status& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  #else
+  bool MergePartialFromCodedStream(
+      ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
+  #endif  // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
+  void SerializeWithCachedSizes(
+      ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  inline void SharedCtor();
+  inline void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(Status* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "milvus.grpc.Status";
+  }
+  private:
+  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
+    return nullptr;
+  }
+  inline void* MaybeArenaPtr() const {
+    return nullptr;
+  }
+  public:
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+  private:
+  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
+    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_status_2eproto);
+    return ::descriptor_table_status_2eproto.file_level_metadata[kIndexInFileMessages];
+  }
+
+  public:
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kReasonFieldNumber = 2,
+    kErrorCodeFieldNumber = 1,
+  };
+  // string reason = 2;
+  void clear_reason();
+  const std::string& reason() const;
+  void set_reason(const std::string& value);
+  void set_reason(std::string&& value);
+  void set_reason(const char* value);
+  void set_reason(const char* value, size_t size);
+  std::string* mutable_reason();
+  std::string* release_reason();
+  void set_allocated_reason(std::string* reason);
+
+  // .milvus.grpc.ErrorCode error_code = 1;
+  void clear_error_code();
+  ::milvus::grpc::ErrorCode error_code() const;
+  void set_error_code(::milvus::grpc::ErrorCode value);
+
+  // @@protoc_insertion_point(class_scope:milvus.grpc.Status)
+ private:
+  class _Internal;
+
+  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr reason_;
+  int error_code_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_status_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// Status
+
+// .milvus.grpc.ErrorCode error_code = 1;
+inline void Status::clear_error_code() {
+  error_code_ = 0;
+}
+inline ::milvus::grpc::ErrorCode Status::error_code() const {
+  // @@protoc_insertion_point(field_get:milvus.grpc.Status.error_code)
+  return static_cast< ::milvus::grpc::ErrorCode >(error_code_);
+}
+inline void Status::set_error_code(::milvus::grpc::ErrorCode value) {
+  
+  error_code_ = value;
+  // @@protoc_insertion_point(field_set:milvus.grpc.Status.error_code)
+}
+
+// string reason = 2;
+inline void Status::clear_reason() {
+  reason_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline const std::string& Status::reason() const {
+  // @@protoc_insertion_point(field_get:milvus.grpc.Status.reason)
+  return reason_.GetNoArena();
+}
+inline void Status::set_reason(const std::string& value) {
+  
+  reason_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:milvus.grpc.Status.reason)
+}
+inline void Status::set_reason(std::string&& value) {
+  
+  reason_.SetNoArena(
+    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:milvus.grpc.Status.reason)
+}
+inline void Status::set_reason(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  
+  reason_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:milvus.grpc.Status.reason)
+}
+inline void Status::set_reason(const char* value, size_t size) {
+  
+  reason_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:milvus.grpc.Status.reason)
+}
+inline std::string* Status::mutable_reason() {
+  
+  // @@protoc_insertion_point(field_mutable:milvus.grpc.Status.reason)
+  return reason_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline std::string* Status::release_reason() {
+  // @@protoc_insertion_point(field_release:milvus.grpc.Status.reason)
+  
+  return reason_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+inline void Status::set_allocated_reason(std::string* reason) {
+  if (reason != nullptr) {
+    
+  } else {
+    
+  }
+  reason_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), reason);
+  // @@protoc_insertion_point(field_set_allocated:milvus.grpc.Status.reason)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace grpc
+}  // namespace milvus
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::milvus::grpc::ErrorCode> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::milvus::grpc::ErrorCode>() {
+  return ::milvus::grpc::ErrorCode_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_status_2eproto
diff --git a/core/src/grpc/milvus.proto b/core/src/grpc/milvus.proto
new file mode 100644
index 0000000000..2856dfc6d9
--- /dev/null
+++ b/core/src/grpc/milvus.proto
@@ -0,0 +1,323 @@
+syntax = "proto3";
+
+import "status.proto";
+
+package milvus.grpc;
+
+/**
+ * @brief Table Name
+ */
+message TableName {
+    string table_name = 1;
+}
+
+/**
+ * @brief Table Name List
+ */
+message TableNameList {
+    Status status = 1;
+    repeated string table_names = 2;
+}
+
+/**
+ * @brief Table Schema
+ */
+message TableSchema {
+    Status status = 1;
+    string table_name = 2;
+    int64 dimension = 3;
+    int64 index_file_size = 4;
+    int32 metric_type = 5;
+}
+
+/**
+ * @brief Range Schema
+ */
+message Range {
+    string start_value = 1;
+    string end_value = 2;
+}
+
+/**
+ * @brief Record inserted
+ */
+message RowRecord {
+    repeated float vector_data = 1;             //binary vector data
+}
+
+/**
+ * @brief params to be inserted
+ */
+message InsertParam {
+    string table_name = 1;
+    repeated RowRecord row_record_array = 2;
+    repeated int64 row_id_array = 3;            //optional
+}
+
+/**
+ * @brief Vector ids
+ */
+message VectorIds {
+    Status status = 1;
+    repeated int64 vector_id_array = 2;
+}
+
+/**
+ * @brief params for searching vector
+ */
+message SearchParam {
+    string table_name = 1;
+    repeated RowRecord query_record_array = 2;
+    repeated Range query_range_array = 3;
+    int64 topk = 4;
+    int64 nprobe = 5;
+}
+
+/**
+ * @brief params for searching vector in files
+ */
+message SearchInFilesParam {
+    repeated string file_id_array = 1;
+    SearchParam search_param = 2;
+}
+
+/**
+ * @brief Query result params
+ */
+message QueryResult {
+    int64 id = 1;
+    double distance = 2;
+}
+
+/**
+ * @brief TopK query result
+ */
+message TopKQueryResult {
+    repeated QueryResult query_result_arrays = 1;
+}
+
+/**
+ * @brief List of topK query result
+ */
+message TopKQueryResultList {
+    Status status = 1;
+    repeated TopKQueryResult topk_query_result = 2;
+}
+
+/**
+ * @brief Server String Reply
+ */
+message StringReply {
+    Status status = 1;
+    string string_reply = 2;
+}
+
+/**
+ * @brief Server bool Reply
+ */
+message BoolReply {
+    Status status = 1;
+    bool bool_reply = 2;
+}
+
+/**
+ * @brief Return table row count
+ */
+message TableRowCount {
+    Status status = 1;
+    int64 table_row_count = 2;
+}
+
+/**
+ * @brief Give Server Command
+ */
+message Command {
+    string cmd = 1;
+}
+
+/**
+ * @brief Index
+ * @index_type: 0-invalid, 1-idmap, 2-ivflat, 3-ivfsq8, 4-nsgmix
+ * @metric_type: 1-L2, 2-IP
+ */
+message Index {
+    int32 index_type = 1;
+    int32 nlist = 2;
+}
+
+/**
+ * @brief Index params
+ */
+message IndexParam {
+    Status status = 1;
+    string table_name = 2;
+    Index index = 3;
+}
+
+/**
+ * @brief table name and range for DeleteByRange
+ */
+message DeleteByRangeParam {
+    Range range = 1;
+    string table_name = 2;
+}
+
+service MilvusService {
+    /**
+     * @brief Create table method
+     *
+     * This method is used to create table
+     *
+     * @param param, use to provide table information to be created.
+     *
+     */
+    rpc CreateTable(TableSchema) returns (Status){}
+
+    /**
+     * @brief Test table existence method
+     *
+     * This method is used to test table existence.
+     *
+     * @param table_name, table name is going to be tested.
+     *
+     */
+    rpc HasTable(TableName) returns (BoolReply) {}
+
+    /**
+     * @brief Delete table method
+     *
+     * This method is used to delete table.
+     *
+     * @param table_name, table name is going to be deleted.
+     *
+     */
+    rpc DropTable(TableName) returns (Status) {}
+
+    /**
+     * @brief Build index by table method
+     *
+     * This method is used to build index by table in sync mode.
+     *
+     * @param table_name, table is going to be built index.
+     *
+     */
+    rpc CreateIndex(IndexParam) returns (Status) {}
+
+    /**
+     * @brief Add vector array to table
+     *
+     * This method is used to add vector array to table.
+     *
+     * @param table_name, table_name is inserted.
+     * @param record_array, vector array is inserted.
+     *
+     * @return vector id array
+     */
+    rpc Insert(InsertParam) returns (VectorIds) {}
+
+    /**
+     * @brief Query vector
+     *
+     * This method is used to query vector in table.
+     *
+     * @param table_name, table_name is queried.
+     * @param query_record_array, all vector are going to be queried.
+     * @param query_range_array, optional ranges for conditional search. If not specified, search whole table
+     * @param topk, how many similarity vectors will be searched.
+     *
+     * @return query result array.
+     */
+    rpc Search(SearchParam) returns (TopKQueryResultList) {}
+
+    /**
+     * @brief Internal use query interface
+     *
+     * This method is used to query vector in specified files.
+     *
+     * @param file_id_array, specified files id array, queried.
+     * @param query_record_array, all vector are going to be queried.
+     * @param query_range_array, optional ranges for conditional search. If not specified, search whole table
+     * @param topk, how many similarity vectors will be searched.
+     *
+     * @return query result array.
+     */
+    rpc SearchInFiles(SearchInFilesParam) returns (TopKQueryResultList) {}
+
+    /**
+     * @brief Get table schema
+     *
+     * This method is used to get table schema.
+     *
+     * @param table_name, target table name.
+     *
+     * @return table schema
+     */
+    rpc DescribeTable(TableName) returns (TableSchema) {}
+
+    /**
+     * @brief Get table schema
+     *
+     * This method is used to get table schema.
+     *
+     * @param table_name, target table name.
+     *
+     * @return table schema
+     */
+    rpc CountTable(TableName) returns (TableRowCount) {}
+
+    /**
+     * @brief List all tables in database
+     *
+     * This method is used to list all tables.
+     *
+     *
+     * @return table names.
+     */
+    rpc ShowTables(Command) returns (TableNameList) {}
+
+    /**
+     * @brief Give the server status
+     *
+     * This method is used to give the server status.
+     *
+     * @return Server status.
+     */
+    rpc Cmd(Command) returns (StringReply) {}
+
+     /**
+     * @brief delete table by range
+     *
+     * This method is used to delete vector by range
+     *
+     * @return rpc status.
+     */
+     rpc DeleteByRange(DeleteByRangeParam) returns (Status) {}
+
+     /**
+      * @brief preload table
+      *
+      * This method is used to preload table
+      *
+      * @return Status.
+      */
+     rpc PreloadTable(TableName) returns (Status) {}
+
+     /**
+      * @brief describe index
+      *
+      * This method is used to describe index
+      *
+      * @return Status.
+      */
+     rpc DescribeIndex(TableName) returns (IndexParam) {}
+
+     /**
+      * @brief drop index
+      *
+      * This method is used to drop index
+      *
+      * @return Status.
+      */
+     rpc DropIndex(TableName) returns (Status) {}
+
+}
diff --git a/core/src/grpc/status.proto b/core/src/grpc/status.proto
new file mode 100644
index 0000000000..2d933b8486
--- /dev/null
+++ b/core/src/grpc/status.proto
@@ -0,0 +1,36 @@
+syntax = "proto3";
+
+package milvus.grpc;
+
+enum ErrorCode {
+    SUCCESS = 0;
+    UNEXPECTED_ERROR = 1;
+    CONNECT_FAILED = 2;
+    PERMISSION_DENIED = 3;
+    TABLE_NOT_EXISTS = 4;
+    ILLEGAL_ARGUMENT = 5;
+    ILLEGAL_RANGE = 6;
+    ILLEGAL_DIMENSION = 7;
+    ILLEGAL_INDEX_TYPE = 8;
+    ILLEGAL_TABLE_NAME = 9;
+    ILLEGAL_TOPK = 10;
+    ILLEGAL_ROWRECORD = 11;
+    ILLEGAL_VECTOR_ID = 12;
+    ILLEGAL_SEARCH_RESULT = 13;
+    FILE_NOT_FOUND = 14;
+    META_FAILED = 15;
+    CACHE_FAILED = 16;
+    CANNOT_CREATE_FOLDER = 17;
+    CANNOT_CREATE_FILE = 18;
+    CANNOT_DELETE_FOLDER = 19;
+    CANNOT_DELETE_FILE = 20;
+    BUILD_INDEX_ERROR = 21;
+    ILLEGAL_NLIST = 22;
+    ILLEGAL_METRIC_TYPE = 23;
+    OUT_OF_MEMORY = 24;
+}
+
+message Status {
+    ErrorCode error_code = 1;
+    string reason = 2;
+}
\ No newline at end of file
diff --git a/core/src/index/.gitignore b/core/src/index/.gitignore
new file mode 100644
index 0000000000..c263e61d36
--- /dev/null
+++ b/core/src/index/.gitignore
@@ -0,0 +1 @@
+cmake_build
\ No newline at end of file
diff --git a/core/src/index/CMakeLists.txt b/core/src/index/CMakeLists.txt
new file mode 100644
index 0000000000..f570752b68
--- /dev/null
+++ b/core/src/index/CMakeLists.txt
@@ -0,0 +1,101 @@
+#-------------------------------------------------------------------------------
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you 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.
+#-------------------------------------------------------------------------------
+
+
+cmake_minimum_required(VERSION 3.14)
+message(STATUS "---------------core--------------")
+message(STATUS "Building using CMake version: ${CMAKE_VERSION}")
+
+set(KNOWHERE_VERSION "0.1.0")
+string(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" KNOWHERE_BASE_VERSION "${KNOWHERE_VERSION}")
+project(knowhere VERSION "${KNOWHERE_BASE_VERSION}" LANGUAGES CUDA C CXX)
+set(CMAKE_CXX_STANDARD 14)
+
+set(KNOWHERE_VERSION_MAJOR "${knowhere_VERSION_MAJOR}")
+set(KNOWHERE_VERSION_MINOR "${knowhere_VERSION_MINOR}")
+set(KNOWHERE_VERSION_PATCH "${knowhere_VERSION_PATCH}")
+if(KNOWHERE_VERSION_MAJOR STREQUAL ""
+        OR KNOWHERE_VERSION_MINOR STREQUAL ""
+        OR KNOWHERE_VERSION_PATCH STREQUAL "")
+    message(FATAL_ERROR "Failed to determine Knowhere version from '${KNOWHERE_VERSION}'")
+endif()
+
+message(STATUS "Knowhere version: "
+        "${KNOWHERE_VERSION_MAJOR}.${KNOWHERE_VERSION_MINOR}.${KNOWHERE_VERSION_PATCH} "
+        "(full: '${KNOWHERE_VERSION}')")
+
+# if no build build type is specified, default to release builds
+if(NOT CMAKE_BUILD_TYPE)
+    set(CMAKE_BUILD_TYPE Release)
+endif(NOT CMAKE_BUILD_TYPE)
+
+if(CMAKE_BUILD_TYPE STREQUAL "Release")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3 -fPIC -DELPP_THREAD_SAFE -fopenmp")
+    set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -O3")
+else()
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O0 -g -fPIC -DELPP_THREAD_SAFE -fopenmp")
+    set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -O0 -g")
+endif()
+MESSAGE(STATUS "CMAKE_CXX_FLAGS" ${CMAKE_CXX_FLAGS})
+
+find_package(CUDA)
+
+if(CMAKE_SYSTEM_PROCESSOR MATCHES "(x86)|(X86)|(amd64)|(AMD64)")
+    message(STATUS "building milvus_engine on x86 architecture")
+    set(KNOWHERE_BUILD_ARCH x86_64)
+elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "(ppc)")
+    message(STATUS "building milvus_engine on ppc architecture")
+    set(KNOWHERE_BUILD_ARCH ppc64le)
+else()
+    message(WARNING "unknown processor type")
+    message(WARNING "CMAKE_SYSTEM_PROCESSOR=${CMAKE_SYSTEM_PROCESSOR}")
+    set(KNOWHERE_BUILD_ARCH unknown)
+endif()
+
+if(CMAKE_BUILD_TYPE STREQUAL "Release")
+    set(BUILD_TYPE "release")
+else()
+    set(BUILD_TYPE "debug")
+endif()
+message(STATUS "Build type = ${BUILD_TYPE}")
+
+set(INDEX_SOURCE_DIR ${PROJECT_SOURCE_DIR})
+set(INDEX_BINARY_DIR ${PROJECT_BINARY_DIR})
+message(STATUS "Core source dir: ${PROJECT_SOURCE_DIR}")
+message(STATUS "Core binary dir: ${PROJECT_BINARY_DIR}")
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${INDEX_SOURCE_DIR}/cmake")
+
+include(ExternalProject)
+include(DefineOptionsCore)
+include(BuildUtilsCore)
+include(ThirdPartyPackagesCore)
+
+add_subdirectory(knowhere)
+
+if (BUILD_COVERAGE STREQUAL "ON")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fprofile-arcs -ftest-coverage")
+endif()
+
+set(INDEX_INCLUDE_DIRS ${INDEX_INCLUDE_DIRS} PARENT_SCOPE)
+
+if(BUILD_UNIT_TEST STREQUAL "ON")
+    add_subdirectory(unittest)
+endif()
+
+config_summary()
diff --git a/core/src/index/build.sh b/core/src/index/build.sh
new file mode 100644
index 0000000000..a77a16cf0b
--- /dev/null
+++ b/core/src/index/build.sh
@@ -0,0 +1,88 @@
+#!/bin/bash
+
+BUILD_TYPE="Debug"
+BUILD_UNITTEST="OFF"
+INSTALL_PREFIX=$(pwd)/cmake_build
+MAKE_CLEAN="OFF"
+PROFILING="OFF"
+BUILD_FAISS_WITH_MKL="OFF"
+USE_JFROG_CACHE="OFF"
+
+while getopts "p:d:t:uhrcgmj" arg
+do
+        case $arg in
+             t)
+                BUILD_TYPE=$OPTARG # BUILD_TYPE
+                ;;
+             u)
+                echo "Build and run unittest cases" ;
+                BUILD_UNITTEST="ON";
+                ;;
+             p)
+                INSTALL_PREFIX=$OPTARG
+                ;;
+             r)
+                if [[ -d cmake_build ]]; then
+                    rm ./cmake_build -r
+                    MAKE_CLEAN="ON"
+                fi
+                ;;
+             g)
+                PROFILING="ON"
+                ;;
+             m)
+                BUILD_FAISS_WITH_MKL="ON"
+                ;;
+             j)
+                USE_JFROG_CACHE="ON"
+                ;;
+             h) # help
+                echo "
+
+parameter:
+-t: build type(default: Debug)
+-u: building unit test options(default: OFF)
+-p: install prefix(default: $(pwd)/knowhere)
+-r: remove previous build directory(default: OFF)
+-g: profiling(default: OFF)
+-m: build faiss with MKL(default: OFF)
+
+usage:
+./build.sh -t \${BUILD_TYPE} [-u] [-h] [-g] [-r] [-c] [-m]
+                "
+                exit 0
+                ;;
+             ?)
+                echo "unknown argument"
+        exit 1
+        ;;
+        esac
+done
+
+if [[ ! -d cmake_build ]]; then
+	mkdir cmake_build
+	MAKE_CLEAN="ON"
+fi
+
+cd cmake_build
+
+CUDA_COMPILER=/usr/local/cuda/bin/nvcc
+
+if [[ ${MAKE_CLEAN} == "ON" ]]; then
+    CMAKE_CMD="cmake -DBUILD_UNIT_TEST=${BUILD_UNITTEST} \
+    -DCMAKE_INSTALL_PREFIX=${INSTALL_PREFIX}
+    -DCMAKE_BUILD_TYPE=${BUILD_TYPE} \
+    -DCMAKE_CUDA_COMPILER=${CUDA_COMPILER} \
+    -DMILVUS_ENABLE_PROFILING=${PROFILING} \
+    -DBUILD_FAISS_WITH_MKL=${BUILD_FAISS_WITH_MKL} \
+    -DUSE_JFROG_CACHE=${USE_JFROG_CACHE} \
+    ../"
+    echo ${CMAKE_CMD}
+
+    ${CMAKE_CMD}
+    make clean
+fi
+
+make -j 8 || exit 1
+
+make install || exit 1
diff --git a/core/src/index/cmake/BuildUtilsCore.cmake b/core/src/index/cmake/BuildUtilsCore.cmake
new file mode 100644
index 0000000000..626229bd7b
--- /dev/null
+++ b/core/src/index/cmake/BuildUtilsCore.cmake
@@ -0,0 +1,204 @@
+# Define a function that check last file modification
+function(Check_Last_Modify cache_check_lists_file_path working_dir last_modified_commit_id)
+    if(EXISTS "${working_dir}")
+        if(EXISTS "${cache_check_lists_file_path}")
+            set(GIT_LOG_SKIP_NUM 0)
+            set(_MATCH_ALL ON CACHE BOOL "Match all")
+            set(_LOOP_STATUS ON CACHE BOOL "Whether out of loop")
+            file(STRINGS ${cache_check_lists_file_path} CACHE_IGNORE_TXT)
+            while(_LOOP_STATUS)
+                foreach(_IGNORE_ENTRY ${CACHE_IGNORE_TXT})
+                    if(NOT _IGNORE_ENTRY MATCHES "^[^#]+")
+                        continue()
+                    endif()
+
+                    set(_MATCH_ALL OFF)
+                    execute_process(COMMAND git log --no-merges -1 --skip=${GIT_LOG_SKIP_NUM} --name-status --pretty= WORKING_DIRECTORY ${working_dir} OUTPUT_VARIABLE CHANGE_FILES)
+                    if(NOT CHANGE_FILES STREQUAL "")
+                        string(REPLACE "\n" ";" _CHANGE_FILES ${CHANGE_FILES})
+                        foreach(_FILE_ENTRY ${_CHANGE_FILES})
+                            string(REGEX MATCH "[^ \t]+$" _FILE_NAME ${_FILE_ENTRY})
+                            execute_process(COMMAND sh -c "echo ${_FILE_NAME} | grep ${_IGNORE_ENTRY}" RESULT_VARIABLE return_code)
+                            if (return_code EQUAL 0)
+                                execute_process(COMMAND git log --no-merges -1 --skip=${GIT_LOG_SKIP_NUM} --pretty=%H WORKING_DIRECTORY ${working_dir} OUTPUT_VARIABLE LAST_MODIFIED_COMMIT_ID)
+                                set (${last_modified_commit_id} ${LAST_MODIFIED_COMMIT_ID} PARENT_SCOPE)
+                                set(_LOOP_STATUS OFF)
+                            endif()
+                        endforeach()
+                    else()
+                        set(_LOOP_STATUS OFF)
+                    endif()
+                endforeach()
+
+                if(_MATCH_ALL)
+                    execute_process(COMMAND git log --no-merges -1 --skip=${GIT_LOG_SKIP_NUM} --pretty=%H WORKING_DIRECTORY ${working_dir} OUTPUT_VARIABLE LAST_MODIFIED_COMMIT_ID)
+                    set (${last_modified_commit_id} ${LAST_MODIFIED_COMMIT_ID} PARENT_SCOPE)
+                    set(_LOOP_STATUS OFF)
+                endif()
+
+                math(EXPR GIT_LOG_SKIP_NUM "${GIT_LOG_SKIP_NUM} + 1")
+            endwhile(_LOOP_STATUS)
+        else()
+            execute_process(COMMAND git log --no-merges -1 --skip=${GIT_LOG_SKIP_NUM} --pretty=%H WORKING_DIRECTORY ${working_dir} OUTPUT_VARIABLE LAST_MODIFIED_COMMIT_ID)
+            set (${last_modified_commit_id} ${LAST_MODIFIED_COMMIT_ID} PARENT_SCOPE)
+        endif()
+    else()
+        message(FATAL_ERROR "The directory ${working_dir} does not exist")
+    endif()
+endfunction()
+
+# Define a function that extracts a cached package
+function(ExternalProject_Use_Cache project_name package_file install_path)
+    message(STATUS "Will use cached package file: ${package_file}")
+
+    ExternalProject_Add(${project_name}
+            DOWNLOAD_COMMAND ${CMAKE_COMMAND} -E echo
+            "No download step needed (using cached package)"
+            CONFIGURE_COMMAND ${CMAKE_COMMAND} -E echo
+            "No configure step needed (using cached package)"
+            BUILD_COMMAND ${CMAKE_COMMAND} -E echo
+            "No build step needed (using cached package)"
+            INSTALL_COMMAND ${CMAKE_COMMAND} -E echo
+            "No install step needed (using cached package)"
+            )
+
+    # We want our tar files to contain the Install/<package> prefix (not for any
+    # very special reason, only for consistency and so that we can identify them
+    # in the extraction logs) which means that we must extract them in the
+    # binary (top-level build) directory to have them installed in the right
+    # place for subsequent ExternalProjects to pick them up. It seems that the
+    # only way to control the working directory is with Add_Step!
+    ExternalProject_Add_Step(${project_name} extract
+            ALWAYS 1
+            COMMAND
+            ${CMAKE_COMMAND} -E echo
+            "Extracting ${package_file} to ${install_path}"
+            COMMAND
+            ${CMAKE_COMMAND} -E tar xzvf ${package_file} ${install_path}
+            WORKING_DIRECTORY ${INDEX_BINARY_DIR}
+            )
+
+    ExternalProject_Add_StepTargets(${project_name} extract)
+endfunction()
+
+# Define a function that to create a new cached package
+function(ExternalProject_Create_Cache project_name package_file install_path cache_username cache_password cache_path)
+    if(EXISTS ${package_file})
+        message(STATUS "Removing existing package file: ${package_file}")
+        file(REMOVE ${package_file})
+    endif()
+
+    string(REGEX REPLACE "(.+)/.+$" "\\1" package_dir ${package_file})
+    if(NOT EXISTS ${package_dir})
+        file(MAKE_DIRECTORY ${package_dir})
+    endif()
+
+    message(STATUS "Will create cached package file: ${package_file}")
+
+    ExternalProject_Add_Step(${project_name} package
+            DEPENDEES install
+            BYPRODUCTS ${package_file}
+            COMMAND ${CMAKE_COMMAND} -E echo "Updating cached package file: ${package_file}"
+            COMMAND ${CMAKE_COMMAND} -E tar czvf ${package_file} ${install_path}
+            COMMAND ${CMAKE_COMMAND} -E echo "Uploading package file ${package_file} to ${cache_path}"
+            COMMAND curl -u${cache_username}:${cache_password} -T ${package_file} ${cache_path}
+            )
+
+    ExternalProject_Add_StepTargets(${project_name} package)
+endfunction()
+
+function(ADD_THIRDPARTY_LIB LIB_NAME)
+    set(options)
+    set(one_value_args SHARED_LIB STATIC_LIB)
+    set(multi_value_args DEPS INCLUDE_DIRECTORIES)
+    cmake_parse_arguments(ARG
+            "${options}"
+            "${one_value_args}"
+            "${multi_value_args}"
+            ${ARGN})
+    if(ARG_UNPARSED_ARGUMENTS)
+        message(SEND_ERROR "Error: unrecognized arguments: ${ARG_UNPARSED_ARGUMENTS}")
+    endif()
+
+    if(ARG_STATIC_LIB AND ARG_SHARED_LIB)
+        if(NOT ARG_STATIC_LIB)
+            message(FATAL_ERROR "No static or shared library provided for ${LIB_NAME}")
+        endif()
+
+        set(AUG_LIB_NAME "${LIB_NAME}_static")
+        add_library(${AUG_LIB_NAME} STATIC IMPORTED)
+        set_target_properties(${AUG_LIB_NAME}
+                PROPERTIES IMPORTED_LOCATION "${ARG_STATIC_LIB}")
+        if(ARG_DEPS)
+            set_target_properties(${AUG_LIB_NAME}
+                    PROPERTIES INTERFACE_LINK_LIBRARIES "${ARG_DEPS}")
+        endif()
+        message(STATUS "Added static library dependency ${AUG_LIB_NAME}: ${ARG_STATIC_LIB}")
+        if(ARG_INCLUDE_DIRECTORIES)
+            set_target_properties(${AUG_LIB_NAME}
+                    PROPERTIES INTERFACE_INCLUDE_DIRECTORIES
+                    "${ARG_INCLUDE_DIRECTORIES}")
+        endif()
+
+        set(AUG_LIB_NAME "${LIB_NAME}_shared")
+        add_library(${AUG_LIB_NAME} SHARED IMPORTED)
+
+        if(WIN32)
+            # Mark the ".lib" location as part of a Windows DLL
+            set_target_properties(${AUG_LIB_NAME}
+                    PROPERTIES IMPORTED_IMPLIB "${ARG_SHARED_LIB}")
+        else()
+            set_target_properties(${AUG_LIB_NAME}
+                    PROPERTIES IMPORTED_LOCATION "${ARG_SHARED_LIB}")
+        endif()
+        if(ARG_DEPS)
+            set_target_properties(${AUG_LIB_NAME}
+                    PROPERTIES INTERFACE_LINK_LIBRARIES "${ARG_DEPS}")
+        endif()
+        message(STATUS "Added shared library dependency ${AUG_LIB_NAME}: ${ARG_SHARED_LIB}")
+        if(ARG_INCLUDE_DIRECTORIES)
+            set_target_properties(${AUG_LIB_NAME}
+                    PROPERTIES INTERFACE_INCLUDE_DIRECTORIES
+                    "${ARG_INCLUDE_DIRECTORIES}")
+        endif()
+    elseif(ARG_STATIC_LIB)
+        set(AUG_LIB_NAME "${LIB_NAME}_static")
+        add_library(${AUG_LIB_NAME} STATIC IMPORTED)
+        set_target_properties(${AUG_LIB_NAME}
+                PROPERTIES IMPORTED_LOCATION "${ARG_STATIC_LIB}")
+        if(ARG_DEPS)
+            set_target_properties(${AUG_LIB_NAME}
+                    PROPERTIES INTERFACE_LINK_LIBRARIES "${ARG_DEPS}")
+        endif()
+        message(STATUS "Added static library dependency ${AUG_LIB_NAME}: ${ARG_STATIC_LIB}")
+        if(ARG_INCLUDE_DIRECTORIES)
+            set_target_properties(${AUG_LIB_NAME}
+                    PROPERTIES INTERFACE_INCLUDE_DIRECTORIES
+                    "${ARG_INCLUDE_DIRECTORIES}")
+        endif()
+    elseif(ARG_SHARED_LIB)
+        set(AUG_LIB_NAME "${LIB_NAME}_shared")
+        add_library(${AUG_LIB_NAME} SHARED IMPORTED)
+
+        if(WIN32)
+            # Mark the ".lib" location as part of a Windows DLL
+            set_target_properties(${AUG_LIB_NAME}
+                    PROPERTIES IMPORTED_IMPLIB "${ARG_SHARED_LIB}")
+        else()
+            set_target_properties(${AUG_LIB_NAME}
+                    PROPERTIES IMPORTED_LOCATION "${ARG_SHARED_LIB}")
+        endif()
+        message(STATUS "Added shared library dependency ${AUG_LIB_NAME}: ${ARG_SHARED_LIB}")
+        if(ARG_DEPS)
+            set_target_properties(${AUG_LIB_NAME}
+                    PROPERTIES INTERFACE_LINK_LIBRARIES "${ARG_DEPS}")
+        endif()
+        if(ARG_INCLUDE_DIRECTORIES)
+            set_target_properties(${AUG_LIB_NAME}
+                    PROPERTIES INTERFACE_INCLUDE_DIRECTORIES
+                    "${ARG_INCLUDE_DIRECTORIES}")
+        endif()
+    else()
+        message(FATAL_ERROR "No static or shared library provided for ${LIB_NAME}")
+    endif()
+endfunction()
diff --git a/core/src/index/cmake/DefineOptionsCore.cmake b/core/src/index/cmake/DefineOptionsCore.cmake
new file mode 100644
index 0000000000..cf5e8ea328
--- /dev/null
+++ b/core/src/index/cmake/DefineOptionsCore.cmake
@@ -0,0 +1,164 @@
+
+macro(set_option_category name)
+    set(KNOWHERE_OPTION_CATEGORY ${name})
+    list(APPEND "KNOWHERE_OPTION_CATEGORIES" ${name})
+endmacro()
+
+macro(define_option name description default)
+    option(${name} ${description} ${default})
+    list(APPEND "KNOWHERE_${KNOWHERE_OPTION_CATEGORY}_OPTION_NAMES" ${name})
+    set("${name}_OPTION_DESCRIPTION" ${description})
+    set("${name}_OPTION_DEFAULT" ${default})
+    set("${name}_OPTION_TYPE" "bool")
+endmacro()
+
+function(list_join lst glue out)
+    if("${${lst}}" STREQUAL "")
+        set(${out} "" PARENT_SCOPE)
+        return()
+    endif()
+
+    list(GET ${lst} 0 joined)
+    list(REMOVE_AT ${lst} 0)
+    foreach(item ${${lst}})
+        set(joined "${joined}${glue}${item}")
+    endforeach()
+    set(${out} ${joined} PARENT_SCOPE)
+endfunction()
+
+macro(define_option_string name description default)
+    set(${name} ${default} CACHE STRING ${description})
+    list(APPEND "KNOWHERE_${KNOWHERE_OPTION_CATEGORY}_OPTION_NAMES" ${name})
+    set("${name}_OPTION_DESCRIPTION" ${description})
+    set("${name}_OPTION_DEFAULT" "\"${default}\"")
+    set("${name}_OPTION_TYPE" "string")
+
+    set("${name}_OPTION_ENUM" ${ARGN})
+    list_join("${name}_OPTION_ENUM" "|" "${name}_OPTION_ENUM")
+    if(NOT ("${${name}_OPTION_ENUM}" STREQUAL ""))
+        set_property(CACHE ${name} PROPERTY STRINGS ${ARGN})
+    endif()
+endmacro()
+
+#----------------------------------------------------------------------
+set_option_category("Thirdparty")
+
+set(KNOWHERE_DEPENDENCY_SOURCE_DEFAULT "AUTO")
+
+define_option_string(KNOWHERE_DEPENDENCY_SOURCE
+                    "Method to use for acquiring KNOWHERE's build dependencies"
+                    "${KNOWHERE_DEPENDENCY_SOURCE_DEFAULT}"
+                    "AUTO"
+                    "BUNDLED"
+                    "SYSTEM")
+
+define_option(KNOWHERE_VERBOSE_THIRDPARTY_BUILD
+        "Show output from ExternalProjects rather than just logging to files" ON)
+
+define_option(KNOWHERE_BOOST_USE_SHARED "Rely on boost shared libraries where relevant" OFF)
+
+define_option(KNOWHERE_BOOST_VENDORED "Use vendored Boost instead of existing Boost. \
+Note that this requires linking Boost statically" OFF)
+
+define_option(KNOWHERE_BOOST_HEADER_ONLY "Use only BOOST headers" OFF)
+
+define_option(KNOWHERE_WITH_ARROW "Build with ARROW" ON)
+
+define_option(KNOWHERE_WITH_LAPACK "Build with LAPACK library" ON)
+
+define_option(KNOWHERE_WITH_FAISS "Build with FAISS library" ON)
+
+define_option(KNOWHERE_WITH_FAISS_GPU_VERSION "Build with FAISS GPU version" ON)
+
+define_option(KNOWHERE_WITH_OPENBLAS "Build with OpenBLAS library" ON)
+
+#----------------------------------------------------------------------
+if(MSVC)
+    set_option_category("MSVC")
+
+    define_option(MSVC_LINK_VERBOSE
+            "Pass verbose linking options when linking libraries and executables"
+            OFF)
+
+    define_option(KNOWHERE_USE_STATIC_CRT "Build KNOWHERE with statically linked CRT" OFF)
+endif()
+
+#----------------------------------------------------------------------
+set_option_category("Test and benchmark")
+
+if (BUILD_UNIT_TEST)
+    define_option(KNOWHERE_BUILD_TESTS "Build the KNOWHERE googletest unit tests" ON)
+else()
+    define_option(KNOWHERE_BUILD_TESTS "Build the KNOWHERE googletest unit tests" OFF)
+endif(BUILD_UNIT_TEST)
+
+#----------------------------------------------------------------------
+macro(config_summary)
+    message(STATUS "---------------------------------------------------------------------")
+    message(STATUS "KNOWHERE version:                                 ${KNOWHERE_VERSION}")
+    message(STATUS)
+    message(STATUS "Build configuration summary:")
+
+    message(STATUS "  Generator: ${CMAKE_GENERATOR}")
+    message(STATUS "  Build type: ${CMAKE_BUILD_TYPE}")
+    message(STATUS "  Source directory: ${CMAKE_CURRENT_SOURCE_DIR}")
+    if(${CMAKE_EXPORT_COMPILE_COMMANDS})
+        message(
+                STATUS "  Compile commands: ${INDEX_BINARY_DIR}/compile_commands.json")
+    endif()
+
+    foreach(category ${KNOWHERE_OPTION_CATEGORIES})
+
+        message(STATUS)
+        message(STATUS "${category} options:")
+
+        set(option_names ${KNOWHERE_${category}_OPTION_NAMES})
+
+        set(max_value_length 0)
+        foreach(name ${option_names})
+            string(LENGTH "\"${${name}}\"" value_length)
+            if(${max_value_length} LESS ${value_length})
+                set(max_value_length ${value_length})
+            endif()
+        endforeach()
+
+        foreach(name ${option_names})
+            if("${${name}_OPTION_TYPE}" STREQUAL "string")
+                set(value "\"${${name}}\"")
+            else()
+                set(value "${${name}}")
+            endif()
+
+            set(default ${${name}_OPTION_DEFAULT})
+            set(description ${${name}_OPTION_DESCRIPTION})
+            string(LENGTH ${description} description_length)
+            if(${description_length} LESS 70)
+                string(
+                        SUBSTRING
+                        "                                                                     "
+                        ${description_length} -1 description_padding)
+            else()
+                set(description_padding "
+                ")
+            endif()
+
+            set(comment "[${name}]")
+
+            if("${value}" STREQUAL "${default}")
+                set(comment "[default] ${comment}")
+            endif()
+
+            if(NOT ("${${name}_OPTION_ENUM}" STREQUAL ""))
+                set(comment "${comment} [${${name}_OPTION_ENUM}]")
+            endif()
+
+            string(
+                    SUBSTRING "${value}                                                             "
+                    0 ${max_value_length} value)
+
+            message(STATUS "  ${description} ${description_padding} ${value} ${comment}")
+        endforeach()
+
+    endforeach()
+
+endmacro()
diff --git a/core/src/index/cmake/ThirdPartyPackagesCore.cmake b/core/src/index/cmake/ThirdPartyPackagesCore.cmake
new file mode 100644
index 0000000000..7e9bb0b671
--- /dev/null
+++ b/core/src/index/cmake/ThirdPartyPackagesCore.cmake
@@ -0,0 +1,777 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you 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
+#
+#
+# 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.
+
+set(KNOWHERE_THIRDPARTY_DEPENDENCIES
+
+        ARROW
+        FAISS
+        GTest
+        LAPACK
+        OpenBLAS
+        )
+
+message(STATUS "Using ${KNOWHERE_DEPENDENCY_SOURCE} approach to find dependencies")
+
+# For each dependency, set dependency source to global default, if unset
+foreach(DEPENDENCY ${KNOWHERE_THIRDPARTY_DEPENDENCIES})
+    if("${${DEPENDENCY}_SOURCE}" STREQUAL "")
+        set(${DEPENDENCY}_SOURCE ${KNOWHERE_DEPENDENCY_SOURCE})
+    endif()
+endforeach()
+
+macro(build_dependency DEPENDENCY_NAME)
+    if("${DEPENDENCY_NAME}" STREQUAL "ARROW")
+        build_arrow()
+    elseif("${DEPENDENCY_NAME}" STREQUAL "LAPACK")
+        build_lapack()
+    elseif ("${DEPENDENCY_NAME}" STREQUAL "GTest")
+        build_gtest()
+    elseif ("${DEPENDENCY_NAME}" STREQUAL "OpenBLAS")
+        build_openblas()
+    elseif("${DEPENDENCY_NAME}" STREQUAL "FAISS")
+        build_faiss()
+    else()
+        message(FATAL_ERROR "Unknown thirdparty dependency to build: ${DEPENDENCY_NAME}")
+    endif ()
+endmacro()
+
+macro(resolve_dependency DEPENDENCY_NAME)
+    if (${DEPENDENCY_NAME}_SOURCE STREQUAL "AUTO")
+        #message(STATUS "Finding ${DEPENDENCY_NAME} package")
+            #message(STATUS "${DEPENDENCY_NAME} package not found")
+        build_dependency(${DEPENDENCY_NAME})
+    elseif (${DEPENDENCY_NAME}_SOURCE STREQUAL "BUNDLED")
+        build_dependency(${DEPENDENCY_NAME})
+    elseif (${DEPENDENCY_NAME}_SOURCE STREQUAL "SYSTEM")
+        find_package(${DEPENDENCY_NAME} REQUIRED)
+    endif ()
+endmacro()
+
+# ----------------------------------------------------------------------
+# Identify OS
+if (UNIX)
+    if (APPLE)
+        set (CMAKE_OS_NAME "osx" CACHE STRING "Operating system name" FORCE)
+    else (APPLE)
+        ## Check for Debian GNU/Linux ________________
+        find_file (DEBIAN_FOUND debian_version debconf.conf
+                PATHS /etc
+                )
+        if (DEBIAN_FOUND)
+            set (CMAKE_OS_NAME "debian" CACHE STRING "Operating system name" FORCE)
+        endif (DEBIAN_FOUND)
+        ##  Check for Fedora _________________________
+        find_file (FEDORA_FOUND fedora-release
+                PATHS /etc
+                )
+        if (FEDORA_FOUND)
+            set (CMAKE_OS_NAME "fedora" CACHE STRING "Operating system name" FORCE)
+        endif (FEDORA_FOUND)
+        ##  Check for RedHat _________________________
+        find_file (REDHAT_FOUND redhat-release inittab.RH
+                PATHS /etc
+                )
+        if (REDHAT_FOUND)
+            set (CMAKE_OS_NAME "redhat" CACHE STRING "Operating system name" FORCE)
+        endif (REDHAT_FOUND)
+        ## Extra check for Ubuntu ____________________
+        if (DEBIAN_FOUND)
+            ## At its core Ubuntu is a Debian system, with
+            ## a slightly altered configuration; hence from
+            ## a first superficial inspection a system will
+            ## be considered as Debian, which signifies an
+            ## extra check is required.
+            find_file (UBUNTU_EXTRA legal issue
+                    PATHS /etc
+                    )
+            if (UBUNTU_EXTRA)
+                ## Scan contents of file
+                file (STRINGS ${UBUNTU_EXTRA} UBUNTU_FOUND
+                        REGEX Ubuntu
+                        )
+                ## Check result of string search
+                if (UBUNTU_FOUND)
+                    set (CMAKE_OS_NAME "ubuntu" CACHE STRING "Operating system name" FORCE)
+                    set (DEBIAN_FOUND FALSE)
+                endif (UBUNTU_FOUND)
+            endif (UBUNTU_EXTRA)
+        endif (DEBIAN_FOUND)
+    endif (APPLE)
+endif (UNIX)
+
+
+# ----------------------------------------------------------------------
+# thirdparty directory
+set(THIRDPARTY_DIR "${INDEX_SOURCE_DIR}/thirdparty")
+
+# ----------------------------------------------------------------------
+# JFrog
+if(NOT DEFINED USE_JFROG_CACHE)
+    set(USE_JFROG_CACHE "OFF")
+endif()
+if(USE_JFROG_CACHE STREQUAL "ON")
+    set(JFROG_ARTFACTORY_CACHE_URL "${JFROG_ARTFACTORY_URL}/milvus/thirdparty/cache/${CMAKE_OS_NAME}/${KNOWHERE_BUILD_ARCH}/${BUILD_TYPE}")
+    set(THIRDPARTY_PACKAGE_CACHE "${THIRDPARTY_DIR}/cache")
+    if(NOT EXISTS ${THIRDPARTY_PACKAGE_CACHE})
+        message(STATUS "Will create cached directory: ${THIRDPARTY_PACKAGE_CACHE}")
+        file(MAKE_DIRECTORY ${THIRDPARTY_PACKAGE_CACHE})
+    endif()
+endif()
+
+macro(resolve_dependency DEPENDENCY_NAME)
+    if (${DEPENDENCY_NAME}_SOURCE STREQUAL "AUTO")
+        #disable find_package for now
+        build_dependency(${DEPENDENCY_NAME})
+    elseif (${DEPENDENCY_NAME}_SOURCE STREQUAL "BUNDLED")
+        build_dependency(${DEPENDENCY_NAME})
+    elseif (${DEPENDENCY_NAME}_SOURCE STREQUAL "SYSTEM")
+        find_package(${DEPENDENCY_NAME} REQUIRED)
+    endif ()
+endmacro()
+
+# ----------------------------------------------------------------------
+# ExternalProject options
+
+string(TOUPPER ${CMAKE_BUILD_TYPE} UPPERCASE_BUILD_TYPE)
+
+set(EP_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_${UPPERCASE_BUILD_TYPE}}")
+set(EP_C_FLAGS "${CMAKE_C_FLAGS} ${CMAKE_C_FLAGS_${UPPERCASE_BUILD_TYPE}}")
+
+if(NOT MSVC)
+    # Set -fPIC on all external projects
+    set(EP_CXX_FLAGS "${EP_CXX_FLAGS} -fPIC")
+    set(EP_C_FLAGS "${EP_C_FLAGS} -fPIC")
+endif()
+
+# CC/CXX environment variables are captured on the first invocation of the
+# builder (e.g make or ninja) instead of when CMake is invoked into to build
+# directory. This leads to issues if the variables are exported in a subshell
+# and the invocation of make/ninja is in distinct subshell without the same
+# environment (CC/CXX).
+set(EP_COMMON_TOOLCHAIN -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+        -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER})
+
+if(CMAKE_AR)
+    set(EP_COMMON_TOOLCHAIN ${EP_COMMON_TOOLCHAIN} -DCMAKE_AR=${CMAKE_AR})
+endif()
+
+if(CMAKE_RANLIB)
+    set(EP_COMMON_TOOLCHAIN ${EP_COMMON_TOOLCHAIN} -DCMAKE_RANLIB=${CMAKE_RANLIB})
+endif()
+
+# External projects are still able to override the following declarations.
+# cmake command line will favor the last defined variable when a duplicate is
+# encountered. This requires that `EP_COMMON_CMAKE_ARGS` is always the first
+# argument.
+set(EP_COMMON_CMAKE_ARGS
+        ${EP_COMMON_TOOLCHAIN}
+        -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
+        -DCMAKE_C_FLAGS=${EP_C_FLAGS}
+        -DCMAKE_C_FLAGS_${UPPERCASE_BUILD_TYPE}=${EP_C_FLAGS}
+        -DCMAKE_CXX_FLAGS=${EP_CXX_FLAGS}
+        -DCMAKE_CXX_FLAGS_${UPPERCASE_BUILD_TYPE}=${EP_CXX_FLAGS})
+
+if(NOT KNOWHERE_VERBOSE_THIRDPARTY_BUILD)
+    set(EP_LOG_OPTIONS LOG_CONFIGURE 1 LOG_BUILD 1 LOG_INSTALL 1 LOG_DOWNLOAD 1)
+else()
+    set(EP_LOG_OPTIONS)
+endif()
+
+# Ensure that a default make is set
+if("${MAKE}" STREQUAL "")
+    if(NOT MSVC)
+        find_program(MAKE make)
+    endif()
+endif()
+
+set(MAKE_BUILD_ARGS "-j8")
+
+
+# ----------------------------------------------------------------------
+# Find pthreads
+
+set(THREADS_PREFER_PTHREAD_FLAG ON)
+find_package(Threads REQUIRED)
+
+# ----------------------------------------------------------------------
+# Versions and URLs for toolchain builds, which also can be used to configure
+# offline builds
+
+# Read toolchain versions from cpp/thirdparty/versions.txt
+file(STRINGS "${THIRDPARTY_DIR}/versions.txt" TOOLCHAIN_VERSIONS_TXT)
+foreach(_VERSION_ENTRY ${TOOLCHAIN_VERSIONS_TXT})
+    # Exclude comments
+    if(NOT _VERSION_ENTRY MATCHES "^[^#][A-Za-z0-9-_]+_VERSION=")
+        continue()
+    endif()
+
+    string(REGEX MATCH "^[^=]*" _LIB_NAME ${_VERSION_ENTRY})
+    string(REPLACE "${_LIB_NAME}=" "" _LIB_VERSION ${_VERSION_ENTRY})
+
+    # Skip blank or malformed lines
+    if(${_LIB_VERSION} STREQUAL "")
+        continue()
+    endif()
+
+    # For debugging
+    #message(STATUS "${_LIB_NAME}: ${_LIB_VERSION}")
+
+    set(${_LIB_NAME} "${_LIB_VERSION}")
+endforeach()
+
+if(CUSTOMIZATION)
+    execute_process(COMMAND wget -q --method HEAD ${FAISS_URL} RESULT_VARIABLE return_code)
+    message(STATUS "Check the remote cache file ${FAISS_URL}. return code = ${return_code}")
+    if (NOT return_code EQUAL 0)
+        MESSAGE(FATAL_ERROR "Can't access to ${FAISS_URL}")
+    else()
+        set(FAISS_SOURCE_URL ${FAISS_URL})
+        # set(FAISS_MD5 "a589663865a8558205533c8ac414278c")
+        # set(FAISS_MD5 "57da9c4f599cc8fa4260488b1c96e1cc") # commit-id 6dbdf75987c34a2c853bd172ea0d384feea8358c branch-0.2.0
+        # set(FAISS_MD5 "21deb1c708490ca40ecb899122c01403") # commit-id 643e48f479637fd947e7b93fa4ca72b38ecc9a39 branch-0.2.0
+        # set(FAISS_MD5 "072db398351cca6e88f52d743bbb9fa0") # commit-id 3a2344d04744166af41ef1a74449d68a315bfe17 branch-0.2.1
+        # set(FAISS_MD5 "c89ea8e655f5cdf58f42486f13614714") # commit-id 9c28a1cbb88f41fa03b03d7204106201ad33276b branch-0.2.1
+        set(FAISS_MD5 "87fdd86351ffcaf3f80dc26ade63c44b") # commit-id 841a156e67e8e22cd8088e1b58c00afbf2efc30b branch-0.2.1
+    endif()
+else()
+    set(FAISS_SOURCE_URL "https://github.com/facebookresearch/faiss/archive/v1.5.3.tar.gz")
+    set(FAISS_MD5 "0bc12737b23def156f6a1eb782050135")
+endif()
+message(STATUS "FAISS URL = ${FAISS_SOURCE_URL}")
+
+if(DEFINED ENV{KNOWHERE_ARROW_URL})
+    set(ARROW_SOURCE_URL "$ENV{KNOWHERE_ARROW_URL}")
+else()
+    set(ARROW_SOURCE_URL
+            "https://github.com/apache/arrow.git"
+            )
+endif()
+
+if (DEFINED ENV{KNOWHERE_GTEST_URL})
+    set(GTEST_SOURCE_URL "$ENV{KNOWHERE_GTEST_URL}")
+else ()
+    set(GTEST_SOURCE_URL
+            "https://github.com/google/googletest/archive/release-${GTEST_VERSION}.tar.gz")
+endif()
+set(GTEST_MD5 "2e6fbeb6a91310a16efe181886c59596")
+
+if(DEFINED ENV{KNOWHERE_LAPACK_URL})
+    set(LAPACK_SOURCE_URL "$ENV{KNOWHERE_LAPACK_URL}")
+else()
+    set(LAPACK_SOURCE_URL "https://github.com/Reference-LAPACK/lapack/archive/${LAPACK_VERSION}.tar.gz")
+endif()
+set(LAPACK_MD5 "96591affdbf58c450d45c1daa540dbd2")
+
+if (DEFINED ENV{KNOWHERE_OPENBLAS_URL})
+    set(OPENBLAS_SOURCE_URL "$ENV{KNOWHERE_OPENBLAS_URL}")
+else ()
+    set(OPENBLAS_SOURCE_URL
+            "https://github.com/xianyi/OpenBLAS/archive/${OPENBLAS_VERSION}.tar.gz")
+endif()
+set(OPENBLAS_MD5 "8a110a25b819a4b94e8a9580702b6495")
+
+# ----------------------------------------------------------------------
+# ARROW
+set(ARROW_PREFIX "${INDEX_BINARY_DIR}/arrow_ep-prefix/src/arrow_ep/cpp")
+
+macro(build_arrow)
+    message(STATUS "Building Apache ARROW-${ARROW_VERSION} from source")
+    set(ARROW_STATIC_LIB_NAME arrow)
+        set(ARROW_STATIC_LIB
+            "${ARROW_PREFIX}/lib/${CMAKE_STATIC_LIBRARY_PREFIX}${ARROW_STATIC_LIB_NAME}${CMAKE_STATIC_LIBRARY_SUFFIX}"
+            )
+                set(ARROW_INCLUDE_DIR "${ARROW_PREFIX}/include")
+
+    set(ARROW_CMAKE_ARGS
+            ${EP_COMMON_CMAKE_ARGS}
+            -DARROW_BUILD_STATIC=ON
+            -DARROW_BUILD_SHARED=OFF
+            -DARROW_PARQUET=OFF
+            -DARROW_USE_GLOG=OFF
+            -DCMAKE_INSTALL_PREFIX=${ARROW_PREFIX}
+            "-DCMAKE_LIBRARY_PATH=${CUDA_TOOLKIT_ROOT_DIR}/lib64/stubs"
+            -DCMAKE_BUILD_TYPE=Release
+            -DARROW_DEPENDENCY_SOURCE=BUNDLED) #Build all arrow dependencies from source instead of calling find_package first
+
+    
+    if(USE_JFROG_CACHE STREQUAL "ON")
+        execute_process(COMMAND sh -c "git ls-remote --heads --tags ${ARROW_SOURCE_URL} ${ARROW_VERSION} | cut -f 1" OUTPUT_VARIABLE ARROW_LAST_COMMIT_ID)
+        if(${ARROW_LAST_COMMIT_ID} MATCHES "^[^#][a-z0-9]+")
+            string(MD5 ARROW_COMBINE_MD5 "${ARROW_LAST_COMMIT_ID}")
+            set(ARROW_CACHE_PACKAGE_NAME "arrow_${ARROW_COMBINE_MD5}.tar.gz")
+            set(ARROW_CACHE_URL "${JFROG_ARTFACTORY_CACHE_URL}/${ARROW_CACHE_PACKAGE_NAME}")
+            set(ARROW_CACHE_PACKAGE_PATH "${THIRDPARTY_PACKAGE_CACHE}/${ARROW_CACHE_PACKAGE_NAME}")
+
+            execute_process(COMMAND wget -q --method HEAD ${ARROW_CACHE_URL} RESULT_VARIABLE return_code)
+            message(STATUS "Check the remote file ${ARROW_CACHE_URL}. return code = ${return_code}")
+            if (NOT return_code EQUAL 0)
+                externalproject_add(arrow_ep
+                        GIT_REPOSITORY
+                        ${ARROW_SOURCE_URL}
+                        GIT_TAG
+                        ${ARROW_VERSION}
+                        GIT_SHALLOW
+                        TRUE
+                        SOURCE_SUBDIR
+                        cpp
+                        ${EP_LOG_OPTIONS}
+                        CMAKE_ARGS
+                        ${ARROW_CMAKE_ARGS}
+                        BUILD_COMMAND
+                        ""
+                        INSTALL_COMMAND
+                        ${MAKE} ${MAKE_BUILD_ARGS} install
+                        BUILD_BYPRODUCTS
+                        "${ARROW_STATIC_LIB}"
+                        )
+
+                ExternalProject_Create_Cache(arrow_ep ${ARROW_CACHE_PACKAGE_PATH} "${INDEX_BINARY_DIR}/arrow_ep-prefix" ${JFROG_USER_NAME} ${JFROG_PASSWORD} ${ARROW_CACHE_URL})
+            else()
+                file(DOWNLOAD ${ARROW_CACHE_URL} ${ARROW_CACHE_PACKAGE_PATH} STATUS status)
+                list(GET status 0 status_code)
+                message(STATUS "DOWNLOADING FROM ${ARROW_CACHE_URL} TO ${ARROW_CACHE_PACKAGE_PATH}. STATUS = ${status_code}")
+                if (status_code EQUAL 0)
+                    ExternalProject_Use_Cache(arrow_ep ${ARROW_CACHE_PACKAGE_PATH} ${INDEX_BINARY_DIR})
+                endif()
+            endif()
+        else()
+            message(FATAL_ERROR "The last commit ID of \"${ARROW_SOURCE_URL}\" repository don't match!")
+        endif()
+    else()
+        externalproject_add(arrow_ep
+                GIT_REPOSITORY
+                ${ARROW_SOURCE_URL}
+                GIT_TAG
+                ${ARROW_VERSION}
+                GIT_SHALLOW
+                TRUE
+                SOURCE_SUBDIR
+                cpp
+                ${EP_LOG_OPTIONS}
+                CMAKE_ARGS
+                ${ARROW_CMAKE_ARGS}
+                BUILD_COMMAND
+                ""
+                INSTALL_COMMAND
+                ${MAKE} ${MAKE_BUILD_ARGS} install
+                BUILD_BYPRODUCTS
+                "${ARROW_STATIC_LIB}"
+                )
+    endif()
+
+    file(MAKE_DIRECTORY "${ARROW_PREFIX}/include")
+    add_library(arrow STATIC IMPORTED)
+    set_target_properties(arrow
+            PROPERTIES IMPORTED_LOCATION "${ARROW_STATIC_LIB}"
+            INTERFACE_INCLUDE_DIRECTORIES "${ARROW_INCLUDE_DIR}")
+        add_dependencies(arrow arrow_ep)
+
+    set(JEMALLOC_PREFIX "${INDEX_BINARY_DIR}/arrow_ep-prefix/src/arrow_ep-build/jemalloc_ep-prefix/src/jemalloc_ep")
+
+    add_custom_command(TARGET arrow_ep POST_BUILD
+            COMMAND ${CMAKE_COMMAND} -E make_directory ${ARROW_PREFIX}/lib/
+            COMMAND ${CMAKE_COMMAND} -E copy ${JEMALLOC_PREFIX}/lib/libjemalloc_pic.a ${ARROW_PREFIX}/lib/
+            DEPENDS ${JEMALLOC_PREFIX}/lib/libjemalloc_pic.a)
+
+endmacro()
+
+if(KNOWHERE_WITH_ARROW AND NOT TARGET arrow_ep)
+
+    resolve_dependency(ARROW)
+
+    link_directories(SYSTEM ${ARROW_PREFIX}/lib/)
+    include_directories(SYSTEM ${ARROW_INCLUDE_DIR})
+endif()
+
+# ----------------------------------------------------------------------
+# OpenBLAS
+
+macro(build_openblas)
+    message(STATUS "Building OpenBLAS-${OPENBLAS_VERSION} from source")
+    set(OPENBLAS_PREFIX "${INDEX_BINARY_DIR}/openblas_ep-prefix/src/openblas_ep")
+    set(OPENBLAS_INCLUDE_DIR "${OPENBLAS_PREFIX}/include")
+    set(OPENBLAS_STATIC_LIB
+            "${OPENBLAS_PREFIX}/lib/${CMAKE_STATIC_LIBRARY_PREFIX}openblas${CMAKE_STATIC_LIBRARY_SUFFIX}")
+    set(OPENBLAS_REAL_STATIC_LIB
+            "${OPENBLAS_PREFIX}/lib/${CMAKE_STATIC_LIBRARY_PREFIX}openblas_haswellp-r0.3.6${CMAKE_STATIC_LIBRARY_SUFFIX}")
+
+    if(USE_JFROG_CACHE STREQUAL "ON")
+        set(OPENBLAS_CACHE_PACKAGE_NAME "openblas_${OPENBLAS_MD5}.tar.gz")
+        set(OPENBLAS_CACHE_URL "${JFROG_ARTFACTORY_CACHE_URL}/${OPENBLAS_CACHE_PACKAGE_NAME}")
+        set(OPENBLAS_CACHE_PACKAGE_PATH "${THIRDPARTY_PACKAGE_CACHE}/${OPENBLAS_CACHE_PACKAGE_NAME}")
+
+        execute_process(COMMAND wget -q --method HEAD ${OPENBLAS_CACHE_URL} RESULT_VARIABLE return_code)
+        message(STATUS "Check the remote file ${OPENBLAS_CACHE_URL}. return code = ${return_code}")
+        if (NOT return_code EQUAL 0)
+            externalproject_add(openblas_ep
+                    URL
+                    ${OPENBLAS_SOURCE_URL}
+                    ${EP_LOG_OPTIONS}
+                    CONFIGURE_COMMAND
+                    ""
+                    BUILD_IN_SOURCE
+                    1
+                    BUILD_COMMAND
+                    ${MAKE}
+                    ${MAKE_BUILD_ARGS}
+                    INSTALL_COMMAND
+                    ${MAKE}
+                    PREFIX=${OPENBLAS_PREFIX}
+                    install
+                    BUILD_BYPRODUCTS
+                    ${OPENBLAS_STATIC_LIB})
+
+            ExternalProject_Create_Cache(openblas_ep ${OPENBLAS_CACHE_PACKAGE_PATH} "${INDEX_BINARY_DIR}/openblas_ep-prefix" ${JFROG_USER_NAME} ${JFROG_PASSWORD} ${OPENBLAS_CACHE_URL})
+        else()
+            file(DOWNLOAD ${OPENBLAS_CACHE_URL} ${OPENBLAS_CACHE_PACKAGE_PATH} STATUS status)
+            list(GET status 0 status_code)
+            message(STATUS "DOWNLOADING FROM ${OPENBLAS_CACHE_URL} TO ${OPENBLAS_CACHE_PACKAGE_PATH}. STATUS = ${status_code}")
+            if (status_code EQUAL 0)
+                ExternalProject_Use_Cache(openblas_ep ${OPENBLAS_CACHE_PACKAGE_PATH} ${INDEX_BINARY_DIR})
+            endif()
+        endif()
+    else()
+        externalproject_add(openblas_ep
+                URL
+                ${OPENBLAS_SOURCE_URL}
+                ${EP_LOG_OPTIONS}
+                CONFIGURE_COMMAND
+                ""
+                BUILD_IN_SOURCE
+                1
+                BUILD_COMMAND
+                ${MAKE}
+                ${MAKE_BUILD_ARGS}
+                INSTALL_COMMAND
+                ${MAKE}
+                PREFIX=${OPENBLAS_PREFIX}
+                install
+                BUILD_BYPRODUCTS
+                ${OPENBLAS_STATIC_LIB})
+    endif()
+
+    file(MAKE_DIRECTORY "${OPENBLAS_INCLUDE_DIR}")
+    add_library(openblas STATIC IMPORTED)
+    set_target_properties(
+            openblas
+            PROPERTIES IMPORTED_LOCATION "${OPENBLAS_STATIC_LIB}"
+            INTERFACE_INCLUDE_DIRECTORIES "${OPENBLAS_INCLUDE_DIR}")
+
+    add_dependencies(openblas openblas_ep)
+endmacro()
+
+# ----------------------------------------------------------------------
+# LAPACK
+
+macro(build_lapack)
+    message(STATUS "Building LAPACK-${LAPACK_VERSION} from source")
+    set(LAPACK_PREFIX "${INDEX_BINARY_DIR}/lapack_ep-prefix/src/lapack_ep")
+    set(LAPACK_INCLUDE_DIR "${LAPACK_PREFIX}/include")
+    set(LAPACK_STATIC_LIB
+            "${LAPACK_PREFIX}/lib/${CMAKE_STATIC_LIBRARY_PREFIX}lapack${CMAKE_STATIC_LIBRARY_SUFFIX}")
+    set(BLAS_STATIC_LIB
+            "${LAPACK_PREFIX}/lib/${CMAKE_STATIC_LIBRARY_PREFIX}blas${CMAKE_STATIC_LIBRARY_SUFFIX}")
+
+    set(LAPACK_CMAKE_ARGS
+            ${EP_COMMON_CMAKE_ARGS}
+            "-DCMAKE_INSTALL_PREFIX=${LAPACK_PREFIX}"
+            -DCMAKE_INSTALL_LIBDIR=lib)
+
+    if(USE_JFROG_CACHE STREQUAL "ON")
+        set(LAPACK_CACHE_PACKAGE_NAME "lapack_${LAPACK_MD5}.tar.gz")
+        set(LAPACK_CACHE_URL "${JFROG_ARTFACTORY_CACHE_URL}/${LAPACK_CACHE_PACKAGE_NAME}")
+        set(LAPACK_CACHE_PACKAGE_PATH "${THIRDPARTY_PACKAGE_CACHE}/${LAPACK_CACHE_PACKAGE_NAME}")
+
+        execute_process(COMMAND wget -q --method HEAD ${LAPACK_CACHE_URL} RESULT_VARIABLE return_code)
+        message(STATUS "Check the remote file ${LAPACK_CACHE_URL}. return code = ${return_code}")
+        if (NOT return_code EQUAL 0)
+            externalproject_add(lapack_ep
+                    URL
+                    ${LAPACK_SOURCE_URL}
+                    ${EP_LOG_OPTIONS}
+                    CMAKE_ARGS
+                    ${LAPACK_CMAKE_ARGS}
+                    BUILD_COMMAND
+                    ${MAKE}
+                    ${MAKE_BUILD_ARGS}
+                    BUILD_BYPRODUCTS
+                    ${LAPACK_STATIC_LIB})
+
+            ExternalProject_Create_Cache(lapack_ep ${LAPACK_CACHE_PACKAGE_PATH} "${INDEX_BINARY_DIR}/lapack_ep-prefix" ${JFROG_USER_NAME} ${JFROG_PASSWORD} ${LAPACK_CACHE_URL})
+        else()
+            file(DOWNLOAD ${LAPACK_CACHE_URL} ${LAPACK_CACHE_PACKAGE_PATH} STATUS status)
+            list(GET status 0 status_code)
+            message(STATUS "DOWNLOADING FROM ${LAPACK_CACHE_URL} TO ${LAPACK_CACHE_PACKAGE_PATH}. STATUS = ${status_code}")
+            if (status_code EQUAL 0)
+                ExternalProject_Use_Cache(lapack_ep ${LAPACK_CACHE_PACKAGE_PATH} ${INDEX_BINARY_DIR})
+            endif()
+        endif()
+    else()
+        externalproject_add(lapack_ep
+                URL
+                ${LAPACK_SOURCE_URL}
+                ${EP_LOG_OPTIONS}
+                CMAKE_ARGS
+                ${LAPACK_CMAKE_ARGS}
+                BUILD_COMMAND
+                ${MAKE}
+                ${MAKE_BUILD_ARGS}
+                BUILD_BYPRODUCTS
+                ${LAPACK_STATIC_LIB})
+    endif()
+
+    file(MAKE_DIRECTORY "${LAPACK_INCLUDE_DIR}")
+    add_library(lapack STATIC IMPORTED)
+    set_target_properties(
+            lapack
+            PROPERTIES IMPORTED_LOCATION "${LAPACK_STATIC_LIB}"
+            INTERFACE_INCLUDE_DIRECTORIES "${LAPACK_INCLUDE_DIR}")
+
+    add_dependencies(lapack lapack_ep)
+endmacro()
+
+# ----------------------------------------------------------------------
+# Google gtest
+
+macro(build_gtest)
+    message(STATUS "Building gtest-${GTEST_VERSION} from source")
+    set(GTEST_VENDORED TRUE)
+    set(GTEST_CMAKE_CXX_FLAGS "${EP_CXX_FLAGS}")
+
+    if(APPLE)
+        set(GTEST_CMAKE_CXX_FLAGS
+                ${GTEST_CMAKE_CXX_FLAGS}
+                -DGTEST_USE_OWN_TR1_TUPLE=1
+                -Wno-unused-value
+                -Wno-ignored-attributes)
+    endif()
+
+    set(GTEST_PREFIX "${INDEX_BINARY_DIR}/googletest_ep-prefix/src/googletest_ep")
+    set(GTEST_INCLUDE_DIR "${GTEST_PREFIX}/include")
+    set(GTEST_STATIC_LIB
+            "${GTEST_PREFIX}/lib/${CMAKE_STATIC_LIBRARY_PREFIX}gtest${CMAKE_STATIC_LIBRARY_SUFFIX}")
+    set(GTEST_MAIN_STATIC_LIB
+            "${GTEST_PREFIX}/lib/${CMAKE_STATIC_LIBRARY_PREFIX}gtest_main${CMAKE_STATIC_LIBRARY_SUFFIX}")
+
+    set(GTEST_CMAKE_ARGS
+            ${EP_COMMON_CMAKE_ARGS}
+            "-DCMAKE_INSTALL_PREFIX=${GTEST_PREFIX}"
+            "-DCMAKE_INSTALL_LIBDIR=lib"
+            -DCMAKE_CXX_FLAGS=${GTEST_CMAKE_CXX_FLAGS}
+            -DCMAKE_BUILD_TYPE=Release)
+
+    set(GMOCK_INCLUDE_DIR "${GTEST_PREFIX}/include")
+    set(GMOCK_STATIC_LIB
+            "${GTEST_PREFIX}/lib/${CMAKE_STATIC_LIBRARY_PREFIX}gmock${CMAKE_STATIC_LIBRARY_SUFFIX}"
+    )
+
+
+    if(USE_JFROG_CACHE STREQUAL "ON")
+        set(GTEST_CACHE_PACKAGE_NAME "googletest_${GTEST_MD5}.tar.gz")
+        set(GTEST_CACHE_URL "${JFROG_ARTFACTORY_CACHE_URL}/${GTEST_CACHE_PACKAGE_NAME}")
+        set(GTEST_CACHE_PACKAGE_PATH "${THIRDPARTY_PACKAGE_CACHE}/${GTEST_CACHE_PACKAGE_NAME}")
+
+        execute_process(COMMAND wget -q --method HEAD ${GTEST_CACHE_URL} RESULT_VARIABLE return_code)
+        message(STATUS "Check the remote file ${GTEST_CACHE_URL}. return code = ${return_code}")
+        if (NOT return_code EQUAL 0)
+            ExternalProject_Add(googletest_ep
+                    URL
+                    ${GTEST_SOURCE_URL}
+                    BUILD_COMMAND
+                    ${MAKE}
+                    ${MAKE_BUILD_ARGS}
+                    BUILD_BYPRODUCTS
+                    ${GTEST_STATIC_LIB}
+                    ${GTEST_MAIN_STATIC_LIB}
+                    ${GMOCK_STATIC_LIB}
+                    CMAKE_ARGS
+                    ${GTEST_CMAKE_ARGS}
+                    ${EP_LOG_OPTIONS})
+
+            ExternalProject_Create_Cache(googletest_ep ${GTEST_CACHE_PACKAGE_PATH} "${INDEX_BINARY_DIR}/googletest_ep-prefix" ${JFROG_USER_NAME} ${JFROG_PASSWORD} ${GTEST_CACHE_URL})
+        else()
+            file(DOWNLOAD ${GTEST_CACHE_URL} ${GTEST_CACHE_PACKAGE_PATH} STATUS status)
+            list(GET status 0 status_code)
+            message(STATUS "DOWNLOADING FROM ${GTEST_CACHE_URL} TO ${GTEST_CACHE_PACKAGE_PATH}. STATUS = ${status_code}")
+            if (status_code EQUAL 0)
+                ExternalProject_Use_Cache(googletest_ep ${GTEST_CACHE_PACKAGE_PATH} ${INDEX_BINARY_DIR})
+            endif()
+        endif()
+    else()
+        ExternalProject_Add(googletest_ep
+                URL
+                ${GTEST_SOURCE_URL}
+                BUILD_COMMAND
+                ${MAKE}
+                ${MAKE_BUILD_ARGS}
+                BUILD_BYPRODUCTS
+                ${GTEST_STATIC_LIB}
+                ${GTEST_MAIN_STATIC_LIB}
+                ${GMOCK_STATIC_LIB}
+                CMAKE_ARGS
+                ${GTEST_CMAKE_ARGS}
+                ${EP_LOG_OPTIONS})
+    endif()
+
+    # The include directory must exist before it is referenced by a target.
+    file(MAKE_DIRECTORY "${GTEST_INCLUDE_DIR}")
+
+    add_library(gtest STATIC IMPORTED)
+    set_target_properties(gtest
+                            PROPERTIES IMPORTED_LOCATION "${GTEST_STATIC_LIB}"
+                            INTERFACE_INCLUDE_DIRECTORIES "${GTEST_INCLUDE_DIR}")
+
+    add_library(gtest_main STATIC IMPORTED)
+    set_target_properties(gtest_main
+                            PROPERTIES IMPORTED_LOCATION "${GTEST_MAIN_STATIC_LIB}"
+                            INTERFACE_INCLUDE_DIRECTORIES "${GTEST_INCLUDE_DIR}")
+
+    add_library(gmock STATIC IMPORTED)
+    set_target_properties(gmock
+            PROPERTIES IMPORTED_LOCATION "${GMOCK_STATIC_LIB}"
+            INTERFACE_INCLUDE_DIRECTORIES "${GTEST_INCLUDE_DIR}")
+
+    add_dependencies(gtest googletest_ep)
+    add_dependencies(gtest_main googletest_ep)
+    add_dependencies(gmock googletest_ep)
+
+endmacro()
+
+if (KNOWHERE_BUILD_TESTS AND NOT TARGET googletest_ep)
+    resolve_dependency(GTest)
+
+    if(NOT GTEST_VENDORED)
+    endif()
+
+    # TODO: Don't use global includes but rather target_include_directories
+    get_target_property(GTEST_INCLUDE_DIR gtest INTERFACE_INCLUDE_DIRECTORIES)
+    link_directories(SYSTEM "${GTEST_PREFIX}/lib")
+    include_directories(SYSTEM ${GTEST_INCLUDE_DIR})
+endif()
+
+# ----------------------------------------------------------------------
+# FAISS
+
+macro(build_faiss)
+    message(STATUS "Building FAISS-${FAISS_VERSION} from source")
+    set(FAISS_PREFIX "${INDEX_BINARY_DIR}/faiss_ep-prefix/src/faiss_ep")
+    set(FAISS_INCLUDE_DIR "${FAISS_PREFIX}/include")
+    set(FAISS_STATIC_LIB
+            "${FAISS_PREFIX}/lib/${CMAKE_STATIC_LIBRARY_PREFIX}faiss${CMAKE_STATIC_LIBRARY_SUFFIX}")
+
+                    
+    set(FAISS_CONFIGURE_ARGS
+            "--prefix=${FAISS_PREFIX}"
+            "CFLAGS=${EP_C_FLAGS}"
+            "CXXFLAGS=${EP_CXX_FLAGS}"
+            "LDFLAGS=-L${OPENBLAS_PREFIX}/lib -L${LAPACK_PREFIX}/lib -lopenblas -llapack"
+            --without-python)
+
+                        
+    if(${KNOWHERE_WITH_FAISS_GPU_VERSION} STREQUAL "ON")
+        set(FAISS_CONFIGURE_ARGS ${FAISS_CONFIGURE_ARGS}
+                "--with-cuda=${CUDA_TOOLKIT_ROOT_DIR}"
+                "--with-cuda-arch=-gencode=arch=compute_60,code=sm_60 -gencode=arch=compute_61,code=sm_61 -gencode=arch=compute_70,code=sm_70 -gencode=arch=compute_75,code=sm_75"
+                )
+    else()
+        set(FAISS_CONFIGURE_ARGS ${FAISS_CONFIGURE_ARGS} --without-cuda)
+    endif()
+
+    if(USE_JFROG_CACHE STREQUAL "ON")
+        string(MD5 FAISS_COMBINE_MD5 "${FAISS_MD5}${LAPACK_MD5}${OPENBLAS_MD5}")
+        set(FAISS_CACHE_PACKAGE_NAME "faiss_${FAISS_COMBINE_MD5}.tar.gz")
+        set(FAISS_CACHE_URL "${JFROG_ARTFACTORY_CACHE_URL}/${FAISS_CACHE_PACKAGE_NAME}")
+        set(FAISS_CACHE_PACKAGE_PATH "${THIRDPARTY_PACKAGE_CACHE}/${FAISS_CACHE_PACKAGE_NAME}")
+
+        execute_process(COMMAND wget -q --method HEAD ${FAISS_CACHE_URL} RESULT_VARIABLE return_code)
+        message(STATUS "Check the remote file ${FAISS_CACHE_URL}. return code = ${return_code}")
+        if (NOT return_code EQUAL 0)
+            externalproject_add(faiss_ep
+                    URL
+                    ${FAISS_SOURCE_URL}
+                    ${EP_LOG_OPTIONS}
+                    CONFIGURE_COMMAND
+                    "./configure"
+                    ${FAISS_CONFIGURE_ARGS}
+                    BUILD_COMMAND
+                    ${MAKE} ${MAKE_BUILD_ARGS} all
+                    BUILD_IN_SOURCE
+                    1
+                    INSTALL_COMMAND
+                    ${MAKE} install
+                    BUILD_BYPRODUCTS
+                    ${FAISS_STATIC_LIB})
+
+            ExternalProject_Add_StepDependencies(faiss_ep build openblas_ep lapack_ep)
+
+            ExternalProject_Create_Cache(faiss_ep ${FAISS_CACHE_PACKAGE_PATH} "${INDEX_BINARY_DIR}/faiss_ep-prefix" ${JFROG_USER_NAME} ${JFROG_PASSWORD} ${FAISS_CACHE_URL})
+        else()
+            file(DOWNLOAD ${FAISS_CACHE_URL} ${FAISS_CACHE_PACKAGE_PATH} STATUS status)
+            list(GET status 0 status_code)
+            message(STATUS "DOWNLOADING FROM ${FAISS_CACHE_URL} TO ${FAISS_CACHE_PACKAGE_PATH}. STATUS = ${status_code}")
+            if (status_code EQUAL 0)
+                ExternalProject_Use_Cache(faiss_ep ${FAISS_CACHE_PACKAGE_PATH} ${INDEX_BINARY_DIR})
+            endif()
+        endif()
+    else()
+        externalproject_add(faiss_ep
+                URL
+                ${FAISS_SOURCE_URL}
+                ${EP_LOG_OPTIONS}
+                CONFIGURE_COMMAND
+                "./configure"
+                ${FAISS_CONFIGURE_ARGS}
+                BUILD_COMMAND
+                ${MAKE} ${MAKE_BUILD_ARGS} all
+                BUILD_IN_SOURCE
+                1
+                INSTALL_COMMAND
+                ${MAKE} install
+                BUILD_BYPRODUCTS
+                ${FAISS_STATIC_LIB})
+
+        ExternalProject_Add_StepDependencies(faiss_ep build openblas_ep lapack_ep)
+    endif()
+
+    file(MAKE_DIRECTORY "${FAISS_INCLUDE_DIR}")
+    add_library(faiss STATIC IMPORTED)
+    set_target_properties(
+            faiss
+            PROPERTIES IMPORTED_LOCATION "${FAISS_STATIC_LIB}"
+            INTERFACE_INCLUDE_DIRECTORIES "${FAISS_INCLUDE_DIR}"
+            INTERFACE_LINK_LIBRARIES "openblas;lapack" )
+
+    add_dependencies(faiss faiss_ep)
+
+endmacro()
+
+if(KNOWHERE_WITH_FAISS AND NOT TARGET faiss_ep)
+
+    resolve_dependency(OpenBLAS)
+    get_target_property(OPENBLAS_INCLUDE_DIR openblas INTERFACE_INCLUDE_DIRECTORIES)
+    include_directories(SYSTEM "${OPENBLAS_INCLUDE_DIR}")
+    link_directories(SYSTEM ${OPENBLAS_PREFIX}/lib)
+
+    resolve_dependency(LAPACK)
+    get_target_property(LAPACK_INCLUDE_DIR lapack INTERFACE_INCLUDE_DIRECTORIES)
+    include_directories(SYSTEM "${LAPACK_INCLUDE_DIR}")
+    link_directories(SYSTEM "${LAPACK_PREFIX}/lib")
+
+    resolve_dependency(FAISS)
+    get_target_property(FAISS_INCLUDE_DIR faiss INTERFACE_INCLUDE_DIRECTORIES)
+    include_directories(SYSTEM "${FAISS_INCLUDE_DIR}")
+    link_directories(SYSTEM ${FAISS_PREFIX}/lib/)
+endif()
diff --git a/core/src/index/knowhere/CMakeLists.txt b/core/src/index/knowhere/CMakeLists.txt
new file mode 100644
index 0000000000..2a499dc1a3
--- /dev/null
+++ b/core/src/index/knowhere/CMakeLists.txt
@@ -0,0 +1,128 @@
+include_directories(${CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES})
+link_directories(${CUDA_TOOLKIT_ROOT_DIR}/lib64)
+
+include_directories(${INDEX_SOURCE_DIR}/knowhere)
+include_directories(${INDEX_SOURCE_DIR}/thirdparty)
+include_directories(${INDEX_SOURCE_DIR}/thirdparty/SPTAG/AnnService)
+
+set(SPTAG_SOURCE_DIR ${INDEX_SOURCE_DIR}/thirdparty/SPTAG)
+file(GLOB HDR_FILES
+        ${SPTAG_SOURCE_DIR}/AnnService/inc/Core/*.h
+        ${SPTAG_SOURCE_DIR}/AnnService/inc/Core/Common/*.h
+        ${SPTAG_SOURCE_DIR}/AnnService/inc/Core/BKT/*.h
+        ${SPTAG_SOURCE_DIR}/AnnService/inc/Core/KDT/*.h
+        ${SPTAG_SOURCE_DIR}/AnnService/inc/Helper/*.h)
+file(GLOB SRC_FILES
+        ${SPTAG_SOURCE_DIR}/AnnService/src/Core/*.cpp
+        ${SPTAG_SOURCE_DIR}/AnnService/src/Core/Common/*.cpp
+        ${SPTAG_SOURCE_DIR}/AnnService/src/Core/BKT/*.cpp
+        ${SPTAG_SOURCE_DIR}/AnnService/src/Core/KDT/*.cpp
+        ${SPTAG_SOURCE_DIR}/AnnService/src/Helper/*.cpp)
+
+if(NOT TARGET SPTAGLibStatic)
+    add_library(SPTAGLibStatic STATIC ${SRC_FILES} ${HDR_FILES})
+endif()
+
+set(external_srcs
+        knowhere/adapter/SptagAdapter.cpp
+        knowhere/adapter/Structure.cpp
+        knowhere/adapter/ArrowAdapter.cpp
+        knowhere/common/Exception.cpp
+        knowhere/common/Timer.cpp
+        )
+
+set(index_srcs
+        knowhere/index/preprocessor/Normalize.cpp
+        knowhere/index/vector_index/IndexKDT.cpp
+        knowhere/index/vector_index/IndexIDMAP.cpp
+        knowhere/index/vector_index/IndexIVF.cpp
+        knowhere/index/vector_index/IndexGPUIVF.cpp
+        knowhere/index/vector_index/helpers/KDTParameterMgr.cpp
+        knowhere/index/vector_index/IndexNSG.cpp
+        knowhere/index/vector_index/nsg/NSG.cpp
+        knowhere/index/vector_index/nsg/NSGIO.cpp
+        knowhere/index/vector_index/nsg/NSGHelper.cpp
+        knowhere/index/vector_index/helpers/Cloner.cpp
+        knowhere/index/vector_index/helpers/FaissGpuResourceMgr.cpp
+        knowhere/index/vector_index/IndexIVFSQ.cpp
+        knowhere/index/vector_index/IndexGPUIVFSQ.cpp
+        knowhere/index/vector_index/IndexIVFSQHybrid.cpp
+        knowhere/index/vector_index/IndexIVFPQ.cpp
+        knowhere/index/vector_index/IndexGPUIVFPQ.cpp
+        knowhere/index/vector_index/FaissBaseIndex.cpp
+        knowhere/index/vector_index/helpers/FaissIO.cpp
+        knowhere/index/vector_index/helpers/IndexParameter.cpp
+        )
+
+set(depend_libs
+        SPTAGLibStatic
+        faiss
+        openblas
+        lapack
+        arrow
+        ${ARROW_PREFIX}/lib/libjemalloc_pic.a
+        cudart
+        cublas
+        gomp
+        gfortran
+        pthread
+        )
+
+if(NOT TARGET knowhere)
+    add_library(
+            knowhere STATIC
+            ${external_srcs}
+            ${index_srcs}
+    )
+endif()
+
+target_link_libraries(
+        knowhere
+        ${depend_libs}
+)
+
+INSTALL(TARGETS
+        knowhere
+        SPTAGLibStatic
+        DESTINATION
+        lib)
+
+INSTALL(FILES
+        ${ARROW_STATIC_LIB}
+        ${ARROW_PREFIX}/lib/libjemalloc_pic.a
+        ${FAISS_STATIC_LIB}
+        ${LAPACK_STATIC_LIB}
+        ${BLAS_STATIC_LIB}
+        DESTINATION
+        lib
+        )
+
+INSTALL(FILES ${OPENBLAS_REAL_STATIC_LIB}
+        RENAME "libopenblas.a"
+        DESTINATION lib
+        )
+
+set(INDEX_INCLUDE_DIRS
+        ${INDEX_SOURCE_DIR}/knowhere
+        ${INDEX_SOURCE_DIR}/thirdparty
+        ${INDEX_SOURCE_DIR}/thirdparty/SPTAG/AnnService
+        ${ARROW_INCLUDE_DIR}
+        ${FAISS_INCLUDE_DIR}
+        ${OPENBLAS_INCLUDE_DIR}
+        ${LAPACK_INCLUDE_DIR}
+        )
+
+set(INDEX_INCLUDE_DIRS ${INDEX_INCLUDE_DIRS} PARENT_SCOPE)
+
+#INSTALL(DIRECTORY
+#        ${INDEX_SOURCE_DIR}/include/knowhere
+#        ${ARROW_INCLUDE_DIR}/arrow
+#        ${FAISS_PREFIX}/include/faiss
+#        ${OPENBLAS_INCLUDE_DIR}/
+#        DESTINATION
+#        include)
+#
+#INSTALL(DIRECTORY
+#        ${SPTAG_SOURCE_DIR}/AnnService/inc/
+#        DESTINATION
+#        include/SPTAG/AnnService/inc)
diff --git a/core/src/index/knowhere/knowhere/adapter/ArrowAdapter.cpp b/core/src/index/knowhere/knowhere/adapter/ArrowAdapter.cpp
new file mode 100644
index 0000000000..38227f43ab
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/adapter/ArrowAdapter.cpp
@@ -0,0 +1,53 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "knowhere/adapter/ArrowAdapter.h"
+
+namespace knowhere {
+
+ArrayPtr
+CopyArray(const ArrayPtr& origin) {
+    ArrayPtr copy = nullptr;
+    auto copy_data = origin->data()->Copy();
+    switch (origin->type_id()) {
+#define DEFINE_TYPE(type, clazz)                          \
+    case arrow::Type::type: {                             \
+        copy = std::make_shared<arrow::clazz>(copy_data); \
+    }
+        DEFINE_TYPE(BOOL, BooleanArray)
+        DEFINE_TYPE(BINARY, BinaryArray)
+        DEFINE_TYPE(FIXED_SIZE_BINARY, FixedSizeBinaryArray)
+        DEFINE_TYPE(DECIMAL, Decimal128Array)
+        DEFINE_TYPE(FLOAT, NumericArray<arrow::FloatType>)
+        DEFINE_TYPE(INT64, NumericArray<arrow::Int64Type>)
+        default:
+            break;
+    }
+    return copy;
+}
+
+SchemaPtr
+CopySchema(const SchemaPtr& origin) {
+    std::vector<std::shared_ptr<Field>> fields;
+    for (auto& field : origin->fields()) {
+        auto copy = std::make_shared<Field>(field->name(), field->type(), field->nullable(), nullptr);
+        fields.emplace_back(copy);
+    }
+    return std::make_shared<Schema>(std::move(fields));
+}
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/adapter/ArrowAdapter.h b/core/src/index/knowhere/knowhere/adapter/ArrowAdapter.h
new file mode 100644
index 0000000000..75580cd163
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/adapter/ArrowAdapter.h
@@ -0,0 +1,34 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include "knowhere/common/Array.h"
+
+namespace knowhere {
+
+ArrayPtr
+CopyArray(const ArrayPtr& origin);
+
+SchemaPtr
+CopySchema(const SchemaPtr& origin);
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/adapter/SptagAdapter.cpp b/core/src/index/knowhere/knowhere/adapter/SptagAdapter.cpp
new file mode 100644
index 0000000000..b4c3910a01
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/adapter/SptagAdapter.cpp
@@ -0,0 +1,122 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "knowhere/adapter/SptagAdapter.h"
+#include "knowhere/adapter/Structure.h"
+#include "knowhere/index/vector_index/helpers/Definitions.h"
+
+namespace knowhere {
+
+std::shared_ptr<SPTAG::MetadataSet>
+ConvertToMetadataSet(const DatasetPtr& dataset) {
+    auto array = dataset->array()[0];
+    auto elems = array->length();
+
+    auto p_data = array->data()->GetValues<int64_t>(1, 0);
+    auto p_offset = (int64_t*)malloc(sizeof(int64_t) * elems);
+    for (auto i = 0; i <= elems; ++i) p_offset[i] = i * 8;
+
+    std::shared_ptr<SPTAG::MetadataSet> metaset(
+        new SPTAG::MemMetadataSet(SPTAG::ByteArray((std::uint8_t*)p_data, elems * sizeof(int64_t), false),
+                                  SPTAG::ByteArray((std::uint8_t*)p_offset, elems * sizeof(int64_t), true), elems));
+
+    return metaset;
+}
+
+std::shared_ptr<SPTAG::VectorSet>
+ConvertToVectorSet(const DatasetPtr& dataset) {
+    auto tensor = dataset->tensor()[0];
+
+    auto p_data = tensor->raw_mutable_data();
+    auto dimension = tensor->shape()[1];
+    auto rows = tensor->shape()[0];
+    auto num_bytes = tensor->size() * sizeof(float);
+
+    SPTAG::ByteArray byte_array(p_data, num_bytes, false);
+
+    auto vectorset =
+        std::make_shared<SPTAG::BasicVectorSet>(byte_array, SPTAG::VectorValueType::Float, dimension, rows);
+    return vectorset;
+}
+
+std::vector<SPTAG::QueryResult>
+ConvertToQueryResult(const DatasetPtr& dataset, const Config& config) {
+    auto tensor = dataset->tensor()[0];
+
+    auto p_data = (float*)tensor->raw_mutable_data();
+    auto dimension = tensor->shape()[1];
+    auto rows = tensor->shape()[0];
+
+    std::vector<SPTAG::QueryResult> query_results(rows, SPTAG::QueryResult(nullptr, config->k, true));
+    for (auto i = 0; i < rows; ++i) {
+        query_results[i].SetTarget(&p_data[i * dimension]);
+    }
+
+    return query_results;
+}
+
+DatasetPtr
+ConvertToDataset(std::vector<SPTAG::QueryResult> query_results) {
+    auto k = query_results[0].GetResultNum();
+    auto elems = query_results.size() * k;
+
+    auto p_id = (int64_t*)malloc(sizeof(int64_t) * elems);
+    auto p_dist = (float*)malloc(sizeof(float) * elems);
+    // TODO: throw if malloc failed.
+
+#pragma omp parallel for
+    for (auto i = 0; i < query_results.size(); ++i) {
+        auto results = query_results[i].GetResults();
+        auto num_result = query_results[i].GetResultNum();
+        for (auto j = 0; j < num_result; ++j) {
+            //            p_id[i * k + j] = results[j].VID;
+            p_id[i * k + j] = *(int64_t*)query_results[i].GetMetadata(j).Data();
+            p_dist[i * k + j] = results[j].Dist;
+        }
+    }
+
+    auto id_buf = MakeMutableBufferSmart((uint8_t*)p_id, sizeof(int64_t) * elems);
+    auto dist_buf = MakeMutableBufferSmart((uint8_t*)p_dist, sizeof(float) * elems);
+
+    // TODO: magic
+    std::vector<BufferPtr> id_bufs{nullptr, id_buf};
+    std::vector<BufferPtr> dist_bufs{nullptr, dist_buf};
+
+    auto int64_type = std::make_shared<arrow::Int64Type>();
+    auto float_type = std::make_shared<arrow::FloatType>();
+
+    auto id_array_data = arrow::ArrayData::Make(int64_type, elems, id_bufs);
+    auto dist_array_data = arrow::ArrayData::Make(float_type, elems, dist_bufs);
+    //    auto id_array_data = std::make_shared<ArrayData>(int64_type, sizeof(int64_t) * elems, id_bufs);
+    //    auto dist_array_data = std::make_shared<ArrayData>(float_type, sizeof(float) * elems, dist_bufs);
+
+    //    auto ids = ConstructInt64Array((uint8_t*)p_id, sizeof(int64_t) * elems);
+    //    auto dists = ConstructFloatArray((uint8_t*)p_dist, sizeof(float) * elems);
+
+    auto ids = std::make_shared<NumericArray<arrow::Int64Type>>(id_array_data);
+    auto dists = std::make_shared<NumericArray<arrow::FloatType>>(dist_array_data);
+    std::vector<ArrayPtr> array{ids, dists};
+
+    auto field_id = std::make_shared<Field>("id", std::make_shared<arrow::Int64Type>());
+    auto field_dist = std::make_shared<Field>("dist", std::make_shared<arrow::FloatType>());
+    std::vector<FieldPtr> fields{field_id, field_dist};
+    auto schema = std::make_shared<Schema>(fields);
+
+    return std::make_shared<Dataset>(array, schema);
+}
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/adapter/SptagAdapter.h b/core/src/index/knowhere/knowhere/adapter/SptagAdapter.h
new file mode 100644
index 0000000000..9f92497562
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/adapter/SptagAdapter.h
@@ -0,0 +1,40 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <SPTAG/AnnService/inc/Core/VectorIndex.h>
+#include <memory>
+#include <vector>
+
+#include "knowhere/common/Dataset.h"
+
+namespace knowhere {
+
+std::shared_ptr<SPTAG::VectorSet>
+ConvertToVectorSet(const DatasetPtr& dataset);
+
+std::shared_ptr<SPTAG::MetadataSet>
+ConvertToMetadataSet(const DatasetPtr& dataset);
+
+std::vector<SPTAG::QueryResult>
+ConvertToQueryResult(const DatasetPtr& dataset, const Config& config);
+
+DatasetPtr
+ConvertToDataset(std::vector<SPTAG::QueryResult> query_results);
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/adapter/Structure.cpp b/core/src/index/knowhere/knowhere/adapter/Structure.cpp
new file mode 100644
index 0000000000..44b068c792
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/adapter/Structure.cpp
@@ -0,0 +1,87 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "knowhere/adapter/Structure.h"
+
+#include <string>
+#include <vector>
+
+namespace knowhere {
+
+ArrayPtr
+ConstructInt64ArraySmart(uint8_t* data, int64_t size) {
+    // TODO: magic
+    std::vector<BufferPtr> id_buf{nullptr, MakeMutableBufferSmart(data, size)};
+    auto type = std::make_shared<arrow::Int64Type>();
+    auto id_array_data = arrow::ArrayData::Make(type, size / sizeof(int64_t), id_buf);
+    return std::make_shared<NumericArray<arrow::Int64Type>>(id_array_data);
+}
+
+ArrayPtr
+ConstructFloatArraySmart(uint8_t* data, int64_t size) {
+    // TODO: magic
+    std::vector<BufferPtr> id_buf{nullptr, MakeMutableBufferSmart(data, size)};
+    auto type = std::make_shared<arrow::FloatType>();
+    auto id_array_data = arrow::ArrayData::Make(type, size / sizeof(float), id_buf);
+    return std::make_shared<NumericArray<arrow::FloatType>>(id_array_data);
+}
+
+TensorPtr
+ConstructFloatTensorSmart(uint8_t* data, int64_t size, std::vector<int64_t> shape) {
+    auto buffer = MakeMutableBufferSmart(data, size);
+    auto float_type = std::make_shared<arrow::FloatType>();
+    return std::make_shared<Tensor>(float_type, buffer, shape);
+}
+
+ArrayPtr
+ConstructInt64Array(uint8_t* data, int64_t size) {
+    // TODO: magic
+    std::vector<BufferPtr> id_buf{nullptr, MakeMutableBuffer(data, size)};
+    auto type = std::make_shared<arrow::Int64Type>();
+    auto id_array_data = arrow::ArrayData::Make(type, size / sizeof(int64_t), id_buf);
+    return std::make_shared<NumericArray<arrow::Int64Type>>(id_array_data);
+}
+
+ArrayPtr
+ConstructFloatArray(uint8_t* data, int64_t size) {
+    // TODO: magic
+    std::vector<BufferPtr> id_buf{nullptr, MakeMutableBuffer(data, size)};
+    auto type = std::make_shared<arrow::FloatType>();
+    auto id_array_data = arrow::ArrayData::Make(type, size / sizeof(float), id_buf);
+    return std::make_shared<NumericArray<arrow::FloatType>>(id_array_data);
+}
+
+TensorPtr
+ConstructFloatTensor(uint8_t* data, int64_t size, std::vector<int64_t> shape) {
+    auto buffer = MakeMutableBuffer(data, size);
+    auto float_type = std::make_shared<arrow::FloatType>();
+    return std::make_shared<Tensor>(float_type, buffer, shape);
+}
+
+FieldPtr
+ConstructInt64Field(const std::string& name) {
+    auto type = std::make_shared<arrow::Int64Type>();
+    return std::make_shared<Field>(name, type);
+}
+
+FieldPtr
+ConstructFloatField(const std::string& name) {
+    auto type = std::make_shared<arrow::FloatType>();
+    return std::make_shared<Field>(name, type);
+}
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/adapter/Structure.h b/core/src/index/knowhere/knowhere/adapter/Structure.h
new file mode 100644
index 0000000000..6bde9ddfe6
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/adapter/Structure.h
@@ -0,0 +1,52 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "knowhere/common/Dataset.h"
+
+namespace knowhere {
+
+extern ArrayPtr
+ConstructInt64ArraySmart(uint8_t* data, int64_t size);
+
+extern ArrayPtr
+ConstructFloatArraySmart(uint8_t* data, int64_t size);
+
+extern TensorPtr
+ConstructFloatTensorSmart(uint8_t* data, int64_t size, std::vector<int64_t> shape);
+
+extern ArrayPtr
+ConstructInt64Array(uint8_t* data, int64_t size);
+
+extern ArrayPtr
+ConstructFloatArray(uint8_t* data, int64_t size);
+
+extern TensorPtr
+ConstructFloatTensor(uint8_t* data, int64_t size, std::vector<int64_t> shape);
+
+extern FieldPtr
+ConstructInt64Field(const std::string& name);
+
+extern FieldPtr
+ConstructFloatField(const std::string& name);
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/adapter/VectorAdapter.h b/core/src/index/knowhere/knowhere/adapter/VectorAdapter.h
new file mode 100644
index 0000000000..2b16227bb3
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/adapter/VectorAdapter.h
@@ -0,0 +1,28 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+namespace knowhere {
+
+#define GETTENSOR(dataset)              \
+    auto tensor = dataset->tensor()[0]; \
+    auto p_data = tensor->raw_data();   \
+    auto dim = tensor->shape()[1];      \
+    auto rows = tensor->shape()[0];
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/common/Array.h b/core/src/index/knowhere/knowhere/common/Array.h
new file mode 100644
index 0000000000..71ad78b79b
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/common/Array.h
@@ -0,0 +1,50 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <arrow/array.h>
+#include <memory>
+
+#include "Schema.h"
+
+namespace knowhere {
+
+using ArrayData = arrow::ArrayData;
+using ArrayDataPtr = std::shared_ptr<ArrayData>;
+
+using Array = arrow::Array;
+using ArrayPtr = std::shared_ptr<Array>;
+
+using BooleanArray = arrow::BooleanArray;
+using BooleanArrayPtr = std::shared_ptr<arrow::BooleanArray>;
+
+template <typename DType>
+using NumericArray = arrow::NumericArray<DType>;
+template <typename DType>
+using NumericArrayPtr = std::shared_ptr<arrow::NumericArray<DType>>;
+
+using BinaryArray = arrow::BinaryArray;
+using BinaryArrayPtr = std::shared_ptr<arrow::BinaryArray>;
+
+using FixedSizeBinaryArray = arrow::FixedSizeBinaryArray;
+using FixedSizeBinaryArrayPtr = std::shared_ptr<arrow::FixedSizeBinaryArray>;
+
+using Decimal128Array = arrow::Decimal128Array;
+using Decimal128ArrayPtr = std::shared_ptr<arrow::Decimal128Array>;
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/common/BinarySet.h b/core/src/index/knowhere/knowhere/common/BinarySet.h
new file mode 100644
index 0000000000..6e6d53000e
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/common/BinarySet.h
@@ -0,0 +1,75 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <map>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "Id.h"
+
+namespace knowhere {
+
+struct Binary {
+    ID id;
+    std::shared_ptr<uint8_t> data;
+    int64_t size = 0;
+};
+using BinaryPtr = std::shared_ptr<Binary>;
+
+class BinarySet {
+ public:
+    BinaryPtr
+    GetByName(const std::string& name) const {
+        return binary_map_.at(name);
+    }
+
+    void
+    Append(const std::string& name, BinaryPtr binary) {
+        binary_map_[name] = std::move(binary);
+    }
+
+    void
+    Append(const std::string& name, std::shared_ptr<uint8_t> data, int64_t size) {
+        auto binary = std::make_shared<Binary>();
+        binary->data = data;
+        binary->size = size;
+        binary_map_[name] = std::move(binary);
+    }
+
+    // void
+    // Append(const std::string &name, void *data, int64_t size, ID id) {
+    //    Binary binary;
+    //    binary.data = data;
+    //    binary.size = size;
+    //    binary.id = id;
+    //    binary_map_[name] = binary;
+    //}
+
+    void
+    clear() {
+        binary_map_.clear();
+    }
+
+ public:
+    std::map<std::string, BinaryPtr> binary_map_;
+};
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/common/Buffer.h b/core/src/index/knowhere/knowhere/common/Buffer.h
new file mode 100644
index 0000000000..f9e15d95bd
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/common/Buffer.h
@@ -0,0 +1,61 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <memory>
+
+#include <arrow/buffer.h>
+
+namespace knowhere {
+
+using Buffer = arrow::Buffer;
+using BufferPtr = std::shared_ptr<Buffer>;
+using MutableBuffer = arrow::MutableBuffer;
+using MutableBufferPtr = std::shared_ptr<MutableBuffer>;
+
+namespace internal {
+
+struct BufferDeleter {
+    void
+    operator()(Buffer* buffer) {
+        free((void*)buffer->data());
+    }
+};
+}  // namespace internal
+
+inline BufferPtr
+MakeBufferSmart(uint8_t* data, const int64_t size) {
+    return BufferPtr(new Buffer(data, size), internal::BufferDeleter());
+}
+
+inline MutableBufferPtr
+MakeMutableBufferSmart(uint8_t* data, const int64_t size) {
+    return MutableBufferPtr(new MutableBuffer(data, size), internal::BufferDeleter());
+}
+
+inline BufferPtr
+MakeBuffer(uint8_t* data, const int64_t size) {
+    return std::make_shared<Buffer>(data, size);
+}
+
+inline MutableBufferPtr
+MakeMutableBuffer(uint8_t* data, const int64_t size) {
+    return std::make_shared<MutableBuffer>(data, size);
+}
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/common/Config.h b/core/src/index/knowhere/knowhere/common/Config.h
new file mode 100644
index 0000000000..6191ecb771
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/common/Config.h
@@ -0,0 +1,56 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <memory>
+
+namespace knowhere {
+
+enum class METRICTYPE {
+    INVALID = 0,
+    L2 = 1,
+    IP = 2,
+};
+
+// General Config
+constexpr int64_t INVALID_VALUE = -1;
+constexpr int64_t DEFAULT_K = INVALID_VALUE;
+constexpr int64_t DEFAULT_DIM = INVALID_VALUE;
+constexpr int64_t DEFAULT_GPUID = INVALID_VALUE;
+constexpr METRICTYPE DEFAULT_TYPE = METRICTYPE::INVALID;
+
+struct Cfg {
+    METRICTYPE metric_type = DEFAULT_TYPE;
+    int64_t k = DEFAULT_K;
+    int64_t gpu_id = DEFAULT_GPUID;
+    int64_t d = DEFAULT_DIM;
+
+    Cfg(const int64_t& dim, const int64_t& k, const int64_t& gpu_id, METRICTYPE type)
+        : metric_type(type), k(k), gpu_id(gpu_id), d(dim) {
+    }
+
+    Cfg() = default;
+
+    virtual bool
+    CheckValid() {
+        return true;
+    }
+};
+using Config = std::shared_ptr<Cfg>;
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/common/Dataset.h b/core/src/index/knowhere/knowhere/common/Dataset.h
new file mode 100644
index 0000000000..1331239dd6
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/common/Dataset.h
@@ -0,0 +1,149 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include "Array.h"
+#include "Buffer.h"
+#include "Config.h"
+#include "Schema.h"
+#include "Tensor.h"
+#include "knowhere/adapter/ArrowAdapter.h"
+
+namespace knowhere {
+
+class Dataset;
+
+using DatasetPtr = std::shared_ptr<Dataset>;
+
+class Dataset {
+ public:
+    Dataset() = default;
+
+    Dataset(std::vector<ArrayPtr>&& array, SchemaPtr array_schema, std::vector<TensorPtr>&& tensor,
+            SchemaPtr tensor_schema)
+        : array_(std::move(array)),
+          array_schema_(std::move(array_schema)),
+          tensor_(std::move(tensor)),
+          tensor_schema_(std::move(tensor_schema)) {
+    }
+
+    Dataset(std::vector<ArrayPtr> array, SchemaPtr array_schema)
+        : array_(std::move(array)), array_schema_(std::move(array_schema)) {
+    }
+
+    Dataset(std::vector<TensorPtr> tensor, SchemaPtr tensor_schema)
+        : tensor_(std::move(tensor)), tensor_schema_(std::move(tensor_schema)) {
+    }
+
+    Dataset(const Dataset&) = delete;
+    Dataset&
+    operator=(const Dataset&) = delete;
+
+    DatasetPtr
+    Clone() {
+        auto dataset = std::make_shared<Dataset>();
+
+        std::vector<ArrayPtr> clone_array;
+        for (auto& array : array_) {
+            clone_array.emplace_back(CopyArray(array));
+        }
+        dataset->set_array(clone_array);
+
+        std::vector<TensorPtr> clone_tensor;
+        for (auto& tensor : tensor_) {
+            auto buffer = tensor->data();
+            std::shared_ptr<Buffer> copy_buffer;
+            // TODO: checkout copy success;
+            buffer->Copy(0, buffer->size(), &copy_buffer);
+            auto copy = std::make_shared<Tensor>(tensor->type(), copy_buffer, tensor->shape());
+            clone_tensor.emplace_back(copy);
+        }
+        dataset->set_tensor(clone_tensor);
+
+        if (array_schema_)
+            dataset->set_array_schema(CopySchema(array_schema_));
+        if (tensor_schema_)
+            dataset->set_tensor_schema(CopySchema(tensor_schema_));
+
+        return dataset;
+    }
+
+ public:
+    const std::vector<ArrayPtr>&
+    array() const {
+        return array_;
+    }
+
+    void
+    set_array(std::vector<ArrayPtr> array) {
+        array_ = std::move(array);
+    }
+
+    const std::vector<TensorPtr>&
+    tensor() const {
+        return tensor_;
+    }
+
+    void
+    set_tensor(std::vector<TensorPtr> tensor) {
+        tensor_ = std::move(tensor);
+    }
+
+    SchemaConstPtr
+    array_schema() const {
+        return array_schema_;
+    }
+
+    void
+    set_array_schema(SchemaPtr array_schema) {
+        array_schema_ = std::move(array_schema);
+    }
+
+    SchemaConstPtr
+    tensor_schema() const {
+        return tensor_schema_;
+    }
+
+    void
+    set_tensor_schema(SchemaPtr tensor_schema) {
+        tensor_schema_ = std::move(tensor_schema);
+    }
+
+    // const Config &
+    // meta() const { return meta_; }
+
+    // void
+    // set_meta(Config meta) {
+    //    meta_ = std::move(meta);
+    //}
+
+ private:
+    std::vector<ArrayPtr> array_;
+    SchemaPtr array_schema_;
+    std::vector<TensorPtr> tensor_;
+    SchemaPtr tensor_schema_;
+    // Config meta_;
+};
+
+using DatasetPtr = std::shared_ptr<Dataset>;
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/common/Exception.cpp b/core/src/index/knowhere/knowhere/common/Exception.cpp
new file mode 100644
index 0000000000..4fef9529ac
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/common/Exception.cpp
@@ -0,0 +1,49 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 <cstdio>
+
+#include "Log.h"
+#include "knowhere/common/Exception.h"
+
+namespace knowhere {
+
+KnowhereException::KnowhereException(const std::string& msg) : msg(msg) {
+}
+
+KnowhereException::KnowhereException(const std::string& m, const char* funcName, const char* file, int line) {
+#ifdef DEBUG
+    int size = snprintf(nullptr, 0, "Error in %s at %s:%d: %s", funcName, file, line, m.c_str());
+    msg.resize(size + 1);
+    snprintf(&msg[0], msg.size(), "Error in %s at %s:%d: %s", funcName, file, line, m.c_str());
+#else
+    std::string file_path(file);
+    auto const pos = file_path.find_last_of('/');
+    auto filename = file_path.substr(pos + 1).c_str();
+
+    int size = snprintf(nullptr, 0, "Error in %s at %s:%d: %s", funcName, filename, line, m.c_str());
+    msg.resize(size + 1);
+    snprintf(&msg[0], msg.size(), "Error in %s at %s:%d: %s", funcName, filename, line, m.c_str());
+#endif
+}
+
+const char*
+KnowhereException::what() const noexcept {
+    return msg.c_str();
+}
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/common/Exception.h b/core/src/index/knowhere/knowhere/common/Exception.h
new file mode 100644
index 0000000000..9ffc7838cf
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/common/Exception.h
@@ -0,0 +1,53 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <exception>
+#include <string>
+
+namespace knowhere {
+
+class KnowhereException : public std::exception {
+ public:
+    explicit KnowhereException(const std::string& msg);
+
+    KnowhereException(const std::string& msg, const char* funName, const char* file, int line);
+
+    const char*
+    what() const noexcept override;
+
+    std::string msg;
+};
+
+#define KNOHWERE_ERROR_MSG(MSG) printf("%s", KnowhereException(MSG, __PRETTY_FUNCTION__, __FILE__, __LINE__).what())
+
+#define KNOWHERE_THROW_MSG(MSG)                                                \
+    do {                                                                       \
+        throw KnowhereException(MSG, __PRETTY_FUNCTION__, __FILE__, __LINE__); \
+    } while (false)
+
+#define KNOHERE_THROW_FORMAT(FMT, ...)                                             \
+    do {                                                                           \
+        std::string __s;                                                           \
+        int __size = snprintf(nullptr, 0, FMT, __VA_ARGS__);                       \
+        __s.resize(__size + 1);                                                    \
+        snprintf(&__s[0], __s.size(), FMT, __VA_ARGS__);                           \
+        throw faiss::FaissException(__s, __PRETTY_FUNCTION__, __FILE__, __LINE__); \
+    } while (false)
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/common/Id.h b/core/src/index/knowhere/knowhere/common/Id.h
new file mode 100644
index 0000000000..1c82161684
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/common/Id.h
@@ -0,0 +1,56 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <stdint.h>
+#include <string>
+
+namespace knowhere {
+
+class ID {
+ public:
+    constexpr static int64_t kIDSize = 20;
+
+ public:
+    const int32_t*
+    data() const {
+        return content_;
+    }
+
+    int32_t*
+    mutable_data() {
+        return content_;
+    }
+
+    bool
+    IsValid() const;
+
+    std::string
+    ToString() const;
+
+    bool
+    operator==(const ID& that) const;
+
+    bool
+    operator<(const ID& that) const;
+
+ protected:
+    int32_t content_[5] = {};
+};
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/common/Log.h b/core/src/index/knowhere/knowhere/common/Log.h
new file mode 100644
index 0000000000..222d03d73e
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/common/Log.h
@@ -0,0 +1,34 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "utils/easylogging++.h"
+
+namespace knowhere {
+
+#define KNOWHERE_DOMAIN_NAME "[KNOWHERE] "
+#define KNOWHERE_ERROR_TEXT "KNOWHERE Error:"
+
+#define KNOWHERE_LOG_TRACE LOG(TRACE) << KNOWHERE_DOMAIN_NAME
+#define KNOWHERE_LOG_DEBUG LOG(DEBUG) << KNOWHERE_DOMAIN_NAME
+#define KNOWHERE_LOG_INFO LOG(INFO) << KNOWHERE_DOMAIN_NAME
+#define KNOWHERE_LOG_WARNING LOG(WARNING) << KNOWHERE_DOMAIN_NAME
+#define KNOWHERE_LOG_ERROR LOG(ERROR) << KNOWHERE_DOMAIN_NAME
+#define KNOWHERE_LOG_FATAL LOG(FATAL) << KNOWHERE_DOMAIN_NAME
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/common/Schema.h b/core/src/index/knowhere/knowhere/common/Schema.h
new file mode 100644
index 0000000000..c90bac7572
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/common/Schema.h
@@ -0,0 +1,33 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <memory>
+
+#include <arrow/type.h>
+
+namespace knowhere {
+
+using DataType = arrow::DataType;
+using Field = arrow::Field;
+using FieldPtr = std::shared_ptr<arrow::Field>;
+using Schema = arrow::Schema;
+using SchemaPtr = std::shared_ptr<Schema>;
+using SchemaConstPtr = std::shared_ptr<const Schema>;
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/common/Tensor.h b/core/src/index/knowhere/knowhere/common/Tensor.h
new file mode 100644
index 0000000000..ff957319e5
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/common/Tensor.h
@@ -0,0 +1,29 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <memory>
+
+#include <arrow/tensor.h>
+
+namespace knowhere {
+
+using Tensor = arrow::Tensor;
+using TensorPtr = std::shared_ptr<Tensor>;
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/common/Timer.cpp b/core/src/index/knowhere/knowhere/common/Timer.cpp
new file mode 100644
index 0000000000..fefe1e1705
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/common/Timer.cpp
@@ -0,0 +1,100 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 <iostream>  // TODO(linxj): using Log instead
+
+#include "knowhere/common/Timer.h"
+
+namespace knowhere {
+
+TimeRecorder::TimeRecorder(const std::string& header, int64_t log_level) : header_(header), log_level_(log_level) {
+    start_ = last_ = stdclock::now();
+}
+
+TimeRecorder::~TimeRecorder() {
+}
+
+std::string
+TimeRecorder::GetTimeSpanStr(double span) {
+    std::string str_sec = std::to_string(span * 0.000001) + ((span > 1000000) ? " seconds" : " second");
+    std::string str_ms = std::to_string(span * 0.001) + " ms";
+
+    return str_sec + " [" + str_ms + "]";
+}
+
+void
+TimeRecorder::PrintTimeRecord(const std::string& msg, double span) {
+    std::string str_log;
+    if (!header_.empty())
+        str_log += header_ + ": ";
+    str_log += msg;
+    str_log += " (";
+    str_log += TimeRecorder::GetTimeSpanStr(span);
+    str_log += ")";
+
+    switch (log_level_) {
+        case 0: {
+            std::cout << str_log << std::endl;
+            break;
+        }
+            // case 1: {
+            //    SERVER_LOG_DEBUG << str_log;
+            //    break;
+            //}
+            // case 2: {
+            //    SERVER_LOG_INFO << str_log;
+            //    break;
+            //}
+            // case 3: {
+            //    SERVER_LOG_WARNING << str_log;
+            //    break;
+            //}
+            // case 4: {
+            //    SERVER_LOG_ERROR << str_log;
+            //    break;
+            //}
+            // case 5: {
+            //    SERVER_LOG_FATAL << str_log;
+            //    break;
+            //}
+            // default: {
+            //    SERVER_LOG_INFO << str_log;
+            //    break;
+            //}
+    }
+}
+
+double
+TimeRecorder::RecordSection(const std::string& msg) {
+    stdclock::time_point curr = stdclock::now();
+    double span = (std::chrono::duration<double, std::micro>(curr - last_)).count();
+    last_ = curr;
+
+    PrintTimeRecord(msg, span);
+    return span;
+}
+
+double
+TimeRecorder::ElapseFromBegin(const std::string& msg) {
+    stdclock::time_point curr = stdclock::now();
+    double span = (std::chrono::duration<double, std::micro>(curr - start_)).count();
+
+    PrintTimeRecord(msg, span);
+    return span;
+}
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/common/Timer.h b/core/src/index/knowhere/knowhere/common/Timer.h
new file mode 100644
index 0000000000..7e01e88aa9
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/common/Timer.h
@@ -0,0 +1,53 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <chrono>
+#include <string>
+
+namespace knowhere {
+
+class TimeRecorder {
+    using stdclock = std::chrono::high_resolution_clock;
+
+ public:
+    explicit TimeRecorder(const std::string& header, int64_t log_level = 0);
+
+    ~TimeRecorder();  // trace = 0, debug = 1, info = 2, warn = 3, error = 4, critical = 5
+
+    double
+    RecordSection(const std::string& msg);
+
+    double
+    ElapseFromBegin(const std::string& msg);
+
+    static std::string
+    GetTimeSpanStr(double span);
+
+ private:
+    void
+    PrintTimeRecord(const std::string& msg, double span);
+
+ private:
+    std::string header_;
+    stdclock::time_point start_;
+    stdclock::time_point last_;
+    int64_t log_level_;
+};
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/index/Index.h b/core/src/index/knowhere/knowhere/index/Index.h
new file mode 100644
index 0000000000..ffa685689b
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/index/Index.h
@@ -0,0 +1,67 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <memory>
+
+#include "IndexModel.h"
+#include "IndexType.h"
+#include "knowhere/common/BinarySet.h"
+#include "knowhere/common/Dataset.h"
+#include "knowhere/index/preprocessor/Preprocessor.h"
+
+namespace knowhere {
+
+class Index {
+ public:
+    virtual BinarySet
+    Serialize() = 0;
+
+    virtual void
+    Load(const BinarySet& index_binary) = 0;
+
+    // @throw
+    virtual DatasetPtr
+    Search(const DatasetPtr& dataset, const Config& config) = 0;
+
+ public:
+    IndexType
+    idx_type() const {
+        return idx_type_;
+    }
+
+    void
+    set_idx_type(IndexType idx_type) {
+        idx_type_ = idx_type;
+    }
+
+    virtual void
+    set_preprocessor(PreprocessorPtr preprocessor) {
+    }
+
+    virtual void
+    set_index_model(IndexModelPtr model) {
+    }
+
+ private:
+    IndexType idx_type_;
+};
+
+using IndexPtr = std::shared_ptr<Index>;
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/index/IndexModel.h b/core/src/index/knowhere/knowhere/index/IndexModel.h
new file mode 100644
index 0000000000..1229e21f2c
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/index/IndexModel.h
@@ -0,0 +1,36 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <memory>
+#include "knowhere/common/BinarySet.h"
+
+namespace knowhere {
+
+class IndexModel {
+ public:
+    virtual BinarySet
+    Serialize() = 0;
+
+    virtual void
+    Load(const BinarySet& binary) = 0;
+};
+
+using IndexModelPtr = std::shared_ptr<IndexModel>;
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/index/IndexType.h b/core/src/index/knowhere/knowhere/index/IndexType.h
new file mode 100644
index 0000000000..e39b57bf44
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/index/IndexType.h
@@ -0,0 +1,29 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+namespace knowhere {
+
+enum class IndexType {
+    kUnknown = 0,
+    kVecIdxBegin = 100,
+    kVecIVFFlat = kVecIdxBegin,
+    kVecIdxEnd,
+};
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/index/preprocessor/Normalize.cpp b/core/src/index/knowhere/knowhere/index/preprocessor/Normalize.cpp
new file mode 100644
index 0000000000..f21c787abe
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/index/preprocessor/Normalize.cpp
@@ -0,0 +1,57 @@
+//// Licensed to the Apache Software Foundation (ASF) under one
+//// or more contributor license agreements.  See the NOTICE file
+//// distributed with this work for additional information
+//// regarding copyright ownership.  The ASF licenses this file
+//// to you 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 "knowhere/index/vector_index/definitions.h"
+//#include "knowhere/common/config.h"
+#include "knowhere/index/preprocessor/Normalize.h"
+//
+//
+//
+// namespace knowhere {
+//
+// DatasetPtr
+// NormalizePreprocessor::Preprocess(const DatasetPtr &dataset) {
+//    // TODO: wrap dataset->tensor
+//    auto tensor = dataset->tensor()[0];
+//    auto p_data = (float *)tensor->raw_mutable_data();
+//    auto dimension = tensor->shape()[1];
+//    auto rows = tensor->shape()[0];
+//
+//#pragma omp parallel for
+//    for (auto i = 0; i < rows; ++i) {
+//        Normalize(&(p_data[i * dimension]), dimension);
+//    }
+//}
+//
+// void
+// NormalizePreprocessor::Normalize(float *arr, int64_t dimension) {
+//    double vector_length = 0;
+//    for (auto j = 0; j < dimension; j++) {
+//        double val = arr[j];
+//        vector_length += val * val;
+//    }
+//    vector_length = std::sqrt(vector_length);
+//    if (vector_length < 1e-6) {
+//        auto val = (float) (1.0 / std::sqrt((double) dimension));
+//        for (int j = 0; j < dimension; j++) arr[j] = val;
+//    } else {
+//        for (int j = 0; j < dimension; j++) arr[j] = (float) (arr[j] / vector_length);
+//    }
+//}
+//
+//} // namespace knowhere
+//
diff --git a/core/src/index/knowhere/knowhere/index/preprocessor/Normalize.h b/core/src/index/knowhere/knowhere/index/preprocessor/Normalize.h
new file mode 100644
index 0000000000..572c447b27
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/index/preprocessor/Normalize.h
@@ -0,0 +1,43 @@
+//// Licensed to the Apache Software Foundation (ASF) under one
+//// or more contributor license agreements.  See the NOTICE file
+//// distributed with this work for additional information
+//// regarding copyright ownership.  The ASF licenses this file
+//// to you 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.
+//
+//#pragma once
+//
+//#include <memory>
+//#include "preprocessor.h"
+//
+//
+//
+// namespace knowhere {
+//
+// class NormalizePreprocessor : public Preprocessor {
+// public:
+//    DatasetPtr
+//    Preprocess(const DatasetPtr &input) override;
+//
+// private:
+//
+//    void
+//    Normalize(float *arr, int64_t dimension);
+//};
+//
+//
+// using NormalizePreprocessorPtr = std::shared_ptr<NormalizePreprocessor>;
+//
+//
+//} // namespace knowhere
+//
diff --git a/core/src/index/knowhere/knowhere/index/preprocessor/Preprocessor.h b/core/src/index/knowhere/knowhere/index/preprocessor/Preprocessor.h
new file mode 100644
index 0000000000..d1cb1817d6
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/index/preprocessor/Preprocessor.h
@@ -0,0 +1,34 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <memory>
+
+#include "knowhere/common/Dataset.h"
+
+namespace knowhere {
+
+class Preprocessor {
+ public:
+    virtual DatasetPtr
+    Preprocess(const DatasetPtr& input) = 0;
+};
+
+using PreprocessorPtr = std::shared_ptr<Preprocessor>;
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/index/vector_index/FaissBaseIndex.cpp b/core/src/index/knowhere/knowhere/index/vector_index/FaissBaseIndex.cpp
new file mode 100644
index 0000000000..783487be3a
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/index/vector_index/FaissBaseIndex.cpp
@@ -0,0 +1,76 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 <faiss/index_io.h>
+#include <utility>
+
+#include "knowhere/common/Exception.h"
+#include "knowhere/index/vector_index/FaissBaseIndex.h"
+#include "knowhere/index/vector_index/IndexIVF.h"
+#include "knowhere/index/vector_index/helpers/FaissIO.h"
+
+namespace knowhere {
+
+FaissBaseIndex::FaissBaseIndex(std::shared_ptr<faiss::Index> index) : index_(std::move(index)) {
+}
+
+BinarySet
+FaissBaseIndex::SerializeImpl() {
+    try {
+        faiss::Index* index = index_.get();
+
+        SealImpl();
+
+        MemoryIOWriter writer;
+        faiss::write_index(index, &writer);
+        auto data = std::make_shared<uint8_t>();
+        data.reset(writer.data_);
+
+        BinarySet res_set;
+        // TODO(linxj): use virtual func Name() instead of raw string.
+        res_set.Append("IVF", data, writer.rp);
+        return res_set;
+    } catch (std::exception& e) {
+        KNOWHERE_THROW_MSG(e.what());
+    }
+}
+
+void
+FaissBaseIndex::LoadImpl(const BinarySet& index_binary) {
+    auto binary = index_binary.GetByName("IVF");
+
+    MemoryIOReader reader;
+    reader.total = binary->size;
+    reader.data_ = binary->data.get();
+
+    faiss::Index* index = faiss::read_index(&reader);
+
+    index_.reset(index);
+}
+
+void
+FaissBaseIndex::SealImpl() {
+#ifdef CUSTOMIZATION
+    faiss::Index* index = index_.get();
+    auto idx = dynamic_cast<faiss::IndexIVF*>(index);
+    if (idx != nullptr) {
+        idx->to_readonly();
+    }
+#endif
+}
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/index/vector_index/FaissBaseIndex.h b/core/src/index/knowhere/knowhere/index/vector_index/FaissBaseIndex.h
new file mode 100644
index 0000000000..f3fceebb88
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/index/vector_index/FaissBaseIndex.h
@@ -0,0 +1,45 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <memory>
+
+#include <faiss/Index.h>
+
+#include "knowhere/common/BinarySet.h"
+
+namespace knowhere {
+
+class FaissBaseIndex {
+ protected:
+    explicit FaissBaseIndex(std::shared_ptr<faiss::Index> index);
+
+    virtual BinarySet
+    SerializeImpl();
+
+    virtual void
+    LoadImpl(const BinarySet& index_binary);
+
+    virtual void
+    SealImpl();
+
+ protected:
+    std::shared_ptr<faiss::Index> index_ = nullptr;
+};
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/index/vector_index/IndexGPUIVF.cpp b/core/src/index/knowhere/knowhere/index/vector_index/IndexGPUIVF.cpp
new file mode 100644
index 0000000000..a5e8f90f34
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/index/vector_index/IndexGPUIVF.cpp
@@ -0,0 +1,196 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 <faiss/gpu/GpuAutoTune.h>
+#include <faiss/gpu/GpuIndexFlat.h>
+#include <faiss/gpu/GpuIndexIVF.h>
+#include <faiss/gpu/GpuIndexIVFFlat.h>
+#include <faiss/index_io.h>
+#include <memory>
+
+#include "knowhere/adapter/VectorAdapter.h"
+#include "knowhere/common/Exception.h"
+#include "knowhere/index/vector_index/IndexGPUIVF.h"
+#include "knowhere/index/vector_index/IndexIVFPQ.h"
+#include "knowhere/index/vector_index/helpers/Cloner.h"
+#include "knowhere/index/vector_index/helpers/FaissIO.h"
+
+namespace knowhere {
+
+IndexModelPtr
+GPUIVF::Train(const DatasetPtr& dataset, const Config& config) {
+    auto build_cfg = std::dynamic_pointer_cast<IVFCfg>(config);
+    if (build_cfg != nullptr) {
+        build_cfg->CheckValid();  // throw exception
+    }
+    gpu_id_ = build_cfg->gpu_id;
+
+    GETTENSOR(dataset)
+
+    auto temp_resource = FaissGpuResourceMgr::GetInstance().GetRes(gpu_id_);
+    if (temp_resource != nullptr) {
+        ResScope rs(temp_resource, gpu_id_, true);
+        faiss::gpu::GpuIndexIVFFlatConfig idx_config;
+        idx_config.device = gpu_id_;
+        faiss::gpu::GpuIndexIVFFlat device_index(temp_resource->faiss_res.get(), dim, build_cfg->nlist,
+                                                 GetMetricType(build_cfg->metric_type), idx_config);
+        device_index.train(rows, (float*)p_data);
+
+        std::shared_ptr<faiss::Index> host_index = nullptr;
+        host_index.reset(faiss::gpu::index_gpu_to_cpu(&device_index));
+
+        return std::make_shared<IVFIndexModel>(host_index);
+    } else {
+        KNOWHERE_THROW_MSG("Build IVF can't get gpu resource");
+    }
+}
+
+void
+GPUIVF::set_index_model(IndexModelPtr model) {
+    std::lock_guard<std::mutex> lk(mutex_);
+
+    auto host_index = std::static_pointer_cast<IVFIndexModel>(model);
+    if (auto gpures = FaissGpuResourceMgr::GetInstance().GetRes(gpu_id_)) {
+        ResScope rs(gpures, gpu_id_, false);
+        auto device_index = faiss::gpu::index_cpu_to_gpu(gpures->faiss_res.get(), gpu_id_, host_index->index_.get());
+        index_.reset(device_index);
+        res_ = gpures;
+    } else {
+        KNOWHERE_THROW_MSG("load index model error, can't get gpu_resource");
+    }
+}
+
+BinarySet
+GPUIVF::SerializeImpl() {
+    if (!index_ || !index_->is_trained) {
+        KNOWHERE_THROW_MSG("index not initialize or trained");
+    }
+
+    try {
+        MemoryIOWriter writer;
+        {
+            faiss::Index* index = index_.get();
+            faiss::Index* host_index = faiss::gpu::index_gpu_to_cpu(index);
+
+            SealImpl();
+
+            faiss::write_index(host_index, &writer);
+            delete host_index;
+        }
+        auto data = std::make_shared<uint8_t>();
+        data.reset(writer.data_);
+
+        BinarySet res_set;
+        res_set.Append("IVF", data, writer.rp);
+
+        return res_set;
+    } catch (std::exception& e) {
+        KNOWHERE_THROW_MSG(e.what());
+    }
+}
+
+void
+GPUIVF::LoadImpl(const BinarySet& index_binary) {
+    auto binary = index_binary.GetByName("IVF");
+    MemoryIOReader reader;
+    {
+        reader.total = binary->size;
+        reader.data_ = binary->data.get();
+
+        faiss::Index* index = faiss::read_index(&reader);
+
+        if (auto temp_res = FaissGpuResourceMgr::GetInstance().GetRes(gpu_id_)) {
+            ResScope rs(temp_res, gpu_id_, false);
+            auto device_index = faiss::gpu::index_cpu_to_gpu(temp_res->faiss_res.get(), gpu_id_, index);
+            index_.reset(device_index);
+            res_ = temp_res;
+        } else {
+            KNOWHERE_THROW_MSG("Load error, can't get gpu resource");
+        }
+
+        delete index;
+    }
+}
+
+void
+GPUIVF::search_impl(int64_t n, const float* data, int64_t k, float* distances, int64_t* labels, const Config& cfg) {
+    std::lock_guard<std::mutex> lk(mutex_);
+
+    // TODO(linxj): gpu index support GenParams
+    if (auto device_index = std::dynamic_pointer_cast<faiss::gpu::GpuIndexIVF>(index_)) {
+        auto search_cfg = std::dynamic_pointer_cast<IVFCfg>(cfg);
+        device_index->setNumProbes(search_cfg->nprobe);
+
+        {
+            // TODO(linxj): allocate gpu mem
+            ResScope rs(res_, gpu_id_);
+            device_index->search(n, (float*)data, k, distances, labels);
+        }
+    } else {
+        KNOWHERE_THROW_MSG("Not a GpuIndexIVF type.");
+    }
+}
+
+VectorIndexPtr
+GPUIVF::CopyGpuToCpu(const Config& config) {
+    std::lock_guard<std::mutex> lk(mutex_);
+
+    if (auto device_idx = std::dynamic_pointer_cast<faiss::gpu::GpuIndexIVF>(index_)) {
+        faiss::Index* device_index = index_.get();
+        faiss::Index* host_index = faiss::gpu::index_gpu_to_cpu(device_index);
+
+        std::shared_ptr<faiss::Index> new_index;
+        new_index.reset(host_index);
+        return std::make_shared<IVF>(new_index);
+    } else {
+        return std::make_shared<IVF>(index_);
+    }
+}
+
+VectorIndexPtr
+GPUIVF::Clone() {
+    auto cpu_idx = CopyGpuToCpu(Config());
+    return knowhere::cloner::CopyCpuToGpu(cpu_idx, gpu_id_, Config());
+}
+
+VectorIndexPtr
+GPUIVF::CopyGpuToGpu(const int64_t& device_id, const Config& config) {
+    auto host_index = CopyGpuToCpu(config);
+    return std::static_pointer_cast<IVF>(host_index)->CopyCpuToGpu(device_id, config);
+}
+
+void
+GPUIVF::Add(const DatasetPtr& dataset, const Config& config) {
+    if (auto spt = res_.lock()) {
+        ResScope rs(res_, gpu_id_);
+        IVF::Add(dataset, config);
+    } else {
+        KNOWHERE_THROW_MSG("Add IVF can't get gpu resource");
+    }
+}
+
+void
+GPUIndex::SetGpuDevice(const int& gpu_id) {
+    gpu_id_ = gpu_id;
+}
+
+const int64_t&
+GPUIndex::GetGpuDevice() {
+    return gpu_id_;
+}
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/index/vector_index/IndexGPUIVF.h b/core/src/index/knowhere/knowhere/index/vector_index/IndexGPUIVF.h
new file mode 100644
index 0000000000..fa9a206c48
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/index/vector_index/IndexGPUIVF.h
@@ -0,0 +1,92 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include "IndexIVF.h"
+#include "knowhere/index/vector_index/helpers/FaissGpuResourceMgr.h"
+
+namespace knowhere {
+
+class GPUIndex {
+ public:
+    explicit GPUIndex(const int& device_id) : gpu_id_(device_id) {
+    }
+
+    GPUIndex(const int& device_id, const ResPtr& resource) : gpu_id_(device_id), res_(resource) {
+    }
+
+    virtual VectorIndexPtr
+    CopyGpuToCpu(const Config& config) = 0;
+
+    virtual VectorIndexPtr
+    CopyGpuToGpu(const int64_t& device_id, const Config& config) = 0;
+
+    void
+    SetGpuDevice(const int& gpu_id);
+
+    const int64_t&
+    GetGpuDevice();
+
+ protected:
+    int64_t gpu_id_;
+    ResWPtr res_;
+};
+
+class GPUIVF : public IVF, public GPUIndex {
+ public:
+    explicit GPUIVF(const int& device_id) : IVF(), GPUIndex(device_id) {
+    }
+
+    explicit GPUIVF(std::shared_ptr<faiss::Index> index, const int64_t& device_id, ResPtr& resource)
+        : IVF(std::move(index)), GPUIndex(device_id, resource) {
+    }
+
+    IndexModelPtr
+    Train(const DatasetPtr& dataset, const Config& config) override;
+
+    void
+    Add(const DatasetPtr& dataset, const Config& config) override;
+
+    void
+    set_index_model(IndexModelPtr model) override;
+
+    // DatasetPtr Search(const DatasetPtr &dataset, const Config &config) override;
+    VectorIndexPtr
+    CopyGpuToCpu(const Config& config) override;
+
+    VectorIndexPtr
+    CopyGpuToGpu(const int64_t& device_id, const Config& config) override;
+
+    VectorIndexPtr
+    Clone() final;
+
+ protected:
+    void
+    search_impl(int64_t n, const float* data, int64_t k, float* distances, int64_t* labels, const Config& cfg) override;
+
+    BinarySet
+    SerializeImpl() override;
+
+    void
+    LoadImpl(const BinarySet& index_binary) override;
+};
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/index/vector_index/IndexGPUIVFPQ.cpp b/core/src/index/knowhere/knowhere/index/vector_index/IndexGPUIVFPQ.cpp
new file mode 100644
index 0000000000..213141b3ac
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/index/vector_index/IndexGPUIVFPQ.cpp
@@ -0,0 +1,70 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 <faiss/IndexIVFPQ.h>
+#include <faiss/gpu/GpuAutoTune.h>
+#include <faiss/gpu/GpuIndexIVFPQ.h>
+#include <memory>
+
+#include "knowhere/adapter/VectorAdapter.h"
+#include "knowhere/common/Exception.h"
+#include "knowhere/index/vector_index/IndexGPUIVFPQ.h"
+#include "knowhere/index/vector_index/IndexIVFPQ.h"
+
+namespace knowhere {
+
+IndexModelPtr
+GPUIVFPQ::Train(const DatasetPtr& dataset, const Config& config) {
+    auto build_cfg = std::dynamic_pointer_cast<IVFPQCfg>(config);
+    if (build_cfg != nullptr) {
+        build_cfg->CheckValid();  // throw exception
+    }
+    gpu_id_ = build_cfg->gpu_id;
+
+    GETTENSOR(dataset)
+
+    // TODO(linxj): set device here.
+    // TODO(linxj): set gpu resource here.
+    faiss::gpu::StandardGpuResources res;
+    faiss::gpu::GpuIndexIVFPQ device_index(&res, dim, build_cfg->nlist, build_cfg->m, build_cfg->nbits,
+                                           GetMetricType(build_cfg->metric_type));  // IP not support
+    device_index.train(rows, (float*)p_data);
+
+    std::shared_ptr<faiss::Index> host_index = nullptr;
+    host_index.reset(faiss::gpu::index_gpu_to_cpu(&device_index));
+
+    return std::make_shared<IVFIndexModel>(host_index);
+}
+
+std::shared_ptr<faiss::IVFSearchParameters>
+GPUIVFPQ::GenParams(const Config& config) {
+    auto params = std::make_shared<faiss::IVFPQSearchParameters>();
+    auto search_cfg = std::dynamic_pointer_cast<IVFPQCfg>(config);
+    params->nprobe = search_cfg->nprobe;
+    //    params->scan_table_threshold = conf->scan_table_threhold;
+    //    params->polysemous_ht = conf->polysemous_ht;
+    //    params->max_codes = conf->max_codes;
+
+    return params;
+}
+
+VectorIndexPtr
+GPUIVFPQ::CopyGpuToCpu(const Config& config) {
+    KNOWHERE_THROW_MSG("not support yet");
+}
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/index/vector_index/IndexGPUIVFPQ.h b/core/src/index/knowhere/knowhere/index/vector_index/IndexGPUIVFPQ.h
new file mode 100644
index 0000000000..13ea1075ca
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/index/vector_index/IndexGPUIVFPQ.h
@@ -0,0 +1,44 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <memory>
+
+#include "IndexGPUIVF.h"
+
+namespace knowhere {
+
+class GPUIVFPQ : public GPUIVF {
+ public:
+    explicit GPUIVFPQ(const int& device_id) : GPUIVF(device_id) {
+    }
+
+    IndexModelPtr
+    Train(const DatasetPtr& dataset, const Config& config) override;
+
+ public:
+    VectorIndexPtr
+    CopyGpuToCpu(const Config& config) override;
+
+ protected:
+    // TODO(linxj): remove GenParams.
+    std::shared_ptr<faiss::IVFSearchParameters>
+    GenParams(const Config& config) override;
+};
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/index/vector_index/IndexGPUIVFSQ.cpp b/core/src/index/knowhere/knowhere/index/vector_index/IndexGPUIVFSQ.cpp
new file mode 100644
index 0000000000..5e1f5226f2
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/index/vector_index/IndexGPUIVFSQ.cpp
@@ -0,0 +1,83 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 <faiss/gpu/GpuAutoTune.h>
+#include <memory>
+#include <utility>
+
+#include "knowhere/adapter/VectorAdapter.h"
+#include "knowhere/common/Exception.h"
+#include "knowhere/index/vector_index/IndexGPUIVFSQ.h"
+#include "knowhere/index/vector_index/IndexIVFSQ.h"
+
+namespace knowhere {
+
+IndexModelPtr
+GPUIVFSQ::Train(const DatasetPtr& dataset, const Config& config) {
+    auto build_cfg = std::dynamic_pointer_cast<IVFSQCfg>(config);
+    if (build_cfg != nullptr) {
+        build_cfg->CheckValid();  // throw exception
+    }
+    gpu_id_ = build_cfg->gpu_id;
+
+    GETTENSOR(dataset)
+
+    std::stringstream index_type;
+    index_type << "IVF" << build_cfg->nlist << ","
+               << "SQ" << build_cfg->nbits;
+    auto build_index = faiss::index_factory(dim, index_type.str().c_str(), GetMetricType(build_cfg->metric_type));
+
+    auto temp_resource = FaissGpuResourceMgr::GetInstance().GetRes(gpu_id_);
+    if (temp_resource != nullptr) {
+        ResScope rs(temp_resource, gpu_id_, true);
+        auto device_index = faiss::gpu::index_cpu_to_gpu(temp_resource->faiss_res.get(), gpu_id_, build_index);
+        device_index->train(rows, (float*)p_data);
+
+        std::shared_ptr<faiss::Index> host_index = nullptr;
+        host_index.reset(faiss::gpu::index_gpu_to_cpu(device_index));
+
+        delete device_index;
+        delete build_index;
+
+        return std::make_shared<IVFIndexModel>(host_index);
+    } else {
+        KNOWHERE_THROW_MSG("Build IVFSQ can't get gpu resource");
+    }
+}
+
+VectorIndexPtr
+GPUIVFSQ::CopyGpuToCpu(const Config& config) {
+    std::lock_guard<std::mutex> lk(mutex_);
+
+    faiss::Index* device_index = index_.get();
+    faiss::Index* host_index = faiss::gpu::index_gpu_to_cpu(device_index);
+
+    std::shared_ptr<faiss::Index> new_index;
+    new_index.reset(host_index);
+    return std::make_shared<IVFSQ>(new_index);
+}
+
+void
+GPUIVFSQ::search_impl(int64_t n, const float* data, int64_t k, float* distances, int64_t* labels, const Config& cfg) {
+#ifdef CUSTOMIZATION
+    GPUIVF::search_impl(n, data, k, distances, labels, cfg);
+#else
+    IVF::search_impl(n, data, k, distances, labels, cfg);
+#endif
+}
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/index/vector_index/IndexGPUIVFSQ.h b/core/src/index/knowhere/knowhere/index/vector_index/IndexGPUIVFSQ.h
new file mode 100644
index 0000000000..7332bce691
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/index/vector_index/IndexGPUIVFSQ.h
@@ -0,0 +1,47 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include "IndexGPUIVF.h"
+
+namespace knowhere {
+
+class GPUIVFSQ : public GPUIVF {
+ public:
+    explicit GPUIVFSQ(const int& device_id) : GPUIVF(device_id) {
+    }
+
+    explicit GPUIVFSQ(std::shared_ptr<faiss::Index> index, const int64_t& device_id, ResPtr& resource)
+        : GPUIVF(std::move(index), device_id, resource) {
+    }
+
+    IndexModelPtr
+    Train(const DatasetPtr& dataset, const Config& config) override;
+
+    VectorIndexPtr
+    CopyGpuToCpu(const Config& config) override;
+
+ protected:
+    void
+    search_impl(int64_t n, const float* data, int64_t k, float* distances, int64_t* labels, const Config& cfg) override;
+};
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/index/vector_index/IndexIDMAP.cpp b/core/src/index/knowhere/knowhere/index/vector_index/IndexIDMAP.cpp
new file mode 100644
index 0000000000..2371591b5c
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/index/vector_index/IndexIDMAP.cpp
@@ -0,0 +1,270 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 <faiss/AutoTune.h>
+#include <faiss/IndexFlat.h>
+#include <faiss/MetaIndexes.h>
+#include <faiss/gpu/GpuAutoTune.h>
+#include <faiss/index_io.h>
+#include <vector>
+
+#include "knowhere/adapter/VectorAdapter.h"
+#include "knowhere/common/Exception.h"
+#include "knowhere/index/vector_index/IndexIDMAP.h"
+#include "knowhere/index/vector_index/helpers/FaissIO.h"
+
+namespace knowhere {
+
+BinarySet
+IDMAP::Serialize() {
+    if (!index_) {
+        KNOWHERE_THROW_MSG("index not initialize");
+    }
+
+    std::lock_guard<std::mutex> lk(mutex_);
+    return SerializeImpl();
+}
+
+void
+IDMAP::Load(const BinarySet& index_binary) {
+    std::lock_guard<std::mutex> lk(mutex_);
+    LoadImpl(index_binary);
+}
+
+DatasetPtr
+IDMAP::Search(const DatasetPtr& dataset, const Config& config) {
+    if (!index_) {
+        KNOWHERE_THROW_MSG("index not initialize");
+    }
+
+    config->CheckValid();
+    // auto metric_type = config["metric_type"].as_string() == "L2" ?
+    //                   faiss::METRIC_L2 : faiss::METRIC_INNER_PRODUCT;
+    // index_->metric_type = metric_type;
+
+    GETTENSOR(dataset)
+
+    auto elems = rows * config->k;
+    auto res_ids = (int64_t*)malloc(sizeof(int64_t) * elems);
+    auto res_dis = (float*)malloc(sizeof(float) * elems);
+
+    search_impl(rows, (float*)p_data, config->k, res_dis, res_ids, Config());
+
+    auto id_buf = MakeMutableBufferSmart((uint8_t*)res_ids, sizeof(int64_t) * elems);
+    auto dist_buf = MakeMutableBufferSmart((uint8_t*)res_dis, sizeof(float) * elems);
+
+    std::vector<BufferPtr> id_bufs{nullptr, id_buf};
+    std::vector<BufferPtr> dist_bufs{nullptr, dist_buf};
+
+    auto int64_type = std::make_shared<arrow::Int64Type>();
+    auto float_type = std::make_shared<arrow::FloatType>();
+
+    auto id_array_data = arrow::ArrayData::Make(int64_type, elems, id_bufs);
+    auto dist_array_data = arrow::ArrayData::Make(float_type, elems, dist_bufs);
+
+    auto ids = std::make_shared<NumericArray<arrow::Int64Type>>(id_array_data);
+    auto dists = std::make_shared<NumericArray<arrow::FloatType>>(dist_array_data);
+    std::vector<ArrayPtr> array{ids, dists};
+
+    return std::make_shared<Dataset>(array, nullptr);
+}
+
+void
+IDMAP::search_impl(int64_t n, const float* data, int64_t k, float* distances, int64_t* labels, const Config& cfg) {
+    index_->search(n, (float*)data, k, distances, labels);
+}
+
+void
+IDMAP::Add(const DatasetPtr& dataset, const Config& config) {
+    if (!index_) {
+        KNOWHERE_THROW_MSG("index not initialize");
+    }
+
+    std::lock_guard<std::mutex> lk(mutex_);
+    GETTENSOR(dataset)
+
+    // TODO: magic here.
+    auto array = dataset->array()[0];
+    auto p_ids = array->data()->GetValues<int64_t>(1, 0);
+
+    index_->add_with_ids(rows, (float*)p_data, p_ids);
+}
+
+int64_t
+IDMAP::Count() {
+    return index_->ntotal;
+}
+
+int64_t
+IDMAP::Dimension() {
+    return index_->d;
+}
+
+// TODO(linxj): return const pointer
+float*
+IDMAP::GetRawVectors() {
+    try {
+        auto file_index = dynamic_cast<faiss::IndexIDMap*>(index_.get());
+        auto flat_index = dynamic_cast<faiss::IndexFlat*>(file_index->index);
+        return flat_index->xb.data();
+    } catch (std::exception& e) {
+        KNOWHERE_THROW_MSG(e.what());
+    }
+}
+
+// TODO(linxj): return const pointer
+int64_t*
+IDMAP::GetRawIds() {
+    try {
+        auto file_index = dynamic_cast<faiss::IndexIDMap*>(index_.get());
+        return file_index->id_map.data();
+    } catch (std::exception& e) {
+        KNOWHERE_THROW_MSG(e.what());
+    }
+}
+
+const char* type = "IDMap,Flat";
+
+void
+IDMAP::Train(const Config& config) {
+    config->CheckValid();
+
+    auto index = faiss::index_factory(config->d, type, GetMetricType(config->metric_type));
+    index_.reset(index);
+}
+
+VectorIndexPtr
+IDMAP::Clone() {
+    std::lock_guard<std::mutex> lk(mutex_);
+
+    auto clone_index = faiss::clone_index(index_.get());
+    std::shared_ptr<faiss::Index> new_index;
+    new_index.reset(clone_index);
+    return std::make_shared<IDMAP>(new_index);
+}
+
+VectorIndexPtr
+IDMAP::CopyCpuToGpu(const int64_t& device_id, const Config& config) {
+    if (auto res = FaissGpuResourceMgr::GetInstance().GetRes(device_id)) {
+        ResScope rs(res, device_id, false);
+        auto gpu_index = faiss::gpu::index_cpu_to_gpu(res->faiss_res.get(), device_id, index_.get());
+
+        std::shared_ptr<faiss::Index> device_index;
+        device_index.reset(gpu_index);
+        return std::make_shared<GPUIDMAP>(device_index, device_id, res);
+    } else {
+        KNOWHERE_THROW_MSG("CopyCpuToGpu Error, can't get gpu_resource");
+    }
+}
+
+void
+IDMAP::Seal() {
+    // do nothing
+}
+
+VectorIndexPtr
+GPUIDMAP::CopyGpuToCpu(const Config& config) {
+    std::lock_guard<std::mutex> lk(mutex_);
+
+    faiss::Index* device_index = index_.get();
+    faiss::Index* host_index = faiss::gpu::index_gpu_to_cpu(device_index);
+
+    std::shared_ptr<faiss::Index> new_index;
+    new_index.reset(host_index);
+    return std::make_shared<IDMAP>(new_index);
+}
+
+VectorIndexPtr
+GPUIDMAP::Clone() {
+    auto cpu_idx = CopyGpuToCpu(Config());
+
+    if (auto idmap = std::dynamic_pointer_cast<IDMAP>(cpu_idx)) {
+        return idmap->CopyCpuToGpu(gpu_id_, Config());
+    } else {
+        KNOWHERE_THROW_MSG("IndexType not Support GpuClone");
+    }
+}
+
+BinarySet
+GPUIDMAP::SerializeImpl() {
+    try {
+        MemoryIOWriter writer;
+        {
+            faiss::Index* index = index_.get();
+            faiss::Index* host_index = faiss::gpu::index_gpu_to_cpu(index);
+
+            faiss::write_index(host_index, &writer);
+            delete host_index;
+        }
+        auto data = std::make_shared<uint8_t>();
+        data.reset(writer.data_);
+
+        BinarySet res_set;
+        res_set.Append("IVF", data, writer.rp);
+
+        return res_set;
+    } catch (std::exception& e) {
+        KNOWHERE_THROW_MSG(e.what());
+    }
+}
+
+void
+GPUIDMAP::LoadImpl(const BinarySet& index_binary) {
+    auto binary = index_binary.GetByName("IVF");
+    MemoryIOReader reader;
+    {
+        reader.total = binary->size;
+        reader.data_ = binary->data.get();
+
+        faiss::Index* index = faiss::read_index(&reader);
+
+        if (auto res = FaissGpuResourceMgr::GetInstance().GetRes(gpu_id_)) {
+            ResScope rs(res, gpu_id_, false);
+            auto device_index = faiss::gpu::index_cpu_to_gpu(res->faiss_res.get(), gpu_id_, index);
+            index_.reset(device_index);
+            res_ = res;
+        } else {
+            KNOWHERE_THROW_MSG("Load error, can't get gpu resource");
+        }
+
+        delete index;
+    }
+}
+
+VectorIndexPtr
+GPUIDMAP::CopyGpuToGpu(const int64_t& device_id, const Config& config) {
+    auto cpu_index = CopyGpuToCpu(config);
+    return std::static_pointer_cast<IDMAP>(cpu_index)->CopyCpuToGpu(device_id, config);
+}
+
+float*
+GPUIDMAP::GetRawVectors() {
+    KNOWHERE_THROW_MSG("Not support");
+}
+
+int64_t*
+GPUIDMAP::GetRawIds() {
+    KNOWHERE_THROW_MSG("Not support");
+}
+
+void
+GPUIDMAP::search_impl(int64_t n, const float* data, int64_t k, float* distances, int64_t* labels, const Config& cfg) {
+    ResScope rs(res_, gpu_id_);
+    index_->search(n, (float*)data, k, distances, labels);
+}
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/index/vector_index/IndexIDMAP.h b/core/src/index/knowhere/knowhere/index/vector_index/IndexIDMAP.h
new file mode 100644
index 0000000000..ec1cbb9e77
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/index/vector_index/IndexIDMAP.h
@@ -0,0 +1,98 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "IndexGPUIVF.h"
+#include "IndexIVF.h"
+
+#include <memory>
+#include <utility>
+
+namespace knowhere {
+
+class IDMAP : public VectorIndex, public FaissBaseIndex {
+ public:
+    IDMAP() : FaissBaseIndex(nullptr) {
+    }
+
+    explicit IDMAP(std::shared_ptr<faiss::Index> index) : FaissBaseIndex(std::move(index)) {
+    }
+
+    BinarySet
+    Serialize() override;
+    void
+    Load(const BinarySet& index_binary) override;
+    void
+    Train(const Config& config);
+    DatasetPtr
+    Search(const DatasetPtr& dataset, const Config& config) override;
+    int64_t
+    Count() override;
+    VectorIndexPtr
+    Clone() override;
+    int64_t
+    Dimension() override;
+    void
+    Add(const DatasetPtr& dataset, const Config& config) override;
+    VectorIndexPtr
+    CopyCpuToGpu(const int64_t& device_id, const Config& config);
+    void
+    Seal() override;
+
+    virtual float*
+    GetRawVectors();
+    virtual int64_t*
+    GetRawIds();
+
+ protected:
+    virtual void
+    search_impl(int64_t n, const float* data, int64_t k, float* distances, int64_t* labels, const Config& cfg);
+    std::mutex mutex_;
+};
+
+using IDMAPPtr = std::shared_ptr<IDMAP>;
+
+class GPUIDMAP : public IDMAP, public GPUIndex {
+ public:
+    explicit GPUIDMAP(std::shared_ptr<faiss::Index> index, const int64_t& device_id, ResPtr& res)
+        : IDMAP(std::move(index)), GPUIndex(device_id, res) {
+    }
+
+    VectorIndexPtr
+    CopyGpuToCpu(const Config& config) override;
+    float*
+    GetRawVectors() override;
+    int64_t*
+    GetRawIds() override;
+    VectorIndexPtr
+    Clone() override;
+    VectorIndexPtr
+    CopyGpuToGpu(const int64_t& device_id, const Config& config) override;
+
+ protected:
+    void
+    search_impl(int64_t n, const float* data, int64_t k, float* distances, int64_t* labels, const Config& cfg) override;
+    BinarySet
+    SerializeImpl() override;
+    void
+    LoadImpl(const BinarySet& index_binary) override;
+};
+
+using GPUIDMAPPtr = std::shared_ptr<GPUIDMAP>;
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/index/vector_index/IndexIVF.cpp b/core/src/index/knowhere/knowhere/index/vector_index/IndexIVF.cpp
new file mode 100644
index 0000000000..fba2e11e2e
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/index/vector_index/IndexIVF.cpp
@@ -0,0 +1,294 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 <faiss/AutoTune.h>
+#include <faiss/AuxIndexStructures.h>
+#include <faiss/IVFlib.h>
+#include <faiss/IndexFlat.h>
+#include <faiss/IndexIVF.h>
+#include <faiss/IndexIVFFlat.h>
+#include <faiss/IndexIVFPQ.h>
+#include <faiss/gpu/GpuAutoTune.h>
+#include <faiss/index_io.h>
+#include <chrono>
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include "knowhere/adapter/VectorAdapter.h"
+#include "knowhere/common/Exception.h"
+#include "knowhere/common/Log.h"
+#include "knowhere/index/vector_index/IndexGPUIVF.h"
+#include "knowhere/index/vector_index/IndexIVF.h"
+
+namespace knowhere {
+
+using stdclock = std::chrono::high_resolution_clock;
+
+IndexModelPtr
+IVF::Train(const DatasetPtr& dataset, const Config& config) {
+    auto build_cfg = std::dynamic_pointer_cast<IVFCfg>(config);
+    if (build_cfg != nullptr) {
+        build_cfg->CheckValid();  // throw exception
+    }
+
+    GETTENSOR(dataset)
+
+    faiss::Index* coarse_quantizer = new faiss::IndexFlatL2(dim);
+    auto index = std::make_shared<faiss::IndexIVFFlat>(coarse_quantizer, dim, build_cfg->nlist,
+                                                       GetMetricType(build_cfg->metric_type));
+    index->train(rows, (float*)p_data);
+
+    // TODO(linxj): override here. train return model or not.
+    return std::make_shared<IVFIndexModel>(index);
+}
+
+void
+IVF::Add(const DatasetPtr& dataset, const Config& config) {
+    if (!index_ || !index_->is_trained) {
+        KNOWHERE_THROW_MSG("index not initialize or trained");
+    }
+
+    std::lock_guard<std::mutex> lk(mutex_);
+    GETTENSOR(dataset)
+
+    auto array = dataset->array()[0];
+    auto p_ids = array->data()->GetValues<int64_t>(1, 0);
+    index_->add_with_ids(rows, (float*)p_data, p_ids);
+}
+
+void
+IVF::AddWithoutIds(const DatasetPtr& dataset, const Config& config) {
+    if (!index_ || !index_->is_trained) {
+        KNOWHERE_THROW_MSG("index not initialize or trained");
+    }
+
+    std::lock_guard<std::mutex> lk(mutex_);
+    GETTENSOR(dataset)
+
+    index_->add(rows, (float*)p_data);
+}
+
+BinarySet
+IVF::Serialize() {
+    if (!index_ || !index_->is_trained) {
+        KNOWHERE_THROW_MSG("index not initialize or trained");
+    }
+
+    std::lock_guard<std::mutex> lk(mutex_);
+    Seal();
+    return SerializeImpl();
+}
+
+void
+IVF::Load(const BinarySet& index_binary) {
+    std::lock_guard<std::mutex> lk(mutex_);
+    LoadImpl(index_binary);
+}
+
+DatasetPtr
+IVF::Search(const DatasetPtr& dataset, const Config& config) {
+    if (!index_ || !index_->is_trained) {
+        KNOWHERE_THROW_MSG("index not initialize or trained");
+    }
+
+    auto search_cfg = std::dynamic_pointer_cast<IVFCfg>(config);
+    if (search_cfg != nullptr) {
+        search_cfg->CheckValid();  // throw exception
+    }
+
+    GETTENSOR(dataset)
+
+    auto elems = rows * search_cfg->k;
+    auto res_ids = (int64_t*)malloc(sizeof(int64_t) * elems);
+    auto res_dis = (float*)malloc(sizeof(float) * elems);
+
+    search_impl(rows, (float*)p_data, search_cfg->k, res_dis, res_ids, config);
+
+    //    std::stringstream ss_res_id, ss_res_dist;
+    //    for (int i = 0; i < 10; ++i) {
+    //        printf("%llu", res_ids[i]);
+    //        printf("\n");
+    //        printf("%.6f", res_dis[i]);
+    //        printf("\n");
+    //        ss_res_id << res_ids[i] << " ";
+    //        ss_res_dist << res_dis[i] << " ";
+    //    }
+    //    std::cout << std::endl << "after search: " << std::endl;
+    //    std::cout << ss_res_id.str() << std::endl;
+    //    std::cout << ss_res_dist.str() << std::endl << std::endl;
+
+    auto id_buf = MakeMutableBufferSmart((uint8_t*)res_ids, sizeof(int64_t) * elems);
+    auto dist_buf = MakeMutableBufferSmart((uint8_t*)res_dis, sizeof(float) * elems);
+
+    std::vector<BufferPtr> id_bufs{nullptr, id_buf};
+    std::vector<BufferPtr> dist_bufs{nullptr, dist_buf};
+
+    auto int64_type = std::make_shared<arrow::Int64Type>();
+    auto float_type = std::make_shared<arrow::FloatType>();
+
+    auto id_array_data = arrow::ArrayData::Make(int64_type, elems, id_bufs);
+    auto dist_array_data = arrow::ArrayData::Make(float_type, elems, dist_bufs);
+
+    auto ids = std::make_shared<NumericArray<arrow::Int64Type>>(id_array_data);
+    auto dists = std::make_shared<NumericArray<arrow::FloatType>>(dist_array_data);
+    std::vector<ArrayPtr> array{ids, dists};
+
+    return std::make_shared<Dataset>(array, nullptr);
+}
+
+void
+IVF::set_index_model(IndexModelPtr model) {
+    std::lock_guard<std::mutex> lk(mutex_);
+
+    auto rel_model = std::static_pointer_cast<IVFIndexModel>(model);
+
+    // Deep copy here.
+    index_.reset(faiss::clone_index(rel_model->index_.get()));
+}
+
+std::shared_ptr<faiss::IVFSearchParameters>
+IVF::GenParams(const Config& config) {
+    auto params = std::make_shared<faiss::IVFSearchParameters>();
+
+    auto search_cfg = std::dynamic_pointer_cast<IVFCfg>(config);
+    params->nprobe = search_cfg->nprobe;
+    // params->max_codes = config.get_with_default("max_codes", size_t(0));
+
+    return params;
+}
+
+int64_t
+IVF::Count() {
+    return index_->ntotal;
+}
+
+int64_t
+IVF::Dimension() {
+    return index_->d;
+}
+
+void
+IVF::GenGraph(const int64_t& k, Graph& graph, const DatasetPtr& dataset, const Config& config) {
+    GETTENSOR(dataset)
+
+    auto ntotal = Count();
+
+    auto batch_size = 100;
+    auto tail_batch_size = ntotal % batch_size;
+    auto batch_search_count = ntotal / batch_size;
+    auto total_search_count = tail_batch_size == 0 ? batch_search_count : batch_search_count + 1;
+
+    std::vector<float> res_dis(k * batch_size);
+    graph.resize(ntotal);
+    Graph res_vec(total_search_count);
+    for (int i = 0; i < total_search_count; ++i) {
+        auto b_size = i == total_search_count - 1 && tail_batch_size != 0 ? tail_batch_size : batch_size;
+
+        auto& res = res_vec[i];
+        res.resize(k * b_size);
+
+        auto xq = p_data + batch_size * dim * i;
+        search_impl(b_size, (float*)xq, k, res_dis.data(), res.data(), config);
+
+        int tmp = 0;
+        for (int j = 0; j < b_size; ++j) {
+            auto& node = graph[batch_size * i + j];
+            node.resize(k);
+            for (int m = 0; m < k && tmp < k * b_size; ++m, ++tmp) {
+                // TODO(linxj): avoid memcopy here.
+                node[m] = res[tmp];
+            }
+        }
+    }
+}
+
+void
+IVF::search_impl(int64_t n, const float* data, int64_t k, float* distances, int64_t* labels, const Config& cfg) {
+    auto params = GenParams(cfg);
+    stdclock::time_point before = stdclock::now();
+    faiss::ivflib::search_with_parameters(index_.get(), n, (float*)data, k, distances, labels, params.get());
+    stdclock::time_point after = stdclock::now();
+    double search_cost = (std::chrono::duration<double, std::micro>(after - before)).count();
+    KNOWHERE_LOG_DEBUG << "IVF search cost: " << search_cost
+                       << ", quantization cost: " << faiss::indexIVF_stats.quantization_time
+                       << ", data search cost: " << faiss::indexIVF_stats.search_time;
+    faiss::indexIVF_stats.quantization_time = 0;
+    faiss::indexIVF_stats.search_time = 0;
+}
+
+VectorIndexPtr
+IVF::CopyCpuToGpu(const int64_t& device_id, const Config& config) {
+    if (auto res = FaissGpuResourceMgr::GetInstance().GetRes(device_id)) {
+        ResScope rs(res, device_id, false);
+        auto gpu_index = faiss::gpu::index_cpu_to_gpu(res->faiss_res.get(), device_id, index_.get());
+
+        std::shared_ptr<faiss::Index> device_index;
+        device_index.reset(gpu_index);
+        return std::make_shared<GPUIVF>(device_index, device_id, res);
+    } else {
+        KNOWHERE_THROW_MSG("CopyCpuToGpu Error, can't get gpu_resource");
+    }
+}
+
+VectorIndexPtr
+IVF::Clone() {
+    std::lock_guard<std::mutex> lk(mutex_);
+
+    auto clone_index = faiss::clone_index(index_.get());
+    std::shared_ptr<faiss::Index> new_index;
+    new_index.reset(clone_index);
+    return Clone_impl(new_index);
+}
+
+VectorIndexPtr
+IVF::Clone_impl(const std::shared_ptr<faiss::Index>& index) {
+    return std::make_shared<IVF>(index);
+}
+
+void
+IVF::Seal() {
+    if (!index_ || !index_->is_trained) {
+        KNOWHERE_THROW_MSG("index not initialize or trained");
+    }
+    SealImpl();
+}
+
+IVFIndexModel::IVFIndexModel(std::shared_ptr<faiss::Index> index) : FaissBaseIndex(std::move(index)) {
+}
+
+BinarySet
+IVFIndexModel::Serialize() {
+    if (!index_ || !index_->is_trained) {
+        KNOWHERE_THROW_MSG("indexmodel not initialize or trained");
+    }
+    std::lock_guard<std::mutex> lk(mutex_);
+    return SerializeImpl();
+}
+
+void
+IVFIndexModel::Load(const BinarySet& binary_set) {
+    std::lock_guard<std::mutex> lk(mutex_);
+    LoadImpl(binary_set);
+}
+
+void
+IVFIndexModel::SealImpl() {
+    // do nothing
+}
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/index/vector_index/IndexIVF.h b/core/src/index/knowhere/knowhere/index/vector_index/IndexIVF.h
new file mode 100644
index 0000000000..ef9982fa30
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/index/vector_index/IndexIVF.h
@@ -0,0 +1,123 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <memory>
+#include <mutex>
+#include <utility>
+#include <vector>
+
+#include "FaissBaseIndex.h"
+#include "VectorIndex.h"
+#include "faiss/IndexIVF.h"
+
+namespace knowhere {
+
+using Graph = std::vector<std::vector<int64_t>>;
+
+class IVF : public VectorIndex, protected FaissBaseIndex {
+ public:
+    IVF() : FaissBaseIndex(nullptr) {
+    }
+
+    explicit IVF(std::shared_ptr<faiss::Index> index) : FaissBaseIndex(std::move(index)) {
+    }
+
+    VectorIndexPtr
+    Clone() override;
+
+    IndexModelPtr
+    Train(const DatasetPtr& dataset, const Config& config) override;
+
+    void
+    set_index_model(IndexModelPtr model) override;
+
+    void
+    Add(const DatasetPtr& dataset, const Config& config) override;
+
+    void
+    AddWithoutIds(const DatasetPtr& dataset, const Config& config);
+
+    DatasetPtr
+    Search(const DatasetPtr& dataset, const Config& config) override;
+
+    void
+    GenGraph(const int64_t& k, Graph& graph, const DatasetPtr& dataset, const Config& config);
+
+    BinarySet
+    Serialize() override;
+
+    void
+    Load(const BinarySet& index_binary) override;
+
+    int64_t
+    Count() override;
+
+    int64_t
+    Dimension() override;
+
+    void
+    Seal() override;
+
+    virtual VectorIndexPtr
+    CopyCpuToGpu(const int64_t& device_id, const Config& config);
+
+ protected:
+    virtual std::shared_ptr<faiss::IVFSearchParameters>
+    GenParams(const Config& config);
+
+    virtual VectorIndexPtr
+    Clone_impl(const std::shared_ptr<faiss::Index>& index);
+
+    virtual void
+    search_impl(int64_t n, const float* data, int64_t k, float* distances, int64_t* labels, const Config& cfg);
+
+ protected:
+    std::mutex mutex_;
+};
+
+using IVFIndexPtr = std::shared_ptr<IVF>;
+
+class GPUIVF;
+class IVFIndexModel : public IndexModel, public FaissBaseIndex {
+    friend IVF;
+    friend GPUIVF;
+
+ public:
+    explicit IVFIndexModel(std::shared_ptr<faiss::Index> index);
+
+    IVFIndexModel() : FaissBaseIndex(nullptr) {
+    }
+
+    BinarySet
+    Serialize() override;
+
+    void
+    Load(const BinarySet& binary) override;
+
+ protected:
+    void
+    SealImpl() override;
+
+ protected:
+    std::mutex mutex_;
+};
+
+using IVFIndexModelPtr = std::shared_ptr<IVFIndexModel>;
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/index/vector_index/IndexIVFPQ.cpp b/core/src/index/knowhere/knowhere/index/vector_index/IndexIVFPQ.cpp
new file mode 100644
index 0000000000..03acbf31d7
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/index/vector_index/IndexIVFPQ.cpp
@@ -0,0 +1,63 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 <faiss/IndexFlat.h>
+#include <faiss/IndexIVFPQ.h>
+#include <memory>
+#include <utility>
+
+#include "knowhere/adapter/VectorAdapter.h"
+#include "knowhere/common/Exception.h"
+#include "knowhere/index/vector_index/IndexIVFPQ.h"
+
+namespace knowhere {
+
+IndexModelPtr
+IVFPQ::Train(const DatasetPtr& dataset, const Config& config) {
+    auto build_cfg = std::dynamic_pointer_cast<IVFPQCfg>(config);
+    if (build_cfg != nullptr) {
+        build_cfg->CheckValid();  // throw exception
+    }
+
+    GETTENSOR(dataset)
+
+    faiss::Index* coarse_quantizer = new faiss::IndexFlat(dim, GetMetricType(build_cfg->metric_type));
+    auto index =
+        std::make_shared<faiss::IndexIVFPQ>(coarse_quantizer, dim, build_cfg->nlist, build_cfg->m, build_cfg->nbits);
+    index->train(rows, (float*)p_data);
+
+    return std::make_shared<IVFIndexModel>(index);
+}
+
+std::shared_ptr<faiss::IVFSearchParameters>
+IVFPQ::GenParams(const Config& config) {
+    auto params = std::make_shared<faiss::IVFPQSearchParameters>();
+    auto search_cfg = std::dynamic_pointer_cast<IVFPQCfg>(config);
+    params->nprobe = search_cfg->nprobe;
+    //    params->scan_table_threshold = conf->scan_table_threhold;
+    //    params->polysemous_ht = conf->polysemous_ht;
+    //    params->max_codes = conf->max_codes;
+
+    return params;
+}
+
+VectorIndexPtr
+IVFPQ::Clone_impl(const std::shared_ptr<faiss::Index>& index) {
+    return std::make_shared<IVFPQ>(index);
+}
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/index/vector_index/IndexIVFPQ.h b/core/src/index/knowhere/knowhere/index/vector_index/IndexIVFPQ.h
new file mode 100644
index 0000000000..69aaa5090b
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/index/vector_index/IndexIVFPQ.h
@@ -0,0 +1,45 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include "IndexIVF.h"
+
+namespace knowhere {
+
+class IVFPQ : public IVF {
+ public:
+    explicit IVFPQ(std::shared_ptr<faiss::Index> index) : IVF(std::move(index)) {
+    }
+
+    IVFPQ() = default;
+
+    IndexModelPtr
+    Train(const DatasetPtr& dataset, const Config& config) override;
+
+ protected:
+    std::shared_ptr<faiss::IVFSearchParameters>
+    GenParams(const Config& config) override;
+
+    VectorIndexPtr
+    Clone_impl(const std::shared_ptr<faiss::Index>& index) override;
+};
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/index/vector_index/IndexIVFSQ.cpp b/core/src/index/knowhere/knowhere/index/vector_index/IndexIVFSQ.cpp
new file mode 100644
index 0000000000..063dc63550
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/index/vector_index/IndexIVFSQ.cpp
@@ -0,0 +1,76 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 <faiss/gpu/GpuAutoTune.h>
+#include <memory>
+
+#include "knowhere/adapter/VectorAdapter.h"
+#include "knowhere/common/Exception.h"
+#include "knowhere/index/vector_index/IndexGPUIVFSQ.h"
+#include "knowhere/index/vector_index/IndexIVFSQ.h"
+#include "knowhere/index/vector_index/helpers/FaissGpuResourceMgr.h"
+
+namespace knowhere {
+
+IndexModelPtr
+IVFSQ::Train(const DatasetPtr& dataset, const Config& config) {
+    auto build_cfg = std::dynamic_pointer_cast<IVFSQCfg>(config);
+    if (build_cfg != nullptr) {
+        build_cfg->CheckValid();  // throw exception
+    }
+
+    GETTENSOR(dataset)
+
+    std::stringstream index_type;
+    index_type << "IVF" << build_cfg->nlist << ","
+               << "SQ" << build_cfg->nbits;
+    auto build_index = faiss::index_factory(dim, index_type.str().c_str(), GetMetricType(build_cfg->metric_type));
+    build_index->train(rows, (float*)p_data);
+
+    std::shared_ptr<faiss::Index> ret_index;
+    ret_index.reset(build_index);
+    return std::make_shared<IVFIndexModel>(ret_index);
+}
+
+VectorIndexPtr
+IVFSQ::Clone_impl(const std::shared_ptr<faiss::Index>& index) {
+    return std::make_shared<IVFSQ>(index);
+}
+
+VectorIndexPtr
+IVFSQ::CopyCpuToGpu(const int64_t& device_id, const Config& config) {
+    if (auto res = FaissGpuResourceMgr::GetInstance().GetRes(device_id)) {
+        ResScope rs(res, device_id, false);
+
+#ifdef CUSTOMIZATION
+        faiss::gpu::GpuClonerOptions option;
+        option.allInGpu = true;
+
+        auto gpu_index = faiss::gpu::index_cpu_to_gpu(res->faiss_res.get(), device_id, index_.get(), &option);
+#else
+        auto gpu_index = faiss::gpu::index_cpu_to_gpu(res->faiss_res.get(), device_id, index_.get());
+#endif
+
+        std::shared_ptr<faiss::Index> device_index;
+        device_index.reset(gpu_index);
+        return std::make_shared<GPUIVFSQ>(device_index, device_id, res);
+    } else {
+        KNOWHERE_THROW_MSG("CopyCpuToGpu Error, can't get gpu_resource");
+    }
+}
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/index/vector_index/IndexIVFSQ.h b/core/src/index/knowhere/knowhere/index/vector_index/IndexIVFSQ.h
new file mode 100644
index 0000000000..cac95faebf
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/index/vector_index/IndexIVFSQ.h
@@ -0,0 +1,45 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include "IndexIVF.h"
+
+namespace knowhere {
+
+class IVFSQ : public IVF {
+ public:
+    explicit IVFSQ(std::shared_ptr<faiss::Index> index) : IVF(std::move(index)) {
+    }
+
+    IVFSQ() = default;
+
+    IndexModelPtr
+    Train(const DatasetPtr& dataset, const Config& config) override;
+
+    VectorIndexPtr
+    CopyCpuToGpu(const int64_t& device_id, const Config& config) override;
+
+ protected:
+    VectorIndexPtr
+    Clone_impl(const std::shared_ptr<faiss::Index>& index) override;
+};
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/index/vector_index/IndexIVFSQHybrid.cpp b/core/src/index/knowhere/knowhere/index/vector_index/IndexIVFSQHybrid.cpp
new file mode 100644
index 0000000000..fe5bf0990a
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/index/vector_index/IndexIVFSQHybrid.cpp
@@ -0,0 +1,311 @@
+//
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "knowhere/index/vector_index/IndexIVFSQHybrid.h"
+#include <utility>
+#include "faiss/AutoTune.h"
+#include "faiss/gpu/GpuAutoTune.h"
+#include "faiss/gpu/GpuIndexIVF.h"
+#include "knowhere/adapter/VectorAdapter.h"
+#include "knowhere/common/Exception.h"
+
+namespace knowhere {
+
+#ifdef CUSTOMIZATION
+
+IndexModelPtr
+IVFSQHybrid::Train(const DatasetPtr& dataset, const Config& config) {
+    auto build_cfg = std::dynamic_pointer_cast<IVFSQCfg>(config);
+    if (build_cfg != nullptr) {
+        build_cfg->CheckValid();  // throw exception
+    }
+    gpu_id_ = build_cfg->gpu_id;
+
+    GETTENSOR(dataset)
+
+    std::stringstream index_type;
+    index_type << "IVF" << build_cfg->nlist << ","
+               << "SQ8Hybrid";
+    auto build_index = faiss::index_factory(dim, index_type.str().c_str(), GetMetricType(build_cfg->metric_type));
+
+    auto temp_resource = FaissGpuResourceMgr::GetInstance().GetRes(gpu_id_);
+    if (temp_resource != nullptr) {
+        ResScope rs(temp_resource, gpu_id_, true);
+        auto device_index = faiss::gpu::index_cpu_to_gpu(temp_resource->faiss_res.get(), gpu_id_, build_index);
+        device_index->train(rows, (float*)p_data);
+
+        std::shared_ptr<faiss::Index> host_index = nullptr;
+        host_index.reset(faiss::gpu::index_gpu_to_cpu(device_index));
+
+        delete device_index;
+        delete build_index;
+
+        return std::make_shared<IVFIndexModel>(host_index);
+    } else {
+        KNOWHERE_THROW_MSG("Build IVFSQHybrid can't get gpu resource");
+    }
+}
+
+VectorIndexPtr
+IVFSQHybrid::CopyGpuToCpu(const Config& config) {
+    std::lock_guard<std::mutex> lk(mutex_);
+
+    if (auto device_idx = std::dynamic_pointer_cast<faiss::IndexIVF>(index_)) {
+        faiss::Index* device_index = index_.get();
+        faiss::Index* host_index = faiss::gpu::index_gpu_to_cpu(device_index);
+
+        std::shared_ptr<faiss::Index> new_index;
+        new_index.reset(host_index);
+        return std::make_shared<IVFSQHybrid>(new_index);
+    } else {
+        // TODO(linxj): why? jinhai
+        return std::make_shared<IVFSQHybrid>(index_);
+    }
+}
+
+VectorIndexPtr
+IVFSQHybrid::CopyCpuToGpu(const int64_t& device_id, const Config& config) {
+    if (auto res = FaissGpuResourceMgr::GetInstance().GetRes(device_id)) {
+        ResScope rs(res, device_id, false);
+        faiss::gpu::GpuClonerOptions option;
+        option.allInGpu = true;
+
+        faiss::IndexComposition index_composition;
+        index_composition.index = index_.get();
+        index_composition.quantizer = nullptr;
+        index_composition.mode = 0;  // copy all
+
+        auto gpu_index = faiss::gpu::index_cpu_to_gpu(res->faiss_res.get(), device_id, &index_composition, &option);
+
+        std::shared_ptr<faiss::Index> device_index = std::shared_ptr<faiss::Index>(gpu_index);
+        auto new_idx = std::make_shared<IVFSQHybrid>(device_index, device_id, res);
+        return new_idx;
+    } else {
+        KNOWHERE_THROW_MSG("CopyCpuToGpu Error, can't get gpu: " + std::to_string(gpu_id_) + "resource");
+    }
+}
+
+void
+IVFSQHybrid::LoadImpl(const BinarySet& index_binary) {
+    FaissBaseIndex::LoadImpl(index_binary);  // load on cpu
+    auto* ivf_index = dynamic_cast<faiss::IndexIVF*>(index_.get());
+    ivf_index->backup_quantizer();
+}
+
+void
+IVFSQHybrid::search_impl(int64_t n, const float* data, int64_t k, float* distances, int64_t* labels,
+                         const Config& cfg) {
+    if (gpu_mode == 2) {
+        GPUIVF::search_impl(n, data, k, distances, labels, cfg);
+    } else if (gpu_mode == 1) {
+        ResScope rs(res_, gpu_id_);
+        IVF::search_impl(n, data, k, distances, labels, cfg);
+    } else if (gpu_mode == 0) {
+        IVF::search_impl(n, data, k, distances, labels, cfg);
+    }
+}
+
+QuantizerPtr
+IVFSQHybrid::LoadQuantizer(const Config& conf) {
+    auto quantizer_conf = std::dynamic_pointer_cast<QuantizerCfg>(conf);
+    if (quantizer_conf != nullptr) {
+        if (quantizer_conf->mode != 1) {
+            KNOWHERE_THROW_MSG("mode only support 1 in this func");
+        }
+    }
+    gpu_id_ = quantizer_conf->gpu_id;
+
+    if (auto res = FaissGpuResourceMgr::GetInstance().GetRes(gpu_id_)) {
+        ResScope rs(res, gpu_id_, false);
+        faiss::gpu::GpuClonerOptions option;
+        option.allInGpu = true;
+
+        auto index_composition = new faiss::IndexComposition;
+        index_composition->index = index_.get();
+        index_composition->quantizer = nullptr;
+        index_composition->mode = quantizer_conf->mode;  // only 1
+
+        auto gpu_index = faiss::gpu::index_cpu_to_gpu(res->faiss_res.get(), gpu_id_, index_composition, &option);
+        delete gpu_index;
+
+        auto q = std::make_shared<FaissIVFQuantizer>();
+
+        auto& q_ptr = index_composition->quantizer;
+        q->size = q_ptr->d * q_ptr->getNumVecs() * sizeof(float);
+        q->quantizer = q_ptr;
+        res_ = res;
+        gpu_mode = 1;
+        return q;
+    } else {
+        KNOWHERE_THROW_MSG("CopyCpuToGpu Error, can't get gpu: " + std::to_string(gpu_id_) + "resource");
+    }
+}
+
+void
+IVFSQHybrid::SetQuantizer(const QuantizerPtr& q) {
+    auto ivf_quantizer = std::dynamic_pointer_cast<FaissIVFQuantizer>(q);
+    if (ivf_quantizer == nullptr) {
+        KNOWHERE_THROW_MSG("Quantizer type error");
+    }
+
+    faiss::IndexIVF* ivf_index = dynamic_cast<faiss::IndexIVF*>(index_.get());
+
+    faiss::gpu::GpuIndexFlat* is_gpu_flat_index = dynamic_cast<faiss::gpu::GpuIndexFlat*>(ivf_index->quantizer);
+    if (is_gpu_flat_index == nullptr) {
+        //        delete ivf_index->quantizer;
+        ivf_index->quantizer = ivf_quantizer->quantizer;
+    }
+}
+
+void
+IVFSQHybrid::UnsetQuantizer() {
+    auto* ivf_index = dynamic_cast<faiss::IndexIVF*>(index_.get());
+    if (ivf_index == nullptr) {
+        KNOWHERE_THROW_MSG("Index type error");
+    }
+
+    ivf_index->quantizer = nullptr;
+}
+
+VectorIndexPtr
+IVFSQHybrid::LoadData(const knowhere::QuantizerPtr& q, const Config& conf) {
+    auto quantizer_conf = std::dynamic_pointer_cast<QuantizerCfg>(conf);
+    if (quantizer_conf != nullptr) {
+        if (quantizer_conf->mode != 2) {
+            KNOWHERE_THROW_MSG("mode only support 2 in this func");
+        }
+    } else {
+        KNOWHERE_THROW_MSG("conf error");
+    }
+    //    if (quantizer_conf->gpu_id != gpu_id_) {
+    //        KNOWHERE_THROW_MSG("quantizer and data must on the same gpu card");
+    //    }
+    gpu_id_ = quantizer_conf->gpu_id;
+
+    if (auto res = FaissGpuResourceMgr::GetInstance().GetRes(gpu_id_)) {
+        ResScope rs(res, gpu_id_, false);
+        faiss::gpu::GpuClonerOptions option;
+        option.allInGpu = true;
+
+        auto ivf_quantizer = std::dynamic_pointer_cast<FaissIVFQuantizer>(q);
+        if (ivf_quantizer == nullptr)
+            KNOWHERE_THROW_MSG("quantizer type not faissivfquantizer");
+
+        auto index_composition = new faiss::IndexComposition;
+        index_composition->index = index_.get();
+        index_composition->quantizer = ivf_quantizer->quantizer;
+        index_composition->mode = quantizer_conf->mode;  // only 2
+
+        auto gpu_index = faiss::gpu::index_cpu_to_gpu(res->faiss_res.get(), gpu_id_, index_composition, &option);
+        std::shared_ptr<faiss::Index> new_idx;
+        new_idx.reset(gpu_index);
+        auto sq_idx = std::make_shared<IVFSQHybrid>(new_idx, gpu_id_, res);
+        return sq_idx;
+    } else {
+        KNOWHERE_THROW_MSG("CopyCpuToGpu Error, can't get gpu: " + std::to_string(gpu_id_) + "resource");
+    }
+}
+
+std::pair<VectorIndexPtr, QuantizerPtr>
+IVFSQHybrid::CopyCpuToGpuWithQuantizer(const int64_t& device_id, const Config& config) {
+    if (auto res = FaissGpuResourceMgr::GetInstance().GetRes(device_id)) {
+        ResScope rs(res, device_id, false);
+        faiss::gpu::GpuClonerOptions option;
+        option.allInGpu = true;
+
+        faiss::IndexComposition index_composition;
+        index_composition.index = index_.get();
+        index_composition.quantizer = nullptr;
+        index_composition.mode = 0;  // copy all
+
+        auto gpu_index = faiss::gpu::index_cpu_to_gpu(res->faiss_res.get(), device_id, &index_composition, &option);
+
+        std::shared_ptr<faiss::Index> device_index;
+        device_index.reset(gpu_index);
+        auto new_idx = std::make_shared<IVFSQHybrid>(device_index, device_id, res);
+
+        auto q = std::make_shared<FaissIVFQuantizer>();
+        q->quantizer = index_composition.quantizer;
+        q->size = index_composition.quantizer->d * index_composition.quantizer->getNumVecs() * sizeof(float);
+        return std::make_pair(new_idx, q);
+    } else {
+        KNOWHERE_THROW_MSG("CopyCpuToGpu Error, can't get gpu: " + std::to_string(gpu_id_) + "resource");
+    }
+}
+
+FaissIVFQuantizer::~FaissIVFQuantizer() {
+    if (quantizer != nullptr) {
+        delete quantizer;
+        quantizer = nullptr;
+    }
+    // else do nothing
+}
+
+#else
+
+QuantizerPtr
+IVFSQHybrid::LoadQuantizer(const Config& conf) {
+    return knowhere::QuantizerPtr();
+}
+
+void
+IVFSQHybrid::SetQuantizer(const QuantizerPtr& q) {
+}
+
+void
+IVFSQHybrid::UnsetQuantizer() {
+}
+
+VectorIndexPtr
+IVFSQHybrid::LoadData(const knowhere::QuantizerPtr& q, const Config& conf) {
+    return nullptr;
+}
+
+std::pair<VectorIndexPtr, QuantizerPtr>
+IVFSQHybrid::CopyCpuToGpuWithQuantizer(const int64_t& device_id, const Config& config) {
+    KNOWHERE_THROW_MSG("Not yet implemented");
+}
+
+IndexModelPtr
+IVFSQHybrid::Train(const DatasetPtr& dataset, const Config& config) {
+    return GPUIVFSQ::Train(dataset, config);
+}
+
+VectorIndexPtr
+IVFSQHybrid::CopyGpuToCpu(const Config& config) {
+    return GPUIVFSQ::CopyGpuToCpu(config);
+}
+
+VectorIndexPtr
+IVFSQHybrid::CopyCpuToGpu(const int64_t& device_id, const Config& config) {
+    return IVF::CopyCpuToGpu(device_id, config);
+}
+
+void
+IVFSQHybrid::search_impl(int64_t n, const float* data, int64_t k, float* distances, int64_t* labels,
+                         const Config& cfg) {
+    GPUIVF::search_impl(n, data, k, distances, labels, cfg);
+}
+
+void
+IVFSQHybrid::LoadImpl(const BinarySet& index_binary) {
+    GPUIVF::LoadImpl(index_binary);
+}
+
+#endif
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/index/vector_index/IndexIVFSQHybrid.h b/core/src/index/knowhere/knowhere/index/vector_index/IndexIVFSQHybrid.h
new file mode 100644
index 0000000000..f54c61c20f
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/index/vector_index/IndexIVFSQHybrid.h
@@ -0,0 +1,90 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <faiss/index_io.h>
+#include <memory>
+#include <utility>
+
+#include "IndexGPUIVFSQ.h"
+#include "Quantizer.h"
+
+namespace knowhere {
+
+#ifdef CUSTOMIZATION
+struct FaissIVFQuantizer : public Quantizer {
+    faiss::gpu::GpuIndexFlat* quantizer = nullptr;
+
+    ~FaissIVFQuantizer() override;
+};
+using FaissIVFQuantizerPtr = std::shared_ptr<FaissIVFQuantizer>;
+#endif
+
+class IVFSQHybrid : public GPUIVFSQ {
+ public:
+    explicit IVFSQHybrid(const int& device_id) : GPUIVFSQ(device_id) {
+        gpu_mode = 0;
+    }
+
+    explicit IVFSQHybrid(std::shared_ptr<faiss::Index> index) : GPUIVFSQ(-1) {
+        index_ = index;
+        gpu_mode = 0;
+    }
+
+    explicit IVFSQHybrid(std::shared_ptr<faiss::Index> index, const int64_t& device_id, ResPtr& resource)
+        : GPUIVFSQ(index, device_id, resource) {
+        gpu_mode = 2;
+    }
+
+ public:
+    QuantizerPtr
+    LoadQuantizer(const Config& conf);
+
+    void
+    SetQuantizer(const QuantizerPtr& q);
+
+    void
+    UnsetQuantizer();
+
+    VectorIndexPtr
+    LoadData(const knowhere::QuantizerPtr& q, const Config& conf);
+
+    std::pair<VectorIndexPtr, QuantizerPtr>
+    CopyCpuToGpuWithQuantizer(const int64_t& device_id, const Config& config);
+
+    IndexModelPtr
+    Train(const DatasetPtr& dataset, const Config& config) override;
+
+    VectorIndexPtr
+    CopyGpuToCpu(const Config& config) override;
+
+    VectorIndexPtr
+    CopyCpuToGpu(const int64_t& device_id, const Config& config) override;
+
+ protected:
+    void
+    search_impl(int64_t n, const float* data, int64_t k, float* distances, int64_t* labels, const Config& cfg) override;
+
+    void
+    LoadImpl(const BinarySet& index_binary) override;
+
+ protected:
+    int64_t gpu_mode = 0;  // 0,1,2
+};
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/index/vector_index/IndexKDT.cpp b/core/src/index/knowhere/knowhere/index/vector_index/IndexKDT.cpp
new file mode 100644
index 0000000000..1bd45075e3
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/index/vector_index/IndexKDT.cpp
@@ -0,0 +1,180 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 <SPTAG/AnnService/inc/Core/Common.h>
+#include <SPTAG/AnnService/inc/Core/VectorSet.h>
+#include <SPTAG/AnnService/inc/Server/QueryParser.h>
+#include <sstream>
+#include <vector>
+
+#undef mkdir
+
+#include "knowhere/index/vector_index/IndexKDT.h"
+#include "knowhere/index/vector_index/helpers/Definitions.h"
+//#include "knowhere/index/preprocessor/normalize.h"
+#include "knowhere/adapter/SptagAdapter.h"
+#include "knowhere/common/Exception.h"
+#include "knowhere/index/vector_index/helpers/KDTParameterMgr.h"
+
+namespace knowhere {
+
+BinarySet
+CPUKDTRNG::Serialize() {
+    std::vector<void*> index_blobs;
+    std::vector<int64_t> index_len;
+
+    // TODO(zirui): dev
+    //    index_ptr_->SaveIndexToMemory(index_blobs, index_len);
+    BinarySet binary_set;
+
+    //
+    //    auto sample = std::make_shared<uint8_t>();
+    //    sample.reset(static_cast<uint8_t*>(index_blobs[0]));
+    //    auto tree = std::make_shared<uint8_t>();
+    //    tree.reset(static_cast<uint8_t*>(index_blobs[1]));
+    //    auto graph = std::make_shared<uint8_t>();
+    //    graph.reset(static_cast<uint8_t*>(index_blobs[2]));
+    //    auto metadata = std::make_shared<uint8_t>();
+    //    metadata.reset(static_cast<uint8_t*>(index_blobs[3]));
+    //
+    //    binary_set.Append("samples", sample, index_len[0]);
+    //    binary_set.Append("tree", tree, index_len[1]);
+    //    binary_set.Append("graph", graph, index_len[2]);
+    //    binary_set.Append("metadata", metadata, index_len[3]);
+    return binary_set;
+}
+
+void
+CPUKDTRNG::Load(const BinarySet& binary_set) {
+    // TODO(zirui): dev
+
+    //    std::vector<void*> index_blobs;
+    //
+    //    auto samples = binary_set.GetByName("samples");
+    //    index_blobs.push_back(samples->data.get());
+    //
+    //    auto tree = binary_set.GetByName("tree");
+    //    index_blobs.push_back(tree->data.get());
+    //
+    //    auto graph = binary_set.GetByName("graph");
+    //    index_blobs.push_back(graph->data.get());
+    //
+    //    auto metadata = binary_set.GetByName("metadata");
+    //    index_blobs.push_back(metadata->data.get());
+    //
+    //    index_ptr_->LoadIndexFromMemory(index_blobs);
+}
+
+// PreprocessorPtr
+// CPUKDTRNG::BuildPreprocessor(const DatasetPtr &dataset, const Config &config) {
+//    return std::make_shared<NormalizePreprocessor>();
+//}
+
+IndexModelPtr
+CPUKDTRNG::Train(const DatasetPtr& origin, const Config& train_config) {
+    SetParameters(train_config);
+    DatasetPtr dataset = origin->Clone();
+
+    // if (index_ptr_->GetDistCalcMethod() == SPTAG::DistCalcMethod::Cosine
+    //    && preprocessor_) {
+    //    preprocessor_->Preprocess(dataset);
+    //}
+
+    auto vectorset = ConvertToVectorSet(dataset);
+    auto metaset = ConvertToMetadataSet(dataset);
+    index_ptr_->BuildIndex(vectorset, metaset);
+
+    // TODO: return IndexModelPtr
+    return nullptr;
+}
+
+void
+CPUKDTRNG::Add(const DatasetPtr& origin, const Config& add_config) {
+    SetParameters(add_config);
+    DatasetPtr dataset = origin->Clone();
+
+    // if (index_ptr_->GetDistCalcMethod() == SPTAG::DistCalcMethod::Cosine
+    //    && preprocessor_) {
+    //    preprocessor_->Preprocess(dataset);
+    //}
+
+    auto vectorset = ConvertToVectorSet(dataset);
+    auto metaset = ConvertToMetadataSet(dataset);
+    index_ptr_->AddIndex(vectorset, metaset);
+}
+
+void
+CPUKDTRNG::SetParameters(const Config& config) {
+    for (auto& para : KDTParameterMgr::GetInstance().GetKDTParameters()) {
+        //        auto value = config.get_with_default(para.first, para.second);
+        index_ptr_->SetParameter(para.first, para.second);
+    }
+}
+
+DatasetPtr
+CPUKDTRNG::Search(const DatasetPtr& dataset, const Config& config) {
+    SetParameters(config);
+    auto tensor = dataset->tensor()[0];
+    auto p = (float*)tensor->raw_mutable_data();
+    for (auto i = 0; i < 10; ++i) {
+        for (auto j = 0; j < 10; ++j) {
+            std::cout << p[i * 10 + j] << " ";
+        }
+        std::cout << std::endl;
+    }
+    std::vector<SPTAG::QueryResult> query_results = ConvertToQueryResult(dataset, config);
+
+#pragma omp parallel for
+    for (auto i = 0; i < query_results.size(); ++i) {
+        auto target = (float*)query_results[i].GetTarget();
+        std::cout << target[0] << ", " << target[1] << ", " << target[2] << std::endl;
+        index_ptr_->SearchIndex(query_results[i]);
+    }
+
+    return ConvertToDataset(query_results);
+}
+
+int64_t
+CPUKDTRNG::Count() {
+    index_ptr_->GetNumSamples();
+}
+
+int64_t
+CPUKDTRNG::Dimension() {
+    index_ptr_->GetFeatureDim();
+}
+
+VectorIndexPtr
+CPUKDTRNG::Clone() {
+    KNOWHERE_THROW_MSG("not support");
+}
+
+void
+CPUKDTRNG::Seal() {
+    // do nothing
+}
+
+// TODO(linxj):
+BinarySet
+CPUKDTRNGIndexModel::Serialize() {
+}
+
+void
+CPUKDTRNGIndexModel::Load(const BinarySet& binary) {
+}
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/index/vector_index/IndexKDT.h b/core/src/index/knowhere/knowhere/index/vector_index/IndexKDT.h
new file mode 100644
index 0000000000..f6d436995b
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/index/vector_index/IndexKDT.h
@@ -0,0 +1,87 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <SPTAG/AnnService/inc/Core/VectorIndex.h>
+#include <cstdint>
+#include <memory>
+#include "VectorIndex.h"
+#include "knowhere/index/IndexModel.h"
+
+namespace knowhere {
+
+class CPUKDTRNG : public VectorIndex {
+ public:
+    CPUKDTRNG() {
+        index_ptr_ = SPTAG::VectorIndex::CreateInstance(SPTAG::IndexAlgoType::KDT, SPTAG::VectorValueType::Float);
+        index_ptr_->SetParameter("DistCalcMethod", "L2");
+    }
+
+ public:
+    BinarySet
+    Serialize() override;
+    VectorIndexPtr
+    Clone() override;
+    void
+    Load(const BinarySet& index_array) override;
+
+ public:
+    // PreprocessorPtr
+    // BuildPreprocessor(const DatasetPtr &dataset, const Config &config) override;
+    int64_t
+    Count() override;
+    int64_t
+    Dimension() override;
+
+    IndexModelPtr
+    Train(const DatasetPtr& dataset, const Config& config) override;
+
+    void
+    Add(const DatasetPtr& dataset, const Config& config) override;
+
+    DatasetPtr
+    Search(const DatasetPtr& dataset, const Config& config) override;
+    void
+    Seal() override;
+
+ private:
+    void
+    SetParameters(const Config& config);
+
+ private:
+    PreprocessorPtr preprocessor_;
+    std::shared_ptr<SPTAG::VectorIndex> index_ptr_;
+};
+
+using CPUKDTRNGPtr = std::shared_ptr<CPUKDTRNG>;
+
+class CPUKDTRNGIndexModel : public IndexModel {
+ public:
+    BinarySet
+    Serialize() override;
+
+    void
+    Load(const BinarySet& binary) override;
+
+ private:
+    std::shared_ptr<SPTAG::VectorIndex> index_;
+};
+
+using CPUKDTRNGIndexModelPtr = std::shared_ptr<CPUKDTRNGIndexModel>;
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/index/vector_index/IndexNSG.cpp b/core/src/index/knowhere/knowhere/index/vector_index/IndexNSG.cpp
new file mode 100644
index 0000000000..f5519b8240
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/index/vector_index/IndexNSG.cpp
@@ -0,0 +1,168 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "knowhere/index/vector_index/IndexNSG.h"
+#include "knowhere/adapter/VectorAdapter.h"
+#include "knowhere/common/Exception.h"
+#include "knowhere/common/Timer.h"
+#include "knowhere/index/vector_index/IndexGPUIVF.h"
+#include "knowhere/index/vector_index/IndexIDMAP.h"
+#include "knowhere/index/vector_index/IndexIVF.h"
+#include "knowhere/index/vector_index/nsg/NSG.h"
+#include "knowhere/index/vector_index/nsg/NSGIO.h"
+
+namespace knowhere {
+
+BinarySet
+NSG::Serialize() {
+    if (!index_ || !index_->is_trained) {
+        KNOWHERE_THROW_MSG("index not initialize or trained");
+    }
+
+    try {
+        algo::NsgIndex* index = index_.get();
+
+        MemoryIOWriter writer;
+        algo::write_index(index, writer);
+        auto data = std::make_shared<uint8_t>();
+        data.reset(writer.data_);
+
+        BinarySet res_set;
+        res_set.Append("NSG", data, writer.total);
+        return res_set;
+    } catch (std::exception& e) {
+        KNOWHERE_THROW_MSG(e.what());
+    }
+}
+
+void
+NSG::Load(const BinarySet& index_binary) {
+    try {
+        auto binary = index_binary.GetByName("NSG");
+
+        MemoryIOReader reader;
+        reader.total = binary->size;
+        reader.data_ = binary->data.get();
+
+        auto index = algo::read_index(reader);
+        index_.reset(index);
+    } catch (std::exception& e) {
+        KNOWHERE_THROW_MSG(e.what());
+    }
+}
+
+DatasetPtr
+NSG::Search(const DatasetPtr& dataset, const Config& config) {
+    auto build_cfg = std::dynamic_pointer_cast<NSGCfg>(config);
+    if (build_cfg != nullptr) {
+        build_cfg->CheckValid();  // throw exception
+    }
+
+    if (!index_ || !index_->is_trained) {
+        KNOWHERE_THROW_MSG("index not initialize or trained");
+    }
+
+    GETTENSOR(dataset)
+
+    auto elems = rows * build_cfg->k;
+    auto res_ids = (int64_t*)malloc(sizeof(int64_t) * elems);
+    auto res_dis = (float*)malloc(sizeof(float) * elems);
+
+    algo::SearchParams s_params;
+    s_params.search_length = build_cfg->search_length;
+    index_->Search((float*)p_data, rows, dim, build_cfg->k, res_dis, res_ids, s_params);
+
+    auto id_buf = MakeMutableBufferSmart((uint8_t*)res_ids, sizeof(int64_t) * elems);
+    auto dist_buf = MakeMutableBufferSmart((uint8_t*)res_dis, sizeof(float) * elems);
+
+    std::vector<BufferPtr> id_bufs{nullptr, id_buf};
+    std::vector<BufferPtr> dist_bufs{nullptr, dist_buf};
+
+    auto int64_type = std::make_shared<arrow::Int64Type>();
+    auto float_type = std::make_shared<arrow::FloatType>();
+
+    auto id_array_data = arrow::ArrayData::Make(int64_type, elems, id_bufs);
+    auto dist_array_data = arrow::ArrayData::Make(float_type, elems, dist_bufs);
+
+    auto ids = std::make_shared<NumericArray<arrow::Int64Type>>(id_array_data);
+    auto dists = std::make_shared<NumericArray<arrow::FloatType>>(dist_array_data);
+    std::vector<ArrayPtr> array{ids, dists};
+
+    return std::make_shared<Dataset>(array, nullptr);
+}
+
+IndexModelPtr
+NSG::Train(const DatasetPtr& dataset, const Config& config) {
+    auto build_cfg = std::dynamic_pointer_cast<NSGCfg>(config);
+    if (build_cfg != nullptr) {
+        build_cfg->CheckValid();  // throw exception
+    }
+
+    if (build_cfg->metric_type != METRICTYPE::L2) {
+        KNOWHERE_THROW_MSG("NSG not support this kind of metric type");
+    }
+
+    // TODO(linxj): dev IndexFactory, support more IndexType
+    auto preprocess_index = std::make_shared<GPUIVF>(build_cfg->gpu_id);
+    auto model = preprocess_index->Train(dataset, config);
+    preprocess_index->set_index_model(model);
+    preprocess_index->AddWithoutIds(dataset, config);
+
+    Graph knng;
+    preprocess_index->GenGraph(build_cfg->knng, knng, dataset, config);
+
+    algo::BuildParams b_params;
+    b_params.candidate_pool_size = build_cfg->candidate_pool_size;
+    b_params.out_degree = build_cfg->out_degree;
+    b_params.search_length = build_cfg->search_length;
+
+    GETTENSOR(dataset)
+    auto array = dataset->array()[0];
+    auto p_ids = array->data()->GetValues<int64_t>(1, 0);
+
+    index_ = std::make_shared<algo::NsgIndex>(dim, rows);
+    index_->SetKnnGraph(knng);
+    index_->Build_with_ids(rows, (float*)p_data, (int64_t*)p_ids, b_params);
+    return nullptr;  // TODO(linxj): support serialize
+}
+
+void
+NSG::Add(const DatasetPtr& dataset, const Config& config) {
+    // do nothing
+}
+
+int64_t
+NSG::Count() {
+    return index_->ntotal;
+}
+
+int64_t
+NSG::Dimension() {
+    return index_->dimension;
+}
+
+VectorIndexPtr
+NSG::Clone() {
+    KNOWHERE_THROW_MSG("not support");
+}
+
+void
+NSG::Seal() {
+    // do nothing
+}
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/index/vector_index/IndexNSG.h b/core/src/index/knowhere/knowhere/index/vector_index/IndexNSG.h
new file mode 100644
index 0000000000..04a146d58a
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/index/vector_index/IndexNSG.h
@@ -0,0 +1,64 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <memory>
+#include <vector>
+
+#include "VectorIndex.h"
+
+namespace knowhere {
+
+namespace algo {
+class NsgIndex;
+}
+
+class NSG : public VectorIndex {
+ public:
+    explicit NSG(const int64_t& gpu_num) : gpu_(gpu_num) {
+    }
+
+    NSG() = default;
+
+    IndexModelPtr
+    Train(const DatasetPtr& dataset, const Config& config) override;
+    DatasetPtr
+    Search(const DatasetPtr& dataset, const Config& config) override;
+    void
+    Add(const DatasetPtr& dataset, const Config& config) override;
+    BinarySet
+    Serialize() override;
+    void
+    Load(const BinarySet& index_binary) override;
+    int64_t
+    Count() override;
+    int64_t
+    Dimension() override;
+    VectorIndexPtr
+    Clone() override;
+    void
+    Seal() override;
+
+ private:
+    std::shared_ptr<algo::NsgIndex> index_;
+    int64_t gpu_;
+};
+
+using NSGIndexPtr = std::shared_ptr<NSG>();
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/index/vector_index/Quantizer.h b/core/src/index/knowhere/knowhere/index/vector_index/Quantizer.h
new file mode 100644
index 0000000000..f7f9fda80a
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/index/vector_index/Quantizer.h
@@ -0,0 +1,37 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <memory>
+#include "knowhere/common/Config.h"
+
+namespace knowhere {
+
+struct Quantizer {
+    virtual ~Quantizer() = default;
+
+    int64_t size = -1;
+};
+using QuantizerPtr = std::shared_ptr<Quantizer>;
+
+struct QuantizerCfg : Cfg {
+    int64_t mode = -1;  // 0: all data, 1: copy quantizer, 2: copy data
+};
+using QuantizerConfig = std::shared_ptr<QuantizerCfg>;
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/index/vector_index/VectorIndex.h b/core/src/index/knowhere/knowhere/index/vector_index/VectorIndex.h
new file mode 100644
index 0000000000..810c4d2ea4
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/index/vector_index/VectorIndex.h
@@ -0,0 +1,61 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <memory>
+
+#include "knowhere/common/Config.h"
+#include "knowhere/common/Dataset.h"
+#include "knowhere/index/Index.h"
+#include "knowhere/index/preprocessor/Preprocessor.h"
+#include "knowhere/index/vector_index/helpers/IndexParameter.h"
+
+namespace knowhere {
+
+class VectorIndex;
+using VectorIndexPtr = std::shared_ptr<VectorIndex>;
+
+class VectorIndex : public Index {
+ public:
+    virtual PreprocessorPtr
+    BuildPreprocessor(const DatasetPtr& dataset, const Config& config) {
+        return nullptr;
+    }
+
+    virtual IndexModelPtr
+    Train(const DatasetPtr& dataset, const Config& config) {
+        return nullptr;
+    }
+
+    virtual void
+    Add(const DatasetPtr& dataset, const Config& config) = 0;
+
+    virtual void
+    Seal() = 0;
+
+    virtual VectorIndexPtr
+    Clone() = 0;
+
+    virtual int64_t
+    Count() = 0;
+
+    virtual int64_t
+    Dimension() = 0;
+};
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/index/vector_index/helpers/Cloner.cpp b/core/src/index/knowhere/knowhere/index/vector_index/helpers/Cloner.cpp
new file mode 100644
index 0000000000..5ff2bfc2e3
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/index/vector_index/helpers/Cloner.cpp
@@ -0,0 +1,63 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "knowhere/index/vector_index/helpers/Cloner.h"
+#include "knowhere/common/Exception.h"
+#include "knowhere/index/vector_index/IndexGPUIVF.h"
+#include "knowhere/index/vector_index/IndexIDMAP.h"
+#include "knowhere/index/vector_index/IndexIVF.h"
+#include "knowhere/index/vector_index/IndexIVFPQ.h"
+#include "knowhere/index/vector_index/IndexIVFSQ.h"
+#include "knowhere/index/vector_index/IndexIVFSQHybrid.h"
+
+namespace knowhere {
+namespace cloner {
+
+VectorIndexPtr
+CopyGpuToCpu(const VectorIndexPtr& index, const Config& config) {
+    if (auto device_index = std::dynamic_pointer_cast<GPUIndex>(index)) {
+        return device_index->CopyGpuToCpu(config);
+    } else {
+        KNOWHERE_THROW_MSG("index type is not gpuindex");
+    }
+}
+
+VectorIndexPtr
+CopyCpuToGpu(const VectorIndexPtr& index, const int64_t& device_id, const Config& config) {
+    if (auto device_index = std::dynamic_pointer_cast<IVFSQHybrid>(index)) {
+        return device_index->CopyCpuToGpu(device_id, config);
+    }
+
+    if (auto device_index = std::dynamic_pointer_cast<GPUIndex>(index)) {
+        return device_index->CopyGpuToGpu(device_id, config);
+    }
+
+    if (auto cpu_index = std::dynamic_pointer_cast<IVFSQ>(index)) {
+        return cpu_index->CopyCpuToGpu(device_id, config);
+    } else if (auto cpu_index = std::dynamic_pointer_cast<IVFPQ>(index)) {
+        KNOWHERE_THROW_MSG("IVFPQ not support transfer to gpu");
+    } else if (auto cpu_index = std::dynamic_pointer_cast<IVF>(index)) {
+        return cpu_index->CopyCpuToGpu(device_id, config);
+    } else if (auto cpu_index = std::dynamic_pointer_cast<IDMAP>(index)) {
+        return cpu_index->CopyCpuToGpu(device_id, config);
+    } else {
+        KNOWHERE_THROW_MSG("this index type not support tranfer to gpu");
+    }
+}
+
+}  // namespace cloner
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/index/vector_index/helpers/Cloner.h b/core/src/index/knowhere/knowhere/index/vector_index/helpers/Cloner.h
new file mode 100644
index 0000000000..3134238ed8
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/index/vector_index/helpers/Cloner.h
@@ -0,0 +1,33 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "knowhere/index/vector_index/VectorIndex.h"
+
+namespace knowhere {
+namespace cloner {
+
+// TODO(linxj): rename CopyToGpu
+extern VectorIndexPtr
+CopyCpuToGpu(const VectorIndexPtr& index, const int64_t& device_id, const Config& config);
+
+extern VectorIndexPtr
+CopyGpuToCpu(const VectorIndexPtr& index, const Config& config);
+
+}  // namespace cloner
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/index/vector_index/helpers/Definitions.h b/core/src/index/knowhere/knowhere/index/vector_index/helpers/Definitions.h
new file mode 100644
index 0000000000..f39a28d20f
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/index/vector_index/helpers/Definitions.h
@@ -0,0 +1,28 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+namespace knowhere {
+namespace definition {
+
+#define META_ROWS ("rows")
+#define META_DIM ("dimension")
+#define META_K ("k")
+
+}  // namespace definition
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/index/vector_index/helpers/FaissGpuResourceMgr.cpp b/core/src/index/knowhere/knowhere/index/vector_index/helpers/FaissGpuResourceMgr.cpp
new file mode 100644
index 0000000000..837629c6eb
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/index/vector_index/helpers/FaissGpuResourceMgr.cpp
@@ -0,0 +1,126 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "knowhere/index/vector_index/helpers/FaissGpuResourceMgr.h"
+
+#include <utility>
+
+namespace knowhere {
+
+FaissGpuResourceMgr&
+FaissGpuResourceMgr::GetInstance() {
+    static FaissGpuResourceMgr instance;
+    return instance;
+}
+
+void
+FaissGpuResourceMgr::AllocateTempMem(ResPtr& resource, const int64_t& device_id, const int64_t& size) {
+    if (size) {
+        resource->faiss_res->setTempMemory(size);
+    } else {
+        auto search = devices_params_.find(device_id);
+        if (search != devices_params_.end()) {
+            resource->faiss_res->setTempMemory(search->second.temp_mem_size);
+        }
+        // else do nothing. allocate when use.
+    }
+}
+
+void
+FaissGpuResourceMgr::InitDevice(int64_t device_id, int64_t pin_mem_size, int64_t temp_mem_size, int64_t res_num) {
+    DeviceParams params;
+    params.pinned_mem_size = pin_mem_size;
+    params.temp_mem_size = temp_mem_size;
+    params.resource_num = res_num;
+
+    devices_params_.emplace(device_id, params);
+}
+
+void
+FaissGpuResourceMgr::InitResource() {
+    if (is_init)
+        return;
+
+    is_init = true;
+
+    // std::cout << "InitResource" << std::endl;
+    for (auto& device : devices_params_) {
+        auto& device_id = device.first;
+
+        mutex_cache_.emplace(device_id, std::make_unique<std::mutex>());
+
+        // std::cout << "Device Id: " << DEVICEID << std::endl;
+        auto& device_param = device.second;
+        auto& bq = idle_map_[device_id];
+
+        for (int64_t i = 0; i < device_param.resource_num; ++i) {
+            // std::cout << "Resource Id: " << i << std::endl;
+            auto raw_resource = std::make_shared<faiss::gpu::StandardGpuResources>();
+
+            // TODO(linxj): enable set pinned memory
+            auto res_wrapper = std::make_shared<Resource>(raw_resource);
+            AllocateTempMem(res_wrapper, device_id, 0);
+
+            bq.Put(res_wrapper);
+        }
+    }
+    // std::cout << "End initResource" << std::endl;
+}
+
+ResPtr
+FaissGpuResourceMgr::GetRes(const int64_t& device_id, const int64_t& alloc_size) {
+    InitResource();
+
+    auto finder = idle_map_.find(device_id);
+    if (finder != idle_map_.end()) {
+        auto& bq = finder->second;
+        auto&& resource = bq.Take();
+        AllocateTempMem(resource, device_id, alloc_size);
+        return resource;
+    }
+    return nullptr;
+}
+
+void
+FaissGpuResourceMgr::MoveToIdle(const int64_t& device_id, const ResPtr& res) {
+    auto finder = idle_map_.find(device_id);
+    if (finder != idle_map_.end()) {
+        auto& bq = finder->second;
+        bq.Put(res);
+    }
+}
+
+void
+FaissGpuResourceMgr::Free() {
+    for (auto& item : idle_map_) {
+        auto& bq = item.second;
+        while (!bq.Empty()) {
+            bq.Take();
+        }
+    }
+    is_init = false;
+}
+
+void
+FaissGpuResourceMgr::Dump() {
+    for (auto& item : idle_map_) {
+        auto& bq = item.second;
+        std::cout << "DEVICEID: " << item.first << ", resource count:" << bq.Size();
+    }
+}
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/index/vector_index/helpers/FaissGpuResourceMgr.h b/core/src/index/knowhere/knowhere/index/vector_index/helpers/FaissGpuResourceMgr.h
new file mode 100644
index 0000000000..73f959baa0
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/index/vector_index/helpers/FaissGpuResourceMgr.h
@@ -0,0 +1,133 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <map>
+#include <memory>
+#include <mutex>
+#include <utility>
+
+#include <faiss/gpu/StandardGpuResources.h>
+
+#include "src/utils/BlockingQueue.h"
+
+namespace knowhere {
+
+struct Resource {
+    explicit Resource(std::shared_ptr<faiss::gpu::StandardGpuResources>& r) : faiss_res(r) {
+        static int64_t global_id = 0;
+        id = global_id++;
+    }
+
+    std::shared_ptr<faiss::gpu::StandardGpuResources> faiss_res;
+    int64_t id;
+    std::mutex mutex;
+};
+using ResPtr = std::shared_ptr<Resource>;
+using ResWPtr = std::weak_ptr<Resource>;
+
+class FaissGpuResourceMgr {
+ public:
+    friend class ResScope;
+    using ResBQ = milvus::server::BlockingQueue<ResPtr>;
+
+ public:
+    struct DeviceParams {
+        int64_t temp_mem_size = 0;
+        int64_t pinned_mem_size = 0;
+        int64_t resource_num = 2;
+    };
+
+ public:
+    static FaissGpuResourceMgr&
+    GetInstance();
+
+    // Free gpu resource, avoid cudaGetDevice error when deallocate.
+    // this func should be invoke before main return
+    void
+    Free();
+
+    void
+    AllocateTempMem(ResPtr& resource, const int64_t& device_id, const int64_t& size);
+
+    void
+    InitDevice(int64_t device_id, int64_t pin_mem_size = 0, int64_t temp_mem_size = 0, int64_t res_num = 2);
+
+    void
+    InitResource();
+
+    // allocate gpu memory invoke by build or copy_to_gpu
+    ResPtr
+    GetRes(const int64_t& device_id, const int64_t& alloc_size = 0);
+
+    void
+    MoveToIdle(const int64_t& device_id, const ResPtr& res);
+
+    void
+    Dump();
+
+ protected:
+    bool is_init = false;
+
+    std::map<int64_t, std::unique_ptr<std::mutex>> mutex_cache_;
+    std::map<int64_t, DeviceParams> devices_params_;
+    std::map<int64_t, ResBQ> idle_map_;
+};
+
+class ResScope {
+ public:
+    ResScope(ResPtr& res, const int64_t& device_id, const bool& isown)
+        : resource(res), device_id(device_id), move(true), own(isown) {
+        Lock();
+    }
+
+    ResScope(ResWPtr& res, const int64_t& device_id, const bool& isown)
+        : resource(res), device_id(device_id), move(true), own(isown) {
+        Lock();
+    }
+
+    // specif for search
+    // get the ownership of gpuresource and gpu
+    ResScope(ResWPtr& res, const int64_t& device_id) : device_id(device_id), move(false), own(true) {
+        resource = res.lock();
+        Lock();
+    }
+
+    void
+    Lock() {
+        if (own)
+            FaissGpuResourceMgr::GetInstance().mutex_cache_[device_id]->lock();
+        resource->mutex.lock();
+    }
+
+    ~ResScope() {
+        if (own)
+            FaissGpuResourceMgr::GetInstance().mutex_cache_[device_id]->unlock();
+        if (move)
+            FaissGpuResourceMgr::GetInstance().MoveToIdle(device_id, resource);
+        resource->mutex.unlock();
+    }
+
+ private:
+    ResPtr resource;  // hold resource until deconstruct
+    int64_t device_id;
+    bool move = true;
+    bool own = false;
+};
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/index/vector_index/helpers/FaissIO.cpp b/core/src/index/knowhere/knowhere/index/vector_index/helpers/FaissIO.cpp
new file mode 100644
index 0000000000..99532137c0
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/index/vector_index/helpers/FaissIO.cpp
@@ -0,0 +1,67 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 <cstring>
+
+#include "knowhere/index/vector_index/helpers/FaissIO.h"
+
+namespace knowhere {
+
+// TODO(linxj): Get From Config File
+static size_t magic_num = 2;
+
+size_t
+MemoryIOWriter::operator()(const void* ptr, size_t size, size_t nitems) {
+    auto total_need = size * nitems + rp;
+
+    if (!data_) {  // data == nullptr
+        total = total_need * magic_num;
+        rp = size * nitems;
+        data_ = new uint8_t[total];
+        memcpy((void*)(data_), ptr, rp);
+    }
+
+    if (total_need > total) {
+        total = total_need * magic_num;
+        auto new_data = new uint8_t[total];
+        memcpy((void*)new_data, (void*)data_, rp);
+        delete data_;
+        data_ = new_data;
+
+        memcpy((void*)(data_ + rp), ptr, size * nitems);
+        rp = total_need;
+    } else {
+        memcpy((void*)(data_ + rp), ptr, size * nitems);
+        rp = total_need;
+    }
+
+    return nitems;
+}
+
+size_t
+MemoryIOReader::operator()(void* ptr, size_t size, size_t nitems) {
+    if (rp >= total)
+        return 0;
+    size_t nremain = (total - rp) / size;
+    if (nremain < nitems)
+        nitems = nremain;
+    memcpy(ptr, (void*)(data_ + rp), size * nitems);
+    rp += size * nitems;
+    return nitems;
+}
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/index/vector_index/helpers/FaissIO.h b/core/src/index/knowhere/knowhere/index/vector_index/helpers/FaissIO.h
new file mode 100644
index 0000000000..7cce5bbbac
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/index/vector_index/helpers/FaissIO.h
@@ -0,0 +1,42 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <faiss/AuxIndexStructures.h>
+
+namespace knowhere {
+
+struct MemoryIOWriter : public faiss::IOWriter {
+    uint8_t* data_ = nullptr;
+    size_t total = 0;
+    size_t rp = 0;
+
+    size_t
+    operator()(const void* ptr, size_t size, size_t nitems) override;
+};
+
+struct MemoryIOReader : public faiss::IOReader {
+    uint8_t* data_;
+    size_t rp = 0;
+    size_t total = 0;
+
+    size_t
+    operator()(void* ptr, size_t size, size_t nitems) override;
+};
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/index/vector_index/helpers/IndexParameter.cpp b/core/src/index/knowhere/knowhere/index/vector_index/helpers/IndexParameter.cpp
new file mode 100644
index 0000000000..20f3388174
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/index/vector_index/helpers/IndexParameter.cpp
@@ -0,0 +1,37 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "knowhere/index/vector_index/helpers/IndexParameter.h"
+#include "knowhere/common/Exception.h"
+
+#include <faiss/Index.h>
+
+namespace knowhere {
+
+faiss::MetricType
+GetMetricType(METRICTYPE& type) {
+    if (type == METRICTYPE::L2) {
+        return faiss::METRIC_L2;
+    }
+    if (type == METRICTYPE::IP) {
+        return faiss::METRIC_INNER_PRODUCT;
+    }
+
+    KNOWHERE_THROW_MSG("Metric type is invalid");
+}
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/index/vector_index/helpers/IndexParameter.h b/core/src/index/knowhere/knowhere/index/vector_index/helpers/IndexParameter.h
new file mode 100644
index 0000000000..b2854abef8
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/index/vector_index/helpers/IndexParameter.h
@@ -0,0 +1,133 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <faiss/Index.h>
+#include <memory>
+
+#include "knowhere/common/Config.h"
+
+namespace knowhere {
+
+extern faiss::MetricType
+GetMetricType(METRICTYPE& type);
+
+// IVF Config
+constexpr int64_t DEFAULT_NLIST = INVALID_VALUE;
+constexpr int64_t DEFAULT_NPROBE = INVALID_VALUE;
+constexpr int64_t DEFAULT_NSUBVECTORS = INVALID_VALUE;
+constexpr int64_t DEFAULT_NBITS = INVALID_VALUE;
+constexpr int64_t DEFAULT_SCAN_TABLE_THREHOLD = INVALID_VALUE;
+constexpr int64_t DEFAULT_POLYSEMOUS_HT = INVALID_VALUE;
+constexpr int64_t DEFAULT_MAX_CODES = INVALID_VALUE;
+
+// NSG Config
+constexpr int64_t DEFAULT_SEARCH_LENGTH = INVALID_VALUE;
+constexpr int64_t DEFAULT_OUT_DEGREE = INVALID_VALUE;
+constexpr int64_t DEFAULT_CANDIDATE_SISE = INVALID_VALUE;
+constexpr int64_t DEFAULT_NNG_K = INVALID_VALUE;
+
+struct IVFCfg : public Cfg {
+    int64_t nlist = DEFAULT_NLIST;
+    int64_t nprobe = DEFAULT_NPROBE;
+
+    IVFCfg(const int64_t& dim, const int64_t& k, const int64_t& gpu_id, const int64_t& nlist, const int64_t& nprobe,
+           METRICTYPE type)
+        : Cfg(dim, k, gpu_id, type), nlist(nlist), nprobe(nprobe) {
+    }
+
+    IVFCfg() = default;
+
+    bool
+    CheckValid() override {
+        return true;
+    };
+};
+using IVFConfig = std::shared_ptr<IVFCfg>;
+
+struct IVFSQCfg : public IVFCfg {
+    // TODO(linxj): cpu only support SQ4 SQ6 SQ8 SQ16, gpu only support SQ4, SQ8, SQ16
+    int64_t nbits = DEFAULT_NBITS;
+
+    IVFSQCfg(const int64_t& dim, const int64_t& k, const int64_t& gpu_id, const int64_t& nlist, const int64_t& nprobe,
+             const int64_t& nbits, METRICTYPE type)
+        : IVFCfg(dim, k, gpu_id, nlist, nprobe, type), nbits(nbits) {
+    }
+
+    IVFSQCfg() = default;
+
+    bool
+    CheckValid() override {
+        return true;
+    };
+};
+using IVFSQConfig = std::shared_ptr<IVFSQCfg>;
+
+struct IVFPQCfg : public IVFCfg {
+    int64_t m = DEFAULT_NSUBVECTORS;  // number of subquantizers(subvector)
+    int64_t nbits = DEFAULT_NBITS;    // number of bit per subvector index
+
+    // TODO(linxj): not use yet
+    int64_t scan_table_threhold = DEFAULT_SCAN_TABLE_THREHOLD;
+    int64_t polysemous_ht = DEFAULT_POLYSEMOUS_HT;
+    int64_t max_codes = DEFAULT_MAX_CODES;
+
+    IVFPQCfg(const int64_t& dim, const int64_t& k, const int64_t& gpu_id, const int64_t& nlist, const int64_t& nprobe,
+             const int64_t& nbits, const int64_t& m, METRICTYPE type)
+        : IVFCfg(dim, k, gpu_id, nlist, nprobe, type), m(m), nbits(nbits) {
+    }
+
+    IVFPQCfg() = default;
+
+    bool
+    CheckValid() override {
+        return true;
+    };
+};
+using IVFPQConfig = std::shared_ptr<IVFPQCfg>;
+
+struct NSGCfg : public IVFCfg {
+    int64_t knng = DEFAULT_NNG_K;
+    int64_t search_length = DEFAULT_SEARCH_LENGTH;
+    int64_t out_degree = DEFAULT_OUT_DEGREE;
+    int64_t candidate_pool_size = DEFAULT_CANDIDATE_SISE;
+
+    NSGCfg(const int64_t& dim, const int64_t& k, const int64_t& gpu_id, const int64_t& nlist, const int64_t& nprobe,
+           const int64_t& knng, const int64_t& search_length, const int64_t& out_degree, const int64_t& candidate_size,
+           METRICTYPE type)
+        : IVFCfg(dim, k, gpu_id, nlist, nprobe, type),
+          knng(knng),
+          search_length(search_length),
+          out_degree(out_degree),
+          candidate_pool_size(candidate_size) {
+    }
+
+    NSGCfg() = default;
+
+    bool
+    CheckValid() override {
+        return true;
+    };
+};
+using NSGConfig = std::shared_ptr<NSGCfg>;
+
+struct KDTCfg : public Cfg {
+    int64_t tptnubmber = -1;
+};
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/index/vector_index/helpers/KDTParameterMgr.cpp b/core/src/index/knowhere/knowhere/index/vector_index/helpers/KDTParameterMgr.cpp
new file mode 100644
index 0000000000..19bf070dba
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/index/vector_index/helpers/KDTParameterMgr.cpp
@@ -0,0 +1,55 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 <mutex>
+
+#include "knowhere/index/vector_index/helpers/KDTParameterMgr.h"
+
+namespace knowhere {
+
+const std::vector<KDTParameter>&
+KDTParameterMgr::GetKDTParameters() {
+    return kdt_parameters_;
+}
+
+KDTParameterMgr::KDTParameterMgr() {
+    kdt_parameters_ = std::vector<KDTParameter>{
+        {"KDTNumber", "1"},
+        {"NumTopDimensionKDTSplit", "5"},
+        {"NumSamplesKDTSplitConsideration", "100"},
+
+        {"TPTNumber", "1"},
+        {"TPTLeafSize", "2000"},
+        {"NumTopDimensionTPTSplit", "5"},
+
+        {"NeighborhoodSize", "32"},
+        {"GraphNeighborhoodScale", "2"},
+        {"GraphCEFScale", "2"},
+        {"RefineIterations", "0"},
+        {"CEF", "1000"},
+        {"MaxCheckForRefineGraph", "10000"},
+
+        {"NumberOfThreads", "1"},
+
+        {"MaxCheck", "8192"},
+        {"ThresholdOfNumberOfContinuousNoBetterPropagation", "3"},
+        {"NumberOfInitialDynamicPivots", "50"},
+        {"NumberOfOtherDynamicPivots", "4"},
+    };
+}
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/index/vector_index/helpers/KDTParameterMgr.h b/core/src/index/knowhere/knowhere/index/vector_index/helpers/KDTParameterMgr.h
new file mode 100644
index 0000000000..fe90761e17
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/index/vector_index/helpers/KDTParameterMgr.h
@@ -0,0 +1,52 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace knowhere {
+
+using KDTParameter = std::pair<std::string, std::string>;
+
+class KDTParameterMgr {
+ public:
+    const std::vector<KDTParameter>&
+    GetKDTParameters();
+
+ public:
+    static KDTParameterMgr&
+    GetInstance() {
+        static KDTParameterMgr instance;
+        return instance;
+    }
+
+    KDTParameterMgr(const KDTParameterMgr&) = delete;
+    KDTParameterMgr&
+    operator=(const KDTParameterMgr&) = delete;
+
+ private:
+    KDTParameterMgr();
+
+ private:
+    std::vector<KDTParameter> kdt_parameters_;
+};
+
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/index/vector_index/nsg/NSG.cpp b/core/src/index/knowhere/knowhere/index/vector_index/nsg/NSG.cpp
new file mode 100644
index 0000000000..bdf538c204
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/index/vector_index/nsg/NSG.cpp
@@ -0,0 +1,793 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 <algorithm>
+#include <cstdlib>
+#include <cstring>
+#include <fstream>
+#include <iostream>
+#include <stack>
+#include <utility>
+
+#include "knowhere/common/Exception.h"
+#include "knowhere/common/Log.h"
+#include "knowhere/common/Timer.h"
+#include "knowhere/index/vector_index/nsg/NSG.h"
+#include "knowhere/index/vector_index/nsg/NSGHelper.h"
+
+// TODO: enable macro
+//#include <gperftools/profiler.h>
+
+namespace knowhere {
+namespace algo {
+
+NsgIndex::NsgIndex(const size_t& dimension, const size_t& n, MetricType metric)
+    : dimension(dimension), ntotal(n), metric_type(metric) {
+}
+
+NsgIndex::~NsgIndex() {
+    delete[] ori_data_;
+    delete[] ids_;
+}
+
+// void NsgIndex::Build(size_t nb, const float *data, const BuildParam &parameters) {
+//}
+void
+NsgIndex::Build_with_ids(size_t nb, const float* data, const int64_t* ids, const BuildParams& parameters) {
+    TimeRecorder rc("NSG");
+
+    ntotal = nb;
+    ori_data_ = new float[ntotal * dimension];
+    ids_ = new int64_t[ntotal];
+    memcpy((void*)ori_data_, (void*)data, sizeof(float) * ntotal * dimension);
+    memcpy((void*)ids_, (void*)ids, sizeof(int64_t) * ntotal);
+
+    search_length = parameters.search_length;
+    out_degree = parameters.out_degree;
+    candidate_pool_size = parameters.candidate_pool_size;
+
+    InitNavigationPoint();
+    rc.RecordSection("init");
+
+    Link();
+    rc.RecordSection("Link");
+
+    //>> Debug code
+    /////
+    // int count = 0;
+    // for (int i = 0; i < ntotal; ++i) {
+    //    count += nsg[i].size();
+    //}
+    /////
+
+    CheckConnectivity();
+    rc.RecordSection("Connect");
+
+    //>> Debug code
+    ///
+    int total_degree = 0;
+    for (size_t i = 0; i < ntotal; ++i) {
+        total_degree += nsg[i].size();
+    }
+
+    KNOWHERE_LOG_DEBUG << "Graph physical size: " << total_degree * sizeof(node_t) / 1024 / 1024 << "m";
+    KNOWHERE_LOG_DEBUG << "Average degree: " << total_degree / ntotal;
+    /////
+
+    is_trained = true;
+}
+
+void
+NsgIndex::InitNavigationPoint() {
+    // calculate the center of vectors
+    auto center = new float[dimension];
+    memset(center, 0, sizeof(float) * dimension);
+
+    for (size_t i = 0; i < ntotal; i++) {
+        for (size_t j = 0; j < dimension; j++) {
+            center[j] += ori_data_[i * dimension + j];
+        }
+    }
+    for (size_t j = 0; j < dimension; j++) {
+        center[j] /= ntotal;
+    }
+
+    // select navigation point
+    std::vector<Neighbor> resset, fullset;
+    unsigned int seed = 100;
+    navigation_point = rand_r(&seed) % ntotal;  // random initialize navigating point
+
+    //>> Debug code
+    /////
+    // navigation_point = drand48();
+    /////
+
+    GetNeighbors(center, resset, knng);
+    navigation_point = resset[0].id;
+
+    //>> Debug code
+    /////
+    // std::cout << "ep: " << navigation_point << std::endl;
+    /////
+
+    //>> Debug code
+    /////
+    // float r1 = calculate(center, ori_data_ + navigation_point * dimension, dimension);
+    // assert(r1 == resset[0].distance);
+    /////
+}
+
+// Specify Link
+void
+NsgIndex::GetNeighbors(const float* query, std::vector<Neighbor>& resset, std::vector<Neighbor>& fullset,
+                       boost::dynamic_bitset<>& has_calculated_dist) {
+    auto& graph = knng;
+    size_t buffer_size = search_length;
+
+    if (buffer_size > ntotal) {
+        // TODO: throw exception here.
+    }
+
+    std::vector<node_t> init_ids;
+
+    {
+        /*
+         * copy navigation-point neighbor,  pick random node if less than buffer size
+         */
+        size_t count = 0;
+
+        // Get all neighbors
+        for (size_t i = 0; i < graph[navigation_point].size(); ++i) {
+            init_ids.push_back(graph[navigation_point][i]);
+            has_calculated_dist[init_ids[i]] = true;
+            ++count;
+        }
+
+        unsigned int seed = 100;
+        while (count < buffer_size) {
+            node_t id = rand_r(&seed) % ntotal;
+            if (has_calculated_dist[id])
+                continue;  // duplicate id
+            init_ids.push_back(id);
+            ++count;
+            has_calculated_dist[id] = true;
+        }
+    }
+
+    {
+        resset.resize(init_ids.size());
+
+        // init resset and sort by distance
+        for (size_t i = 0; i < init_ids.size(); ++i) {
+            node_t id = init_ids[i];
+
+            if (id >= static_cast<node_t>(ntotal)) {
+                KNOWHERE_THROW_MSG("Build Index Error, id > ntotal");
+                continue;
+            }
+
+            float dist = calculate(ori_data_ + dimension * id, query, dimension);
+            resset[i] = Neighbor(id, dist, false);
+
+            ///////////// difference from other GetNeighbors ///////////////
+            fullset.push_back(resset[i]);
+            ///////////////////////////////////////
+        }
+        std::sort(resset.begin(), resset.end());  // sort by distance
+
+        // search nearest neighbor
+        size_t cursor = 0;
+        while (cursor < buffer_size) {
+            size_t nearest_updated_pos = buffer_size;
+
+            if (!resset[cursor].has_explored) {
+                resset[cursor].has_explored = true;
+
+                node_t start_pos = resset[cursor].id;
+                auto& wait_for_search_node_vec = graph[start_pos];
+                for (size_t i = 0; i < wait_for_search_node_vec.size(); ++i) {
+                    node_t id = wait_for_search_node_vec[i];
+                    if (has_calculated_dist[id])
+                        continue;
+                    has_calculated_dist[id] = true;
+
+                    float dist = calculate(query, ori_data_ + dimension * id, dimension);
+                    Neighbor nn(id, dist, false);
+                    fullset.push_back(nn);
+
+                    if (dist >= resset[buffer_size - 1].distance)
+                        continue;
+
+                    size_t pos = InsertIntoPool(resset.data(), buffer_size, nn);  // replace with a closer node
+                    if (pos < nearest_updated_pos)
+                        nearest_updated_pos = pos;
+
+                    // assert(buffer_size + 1 >= resset.size());
+                    if (buffer_size + 1 < resset.size())
+                        ++buffer_size;
+                }
+            }
+            if (cursor >= nearest_updated_pos) {
+                cursor = nearest_updated_pos;  // re-search from new pos
+            } else {
+                ++cursor;
+            }
+        }
+    }
+}
+
+// FindUnconnectedNode
+void
+NsgIndex::GetNeighbors(const float* query, std::vector<Neighbor>& resset, std::vector<Neighbor>& fullset) {
+    auto& graph = nsg;
+    size_t buffer_size = search_length;
+
+    if (buffer_size > ntotal) {
+        // TODO: throw exception here.
+    }
+
+    std::vector<node_t> init_ids;
+    boost::dynamic_bitset<> has_calculated_dist{ntotal, 0};  // TODO: ?
+
+    {
+        /*
+         * copy navigation-point neighbor,  pick random node if less than buffer size
+         */
+        size_t count = 0;
+
+        // Get all neighbors
+        for (size_t i = 0; i < graph[navigation_point].size(); ++i) {
+            init_ids.push_back(graph[navigation_point][i]);
+            has_calculated_dist[init_ids[i]] = true;
+            ++count;
+        }
+        unsigned int seed = 100;
+        while (count < buffer_size) {
+            node_t id = rand_r(&seed) % ntotal;
+            if (has_calculated_dist[id])
+                continue;  // duplicate id
+            init_ids.push_back(id);
+            ++count;
+            has_calculated_dist[id] = true;
+        }
+    }
+
+    {
+        resset.resize(init_ids.size());
+
+        // init resset and sort by distance
+        for (size_t i = 0; i < init_ids.size(); ++i) {
+            node_t id = init_ids[i];
+
+            if (id >= static_cast<node_t>(ntotal)) {
+                KNOWHERE_THROW_MSG("Build Index Error, id > ntotal");
+                continue;
+            }
+
+            float dist = calculate(ori_data_ + id * dimension, query, dimension);
+            resset[i] = Neighbor(id, dist, false);
+        }
+        std::sort(resset.begin(), resset.end());  // sort by distance
+
+        // search nearest neighbor
+        size_t cursor = 0;
+        while (cursor < buffer_size) {
+            size_t nearest_updated_pos = buffer_size;
+
+            if (!resset[cursor].has_explored) {
+                resset[cursor].has_explored = true;
+
+                node_t start_pos = resset[cursor].id;
+                auto& wait_for_search_node_vec = graph[start_pos];
+                for (size_t i = 0; i < wait_for_search_node_vec.size(); ++i) {
+                    node_t id = wait_for_search_node_vec[i];
+                    if (has_calculated_dist[id])
+                        continue;
+                    has_calculated_dist[id] = true;
+
+                    float dist = calculate(ori_data_ + dimension * id, query, dimension);
+                    Neighbor nn(id, dist, false);
+                    fullset.push_back(nn);
+
+                    if (dist >= resset[buffer_size - 1].distance)
+                        continue;
+
+                    size_t pos = InsertIntoPool(resset.data(), buffer_size, nn);  // replace with a closer node
+                    if (pos < nearest_updated_pos)
+                        nearest_updated_pos = pos;
+
+                    // assert(buffer_size + 1 >= resset.size());
+                    if (buffer_size + 1 < resset.size())
+                        ++buffer_size;  // trick
+                }
+            }
+            if (cursor >= nearest_updated_pos) {
+                cursor = nearest_updated_pos;  // re-search from new pos
+            } else {
+                ++cursor;
+            }
+        }
+    }
+}
+
+void
+NsgIndex::GetNeighbors(const float* query, std::vector<Neighbor>& resset, Graph& graph, SearchParams* params) {
+    size_t& buffer_size = params ? params->search_length : search_length;
+
+    if (buffer_size > ntotal) {
+        // TODO: throw exception here.
+    }
+
+    std::vector<node_t> init_ids;
+    boost::dynamic_bitset<> has_calculated_dist{ntotal, 0};
+
+    {
+        /*
+         * copy navigation-point neighbor,  pick random node if less than buffer size
+         */
+        size_t count = 0;
+
+        // Get all neighbors
+        for (size_t i = 0; i < graph[navigation_point].size(); ++i) {
+            init_ids.push_back(graph[navigation_point][i]);
+            has_calculated_dist[init_ids[i]] = true;
+            ++count;
+        }
+        unsigned int seed = 100;
+        while (count < buffer_size) {
+            node_t id = rand_r(&seed) % ntotal;
+            if (has_calculated_dist[id])
+                continue;  // duplicate id
+            init_ids.push_back(id);
+            ++count;
+            has_calculated_dist[id] = true;
+        }
+    }
+
+    {
+        resset.resize(init_ids.size());
+
+        // init resset and sort by distance
+        for (size_t i = 0; i < init_ids.size(); ++i) {
+            node_t id = init_ids[i];
+
+            // assert(id < ntotal);
+            if (id >= static_cast<node_t>(ntotal)) {
+                KNOWHERE_THROW_MSG("Build Index Error, id > ntotal");
+                continue;
+            }
+
+            float dist = calculate(ori_data_ + id * dimension, query, dimension);
+            resset[i] = Neighbor(id, dist, false);
+        }
+        std::sort(resset.begin(), resset.end());  // sort by distance
+
+        //>> Debug code
+        /////
+        // for (int j = 0; j < buffer_size; ++j) {
+        //    std::cout << "resset_id: " << resset[j].id << ", resset_dist: " << resset[j].distance << std::endl;
+        //}
+        /////
+
+        // search nearest neighbor
+        size_t cursor = 0;
+        while (cursor < buffer_size) {
+            size_t nearest_updated_pos = buffer_size;
+
+            if (!resset[cursor].has_explored) {
+                resset[cursor].has_explored = true;
+
+                node_t start_pos = resset[cursor].id;
+                auto& wait_for_search_node_vec = graph[start_pos];
+                for (size_t i = 0; i < wait_for_search_node_vec.size(); ++i) {
+                    node_t id = wait_for_search_node_vec[i];
+                    if (has_calculated_dist[id])
+                        continue;
+                    has_calculated_dist[id] = true;
+
+                    float dist = calculate(query, ori_data_ + dimension * id, dimension);
+
+                    if (dist >= resset[buffer_size - 1].distance)
+                        continue;
+                    ///////////// difference from other GetNeighbors ///////////////
+                    Neighbor nn(id, dist, false);
+                    ///////////////////////////////////////
+
+                    size_t pos = InsertIntoPool(resset.data(), buffer_size, nn);  // replace with a closer node
+                    if (pos < nearest_updated_pos)
+                        nearest_updated_pos = pos;
+
+                    //>> Debug code
+                    /////
+                    // std::cout << "pos: " << pos << ", nn: " << nn.id << ":" << nn.distance << ", nup: " <<
+                    // nearest_updated_pos << std::endl;
+                    /////
+
+                    // trick: avoid search query search_length < init_ids.size() ...
+                    if (buffer_size + 1 < resset.size())
+                        ++buffer_size;
+                }
+            }
+            if (cursor >= nearest_updated_pos) {
+                cursor = nearest_updated_pos;  // re-search from new pos
+            } else {
+                ++cursor;
+            }
+        }
+    }
+}
+
+void
+NsgIndex::Link() {
+    auto cut_graph_dist = new float[ntotal * out_degree];
+    nsg.resize(ntotal);
+
+#pragma omp parallel
+    {
+        std::vector<Neighbor> fullset;
+        std::vector<Neighbor> temp;
+        boost::dynamic_bitset<> flags{ntotal, 0};  // TODO: ?
+#pragma omp for schedule(dynamic, 100)
+        for (size_t n = 0; n < ntotal; ++n) {
+            fullset.clear();
+            flags.reset();
+            GetNeighbors(ori_data_ + dimension * n, temp, fullset, flags);
+
+            //>> Debug code
+            /////
+            // float r1 = calculate(ori_data_ + n * dimension, ori_data_ + temp[0].id * dimension, dimension);
+            // assert(r1 == temp[0].distance);
+            /////
+            SyncPrune(n, fullset, flags, cut_graph_dist);
+        }
+    }
+
+    //>> Debug code
+    /////
+    // auto bak_nsg = nsg;
+    /////
+
+    knng.clear();
+    knng.shrink_to_fit();
+
+    std::vector<std::mutex> mutex_vec(ntotal);
+
+#pragma omp for schedule(dynamic, 100)
+    for (unsigned n = 0; n < ntotal; ++n) {
+        InterInsert(n, mutex_vec, cut_graph_dist);
+    }
+    delete[] cut_graph_dist;
+
+    //>> Debug code
+    /////
+    // int count = 0;
+    // for (int i = 0; i < ntotal; ++i) {
+    //    if (bak_nsg[i].size() != nsg[i].size()) {
+    //        //count += nsg[i].size() - bak_nsg[i].size();
+    //        count += nsg[i].size();
+    //    }
+    //}
+    /////
+
+    for (size_t i = 0; i < ntotal; ++i) {
+        nsg[i].shrink_to_fit();
+    }
+}
+
+void
+NsgIndex::SyncPrune(size_t n, std::vector<Neighbor>& pool, boost::dynamic_bitset<>& has_calculated,
+                    float* cut_graph_dist) {
+    // avoid lose nearest neighbor in knng
+    for (size_t i = 0; i < knng[n].size(); ++i) {
+        auto id = knng[n][i];
+        if (has_calculated[id])
+            continue;
+        float dist = calculate(ori_data_ + dimension * n, ori_data_ + dimension * id, dimension);
+        pool.emplace_back(Neighbor(id, dist, true));
+    }
+
+    // sort and find closest node
+    unsigned cursor = 0;
+    std::sort(pool.begin(), pool.end());
+    std::vector<Neighbor> result;
+    if (pool[cursor].id == static_cast<node_t>(n)) {
+        cursor++;
+    }
+    result.push_back(pool[cursor]);  // init result with nearest neighbor
+
+    SelectEdge(cursor, pool, result, true);
+
+    // filling the cut_graph
+    auto& des_id_pool = nsg[n];
+    float* des_dist_pool = cut_graph_dist + n * out_degree;
+    for (size_t i = 0; i < result.size(); ++i) {
+        des_id_pool.push_back(result[i].id);
+        des_dist_pool[i] = result[i].distance;
+    }
+    if (result.size() < out_degree) {
+        des_dist_pool[result.size()] = -1;
+    }
+    //>> Optimize: reserve id_pool capacity
+}
+
+//>> Optimize: remove read-lock
+void
+NsgIndex::InterInsert(unsigned n, std::vector<std::mutex>& mutex_vec, float* cut_graph_dist) {
+    auto& current = n;
+
+    auto& neighbor_id_pool = nsg[current];
+    float* neighbor_dist_pool = cut_graph_dist + current * out_degree;
+    for (size_t i = 0; i < out_degree; ++i) {
+        if (neighbor_dist_pool[i] == -1)
+            break;
+
+        size_t current_neighbor = neighbor_id_pool[i];  // center's neighbor id
+        auto& nsn_id_pool = nsg[current_neighbor];      // nsn => neighbor's neighbor
+        float* nsn_dist_pool = cut_graph_dist + current_neighbor * out_degree;
+
+        std::vector<Neighbor> wait_for_link_pool;  // maintain candidate neighbor of the current neighbor.
+        int duplicate = false;
+        {
+            LockGuard lk(mutex_vec[current_neighbor]);
+            for (size_t j = 0; j < out_degree; ++j) {
+                if (nsn_dist_pool[j] == -1)
+                    break;
+
+                // 保证至少有一条边能连回来
+                if (n == nsn_id_pool[j]) {
+                    duplicate = true;
+                    break;
+                }
+
+                Neighbor nsn(nsn_id_pool[j], nsn_dist_pool[j]);
+                wait_for_link_pool.push_back(nsn);
+            }
+        }
+        if (duplicate)
+            continue;
+
+        // original: (neighbor) <------- (current)
+        // after:    (neighbor) -------> (current)
+        // current node as a neighbor of its neighbor
+        Neighbor current_as_neighbor(n, neighbor_dist_pool[i]);
+        wait_for_link_pool.push_back(current_as_neighbor);
+
+        // re-selectEdge if candidate neighbor num > out_degree
+        if (wait_for_link_pool.size() > out_degree) {
+            std::vector<Neighbor> result;
+
+            unsigned start = 0;
+            std::sort(wait_for_link_pool.begin(), wait_for_link_pool.end());
+            result.push_back(wait_for_link_pool[start]);
+
+            SelectEdge(start, wait_for_link_pool, result);
+
+            {
+                LockGuard lk(mutex_vec[current_neighbor]);
+                for (size_t j = 0; j < result.size(); ++j) {
+                    nsn_id_pool[j] = result[j].id;
+                    nsn_dist_pool[j] = result[j].distance;
+                }
+            }
+        } else {
+            LockGuard lk(mutex_vec[current_neighbor]);
+            for (size_t j = 0; j < out_degree; ++j) {
+                if (nsn_dist_pool[j] == -1) {
+                    nsn_id_pool.push_back(current_as_neighbor.id);
+                    nsn_dist_pool[j] = current_as_neighbor.distance;
+                    if (j + 1 < out_degree)
+                        nsn_dist_pool[j + 1] = -1;
+                    break;
+                }
+            }
+        }
+    }
+}
+
+void
+NsgIndex::SelectEdge(unsigned& cursor, std::vector<Neighbor>& sort_pool, std::vector<Neighbor>& result, bool limit) {
+    auto& pool = sort_pool;
+
+    /*
+     * edge selection
+     *
+     * search in pool and search deepth is under candidate_pool_size
+     * max result size equal to out_degress
+     */
+    size_t search_deepth = limit ? candidate_pool_size : pool.size();
+    while (result.size() < out_degree && cursor < search_deepth && (++cursor) < pool.size()) {
+        auto& p = pool[cursor];
+        bool should_link = true;
+        for (size_t t = 0; t < result.size(); ++t) {
+            float dist = calculate(ori_data_ + dimension * result[t].id, ori_data_ + dimension * p.id, dimension);
+
+            if (dist < p.distance) {
+                should_link = false;
+                break;
+            }
+        }
+        if (should_link)
+            result.push_back(p);
+    }
+}
+
+void
+NsgIndex::CheckConnectivity() {
+    auto root = navigation_point;
+    boost::dynamic_bitset<> has_linked{ntotal, 0};
+    int64_t linked_count = 0;
+
+    while (linked_count < static_cast<int64_t>(ntotal)) {
+        DFS(root, has_linked, linked_count);
+        if (linked_count >= static_cast<int64_t>(ntotal)) {
+            break;
+        }
+        FindUnconnectedNode(has_linked, root);
+    }
+}
+
+void
+NsgIndex::DFS(size_t root, boost::dynamic_bitset<>& has_linked, int64_t& linked_count) {
+    size_t start = root;
+    std::stack<size_t> s;
+    s.push(root);
+    if (!has_linked[root]) {
+        linked_count++;           // not link
+        has_linked[root] = true;  // link start...
+    }
+
+    while (!s.empty()) {
+        size_t next = ntotal + 1;
+
+        for (unsigned i = 0; i < nsg[start].size(); i++) {
+            if (has_linked[nsg[start][i]] == false) {  // if not link
+                next = nsg[start][i];
+                break;
+            }
+        }
+        if (next == (ntotal + 1)) {
+            s.pop();
+            if (s.empty())
+                break;
+            start = s.top();
+            continue;
+        }
+        start = next;
+        has_linked[start] = true;
+        s.push(start);
+        ++linked_count;
+    }
+}
+
+void
+NsgIndex::FindUnconnectedNode(boost::dynamic_bitset<>& has_linked, int64_t& root) {
+    // find any of unlinked-node
+    size_t id = ntotal;
+    for (size_t i = 0; i < ntotal; i++) {  // find not link
+        if (has_linked[i] == false) {
+            id = i;
+            break;
+        }
+    }
+
+    if (id == ntotal)
+        return;  // No Unlinked Node
+
+    // search unlinked-node's neighbor
+    std::vector<Neighbor> tmp, pool;
+    GetNeighbors(ori_data_ + dimension * id, tmp, pool);
+    std::sort(pool.begin(), pool.end());
+
+    size_t found = 0;
+    for (size_t i = 0; i < pool.size(); i++) {  // find nearest neighbor and add unlinked-node as its neighbor
+        if (has_linked[pool[i].id]) {
+            root = pool[i].id;
+            found = 1;
+            break;
+        }
+    }
+    if (found == 0) {
+        unsigned int seed = 100;
+        while (true) {  // random a linked-node and add unlinked-node as its neighbor
+            size_t rid = rand_r(&seed) % ntotal;
+            if (has_linked[rid]) {
+                root = rid;
+                break;
+            }
+        }
+    }
+    nsg[root].push_back(id);
+}
+
+void
+NsgIndex::Search(const float* query, const unsigned& nq, const unsigned& dim, const unsigned& k, float* dist,
+                 int64_t* ids, SearchParams& params) {
+    std::vector<std::vector<Neighbor>> resset(nq);
+
+    TimeRecorder rc("search");
+    if (nq == 1) {
+        GetNeighbors(query, resset[0], nsg, &params);
+    } else {
+//#pragma omp parallel for schedule(dynamic, 50)
+#pragma omp parallel for
+        for (unsigned int i = 0; i < nq; ++i) {
+            // TODO(linxj): when to use openmp
+            auto single_query = query + i * dim;
+            GetNeighbors(single_query, resset[i], nsg, &params);
+        }
+    }
+    rc.ElapseFromBegin("cost");
+
+    for (unsigned int i = 0; i < nq; ++i) {
+        for (unsigned int j = 0; j < k; ++j) {
+            // ids[i * k + j] = resset[i][j].id;
+
+            // Fix(linxj): bug, reset[i][j] out of range
+            ids[i * k + j] = ids_[resset[i][j].id];
+            dist[i * k + j] = resset[i][j].distance;
+        }
+    }
+
+    //>> Debug: test single insert
+    // int x_0 = resset[0].size();
+    // for (int l = 0; l < resset[0].size(); ++l) {
+    //    resset[0].pop_back();
+    //}
+    // resset.clear();
+
+    // ProfilerStart("xx.prof");
+    // std::vector<Neighbor> resset;
+    // GetNeighbors(query, resset, nsg, &params);
+    // for (int i = 0; i < k; ++i) {
+    //    ids[i] = resset[i].id;
+    // dist[i] = resset[i].distance;
+    //}
+    // ProfilerStop();
+}
+
+void
+NsgIndex::SetKnnGraph(Graph& g) {
+    knng = std::move(g);
+}
+
+// void NsgIndex::GetKnnGraphFromFile() {
+//    //std::string filename = "sift.1M.50NN.graph";
+//    std::string filename = "sift.50NN.graph";
+//
+//    std::ifstream in(filename, std::ios::binary);
+//    unsigned k;
+//    in.read((char *) &k, sizeof(unsigned));
+//    in.seekg(0, std::ios::end);
+//    std::ios::pos_type ss = in.tellg();
+//    size_t fsize = (size_t) ss;
+//    size_t num = (unsigned) (fsize / (k + 1) / 4);
+//    in.seekg(0, std::ios::beg);
+//
+//    knng.resize(num);
+//    knng.reserve(num);
+//    unsigned kk = (k + 3) / 4 * 4;
+//    for (size_t i = 0; i < num; i++) {
+//        in.seekg(4, std::ios::cur);
+//        knng[i].resize(k);
+//        knng[i].reserve(kk);
+//        in.read((char *) knng[i].data(), k * sizeof(unsigned));
+//    }
+//    in.close();
+//}
+
+}  // namespace algo
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/index/vector_index/nsg/NSG.h b/core/src/index/knowhere/knowhere/index/vector_index/nsg/NSG.h
new file mode 100644
index 0000000000..160c076e45
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/index/vector_index/nsg/NSG.h
@@ -0,0 +1,144 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <cstddef>
+#include <mutex>
+#include <vector>
+
+#include <boost/dynamic_bitset.hpp>
+#include "Neighbor.h"
+
+namespace knowhere {
+namespace algo {
+
+using node_t = int64_t;
+
+enum class MetricType {
+    METRIC_INNER_PRODUCT = 0,
+    METRIC_L2 = 1,
+};
+
+struct BuildParams {
+    size_t search_length;
+    size_t out_degree;
+    size_t candidate_pool_size;
+};
+
+struct SearchParams {
+    size_t search_length;
+};
+
+using Graph = std::vector<std::vector<node_t>>;
+
+class NsgIndex {
+ public:
+    size_t dimension;
+    size_t ntotal;           // totabl nb of indexed vectors
+    MetricType metric_type;  // L2 | IP
+
+    float* ori_data_;
+    int64_t* ids_;  // TODO: support different type
+    Graph nsg;      // final graph
+    Graph knng;     // reset after build
+
+    node_t navigation_point;  // offset of node in origin data
+
+    bool is_trained = false;
+
+    /*
+     * build and search parameter
+     */
+    size_t search_length;
+    size_t candidate_pool_size;  // search deepth in fullset
+    size_t out_degree;
+
+ public:
+    explicit NsgIndex(const size_t& dimension, const size_t& n, MetricType metric = MetricType::METRIC_L2);
+
+    NsgIndex() = default;
+
+    virtual ~NsgIndex();
+
+    void
+    SetKnnGraph(Graph& knng);
+
+    virtual void
+    Build_with_ids(size_t nb, const float* data, const int64_t* ids, const BuildParams& parameters);
+
+    void
+    Search(const float* query, const unsigned& nq, const unsigned& dim, const unsigned& k, float* dist, int64_t* ids,
+           SearchParams& params);
+
+    // Not support yet.
+    // virtual void Add() = 0;
+    // virtual void Add_with_ids() = 0;
+    // virtual void Delete() = 0;
+    // virtual void Delete_with_ids() = 0;
+    // virtual void Rebuild(size_t nb,
+    //                     const float *data,
+    //                     const int64_t *ids,
+    //                     const Parameters &parameters) = 0;
+    // virtual void Build(size_t nb,
+    //                   const float *data,
+    //                   const BuildParam &parameters);
+
+ protected:
+    virtual void
+    InitNavigationPoint();
+
+    // link specify
+    void
+    GetNeighbors(const float* query, std::vector<Neighbor>& resset, std::vector<Neighbor>& fullset,
+                 boost::dynamic_bitset<>& has_calculated_dist);
+
+    // FindUnconnectedNode
+    void
+    GetNeighbors(const float* query, std::vector<Neighbor>& resset, std::vector<Neighbor>& fullset);
+
+    // search and navigation-point
+    void
+    GetNeighbors(const float* query, std::vector<Neighbor>& resset, Graph& graph, SearchParams* param = nullptr);
+
+    void
+    Link();
+
+    void
+    SyncPrune(size_t q, std::vector<Neighbor>& pool, boost::dynamic_bitset<>& has_calculated, float* cut_graph_dist);
+
+    void
+    SelectEdge(unsigned& cursor, std::vector<Neighbor>& sort_pool, std::vector<Neighbor>& result, bool limit = false);
+
+    void
+    InterInsert(unsigned n, std::vector<std::mutex>& mutex_vec, float* dist);
+
+    void
+    CheckConnectivity();
+
+    void
+    DFS(size_t root, boost::dynamic_bitset<>& flags, int64_t& count);
+
+    void
+    FindUnconnectedNode(boost::dynamic_bitset<>& flags, int64_t& root);
+
+    // private:
+    //   void GetKnnGraphFromFile();
+};
+
+}  // namespace algo
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/index/vector_index/nsg/NSGHelper.cpp b/core/src/index/knowhere/knowhere/index/vector_index/nsg/NSGHelper.cpp
new file mode 100644
index 0000000000..05e8d18787
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/index/vector_index/nsg/NSGHelper.cpp
@@ -0,0 +1,181 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 <cstring>
+#include <fstream>
+
+#include "knowhere/index/vector_index/nsg/NSGHelper.h"
+
+namespace knowhere {
+namespace algo {
+
+// TODO: impl search && insert && return insert pos. why not just find and swap?
+int
+InsertIntoPool(Neighbor* addr, unsigned K, Neighbor nn) {
+    //>> Fix: Add assert
+    for (unsigned int i = 0; i < K; ++i) {
+        assert(addr[i].id != nn.id);
+    }
+
+    // find the location to insert
+    int left = 0, right = K - 1;
+    if (addr[left].distance > nn.distance) {
+        //>> Fix: memmove overflow, dump when vector<Neighbor> deconstruct
+        memmove((char*)&addr[left + 1], &addr[left], (K - 1) * sizeof(Neighbor));
+        addr[left] = nn;
+        return left;
+    }
+    if (addr[right].distance < nn.distance) {
+        addr[K] = nn;
+        return K;
+    }
+    while (left < right - 1) {
+        int mid = (left + right) / 2;
+        if (addr[mid].distance > nn.distance)
+            right = mid;
+        else
+            left = mid;
+    }
+    // check equal ID
+
+    while (left > 0) {
+        if (addr[left].distance < nn.distance)  // pos is right
+            break;
+        if (addr[left].id == nn.id)
+            return K + 1;
+        left--;
+    }
+    if (addr[left].id == nn.id || addr[right].id == nn.id)
+        return K + 1;
+
+    //>> Fix: memmove overflow, dump when vector<Neighbor> deconstruct
+    memmove((char*)&addr[right + 1], &addr[right], (K - 1 - right) * sizeof(Neighbor));
+    addr[right] = nn;
+    return right;
+}
+
+// TODO: support L2 / IP
+float
+calculate(const float* a, const float* b, unsigned size) {
+    float result = 0;
+
+#ifdef __GNUC__
+#ifdef __AVX__
+
+#define AVX_L2SQR(addr1, addr2, dest, tmp1, tmp2) \
+    tmp1 = _mm256_loadu_ps(addr1);                \
+    tmp2 = _mm256_loadu_ps(addr2);                \
+    tmp1 = _mm256_sub_ps(tmp1, tmp2);             \
+    tmp1 = _mm256_mul_ps(tmp1, tmp1);             \
+    dest = _mm256_add_ps(dest, tmp1);
+
+    __m256 sum;
+    __m256 l0, l1;
+    __m256 r0, r1;
+    unsigned D = (size + 7) & ~7U;
+    unsigned DR = D % 16;
+    unsigned DD = D - DR;
+    const float* l = a;
+    const float* r = b;
+    const float* e_l = l + DD;
+    const float* e_r = r + DD;
+    float unpack[8] __attribute__((aligned(32))) = {0, 0, 0, 0, 0, 0, 0, 0};
+
+    sum = _mm256_loadu_ps(unpack);
+    if (DR) {
+        AVX_L2SQR(e_l, e_r, sum, l0, r0);
+    }
+
+    for (unsigned i = 0; i < DD; i += 16, l += 16, r += 16) {
+        AVX_L2SQR(l, r, sum, l0, r0);
+        AVX_L2SQR(l + 8, r + 8, sum, l1, r1);
+    }
+    _mm256_storeu_ps(unpack, sum);
+    result = unpack[0] + unpack[1] + unpack[2] + unpack[3] + unpack[4] + unpack[5] + unpack[6] + unpack[7];
+
+#else
+#ifdef __SSE2__
+#define SSE_L2SQR(addr1, addr2, dest, tmp1, tmp2) \
+    tmp1 = _mm_load_ps(addr1);                    \
+    tmp2 = _mm_load_ps(addr2);                    \
+    tmp1 = _mm_sub_ps(tmp1, tmp2);                \
+    tmp1 = _mm_mul_ps(tmp1, tmp1);                \
+    dest = _mm_add_ps(dest, tmp1);
+
+    __m128 sum;
+    __m128 l0, l1, l2, l3;
+    __m128 r0, r1, r2, r3;
+    unsigned D = (size + 3) & ~3U;
+    unsigned DR = D % 16;
+    unsigned DD = D - DR;
+    const float* l = a;
+    const float* r = b;
+    const float* e_l = l + DD;
+    const float* e_r = r + DD;
+    float unpack[4] __attribute__((aligned(16))) = {0, 0, 0, 0};
+
+    sum = _mm_load_ps(unpack);
+    switch (DR) {
+        case 12:
+            SSE_L2SQR(e_l + 8, e_r + 8, sum, l2, r2);
+        case 8:
+            SSE_L2SQR(e_l + 4, e_r + 4, sum, l1, r1);
+        case 4:
+            SSE_L2SQR(e_l, e_r, sum, l0, r0);
+        default:
+            break;
+    }
+    for (unsigned i = 0; i < DD; i += 16, l += 16, r += 16) {
+        SSE_L2SQR(l, r, sum, l0, r0);
+        SSE_L2SQR(l + 4, r + 4, sum, l1, r1);
+        SSE_L2SQR(l + 8, r + 8, sum, l2, r2);
+        SSE_L2SQR(l + 12, r + 12, sum, l3, r3);
+    }
+    _mm_storeu_ps(unpack, sum);
+    result += unpack[0] + unpack[1] + unpack[2] + unpack[3];
+
+// nomal distance
+#else
+
+    float diff0, diff1, diff2, diff3;
+    const float* last = a + size;
+    const float* unroll_group = last - 3;
+
+    /* Process 4 items with each loop for efficiency. */
+    while (a < unroll_group) {
+        diff0 = a[0] - b[0];
+        diff1 = a[1] - b[1];
+        diff2 = a[2] - b[2];
+        diff3 = a[3] - b[3];
+        result += diff0 * diff0 + diff1 * diff1 + diff2 * diff2 + diff3 * diff3;
+        a += 4;
+        b += 4;
+    }
+    /* Process last 0-3 pixels.  Not needed for standard vector lengths. */
+    while (a < last) {
+        diff0 = *a++ - *b++;
+        result += diff0 * diff0;
+    }
+#endif
+#endif
+#endif
+
+    return result;
+}
+
+}  // namespace algo
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/index/vector_index/nsg/NSGHelper.h b/core/src/index/knowhere/knowhere/index/vector_index/nsg/NSGHelper.h
new file mode 100644
index 0000000000..5007cf019c
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/index/vector_index/nsg/NSGHelper.h
@@ -0,0 +1,37 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <x86intrin.h>
+#include <iostream>
+
+#include <faiss/AutoTune.h>
+
+#include "NSG.h"
+#include "knowhere/common/Config.h"
+
+namespace knowhere {
+namespace algo {
+
+extern int
+InsertIntoPool(Neighbor* addr, unsigned K, Neighbor nn);
+extern float
+calculate(const float* a, const float* b, unsigned size);
+
+}  // namespace algo
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/index/vector_index/nsg/NSGIO.cpp b/core/src/index/knowhere/knowhere/index/vector_index/nsg/NSGIO.cpp
new file mode 100644
index 0000000000..cac3b5864f
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/index/vector_index/nsg/NSGIO.cpp
@@ -0,0 +1,69 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 <cstring>
+
+#include "knowhere/index/vector_index/nsg/NSGIO.h"
+
+namespace knowhere {
+namespace algo {
+
+void
+write_index(NsgIndex* index, MemoryIOWriter& writer) {
+    writer(&index->ntotal, sizeof(index->ntotal), 1);
+    writer(&index->dimension, sizeof(index->dimension), 1);
+    writer(&index->navigation_point, sizeof(index->navigation_point), 1);
+    writer(index->ori_data_, sizeof(float) * index->ntotal * index->dimension, 1);
+    writer(index->ids_, sizeof(int64_t) * index->ntotal, 1);
+
+    for (unsigned i = 0; i < index->ntotal; ++i) {
+        auto neighbor_num = (node_t)index->nsg[i].size();
+        writer(&neighbor_num, sizeof(node_t), 1);
+        writer(index->nsg[i].data(), neighbor_num * sizeof(node_t), 1);
+    }
+}
+
+NsgIndex*
+read_index(MemoryIOReader& reader) {
+    size_t ntotal;
+    size_t dimension;
+    reader(&ntotal, sizeof(size_t), 1);
+    reader(&dimension, sizeof(size_t), 1);
+    auto index = new NsgIndex(dimension, ntotal);
+    reader(&index->navigation_point, sizeof(index->navigation_point), 1);
+
+    index->ori_data_ = new float[index->ntotal * index->dimension];
+    index->ids_ = new int64_t[index->ntotal];
+    reader(index->ori_data_, sizeof(float) * index->ntotal * index->dimension, 1);
+    reader(index->ids_, sizeof(int64_t) * index->ntotal, 1);
+
+    index->nsg.reserve(index->ntotal);
+    index->nsg.resize(index->ntotal);
+    node_t neighbor_num;
+    for (unsigned i = 0; i < index->ntotal; ++i) {
+        reader(&neighbor_num, sizeof(node_t), 1);
+        index->nsg[i].reserve(neighbor_num);
+        index->nsg[i].resize(neighbor_num);
+        reader(index->nsg[i].data(), neighbor_num * sizeof(node_t), 1);
+    }
+
+    index->is_trained = true;
+    return index;
+}
+
+}  // namespace algo
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/index/vector_index/nsg/NSGIO.h b/core/src/index/knowhere/knowhere/index/vector_index/nsg/NSGIO.h
new file mode 100644
index 0000000000..12913b69df
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/index/vector_index/nsg/NSGIO.h
@@ -0,0 +1,33 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "NSG.h"
+#include "knowhere/index/vector_index/IndexIVF.h"
+#include "knowhere/index/vector_index/helpers/FaissIO.h"
+
+namespace knowhere {
+namespace algo {
+
+extern void
+write_index(NsgIndex* index, MemoryIOWriter& writer);
+extern NsgIndex*
+read_index(MemoryIOReader& reader);
+
+}  // namespace algo
+}  // namespace knowhere
diff --git a/core/src/index/knowhere/knowhere/index/vector_index/nsg/Neighbor.h b/core/src/index/knowhere/knowhere/index/vector_index/nsg/Neighbor.h
new file mode 100644
index 0000000000..c3a314164c
--- /dev/null
+++ b/core/src/index/knowhere/knowhere/index/vector_index/nsg/Neighbor.h
@@ -0,0 +1,62 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <mutex>
+
+namespace knowhere {
+namespace algo {
+
+using node_t = int64_t;
+
+// TODO: search use simple neighbor
+struct Neighbor {
+    node_t id;  // offset of node in origin data
+    float distance;
+    bool has_explored;
+
+    Neighbor() = default;
+
+    explicit Neighbor(node_t id, float distance, bool f) : id{id}, distance{distance}, has_explored(f) {
+    }
+
+    explicit Neighbor(node_t id, float distance) : id{id}, distance{distance}, has_explored(false) {
+    }
+
+    inline bool
+    operator<(const Neighbor& other) const {
+        return distance < other.distance;
+    }
+};
+
+// struct SimpleNeighbor {
+//    node_t id; // offset of node in origin data
+//    float distance;
+//
+//    SimpleNeighbor() = default;
+//    explicit SimpleNeighbor(node_t id, float distance) : id{id}, distance{distance}{}
+//
+//    inline bool operator<(const Neighbor &other) const {
+//        return distance < other.distance;
+//    }
+//};
+
+typedef std::lock_guard<std::mutex> LockGuard;
+
+}  // namespace algo
+}  // namespace knowhere
diff --git a/core/src/index/thirdparty/SPTAG/.github/ISSUE_TEMPLATE/bug_report.md b/core/src/index/thirdparty/SPTAG/.github/ISSUE_TEMPLATE/bug_report.md
new file mode 100644
index 0000000000..b735373365
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/.github/ISSUE_TEMPLATE/bug_report.md
@@ -0,0 +1,35 @@
+---
+name: Bug report
+about: Create a report to help us improve
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Desktop (please complete the following information):**
+ - OS: [e.g. iOS]
+ - Browser [e.g. chrome, safari]
+ - Version [e.g. 22]
+
+**Smartphone (please complete the following information):**
+ - Device: [e.g. iPhone6]
+ - OS: [e.g. iOS8.1]
+ - Browser [e.g. stock browser, safari]
+ - Version [e.g. 22]
+
+**Additional context**
+Add any other context about the problem here.
diff --git a/core/src/index/thirdparty/SPTAG/.github/ISSUE_TEMPLATE/feature_request.md b/core/src/index/thirdparty/SPTAG/.github/ISSUE_TEMPLATE/feature_request.md
new file mode 100644
index 0000000000..066b2d920a
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/.github/ISSUE_TEMPLATE/feature_request.md
@@ -0,0 +1,17 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.
diff --git a/core/src/index/thirdparty/SPTAG/.gitignore b/core/src/index/thirdparty/SPTAG/.gitignore
new file mode 100644
index 0000000000..973785834c
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/.gitignore
@@ -0,0 +1,91 @@
+# Prerequisites
+*.d
+
+# Object files
+*.o
+*.ko
+*.obj
+*.elf
+
+# Linker output
+*.ilk
+*.map
+*.exp
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Libraries
+*.lib
+*.a
+*.la
+*.lo
+
+# Shared objects (inc. Windows DLLs)
+*.dll
+*.so
+*.so.*
+*.dylib
+
+# Executables
+*.exe
+*.out
+*.app
+*.i*86
+*.x86_64
+*.hex
+
+# Debug files
+*.dSYM/
+*.su
+*.idb
+*.pdb
+
+# Kernel Module Compile Results
+*.mod*
+*.cmd
+.tmp_versions/
+modules.order
+Module.symvers
+Mkfile.old
+dkms.conf
+/.vs/SPTAG/v14
+/AnnService/x64
+/obj/x64_Release
+/PythonWrapper/x64/Release
+/x64/Release
+/SPTAG.VC.db
+/SPTAG.VC.VC.opendb
+/AnnService/CoreLibrary.vcxproj.user
+/AnnService/IndexBuilder.vcxproj.user
+/AnnService/Server.vcxproj.user
+/AnnService/SocketLib.vcxproj.user
+/PythonWrapper/PythonCore.vcxproj.user
+/build
+/PythonWrapper/inc/ClientInterface_wrap.cxx
+/PythonWrapper/inc/CoreInterface_wrap.cxx
+/PythonWrapper/inc/SPTAG.py
+/PythonWrapper/inc/SPTAGClient.py
+/ipch/TEST-4fb66b42
+/obj/x64_Debug
+/x64/Debug
+/packages
+/Search/Search.vcxproj.user
+/AnnService/IndexSearcher.vcxproj.user
+/Wrappers/inc/SWIGTYPE_p_RemoteSearchResult.java
+/Wrappers/inc/SWIGTYPE_p_QueryResult.java
+/Wrappers/inc/SPTAGJNI.java
+/Wrappers/inc/SPTAGClientJNI.java
+/Wrappers/inc/SPTAGClient.py
+/Wrappers/inc/SPTAGClient.java
+/Wrappers/inc/SPTAG.py
+/Wrappers/inc/SPTAG.java
+/Wrappers/inc/CoreInterface_pwrap.cpp
+/Wrappers/inc/CoreInterface_jwrap.cpp
+/Wrappers/inc/ClientInterface_pwrap.cpp
+/Wrappers/inc/ClientInterface_jwrap.cpp
+/Wrappers/inc/AnnIndex.java
+/Wrappers/inc/AnnClient.java
+/AnnService.users - Copy.props
+/.vs
diff --git a/core/src/index/thirdparty/SPTAG/AnnService.users.props b/core/src/index/thirdparty/SPTAG/AnnService.users.props
new file mode 100644
index 0000000000..e65231357f
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService.users.props
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(SolutionDir)AnnService.users.props.user" Condition="Exists('$(SolutionDir)AnnService.users.props.user')" />
+
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <AdditionalOptions>$(SystemVersionDef) %(AdditionalOptions)</AdditionalOptions>
+    </ClCompile>
+  </ItemDefinitionGroup>
+
+  <PropertyGroup Label="UserMacros">
+	<OutAppDir>$(SolutionDir)\$(Platform)\$(Configuration)\</OutAppDir>
+    <OutLibDir>$(SolutionDir)\$(Platform)\$(Configuration)\</OutLibDir>
+	<JavaIncDir></JavaIncDir>
+	<JavaLib></JavaLib>
+  </PropertyGroup>
+</Project>
+
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/Aggregator.vcxproj b/core/src/index/thirdparty/SPTAG/AnnService/Aggregator.vcxproj
new file mode 100644
index 0000000000..4e5514f057
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/Aggregator.vcxproj
@@ -0,0 +1,178 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>15.0</VCProjectVersion>
+    <ProjectGuid>{D7F09A63-BDCA-4F6C-A864-8551D1FE447A}</ProjectGuid>
+    <RootNamespace>Aggregator</RootNamespace>
+    <WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <Import Project="$(SolutionDir)\AnnService.users.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <IntDir>$(SolutionDir)obj\$(Platform)_$(Configuration)\$(ProjectName)\</IntDir>
+    <IncludePath>$(ProjectDir);$(IncludePath)</IncludePath>
+    <OutDir>$(OutAppDir)</OutDir>
+    <LibraryPath>$(OutLibDir);$(LibraryPath)</LibraryPath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <SDLCheck>true</SDLCheck>
+      <ConformanceMode>true</ConformanceMode>
+      <PreprocessorDefinitions>_MBCS;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ControlFlowGuard>Guard</ControlFlowGuard>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+    </ClCompile>
+    <Link>
+      <AdditionalDependencies>CoreLibrary.lib;SocketLib.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalOptions>/guard:cf
+ %(AdditionalOptions)</AdditionalOptions>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <SDLCheck>true</SDLCheck>
+      <ConformanceMode>true</ConformanceMode>
+    </ClCompile>
+    <Link>
+      <AdditionalDependencies>CoreLibrary.lib;SocketLib.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <ConformanceMode>true</ConformanceMode>
+    </ClCompile>
+    <Link>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <AdditionalDependencies>CoreLibrary.lib;SocketLib.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <ConformanceMode>true</ConformanceMode>
+      <PreprocessorDefinitions>_MBCS;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <AdditionalDependencies>CoreLibrary.lib;SocketLib.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="inc\Aggregator\AggregatorContext.h" />
+    <ClInclude Include="inc\Aggregator\AggregatorExecutionContext.h" />
+    <ClInclude Include="inc\Aggregator\AggregatorService.h" />
+    <ClInclude Include="inc\Aggregator\AggregatorSettings.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="src\Aggregator\AggregatorContext.cpp" />
+    <ClCompile Include="src\Aggregator\AggregatorExecutionContext.cpp" />
+    <ClCompile Include="src\Aggregator\AggregatorService.cpp" />
+    <ClCompile Include="src\Aggregator\AggregatorSettings.cpp" />
+    <ClCompile Include="src\Aggregator\main.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="..\packages\boost.1.67.0.0\build\boost.targets" Condition="Exists('..\packages\boost.1.67.0.0\build\boost.targets')" />
+    <Import Project="..\packages\boost_date_time-vc140.1.67.0.0\build\boost_date_time-vc140.targets" Condition="Exists('..\packages\boost_date_time-vc140.1.67.0.0\build\boost_date_time-vc140.targets')" />
+    <Import Project="..\packages\boost_regex-vc140.1.67.0.0\build\boost_regex-vc140.targets" Condition="Exists('..\packages\boost_regex-vc140.1.67.0.0\build\boost_regex-vc140.targets')" />
+    <Import Project="..\packages\boost_serialization-vc140.1.67.0.0\build\boost_serialization-vc140.targets" Condition="Exists('..\packages\boost_serialization-vc140.1.67.0.0\build\boost_serialization-vc140.targets')" />
+    <Import Project="..\packages\boost_system-vc140.1.67.0.0\build\boost_system-vc140.targets" Condition="Exists('..\packages\boost_system-vc140.1.67.0.0\build\boost_system-vc140.targets')" />
+    <Import Project="..\packages\boost_thread-vc140.1.67.0.0\build\boost_thread-vc140.targets" Condition="Exists('..\packages\boost_thread-vc140.1.67.0.0\build\boost_thread-vc140.targets')" />
+    <Import Project="..\packages\boost_wserialization-vc140.1.67.0.0\build\boost_wserialization-vc140.targets" Condition="Exists('..\packages\boost_wserialization-vc140.1.67.0.0\build\boost_wserialization-vc140.targets')" />
+  </ImportGroup>
+  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
+    <PropertyGroup>
+      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
+    </PropertyGroup>
+    <Error Condition="!Exists('..\packages\boost.1.67.0.0\build\boost.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost.1.67.0.0\build\boost.targets'))" />
+    <Error Condition="!Exists('..\packages\boost_date_time-vc140.1.67.0.0\build\boost_date_time-vc140.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost_date_time-vc140.1.67.0.0\build\boost_date_time-vc140.targets'))" />
+    <Error Condition="!Exists('..\packages\boost_regex-vc140.1.67.0.0\build\boost_regex-vc140.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost_regex-vc140.1.67.0.0\build\boost_regex-vc140.targets'))" />
+    <Error Condition="!Exists('..\packages\boost_serialization-vc140.1.67.0.0\build\boost_serialization-vc140.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost_serialization-vc140.1.67.0.0\build\boost_serialization-vc140.targets'))" />
+    <Error Condition="!Exists('..\packages\boost_system-vc140.1.67.0.0\build\boost_system-vc140.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost_system-vc140.1.67.0.0\build\boost_system-vc140.targets'))" />
+    <Error Condition="!Exists('..\packages\boost_thread-vc140.1.67.0.0\build\boost_thread-vc140.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost_thread-vc140.1.67.0.0\build\boost_thread-vc140.targets'))" />
+    <Error Condition="!Exists('..\packages\boost_wserialization-vc140.1.67.0.0\build\boost_wserialization-vc140.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost_wserialization-vc140.1.67.0.0\build\boost_wserialization-vc140.targets'))" />
+  </Target>
+</Project>
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/Aggregator.vcxproj.filters b/core/src/index/thirdparty/SPTAG/AnnService/Aggregator.vcxproj.filters
new file mode 100644
index 0000000000..de08faca3f
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/Aggregator.vcxproj.filters
@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="inc\Aggregator\AggregatorService.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Aggregator\AggregatorContext.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Aggregator\AggregatorSettings.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Aggregator\AggregatorExecutionContext.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="src\Aggregator\AggregatorService.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\Aggregator\AggregatorContext.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\Aggregator\AggregatorExecutionContext.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\Aggregator\AggregatorSettings.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\Aggregator\main.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/CMakeLists.txt b/core/src/index/thirdparty/SPTAG/AnnService/CMakeLists.txt
new file mode 100644
index 0000000000..fffc5ce426
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/CMakeLists.txt
@@ -0,0 +1,41 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+
+file(GLOB HDR_FILES ${PROJECT_SOURCE_DIR}/AnnService/inc/Core/*.h ${PROJECT_SOURCE_DIR}/AnnService/inc/Core/Common/*.h ${PROJECT_SOURCE_DIR}/AnnService/inc/Core/BKT/*.h ${PROJECT_SOURCE_DIR}/AnnService/inc/Core/KDT/*.h ${PROJECT_SOURCE_DIR}/AnnService/inc/Helper/*.h ${PROJECT_SOURCE_DIR}/AnnService/inc/Helper/VectorSetReaders/*.h)
+file(GLOB SRC_FILES ${PROJECT_SOURCE_DIR}/AnnService/src/Core/*.cpp ${PROJECT_SOURCE_DIR}/AnnService/src/Core/Common/*.cpp ${PROJECT_SOURCE_DIR}/AnnService/src/Core/BKT/*.cpp ${PROJECT_SOURCE_DIR}/AnnService/src/Core/KDT/*.cpp ${PROJECT_SOURCE_DIR}/AnnService/src/Helper/*.cpp ${PROJECT_SOURCE_DIR}/AnnService/src/Helper/VectorSetReaders/*.cpp)
+
+include_directories(${PROJECT_SOURCE_DIR}/AnnService)
+
+add_library (SPTAGLib SHARED ${SRC_FILES} ${HDR_FILES})
+target_link_libraries (SPTAGLib)
+add_library (SPTAGLibStatic STATIC ${SRC_FILES} ${HDR_FILES})
+set_target_properties(SPTAGLibStatic PROPERTIES OUTPUT_NAME SPTAGLib)
+
+file(GLOB SERVER_HDR_FILES ${HDR_FILES} ${PROJECT_SOURCE_DIR}/AnnService/inc/Server/*.h ${PROJECT_SOURCE_DIR}/AnnService/inc/Socket/*.h)
+file(GLOB SERVER_FILES ${SRC_FILES} ${PROJECT_SOURCE_DIR}/AnnService/src/Server/*.cpp ${PROJECT_SOURCE_DIR}/AnnService/src/Socket/*.cpp)
+add_executable (server ${SERVER_FILES} ${SERVER_HDR_FILES})
+target_link_libraries(server ${Boost_LIBRARIES})
+
+file(GLOB CLIENT_HDR_FILES ${HDR_FILES} ${PROJECT_SOURCE_DIR}/AnnService/inc/Client/*.h ${PROJECT_SOURCE_DIR}/AnnService/inc/Socket/*.h)
+file(GLOB CLIENT_FILES ${SRC_FILES} ${PROJECT_SOURCE_DIR}/AnnService/src/Client/*.cpp ${PROJECT_SOURCE_DIR}/AnnService/src/Socket/*.cpp)
+add_executable (client ${CLIENT_FILES} ${CLIENT_HDR_FILES})
+target_link_libraries(client ${Boost_LIBRARIES})
+
+file(GLOB AGG_HDR_FILES ${HDR_FILES} ${PROJECT_SOURCE_DIR}/AnnService/inc/Aggregator/*.h ${PROJECT_SOURCE_DIR}/AnnService/inc/Socket/*.h)
+file(GLOB AGG_FILES ${SRC_FILES} ${PROJECT_SOURCE_DIR}/AnnService/src/Aggregator/*.cpp ${PROJECT_SOURCE_DIR}/AnnService/src/Socket/*.cpp)
+add_executable (aggregator ${AGG_FILES} ${AGG_HDR_FILES})
+target_link_libraries(aggregator ${Boost_LIBRARIES})
+
+file(GLOB BUILDER_HDR_FILES ${HDR_FILES} ${PROJECT_SOURCE_DIR}/AnnService/inc/IndexBuilder/*.h)
+file(GLOB BUILDER_FILES ${SRC_FILES} ${PROJECT_SOURCE_DIR}/AnnService/src/IndexBuilder/*.cpp)
+add_executable (indexbuilder ${BUILDER_FILES} ${BUILDER_HDR_FILES})
+target_link_libraries(indexbuilder ${Boost_LIBRARIES})
+
+file(GLOB SEARCHER_FILES ${SRC_FILES} ${PROJECT_SOURCE_DIR}/AnnService/src/IndexSearcher/*.cpp)
+add_executable (indexsearcher ${SEARCHER_FILES} ${HDR_FILES})
+target_link_libraries(indexsearcher ${Boost_LIBRARIES})
+
+install(TARGETS SPTAGLib SPTAGLibStatic server client aggregator indexbuilder indexsearcher
+  RUNTIME DESTINATION bin
+  ARCHIVE DESTINATION lib
+  LIBRARY DESTINATION lib)
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/Client.vcxproj b/core/src/index/thirdparty/SPTAG/AnnService/Client.vcxproj
new file mode 100644
index 0000000000..34cb9def7a
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/Client.vcxproj
@@ -0,0 +1,145 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>15.0</VCProjectVersion>
+    <ProjectGuid>{A89D70C3-C53B-42DE-A5CE-9A472540F5CB}</ProjectGuid>
+    <RootNamespace>Client</RootNamespace>
+    <WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <Import Project="$(SolutionDir)\AnnService.users.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <IntDir>$(SolutionDir)obj\$(Platform)_$(Configuration)\$(ProjectName)\</IntDir>
+    <IncludePath>$(ProjectDir);$(IncludePath)</IncludePath>
+    <OutDir>$(OutAppDir)</OutDir>
+    <LibraryPath>$(OutLibDir);$(LibraryPath)</LibraryPath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Link>
+      <AdditionalDependencies>CoreLibrary.lib;SocketLib.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Link>
+      <AdditionalDependencies>CoreLibrary.lib;SocketLib.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Link>
+      <AdditionalDependencies>CoreLibrary.lib;SocketLib.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalOptions>/guard:cf %(AdditionalOptions)</AdditionalOptions>
+    </Link>
+    <ClCompile>
+      <ControlFlowGuard>Guard</ControlFlowGuard>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <PreprocessorDefinitions>_MBCS;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Link>
+      <AdditionalDependencies>CoreLibrary.lib;SocketLib.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+    <ClCompile>
+      <PreprocessorDefinitions>_MBCS;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="src\Client\ClientWrapper.cpp" />
+    <ClCompile Include="src\Client\main.cpp" />
+    <ClCompile Include="src\Client\Options.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="inc\Client\ClientWrapper.h" />
+    <ClInclude Include="inc\Client\Options.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="..\packages\boost.1.67.0.0\build\boost.targets" Condition="Exists('..\packages\boost.1.67.0.0\build\boost.targets')" />
+    <Import Project="..\packages\boost_date_time-vc140.1.67.0.0\build\boost_date_time-vc140.targets" Condition="Exists('..\packages\boost_date_time-vc140.1.67.0.0\build\boost_date_time-vc140.targets')" />
+    <Import Project="..\packages\boost_regex-vc140.1.67.0.0\build\boost_regex-vc140.targets" Condition="Exists('..\packages\boost_regex-vc140.1.67.0.0\build\boost_regex-vc140.targets')" />
+    <Import Project="..\packages\boost_serialization-vc140.1.67.0.0\build\boost_serialization-vc140.targets" Condition="Exists('..\packages\boost_serialization-vc140.1.67.0.0\build\boost_serialization-vc140.targets')" />
+    <Import Project="..\packages\boost_system-vc140.1.67.0.0\build\boost_system-vc140.targets" Condition="Exists('..\packages\boost_system-vc140.1.67.0.0\build\boost_system-vc140.targets')" />
+    <Import Project="..\packages\boost_thread-vc140.1.67.0.0\build\boost_thread-vc140.targets" Condition="Exists('..\packages\boost_thread-vc140.1.67.0.0\build\boost_thread-vc140.targets')" />
+    <Import Project="..\packages\boost_wserialization-vc140.1.67.0.0\build\boost_wserialization-vc140.targets" Condition="Exists('..\packages\boost_wserialization-vc140.1.67.0.0\build\boost_wserialization-vc140.targets')" />
+  </ImportGroup>
+  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
+    <PropertyGroup>
+      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
+    </PropertyGroup>
+    <Error Condition="!Exists('..\packages\boost.1.67.0.0\build\boost.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost.1.67.0.0\build\boost.targets'))" />
+    <Error Condition="!Exists('..\packages\boost_date_time-vc140.1.67.0.0\build\boost_date_time-vc140.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost_date_time-vc140.1.67.0.0\build\boost_date_time-vc140.targets'))" />
+    <Error Condition="!Exists('..\packages\boost_regex-vc140.1.67.0.0\build\boost_regex-vc140.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost_regex-vc140.1.67.0.0\build\boost_regex-vc140.targets'))" />
+    <Error Condition="!Exists('..\packages\boost_serialization-vc140.1.67.0.0\build\boost_serialization-vc140.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost_serialization-vc140.1.67.0.0\build\boost_serialization-vc140.targets'))" />
+    <Error Condition="!Exists('..\packages\boost_system-vc140.1.67.0.0\build\boost_system-vc140.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost_system-vc140.1.67.0.0\build\boost_system-vc140.targets'))" />
+    <Error Condition="!Exists('..\packages\boost_thread-vc140.1.67.0.0\build\boost_thread-vc140.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost_thread-vc140.1.67.0.0\build\boost_thread-vc140.targets'))" />
+    <Error Condition="!Exists('..\packages\boost_wserialization-vc140.1.67.0.0\build\boost_wserialization-vc140.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost_wserialization-vc140.1.67.0.0\build\boost_wserialization-vc140.targets'))" />
+  </Target>
+</Project>
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/Client.vcxproj.filters b/core/src/index/thirdparty/SPTAG/AnnService/Client.vcxproj.filters
new file mode 100644
index 0000000000..31d84bd1d5
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/Client.vcxproj.filters
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="src\Client\main.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\Client\ClientWrapper.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\Client\Options.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="inc\Client\Options.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Client\ClientWrapper.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/CoreLibrary.vcxproj b/core/src/index/thirdparty/SPTAG/AnnService/CoreLibrary.vcxproj
new file mode 100644
index 0000000000..08921f2444
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/CoreLibrary.vcxproj
@@ -0,0 +1,192 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>15.0</VCProjectVersion>
+    <ProjectGuid>{C2BC5FDE-C853-4F3D-B7E4-2C9B5524DDF9}</ProjectGuid>
+    <RootNamespace>CoreLibrary</RootNamespace>
+    <WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
+    <ProjectName>CoreLibrary</ProjectName>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <Import Project="$(SolutionDir)\AnnService.users.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <IncludePath>$(IncludePath);$(ProjectDir)</IncludePath>
+  </PropertyGroup>
+  <PropertyGroup>
+    <IntDir>$(SolutionDir)obj\$(Platform)_$(Configuration)\$(ProjectName)\</IntDir>
+    <OutDir>$(OutLibDir)</OutDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <SDLCheck>true</SDLCheck>
+      <ConformanceMode>true</ConformanceMode>
+      <AdditionalOptions>/Zc:twoPhase- %(AdditionalOptions)</AdditionalOptions>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <SDLCheck>true</SDLCheck>
+      <ConformanceMode>true</ConformanceMode>
+      <OpenMPSupport>true</OpenMPSupport>
+      <PreprocessorDefinitions>_MBCS;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ControlFlowGuard>Guard</ControlFlowGuard>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <ConformanceMode>true</ConformanceMode>
+      <AdditionalOptions>/Zc:twoPhase- %(AdditionalOptions)</AdditionalOptions>
+    </ClCompile>
+    <Link>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <ConformanceMode>true</ConformanceMode>
+      <OpenMPSupport>true</OpenMPSupport>
+      <PreprocessorDefinitions>_MBCS;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="inc\Core\Common\FineGrainedLock.h" />
+    <ClInclude Include="inc\Core\Common\WorkSpace.h" />
+    <ClInclude Include="inc\Core\Common\CommonUtils.h" />
+    <ClInclude Include="inc\Core\Common\Dataset.h" />
+    <ClInclude Include="inc\Core\Common\DataUtils.h" />
+    <ClInclude Include="inc\Core\Common\DistanceUtils.h" />
+    <ClInclude Include="inc\Core\Common\Heap.h" />
+    <ClInclude Include="inc\Core\Common\QueryResultSet.h" />
+    <ClInclude Include="inc\Core\Common\WorkSpacePool.h" />
+    <ClInclude Include="inc\Core\BKT\Index.h" />
+    <ClInclude Include="inc\Core\BKT\ParameterDefinitionList.h" />
+    <ClInclude Include="inc\Core\KDT\Index.h" />
+    <ClInclude Include="inc\Core\KDT\ParameterDefinitionList.h" />
+    <ClInclude Include="inc\Core\Common.h" />
+    <ClInclude Include="inc\Core\CommonDataStructure.h" />
+    <ClInclude Include="inc\Core\DefinitionList.h" />
+    <ClInclude Include="inc\Core\MetadataSet.h" />
+    <ClInclude Include="inc\Core\SearchQuery.h" />
+    <ClInclude Include="inc\Core\SearchResult.h" />
+    <ClInclude Include="inc\Core\VectorIndex.h" />
+    <ClInclude Include="inc\Core\VectorSet.h" />
+    <ClInclude Include="inc\Helper\ArgumentsParser.h" />
+    <ClInclude Include="inc\Helper\Base64Encode.h" />
+    <ClInclude Include="inc\Helper\BufferStream.h" />
+    <ClInclude Include="inc\Helper\CommonHelper.h" />
+    <ClInclude Include="inc\Helper\Concurrent.h" />
+    <ClInclude Include="inc\Helper\ConcurrentSet.h" />
+    <ClInclude Include="inc\Helper\SimpleIniReader.h" />
+    <ClInclude Include="inc\Helper\StringConvert.h" />
+    <ClInclude Include="inc\Core\Common\NeighborhoodGraph.h" />
+    <ClInclude Include="inc\Core\Common\RelativeNeighborhoodGraph.h" />
+    <ClInclude Include="inc\Core\Common\BKTree.h" />
+    <ClInclude Include="inc\Core\Common\KDTree.h" />
+    <ClInclude Include="inc\Helper\VectorSetReader.h" />
+    <ClInclude Include="inc\Helper\VectorSetReaders\DefaultReader.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="src\Core\BKT\BKTIndex.cpp" />
+    <ClCompile Include="src\Core\Common\NeighborhoodGraph.cpp" />
+    <ClCompile Include="src\Core\KDT\KDTIndex.cpp" />
+    <ClCompile Include="src\Core\Common\WorkSpacePool.cpp" />
+    <ClCompile Include="src\Core\MetadataSet.cpp" />
+    <ClCompile Include="src\Core\VectorIndex.cpp" />
+    <ClCompile Include="src\Core\VectorSet.cpp" />
+    <ClCompile Include="src\Helper\ArgumentsParser.cpp" />
+    <ClCompile Include="src\Helper\Base64Encode.cpp" />
+    <ClCompile Include="src\Helper\CommonHelper.cpp" />
+    <ClCompile Include="src\Helper\Concurrent.cpp" />
+    <ClCompile Include="src\Helper\SimpleIniReader.cpp" />
+    <ClCompile Include="src\Helper\VectorSetReader.cpp" />
+    <ClCompile Include="src\Helper\VectorSetReaders\DefaultReader.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/CoreLibrary.vcxproj.filters b/core/src/index/thirdparty/SPTAG/AnnService/CoreLibrary.vcxproj.filters
new file mode 100644
index 0000000000..94f27df3f1
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/CoreLibrary.vcxproj.filters
@@ -0,0 +1,202 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{c260e4c4-ec44-4d50-941f-078454da2a89}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Header Files\Core">
+      <UniqueIdentifier>{c7b9ab49-a99f-4eb4-b8ab-61f0730b9a89}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Header Files\Core\BKT">
+      <UniqueIdentifier>{a306a099-8e3f-433d-b065-9d99433f422e}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Header Files\Helper">
+      <UniqueIdentifier>{33f272c5-907e-4848-bbd7-4340fe44f511}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Source Files\Core">
+      <UniqueIdentifier>{47ec2958-e880-4c1a-b663-04fc48c799af}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Source Files\Core\BKT">
+      <UniqueIdentifier>{10d17e5e-9ad2-4000-96d4-83b616480b97}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Source Files\Helper">
+      <UniqueIdentifier>{23fdeb31-9052-47d1-8edb-9b47c4b02707}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Header Files\Core\KDT">
+      <UniqueIdentifier>{6dff7b24-66ea-40b4-b408-d8fe264a6caa}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Header Files\Core\Common">
+      <UniqueIdentifier>{b0f1e81d-ca05-426e-bffa-75513a52ca6b}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Source Files\Core\Common">
+      <UniqueIdentifier>{774592a9-40aa-4342-a4af-b711a1cc4d52}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Source Files\Core\KDT">
+      <UniqueIdentifier>{8fb36afb-73ed-4c3d-8c9b-c3581d80c5d1}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Header Files\Helper\VectorSetReaders">
+      <UniqueIdentifier>{f7bc0bc7-1af5-4870-b8ee-fabdbabdb4c4}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Source Files\Helper\VectorSetReaders">
+      <UniqueIdentifier>{5c1449e0-38b7-4c82-976e-cbdc488d3fb5}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="inc\Core\Common.h">
+      <Filter>Header Files\Core</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Core\CommonDataStructure.h">
+      <Filter>Header Files\Core</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Core\DefinitionList.h">
+      <Filter>Header Files\Core</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Core\SearchQuery.h">
+      <Filter>Header Files\Core</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Core\SearchResult.h">
+      <Filter>Header Files\Core</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Core\VectorIndex.h">
+      <Filter>Header Files\Core</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Core\BKT\Index.h">
+      <Filter>Header Files\Core\BKT</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Helper\CommonHelper.h">
+      <Filter>Header Files\Helper</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Helper\SimpleIniReader.h">
+      <Filter>Header Files\Helper</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Helper\StringConvert.h">
+      <Filter>Header Files\Helper</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Core\MetadataSet.h">
+      <Filter>Header Files\Core</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Core\VectorSet.h">
+      <Filter>Header Files\Core</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Helper\Base64Encode.h">
+      <Filter>Header Files\Helper</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Helper\Concurrent.h">
+      <Filter>Header Files\Helper</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Helper\ArgumentsParser.h">
+      <Filter>Header Files\Helper</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Core\BKT\ParameterDefinitionList.h">
+      <Filter>Header Files\Core\BKT</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Core\Common\WorkSpace.h">
+      <Filter>Header Files\Core\Common</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Core\Common\CommonUtils.h">
+      <Filter>Header Files\Core\Common</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Core\Common\Dataset.h">
+      <Filter>Header Files\Core\Common</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Core\Common\DataUtils.h">
+      <Filter>Header Files\Core\Common</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Core\Common\DistanceUtils.h">
+      <Filter>Header Files\Core\Common</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Core\Common\Heap.h">
+      <Filter>Header Files\Core\Common</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Core\Common\QueryResultSet.h">
+      <Filter>Header Files\Core\Common</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Core\Common\WorkSpacePool.h">
+      <Filter>Header Files\Core\Common</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Core\KDT\Index.h">
+      <Filter>Header Files\Core\KDT</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Core\KDT\ParameterDefinitionList.h">
+      <Filter>Header Files\Core\KDT</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Core\Common\FineGrainedLock.h">
+      <Filter>Header Files\Core\Common</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Core\Common\NeighborhoodGraph.h">
+      <Filter>Header Files\Core\Common</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Core\Common\RelativeNeighborhoodGraph.h">
+      <Filter>Header Files\Core\Common</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Core\Common\KDTree.h">
+      <Filter>Header Files\Core\Common</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Core\Common\BKTree.h">
+      <Filter>Header Files\Core\Common</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Helper\ConcurrentSet.h">
+      <Filter>Header Files\Helper</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Helper\BufferStream.h">
+      <Filter>Header Files\Helper</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Helper\VectorSetReaders\DefaultReader.h">
+      <Filter>Header Files\Helper\VectorSetReaders</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Helper\VectorSetReader.h">
+      <Filter>Header Files\Helper</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="src\Core\VectorIndex.cpp">
+      <Filter>Source Files\Core</Filter>
+    </ClCompile>
+    <ClCompile Include="src\Core\Common\WorkSpacePool.cpp">
+      <Filter>Source Files\Core\Common</Filter>
+    </ClCompile>
+    <ClCompile Include="src\Helper\CommonHelper.cpp">
+      <Filter>Source Files\Helper</Filter>
+    </ClCompile>
+    <ClCompile Include="src\Helper\SimpleIniReader.cpp">
+      <Filter>Source Files\Helper</Filter>
+    </ClCompile>
+    <ClCompile Include="src\Core\VectorSet.cpp">
+      <Filter>Source Files\Core</Filter>
+    </ClCompile>
+    <ClCompile Include="src\Core\MetadataSet.cpp">
+      <Filter>Source Files\Core</Filter>
+    </ClCompile>
+    <ClCompile Include="src\Helper\Base64Encode.cpp">
+      <Filter>Source Files\Helper</Filter>
+    </ClCompile>
+    <ClCompile Include="src\Helper\Concurrent.cpp">
+      <Filter>Source Files\Helper</Filter>
+    </ClCompile>
+    <ClCompile Include="src\Helper\ArgumentsParser.cpp">
+      <Filter>Source Files\Helper</Filter>
+    </ClCompile>
+    <ClCompile Include="src\Core\BKT\BKTIndex.cpp">
+      <Filter>Source Files\Core\BKT</Filter>
+    </ClCompile>
+    <ClCompile Include="src\Core\KDT\KDTIndex.cpp">
+      <Filter>Source Files\Core\KDT</Filter>
+    </ClCompile>
+    <ClCompile Include="src\Core\Common\NeighborhoodGraph.cpp">
+      <Filter>Source Files\Core\Common</Filter>
+    </ClCompile>
+    <ClCompile Include="src\Helper\VectorSetReaders\DefaultReader.cpp">
+      <Filter>Source Files\Helper\VectorSetReaders</Filter>
+    </ClCompile>
+    <ClCompile Include="src\Helper\VectorSetReader.cpp">
+      <Filter>Source Files\Helper</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+  </ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/IndexBuilder.vcxproj b/core/src/index/thirdparty/SPTAG/AnnService/IndexBuilder.vcxproj
new file mode 100644
index 0000000000..a5d05fb473
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/IndexBuilder.vcxproj
@@ -0,0 +1,173 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>15.0</VCProjectVersion>
+    <ProjectGuid>{F492F794-E78B-4B1F-A556-5E045B9163D5}</ProjectGuid>
+    <RootNamespace>IndexBuilder</RootNamespace>
+    <WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <Import Project="$(SolutionDir)\AnnService.users.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup>
+    <IntDir>$(SolutionDir)obj\$(Platform)_$(Configuration)\$(ProjectName)\</IntDir>
+    <IncludePath>$(ProjectDir);$(IncludePath)</IncludePath>
+    <OutDir>$(OutAppDir)</OutDir>
+    <LibraryPath>$(OutLibDir);$(LibraryPath)</LibraryPath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <Link>
+      <AdditionalDependencies>CoreLibrary.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <ConformanceMode>true</ConformanceMode>
+      <PreprocessorDefinitions>_MBCS;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <OpenMPSupport>true</OpenMPSupport>
+    </ClCompile>
+    <Link>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <SDLCheck>true</SDLCheck>
+      <ConformanceMode>true</ConformanceMode>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <SDLCheck>true</SDLCheck>
+      <ConformanceMode>true</ConformanceMode>
+      <PreprocessorDefinitions>_MBCS;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ControlFlowGuard>Guard</ControlFlowGuard>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <OpenMPSupport>true</OpenMPSupport>
+    </ClCompile>
+    <Link>
+      <AdditionalOptions>/guard:cf %(AdditionalOptions)</AdditionalOptions>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <ConformanceMode>true</ConformanceMode>
+    </ClCompile>
+    <Link>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="inc\IndexBuilder\Options.h" />
+    <ClInclude Include="inc\IndexBuilder\ThreadPool.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="src\IndexBuilder\main.cpp" />
+    <ClCompile Include="src\IndexBuilder\Options.cpp" />
+    <ClCompile Include="src\IndexBuilder\ThreadPool.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="..\packages\boost.1.67.0.0\build\boost.targets" Condition="Exists('..\packages\boost.1.67.0.0\build\boost.targets')" />
+    <Import Project="..\packages\boost_date_time-vc140.1.67.0.0\build\boost_date_time-vc140.targets" Condition="Exists('..\packages\boost_date_time-vc140.1.67.0.0\build\boost_date_time-vc140.targets')" />
+    <Import Project="..\packages\boost_regex-vc140.1.67.0.0\build\boost_regex-vc140.targets" Condition="Exists('..\packages\boost_regex-vc140.1.67.0.0\build\boost_regex-vc140.targets')" />
+    <Import Project="..\packages\boost_serialization-vc140.1.67.0.0\build\boost_serialization-vc140.targets" Condition="Exists('..\packages\boost_serialization-vc140.1.67.0.0\build\boost_serialization-vc140.targets')" />
+    <Import Project="..\packages\boost_system-vc140.1.67.0.0\build\boost_system-vc140.targets" Condition="Exists('..\packages\boost_system-vc140.1.67.0.0\build\boost_system-vc140.targets')" />
+    <Import Project="..\packages\boost_thread-vc140.1.67.0.0\build\boost_thread-vc140.targets" Condition="Exists('..\packages\boost_thread-vc140.1.67.0.0\build\boost_thread-vc140.targets')" />
+    <Import Project="..\packages\boost_wserialization-vc140.1.67.0.0\build\boost_wserialization-vc140.targets" Condition="Exists('..\packages\boost_wserialization-vc140.1.67.0.0\build\boost_wserialization-vc140.targets')" />
+  </ImportGroup>
+  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
+    <PropertyGroup>
+      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
+    </PropertyGroup>
+    <Error Condition="!Exists('..\packages\boost.1.67.0.0\build\boost.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost.1.67.0.0\build\boost.targets'))" />
+    <Error Condition="!Exists('..\packages\boost_date_time-vc140.1.67.0.0\build\boost_date_time-vc140.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost_date_time-vc140.1.67.0.0\build\boost_date_time-vc140.targets'))" />
+    <Error Condition="!Exists('..\packages\boost_regex-vc140.1.67.0.0\build\boost_regex-vc140.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost_regex-vc140.1.67.0.0\build\boost_regex-vc140.targets'))" />
+    <Error Condition="!Exists('..\packages\boost_serialization-vc140.1.67.0.0\build\boost_serialization-vc140.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost_serialization-vc140.1.67.0.0\build\boost_serialization-vc140.targets'))" />
+    <Error Condition="!Exists('..\packages\boost_system-vc140.1.67.0.0\build\boost_system-vc140.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost_system-vc140.1.67.0.0\build\boost_system-vc140.targets'))" />
+    <Error Condition="!Exists('..\packages\boost_thread-vc140.1.67.0.0\build\boost_thread-vc140.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost_thread-vc140.1.67.0.0\build\boost_thread-vc140.targets'))" />
+    <Error Condition="!Exists('..\packages\boost_wserialization-vc140.1.67.0.0\build\boost_wserialization-vc140.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost_wserialization-vc140.1.67.0.0\build\boost_wserialization-vc140.targets'))" />
+  </Target>
+</Project>
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/IndexBuilder.vcxproj.filters b/core/src/index/thirdparty/SPTAG/AnnService/IndexBuilder.vcxproj.filters
new file mode 100644
index 0000000000..0733fae1c1
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/IndexBuilder.vcxproj.filters
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="inc\IndexBuilder\Options.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\IndexBuilder\ThreadPool.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="src\IndexBuilder\Options.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\IndexBuilder\main.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\IndexBuilder\ThreadPool.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/IndexSearcher.vcxproj b/core/src/index/thirdparty/SPTAG/AnnService/IndexSearcher.vcxproj
new file mode 100644
index 0000000000..266ac576b3
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/IndexSearcher.vcxproj
@@ -0,0 +1,170 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>15.0</VCProjectVersion>
+    <ProjectGuid>{97615D3B-9FA0-469E-B229-95A91A5087E0}</ProjectGuid>
+    <RootNamespace>IndexSearcher</RootNamespace>
+    <WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
+    <ProjectName>IndexSearcher</ProjectName>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <Import Project="$(SolutionDir)\AnnService.users.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup>
+    <IntDir>$(SolutionDir)obj\$(Platform)_$(Configuration)\$(ProjectName)\</IntDir>
+    <IncludePath>$(ProjectDir);$(SolutionDir)AnnService\;$(IncludePath)</IncludePath>
+    <LibraryPath>$(OutLibDir);$(LibraryPath)</LibraryPath>
+    <OutDir>$(OutAppDir)</OutDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <Link>
+      <AdditionalDependencies>CoreLibrary.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <ConformanceMode>true</ConformanceMode>
+      <PreprocessorDefinitions>_MBCS;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <OpenMPSupport>true</OpenMPSupport>
+    </ClCompile>
+    <Link>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <SDLCheck>true</SDLCheck>
+      <ConformanceMode>true</ConformanceMode>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <SDLCheck>true</SDLCheck>
+      <ConformanceMode>true</ConformanceMode>
+      <PreprocessorDefinitions>_MBCS;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ControlFlowGuard>Guard</ControlFlowGuard>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <OpenMPSupport>true</OpenMPSupport>
+    </ClCompile>
+    <Link>
+      <AdditionalOptions>/guard:cf %(AdditionalOptions)</AdditionalOptions>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <ConformanceMode>true</ConformanceMode>
+    </ClCompile>
+    <Link>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="src\IndexSearcher\main.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config">
+      <SubType>Designer</SubType>
+    </None>
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="..\packages\boost.1.67.0.0\build\boost.targets" Condition="Exists('..\packages\boost.1.67.0.0\build\boost.targets')" />
+    <Import Project="..\packages\boost_date_time-vc140.1.67.0.0\build\boost_date_time-vc140.targets" Condition="Exists('..\packages\boost_date_time-vc140.1.67.0.0\build\boost_date_time-vc140.targets')" />
+    <Import Project="..\packages\boost_regex-vc140.1.67.0.0\build\boost_regex-vc140.targets" Condition="Exists('..\packages\boost_regex-vc140.1.67.0.0\build\boost_regex-vc140.targets')" />
+    <Import Project="..\packages\boost_serialization-vc140.1.67.0.0\build\boost_serialization-vc140.targets" Condition="Exists('..\packages\boost_serialization-vc140.1.67.0.0\build\boost_serialization-vc140.targets')" />
+    <Import Project="..\packages\boost_system-vc140.1.67.0.0\build\boost_system-vc140.targets" Condition="Exists('..\packages\boost_system-vc140.1.67.0.0\build\boost_system-vc140.targets')" />
+    <Import Project="..\packages\boost_thread-vc140.1.67.0.0\build\boost_thread-vc140.targets" Condition="Exists('..\packages\boost_thread-vc140.1.67.0.0\build\boost_thread-vc140.targets')" />
+    <Import Project="..\packages\boost_wserialization-vc140.1.67.0.0\build\boost_wserialization-vc140.targets" Condition="Exists('..\packages\boost_wserialization-vc140.1.67.0.0\build\boost_wserialization-vc140.targets')" />
+  </ImportGroup>
+  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
+    <PropertyGroup>
+      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
+    </PropertyGroup>
+    <Error Condition="!Exists('..\packages\boost.1.67.0.0\build\boost.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost.1.67.0.0\build\boost.targets'))" />
+    <Error Condition="!Exists('..\packages\boost_date_time-vc140.1.67.0.0\build\boost_date_time-vc140.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost_date_time-vc140.1.67.0.0\build\boost_date_time-vc140.targets'))" />
+    <Error Condition="!Exists('..\packages\boost_regex-vc140.1.67.0.0\build\boost_regex-vc140.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost_regex-vc140.1.67.0.0\build\boost_regex-vc140.targets'))" />
+    <Error Condition="!Exists('..\packages\boost_serialization-vc140.1.67.0.0\build\boost_serialization-vc140.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost_serialization-vc140.1.67.0.0\build\boost_serialization-vc140.targets'))" />
+    <Error Condition="!Exists('..\packages\boost_system-vc140.1.67.0.0\build\boost_system-vc140.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost_system-vc140.1.67.0.0\build\boost_system-vc140.targets'))" />
+    <Error Condition="!Exists('..\packages\boost_thread-vc140.1.67.0.0\build\boost_thread-vc140.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost_thread-vc140.1.67.0.0\build\boost_thread-vc140.targets'))" />
+    <Error Condition="!Exists('..\packages\boost_wserialization-vc140.1.67.0.0\build\boost_wserialization-vc140.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost_wserialization-vc140.1.67.0.0\build\boost_wserialization-vc140.targets'))" />
+  </Target>
+</Project>
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/IndexSearcher.vcxproj.filters b/core/src/index/thirdparty/SPTAG/AnnService/IndexSearcher.vcxproj.filters
new file mode 100644
index 0000000000..82f7700c53
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/IndexSearcher.vcxproj.filters
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
+    </Filter>
+    <Filter Include="Resource Files">
+      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="src\IndexSearcher\main.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+  </ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/Server.vcxproj b/core/src/index/thirdparty/SPTAG/AnnService/Server.vcxproj
new file mode 100644
index 0000000000..d830f3bc0d
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/Server.vcxproj
@@ -0,0 +1,153 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>15.0</VCProjectVersion>
+    <ProjectGuid>{E28B1222-8BEA-4A92-8FE0-088EBDAA7FE0}</ProjectGuid>
+    <RootNamespace>Server</RootNamespace>
+    <WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <Import Project="$(SolutionDir)\AnnService.users.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <IntDir>$(SolutionDir)obj\$(Platform)_$(Configuration)\$(ProjectName)\</IntDir>
+    <IncludePath>$(ProjectDir);$(IncludePath)</IncludePath>
+    <OutDir>$(OutAppDir)</OutDir>
+    <LibraryPath>$(OutLibDir);$(LibraryPath)</LibraryPath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Link>
+      <AdditionalDependencies>CoreLibrary.lib;SocketLib.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Link>
+      <AdditionalDependencies>CoreLibrary.lib;SocketLib.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Link>
+      <AdditionalDependencies>CoreLibrary.lib;SocketLib.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalOptions>/guard:cf %(AdditionalOptions)</AdditionalOptions>
+    </Link>
+    <ClCompile>
+      <PreprocessorDefinitions>_MBCS;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ControlFlowGuard>Guard</ControlFlowGuard>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Link>
+      <AdditionalDependencies>CoreLibrary.lib;SocketLib.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+    <ClCompile>
+      <PreprocessorDefinitions>_MBCS;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="inc\Server\QueryParser.h" />
+    <ClInclude Include="inc\Server\SearchExecutor.h" />
+    <ClInclude Include="inc\Server\SearchExecutionContext.h" />
+    <ClInclude Include="inc\Server\SearchService.h" />
+    <ClInclude Include="inc\Server\ServiceContext.h" />
+    <ClInclude Include="inc\Server\ServiceSettings.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="src\Server\main.cpp" />
+    <ClCompile Include="src\Server\QueryParser.cpp" />
+    <ClCompile Include="src\Server\SearchExecutionContext.cpp" />
+    <ClCompile Include="src\Server\SearchExecutor.cpp" />
+    <ClCompile Include="src\Server\SearchService.cpp" />
+    <ClCompile Include="src\Server\ServiceContext.cpp" />
+    <ClCompile Include="src\Server\ServiceSettings.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="..\packages\boost.1.67.0.0\build\boost.targets" Condition="Exists('..\packages\boost.1.67.0.0\build\boost.targets')" />
+    <Import Project="..\packages\boost_date_time-vc140.1.67.0.0\build\boost_date_time-vc140.targets" Condition="Exists('..\packages\boost_date_time-vc140.1.67.0.0\build\boost_date_time-vc140.targets')" />
+    <Import Project="..\packages\boost_regex-vc140.1.67.0.0\build\boost_regex-vc140.targets" Condition="Exists('..\packages\boost_regex-vc140.1.67.0.0\build\boost_regex-vc140.targets')" />
+    <Import Project="..\packages\boost_serialization-vc140.1.67.0.0\build\boost_serialization-vc140.targets" Condition="Exists('..\packages\boost_serialization-vc140.1.67.0.0\build\boost_serialization-vc140.targets')" />
+    <Import Project="..\packages\boost_system-vc140.1.67.0.0\build\boost_system-vc140.targets" Condition="Exists('..\packages\boost_system-vc140.1.67.0.0\build\boost_system-vc140.targets')" />
+    <Import Project="..\packages\boost_thread-vc140.1.67.0.0\build\boost_thread-vc140.targets" Condition="Exists('..\packages\boost_thread-vc140.1.67.0.0\build\boost_thread-vc140.targets')" />
+    <Import Project="..\packages\boost_wserialization-vc140.1.67.0.0\build\boost_wserialization-vc140.targets" Condition="Exists('..\packages\boost_wserialization-vc140.1.67.0.0\build\boost_wserialization-vc140.targets')" />
+  </ImportGroup>
+  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
+    <PropertyGroup>
+      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
+    </PropertyGroup>
+    <Error Condition="!Exists('..\packages\boost.1.67.0.0\build\boost.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost.1.67.0.0\build\boost.targets'))" />
+    <Error Condition="!Exists('..\packages\boost_date_time-vc140.1.67.0.0\build\boost_date_time-vc140.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost_date_time-vc140.1.67.0.0\build\boost_date_time-vc140.targets'))" />
+    <Error Condition="!Exists('..\packages\boost_regex-vc140.1.67.0.0\build\boost_regex-vc140.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost_regex-vc140.1.67.0.0\build\boost_regex-vc140.targets'))" />
+    <Error Condition="!Exists('..\packages\boost_serialization-vc140.1.67.0.0\build\boost_serialization-vc140.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost_serialization-vc140.1.67.0.0\build\boost_serialization-vc140.targets'))" />
+    <Error Condition="!Exists('..\packages\boost_system-vc140.1.67.0.0\build\boost_system-vc140.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost_system-vc140.1.67.0.0\build\boost_system-vc140.targets'))" />
+    <Error Condition="!Exists('..\packages\boost_thread-vc140.1.67.0.0\build\boost_thread-vc140.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost_thread-vc140.1.67.0.0\build\boost_thread-vc140.targets'))" />
+    <Error Condition="!Exists('..\packages\boost_wserialization-vc140.1.67.0.0\build\boost_wserialization-vc140.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost_wserialization-vc140.1.67.0.0\build\boost_wserialization-vc140.targets'))" />
+  </Target>
+</Project>
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/Server.vcxproj.filters b/core/src/index/thirdparty/SPTAG/AnnService/Server.vcxproj.filters
new file mode 100644
index 0000000000..da95d13f40
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/Server.vcxproj.filters
@@ -0,0 +1,56 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="inc\Server\ServiceSettings.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Server\ServiceContext.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Server\SearchExecutor.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Server\SearchExecutionContext.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Server\QueryParser.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Server\SearchService.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="src\Server\SearchExecutionContext.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\Server\SearchExecutor.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\Server\ServiceContext.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\Server\ServiceSettings.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\Server\QueryParser.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\Server\SearchService.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\Server\main.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/SocketLib.vcxproj b/core/src/index/thirdparty/SPTAG/AnnService/SocketLib.vcxproj
new file mode 100644
index 0000000000..84f968fa0a
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/SocketLib.vcxproj
@@ -0,0 +1,123 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>15.0</VCProjectVersion>
+    <ProjectGuid>{F9A72303-6381-4C80-86FF-606A2F6F7B96}</ProjectGuid>
+    <RootNamespace>SocketLib</RootNamespace>
+    <WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>StaticLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <Import Project="$(SolutionDir)\AnnService.users.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <IncludePath>$(ProjectDir);$(IncludePath)</IncludePath>
+    <IntDir>$(SolutionDir)obj\$(Platform)_$(Configuration)\$(ProjectName)\</IntDir>
+    <OutDir>$(OutLibDir)\</OutDir>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <ControlFlowGuard>Guard</ControlFlowGuard>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <PreprocessorDefinitions>_MBCS;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <PreprocessorDefinitions>_MBCS;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="inc\Socket\Common.h" />
+    <ClInclude Include="inc\Socket\Connection.h" />
+    <ClInclude Include="inc\Socket\ConnectionManager.h" />
+    <ClInclude Include="inc\Socket\Packet.h" />
+    <ClInclude Include="inc\Socket\Client.h" />
+    <ClInclude Include="inc\Socket\ResourceManager.h" />
+    <ClInclude Include="inc\Socket\Server.h" />
+    <ClInclude Include="inc\Socket\RemoteSearchQuery.h" />
+    <ClInclude Include="inc\Socket\SimpleSerialization.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="src\Socket\Client.cpp" />
+    <ClCompile Include="src\Socket\Common.cpp" />
+    <ClCompile Include="src\Socket\Connection.cpp" />
+    <ClCompile Include="src\Socket\ConnectionManager.cpp" />
+    <ClCompile Include="src\Socket\Packet.cpp" />
+    <ClCompile Include="src\Socket\RemoteSearchQuery.cpp" />
+    <ClCompile Include="src\Socket\Server.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="..\packages\boost.1.67.0.0\build\boost.targets" Condition="Exists('..\packages\boost.1.67.0.0\build\boost.targets')" />
+  </ImportGroup>
+  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
+    <PropertyGroup>
+      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
+    </PropertyGroup>
+    <Error Condition="!Exists('..\packages\boost.1.67.0.0\build\boost.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost.1.67.0.0\build\boost.targets'))" />
+  </Target>
+</Project>
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/SocketLib.vcxproj.filters b/core/src/index/thirdparty/SPTAG/AnnService/SocketLib.vcxproj.filters
new file mode 100644
index 0000000000..5aa20f3bbf
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/SocketLib.vcxproj.filters
@@ -0,0 +1,65 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="inc\Socket\Packet.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Socket\Connection.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Socket\ConnectionManager.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Socket\Server.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Socket\Client.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Socket\ResourceManager.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Socket\Common.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Socket\RemoteSearchQuery.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\Socket\SimpleSerialization.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="src\Socket\Connection.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\Socket\ConnectionManager.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\Socket\Packet.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\Socket\Server.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\Socket\Client.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\Socket\Common.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\Socket\RemoteSearchQuery.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Aggregator/AggregatorContext.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Aggregator/AggregatorContext.h
new file mode 100644
index 0000000000..60c86137be
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Aggregator/AggregatorContext.h
@@ -0,0 +1,67 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_AGGREGATOR_AGGREGATORCONTEXT_H_
+#define _SPTAG_AGGREGATOR_AGGREGATORCONTEXT_H_
+
+#include "inc/Socket/Common.h"
+#include "AggregatorSettings.h"
+
+#include <memory>
+#include <vector>
+#include <atomic>
+
+namespace SPTAG
+{
+namespace Aggregator
+{
+
+enum RemoteMachineStatus : uint8_t
+{
+    Disconnected = 0,
+
+    Connecting,
+
+    Connected
+};
+
+
+struct RemoteMachine
+{
+    RemoteMachine();
+
+    std::string m_address;
+
+    std::string m_port;
+
+    Socket::ConnectionID m_connectionID;
+
+    std::atomic<RemoteMachineStatus> m_status;
+};
+
+class AggregatorContext
+{
+public:
+    AggregatorContext(const std::string& p_filePath);
+
+    ~AggregatorContext();
+
+    bool IsInitialized() const;
+
+    const std::vector<std::shared_ptr<RemoteMachine>>& GetRemoteServers() const;
+
+    const std::shared_ptr<AggregatorSettings>& GetSettings() const;
+
+private:
+    std::vector<std::shared_ptr<RemoteMachine>> m_remoteServers;
+
+    std::shared_ptr<AggregatorSettings> m_settings;
+
+    bool m_initialized;
+};
+
+} // namespace Aggregator
+} // namespace AnnService
+
+
+#endif // _SPTAG_AGGREGATOR_AGGREGATORCONTEXT_H_
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Aggregator/AggregatorExecutionContext.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Aggregator/AggregatorExecutionContext.h
new file mode 100644
index 0000000000..12948a218a
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Aggregator/AggregatorExecutionContext.h
@@ -0,0 +1,53 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_AGGREGATOR_AGGREGATOREXECUTIONCONTEXT_H_
+#define _SPTAG_AGGREGATOR_AGGREGATOREXECUTIONCONTEXT_H_
+
+#include "inc/Socket/RemoteSearchQuery.h"
+#include "inc/Socket/Packet.h"
+
+#include <memory>
+#include <atomic>
+
+namespace SPTAG
+{
+namespace Aggregator
+{
+
+typedef std::shared_ptr<Socket::RemoteSearchResult> AggregatorResult;
+
+class AggregatorExecutionContext
+{
+public:
+    AggregatorExecutionContext(std::size_t p_totalServerNumber,
+                               Socket::PacketHeader p_requestHeader);
+
+    ~AggregatorExecutionContext();
+
+    std::size_t GetServerNumber() const;
+
+    AggregatorResult& GetResult(std::size_t p_num);
+
+    const Socket::PacketHeader& GetRequestHeader() const;
+
+    bool IsCompletedAfterFinsh(std::uint32_t p_finishedCount);
+
+private:
+    std::atomic<std::uint32_t> m_unfinishedCount;
+
+    std::vector<AggregatorResult> m_results;
+
+    Socket::PacketHeader m_requestHeader;
+
+};
+
+
+
+
+} // namespace Aggregator
+} // namespace AnnService
+
+
+#endif // _SPTAG_AGGREGATOR_AGGREGATOREXECUTIONCONTEXT_H_
+
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Aggregator/AggregatorService.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Aggregator/AggregatorService.h
new file mode 100644
index 0000000000..4d864aa5f0
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Aggregator/AggregatorService.h
@@ -0,0 +1,88 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_AGGREGATOR_AGGREGATORSERVICE_H_
+#define _SPTAG_AGGREGATOR_AGGREGATORSERVICE_H_
+
+#include "AggregatorContext.h"
+#include "AggregatorExecutionContext.h"
+#include "inc/Socket/Server.h"
+#include "inc/Socket/Client.h"
+#include "inc/Socket/ResourceManager.h"
+
+#include <boost/asio.hpp>
+
+#include <memory>
+#include <vector>
+#include <thread>
+#include <condition_variable>
+
+namespace SPTAG
+{
+namespace Aggregator
+{
+
+class AggregatorService
+{
+public:
+    AggregatorService();
+
+    ~AggregatorService();
+
+    bool Initialize();
+
+    void Run();
+
+private:
+
+    void StartClient();
+
+    void StartListen();
+
+    void WaitForShutdown();
+
+    void ConnectToPendingServers();
+
+    void AddToPendingServers(std::shared_ptr<RemoteMachine> p_remoteServer);
+
+    void SearchRequestHanlder(Socket::ConnectionID p_localConnectionID, Socket::Packet p_packet);
+
+    void SearchResponseHanlder(Socket::ConnectionID p_localConnectionID, Socket::Packet p_packet);
+
+    void AggregateResults(std::shared_ptr<AggregatorExecutionContext> p_exectionContext);
+
+    std::shared_ptr<AggregatorContext> GetContext();
+
+private:
+    typedef std::function<void(Socket::RemoteSearchResult)> AggregatorCallback;
+
+    std::shared_ptr<AggregatorContext> m_aggregatorContext;
+
+    std::shared_ptr<Socket::Server> m_socketServer;
+
+    std::shared_ptr<Socket::Client> m_socketClient;
+
+    bool m_initalized;
+
+    std::unique_ptr<boost::asio::thread_pool> m_threadPool;
+
+    boost::asio::io_context m_ioContext;
+
+    boost::asio::signal_set m_shutdownSignals;
+
+    std::vector<std::shared_ptr<RemoteMachine>> m_pendingConnectServers;
+
+    std::mutex m_pendingConnectServersMutex;
+
+    boost::asio::deadline_timer m_pendingConnectServersTimer;
+
+    Socket::ResourceManager<AggregatorCallback> m_aggregatorCallbackManager;
+};
+
+
+
+} // namespace Aggregator
+} // namespace AnnService
+
+
+#endif // _SPTAG_AGGREGATOR_AGGREGATORSERVICE_H_
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Aggregator/AggregatorSettings.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Aggregator/AggregatorSettings.h
new file mode 100644
index 0000000000..cb1e9fe7f7
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Aggregator/AggregatorSettings.h
@@ -0,0 +1,39 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_AGGREGATOR_AGGREGATORSETTINGS_H_
+#define _SPTAG_AGGREGATOR_AGGREGATORSETTINGS_H_
+
+#include "../Core/Common.h"
+
+#include <string>
+
+namespace SPTAG
+{
+namespace Aggregator
+{
+
+struct AggregatorSettings
+{
+    AggregatorSettings();
+
+    std::string m_listenAddr;
+
+    std::string m_listenPort;
+
+    std::uint32_t m_searchTimeout;
+
+    SizeType m_threadNum;
+
+    SizeType m_socketThreadNum;
+};
+
+
+
+
+} // namespace Aggregator
+} // namespace AnnService
+
+
+#endif // _SPTAG_AGGREGATOR_AGGREGATORSETTINGS_H_
+
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Client/ClientWrapper.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Client/ClientWrapper.h
new file mode 100644
index 0000000000..d96a67061e
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Client/ClientWrapper.h
@@ -0,0 +1,80 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_CLIENT_CLIENTWRAPPER_H_
+#define _SPTAG_CLIENT_CLIENTWRAPPER_H_
+
+#include "inc/Socket/Client.h"
+#include "inc/Socket/RemoteSearchQuery.h"
+#include "inc/Socket/ResourceManager.h"
+#include "Options.h"
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <atomic>
+#include <thread>
+#include <mutex>
+#include <condition_variable>
+#include <functional>
+
+namespace SPTAG
+{
+namespace Client
+{
+
+class ClientWrapper
+{
+public:
+    typedef std::function<void(Socket::RemoteSearchResult)> Callback;
+
+    ClientWrapper(const ClientOptions& p_options);
+
+    ~ClientWrapper();
+
+    void SendQueryAsync(const Socket::RemoteQuery& p_query,
+                        Callback p_callback,
+                        const ClientOptions& p_options);
+
+    void WaitAllFinished();
+
+    bool IsAvailable() const;
+
+private:
+    typedef std::pair<Socket::ConnectionID, Socket::ConnectionID> ConnectionPair;
+
+    Socket::PacketHandlerMapPtr GetHandlerMap();
+
+    void DecreaseUnfnishedJobCount();
+
+    const ConnectionPair& GetConnection();
+
+    void SearchResponseHanlder(Socket::ConnectionID p_localConnectionID, Socket::Packet p_packet);
+
+    void HandleDeadConnection(Socket::ConnectionID p_cid);
+
+private:
+    ClientOptions m_options;
+
+    std::unique_ptr<Socket::Client> m_client;
+
+    std::atomic<std::uint32_t> m_unfinishedJobCount;
+
+    std::atomic_bool m_isWaitingFinish;
+
+    std::condition_variable m_waitingQueue;
+
+    std::mutex m_waitingMutex;
+
+    std::vector<ConnectionPair> m_connections;
+
+    std::atomic<std::uint32_t> m_spinCountOfConnection;
+
+    Socket::ResourceManager<Callback> m_callbackManager;
+};
+
+
+} // namespace Socket
+} // namespace SPTAG
+
+#endif // _SPTAG_CLIENT_OPTIONS_H_
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Client/Options.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Client/Options.h
new file mode 100644
index 0000000000..062061f042
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Client/Options.h
@@ -0,0 +1,42 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_CLIENT_OPTIONS_H_
+#define _SPTAG_CLIENT_OPTIONS_H_
+
+#include "inc/Helper/ArgumentsParser.h"
+
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace SPTAG
+{
+namespace Client
+{
+
+class ClientOptions : public Helper::ArgumentsParser
+{
+public:
+    ClientOptions();
+
+    virtual ~ClientOptions();
+
+    std::string m_serverAddr;
+
+    std::string m_serverPort;
+
+    // in milliseconds.
+    std::uint32_t m_searchTimeout;
+
+    std::uint32_t m_threadNum;
+
+    std::uint32_t m_socketThreadNum;
+
+};
+
+
+} // namespace Socket
+} // namespace SPTAG
+
+#endif // _SPTAG_CLIENT_OPTIONS_H_
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/BKT/Index.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/BKT/Index.h
new file mode 100644
index 0000000000..0722afc1a8
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/BKT/Index.h
@@ -0,0 +1,131 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_BKT_INDEX_H_
+#define _SPTAG_BKT_INDEX_H_
+
+#include "../Common.h"
+#include "../VectorIndex.h"
+
+#include "../Common/CommonUtils.h"
+#include "../Common/DistanceUtils.h"
+#include "../Common/QueryResultSet.h"
+#include "../Common/Dataset.h"
+#include "../Common/WorkSpace.h"
+#include "../Common/WorkSpacePool.h"
+#include "../Common/RelativeNeighborhoodGraph.h"
+#include "../Common/BKTree.h"
+#include "inc/Helper/ConcurrentSet.h"
+#include "inc/Helper/SimpleIniReader.h"
+#include "inc/Helper/StringConvert.h"
+
+#include <functional>
+#include <mutex>
+
+namespace SPTAG
+{
+
+    namespace Helper
+    {
+        class IniReader;
+    }
+
+    namespace BKT
+    {
+        template<typename T>
+        class Index : public VectorIndex
+        {
+        private:
+            // data points
+            COMMON::Dataset<T> m_pSamples;
+        
+            // BKT structures. 
+            COMMON::BKTree m_pTrees;
+
+            // Graph structure
+            COMMON::RelativeNeighborhoodGraph m_pGraph;
+
+            std::string m_sBKTFilename;
+            std::string m_sGraphFilename;
+            std::string m_sDataPointsFilename;
+            std::string m_sDeleteDataPointsFilename;
+
+            std::mutex m_dataAddLock; // protect data and graph
+            Helper::Concurrent::ConcurrentSet<SizeType> m_deletedID;
+            float m_fDeletePercentageForRefine;
+            std::unique_ptr<COMMON::WorkSpacePool> m_workSpacePool;
+
+            int m_iNumberOfThreads;
+            DistCalcMethod m_iDistCalcMethod;
+            float(*m_fComputeDistance)(const T* pX, const T* pY, DimensionType length);
+        
+            int m_iMaxCheck;        
+            int m_iThresholdOfNumberOfContinuousNoBetterPropagation;
+            int m_iNumberOfInitialDynamicPivots;
+            int m_iNumberOfOtherDynamicPivots;
+        public:
+            Index()
+            {
+#define DefineBKTParameter(VarName, VarType, DefaultValue, RepresentStr) \
+                VarName = DefaultValue; \
+
+#include "inc/Core/BKT/ParameterDefinitionList.h"
+#undef DefineBKTParameter
+
+                m_pSamples.SetName("Vector");
+                m_fComputeDistance = COMMON::DistanceCalcSelector<T>(m_iDistCalcMethod);
+            }
+
+            ~Index() {}
+
+            inline SizeType GetNumSamples() const { return m_pSamples.R(); }
+            inline DimensionType GetFeatureDim() const { return m_pSamples.C(); }
+        
+            inline int GetCurrMaxCheck() const { return m_iMaxCheck; }
+            inline int GetNumThreads() const { return m_iNumberOfThreads; }
+            inline DistCalcMethod GetDistCalcMethod() const { return m_iDistCalcMethod; }
+            inline IndexAlgoType GetIndexAlgoType() const { return IndexAlgoType::BKT; }
+            inline VectorValueType GetVectorValueType() const { return GetEnumValueType<T>(); }
+            
+            inline float ComputeDistance(const void* pX, const void* pY) const { return m_fComputeDistance((const T*)pX, (const T*)pY, m_pSamples.C()); }
+            inline const void* GetSample(const SizeType idx) const { return (void*)m_pSamples[idx]; }
+            inline bool ContainSample(const SizeType idx) const { return !m_deletedID.contains(idx); }
+            inline bool NeedRefine() const { return m_deletedID.size() >= (size_t)(GetNumSamples() * m_fDeletePercentageForRefine); }
+            std::shared_ptr<std::vector<std::uint64_t>> BufferSize() const
+            {
+                std::shared_ptr<std::vector<std::uint64_t>> buffersize(new std::vector<std::uint64_t>);
+                buffersize->push_back(m_pSamples.BufferSize());
+                buffersize->push_back(m_pTrees.BufferSize());
+                buffersize->push_back(m_pGraph.BufferSize());
+                buffersize->push_back(m_deletedID.bufferSize());
+                return std::move(buffersize);
+            }
+
+            ErrorCode SaveConfig(std::ostream& p_configout) const;
+            ErrorCode SaveIndexData(const std::string& p_folderPath);
+            ErrorCode SaveIndexData(const std::vector<std::ostream*>& p_indexStreams);
+
+            ErrorCode LoadConfig(Helper::IniReader& p_reader);
+            ErrorCode LoadIndexData(const std::string& p_folderPath);
+            ErrorCode LoadIndexDataFromMemory(const std::vector<ByteArray>& p_indexBlobs);
+
+            ErrorCode BuildIndex(const void* p_data, SizeType p_vectorNum, DimensionType p_dimension);
+            ErrorCode SearchIndex(QueryResult &p_query) const;
+            ErrorCode AddIndex(const void* p_vectors, SizeType p_vectorNum, DimensionType p_dimension, SizeType* p_start = nullptr);
+            ErrorCode DeleteIndex(const void* p_vectors, SizeType p_vectorNum);
+            ErrorCode DeleteIndex(const SizeType& p_id);
+
+            ErrorCode SetParameter(const char* p_param, const char* p_value);
+            std::string GetParameter(const char* p_param) const;
+
+            ErrorCode RefineIndex(const std::string& p_folderPath);
+            ErrorCode RefineIndex(const std::vector<std::ostream*>& p_indexStreams);
+
+        private:
+            void SearchIndexWithDeleted(COMMON::QueryResultSet<T> &p_query, COMMON::WorkSpace &p_space, const Helper::Concurrent::ConcurrentSet<SizeType> &p_deleted) const;
+            void SearchIndexWithoutDeleted(COMMON::QueryResultSet<T> &p_query, COMMON::WorkSpace &p_space) const;
+        };
+    } // namespace BKT
+} // namespace SPTAG
+
+#endif // _SPTAG_BKT_INDEX_H_
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/BKT/ParameterDefinitionList.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/BKT/ParameterDefinitionList.h
new file mode 100644
index 0000000000..3f6f9e0222
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/BKT/ParameterDefinitionList.h
@@ -0,0 +1,38 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifdef DefineBKTParameter
+
+// DefineBKTParameter(VarName, VarType, DefaultValue, RepresentStr)
+DefineBKTParameter(m_sBKTFilename, std::string, std::string("tree.bin"), "TreeFilePath")
+DefineBKTParameter(m_sGraphFilename, std::string, std::string("graph.bin"), "GraphFilePath")
+DefineBKTParameter(m_sDataPointsFilename, std::string, std::string("vectors.bin"), "VectorFilePath")
+DefineBKTParameter(m_sDeleteDataPointsFilename, std::string, std::string("deletes.bin"), "DeleteVectorFilePath")
+
+DefineBKTParameter(m_pTrees.m_iTreeNumber, int, 1L, "BKTNumber")
+DefineBKTParameter(m_pTrees.m_iBKTKmeansK, int, 32L, "BKTKmeansK")
+DefineBKTParameter(m_pTrees.m_iBKTLeafSize, int, 8L, "BKTLeafSize")
+DefineBKTParameter(m_pTrees.m_iSamples, int, 1000L, "Samples")
+
+
+DefineBKTParameter(m_pGraph.m_iTPTNumber, int, 32L, "TPTNumber")
+DefineBKTParameter(m_pGraph.m_iTPTLeafSize, int, 2000L, "TPTLeafSize")
+DefineBKTParameter(m_pGraph.m_numTopDimensionTPTSplit, int, 5L, "NumTopDimensionTpTreeSplit")
+
+DefineBKTParameter(m_pGraph.m_iNeighborhoodSize, DimensionType, 32L, "NeighborhoodSize")
+DefineBKTParameter(m_pGraph.m_iNeighborhoodScale, int, 2L, "GraphNeighborhoodScale")
+DefineBKTParameter(m_pGraph.m_iCEFScale, int, 2L, "GraphCEFScale")
+DefineBKTParameter(m_pGraph.m_iRefineIter, int, 0L, "RefineIterations")
+DefineBKTParameter(m_pGraph.m_iCEF, int, 1000L, "CEF")
+DefineBKTParameter(m_pGraph.m_iMaxCheckForRefineGraph, int, 10000L, "MaxCheckForRefineGraph")
+
+DefineBKTParameter(m_iNumberOfThreads, int, 1L, "NumberOfThreads")
+DefineBKTParameter(m_iDistCalcMethod, SPTAG::DistCalcMethod, SPTAG::DistCalcMethod::Cosine, "DistCalcMethod")
+
+DefineBKTParameter(m_fDeletePercentageForRefine, float, 0.4F, "DeletePercentageForRefine")
+DefineBKTParameter(m_iMaxCheck, int, 8192L, "MaxCheck")
+DefineBKTParameter(m_iThresholdOfNumberOfContinuousNoBetterPropagation, int, 3L, "ThresholdOfNumberOfContinuousNoBetterPropagation")
+DefineBKTParameter(m_iNumberOfInitialDynamicPivots, int, 50L, "NumberOfInitialDynamicPivots")
+DefineBKTParameter(m_iNumberOfOtherDynamicPivots, int, 4L, "NumberOfOtherDynamicPivots")
+
+#endif
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/Common.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/Common.h
new file mode 100644
index 0000000000..02182a4bf2
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/Common.h
@@ -0,0 +1,162 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_CORE_COMMONDEFS_H_
+#define _SPTAG_CORE_COMMONDEFS_H_
+
+#include <cstdint>
+#include <type_traits>
+#include <memory>
+#include <string>
+#include <limits>
+#include <vector>
+#include <cmath>
+
+#ifndef _MSC_VER
+#include <sys/stat.h>
+#include <sys/types.h>
+#define FolderSep '/'
+#define mkdir(a) mkdir(a, ACCESSPERMS)
+inline bool direxists(const char* path) {
+    struct stat info;
+    return stat(path, &info) == 0 && (info.st_mode & S_IFDIR);
+}
+inline bool fileexists(const char* path) {
+    struct stat info;
+    return stat(path, &info) == 0 && (info.st_mode & S_IFDIR) == 0;
+}
+template <class T>
+inline T min(T a, T b) {
+    return a < b ? a : b;
+}
+template <class T>
+inline T max(T a, T b) {
+    return a > b ? a : b;
+}
+
+#ifndef _rotl
+#define _rotl(x, n) (((x) << (n)) | ((x) >> (32-(n))))
+#endif
+
+#else
+#define WIN32_LEAN_AND_MEAN
+#include <Windows.h>
+#include <Psapi.h>
+#define FolderSep '\\'
+#define mkdir(a) CreateDirectory(a, NULL)
+inline bool direxists(const char* path) {
+    auto dwAttr = GetFileAttributes((LPCSTR)path);
+    return (dwAttr != INVALID_FILE_ATTRIBUTES) && (dwAttr & FILE_ATTRIBUTE_DIRECTORY);
+}
+inline bool fileexists(const char* path) {
+    auto dwAttr = GetFileAttributes((LPCSTR)path);
+    return (dwAttr != INVALID_FILE_ATTRIBUTES) && (dwAttr & FILE_ATTRIBUTE_DIRECTORY) == 0;
+}
+#endif
+
+namespace SPTAG
+{
+typedef std::int32_t SizeType;
+typedef std::int32_t DimensionType;
+
+const SizeType MaxSize = (std::numeric_limits<SizeType>::max)();
+const float MinDist = (std::numeric_limits<float>::min)();
+const float MaxDist = (std::numeric_limits<float>::max)();
+const float Epsilon = 0.000000001f;
+
+class MyException : public std::exception 
+{
+private:
+    std::string Exp;
+public:
+    MyException(std::string e) { Exp = e; }
+#ifdef _MSC_VER
+    const char* what() const { return Exp.c_str(); }
+#else
+    const char* what() const noexcept { return Exp.c_str(); }
+#endif
+};
+
+enum class ErrorCode : std::uint16_t
+{
+#define DefineErrorCode(Name, Value) Name = Value,
+#include "DefinitionList.h"
+#undef DefineErrorCode
+
+    Undefined
+};
+static_assert(static_cast<std::uint16_t>(ErrorCode::Undefined) != 0, "Empty ErrorCode!");
+
+
+enum class DistCalcMethod : std::uint8_t
+{
+#define DefineDistCalcMethod(Name) Name,
+#include "DefinitionList.h"
+#undef DefineDistCalcMethod
+
+    Undefined
+};
+static_assert(static_cast<std::uint8_t>(DistCalcMethod::Undefined) != 0, "Empty DistCalcMethod!");
+
+
+enum class VectorValueType : std::uint8_t
+{
+#define DefineVectorValueType(Name, Type) Name,
+#include "DefinitionList.h"
+#undef DefineVectorValueType
+
+    Undefined
+};
+static_assert(static_cast<std::uint8_t>(VectorValueType::Undefined) != 0, "Empty VectorValueType!");
+
+
+enum class IndexAlgoType : std::uint8_t
+{
+#define DefineIndexAlgo(Name) Name,
+#include "DefinitionList.h"
+#undef DefineIndexAlgo
+
+    Undefined
+};
+static_assert(static_cast<std::uint8_t>(IndexAlgoType::Undefined) != 0, "Empty IndexAlgoType!");
+
+
+template<typename T>
+constexpr VectorValueType GetEnumValueType()
+{
+    return VectorValueType::Undefined;
+}
+
+
+#define DefineVectorValueType(Name, Type) \
+template<> \
+constexpr VectorValueType GetEnumValueType<Type>() \
+{ \
+    return VectorValueType::Name; \
+} \
+
+#include "DefinitionList.h"
+#undef DefineVectorValueType
+
+
+inline std::size_t GetValueTypeSize(VectorValueType p_valueType)
+{
+    switch (p_valueType)
+    {
+#define DefineVectorValueType(Name, Type) \
+    case VectorValueType::Name: \
+        return sizeof(Type); \
+
+#include "DefinitionList.h"
+#undef DefineVectorValueType
+
+    default:
+        break;
+    }
+
+    return 0;
+}
+
+} // namespace SPTAG
+
+#endif // _SPTAG_CORE_COMMONDEFS_H_
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/Common/BKTree.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/Common/BKTree.h
new file mode 100644
index 0000000000..56583be164
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/Common/BKTree.h
@@ -0,0 +1,490 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_COMMON_BKTREE_H_
+#define _SPTAG_COMMON_BKTREE_H_
+
+#include <iostream>
+#include <stack>
+#include <string>
+#include <vector>
+
+#include "../VectorIndex.h"
+
+#include "CommonUtils.h"
+#include "QueryResultSet.h"
+#include "WorkSpace.h"
+
+#pragma warning(disable:4996)  // 'fopen': This function or variable may be unsafe. Consider using fopen_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details.
+
+namespace SPTAG
+{
+    namespace COMMON
+    {
+        // node type for storing BKT
+        struct BKTNode
+        {
+            SizeType centerid;
+            SizeType childStart;
+            SizeType childEnd;
+
+            BKTNode(SizeType cid = -1) : centerid(cid), childStart(-1), childEnd(-1) {}
+        };
+
+        template <typename T>
+        struct KmeansArgs {
+            int _K;
+            DimensionType _D;
+            int _T;
+            T* centers;
+            SizeType* counts;
+            float* newCenters;
+            SizeType* newCounts;
+            int* label;
+            SizeType* clusterIdx;
+            float* clusterDist;
+            T* newTCenters;
+
+            KmeansArgs(int k, DimensionType dim, SizeType datasize, int threadnum) : _K(k), _D(dim), _T(threadnum) {
+                centers = new T[k * dim];
+                counts = new SizeType[k];
+                newCenters = new float[threadnum * k * dim];
+                newCounts = new SizeType[threadnum * k];
+                label = new int[datasize];
+                clusterIdx = new SizeType[threadnum * k];
+                clusterDist = new float[threadnum * k];
+                newTCenters = new T[k * dim];
+            }
+
+            ~KmeansArgs() {
+                delete[] centers;
+                delete[] counts;
+                delete[] newCenters;
+                delete[] newCounts;
+                delete[] label;
+                delete[] clusterIdx;
+                delete[] clusterDist;
+                delete[] newTCenters;
+            }
+
+            inline void ClearCounts() {
+                memset(newCounts, 0, sizeof(SizeType) * _T * _K);
+            }
+
+            inline void ClearCenters() {
+                memset(newCenters, 0, sizeof(float) * _T * _K * _D);
+            }
+
+            inline void ClearDists(float dist) {
+                for (int i = 0; i < _T * _K; i++) {
+                    clusterIdx[i] = -1;
+                    clusterDist[i] = dist;
+                }
+            }
+
+            void Shuffle(std::vector<SizeType>& indices, SizeType first, SizeType last) {
+                SizeType* pos = new SizeType[_K];
+                pos[0] = first;
+                for (int k = 1; k < _K; k++) pos[k] = pos[k - 1] + newCounts[k - 1];
+
+                for (int k = 0; k < _K; k++) {
+                    if (newCounts[k] == 0) continue;
+                    SizeType i = pos[k];
+                    while (newCounts[k] > 0) {
+                        SizeType swapid = pos[label[i]] + newCounts[label[i]] - 1;
+                        newCounts[label[i]]--;
+                        std::swap(indices[i], indices[swapid]);
+                        std::swap(label[i], label[swapid]);
+                    }
+                    while (indices[i] != clusterIdx[k]) i++;
+                    std::swap(indices[i], indices[pos[k] + counts[k] - 1]);
+                }
+                delete[] pos;
+            }
+        };
+
+        class BKTree
+        {
+        public:
+            BKTree(): m_iTreeNumber(1), m_iBKTKmeansK(32), m_iBKTLeafSize(8), m_iSamples(1000) {}
+            
+            BKTree(BKTree& other): m_iTreeNumber(other.m_iTreeNumber), 
+                                   m_iBKTKmeansK(other.m_iBKTKmeansK), 
+                                   m_iBKTLeafSize(other.m_iBKTLeafSize),
+                                   m_iSamples(other.m_iSamples) {}
+            ~BKTree() {}
+
+            inline const BKTNode& operator[](SizeType index) const { return m_pTreeRoots[index]; }
+            inline BKTNode& operator[](SizeType index) { return m_pTreeRoots[index]; }
+
+            inline SizeType size() const { return (SizeType)m_pTreeRoots.size(); }
+
+            inline const std::unordered_map<SizeType, SizeType>& GetSampleMap() const { return m_pSampleCenterMap; }
+
+            template <typename T>
+            void BuildTrees(VectorIndex* index, std::vector<SizeType>* indices = nullptr)
+            {
+                struct  BKTStackItem {
+                    SizeType index, first, last;
+                    BKTStackItem(SizeType index_, SizeType first_, SizeType last_) : index(index_), first(first_), last(last_) {}
+                };
+                std::stack<BKTStackItem> ss;
+
+                std::vector<SizeType> localindices;
+                if (indices == nullptr) {
+                    localindices.resize(index->GetNumSamples());
+                    for (SizeType i = 0; i < index->GetNumSamples(); i++) localindices[i] = i;
+                }
+                else {
+                    localindices.assign(indices->begin(), indices->end());
+                }
+                KmeansArgs<T> args(m_iBKTKmeansK, index->GetFeatureDim(), (SizeType)localindices.size(), omp_get_num_threads());
+
+                m_pSampleCenterMap.clear();
+                for (char i = 0; i < m_iTreeNumber; i++)
+                {
+                    std::random_shuffle(localindices.begin(), localindices.end());
+
+                    m_pTreeStart.push_back((SizeType)m_pTreeRoots.size());
+                    m_pTreeRoots.push_back(BKTNode((SizeType)localindices.size()));
+                    std::cout << "Start to build BKTree " << i + 1 << std::endl;
+
+                    ss.push(BKTStackItem(m_pTreeStart[i], 0, (SizeType)localindices.size()));
+                    while (!ss.empty()) {
+                        BKTStackItem item = ss.top(); ss.pop();
+                        SizeType newBKTid = (SizeType)m_pTreeRoots.size();
+                        m_pTreeRoots[item.index].childStart = newBKTid;
+                        if (item.last - item.first <= m_iBKTLeafSize) {
+                            for (SizeType j = item.first; j < item.last; j++) {
+                                m_pTreeRoots.push_back(BKTNode(localindices[j]));
+                            }
+                        }
+                        else { // clustering the data into BKTKmeansK clusters
+                            int numClusters = KmeansClustering(index, localindices, item.first, item.last, args);
+                            if (numClusters <= 1) {
+                                SizeType end = min(item.last + 1, (SizeType)localindices.size());
+                                std::sort(localindices.begin() + item.first, localindices.begin() + end);
+                                m_pTreeRoots[item.index].centerid = localindices[item.first];
+                                m_pTreeRoots[item.index].childStart = -m_pTreeRoots[item.index].childStart;
+                                for (SizeType j = item.first + 1; j < end; j++) {
+                                    m_pTreeRoots.push_back(BKTNode(localindices[j]));
+                                    m_pSampleCenterMap[localindices[j]] = m_pTreeRoots[item.index].centerid;
+                                }
+                                m_pSampleCenterMap[-1 - m_pTreeRoots[item.index].centerid] = item.index;
+                            }
+                            else {
+                                for (int k = 0; k < m_iBKTKmeansK; k++) {
+                                    if (args.counts[k] == 0) continue;
+                                    m_pTreeRoots.push_back(BKTNode(localindices[item.first + args.counts[k] - 1]));
+                                    if (args.counts[k] > 1) ss.push(BKTStackItem(newBKTid++, item.first, item.first + args.counts[k] - 1));
+                                    item.first += args.counts[k];
+                                }
+                            }
+                        }
+                        m_pTreeRoots[item.index].childEnd = (SizeType)m_pTreeRoots.size();
+                    }
+                    std::cout << i + 1 << " BKTree built, " << m_pTreeRoots.size() - m_pTreeStart[i] << " " << localindices.size() << std::endl;
+                }
+            }
+
+            inline std::uint64_t BufferSize() const
+            {
+                return sizeof(int) + sizeof(SizeType) * m_iTreeNumber +
+                    sizeof(SizeType) + sizeof(BKTNode) * m_pTreeRoots.size();
+            }
+
+            bool SaveTrees(std::ostream& p_outstream) const
+            {
+                p_outstream.write((char*)&m_iTreeNumber, sizeof(int));
+                p_outstream.write((char*)m_pTreeStart.data(), sizeof(SizeType) * m_iTreeNumber);
+                SizeType treeNodeSize = (SizeType)m_pTreeRoots.size();
+                p_outstream.write((char*)&treeNodeSize, sizeof(SizeType));
+                p_outstream.write((char*)m_pTreeRoots.data(), sizeof(BKTNode) * treeNodeSize);
+                std::cout << "Save BKT (" << m_iTreeNumber << "," << treeNodeSize << ") Finish!" << std::endl;
+                return true;
+            }
+
+            bool SaveTrees(std::string sTreeFileName) const
+            {
+                std::cout << "Save BKT to " << sTreeFileName << std::endl;
+                std::ofstream output(sTreeFileName, std::ios::binary);
+                if (!output.is_open()) return false;
+                SaveTrees(output);
+                output.close();
+                return true;
+            }
+
+            bool LoadTrees(char* pBKTMemFile)
+            {
+                m_iTreeNumber = *((int*)pBKTMemFile);
+                pBKTMemFile += sizeof(int);
+                m_pTreeStart.resize(m_iTreeNumber);
+                memcpy(m_pTreeStart.data(), pBKTMemFile, sizeof(SizeType) * m_iTreeNumber);
+                pBKTMemFile += sizeof(SizeType)*m_iTreeNumber;
+
+                SizeType treeNodeSize = *((SizeType*)pBKTMemFile);
+                pBKTMemFile += sizeof(SizeType);
+                m_pTreeRoots.resize(treeNodeSize);
+                memcpy(m_pTreeRoots.data(), pBKTMemFile, sizeof(BKTNode) * treeNodeSize);
+                std::cout << "Load BKT (" << m_iTreeNumber << "," << treeNodeSize << ") Finish!" << std::endl;
+                return true;
+            }
+
+            bool LoadTrees(std::string sTreeFileName)
+            {
+                std::cout << "Load BKT From " << sTreeFileName << std::endl;
+                std::ifstream input(sTreeFileName, std::ios::binary);
+                if (!input.is_open()) return false;
+
+                input.read((char*)&m_iTreeNumber, sizeof(int));
+                m_pTreeStart.resize(m_iTreeNumber);
+                input.read((char*)m_pTreeStart.data(), sizeof(SizeType) * m_iTreeNumber);
+
+                SizeType treeNodeSize;
+                input.read((char*)&treeNodeSize, sizeof(SizeType));
+                m_pTreeRoots.resize(treeNodeSize);
+                input.read((char*)m_pTreeRoots.data(), sizeof(BKTNode) * treeNodeSize);
+                input.close();
+                std::cout << "Load BKT (" << m_iTreeNumber << "," << treeNodeSize << ") Finish!" << std::endl;
+                return true;
+            }
+
+            template <typename T>
+            void InitSearchTrees(const VectorIndex* p_index, const COMMON::QueryResultSet<T> &p_query, COMMON::WorkSpace &p_space) const
+            {
+                for (char i = 0; i < m_iTreeNumber; i++) {
+                    const BKTNode& node = m_pTreeRoots[m_pTreeStart[i]];
+                    if (node.childStart < 0) {
+                        p_space.m_SPTQueue.insert(COMMON::HeapCell(m_pTreeStart[i], p_index->ComputeDistance((const void*)p_query.GetTarget(), p_index->GetSample(node.centerid))));
+                    } 
+                    else {
+                        for (SizeType begin = node.childStart; begin < node.childEnd; begin++) {
+                            SizeType index = m_pTreeRoots[begin].centerid;
+                            p_space.m_SPTQueue.insert(COMMON::HeapCell(begin, p_index->ComputeDistance((const void*)p_query.GetTarget(), p_index->GetSample(index))));
+                        }
+                    } 
+                }
+            }
+
+            template <typename T>
+            void SearchTrees(const VectorIndex* p_index, const COMMON::QueryResultSet<T> &p_query, 
+                COMMON::WorkSpace &p_space, const int p_limits) const
+            {
+                do
+                {
+                    COMMON::HeapCell bcell = p_space.m_SPTQueue.pop();
+                    const BKTNode& tnode = m_pTreeRoots[bcell.node];
+                    if (tnode.childStart < 0) {
+                        if (!p_space.CheckAndSet(tnode.centerid)) {
+                            p_space.m_iNumberOfCheckedLeaves++;
+                            p_space.m_NGQueue.insert(COMMON::HeapCell(tnode.centerid, bcell.distance));
+                        }
+                        if (p_space.m_iNumberOfCheckedLeaves >= p_limits) break;
+                    }
+                    else {
+                        if (!p_space.CheckAndSet(tnode.centerid)) {
+                            p_space.m_NGQueue.insert(COMMON::HeapCell(tnode.centerid, bcell.distance));
+                        }
+                        for (SizeType begin = tnode.childStart; begin < tnode.childEnd; begin++) {
+                            SizeType index = m_pTreeRoots[begin].centerid;
+                            p_space.m_SPTQueue.insert(COMMON::HeapCell(begin, p_index->ComputeDistance((const void*)p_query.GetTarget(), p_index->GetSample(index))));
+                        } 
+                    }
+                } while (!p_space.m_SPTQueue.empty());
+            }
+
+        private:
+
+            template <typename T>
+            float KmeansAssign(VectorIndex* p_index,
+                               std::vector<SizeType>& indices,
+                               const SizeType first, const SizeType last, KmeansArgs<T>& args, const bool updateCenters) const {
+                float currDist = 0;
+                int threads = omp_get_num_threads();
+                float lambda = (updateCenters) ? COMMON::Utils::GetBase<T>() * COMMON::Utils::GetBase<T>() / (100.0f * (last - first)) : 0.0f;
+                SizeType subsize = (last - first - 1) / threads + 1;
+
+#pragma omp parallel for
+                for (int tid = 0; tid < threads; tid++)
+                {
+                    SizeType istart = first + tid * subsize;
+                    SizeType iend = min(first + (tid + 1) * subsize, last);
+                    SizeType *inewCounts = args.newCounts + tid * m_iBKTKmeansK;
+                    float *inewCenters = args.newCenters + tid * m_iBKTKmeansK * p_index->GetFeatureDim();
+                    SizeType * iclusterIdx = args.clusterIdx + tid * m_iBKTKmeansK;
+                    float * iclusterDist = args.clusterDist + tid * m_iBKTKmeansK;
+                    float idist = 0;
+                    for (SizeType i = istart; i < iend; i++) {
+                        int clusterid = 0;
+                        float smallestDist = MaxDist;
+                        for (int k = 0; k < m_iBKTKmeansK; k++) {
+                            float dist = p_index->ComputeDistance(p_index->GetSample(indices[i]), (const void*)(args.centers + k*p_index->GetFeatureDim())) + lambda*args.counts[k];
+                            if (dist > -MaxDist && dist < smallestDist) {
+                                clusterid = k; smallestDist = dist;
+                            }
+                        }
+                        args.label[i] = clusterid;
+                        inewCounts[clusterid]++;
+                        idist += smallestDist;
+                        if (updateCenters) {
+                            const T* v = (const T*)p_index->GetSample(indices[i]);
+                            float* center = inewCenters + clusterid*p_index->GetFeatureDim();
+                            for (DimensionType j = 0; j < p_index->GetFeatureDim(); j++) center[j] += v[j];
+                            if (smallestDist > iclusterDist[clusterid]) {
+                                iclusterDist[clusterid] = smallestDist;
+                                iclusterIdx[clusterid] = indices[i];
+                            }
+                        }
+                        else {
+                            if (smallestDist <= iclusterDist[clusterid]) {
+                                iclusterDist[clusterid] = smallestDist;
+                                iclusterIdx[clusterid] = indices[i];
+                            }
+                        }
+                    }
+                    COMMON::Utils::atomic_float_add(&currDist, idist);
+                }
+
+                for (int i = 1; i < threads; i++) {
+                    for (int k = 0; k < m_iBKTKmeansK; k++)
+                        args.newCounts[k] += args.newCounts[i*m_iBKTKmeansK + k];
+                }
+
+                if (updateCenters) {
+                    for (int i = 1; i < threads; i++) {
+                        float* currCenter = args.newCenters + i*m_iBKTKmeansK*p_index->GetFeatureDim();
+                        for (size_t j = 0; j < ((size_t)m_iBKTKmeansK) * p_index->GetFeatureDim(); j++) args.newCenters[j] += currCenter[j];
+
+                        for (int k = 0; k < m_iBKTKmeansK; k++) {
+                            if (args.clusterIdx[i*m_iBKTKmeansK + k] != -1 && args.clusterDist[i*m_iBKTKmeansK + k] > args.clusterDist[k]) {
+                                args.clusterDist[k] = args.clusterDist[i*m_iBKTKmeansK + k];
+                                args.clusterIdx[k] = args.clusterIdx[i*m_iBKTKmeansK + k];
+                            }
+                        }
+                    }
+
+                    int maxcluster = -1;
+                    SizeType maxCount = 0;
+                    for (int k = 0; k < m_iBKTKmeansK; k++) {
+                        if (args.newCounts[k] > maxCount && DistanceUtils::ComputeL2Distance((T*)p_index->GetSample(args.clusterIdx[k]), args.centers + k * p_index->GetFeatureDim(), p_index->GetFeatureDim()) > 1e-6)
+                        {
+                            maxcluster = k;
+                            maxCount = args.newCounts[k];
+                        }
+                    }
+
+                    if (maxcluster != -1 && (args.clusterIdx[maxcluster] < 0 || args.clusterIdx[maxcluster] >= p_index->GetNumSamples()))
+                        std::cout << "first:" << first << " last:" << last << " maxcluster:" << maxcluster << "(" << args.newCounts[maxcluster] << ") Error dist:" << args.clusterDist[maxcluster] << std::endl;
+
+                    for (int k = 0; k < m_iBKTKmeansK; k++) {
+                        T* TCenter = args.newTCenters + k * p_index->GetFeatureDim();
+                        if (args.newCounts[k] == 0) {
+                            if (maxcluster != -1) {
+                                //int nextid = Utils::rand_int(last, first);
+                                //while (args.label[nextid] != maxcluster) nextid = Utils::rand_int(last, first);
+                                SizeType nextid = args.clusterIdx[maxcluster];
+                                std::memcpy(TCenter, p_index->GetSample(nextid), sizeof(T)*p_index->GetFeatureDim());
+                            }
+                            else {
+                                std::memcpy(TCenter, args.centers + k * p_index->GetFeatureDim(), sizeof(T)*p_index->GetFeatureDim());
+                            }
+                        }
+                        else {
+                            float* currCenters = args.newCenters + k * p_index->GetFeatureDim();
+                            for (DimensionType j = 0; j < p_index->GetFeatureDim(); j++) currCenters[j] /= args.newCounts[k];
+
+                            if (p_index->GetDistCalcMethod() == DistCalcMethod::Cosine) {
+                                COMMON::Utils::Normalize(currCenters, p_index->GetFeatureDim(), COMMON::Utils::GetBase<T>());
+                            }
+                            for (DimensionType j = 0; j < p_index->GetFeatureDim(); j++) TCenter[j] = (T)(currCenters[j]);
+                        }
+                    }
+                }
+                else {
+                    for (int i = 1; i < threads; i++) {
+                        for (int k = 0; k < m_iBKTKmeansK; k++) {
+                            if (args.clusterIdx[i*m_iBKTKmeansK + k] != -1 && args.clusterDist[i*m_iBKTKmeansK + k] <= args.clusterDist[k]) {
+                                args.clusterDist[k] = args.clusterDist[i*m_iBKTKmeansK + k];
+                                args.clusterIdx[k] = args.clusterIdx[i*m_iBKTKmeansK + k];
+                            }
+                        }
+                    }
+                }
+                return currDist;
+            }
+
+            template <typename T>
+            int KmeansClustering(VectorIndex* p_index, 
+                std::vector<SizeType>& indices, const SizeType first, const SizeType last, KmeansArgs<T>& args) const {
+                int iterLimit = 100;
+
+                SizeType batchEnd = min(first + m_iSamples, last);
+                float currDiff, currDist, minClusterDist = MaxDist;
+                for (int numKmeans = 0; numKmeans < 3; numKmeans++) {
+                    for (int k = 0; k < m_iBKTKmeansK; k++) {
+                        SizeType randid = COMMON::Utils::rand(last, first);
+                        std::memcpy(args.centers + k*p_index->GetFeatureDim(), p_index->GetSample(indices[randid]), sizeof(T)*p_index->GetFeatureDim());
+                    }
+                    args.ClearCounts();
+                    currDist = KmeansAssign(p_index, indices, first, batchEnd, args, false);
+                    if (currDist < minClusterDist) {
+                        minClusterDist = currDist;
+                        memcpy(args.newTCenters, args.centers, sizeof(T)*m_iBKTKmeansK*p_index->GetFeatureDim());
+                        memcpy(args.counts, args.newCounts, sizeof(SizeType) * m_iBKTKmeansK);
+                    }
+                }
+
+                minClusterDist = MaxDist;
+                int noImprovement = 0;
+                for (int iter = 0; iter < iterLimit; iter++) {
+                    std::memcpy(args.centers, args.newTCenters, sizeof(T)*m_iBKTKmeansK*p_index->GetFeatureDim());
+                    std::random_shuffle(indices.begin() + first, indices.begin() + last);
+
+                    args.ClearCenters();
+                    args.ClearCounts();
+                    args.ClearDists(-MaxDist);
+                    currDist = KmeansAssign(p_index, indices, first, batchEnd, args, true);
+                    memcpy(args.counts, args.newCounts, sizeof(SizeType) * m_iBKTKmeansK);
+
+                    currDiff = 0;
+                    for (int k = 0; k < m_iBKTKmeansK; k++) {
+                        currDiff += p_index->ComputeDistance((const void*)(args.centers + k*p_index->GetFeatureDim()), (const void*)(args.newTCenters + k*p_index->GetFeatureDim()));
+                    }
+
+                    if (currDist < minClusterDist) {
+                        noImprovement = 0;
+                        minClusterDist = currDist;
+                    }
+                    else {
+                        noImprovement++;
+                    }
+                    if (currDiff < 1e-3 || noImprovement >= 5) break;
+                }
+
+                args.ClearCounts();
+                args.ClearDists(MaxDist);
+                currDist = KmeansAssign(p_index, indices, first, last, args, false);
+                memcpy(args.counts, args.newCounts, sizeof(SizeType) * m_iBKTKmeansK);
+
+                int numClusters = 0;
+                for (int i = 0; i < m_iBKTKmeansK; i++) if (args.counts[i] > 0) numClusters++;
+
+                if (numClusters <= 1) {
+                    //if (last - first > 1) std::cout << "large cluster:" << last - first << " dist:" << currDist << std::endl;
+                    return numClusters;
+                }
+                args.Shuffle(indices, first, last);
+                return numClusters;
+            }
+
+        private:
+            std::vector<SizeType> m_pTreeStart;
+            std::vector<BKTNode> m_pTreeRoots;
+            std::unordered_map<SizeType, SizeType> m_pSampleCenterMap;
+
+        public:
+            int m_iTreeNumber, m_iBKTKmeansK, m_iBKTLeafSize, m_iSamples;
+        };
+    }
+}
+#endif
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/Common/CommonUtils.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/Common/CommonUtils.h
new file mode 100644
index 0000000000..4bc8fbb60f
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/Common/CommonUtils.h
@@ -0,0 +1,178 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_COMMON_COMMONUTILS_H_
+#define _SPTAG_COMMON_COMMONUTILS_H_
+
+#include "../Common.h"
+
+#include <unordered_map>
+
+#include <fstream>
+#include <iostream>
+#include <exception>
+#include <algorithm>
+
+#include <time.h>
+#include <omp.h>
+#include <string.h>
+
+#define PREFETCH
+
+#ifndef _MSC_VER
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/resource.h>
+#include <cstring>
+
+#define InterlockedCompareExchange(a,b,c) __sync_val_compare_and_swap(a, c, b)
+#define Sleep(a) usleep(a * 1000)
+#define strtok_s(a, b, c) strtok_r(a, b, c)
+#endif
+
+namespace SPTAG
+{
+    namespace COMMON
+    {
+        class Utils {
+        public:
+            static SizeType rand(SizeType high = MaxSize, SizeType low = 0)   // Generates a random int value.
+            {
+                return low + (SizeType)(float(high - low)*(std::rand() / (RAND_MAX + 1.0)));
+            }
+
+            static inline float atomic_float_add(volatile float* ptr, const float operand)
+            {
+                union {
+                    volatile long iOld;
+                    float fOld;
+                };
+                union {
+                    long iNew;
+                    float fNew;
+                };
+
+                while (true) {
+                    iOld = *(volatile long *)ptr;
+                    fNew = fOld + operand;
+                    if (InterlockedCompareExchange((long *)ptr, iNew, iOld) == iOld) {
+                        return fNew;
+                    }
+                }
+            }
+
+            static double GetVector(char* cstr, const char* sep, std::vector<float>& arr, DimensionType& NumDim) {
+                char* current;
+                char* context = NULL;
+
+                DimensionType i = 0;
+                double sum = 0;
+                arr.clear();
+                current = strtok_s(cstr, sep, &context);
+                while (current != NULL && (i < NumDim || NumDim < 0)) {
+                    try {
+                        float val = (float)atof(current);
+                        arr.push_back(val);
+                    }
+                    catch (std::exception e) {
+                        std::cout << "Exception:" << e.what() << std::endl;
+                        return -2;
+                    }
+
+                    sum += arr[i] * arr[i];
+                    current = strtok_s(NULL, sep, &context);
+                    i++;
+                }
+
+                if (NumDim < 0) NumDim = i;
+                if (i < NumDim) return -2;
+                return std::sqrt(sum);
+            }
+
+            template <typename T>
+            static void Normalize(T* arr, DimensionType col, int base) {
+                double vecLen = 0;
+                for (DimensionType j = 0; j < col; j++) {
+                    double val = arr[j];
+                    vecLen += val * val;
+                }
+                vecLen = std::sqrt(vecLen);
+                if (vecLen < 1e-6) {
+                    T val = (T)(1.0 / std::sqrt((double)col) * base);
+                    for (DimensionType j = 0; j < col; j++) arr[j] = val;
+                }
+                else {
+                    for (DimensionType j = 0; j < col; j++) arr[j] = (T)(arr[j] / vecLen * base);
+                }
+            }
+
+            static size_t ProcessLine(std::string& currentLine, std::vector<float>& arr, DimensionType& D, int base, DistCalcMethod distCalcMethod) {
+                size_t index;
+                double vecLen;
+                if (currentLine.length() == 0 || (index = currentLine.find_last_of("\t")) == std::string::npos || (vecLen = GetVector(const_cast<char*>(currentLine.c_str() + index + 1), "|", arr, D)) < -1) {
+                    std::cout << "Parse vector error: " + currentLine << std::endl;
+                    //throw MyException("Error in parsing data " + currentLine);
+                    return -1;
+                }
+                if (distCalcMethod == DistCalcMethod::Cosine) {
+                    Normalize(arr.data(), D, base);
+                }
+                return index;
+            }
+
+            template <typename T>
+            static void PrepareQuerys(std::ifstream& inStream, std::vector<std::string>& qString, std::vector<std::vector<T>>& Query, SizeType& NumQuery, DimensionType& NumDim, DistCalcMethod distCalcMethod, int base) {
+                std::string currentLine;
+                std::vector<float> arr;
+                SizeType i = 0;
+                size_t index;
+                while ((NumQuery < 0 || i < NumQuery) && !inStream.eof()) {
+                    std::getline(inStream, currentLine);
+                    if (currentLine.length() <= 1 || (index = ProcessLine(currentLine, arr, NumDim, base, distCalcMethod)) < 0) {
+                        continue;
+                    }
+                    qString.push_back(currentLine.substr(0, index));
+                    if ((SizeType)Query.size() < i + 1) Query.push_back(std::vector<T>(NumDim, 0));
+
+                    for (DimensionType j = 0; j < NumDim; j++) Query[i][j] = (T)arr[j];
+                    i++;
+                }
+                NumQuery = i;
+                std::cout << "Load data: (" << NumQuery << ", " << NumDim << ")" << std::endl;
+            }
+
+            template<typename T>
+            static inline int GetBase() {
+                if (GetEnumValueType<T>() != VectorValueType::Float) {
+                    return (int)(std::numeric_limits<T>::max)();
+                }
+                return 1;
+            }
+
+            static inline void AddNeighbor(SizeType idx, float dist, SizeType *neighbors, float *dists, DimensionType size)
+            {
+                size--;
+                if (dist < dists[size] || (dist == dists[size] && idx < neighbors[size]))
+                {
+                    DimensionType nb;
+                    for (nb = 0; nb <= size && neighbors[nb] != idx; nb++);
+
+                    if (nb > size)
+                    {
+                        nb = size;
+                        while (nb > 0 && (dist < dists[nb - 1] || (dist == dists[nb - 1] && idx < neighbors[nb - 1])))
+                        {
+                            dists[nb] = dists[nb - 1];
+                            neighbors[nb] = neighbors[nb - 1];
+                            nb--;
+                        }
+                        dists[nb] = dist;
+                        neighbors[nb] = idx;
+                    }
+                }
+            }
+        };
+    }
+}
+
+#endif // _SPTAG_COMMON_COMMONUTILS_H_
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/Common/DataUtils.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/Common/DataUtils.h
new file mode 100644
index 0000000000..5d751c4c98
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/Common/DataUtils.h
@@ -0,0 +1,116 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_COMMON_DATAUTILS_H_
+#define _SPTAG_COMMON_DATAUTILS_H_
+
+#include <sys/stat.h>
+#include <atomic>
+#include "CommonUtils.h"
+#include "../../Helper/CommonHelper.h"
+
+namespace SPTAG
+{
+    namespace COMMON
+    {
+        const int bufsize = 1 << 30;
+
+        class DataUtils {
+        public:
+            static bool MergeIndex(const std::string& p_vectorfile1, const std::string& p_metafile1, const std::string& p_metaindexfile1,
+                const std::string& p_vectorfile2, const std::string& p_metafile2, const std::string& p_metaindexfile2) {
+                std::ifstream inputStream1, inputStream2;
+                std::ofstream outputStream;
+                std::unique_ptr<char[]> bufferHolder(new char[bufsize]);
+                char * buf = bufferHolder.get();
+                SizeType R1, R2;
+                DimensionType C1, C2;
+
+#define MergeVector(inputStream, vectorFile, R, C) \
+                inputStream.open(vectorFile, std::ifstream::binary); \
+                if (!inputStream.is_open()) { \
+                    std::cout << "Cannot open vector file: " << vectorFile <<"!" << std::endl; \
+                    return false; \
+                } \
+                inputStream.read((char *)&(R), sizeof(SizeType)); \
+                inputStream.read((char *)&(C), sizeof(DimensionType)); \
+
+                MergeVector(inputStream1, p_vectorfile1, R1, C1)
+                MergeVector(inputStream2, p_vectorfile2, R2, C2)
+#undef MergeVector               
+                if (C1 != C2) {
+                    inputStream1.close(); inputStream2.close();
+                    std::cout << "Vector dimensions are not the same!" << std::endl;
+                    return false;
+                }
+                R1 += R2;
+                outputStream.open(p_vectorfile1 + "_tmp", std::ofstream::binary);
+                outputStream.write((char *)&R1, sizeof(SizeType));
+                outputStream.write((char *)&C1, sizeof(DimensionType));
+                while (!inputStream1.eof()) {
+                    inputStream1.read(buf, bufsize);
+                    outputStream.write(buf, inputStream1.gcount());
+                }
+                while (!inputStream2.eof()) {
+                    inputStream2.read(buf, bufsize);
+                    outputStream.write(buf, inputStream2.gcount());
+                }
+                inputStream1.close(); inputStream2.close();
+                outputStream.close();
+
+                if (p_metafile1 != "" && p_metafile2 != "") {
+                    outputStream.open(p_metafile1 + "_tmp", std::ofstream::binary);
+#define MergeMeta(inputStream, metaFile) \
+                    inputStream.open(metaFile, std::ifstream::binary); \
+                    if (!inputStream.is_open()) { \
+                        std::cout << "Cannot open meta file: " << metaFile << "!" << std::endl; \
+                        return false; \
+                    } \
+                    while (!inputStream.eof()) { \
+                        inputStream.read(buf, bufsize); \
+                        outputStream.write(buf, inputStream.gcount()); \
+                    } \
+                    inputStream.close(); \
+
+                    MergeMeta(inputStream1, p_metafile1)
+                    MergeMeta(inputStream2, p_metafile2)
+#undef MergeMeta
+                    outputStream.close();
+                    delete[] buf;
+
+                    std::uint64_t * offsets = reinterpret_cast<std::uint64_t*>(buf);
+                    std::uint64_t lastoff = 0;
+                    outputStream.open(p_metaindexfile1 + "_tmp", std::ofstream::binary);
+                    outputStream.write((char *)&R1, sizeof(SizeType));
+#define MergeMetaIndex(inputStream, metaIndexFile) \
+                    inputStream.open(metaIndexFile, std::ifstream::binary); \
+                    if (!inputStream.is_open()) { \
+                        std::cout << "Cannot open meta index file: " << metaIndexFile << "!" << std::endl; \
+                        return false; \
+                    } \
+                    inputStream.read((char *)&R2, sizeof(SizeType)); \
+                    inputStream.read((char *)offsets, sizeof(std::uint64_t)*(R2 + 1)); \
+                    inputStream.close(); \
+                    for (SizeType j = 0; j < R2 + 1; j++) offsets[j] += lastoff; \
+                    outputStream.write((char *)offsets, sizeof(std::uint64_t)*R2); \
+                    lastoff = offsets[R2]; \
+
+                    MergeMetaIndex(inputStream1, p_metaindexfile1)
+                    MergeMetaIndex(inputStream2, p_metaindexfile2)
+#undef MergeMetaIndex
+                    outputStream.write((char *)&lastoff, sizeof(std::uint64_t));
+                    outputStream.close();
+                    
+                    rename((p_metafile1 + "_tmp").c_str(), p_metafile1.c_str());
+                    rename((p_metaindexfile1 + "_tmp").c_str(), p_metaindexfile1.c_str());
+                }
+                rename((p_vectorfile1 + "_tmp").c_str(), p_vectorfile1.c_str());
+                
+                std::cout << "Merged -> numSamples:" << R1 << " D:" << C1 << std::endl;
+                return true;
+            }
+        };
+    }
+}
+
+#endif // _SPTAG_COMMON_DATAUTILS_H_
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/Common/Dataset.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/Common/Dataset.h
new file mode 100644
index 0000000000..d00ea45365
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/Common/Dataset.h
@@ -0,0 +1,229 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_COMMON_DATASET_H_
+#define _SPTAG_COMMON_DATASET_H_
+
+#include <fstream>
+
+#if defined(_MSC_VER) || defined(__INTEL_COMPILER)
+#include <malloc.h>
+#else
+#include <mm_malloc.h>
+#endif // defined(__GNUC__)
+
+#define ALIGN 32
+
+#define aligned_malloc(a, b) _mm_malloc(a, b)
+#define aligned_free(a) _mm_free(a)
+
+#pragma warning(disable:4996)  // 'fopen': This function or variable may be unsafe. Consider using fopen_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details.
+
+namespace SPTAG
+{
+    namespace COMMON
+    {
+        // structure to save Data and Graph
+        template <typename T>
+        class Dataset
+        {
+        private:
+            std::string name = "Data";
+            SizeType rows = 0;
+            DimensionType cols = 1;
+            bool ownData = false;
+            T* data = nullptr;
+            SizeType incRows = 0;
+            std::vector<T*> incBlocks;
+            static const SizeType rowsInBlock = 1024 * 1024;
+        public:
+            Dataset()
+            {
+                incBlocks.reserve(MaxSize / rowsInBlock + 1); 
+            }
+            Dataset(SizeType rows_, DimensionType cols_, T* data_ = nullptr, bool transferOnwership_ = true)
+            {
+                Initialize(rows_, cols_, data_, transferOnwership_);
+                incBlocks.reserve(MaxSize / rowsInBlock + 1);
+            }
+            ~Dataset()
+            {
+                if (ownData) aligned_free(data);
+                for (T* ptr : incBlocks) aligned_free(ptr);
+                incBlocks.clear();
+            }
+            void Initialize(SizeType rows_, DimensionType cols_, T* data_ = nullptr, bool transferOnwership_ = true)
+            {
+                rows = rows_;
+                cols = cols_;
+                data = data_;
+                if (data_ == nullptr || !transferOnwership_)
+                {
+                    ownData = true;
+                    data = (T*)aligned_malloc(((size_t)rows) * cols * sizeof(T), ALIGN);
+                    if (data_ != nullptr) memcpy(data, data_, ((size_t)rows) * cols * sizeof(T));
+                    else std::memset(data, -1, ((size_t)rows) * cols * sizeof(T));
+                }
+            }
+            void SetName(const std::string name_) { name = name_; }
+            void SetR(SizeType R_) 
+            {
+                if (R_ >= rows)
+                    incRows = R_ - rows;
+                else 
+                {
+                    rows = R_;
+                    incRows = 0;
+                }
+            }
+            inline SizeType R() const { return rows + incRows; }
+            inline DimensionType C() const { return cols; }
+            inline std::uint64_t BufferSize() const { return sizeof(SizeType) + sizeof(DimensionType) + sizeof(T) * R() * C(); }
+
+            inline const T* At(SizeType index) const
+            {
+                if (index >= rows) {
+                    SizeType incIndex = index - rows;
+                    return incBlocks[incIndex / rowsInBlock] + ((size_t)(incIndex % rowsInBlock)) * cols;
+                }
+                return data + ((size_t)index) * cols;
+            }
+
+            T* operator[](SizeType index)
+            {
+                return (T*)At(index);
+            }
+            
+            const T* operator[](SizeType index) const
+            {
+                return At(index);
+            }
+
+            ErrorCode AddBatch(const T* pData, SizeType num)
+            {
+                if (R() > MaxSize - num) return ErrorCode::MemoryOverFlow;
+
+                SizeType written = 0;
+                while (written < num) {
+                    SizeType curBlockIdx = (incRows + written) / rowsInBlock;
+                    if (curBlockIdx >= (SizeType)incBlocks.size()) {
+                        T* newBlock = (T*)aligned_malloc(((size_t)rowsInBlock) * cols * sizeof(T), ALIGN);
+                        if (newBlock == nullptr) return ErrorCode::MemoryOverFlow;
+                        incBlocks.push_back(newBlock);
+                    }
+                    SizeType curBlockPos = (incRows + written) % rowsInBlock;
+                    SizeType toWrite = min(rowsInBlock - curBlockPos, num - written);
+                    std::memcpy(incBlocks[curBlockIdx] + ((size_t)curBlockPos) * cols, pData + ((size_t)written) * cols, ((size_t)toWrite) * cols * sizeof(T));
+                    written += toWrite;
+                }
+                incRows += written;
+                return ErrorCode::Success;
+            }
+
+            ErrorCode AddBatch(SizeType num)
+            {
+                if (R() > MaxSize - num) return ErrorCode::MemoryOverFlow;
+
+                SizeType written = 0;
+                while (written < num) {
+                    SizeType curBlockIdx = (incRows + written) / rowsInBlock;
+                    if (curBlockIdx >= (SizeType)incBlocks.size()) {
+                        T* newBlock = (T*)aligned_malloc(((size_t)rowsInBlock) * cols * sizeof(T), ALIGN);
+                        if (newBlock == nullptr) return ErrorCode::MemoryOverFlow;
+                        incBlocks.push_back(newBlock);
+                    }
+                    SizeType curBlockPos = (incRows + written) % rowsInBlock;
+                    SizeType toWrite = min(rowsInBlock - curBlockPos, num - written);
+                    std::memset(incBlocks[curBlockIdx] + ((size_t)curBlockPos) * cols, -1, ((size_t)toWrite) * cols * sizeof(T));
+                    written += toWrite;
+                }
+                incRows += written;
+                return ErrorCode::Success;
+            }
+
+            bool Save(std::ostream& p_outstream) const
+            {
+                SizeType CR = R();
+                p_outstream.write((char*)&CR, sizeof(SizeType));
+                p_outstream.write((char*)&cols, sizeof(DimensionType));
+                p_outstream.write((char*)data, sizeof(T) * cols * rows);
+
+                SizeType blocks = incRows / rowsInBlock;
+                for (int i = 0; i < blocks; i++)
+                    p_outstream.write((char*)incBlocks[i], sizeof(T) * cols * rowsInBlock);
+
+                SizeType remain = incRows % rowsInBlock;
+                if (remain > 0) p_outstream.write((char*)incBlocks[blocks], sizeof(T) * cols * remain);
+                std::cout << "Save " << name << " (" << CR << ", " << cols << ") Finish!" << std::endl;
+                return true;
+            }
+
+            bool Save(std::string sDataPointsFileName) const
+            {
+                std::cout << "Save " << name << " To " << sDataPointsFileName << std::endl;
+                std::ofstream output(sDataPointsFileName, std::ios::binary);
+                if (!output.is_open()) return false;
+                Save(output);
+                output.close();
+                return true;
+            }
+
+            bool Load(std::string sDataPointsFileName)
+            {
+                std::cout << "Load " << name << " From " << sDataPointsFileName << std::endl;
+                std::ifstream input(sDataPointsFileName, std::ios::binary);
+                if (!input.is_open()) return false;
+
+                input.read((char*)&rows, sizeof(SizeType));
+                input.read((char*)&cols, sizeof(DimensionType));
+
+                Initialize(rows, cols);
+                input.read((char*)data, sizeof(T) * cols * rows);
+                input.close();
+                std::cout << "Load " << name << " (" << rows << ", " << cols << ") Finish!" << std::endl;
+                return true;
+            }
+
+            // Functions for loading models from memory mapped files
+            bool Load(char* pDataPointsMemFile)
+            {
+                SizeType R;
+                DimensionType C;
+                R = *((SizeType*)pDataPointsMemFile);
+                pDataPointsMemFile += sizeof(SizeType);
+
+                C = *((DimensionType*)pDataPointsMemFile);
+                pDataPointsMemFile += sizeof(DimensionType);
+
+                Initialize(R, C, (T*)pDataPointsMemFile);
+                std::cout << "Load " << name << " (" << R << ", " << C << ") Finish!" << std::endl;
+                return true;
+            }
+
+            bool Refine(const std::vector<SizeType>& indices, std::ostream& output)
+            {
+                SizeType R = (SizeType)(indices.size());
+                output.write((char*)&R, sizeof(SizeType));
+                output.write((char*)&cols, sizeof(DimensionType));
+
+                for (SizeType i = 0; i < R; i++) {
+                    output.write((char*)At(indices[i]), sizeof(T) * cols);
+                }
+                std::cout << "Save Refine " << name << " (" << R << ", " << cols << ") Finish!" << std::endl;
+                return true;
+            }
+
+            bool Refine(const std::vector<SizeType>& indices, std::string sDataPointsFileName)
+            {
+                std::cout << "Save Refine " << name << " To " << sDataPointsFileName << std::endl;
+                std::ofstream output(sDataPointsFileName, std::ios::binary);
+                if (!output.is_open()) return false;
+                Refine(indices, output);
+                output.close();
+                return true;
+            }
+        };
+    }
+}
+
+#endif // _SPTAG_COMMON_DATASET_H_
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/Common/DistanceUtils.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/Common/DistanceUtils.h
new file mode 100644
index 0000000000..8e1d349245
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/Common/DistanceUtils.h
@@ -0,0 +1,610 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_COMMON_DISTANCEUTILS_H_
+#define _SPTAG_COMMON_DISTANCEUTILS_H_
+
+#include <immintrin.h>
+#include <functional>
+
+#include "CommonUtils.h"
+
+#define SSE
+
+#ifndef _MSC_VER
+#define DIFF128 diff128
+#define DIFF256 diff256
+#else
+#define DIFF128 diff128.m128_f32
+#define DIFF256 diff256.m256_f32
+#endif
+
+namespace SPTAG
+{
+    namespace COMMON
+    {
+        class DistanceUtils
+        {
+        public:
+            static inline __m128 _mm_mul_epi8(__m128i X, __m128i Y)
+            {
+                __m128i zero = _mm_setzero_si128();
+
+                __m128i sign_x = _mm_cmplt_epi8(X, zero);
+                __m128i sign_y = _mm_cmplt_epi8(Y, zero);
+
+                __m128i xlo = _mm_unpacklo_epi8(X, sign_x);
+                __m128i xhi = _mm_unpackhi_epi8(X, sign_x);
+                __m128i ylo = _mm_unpacklo_epi8(Y, sign_y);
+                __m128i yhi = _mm_unpackhi_epi8(Y, sign_y);
+                
+                return _mm_cvtepi32_ps(_mm_add_epi32(_mm_madd_epi16(xlo, ylo), _mm_madd_epi16(xhi, yhi)));
+            }
+
+            static inline __m128 _mm_sqdf_epi8(__m128i X, __m128i Y)
+            {
+                __m128i zero = _mm_setzero_si128();
+
+                __m128i sign_x = _mm_cmplt_epi8(X, zero);
+                __m128i sign_y = _mm_cmplt_epi8(Y, zero);
+
+                __m128i xlo = _mm_unpacklo_epi8(X, sign_x);
+                __m128i xhi = _mm_unpackhi_epi8(X, sign_x);
+                __m128i ylo = _mm_unpacklo_epi8(Y, sign_y);
+                __m128i yhi = _mm_unpackhi_epi8(Y, sign_y);
+                
+                __m128i dlo = _mm_sub_epi16(xlo, ylo);
+                __m128i dhi = _mm_sub_epi16(xhi, yhi);
+
+                return _mm_cvtepi32_ps(_mm_add_epi32(_mm_madd_epi16(dlo, dlo), _mm_madd_epi16(dhi, dhi)));
+            }
+
+			static inline __m128 _mm_mul_epu8(__m128i X, __m128i Y)
+			{
+				__m128i zero = _mm_setzero_si128();
+
+				__m128i xlo = _mm_unpacklo_epi8(X, zero);
+				__m128i xhi = _mm_unpackhi_epi8(X, zero);
+				__m128i ylo = _mm_unpacklo_epi8(Y, zero);
+				__m128i yhi = _mm_unpackhi_epi8(Y, zero);
+
+				return _mm_cvtepi32_ps(_mm_add_epi32(_mm_madd_epi16(xlo, ylo), _mm_madd_epi16(xhi, yhi)));
+			}
+
+			static inline __m128 _mm_sqdf_epu8(__m128i X, __m128i Y)
+			{
+				__m128i zero = _mm_setzero_si128();
+
+				__m128i xlo = _mm_unpacklo_epi8(X, zero);
+				__m128i xhi = _mm_unpackhi_epi8(X, zero);
+				__m128i ylo = _mm_unpacklo_epi8(Y, zero);
+				__m128i yhi = _mm_unpackhi_epi8(Y, zero);
+
+				__m128i dlo = _mm_sub_epi16(xlo, ylo);
+				__m128i dhi = _mm_sub_epi16(xhi, yhi);
+
+				return _mm_cvtepi32_ps(_mm_add_epi32(_mm_madd_epi16(dlo, dlo), _mm_madd_epi16(dhi, dhi)));
+			}
+
+            static inline __m128 _mm_mul_epi16(__m128i X, __m128i Y)
+            {
+                return _mm_cvtepi32_ps(_mm_madd_epi16(X, Y));
+            }
+
+            static inline __m128 _mm_sqdf_epi16(__m128i X, __m128i Y)
+            {
+                __m128i zero = _mm_setzero_si128();
+
+                __m128i sign_x = _mm_cmplt_epi16(X, zero);
+                __m128i sign_y = _mm_cmplt_epi16(Y, zero);
+
+                __m128i xlo = _mm_unpacklo_epi16(X, sign_x);
+                __m128i xhi = _mm_unpackhi_epi16(X, sign_x);
+                __m128i ylo = _mm_unpacklo_epi16(Y, sign_y);
+                __m128i yhi = _mm_unpackhi_epi16(Y, sign_y);
+
+                __m128 dlo = _mm_cvtepi32_ps(_mm_sub_epi32(xlo, ylo));
+                __m128 dhi = _mm_cvtepi32_ps(_mm_sub_epi32(xhi, yhi));
+
+                return _mm_add_ps(_mm_mul_ps(dlo, dlo), _mm_mul_ps(dhi, dhi));
+            }
+            static inline __m128 _mm_sqdf_ps(__m128 X, __m128 Y)
+            {
+                __m128 d = _mm_sub_ps(X, Y);
+                return _mm_mul_ps(d, d);
+            }
+#if defined(AVX)
+            static inline __m256 _mm256_mul_epi8(__m256i X, __m256i Y)
+            {
+                __m256i zero = _mm256_setzero_si256();
+
+                __m256i sign_x = _mm256_cmpgt_epi8(zero, X);
+                __m256i sign_y = _mm256_cmpgt_epi8(zero, Y);
+
+                __m256i xlo = _mm256_unpacklo_epi8(X, sign_x);
+                __m256i xhi = _mm256_unpackhi_epi8(X, sign_x);
+                __m256i ylo = _mm256_unpacklo_epi8(Y, sign_y);
+                __m256i yhi = _mm256_unpackhi_epi8(Y, sign_y);
+
+                return _mm256_cvtepi32_ps(_mm256_add_epi32(_mm256_madd_epi16(xlo, ylo), _mm256_madd_epi16(xhi, yhi)));
+            }
+            static inline __m256 _mm256_sqdf_epi8(__m256i X, __m256i Y)
+            {
+                __m256i zero = _mm256_setzero_si256();
+
+                __m256i sign_x = _mm256_cmpgt_epi8(zero, X);
+                __m256i sign_y = _mm256_cmpgt_epi8(zero, Y);
+
+                __m256i xlo = _mm256_unpacklo_epi8(X, sign_x);
+                __m256i xhi = _mm256_unpackhi_epi8(X, sign_x);
+                __m256i ylo = _mm256_unpacklo_epi8(Y, sign_y);
+                __m256i yhi = _mm256_unpackhi_epi8(Y, sign_y);
+
+                __m256i dlo = _mm256_sub_epi16(xlo, ylo);
+                __m256i dhi = _mm256_sub_epi16(xhi, yhi);
+
+                return _mm256_cvtepi32_ps(_mm256_add_epi32(_mm256_madd_epi16(dlo, dlo), _mm256_madd_epi16(dhi, dhi)));
+            }
+			static inline __m256 _mm256_mul_epu8(__m256i X, __m256i Y)
+			{
+				__m256i zero = _mm256_setzero_si256();
+
+				__m256i xlo = _mm256_unpacklo_epi8(X, zero);
+				__m256i xhi = _mm256_unpackhi_epi8(X, zero);
+				__m256i ylo = _mm256_unpacklo_epi8(Y, zero);
+				__m256i yhi = _mm256_unpackhi_epi8(Y, zero);
+
+				return _mm256_cvtepi32_ps(_mm256_add_epi32(_mm256_madd_epi16(xlo, ylo), _mm256_madd_epi16(xhi, yhi)));
+			}
+			static inline __m256 _mm256_sqdf_epu8(__m256i X, __m256i Y)
+			{
+				__m256i zero = _mm256_setzero_si256();
+
+				__m256i xlo = _mm256_unpacklo_epi8(X, zero);
+				__m256i xhi = _mm256_unpackhi_epi8(X, zero);
+				__m256i ylo = _mm256_unpacklo_epi8(Y, zero);
+				__m256i yhi = _mm256_unpackhi_epi8(Y, zero);
+
+				__m256i dlo = _mm256_sub_epi16(xlo, ylo);
+				__m256i dhi = _mm256_sub_epi16(xhi, yhi);
+
+				return _mm256_cvtepi32_ps(_mm256_add_epi32(_mm256_madd_epi16(dlo, dlo), _mm256_madd_epi16(dhi, dhi)));
+			}
+            static inline __m256 _mm256_mul_epi16(__m256i X, __m256i Y)
+            {
+                return _mm256_cvtepi32_ps(_mm256_madd_epi16(X, Y));
+            }
+            static inline __m256 _mm256_sqdf_epi16(__m256i X, __m256i Y)
+            {
+                __m256i zero = _mm256_setzero_si256();
+
+                __m256i sign_x = _mm256_cmpgt_epi16(zero, X);
+                __m256i sign_y = _mm256_cmpgt_epi16(zero, Y);
+
+                __m256i xlo = _mm256_unpacklo_epi16(X, sign_x);
+                __m256i xhi = _mm256_unpackhi_epi16(X, sign_x);
+                __m256i ylo = _mm256_unpacklo_epi16(Y, sign_y);
+                __m256i yhi = _mm256_unpackhi_epi16(Y, sign_y);
+
+                __m256 dlo = _mm256_cvtepi32_ps(_mm256_sub_epi32(xlo, ylo));
+                __m256 dhi = _mm256_cvtepi32_ps(_mm256_sub_epi32(xhi, yhi));
+
+                return _mm256_add_ps(_mm256_mul_ps(dlo, dlo), _mm256_mul_ps(dhi, dhi));
+            }
+            static inline __m256 _mm256_sqdf_ps(__m256 X, __m256 Y)
+            {
+                __m256 d = _mm256_sub_ps(X, Y);
+                return _mm256_mul_ps(d, d);
+            }
+#endif
+/*
+            template<typename T>
+            static float ComputeL2Distance(const T *pX, const T *pY, DimensionType length)
+            {
+                float diff = 0;
+                const T* pEnd1 = pX + length;
+                while (pX < pEnd1) {
+                    float c1 = ((float)(*pX++) - (float)(*pY++)); diff += c1 * c1;
+                }
+                return diff;
+            }
+*/
+#define REPEAT(type, ctype, delta, load, exec, acc, result) \
+            { \
+                type c1 = load((ctype *)(pX)); \
+                type c2 = load((ctype *)(pY)); \
+                pX += delta; pY += delta; \
+                result = acc(result, exec(c1, c2)); \
+            } \
+
+            static float ComputeL2Distance(const std::int8_t *pX, const std::int8_t *pY, DimensionType length)
+            {
+                const std::int8_t* pEnd32 = pX + ((length >> 5) << 5);
+                const std::int8_t* pEnd16 = pX + ((length >> 4) << 4);
+                const std::int8_t* pEnd4 = pX + ((length >> 2) << 2);
+                const std::int8_t* pEnd1 = pX + length;
+#if defined(SSE)
+                __m128 diff128 = _mm_setzero_ps();
+                while (pX < pEnd32) {
+                    REPEAT(__m128i, __m128i, 16, _mm_loadu_si128, _mm_sqdf_epi8, _mm_add_ps, diff128)
+                    REPEAT(__m128i, __m128i, 16, _mm_loadu_si128, _mm_sqdf_epi8, _mm_add_ps, diff128)
+                }
+                while (pX < pEnd16) {
+                    REPEAT(__m128i, __m128i, 16, _mm_loadu_si128, _mm_sqdf_epi8, _mm_add_ps, diff128)
+                }
+                float diff = DIFF128[0] + DIFF128[1] + DIFF128[2] + DIFF128[3];
+#elif defined(AVX)
+                __m256 diff256 = _mm256_setzero_ps();
+                while (pX < pEnd32) {
+                    REPEAT(__m256i, __m256i, 32, _mm256_loadu_si256, _mm256_sqdf_epi8, _mm256_add_ps, diff256)
+                }
+                __m128 diff128 = _mm_add_ps(_mm256_castps256_ps128(diff256), _mm256_extractf128_ps(diff256, 1));
+                while (pX < pEnd16) {
+                    REPEAT(__m128i, __m128i, 16, _mm_loadu_si128, _mm_sqdf_epi8, _mm_add_ps, diff128)
+                }
+                float diff = DIFF128[0] + DIFF128[1] + DIFF128[2] + DIFF128[3];
+#else
+                float diff = 0;
+#endif
+                while (pX < pEnd4) {
+                    float c1 = ((float)(*pX++) - (float)(*pY++)); diff += c1 * c1;
+                    c1 = ((float)(*pX++) - (float)(*pY++)); diff += c1 * c1;
+                    c1 = ((float)(*pX++) - (float)(*pY++)); diff += c1 * c1;
+                    c1 = ((float)(*pX++) - (float)(*pY++)); diff += c1 * c1;
+                }
+                while (pX < pEnd1) {
+                    float c1 = ((float)(*pX++) - (float)(*pY++)); diff += c1 * c1;
+                }
+                return diff;
+            }
+
+			static float ComputeL2Distance(const std::uint8_t *pX, const std::uint8_t *pY, DimensionType length)
+			{
+				const std::uint8_t* pEnd32 = pX + ((length >> 5) << 5);
+				const std::uint8_t* pEnd16 = pX + ((length >> 4) << 4);
+				const std::uint8_t* pEnd4 = pX + ((length >> 2) << 2);
+				const std::uint8_t* pEnd1 = pX + length;
+#if defined(SSE)
+				__m128 diff128 = _mm_setzero_ps();
+				while (pX < pEnd32) {
+					REPEAT(__m128i, __m128i, 16, _mm_loadu_si128, _mm_sqdf_epu8, _mm_add_ps, diff128)
+					REPEAT(__m128i, __m128i, 16, _mm_loadu_si128, _mm_sqdf_epu8, _mm_add_ps, diff128)
+				}
+				while (pX < pEnd16) {
+					REPEAT(__m128i, __m128i, 16, _mm_loadu_si128, _mm_sqdf_epu8, _mm_add_ps, diff128)
+				}
+				float diff = DIFF128[0] + DIFF128[1] + DIFF128[2] + DIFF128[3];
+#elif defined(AVX)
+				__m256 diff256 = _mm256_setzero_ps();
+				while (pX < pEnd32) {
+					REPEAT(__m256i, __m256i, 32, _mm256_loadu_si256, _mm256_sqdf_epu8, _mm256_add_ps, diff256)
+				}
+				__m128 diff128 = _mm_add_ps(_mm256_castps256_ps128(diff256), _mm256_extractf128_ps(diff256, 1));
+				while (pX < pEnd16) {
+					REPEAT(__m128i, __m128i, 16, _mm_loadu_si128, _mm_sqdf_epu8, _mm_add_ps, diff128)
+				}
+				float diff = DIFF128[0] + DIFF128[1] + DIFF128[2] + DIFF128[3];
+#else
+				float diff = 0;
+#endif
+				while (pX < pEnd4) {
+					float c1 = ((float)(*pX++) - (float)(*pY++)); diff += c1 * c1;
+					c1 = ((float)(*pX++) - (float)(*pY++)); diff += c1 * c1;
+					c1 = ((float)(*pX++) - (float)(*pY++)); diff += c1 * c1;
+					c1 = ((float)(*pX++) - (float)(*pY++)); diff += c1 * c1;
+				}
+				while (pX < pEnd1) {
+					float c1 = ((float)(*pX++) - (float)(*pY++)); diff += c1 * c1;
+				}
+				return diff;
+			}
+
+            static float ComputeL2Distance(const std::int16_t *pX, const std::int16_t *pY, DimensionType length)
+            {
+                const std::int16_t* pEnd16 = pX + ((length >> 4) << 4);
+                const std::int16_t* pEnd8 = pX + ((length >> 3) << 3);
+                const std::int16_t* pEnd4 = pX + ((length >> 2) << 2);
+                const std::int16_t* pEnd1 = pX + length;
+#if defined(SSE)
+                __m128 diff128 = _mm_setzero_ps();
+                while (pX < pEnd16) {
+                    REPEAT(__m128i, __m128i, 8, _mm_loadu_si128, _mm_sqdf_epi16, _mm_add_ps, diff128)
+                    REPEAT(__m128i, __m128i, 8, _mm_loadu_si128, _mm_sqdf_epi16, _mm_add_ps, diff128)
+                }
+                while (pX < pEnd8) {
+                    REPEAT(__m128i, __m128i, 8, _mm_loadu_si128, _mm_sqdf_epi16, _mm_add_ps, diff128)
+                }
+                float diff = DIFF128[0] + DIFF128[1] + DIFF128[2] + DIFF128[3];
+#elif defined(AVX)
+                __m256 diff256 = _mm256_setzero_ps();
+                while (pX < pEnd16) {
+                    REPEAT(__m256i, __m256i, 16, _mm256_loadu_si256, _mm256_sqdf_epi16, _mm256_add_ps, diff256)
+                }
+                __m128 diff128 = _mm_add_ps(_mm256_castps256_ps128(diff256), _mm256_extractf128_ps(diff256, 1));
+                while (pX < pEnd8) {
+                    REPEAT(__m128i, __m128i, 8, _mm_loadu_si128, _mm_sqdf_epi16, _mm_add_ps, diff128)
+                }
+                float diff = DIFF128[0] + DIFF128[1] + DIFF128[2] + DIFF128[3];
+#else
+                float diff = 0;
+#endif
+                while (pX < pEnd4) {
+                    float c1 = ((float)(*pX++) - (float)(*pY++)); diff += c1 * c1;
+                    c1 = ((float)(*pX++) - (float)(*pY++)); diff += c1 * c1;
+                    c1 = ((float)(*pX++) - (float)(*pY++)); diff += c1 * c1;
+                    c1 = ((float)(*pX++) - (float)(*pY++)); diff += c1 * c1;
+                }
+
+                while (pX < pEnd1) {
+                    float c1 = ((float)(*pX++) - (float)(*pY++)); diff += c1 * c1;
+                }
+                return diff;
+            }
+
+            static float ComputeL2Distance(const float *pX, const float *pY, DimensionType length)
+            {
+                const float* pEnd16 = pX + ((length >> 4) << 4);
+                const float* pEnd4 = pX + ((length >> 2) << 2);
+                const float* pEnd1 = pX + length;
+#if defined(SSE)
+                __m128 diff128 = _mm_setzero_ps();
+                while (pX < pEnd16)
+                {
+                    REPEAT(__m128, const float, 4, _mm_loadu_ps, _mm_sqdf_ps, _mm_add_ps, diff128)
+                    REPEAT(__m128, const float, 4, _mm_loadu_ps, _mm_sqdf_ps, _mm_add_ps, diff128)
+                    REPEAT(__m128, const float, 4, _mm_loadu_ps, _mm_sqdf_ps, _mm_add_ps, diff128)
+                    REPEAT(__m128, const float, 4, _mm_loadu_ps, _mm_sqdf_ps, _mm_add_ps, diff128)
+                }
+                while (pX < pEnd4)
+                {
+                    REPEAT(__m128, const float, 4, _mm_loadu_ps, _mm_sqdf_ps, _mm_add_ps, diff128)
+                }
+                float diff = DIFF128[0] + DIFF128[1] + DIFF128[2] + DIFF128[3];
+#elif defined(AVX)
+                __m256 diff256 = _mm256_setzero_ps();
+                while (pX < pEnd16)
+                {
+                    REPEAT(__m256, const float, 8, _mm256_loadu_ps, _mm256_sqdf_ps, _mm256_add_ps, diff256)
+                    REPEAT(__m256, const float, 8, _mm256_loadu_ps, _mm256_sqdf_ps, _mm256_add_ps, diff256)
+                }
+                __m128 diff128 = _mm_add_ps(_mm256_castps256_ps128(diff256), _mm256_extractf128_ps(diff256, 1));
+                while (pX < pEnd4)
+                {
+                    REPEAT(__m128, const float, 4, _mm_loadu_ps, _mm_sqdf_ps, _mm_add_ps, diff128)
+                }
+                float diff = DIFF128[0] + DIFF128[1] + DIFF128[2] + DIFF128[3];
+#else
+                float diff = 0;
+                while (pX < pEnd4) {
+                    float c1 = (*pX++) - (*pY++); diff += c1 * c1;
+                    c1 = (*pX++) - (*pY++); diff += c1 * c1;
+                    c1 = (*pX++) - (*pY++); diff += c1 * c1;
+                    c1 = (*pX++) - (*pY++); diff += c1 * c1;
+                }
+#endif
+                while (pX < pEnd1) {
+                    float c1 = (*pX++) - (*pY++); diff += c1 * c1;
+                }
+                return diff;
+            }
+/*
+            template<typename T>
+            static float ComputeCosineDistance(const T *pX, const T *pY, DimensionType length) {
+                float diff = 0;
+                const T* pEnd1 = pX + length;
+                while (pX < pEnd1) diff += (*pX++) * (*pY++);
+                return 1 - diff;
+            }
+*/
+            static float ComputeCosineDistance(const std::int8_t *pX, const std::int8_t *pY, DimensionType length) {
+                const std::int8_t* pEnd32 = pX + ((length >> 5) << 5);
+                const std::int8_t* pEnd16 = pX + ((length >> 4) << 4);
+                const std::int8_t* pEnd4 = pX + ((length >> 2) << 2);
+                const std::int8_t* pEnd1 = pX + length;
+#if defined(SSE)
+
+                __m128 diff128 = _mm_setzero_ps();
+                while (pX < pEnd32) {
+                    REPEAT(__m128i, __m128i, 16, _mm_loadu_si128, _mm_mul_epi8, _mm_add_ps, diff128)
+                    REPEAT(__m128i, __m128i, 16, _mm_loadu_si128, _mm_mul_epi8, _mm_add_ps, diff128)
+                }
+                while (pX < pEnd16) {
+                    REPEAT(__m128i, __m128i, 16, _mm_loadu_si128, _mm_mul_epi8, _mm_add_ps, diff128)
+                }
+                float diff = DIFF128[0] + DIFF128[1] + DIFF128[2] + DIFF128[3];
+#elif defined(AVX)
+                __m256 diff256 = _mm256_setzero_ps();
+                while (pX < pEnd32) {
+                    REPEAT(__m256i, __m256i, 32, _mm256_loadu_si256, _mm256_mul_epi8, _mm256_add_ps, diff256)
+                }
+                __m128 diff128 = _mm_add_ps(_mm256_castps256_ps128(diff256), _mm256_extractf128_ps(diff256, 1));
+                while (pX < pEnd16) {
+                    REPEAT(__m128i, __m128i, 16, _mm_loadu_si128, _mm_mul_epi8, _mm_add_ps, diff128)
+                }
+                float diff = DIFF128[0] + DIFF128[1] + DIFF128[2] + DIFF128[3];
+#else
+                float diff = 0;
+#endif
+                while (pX < pEnd4)
+                {
+                    float c1 = ((float)(*pX++) * (float)(*pY++)); diff += c1;
+                    c1 = ((float)(*pX++) * (float)(*pY++)); diff += c1;
+                    c1 = ((float)(*pX++) * (float)(*pY++)); diff += c1;
+                    c1 = ((float)(*pX++) * (float)(*pY++)); diff += c1;
+                }
+                while (pX < pEnd1) diff += ((float)(*pX++) * (float)(*pY++));
+                return 16129 - diff;
+            }
+
+			static float ComputeCosineDistance(const std::uint8_t *pX, const std::uint8_t *pY, DimensionType length) {
+				const std::uint8_t* pEnd32 = pX + ((length >> 5) << 5);
+				const std::uint8_t* pEnd16 = pX + ((length >> 4) << 4);
+				const std::uint8_t* pEnd4 = pX + ((length >> 2) << 2);
+				const std::uint8_t* pEnd1 = pX + length;
+#if defined(SSE)
+
+				__m128 diff128 = _mm_setzero_ps();
+				while (pX < pEnd32) {
+					REPEAT(__m128i, __m128i, 16, _mm_loadu_si128, _mm_mul_epu8, _mm_add_ps, diff128)
+					REPEAT(__m128i, __m128i, 16, _mm_loadu_si128, _mm_mul_epu8, _mm_add_ps, diff128)
+				}
+				while (pX < pEnd16) {
+					REPEAT(__m128i, __m128i, 16, _mm_loadu_si128, _mm_mul_epu8, _mm_add_ps, diff128)
+				}
+				float diff = DIFF128[0] + DIFF128[1] + DIFF128[2] + DIFF128[3];
+#elif defined(AVX)
+				__m256 diff256 = _mm256_setzero_ps();
+				while (pX < pEnd32) {
+					REPEAT(__m256i, __m256i, 32, _mm256_loadu_si256, _mm256_mul_epu8, _mm256_add_ps, diff256)
+				}
+				__m128 diff128 = _mm_add_ps(_mm256_castps256_ps128(diff256), _mm256_extractf128_ps(diff256, 1));
+				while (pX < pEnd16) {
+					REPEAT(__m128i, __m128i, 16, _mm_loadu_si128, _mm_mul_epu8, _mm_add_ps, diff128)
+				}
+				float diff = DIFF128[0] + DIFF128[1] + DIFF128[2] + DIFF128[3];
+#else
+				float diff = 0;
+#endif
+				while (pX < pEnd4)
+				{
+					float c1 = ((float)(*pX++) * (float)(*pY++)); diff += c1;
+					c1 = ((float)(*pX++) * (float)(*pY++)); diff += c1;
+					c1 = ((float)(*pX++) * (float)(*pY++)); diff += c1;
+					c1 = ((float)(*pX++) * (float)(*pY++)); diff += c1;
+				}
+				while (pX < pEnd1) diff += ((float)(*pX++) * (float)(*pY++));
+				return 65025 - diff;
+			}
+
+	static float ComputeCosineDistance(const std::int16_t *pX, const std::int16_t *pY, DimensionType length) {
+                const std::int16_t* pEnd16 = pX + ((length >> 4) << 4);
+                const std::int16_t* pEnd8 = pX + ((length >> 3) << 3);
+                const std::int16_t* pEnd4 = pX + ((length >> 2) << 2);
+                const std::int16_t* pEnd1 = pX + length;
+#if defined(SSE)
+                __m128 diff128 = _mm_setzero_ps();
+                while (pX < pEnd16) {
+                    REPEAT(__m128i, __m128i, 8, _mm_loadu_si128, _mm_mul_epi16, _mm_add_ps, diff128)
+                    REPEAT(__m128i, __m128i, 8, _mm_loadu_si128, _mm_mul_epi16, _mm_add_ps, diff128)
+                }
+                while (pX < pEnd8) {
+                    REPEAT(__m128i, __m128i, 8, _mm_loadu_si128, _mm_mul_epi16, _mm_add_ps, diff128)
+                }
+                float diff = DIFF128[0] + DIFF128[1] + DIFF128[2] + DIFF128[3];
+
+#elif defined(AVX)
+                __m256 diff256 = _mm256_setzero_ps();
+                while (pX < pEnd16) {
+                    REPEAT(__m256i, __m256i, 16, _mm256_loadu_si256, _mm256_mul_epi16, _mm256_add_ps, diff256)
+                }
+                __m128 diff128 = _mm_add_ps(_mm256_castps256_ps128(diff256), _mm256_extractf128_ps(diff256, 1));
+                while (pX < pEnd8) {
+                    REPEAT(__m128i, __m128i, 8, _mm_loadu_si128, _mm_mul_epi16, _mm_add_ps, diff128)
+                }
+                float diff = DIFF128[0] + DIFF128[1] + DIFF128[2] + DIFF128[3];
+#else
+                float diff = 0;
+#endif
+                while (pX < pEnd4)
+                {
+                    float c1 = ((float)(*pX++) * (float)(*pY++)); diff += c1;
+                    c1 = ((float)(*pX++) * (float)(*pY++)); diff += c1;
+                    c1 = ((float)(*pX++) * (float)(*pY++)); diff += c1;
+                    c1 = ((float)(*pX++) * (float)(*pY++)); diff += c1;
+                }
+
+                while (pX < pEnd1) diff += ((float)(*pX++) * (float)(*pY++));
+                return  1073676289 - diff;
+            }
+
+            static float ComputeCosineDistance(const float *pX, const float *pY, DimensionType length) {
+                const float* pEnd16 = pX + ((length >> 4) << 4);
+                const float* pEnd4 = pX + ((length >> 2) << 2);
+                const float* pEnd1 = pX + length;
+#if defined(SSE)
+                __m128 diff128 = _mm_setzero_ps();
+                while (pX < pEnd16)
+                {
+                    REPEAT(__m128, const float, 4, _mm_loadu_ps, _mm_mul_ps, _mm_add_ps, diff128)
+                    REPEAT(__m128, const float, 4, _mm_loadu_ps, _mm_mul_ps, _mm_add_ps, diff128)
+                    REPEAT(__m128, const float, 4, _mm_loadu_ps, _mm_mul_ps, _mm_add_ps, diff128)
+                    REPEAT(__m128, const float, 4, _mm_loadu_ps, _mm_mul_ps, _mm_add_ps, diff128)
+                }
+                while (pX < pEnd4)
+                {
+                    REPEAT(__m128, const float, 4, _mm_loadu_ps, _mm_mul_ps, _mm_add_ps, diff128)
+                }
+                float diff = DIFF128[0] + DIFF128[1] + DIFF128[2] + DIFF128[3];
+
+#elif defined(AVX)
+                __m256 diff256 = _mm256_setzero_ps();
+                while (pX < pEnd16)
+                {
+                    REPEAT(__m256, const float, 8, _mm256_loadu_ps, _mm256_mul_ps, _mm256_add_ps, diff256)
+                    REPEAT(__m256, const float, 8, _mm256_loadu_ps, _mm256_mul_ps, _mm256_add_ps, diff256)
+                }
+                __m128 diff128 = _mm_add_ps(_mm256_castps256_ps128(diff256), _mm256_extractf128_ps(diff256, 1));
+                while (pX < pEnd4)
+                {
+                    REPEAT(__m128, const float, 4, _mm_loadu_ps, _mm_mul_ps, _mm_add_ps, diff128)
+                }
+                float diff = DIFF128[0] + DIFF128[1] + DIFF128[2] + DIFF128[3];
+#else
+                float diff = 0;
+                while (pX < pEnd4)
+                {
+                    float c1 = (*pX++) * (*pY++); diff += c1;
+                    c1 = (*pX++) * (*pY++); diff += c1;
+                    c1 = (*pX++) * (*pY++); diff += c1;
+                    c1 = (*pX++) * (*pY++); diff += c1;
+                }
+#endif
+                while (pX < pEnd1) diff += (*pX++) * (*pY++);
+                return 1 - diff;
+            }
+
+            template<typename T>
+            static inline float ComputeDistance(const T *p1, const T *p2, DimensionType length, SPTAG::DistCalcMethod distCalcMethod)
+            {
+                if (distCalcMethod == SPTAG::DistCalcMethod::L2)
+                    return ComputeL2Distance(p1, p2, length);
+
+                return ComputeCosineDistance(p1, p2, length);
+            }
+
+            static inline float ConvertCosineSimilarityToDistance(float cs)
+            {
+                // Cosine similarity is in [-1, 1], the higher the value, the closer are the two vectors. 
+                // However, the tree is built and searched based on "distance" between two vectors, that's >=0. The smaller the value, the closer are the two vectors.
+                // So we do a linear conversion from a cosine similarity to a distance value.
+                return 1 - cs; //[1, 3]
+            }
+
+            static inline float ConvertDistanceBackToCosineSimilarity(float d)
+            {
+                return 1 - d;
+            }
+        };
+
+
+        template<typename T>
+        float (*DistanceCalcSelector(SPTAG::DistCalcMethod p_method)) (const T*, const T*, DimensionType)
+        {
+            switch (p_method)
+            {
+            case SPTAG::DistCalcMethod::Cosine:
+                return &(DistanceUtils::ComputeCosineDistance);
+
+            case SPTAG::DistCalcMethod::L2:
+                return &(DistanceUtils::ComputeL2Distance);
+
+            default:
+                break;
+            }
+
+            return nullptr;
+        }
+    }
+}
+
+#endif // _SPTAG_COMMON_DISTANCEUTILS_H_
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/Common/FineGrainedLock.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/Common/FineGrainedLock.h
new file mode 100644
index 0000000000..0de7ed8b36
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/Common/FineGrainedLock.h
@@ -0,0 +1,51 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_COMMON_FINEGRAINEDLOCK_H_
+#define _SPTAG_COMMON_FINEGRAINEDLOCK_H_
+
+#include <vector>
+#include <mutex>
+#include <memory>
+
+namespace SPTAG
+{
+    namespace COMMON
+    {
+        class FineGrainedLock {
+        public:
+            FineGrainedLock() {}
+            ~FineGrainedLock() { 
+                for (size_t i = 0; i < locks.size(); i++)
+                    locks[i].reset();
+                locks.clear();
+            }
+            
+            void resize(SizeType n) {
+                SizeType current = (SizeType)locks.size();
+                if (current <= n) {
+                    locks.resize(n);
+                    for (SizeType i = current; i < n; i++)
+                        locks[i].reset(new std::mutex);
+                }
+                else {
+                    for (SizeType i = n; i < current; i++)
+                        locks[i].reset();
+                    locks.resize(n);
+                }
+            }
+
+            std::mutex& operator[](SizeType idx) {
+                return *locks[idx];
+            }
+
+            const std::mutex& operator[](SizeType idx) const {
+                return *locks[idx];
+            }
+        private:
+            std::vector<std::shared_ptr<std::mutex>> locks;
+        };
+    }
+}
+
+#endif // _SPTAG_COMMON_FINEGRAINEDLOCK_H_
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/Common/Heap.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/Common/Heap.h
new file mode 100644
index 0000000000..261aa498a6
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/Common/Heap.h
@@ -0,0 +1,105 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_COMMON_HEAP_H_
+#define _SPTAG_COMMON_HEAP_H_
+
+namespace SPTAG
+{
+    namespace COMMON
+    {
+
+        // priority queue
+        template <typename T>
+        class Heap {
+        public:
+            Heap() : heap(nullptr), length(0), count(0) {}
+
+            Heap(int size) { Resize(size); }
+
+            void Resize(int size)
+            {
+                length = size;
+                heap.reset(new T[length + 1]);  // heap uses 1-based indexing
+                count = 0;
+                lastlevel = int(pow(2.0, floor(log2(size))));
+            }
+            ~Heap() {}
+            inline int size() { return count; }
+            inline bool empty() { return count == 0; }
+            inline void clear() { count = 0; }
+            inline T& Top() { if (count == 0) return heap[0]; else return heap[1]; }
+
+            // Insert a new element in the heap.
+            void insert(T value)
+            {
+                /* If heap is full, then return without adding this element. */
+                int loc;
+                if (count == length) {
+                    int maxi = lastlevel;
+                    for (int i = lastlevel + 1; i <= length; i++)
+                        if (heap[maxi] < heap[i]) maxi = i;
+                    if (value > heap[maxi]) return;
+                    loc = maxi;
+                }
+                else {
+                    loc = ++(count);   /* Remember 1-based indexing. */
+                }
+                /* Keep moving parents down until a place is found for this node. */
+                int par = (loc >> 1);                 /* Location of parent. */
+                while (par > 0 && value < heap[par]) {
+                    heap[loc] = heap[par];     /* Move parent down to loc. */
+                    loc = par;
+                    par >>= 1;
+                }
+                /* Insert the element at the determined location. */
+                heap[loc] = value;
+            }
+            // Returns the node of minimum value from the heap (top of the heap).
+            bool pop(T& value)
+            {
+                if (count == 0) return false;
+                /* Switch first node with last. */
+                value = heap[1];
+                std::swap(heap[1], heap[count]);
+                count--;
+                heapify();      /* Move new node 1 to right position. */
+                return true;  /* Return old last node. */
+            }
+            T& pop()
+            {
+                if (count == 0) return heap[0];
+                /* Switch first node with last. */
+                std::swap(heap[1], heap[count]);
+                count--;
+                heapify();      /* Move new node 1 to right position. */
+                return heap[count + 1];  /* Return old last node. */
+            }
+        private:
+            // Storage array for the heap.
+            // Type T must be comparable.
+            std::unique_ptr<T[]> heap;
+            int length;
+            int count; // Number of element in the heap
+            int lastlevel;
+            // Reorganizes the heap (a parent is smaller than its children) starting with a node.
+
+            void heapify()
+            {
+                int parent = 1, next = 2;
+                while (next < count) {
+                    if (heap[next] > heap[next + 1]) next++;
+                    if (heap[next] < heap[parent]) {
+                        std::swap(heap[parent], heap[next]);
+                        parent = next;
+                        next <<= 1;
+                    }
+                    else break;
+                }
+                if (next == count && heap[next] < heap[parent]) std::swap(heap[parent], heap[next]);
+            }
+        };
+    }
+}
+
+#endif // _SPTAG_COMMON_HEAP_H_
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/Common/KDTree.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/Common/KDTree.h
new file mode 100644
index 0000000000..e46c133940
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/Common/KDTree.h
@@ -0,0 +1,342 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_COMMON_KDTREE_H_
+#define _SPTAG_COMMON_KDTREE_H_
+
+#include <iostream>
+#include <vector>
+#include <string>
+
+#include "../VectorIndex.h"
+
+#include "CommonUtils.h"
+#include "QueryResultSet.h"
+#include "WorkSpace.h"
+
+#pragma warning(disable:4996)  // 'fopen': This function or variable may be unsafe. Consider using fopen_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details.
+
+namespace SPTAG
+{
+    namespace COMMON
+    {
+        // node type for storing KDT
+        struct KDTNode
+        {
+            SizeType left;
+            SizeType right;
+            DimensionType split_dim;
+            float split_value;
+        };
+
+        class KDTree
+        {
+        public:
+            KDTree() : m_iTreeNumber(2), m_numTopDimensionKDTSplit(5), m_iSamples(1000) {}
+
+            KDTree(KDTree& other) : m_iTreeNumber(other.m_iTreeNumber),
+                m_numTopDimensionKDTSplit(other.m_numTopDimensionKDTSplit),
+                m_iSamples(other.m_iSamples) {}
+            ~KDTree() {}
+
+            inline const KDTNode& operator[](SizeType index) const { return m_pTreeRoots[index]; }
+            inline KDTNode& operator[](SizeType index) { return m_pTreeRoots[index]; }
+
+            inline SizeType size() const { return (SizeType)m_pTreeRoots.size(); }
+
+            template <typename T>
+            void BuildTrees(VectorIndex* p_index, std::vector<SizeType>* indices = nullptr)
+            {
+                std::vector<SizeType> localindices;
+                if (indices == nullptr) {
+                    localindices.resize(p_index->GetNumSamples());
+                    for (SizeType i = 0; i < p_index->GetNumSamples(); i++) localindices[i] = i;
+                }
+                else {
+                    localindices.assign(indices->begin(), indices->end());
+                }
+
+                m_pTreeRoots.resize(m_iTreeNumber * localindices.size());
+                m_pTreeStart.resize(m_iTreeNumber, 0);
+#pragma omp parallel for
+                for (int i = 0; i < m_iTreeNumber; i++)
+                {
+                    Sleep(i * 100); std::srand(clock());
+
+                    std::vector<SizeType> pindices(localindices.begin(), localindices.end());
+                    std::random_shuffle(pindices.begin(), pindices.end());
+
+                    m_pTreeStart[i] = i * (SizeType)pindices.size();
+                    std::cout << "Start to build KDTree " << i + 1 << std::endl;
+                    SizeType iTreeSize = m_pTreeStart[i];
+                    DivideTree<T>(p_index, pindices, 0, (SizeType)pindices.size() - 1, m_pTreeStart[i], iTreeSize);
+                    std::cout << i + 1 << " KDTree built, " << iTreeSize - m_pTreeStart[i] << " " << pindices.size() << std::endl;
+                }
+            }
+
+            inline std::uint64_t BufferSize() const 
+            { 
+                return sizeof(int) + sizeof(SizeType) * m_iTreeNumber + 
+                    sizeof(SizeType) + sizeof(KDTNode) * m_pTreeRoots.size();
+            }
+
+            bool SaveTrees(std::ostream& p_outstream) const
+            {
+                p_outstream.write((char*)&m_iTreeNumber, sizeof(int));
+                p_outstream.write((char*)m_pTreeStart.data(), sizeof(SizeType) * m_iTreeNumber);
+                SizeType treeNodeSize = (SizeType)m_pTreeRoots.size();
+                p_outstream.write((char*)&treeNodeSize, sizeof(SizeType));
+                p_outstream.write((char*)m_pTreeRoots.data(), sizeof(KDTNode) * treeNodeSize);
+                std::cout << "Save KDT (" << m_iTreeNumber << "," << treeNodeSize << ") Finish!" << std::endl;
+                return true;
+            }
+
+            bool SaveTrees(std::string sTreeFileName) const
+            {
+                std::cout << "Save KDT to " << sTreeFileName << std::endl;
+                std::ofstream output(sTreeFileName, std::ios::binary);
+                if (!output.is_open()) return false;
+                SaveTrees(output);
+                output.close();
+                return true;
+            }
+
+            bool LoadTrees(char*  pKDTMemFile)
+            {
+                m_iTreeNumber = *((int*)pKDTMemFile);
+                pKDTMemFile += sizeof(int);
+                m_pTreeStart.resize(m_iTreeNumber);
+                memcpy(m_pTreeStart.data(), pKDTMemFile, sizeof(SizeType) * m_iTreeNumber);
+                pKDTMemFile += sizeof(SizeType)*m_iTreeNumber;
+
+                SizeType treeNodeSize = *((SizeType*)pKDTMemFile);
+                pKDTMemFile += sizeof(SizeType);
+                m_pTreeRoots.resize(treeNodeSize);
+                memcpy(m_pTreeRoots.data(), pKDTMemFile, sizeof(KDTNode) * treeNodeSize);
+                std::cout << "Load KDT (" << m_iTreeNumber << "," << treeNodeSize << ") Finish!" << std::endl;
+                return true;
+            }
+
+            bool LoadTrees(std::string sTreeFileName)
+            {
+                std::cout << "Load KDT From " << sTreeFileName << std::endl;
+                std::ifstream input(sTreeFileName, std::ios::binary);
+                if (!input.is_open()) return false;
+
+                input.read((char*)&m_iTreeNumber, sizeof(int));
+                m_pTreeStart.resize(m_iTreeNumber);
+                input.read((char*)m_pTreeStart.data(), sizeof(SizeType) * m_iTreeNumber);
+
+                SizeType treeNodeSize;
+                input.read((char*)&treeNodeSize, sizeof(SizeType));
+                m_pTreeRoots.resize(treeNodeSize);
+                input.read((char*)m_pTreeRoots.data(), sizeof(KDTNode) * treeNodeSize);
+                input.close();
+                std::cout << "Load KDT (" << m_iTreeNumber << "," << treeNodeSize << ") Finish!" << std::endl;
+                return true;
+            }
+
+            template <typename T>
+            void InitSearchTrees(const VectorIndex* p_index, const COMMON::QueryResultSet<T> &p_query, COMMON::WorkSpace &p_space,  const int p_limits) const
+            {
+                for (int i = 0; i < m_iTreeNumber; i++) {
+                    KDTSearch(p_index, p_query, p_space, m_pTreeStart[i], true, 0);
+                }
+
+                while (!p_space.m_SPTQueue.empty() && p_space.m_iNumberOfCheckedLeaves < p_limits)
+                {
+                    auto& tcell = p_space.m_SPTQueue.pop();
+                    if (p_query.worstDist() < tcell.distance) break;
+                    KDTSearch(p_index, p_query, p_space, tcell.node, true, tcell.distance);
+                }
+            }
+
+            template <typename T>
+            void SearchTrees(const VectorIndex* p_index, const COMMON::QueryResultSet<T> &p_query, COMMON::WorkSpace &p_space, const int p_limits) const
+            {
+                while (!p_space.m_SPTQueue.empty() && p_space.m_iNumberOfCheckedLeaves < p_limits)
+                {
+                    auto& tcell = p_space.m_SPTQueue.pop();
+                    KDTSearch(p_index, p_query, p_space, tcell.node, false, tcell.distance);
+                }
+            }
+
+        private:
+
+            template <typename T>
+            void KDTSearch(const VectorIndex* p_index, const COMMON::QueryResultSet<T> &p_query,
+                           COMMON::WorkSpace& p_space, const SizeType node, const bool isInit, const float distBound) const {
+                if (node < 0)
+                {
+                    SizeType index = -node - 1;
+                    if (index >= p_index->GetNumSamples()) return;
+#ifdef PREFETCH
+                    const char* data = (const char *)(p_index->GetSample(index));
+                    _mm_prefetch(data, _MM_HINT_T0);
+                    _mm_prefetch(data + 64, _MM_HINT_T0);
+#endif
+                    if (p_space.CheckAndSet(index)) return;
+
+                    ++p_space.m_iNumberOfTreeCheckedLeaves;
+                    ++p_space.m_iNumberOfCheckedLeaves;
+                    p_space.m_NGQueue.insert(COMMON::HeapCell(index, p_index->ComputeDistance((const void*)p_query.GetTarget(), (const void*)data)));
+                    return;
+                }
+
+                auto& tnode = m_pTreeRoots[node];
+
+                float diff = (p_query.GetTarget())[tnode.split_dim] - tnode.split_value;
+                float distanceBound = distBound + diff * diff;
+                SizeType otherChild, bestChild;
+                if (diff < 0)
+                {
+                    bestChild = tnode.left;
+                    otherChild = tnode.right;
+                }
+                else
+                {
+                    otherChild = tnode.left;
+                    bestChild = tnode.right;
+                }
+
+                if (!isInit || distanceBound < p_query.worstDist())
+                {
+                    p_space.m_SPTQueue.insert(COMMON::HeapCell(otherChild, distanceBound));
+                }
+                KDTSearch(p_index, p_query, p_space, bestChild, isInit, distBound);
+            }
+
+
+            template <typename T>
+            void DivideTree(VectorIndex* p_index, std::vector<SizeType>& indices, SizeType first, SizeType last,
+                SizeType index, SizeType &iTreeSize) {
+                ChooseDivision<T>(p_index, m_pTreeRoots[index], indices, first, last);
+                SizeType i = Subdivide<T>(p_index, m_pTreeRoots[index], indices, first, last);
+                if (i - 1 <= first)
+                {
+                    m_pTreeRoots[index].left = -indices[first] - 1;
+                }
+                else
+                {
+                    iTreeSize++;
+                    m_pTreeRoots[index].left = iTreeSize;
+                    DivideTree<T>(p_index, indices, first, i - 1, iTreeSize, iTreeSize);
+                }
+                if (last == i)
+                {
+                    m_pTreeRoots[index].right = -indices[last] - 1;
+                }
+                else
+                {
+                    iTreeSize++;
+                    m_pTreeRoots[index].right = iTreeSize;
+                    DivideTree<T>(p_index, indices, i, last, iTreeSize, iTreeSize);
+                }
+            }
+
+            template <typename T>
+            void ChooseDivision(VectorIndex* p_index, KDTNode& node, const std::vector<SizeType>& indices, const SizeType first, const SizeType last)
+            {
+                std::vector<float> meanValues(p_index->GetFeatureDim(), 0);
+                std::vector<float> varianceValues(p_index->GetFeatureDim(), 0);
+                SizeType end = min(first + m_iSamples, last);
+                SizeType count = end - first + 1;
+                // calculate the mean of each dimension
+                for (SizeType j = first; j <= end; j++)
+                {
+                    const T* v = (const T*)p_index->GetSample(indices[j]);
+                    for (DimensionType k = 0; k < p_index->GetFeatureDim(); k++)
+                    {
+                        meanValues[k] += v[k];
+                    }
+                }
+                for (DimensionType k = 0; k < p_index->GetFeatureDim(); k++)
+                {
+                    meanValues[k] /= count;
+                }
+                // calculate the variance of each dimension
+                for (SizeType j = first; j <= end; j++)
+                {
+                    const T* v = (const T*)p_index->GetSample(indices[j]);
+                    for (DimensionType k = 0; k < p_index->GetFeatureDim(); k++)
+                    {
+                        float dist = v[k] - meanValues[k];
+                        varianceValues[k] += dist*dist;
+                    }
+                }
+                // choose the split dimension as one of the dimension inside TOP_DIM maximum variance
+                node.split_dim = SelectDivisionDimension(varianceValues);
+                // determine the threshold
+                node.split_value = meanValues[node.split_dim];
+            }
+
+            DimensionType SelectDivisionDimension(const std::vector<float>& varianceValues) const
+            {
+                // Record the top maximum variances
+                std::vector<DimensionType> topind(m_numTopDimensionKDTSplit);
+                int num = 0;
+                // order the variances
+                for (DimensionType i = 0; i < (DimensionType)varianceValues.size(); i++)
+                {
+                    if (num < m_numTopDimensionKDTSplit || varianceValues[i] > varianceValues[topind[num - 1]])
+                    {
+                        if (num < m_numTopDimensionKDTSplit)
+                        {
+                            topind[num++] = i;
+                        }
+                        else
+                        {
+                            topind[num - 1] = i;
+                        }
+                        int j = num - 1;
+                        // order the TOP_DIM variances
+                        while (j > 0 && varianceValues[topind[j]] > varianceValues[topind[j - 1]])
+                        {
+                            std::swap(topind[j], topind[j - 1]);
+                            j--;
+                        }
+                    }
+                }
+                // randomly choose a dimension from TOP_DIM
+                return topind[COMMON::Utils::rand(num)];
+            }
+
+            template <typename T>
+            SizeType Subdivide(VectorIndex* p_index, const KDTNode& node, std::vector<SizeType>& indices, const SizeType first, const SizeType last) const
+            {
+                SizeType i = first;
+                SizeType j = last;
+                // decide which child one point belongs
+                while (i <= j)
+                {
+                    SizeType ind = indices[i];
+                    const T* v = (const T*)p_index->GetSample(ind);
+                    float val = v[node.split_dim];
+                    if (val < node.split_value)
+                    {
+                        i++;
+                    }
+                    else
+                    {
+                        std::swap(indices[i], indices[j]);
+                        j--;
+                    }
+                }
+                // if all the points in the node are equal,equally split the node into 2
+                if ((i == first) || (i == last + 1))
+                {
+                    i = (first + last + 1) / 2;
+                }
+                return i;
+            }
+
+        private:
+            std::vector<SizeType> m_pTreeStart;
+            std::vector<KDTNode> m_pTreeRoots;
+
+        public:
+            int m_iTreeNumber, m_numTopDimensionKDTSplit, m_iSamples;
+        };
+    }
+}
+#endif
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/Common/NeighborhoodGraph.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/Common/NeighborhoodGraph.h
new file mode 100644
index 0000000000..ea47125c36
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/Common/NeighborhoodGraph.h
@@ -0,0 +1,403 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_COMMON_NG_H_
+#define _SPTAG_COMMON_NG_H_
+
+#include "../VectorIndex.h"
+
+#include "CommonUtils.h"
+#include "Dataset.h"
+#include "FineGrainedLock.h"
+#include "QueryResultSet.h"
+
+namespace SPTAG
+{
+    namespace COMMON
+    {
+        class NeighborhoodGraph 
+        {
+        public:
+            NeighborhoodGraph(): m_iTPTNumber(32), 
+                                 m_iTPTLeafSize(2000), 
+                                 m_iSamples(1000), 
+                                 m_numTopDimensionTPTSplit(5),
+                                 m_iNeighborhoodSize(32),
+                                 m_iNeighborhoodScale(2),
+                                 m_iCEFScale(2),
+                                 m_iRefineIter(0),
+                                 m_iCEF(1000),
+                                 m_iMaxCheckForRefineGraph(10000) 
+            {
+                m_pNeighborhoodGraph.SetName("Graph");
+            }
+
+            ~NeighborhoodGraph() {}
+
+            virtual void InsertNeighbors(VectorIndex* index, const SizeType node, SizeType insertNode, float insertDist) = 0;
+
+            virtual void RebuildNeighbors(VectorIndex* index, const SizeType node, SizeType* nodes, const BasicResult* queryResults, const int numResults) = 0;
+
+            virtual float GraphAccuracyEstimation(VectorIndex* index, const SizeType samples, const std::unordered_map<SizeType, SizeType>* idmap = nullptr) = 0;
+
+            template <typename T>
+            void BuildGraph(VectorIndex* index, const std::unordered_map<SizeType, SizeType>* idmap = nullptr)
+            {
+                std::cout << "build RNG graph!" << std::endl;
+
+                m_iGraphSize = index->GetNumSamples();
+                m_iNeighborhoodSize = m_iNeighborhoodSize * m_iNeighborhoodScale;
+                m_pNeighborhoodGraph.Initialize(m_iGraphSize, m_iNeighborhoodSize);
+                m_dataUpdateLock.resize(m_iGraphSize);
+                
+                if (m_iGraphSize < 1000) {
+                    RefineGraph<T>(index, idmap);
+                    std::cout << "Build RNG Graph end!" << std::endl;
+                    return;
+                }
+
+                {
+                    COMMON::Dataset<float> NeighborhoodDists(m_iGraphSize, m_iNeighborhoodSize);
+                    std::vector<std::vector<SizeType>> TptreeDataIndices(m_iTPTNumber, std::vector<SizeType>(m_iGraphSize));
+                    std::vector<std::vector<std::pair<SizeType, SizeType>>> TptreeLeafNodes(m_iTPTNumber, std::vector<std::pair<SizeType, SizeType>>());
+
+                    for (SizeType i = 0; i < m_iGraphSize; i++)
+                        for (DimensionType j = 0; j < m_iNeighborhoodSize; j++)
+                            (NeighborhoodDists)[i][j] = MaxDist;
+
+                    std::cout << "Parallel TpTree Partition begin " << std::endl;
+#pragma omp parallel for schedule(dynamic)
+                    for (int i = 0; i < m_iTPTNumber; i++)
+                    {
+                        Sleep(i * 100); std::srand(clock());
+                        for (SizeType j = 0; j < m_iGraphSize; j++) TptreeDataIndices[i][j] = j;
+                        std::random_shuffle(TptreeDataIndices[i].begin(), TptreeDataIndices[i].end());
+                        PartitionByTptree<T>(index, TptreeDataIndices[i], 0, m_iGraphSize - 1, TptreeLeafNodes[i]);
+                        std::cout << "Finish Getting Leaves for Tree " << i << std::endl;
+                    }
+                    std::cout << "Parallel TpTree Partition done" << std::endl;
+
+                    for (int i = 0; i < m_iTPTNumber; i++)
+                    {
+#pragma omp parallel for schedule(dynamic)
+                        for (SizeType j = 0; j < (SizeType)TptreeLeafNodes[i].size(); j++)
+                        {
+                            SizeType start_index = TptreeLeafNodes[i][j].first;
+                            SizeType end_index = TptreeLeafNodes[i][j].second;
+                            if (omp_get_thread_num() == 0) std::cout << "\rProcessing Tree " << i << ' ' << j * 100 / TptreeLeafNodes[i].size() << '%';
+                            for (SizeType x = start_index; x < end_index; x++)
+                            {
+                                for (SizeType y = x + 1; y <= end_index; y++)
+                                {
+                                    SizeType p1 = TptreeDataIndices[i][x];
+                                    SizeType p2 = TptreeDataIndices[i][y];
+                                    float dist = index->ComputeDistance(index->GetSample(p1), index->GetSample(p2));
+                                    if (idmap != nullptr) {
+                                        p1 = (idmap->find(p1) == idmap->end()) ? p1 : idmap->at(p1);
+                                        p2 = (idmap->find(p2) == idmap->end()) ? p2 : idmap->at(p2);
+                                    }
+                                    COMMON::Utils::AddNeighbor(p2, dist, (m_pNeighborhoodGraph)[p1], (NeighborhoodDists)[p1], m_iNeighborhoodSize);
+                                    COMMON::Utils::AddNeighbor(p1, dist, (m_pNeighborhoodGraph)[p2], (NeighborhoodDists)[p2], m_iNeighborhoodSize);
+                                }
+                            }
+                        }
+                        TptreeDataIndices[i].clear();
+                        TptreeLeafNodes[i].clear();
+                        std::cout << std::endl;
+                    }
+                    TptreeDataIndices.clear();
+                    TptreeLeafNodes.clear();
+                }
+
+                if (m_iMaxCheckForRefineGraph > 0) {
+                    RefineGraph<T>(index, idmap);
+                }
+            }
+
+            template <typename T>
+            void RefineGraph(VectorIndex* index, const std::unordered_map<SizeType, SizeType>* idmap = nullptr)
+            {
+                m_iCEF *= m_iCEFScale;
+                m_iMaxCheckForRefineGraph *= m_iCEFScale;
+
+#pragma omp parallel for schedule(dynamic)
+                for (SizeType i = 0; i < m_iGraphSize; i++)
+                {
+                    RefineNode<T>(index, i, false);
+					if (i % 1000 == 0) std::cout << "\rRefine 1 " << (i * 100 / m_iGraphSize) << "%";
+                }
+                std::cout << "Refine RNG, graph acc:" << GraphAccuracyEstimation(index, 100, idmap) << std::endl;
+
+                m_iCEF /= m_iCEFScale;
+                m_iMaxCheckForRefineGraph /= m_iCEFScale;
+                m_iNeighborhoodSize /= m_iNeighborhoodScale;
+
+#pragma omp parallel for schedule(dynamic)
+                for (SizeType i = 0; i < m_iGraphSize; i++)
+                {
+                    RefineNode<T>(index, i, false);
+					if (i % 1000 == 0) std::cout << "\rRefine 2 " << (i * 100 / m_iGraphSize) << "%";
+                }
+                std::cout << "Refine RNG, graph acc:" << GraphAccuracyEstimation(index, 100, idmap) << std::endl;
+
+                if (idmap != nullptr) {
+                    for (auto iter = idmap->begin(); iter != idmap->end(); iter++)
+                        if (iter->first < 0)
+                        {
+                            m_pNeighborhoodGraph[-1 - iter->first][m_iNeighborhoodSize - 1] = -2 - iter->second;
+                        }
+                }
+            }
+
+            template <typename T>
+            ErrorCode RefineGraph(VectorIndex* index, std::vector<SizeType>& indices, std::vector<SizeType>& reverseIndices,
+                std::ostream& output, const std::unordered_map<SizeType, SizeType>* idmap = nullptr)
+            {
+                SizeType R = (SizeType)indices.size();
+
+#pragma omp parallel for schedule(dynamic)
+                for (SizeType i = 0; i < R; i++)
+                {
+                    RefineNode<T>(index, indices[i], false);
+                    SizeType* nodes = m_pNeighborhoodGraph[indices[i]];
+                    for (DimensionType j = 0; j < m_iNeighborhoodSize; j++)
+                    {
+                        if (nodes[j] < 0) nodes[j] = -1;
+                        else nodes[j] = reverseIndices[nodes[j]];
+                    }
+                    if (idmap == nullptr || idmap->find(-1 - indices[i]) == idmap->end()) continue;
+                    nodes[m_iNeighborhoodSize - 1] = -2 - idmap->at(-1 - indices[i]);
+                }
+
+                m_pNeighborhoodGraph.Refine(indices, output);
+                return ErrorCode::Success;
+            }
+
+
+            template <typename T>
+            void RefineNode(VectorIndex* index, const SizeType node, bool updateNeighbors)
+            {
+                COMMON::QueryResultSet<T> query((const T*)index->GetSample(node), m_iCEF + 1);
+                index->SearchIndex(query);
+                RebuildNeighbors(index, node, m_pNeighborhoodGraph[node], query.GetResults(), m_iCEF + 1);
+
+                if (updateNeighbors) {
+                    // update neighbors
+                    for (int j = 0; j <= m_iCEF; j++)
+                    {
+                        BasicResult* item = query.GetResult(j);
+                        if (item->VID < 0) break;
+                        if (item->VID == node) continue;
+
+                        std::lock_guard<std::mutex> lock(m_dataUpdateLock[item->VID]);
+                        InsertNeighbors(index, item->VID, node, item->Dist);
+                    }
+                }
+            }
+
+            template <typename T>
+            void PartitionByTptree(VectorIndex* index, std::vector<SizeType>& indices, const SizeType first, const SizeType last,
+                std::vector<std::pair<SizeType, SizeType>> & leaves)
+            {
+                if (last - first <= m_iTPTLeafSize)
+                {
+                    leaves.push_back(std::make_pair(first, last));
+                }
+                else
+                {
+                    std::vector<float> Mean(index->GetFeatureDim(), 0);
+
+                    int iIteration = 100;
+                    SizeType end = min(first + m_iSamples, last);
+                    SizeType count = end - first + 1;
+                    // calculate the mean of each dimension
+                    for (SizeType j = first; j <= end; j++)
+                    {
+                        const T* v = (const T*)index->GetSample(indices[j]);
+                        for (DimensionType k = 0; k < index->GetFeatureDim(); k++)
+                        {
+                            Mean[k] += v[k];
+                        }
+                    }
+                    for (DimensionType k = 0; k < index->GetFeatureDim(); k++)
+                    {
+                        Mean[k] /= count;
+                    }
+                    std::vector<BasicResult> Variance;
+                    Variance.reserve(index->GetFeatureDim());
+                    for (DimensionType j = 0; j < index->GetFeatureDim(); j++)
+                    {
+                        Variance.push_back(BasicResult(j, 0));
+                    }
+                    // calculate the variance of each dimension
+                    for (SizeType j = first; j <= end; j++)
+                    {
+                        const T* v = (const T*)index->GetSample(indices[j]);
+                        for (DimensionType k = 0; k < index->GetFeatureDim(); k++)
+                        {
+                            float dist = v[k] - Mean[k];
+                            Variance[k].Dist += dist*dist;
+                        }
+                    }
+                    std::sort(Variance.begin(), Variance.end(), COMMON::Compare);
+                    std::vector<SizeType> indexs(m_numTopDimensionTPTSplit);
+                    std::vector<float> weight(m_numTopDimensionTPTSplit), bestweight(m_numTopDimensionTPTSplit);
+                    float bestvariance = Variance[index->GetFeatureDim() - 1].Dist;
+                    for (int i = 0; i < m_numTopDimensionTPTSplit; i++)
+                    {
+                        indexs[i] = Variance[index->GetFeatureDim() - 1 - i].VID;
+                        bestweight[i] = 0;
+                    }
+                    bestweight[0] = 1;
+                    float bestmean = Mean[indexs[0]];
+
+                    std::vector<float> Val(count);
+                    for (int i = 0; i < iIteration; i++)
+                    {
+                        float sumweight = 0;
+                        for (int j = 0; j < m_numTopDimensionTPTSplit; j++)
+                        {
+                            weight[j] = float(rand() % 10000) / 5000.0f - 1.0f;
+                            sumweight += weight[j] * weight[j];
+                        }
+                        sumweight = sqrt(sumweight);
+                        for (int j = 0; j < m_numTopDimensionTPTSplit; j++)
+                        {
+                            weight[j] /= sumweight;
+                        }
+                        float mean = 0;
+                        for (SizeType j = 0; j < count; j++)
+                        {
+                            Val[j] = 0;
+                            const T* v = (const T*)index->GetSample(indices[first + j]);
+                            for (int k = 0; k < m_numTopDimensionTPTSplit; k++)
+                            {
+                                Val[j] += weight[k] * v[indexs[k]];
+                            }
+                            mean += Val[j];
+                        }
+                        mean /= count;
+                        float var = 0;
+                        for (SizeType j = 0; j < count; j++)
+                        {
+                            float dist = Val[j] - mean;
+                            var += dist * dist;
+                        }
+                        if (var > bestvariance)
+                        {
+                            bestvariance = var;
+                            bestmean = mean;
+                            for (int j = 0; j < m_numTopDimensionTPTSplit; j++)
+                            {
+                                bestweight[j] = weight[j];
+                            }
+                        }
+                    }
+                    SizeType i = first;
+                    SizeType j = last;
+                    // decide which child one point belongs
+                    while (i <= j)
+                    {
+                        float val = 0;
+                        const T* v = (const T*)index->GetSample(indices[i]);
+                        for (int k = 0; k < m_numTopDimensionTPTSplit; k++)
+                        {
+                            val += bestweight[k] * v[indexs[k]];
+                        }
+                        if (val < bestmean)
+                        {
+                            i++;
+                        }
+                        else
+                        {
+                            std::swap(indices[i], indices[j]);
+                            j--;
+                        }
+                    }
+                    // if all the points in the node are equal,equally split the node into 2
+                    if ((i == first) || (i == last + 1))
+                    {
+                        i = (first + last + 1) / 2;
+                    }
+
+                    Mean.clear();
+                    Variance.clear();
+                    Val.clear();
+                    indexs.clear();
+                    weight.clear();
+                    bestweight.clear();
+
+                    PartitionByTptree<T>(index, indices, first, i - 1, leaves);
+                    PartitionByTptree<T>(index, indices, i, last, leaves);
+                }
+            }
+
+            inline std::uint64_t BufferSize() const
+            {
+                return m_pNeighborhoodGraph.BufferSize();
+            }
+
+            bool LoadGraph(std::string sGraphFilename)
+            {
+                if (!m_pNeighborhoodGraph.Load(sGraphFilename)) return false;
+
+                m_iGraphSize = m_pNeighborhoodGraph.R();
+                m_iNeighborhoodSize = m_pNeighborhoodGraph.C();
+                m_dataUpdateLock.resize(m_iGraphSize);
+                return true;
+            }
+            
+            bool LoadGraph(char* pGraphMemFile)
+            {
+                m_pNeighborhoodGraph.Load(pGraphMemFile);
+
+                m_iGraphSize = m_pNeighborhoodGraph.R();
+                m_iNeighborhoodSize = m_pNeighborhoodGraph.C();
+                m_dataUpdateLock.resize(m_iGraphSize);
+                return true;
+            }
+            
+            bool SaveGraph(std::string sGraphFilename) const
+            {
+                return m_pNeighborhoodGraph.Save(sGraphFilename);
+            }
+
+            bool SaveGraph(std::ostream& output) const
+            {
+                return m_pNeighborhoodGraph.Save(output);
+            }
+
+            inline ErrorCode AddBatch(SizeType num)
+            { 
+                ErrorCode ret = m_pNeighborhoodGraph.AddBatch(num);
+                if (ret != ErrorCode::Success) return ret;
+
+                m_iGraphSize += num;
+                m_dataUpdateLock.resize(m_iGraphSize);
+                return ErrorCode::Success;
+            }
+
+            inline SizeType* operator[](SizeType index) { return m_pNeighborhoodGraph[index]; }
+
+            inline const SizeType* operator[](SizeType index) const { return m_pNeighborhoodGraph[index]; }
+
+            inline void SetR(SizeType rows) { m_pNeighborhoodGraph.SetR(rows); m_iGraphSize = rows; m_dataUpdateLock.resize(m_iGraphSize); }
+
+            inline SizeType R() const { return m_iGraphSize; }
+
+            static std::shared_ptr<NeighborhoodGraph> CreateInstance(std::string type);
+
+        protected:
+            // Graph structure
+            SizeType m_iGraphSize;
+            COMMON::Dataset<SizeType> m_pNeighborhoodGraph;
+            COMMON::FineGrainedLock m_dataUpdateLock; // protect one row of the graph
+
+        public:
+            int m_iTPTNumber, m_iTPTLeafSize, m_iSamples, m_numTopDimensionTPTSplit;
+            DimensionType m_iNeighborhoodSize;
+            int m_iNeighborhoodScale, m_iCEFScale, m_iRefineIter, m_iCEF, m_iMaxCheckForRefineGraph;
+        };
+    }
+}
+#endif
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/Common/QueryResultSet.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/Common/QueryResultSet.h
new file mode 100644
index 0000000000..ff8fa14dfd
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/Common/QueryResultSet.h
@@ -0,0 +1,96 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_COMMON_QUERYRESULTSET_H_
+#define _SPTAG_COMMON_QUERYRESULTSET_H_
+
+#include "../SearchQuery.h"
+
+namespace SPTAG
+{
+namespace COMMON
+{
+
+inline bool operator < (const BasicResult& lhs, const BasicResult& rhs)
+{
+    return ((lhs.Dist < rhs.Dist) || ((lhs.Dist == rhs.Dist) && (lhs.VID < rhs.VID)));
+}
+
+
+inline bool Compare(const BasicResult& lhs, const BasicResult& rhs)
+{
+    return ((lhs.Dist < rhs.Dist) || ((lhs.Dist == rhs.Dist) && (lhs.VID < rhs.VID)));
+}
+
+
+// Space to save temporary answer, similar with TopKCache
+template<typename T>
+class QueryResultSet : public QueryResult
+{
+public:
+    QueryResultSet(const T* _target, int _K) : QueryResult(_target, _K, false)
+    {
+    }
+
+    QueryResultSet(const QueryResultSet& other) : QueryResult(other)
+    {
+    }
+
+    inline void SetTarget(const T *p_target)
+    {
+        m_target = p_target;
+    }
+
+    inline const T* GetTarget() const
+    {
+        return reinterpret_cast<const T*>(m_target);
+    }
+
+    inline float worstDist() const
+    {
+        return m_results[0].Dist;
+    }
+
+    bool AddPoint(const SizeType index, float dist)
+    {
+        if (dist < m_results[0].Dist || (dist == m_results[0].Dist && index < m_results[0].VID))
+        {
+            m_results[0].VID = index;
+            m_results[0].Dist = dist;
+            Heapify(m_resultNum);
+            return true;
+        }
+        return false;
+    }
+
+    inline void SortResult()
+    {
+        for (int i = m_resultNum - 1; i >= 0; i--)
+        {
+            std::swap(m_results[0], m_results[i]);
+            Heapify(i);
+        }
+    }
+
+private:
+    void Heapify(int count)
+    {
+        int parent = 0, next = 1, maxidx = count - 1;
+        while (next < maxidx)
+        {
+            if (m_results[next] < m_results[next + 1]) next++;
+            if (m_results[parent] < m_results[next])
+            {
+                std::swap(m_results[next], m_results[parent]);
+                parent = next;
+                next = (parent << 1) + 1;
+            }
+            else break;
+        }
+        if (next == maxidx && m_results[parent] < m_results[next]) std::swap(m_results[parent], m_results[next]);
+    }
+};
+}
+}
+
+#endif // _SPTAG_COMMON_QUERYRESULTSET_H_
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/Common/RelativeNeighborhoodGraph.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/Common/RelativeNeighborhoodGraph.h
new file mode 100644
index 0000000000..33ab01927b
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/Common/RelativeNeighborhoodGraph.h
@@ -0,0 +1,123 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_COMMON_RNG_H_
+#define _SPTAG_COMMON_RNG_H_
+
+#include "NeighborhoodGraph.h"
+
+namespace SPTAG
+{
+    namespace COMMON
+    {
+        class RelativeNeighborhoodGraph: public NeighborhoodGraph
+        {
+        public:
+            void RebuildNeighbors(VectorIndex* index, const SizeType node, SizeType* nodes, const BasicResult* queryResults, const int numResults) {
+                DimensionType count = 0;
+                for (int j = 0; j < numResults && count < m_iNeighborhoodSize; j++) {
+                    const BasicResult& item = queryResults[j];
+                    if (item.VID < 0) break;
+                    if (item.VID == node) continue;
+
+                    bool good = true;
+                    for (DimensionType k = 0; k < count; k++) {
+                        if (index->ComputeDistance(index->GetSample(nodes[k]), index->GetSample(item.VID)) <= item.Dist) {
+                            good = false;
+                            break;
+                        }
+                    }
+                    if (good) nodes[count++] = item.VID;
+                }
+                for (DimensionType j = count; j < m_iNeighborhoodSize; j++)  nodes[j] = -1;
+            }
+
+            void InsertNeighbors(VectorIndex* index, const SizeType node, SizeType insertNode, float insertDist)
+            {
+                SizeType* nodes = m_pNeighborhoodGraph[node];
+                for (DimensionType k = 0; k < m_iNeighborhoodSize; k++)
+                {
+                    SizeType tmpNode = nodes[k];
+                    if (tmpNode < -1) continue;
+
+                    if (tmpNode < 0)
+                    {
+                        bool good = true;
+                        for (DimensionType t = 0; t < k; t++) {
+                            if (index->ComputeDistance(index->GetSample(insertNode), index->GetSample(nodes[t])) < insertDist) {
+                                good = false;
+                                break;
+                            }
+                        }
+                        if (good) {
+                            nodes[k] = insertNode;
+                        }
+                        break;
+                    }
+                    float tmpDist = index->ComputeDistance(index->GetSample(node), index->GetSample(tmpNode));
+                    if (insertDist < tmpDist || (insertDist == tmpDist && insertNode < tmpNode))
+                    {
+                        bool good = true;
+                        for (DimensionType t = 0; t < k; t++) {
+                            if (index->ComputeDistance(index->GetSample(insertNode), index->GetSample(nodes[t])) < insertDist) {
+                                good = false;
+                                break;
+                            }
+                        }
+                        if (good) {
+                            nodes[k] = insertNode;
+                            insertNode = tmpNode;
+                            insertDist = tmpDist;
+                        }
+                        else {
+                            break;
+                        }
+                    }
+                }
+            }
+
+            float GraphAccuracyEstimation(VectorIndex* index, const SizeType samples, const std::unordered_map<SizeType, SizeType>* idmap = nullptr)
+            {
+                DimensionType* correct = new DimensionType[samples];
+
+#pragma omp parallel for schedule(dynamic)
+                for (SizeType i = 0; i < samples; i++)
+                {
+                    SizeType x = COMMON::Utils::rand(m_iGraphSize);
+                    //int x = i;
+                    COMMON::QueryResultSet<void> query(nullptr, m_iCEF);
+                    for (SizeType y = 0; y < m_iGraphSize; y++)
+                    {
+                        if ((idmap != nullptr && idmap->find(y) != idmap->end())) continue;
+                        float dist = index->ComputeDistance(index->GetSample(x), index->GetSample(y));
+                        query.AddPoint(y, dist);
+                    }
+                    query.SortResult();
+                    SizeType * exact_rng = new SizeType[m_iNeighborhoodSize];
+                    RebuildNeighbors(index, x, exact_rng, query.GetResults(), m_iCEF);
+                  
+                    correct[i] = 0;
+                    for (DimensionType j = 0; j < m_iNeighborhoodSize; j++) {
+                        if (exact_rng[j] == -1) {
+                            correct[i] += m_iNeighborhoodSize - j;
+                            break;
+                        }
+                        for (DimensionType k = 0; k < m_iNeighborhoodSize; k++)
+                            if ((m_pNeighborhoodGraph)[x][k] == exact_rng[j]) {
+                                correct[i]++;
+                                break;
+                            }
+                    }
+                    delete[] exact_rng;
+                }
+                float acc = 0;
+                for (SizeType i = 0; i < samples; i++) acc += float(correct[i]);
+                acc = acc / samples / m_iNeighborhoodSize;
+                delete[] correct;
+                return acc;
+            }
+
+        };
+    }
+}
+#endif
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/Common/WorkSpace.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/Common/WorkSpace.h
new file mode 100644
index 0000000000..c236d45a1c
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/Common/WorkSpace.h
@@ -0,0 +1,185 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_COMMON_WORKSPACE_H_
+#define _SPTAG_COMMON_WORKSPACE_H_
+
+#include "CommonUtils.h"
+#include "Heap.h"
+
+namespace SPTAG
+{
+    namespace COMMON
+    {
+        // node type in the priority queue
+        struct HeapCell
+        {
+            SizeType node;
+            float distance;
+
+            HeapCell(SizeType _node = -1, float _distance = MaxDist) : node(_node), distance(_distance) {}
+
+            inline bool operator < (const HeapCell& rhs)
+            {
+                return distance < rhs.distance;
+            }
+
+            inline bool operator > (const HeapCell& rhs)
+            {
+                return distance > rhs.distance;
+            }
+        };
+
+        class OptHashPosVector
+        {
+        protected:
+            // Max loop number in one hash block.
+            static const int m_maxLoop = 8;
+
+            // Max pool size.
+            static const int m_poolSize = 8191;
+
+            // Could we use the second hash block.
+            bool m_secondHash;
+
+            // Record 2 hash tables.
+            // [0~m_poolSize + 1) is the first block.
+            // [m_poolSize + 1, 2*(m_poolSize + 1)) is the second block;
+            SizeType m_hashTable[(m_poolSize + 1) * 2];
+
+
+            inline unsigned hash_func2(unsigned idx, int loop)
+            {
+                return (idx + loop) & m_poolSize;
+            }
+
+
+            inline unsigned hash_func(unsigned idx)
+            {
+                return ((unsigned)(idx * 99991) + _rotl(idx, 2) + 101) & m_poolSize;
+            }
+
+        public:
+            OptHashPosVector() {}
+
+            ~OptHashPosVector() {}
+
+
+            void Init(SizeType size)
+            {
+                m_secondHash = true;
+                clear();
+            }
+
+            void clear()
+            {
+                if (!m_secondHash)
+                {
+                    // Clear first block.
+                    memset(&m_hashTable[0], 0, sizeof(SizeType)*(m_poolSize + 1));
+                }
+                else
+                {
+                    // Clear all blocks.
+                    memset(&m_hashTable[0], 0, 2 * sizeof(SizeType) * (m_poolSize + 1));
+                    m_secondHash = false;
+                }
+            }
+
+
+            inline bool CheckAndSet(SizeType idx)
+            {
+                // Inner Index is begin from 1
+                return _CheckAndSet(&m_hashTable[0], idx + 1) == 0;
+            }
+
+
+            inline int _CheckAndSet(SizeType* hashTable, SizeType idx)
+            {
+                unsigned index;
+
+                // Get first hash position.
+                index = hash_func((unsigned)idx);
+                for (int loop = 0; loop < m_maxLoop; ++loop)
+                {
+                    if (!hashTable[index])
+                    {
+                        // index first match and record it.
+                        hashTable[index] = idx;
+                        return 1;
+                    }
+                    if (hashTable[index] == idx)
+                    {
+                        // Hit this item in hash table.
+                        return 0;
+                    }
+                    // Get next hash position.
+                    index = hash_func2(index, loop);
+                }
+
+                if (hashTable == &m_hashTable[0])
+                {
+                    // Use second hash block.
+                    m_secondHash = true;
+                    return _CheckAndSet(&m_hashTable[m_poolSize + 1], idx);
+                }
+
+                // Do not include this item.
+                return -1;
+            }
+        };
+
+        // Variables for each single NN search
+        struct WorkSpace
+        {
+            void Initialize(int maxCheck, SizeType dataSize)
+            {
+                nodeCheckStatus.Init(dataSize);
+                m_SPTQueue.Resize(maxCheck * 10);
+                m_NGQueue.Resize(maxCheck * 30);
+
+                m_iNumberOfTreeCheckedLeaves = 0;
+                m_iNumberOfCheckedLeaves = 0;
+                m_iContinuousLimit = maxCheck / 64;
+                m_iMaxCheck = maxCheck;
+                m_iNumOfContinuousNoBetterPropagation = 0;
+            }
+
+            void Reset(int maxCheck)
+            {
+                nodeCheckStatus.clear();
+                m_SPTQueue.clear();
+                m_NGQueue.clear();
+
+                m_iNumberOfTreeCheckedLeaves = 0;
+                m_iNumberOfCheckedLeaves = 0;
+                m_iContinuousLimit = maxCheck / 64;
+                m_iMaxCheck = maxCheck;
+                m_iNumOfContinuousNoBetterPropagation = 0;
+            }
+
+            inline bool CheckAndSet(SizeType idx)
+            {
+                return nodeCheckStatus.CheckAndSet(idx);
+            }
+
+            OptHashPosVector nodeCheckStatus;
+            //OptHashPosVector nodeCheckStatus;
+
+            // counter for dynamic pivoting
+            int m_iNumOfContinuousNoBetterPropagation;
+            int m_iContinuousLimit;
+            int m_iNumberOfTreeCheckedLeaves;
+            int m_iNumberOfCheckedLeaves;
+            int m_iMaxCheck;
+
+            // Prioriy queue used for neighborhood graph
+            Heap<HeapCell> m_NGQueue;
+
+            // Priority queue Used for BKT-Tree
+            Heap<HeapCell> m_SPTQueue;
+        };
+    }
+}
+
+#endif // _SPTAG_COMMON_WORKSPACE_H_
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/Common/WorkSpacePool.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/Common/WorkSpacePool.h
new file mode 100644
index 0000000000..a322f42af4
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/Common/WorkSpacePool.h
@@ -0,0 +1,43 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_COMMON_WORKSPACEPOOL_H_
+#define _SPTAG_COMMON_WORKSPACEPOOL_H_
+
+#include "WorkSpace.h"
+
+#include <list>
+#include <mutex>
+
+namespace SPTAG
+{
+namespace COMMON
+{
+
+class WorkSpacePool
+{
+public:
+    WorkSpacePool(int p_maxCheck, SizeType p_vectorCount);
+
+    virtual ~WorkSpacePool();
+
+    std::shared_ptr<WorkSpace> Rent();
+
+    void Return(const std::shared_ptr<WorkSpace>& p_workSpace);
+
+    void Init(int size);
+
+private:
+    std::list<std::shared_ptr<WorkSpace>> m_workSpacePool;
+
+    std::mutex m_workSpacePoolMutex;
+
+    int m_maxCheck;
+
+    SizeType m_vectorCount;
+};
+
+}
+}
+
+#endif // _SPTAG_COMMON_WORKSPACEPOOL_H_
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/CommonDataStructure.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/CommonDataStructure.h
new file mode 100644
index 0000000000..c158fc8802
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/CommonDataStructure.h
@@ -0,0 +1,226 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_COMMONDATASTRUCTURE_H_
+#define _SPTAG_COMMONDATASTRUCTURE_H_
+
+#include "inc/Core/Common.h"
+
+namespace SPTAG
+{
+
+template<typename T>
+class Array
+{
+public:
+    Array();
+
+    Array(T* p_array, std::size_t p_length, bool p_transferOwnership);
+    
+    Array(T* p_array, std::size_t p_length, std::shared_ptr<T> p_dataHolder);
+
+    Array(Array<T>&& p_right);
+
+    Array(const Array<T>& p_right);
+
+    Array<T>& operator= (Array<T>&& p_right);
+
+    Array<T>& operator= (const Array<T>& p_right);
+
+    T& operator[] (std::size_t p_index);
+
+    const T& operator[] (std::size_t p_index) const;
+
+    ~Array();
+
+    T* Data() const;
+
+    std::size_t Length() const;
+
+    std::shared_ptr<T> DataHolder() const;
+    
+    void Set(T* p_array, std::size_t p_length, bool p_transferOwnership);
+
+    void Clear();
+
+    static Array<T> Alloc(std::size_t p_length);
+
+    const static Array<T> c_empty;
+
+private:
+    T* m_data;
+
+    std::size_t m_length;
+
+    // Notice this is holding an array. Set correct deleter for this.
+    std::shared_ptr<T> m_dataHolder;
+};
+
+template<typename T>
+const Array<T> Array<T>::c_empty;
+
+
+template<typename T>
+Array<T>::Array()
+    : m_data(nullptr),
+    m_length(0)
+{
+}
+
+template<typename T>
+Array<T>::Array(T* p_array, std::size_t p_length, bool p_transferOnwership)
+
+    : m_data(p_array),
+    m_length(p_length)
+{
+    if (p_transferOnwership)
+    {
+        m_dataHolder.reset(m_data, std::default_delete<T[]>());
+    }
+}
+
+
+template<typename T>
+Array<T>::Array(T* p_array, std::size_t p_length, std::shared_ptr<T> p_dataHolder)
+    : m_data(p_array),
+    m_length(p_length),
+    m_dataHolder(std::move(p_dataHolder))
+{
+}
+
+
+template<typename T>
+Array<T>::Array(Array<T>&& p_right)
+    : m_data(p_right.m_data),
+    m_length(p_right.m_length),
+    m_dataHolder(std::move(p_right.m_dataHolder))
+{
+}
+
+
+template<typename T>
+Array<T>::Array(const Array<T>& p_right)
+    : m_data(p_right.m_data),
+    m_length(p_right.m_length),
+    m_dataHolder(p_right.m_dataHolder)
+{
+}
+
+
+template<typename T>
+Array<T>&
+Array<T>::operator= (Array<T>&& p_right)
+{
+    m_data = p_right.m_data;
+    m_length = p_right.m_length;
+    m_dataHolder = std::move(p_right.m_dataHolder);
+
+    return *this;
+}
+
+
+template<typename T>
+Array<T>&
+Array<T>::operator= (const Array<T>& p_right)
+{
+    m_data = p_right.m_data;
+    m_length = p_right.m_length;
+    m_dataHolder = p_right.m_dataHolder;
+
+    return *this;
+}
+
+
+template<typename T>
+T&
+Array<T>::operator[] (std::size_t p_index)
+{
+    return m_data[p_index];
+}
+
+
+template<typename T>
+const T&
+Array<T>::operator[] (std::size_t p_index) const
+{
+    return m_data[p_index];
+}
+
+
+template<typename T>
+Array<T>::~Array()
+{
+}
+
+
+template<typename T>
+T*
+Array<T>::Data() const
+{
+    return m_data;
+}
+
+
+template<typename T>
+std::size_t
+Array<T>::Length() const
+{
+    return m_length;
+}
+
+
+template<typename T>
+std::shared_ptr<T>
+Array<T>::DataHolder() const
+{
+    return m_dataHolder;
+}
+
+
+template<typename T>
+void
+Array<T>::Set(T* p_array, std::size_t p_length, bool p_transferOwnership)
+{
+    m_data = p_array;
+    m_length = p_length;
+
+    if (p_transferOwnership)
+    {
+        m_dataHolder.reset(m_data, std::default_delete<T[]>());
+    }
+}
+
+
+template<typename T>
+void
+Array<T>::Clear()
+{
+    m_data = nullptr;
+    m_length = 0;
+    m_dataHolder.reset();
+}
+
+
+template<typename T>
+Array<T>
+Array<T>::Alloc(std::size_t p_length)
+{
+    Array<T> arr;
+    if (0 == p_length)
+    {
+        return arr;
+    }
+
+    arr.m_dataHolder.reset(new T[p_length], std::default_delete<T[]>());
+
+    arr.m_length = p_length;
+    arr.m_data = arr.m_dataHolder.get();
+    return arr;
+}
+
+
+typedef Array<std::uint8_t> ByteArray;
+
+} // namespace SPTAG
+
+#endif // _SPTAG_COMMONDATASTRUCTURE_H_
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/DefinitionList.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/DefinitionList.h
new file mode 100644
index 0000000000..91014963c6
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/DefinitionList.h
@@ -0,0 +1,59 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifdef DefineVectorValueType
+
+DefineVectorValueType(Int8, std::int8_t)
+DefineVectorValueType(UInt8, std::uint8_t)
+DefineVectorValueType(Int16, std::int16_t)
+DefineVectorValueType(Float, float)
+
+#endif // DefineVectorValueType
+
+
+#ifdef DefineDistCalcMethod
+
+DefineDistCalcMethod(L2)
+DefineDistCalcMethod(Cosine)
+
+#endif // DefineDistCalcMethod
+
+
+#ifdef DefineErrorCode
+
+// 0x0000 ~ 0x0FFF  General Status
+DefineErrorCode(Success, 0x0000)
+DefineErrorCode(Fail, 0x0001)
+DefineErrorCode(FailedOpenFile, 0x0002)
+DefineErrorCode(FailedCreateFile, 0x0003)
+DefineErrorCode(ParamNotFound, 0x0010)
+DefineErrorCode(FailedParseValue, 0x0011)
+DefineErrorCode(MemoryOverFlow, 0x0012)
+DefineErrorCode(LackOfInputs, 0x0013)
+
+// 0x1000 ~ 0x1FFF  Index Build Status
+
+// 0x2000 ~ 0x2FFF  Index Serve Status
+
+// 0x3000 ~ 0x3FFF  Helper Function Status
+DefineErrorCode(ReadIni_FailedParseSection, 0x3000)
+DefineErrorCode(ReadIni_FailedParseParam, 0x3001)
+DefineErrorCode(ReadIni_DuplicatedSection, 0x3002)
+DefineErrorCode(ReadIni_DuplicatedParam, 0x3003)
+
+
+// 0x4000 ~ 0x4FFF Socket Library Status
+DefineErrorCode(Socket_FailedResolveEndPoint, 0x4000)
+DefineErrorCode(Socket_FailedConnectToEndPoint, 0x4001)
+
+
+#endif // DefineErrorCode
+
+
+
+#ifdef DefineIndexAlgo
+
+DefineIndexAlgo(BKT)
+DefineIndexAlgo(KDT)
+
+#endif // DefineIndexAlgo
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/KDT/Index.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/KDT/Index.h
new file mode 100644
index 0000000000..668d423b52
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/KDT/Index.h
@@ -0,0 +1,131 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_KDT_INDEX_H_
+#define _SPTAG_KDT_INDEX_H_
+
+#include "../Common.h"
+#include "../VectorIndex.h"
+
+#include "../Common/CommonUtils.h"
+#include "../Common/DistanceUtils.h"
+#include "../Common/QueryResultSet.h"
+#include "../Common/Dataset.h"
+#include "../Common/WorkSpace.h"
+#include "../Common/WorkSpacePool.h"
+#include "../Common/RelativeNeighborhoodGraph.h"
+#include "../Common/KDTree.h"
+#include "inc/Helper/ConcurrentSet.h"
+#include "inc/Helper/StringConvert.h"
+#include "inc/Helper/SimpleIniReader.h"
+
+#include <functional>
+#include <mutex>
+
+namespace SPTAG
+{
+
+    namespace Helper
+    {
+        class IniReader;
+    }
+
+    namespace KDT
+    {
+        template<typename T>
+        class Index : public VectorIndex
+        {
+        private:
+            // data points
+            COMMON::Dataset<T> m_pSamples;
+
+            // KDT structures. 
+            COMMON::KDTree m_pTrees;
+
+            // Graph structure
+            COMMON::RelativeNeighborhoodGraph m_pGraph;
+
+            std::string m_sKDTFilename;
+            std::string m_sGraphFilename;
+            std::string m_sDataPointsFilename;
+            std::string m_sDeleteDataPointsFilename;
+
+            std::mutex m_dataAddLock; // protect data and graph
+            Helper::Concurrent::ConcurrentSet<SizeType> m_deletedID;
+            float m_fDeletePercentageForRefine;
+            std::unique_ptr<COMMON::WorkSpacePool> m_workSpacePool;
+            
+            int m_iNumberOfThreads;
+            DistCalcMethod m_iDistCalcMethod;
+            float(*m_fComputeDistance)(const T* pX, const T* pY, DimensionType length);
+ 
+            int m_iMaxCheck;
+            int m_iThresholdOfNumberOfContinuousNoBetterPropagation;
+            int m_iNumberOfInitialDynamicPivots;
+            int m_iNumberOfOtherDynamicPivots;
+        public:
+            Index()
+            {
+#define DefineKDTParameter(VarName, VarType, DefaultValue, RepresentStr) \
+                VarName = DefaultValue; \
+
+#include "inc/Core/KDT/ParameterDefinitionList.h"
+#undef DefineKDTParameter
+                
+                m_pSamples.SetName("Vector");
+                m_fComputeDistance = COMMON::DistanceCalcSelector<T>(m_iDistCalcMethod);
+            }
+
+            ~Index() {}
+
+            inline SizeType GetNumSamples() const { return m_pSamples.R(); }
+            inline DimensionType GetFeatureDim() const { return m_pSamples.C(); }
+            
+            inline int GetCurrMaxCheck() const { return m_iMaxCheck; }
+            inline int GetNumThreads() const { return m_iNumberOfThreads; }
+            inline DistCalcMethod GetDistCalcMethod() const { return m_iDistCalcMethod; }
+            inline IndexAlgoType GetIndexAlgoType() const { return IndexAlgoType::KDT; }
+            inline VectorValueType GetVectorValueType() const { return GetEnumValueType<T>(); }
+            
+            inline float ComputeDistance(const void* pX, const void* pY) const { return m_fComputeDistance((const T*)pX, (const T*)pY, m_pSamples.C()); }
+            inline const void* GetSample(const SizeType idx) const { return (void*)m_pSamples[idx]; }
+            inline bool ContainSample(const SizeType idx) const { return !m_deletedID.contains(idx); }
+            inline bool NeedRefine() const { return m_deletedID.size() >= (size_t)(GetNumSamples() * m_fDeletePercentageForRefine); }
+            std::shared_ptr<std::vector<std::uint64_t>> BufferSize() const
+            {
+                std::shared_ptr<std::vector<std::uint64_t>> buffersize(new std::vector<std::uint64_t>);
+                buffersize->push_back(m_pSamples.BufferSize());
+                buffersize->push_back(m_pTrees.BufferSize());
+                buffersize->push_back(m_pGraph.BufferSize());
+                buffersize->push_back(m_deletedID.bufferSize());
+                return std::move(buffersize);
+            }
+
+            ErrorCode SaveConfig(std::ostream& p_configout) const;
+            ErrorCode SaveIndexData(const std::string& p_folderPath);
+            ErrorCode SaveIndexData(const std::vector<std::ostream*>& p_indexStreams);
+
+            ErrorCode LoadConfig(Helper::IniReader& p_reader);
+            ErrorCode LoadIndexData(const std::string& p_folderPath);
+            ErrorCode LoadIndexDataFromMemory(const std::vector<ByteArray>& p_indexBlobs);
+
+            ErrorCode BuildIndex(const void* p_data, SizeType p_vectorNum, DimensionType p_dimension);
+            ErrorCode SearchIndex(QueryResult &p_query) const;
+            ErrorCode AddIndex(const void* p_vectors, SizeType p_vectorNum, DimensionType p_dimension, SizeType* p_start = nullptr);
+            ErrorCode DeleteIndex(const void* p_vectors, SizeType p_vectorNum);
+            ErrorCode DeleteIndex(const SizeType& p_id);
+
+            ErrorCode SetParameter(const char* p_param, const char* p_value);
+            std::string GetParameter(const char* p_param) const;
+
+            ErrorCode RefineIndex(const std::string& p_folderPath);
+            ErrorCode RefineIndex(const std::vector<std::ostream*>& p_indexStreams);
+
+        private:
+            void SearchIndexWithDeleted(COMMON::QueryResultSet<T> &p_query, COMMON::WorkSpace &p_space, const Helper::Concurrent::ConcurrentSet<SizeType> &p_deleted) const;
+            void SearchIndexWithoutDeleted(COMMON::QueryResultSet<T> &p_query, COMMON::WorkSpace &p_space) const;
+        };
+    } // namespace KDT
+} // namespace SPTAG
+
+#endif // _SPTAG_KDT_INDEX_H_
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/KDT/ParameterDefinitionList.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/KDT/ParameterDefinitionList.h
new file mode 100644
index 0000000000..c36cb178c1
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/KDT/ParameterDefinitionList.h
@@ -0,0 +1,36 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifdef DefineKDTParameter
+
+// DefineKDTParameter(VarName, VarType, DefaultValue, RepresentStr)
+DefineKDTParameter(m_sKDTFilename, std::string, std::string("tree.bin"), "TreeFilePath")
+DefineKDTParameter(m_sGraphFilename, std::string, std::string("graph.bin"), "GraphFilePath")
+DefineKDTParameter(m_sDataPointsFilename, std::string, std::string("vectors.bin"), "VectorFilePath")
+DefineKDTParameter(m_sDeleteDataPointsFilename, std::string, std::string("deletes.bin"), "DeleteVectorFilePath")
+
+DefineKDTParameter(m_pTrees.m_iTreeNumber, int, 1L, "KDTNumber")
+DefineKDTParameter(m_pTrees.m_numTopDimensionKDTSplit, int, 5L, "NumTopDimensionKDTSplit")
+DefineKDTParameter(m_pTrees.m_iSamples, int, 100L, "Samples")
+
+DefineKDTParameter(m_pGraph.m_iTPTNumber, int, 32L, "TPTNumber")
+DefineKDTParameter(m_pGraph.m_iTPTLeafSize, int, 2000L, "TPTLeafSize")
+DefineKDTParameter(m_pGraph.m_numTopDimensionTPTSplit, int, 5L, "NumTopDimensionTPTSplit")
+
+DefineKDTParameter(m_pGraph.m_iNeighborhoodSize, DimensionType, 32L, "NeighborhoodSize")
+DefineKDTParameter(m_pGraph.m_iNeighborhoodScale, int, 2L, "GraphNeighborhoodScale")
+DefineKDTParameter(m_pGraph.m_iCEFScale, int, 2L, "GraphCEFScale")
+DefineKDTParameter(m_pGraph.m_iRefineIter, int, 0L, "RefineIterations")
+DefineKDTParameter(m_pGraph.m_iCEF, int, 1000L, "CEF")
+DefineKDTParameter(m_pGraph.m_iMaxCheckForRefineGraph, int, 10000L, "MaxCheckForRefineGraph")
+
+DefineKDTParameter(m_iNumberOfThreads, int, 1L, "NumberOfThreads")
+DefineKDTParameter(m_iDistCalcMethod, SPTAG::DistCalcMethod, SPTAG::DistCalcMethod::Cosine, "DistCalcMethod")
+
+DefineKDTParameter(m_fDeletePercentageForRefine, float, 0.4F, "DeletePercentageForRefine")
+DefineKDTParameter(m_iMaxCheck, int, 8192L, "MaxCheck")
+DefineKDTParameter(m_iThresholdOfNumberOfContinuousNoBetterPropagation, int, 3L, "ThresholdOfNumberOfContinuousNoBetterPropagation")
+DefineKDTParameter(m_iNumberOfInitialDynamicPivots, int, 50L, "NumberOfInitialDynamicPivots")
+DefineKDTParameter(m_iNumberOfOtherDynamicPivots, int, 4L, "NumberOfOtherDynamicPivots")
+
+#endif
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/MetadataSet.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/MetadataSet.h
new file mode 100644
index 0000000000..37eba14491
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/MetadataSet.h
@@ -0,0 +1,114 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_METADATASET_H_
+#define _SPTAG_METADATASET_H_
+
+#include "CommonDataStructure.h"
+
+#include <iostream>
+#include <fstream>
+
+namespace SPTAG
+{
+
+class MetadataSet
+{
+public:
+    MetadataSet();
+
+    virtual ~MetadataSet();
+
+    virtual ByteArray GetMetadata(SizeType p_vectorID) const = 0;
+
+    virtual SizeType Count() const = 0;
+
+    virtual bool Available() const = 0;
+
+    virtual std::pair<std::uint64_t, std::uint64_t> BufferSize() const = 0;
+
+    virtual void AddBatch(MetadataSet& data) = 0;
+
+    virtual ErrorCode SaveMetadata(std::ostream& p_metaOut, std::ostream& p_metaIndexOut) = 0;
+
+    virtual ErrorCode SaveMetadata(const std::string& p_metaFile, const std::string& p_metaindexFile) = 0;
+
+    virtual ErrorCode RefineMetadata(std::vector<SizeType>& indices, std::ostream& p_metaOut, std::ostream& p_metaIndexOut);
+
+    virtual ErrorCode RefineMetadata(std::vector<SizeType>& indices, const std::string& p_metaFile, const std::string& p_metaindexFile);
+};
+
+
+class FileMetadataSet : public MetadataSet
+{
+public:
+    FileMetadataSet(const std::string& p_metaFile, const std::string& p_metaindexFile);
+    
+    ~FileMetadataSet();
+
+    ByteArray GetMetadata(SizeType p_vectorID) const;
+
+    SizeType Count() const;
+
+    bool Available() const;
+
+    std::pair<std::uint64_t, std::uint64_t> BufferSize() const;
+
+    void AddBatch(MetadataSet& data);
+
+    ErrorCode SaveMetadata(std::ostream& p_metaOut, std::ostream& p_metaIndexOut);
+
+    ErrorCode SaveMetadata(const std::string& p_metaFile, const std::string& p_metaindexFile);
+
+private:
+    std::ifstream* m_fp = nullptr;
+
+    std::vector<std::uint64_t> m_pOffsets;
+
+    SizeType m_count;
+
+    std::string m_metaFile;
+
+    std::string m_metaindexFile;
+
+    std::vector<std::uint8_t> m_newdata;
+};
+
+
+class MemMetadataSet : public MetadataSet
+{
+public:
+    MemMetadataSet(ByteArray p_metadata, ByteArray p_offsets, SizeType p_count);
+
+    ~MemMetadataSet();
+
+    ByteArray GetMetadata(SizeType p_vectorID) const;
+
+    SizeType Count() const;
+
+    bool Available() const;
+
+    std::pair<std::uint64_t, std::uint64_t> BufferSize() const;
+
+    void AddBatch(MetadataSet& data);
+
+    ErrorCode SaveMetadata(std::ostream& p_metaOut, std::ostream& p_metaIndexOut);
+
+    ErrorCode SaveMetadata(const std::string& p_metaFile, const std::string& p_metaindexFile);
+
+private:
+    std::vector<std::uint64_t> m_offsets;
+
+    SizeType m_count;
+
+    ByteArray m_metadataHolder;
+
+    ByteArray m_offsetHolder;
+
+    std::vector<std::uint8_t> m_newdata;
+};
+
+
+} // namespace SPTAG
+
+#endif // _SPTAG_METADATASET_H_
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/SearchQuery.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/SearchQuery.h
new file mode 100644
index 0000000000..017b1e2e01
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/SearchQuery.h
@@ -0,0 +1,193 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_SEARCHQUERY_H_
+#define _SPTAG_SEARCHQUERY_H_
+
+#include "SearchResult.h"
+
+#include <cstring>
+
+namespace SPTAG
+{
+
+// Space to save temporary answer, similar with TopKCache
+class QueryResult
+{
+public:
+    typedef BasicResult* iterator;
+    typedef const BasicResult* const_iterator;
+
+    QueryResult()
+        : m_target(nullptr),
+          m_resultNum(0),
+          m_withMeta(false)
+    {
+    }
+
+
+    QueryResult(const void* p_target, int p_resultNum, bool p_withMeta)
+    {
+        Init(p_target, p_resultNum, p_withMeta);
+    }
+
+    
+    QueryResult(const void* p_target, int p_resultNum, bool p_withMeta, BasicResult* p_results)
+        : m_target(p_target),
+          m_resultNum(p_resultNum),
+          m_withMeta(p_withMeta)
+    {
+        m_results.Set(p_results, p_resultNum, false);
+    }
+
+
+    QueryResult(const QueryResult& p_other)
+    {
+        Init(p_other.m_target, p_other.m_resultNum, p_other.m_withMeta);
+        if (m_resultNum > 0)
+        {
+            std::copy(p_other.m_results.Data(), p_other.m_results.Data() + m_resultNum, m_results.Data());
+        }
+    }
+
+
+    QueryResult& operator=(const QueryResult& p_other)
+    {
+        Init(p_other.m_target, p_other.m_resultNum, p_other.m_withMeta);
+        if (m_resultNum > 0)
+        {
+            std::copy(p_other.m_results.Data(), p_other.m_results.Data() + m_resultNum, m_results.Data());
+        }
+
+        return *this;
+    }
+
+
+    ~QueryResult()
+    {
+    }
+
+
+    inline void Init(const void* p_target, int p_resultNum, bool p_withMeta)
+    {
+        m_target = p_target;
+        m_resultNum = p_resultNum;
+        m_withMeta = p_withMeta;
+
+        m_results = Array<BasicResult>::Alloc(p_resultNum);
+    }
+
+
+    inline int GetResultNum() const
+    {
+        return m_resultNum;
+    }
+
+
+    inline const void* GetTarget()
+    {
+        return m_target;
+    }
+
+
+    inline void SetTarget(const void* p_target)
+    {
+        m_target = p_target;
+    }
+
+
+    inline BasicResult* GetResult(int i) const
+    {
+        return i < m_resultNum ? m_results.Data() + i : nullptr;
+    }
+
+
+    inline void SetResult(int p_index, SizeType p_VID, float p_dist)
+    {
+        if (p_index < m_resultNum)
+        {
+            m_results[p_index].VID = p_VID;
+            m_results[p_index].Dist = p_dist;
+        }
+    }
+
+
+    inline BasicResult* GetResults() const
+    {
+        return m_results.Data();
+    }
+
+
+    inline bool WithMeta() const
+    {
+        return m_withMeta;
+    }
+
+
+    inline const ByteArray& GetMetadata(int p_index) const
+    {
+        if (p_index < m_resultNum && m_withMeta)
+        {
+            return m_results[p_index].Meta;
+        }
+
+        return ByteArray::c_empty;
+    }
+
+
+    inline void SetMetadata(int p_index, ByteArray p_metadata)
+    {
+        if (p_index < m_resultNum && m_withMeta)
+        {
+            m_results[p_index].Meta = std::move(p_metadata);
+        }
+    }
+
+
+    inline void Reset()
+    {
+        for (int i = 0; i < m_resultNum; i++)
+        {
+            m_results[i].VID = -1;
+            m_results[i].Dist = MaxDist;
+            m_results[i].Meta.Clear();
+        }
+    }
+
+
+    iterator begin()
+    {
+        return m_results.Data();
+    }
+
+
+    iterator end()
+    {
+        return m_results.Data() + m_resultNum;
+    }
+
+
+    const_iterator begin() const
+    {
+        return m_results.Data();
+    }
+
+
+    const_iterator end() const
+    {
+        return m_results.Data() + m_resultNum;
+    }
+
+
+protected:
+    const void* m_target;
+
+    int m_resultNum;
+
+    bool m_withMeta;
+
+    Array<BasicResult> m_results;
+};
+} // namespace SPTAG
+
+#endif // _SPTAG_SEARCHQUERY_H_
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/SearchResult.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/SearchResult.h
new file mode 100644
index 0000000000..64e173030b
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/SearchResult.h
@@ -0,0 +1,26 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_SEARCHRESULT_H_
+#define _SPTAG_SEARCHRESULT_H_
+
+#include "CommonDataStructure.h"
+
+namespace SPTAG
+{
+    struct BasicResult
+    {
+        SizeType VID;
+        float Dist;
+        ByteArray Meta;
+
+        BasicResult() : VID(-1), Dist(MaxDist) {}
+
+        BasicResult(SizeType p_vid, float p_dist) : VID(p_vid), Dist(p_dist) {}
+
+        BasicResult(SizeType p_vid, float p_dist, ByteArray p_meta) : VID(p_vid), Dist(p_dist), Meta(p_meta) {}
+    };
+
+} // namespace SPTAG
+
+#endif // _SPTAG_SEARCHRESULT_H_
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/VectorIndex.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/VectorIndex.h
new file mode 100644
index 0000000000..49475794d5
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/VectorIndex.h
@@ -0,0 +1,128 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_VECTORINDEX_H_
+#define _SPTAG_VECTORINDEX_H_
+
+#include "Common.h"
+#include "SearchQuery.h"
+#include "VectorSet.h"
+#include "MetadataSet.h"
+#include "inc/Helper/SimpleIniReader.h"
+
+#include <unordered_map>
+
+namespace SPTAG
+{
+
+class VectorIndex
+{
+public:
+    VectorIndex();
+
+    virtual ~VectorIndex();
+
+    virtual ErrorCode BuildIndex(const void* p_data, SizeType p_vectorNum, DimensionType p_dimension) = 0;
+
+    virtual ErrorCode AddIndex(const void* p_vectors, SizeType p_vectorNum, DimensionType p_dimension, SizeType* p_start = nullptr) = 0;
+
+    virtual ErrorCode DeleteIndex(const void* p_vectors, SizeType p_vectorNum) = 0;
+
+    virtual ErrorCode SearchIndex(QueryResult& p_results) const = 0;
+    
+    virtual float ComputeDistance(const void* pX, const void* pY) const = 0;
+    virtual const void* GetSample(const SizeType idx) const = 0;
+    virtual bool ContainSample(const SizeType idx) const = 0;
+    virtual bool NeedRefine() const = 0;
+   
+    virtual DimensionType GetFeatureDim() const = 0;
+    virtual SizeType GetNumSamples() const = 0;
+
+    virtual DistCalcMethod GetDistCalcMethod() const = 0;
+    virtual IndexAlgoType GetIndexAlgoType() const = 0;
+    virtual VectorValueType GetVectorValueType() const = 0;
+
+    virtual std::string GetParameter(const char* p_param) const = 0;
+    virtual ErrorCode SetParameter(const char* p_param, const char* p_value) = 0;
+
+    virtual std::shared_ptr<std::vector<std::uint64_t>> CalculateBufferSize() const;
+
+    virtual ErrorCode LoadIndex(const std::string& p_config, const std::vector<ByteArray>& p_indexBlobs);
+
+    virtual ErrorCode LoadIndex(const std::string& p_folderPath);
+
+    virtual ErrorCode SaveIndex(std::string& p_config, const std::vector<ByteArray>& p_indexBlobs);
+
+    virtual ErrorCode SaveIndex(const std::string& p_folderPath);
+
+    virtual ErrorCode BuildIndex(std::shared_ptr<VectorSet> p_vectorSet, std::shared_ptr<MetadataSet> p_metadataSet, bool p_withMetaIndex = false);
+    
+    virtual ErrorCode AddIndex(std::shared_ptr<VectorSet> p_vectorSet, std::shared_ptr<MetadataSet> p_metadataSet);
+
+    virtual ErrorCode DeleteIndex(ByteArray p_meta);
+
+    virtual const void* GetSample(ByteArray p_meta);
+
+    virtual ErrorCode SearchIndex(const void* p_vector, int p_neighborCount, bool p_withMeta, BasicResult* p_results) const;
+
+    virtual std::string GetParameter(const std::string& p_param) const;
+    virtual ErrorCode SetParameter(const std::string& p_param, const std::string& p_value);
+
+    virtual ByteArray GetMetadata(SizeType p_vectorID) const;
+    virtual void SetMetadata(const std::string& p_metadataFilePath, const std::string& p_metadataIndexPath);
+
+    virtual std::string GetIndexName() const 
+    { 
+        if (m_sIndexName == "") return Helper::Convert::ConvertToString(GetIndexAlgoType());
+        return m_sIndexName; 
+    }
+    virtual void SetIndexName(std::string p_name) { m_sIndexName = p_name; }
+
+    static std::shared_ptr<VectorIndex> CreateInstance(IndexAlgoType p_algo, VectorValueType p_valuetype);
+
+    static ErrorCode MergeIndex(const char* p_indexFilePath1, const char* p_indexFilePath2);
+    
+    static ErrorCode LoadIndex(const std::string& p_loaderFilePath, std::shared_ptr<VectorIndex>& p_vectorIndex);
+
+    static ErrorCode LoadIndex(const std::string& p_config, const std::vector<ByteArray>& p_indexBlobs, std::shared_ptr<VectorIndex>& p_vectorIndex);
+
+protected:
+    virtual std::shared_ptr<std::vector<std::uint64_t>> BufferSize() const = 0;
+
+    virtual ErrorCode SaveConfig(std::ostream& p_configout) const = 0;
+
+    virtual ErrorCode SaveIndexData(const std::string& p_folderPath) = 0;
+
+    virtual ErrorCode SaveIndexData(const std::vector<std::ostream*>& p_indexStreams) = 0;
+
+    virtual ErrorCode LoadConfig(Helper::IniReader& p_reader) = 0;
+
+    virtual ErrorCode LoadIndexData(const std::string& p_folderPath) = 0;
+
+    virtual ErrorCode LoadIndexDataFromMemory(const std::vector<ByteArray>& p_indexBlobs) = 0;
+
+    virtual ErrorCode DeleteIndex(const SizeType& p_id) = 0;
+
+    virtual ErrorCode RefineIndex(const std::string& p_folderPath) = 0;
+
+    virtual ErrorCode RefineIndex(const std::vector<std::ostream*>& p_indexStreams) = 0;
+
+private:
+    void BuildMetaMapping();
+
+    ErrorCode LoadIndexConfig(Helper::IniReader& p_reader);
+
+    ErrorCode SaveIndexConfig(std::ostream& p_configOut);
+
+protected:
+    std::string m_sIndexName;
+    std::string m_sMetadataFile = "metadata.bin";
+    std::string m_sMetadataIndexFile = "metadataIndex.bin";
+    std::shared_ptr<MetadataSet> m_pMetadata;
+    std::unique_ptr<std::unordered_map<std::string, SizeType>> m_pMetaToVec;
+};
+
+
+} // namespace SPTAG
+
+#endif // _SPTAG_VECTORINDEX_H_
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/VectorSet.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/VectorSet.h
new file mode 100644
index 0000000000..c394c701ff
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Core/VectorSet.h
@@ -0,0 +1,73 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_VECTORSET_H_
+#define _SPTAG_VECTORSET_H_
+
+#include "CommonDataStructure.h"
+
+namespace SPTAG
+{
+
+class VectorSet
+{
+public:
+    VectorSet();
+
+    virtual ~VectorSet();
+
+    virtual VectorValueType GetValueType() const = 0;
+
+    virtual void* GetVector(SizeType p_vectorID) const = 0;
+
+    virtual void* GetData() const = 0;
+
+    virtual DimensionType Dimension() const = 0;
+
+    virtual SizeType Count() const = 0;
+
+    virtual bool Available() const = 0;
+
+    virtual ErrorCode Save(const std::string& p_vectorFile) const = 0;
+};
+
+
+class BasicVectorSet : public VectorSet
+{
+public:
+    BasicVectorSet(const ByteArray& p_bytesArray,
+                   VectorValueType p_valueType,
+                   DimensionType p_dimension,
+                   SizeType p_vectorCount);
+
+    virtual ~BasicVectorSet();
+
+    virtual VectorValueType GetValueType() const;
+
+    virtual void* GetVector(SizeType p_vectorID) const;
+
+    virtual void* GetData() const;
+
+    virtual DimensionType Dimension() const;
+
+    virtual SizeType Count() const;
+
+    virtual bool Available() const;
+
+    virtual ErrorCode Save(const std::string& p_vectorFile) const;
+
+private:
+    ByteArray m_data;
+
+    VectorValueType m_valueType;
+
+    DimensionType m_dimension;
+
+    SizeType m_vectorCount;
+
+    SizeType m_perVectorDataSize;
+};
+
+} // namespace SPTAG
+
+#endif // _SPTAG_VECTORSET_H_
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Helper/ArgumentsParser.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Helper/ArgumentsParser.h
new file mode 100644
index 0000000000..0ae19b8e8f
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Helper/ArgumentsParser.h
@@ -0,0 +1,253 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_HELPER_ARGUMENTSPARSER_H_
+#define _SPTAG_HELPER_ARGUMENTSPARSER_H_
+
+#include "inc/Helper/StringConvert.h"
+
+#include <cstdint>
+#include <cstddef> 
+#include <memory>
+#include <vector>
+#include <string>
+
+namespace SPTAG
+{
+namespace Helper
+{
+
+class ArgumentsParser
+{
+public:
+    ArgumentsParser();
+
+    virtual ~ArgumentsParser();
+
+    virtual bool Parse(int p_argc, char** p_args);
+
+    virtual void PrintHelp();
+
+protected:
+    class IArgument
+    {
+    public:
+        IArgument();
+
+        virtual ~IArgument();
+
+        virtual bool ParseValue(int& p_restArgc, char** (&p_args)) = 0;
+
+        virtual void PrintDescription(FILE* p_output) = 0;
+
+        virtual bool IsRequiredButNotSet() const = 0;
+    };
+
+
+    template<typename DataType>
+    class ArgumentT : public IArgument
+    {
+    public:
+        ArgumentT(DataType& p_target,
+                  const std::string& p_representStringShort,
+                  const std::string& p_representString,
+                  const std::string& p_description,
+                  bool p_followedValue,
+                  const DataType& p_switchAsValue,
+                  bool p_isRequired)
+            : m_value(p_target),
+              m_representStringShort(p_representStringShort),
+              m_representString(p_representString),
+              m_description(p_description),
+              m_followedValue(p_followedValue),
+              c_switchAsValue(p_switchAsValue),
+              m_isRequired(p_isRequired),
+              m_isSet(false)
+        {
+        }
+
+        virtual ~ArgumentT()
+        {
+        }
+
+
+        virtual bool ParseValue(int& p_restArgc, char** (&p_args))
+        {
+            if (0 == p_restArgc)
+            {
+                return true;
+            }
+
+            if (0 != strcmp(*p_args, m_representString.c_str())
+                && 0 != strcmp(*p_args, m_representStringShort.c_str()))
+            {
+                return true;
+            }
+
+            if (!m_followedValue)
+            {
+                m_value = c_switchAsValue;
+                --p_restArgc;
+                ++p_args;
+                m_isSet = true;
+                return true;
+            }
+
+            if (p_restArgc < 2)
+            {
+                return false;
+            }
+
+            DataType tmp;
+            if (!Helper::Convert::ConvertStringTo(p_args[1], tmp))
+            {
+                return false;
+            }
+
+            m_value = std::move(tmp);
+
+            p_restArgc -= 2;
+            p_args += 2;
+            m_isSet = true;
+            return true;
+        }
+
+
+        virtual void PrintDescription(FILE* p_output)
+        {
+            std::size_t padding = 30;
+            if (!m_representStringShort.empty())
+            {
+                fprintf(p_output, "%s", m_representStringShort.c_str());
+                padding -= m_representStringShort.size();
+            }
+
+            if (!m_representString.empty())
+            {
+                if (!m_representStringShort.empty())
+                {
+                    fprintf(p_output, ", ");
+                    padding -= 2;
+                }
+
+                fprintf(p_output, "%s", m_representString.c_str());
+                padding -= m_representString.size();
+            }
+
+            if (m_followedValue)
+            {
+                fprintf(p_output, " <value>");
+                padding -= 8;
+            }
+
+            while (padding-- > 0)
+            {
+                fputc(' ', p_output);
+            }
+
+            fprintf(p_output, "%s", m_description.c_str());
+        }
+
+
+        virtual bool IsRequiredButNotSet() const
+        {
+            return m_isRequired && !m_isSet;
+        }
+
+    private:
+        DataType & m_value;
+
+        std::string m_representStringShort;
+
+        std::string m_representString;
+
+        std::string m_description;
+
+        bool m_followedValue;
+
+        const DataType c_switchAsValue;
+
+        bool m_isRequired;
+
+        bool m_isSet;
+    };
+
+
+    template<typename DataType>
+    void AddRequiredOption(DataType& p_target,
+                           const std::string& p_representStringShort,
+                           const std::string& p_representString,
+                           const std::string& p_description)
+    {
+        m_arguments.emplace_back(std::shared_ptr<IArgument>(
+            new ArgumentT<DataType>(p_target,
+                                    p_representStringShort,
+                                    p_representString,
+                                    p_description,
+                                    true,
+                                    DataType(),
+                                    true)));
+    }
+
+
+    template<typename DataType>
+    void AddOptionalOption(DataType& p_target,
+                           const std::string& p_representStringShort,
+                           const std::string& p_representString,
+                           const std::string& p_description)
+    {
+        m_arguments.emplace_back(std::shared_ptr<IArgument>(
+            new ArgumentT<DataType>(p_target,
+                                    p_representStringShort,
+                                    p_representString,
+                                    p_description,
+                                    true,
+                                    DataType(),
+                                    false)));
+    }
+
+
+    template<typename DataType>
+    void AddRequiredSwitch(DataType& p_target,
+                           const std::string& p_representStringShort,
+                           const std::string& p_representString,
+                           const std::string& p_description,
+                           const DataType& p_switchAsValue)
+    {
+        m_arguments.emplace_back(std::shared_ptr<IArgument>(
+            new ArgumentT<DataType>(p_target,
+                                    p_representStringShort,
+                                    p_representString,
+                                    p_description,
+                                    false,
+                                    p_switchAsValue,
+                                    true)));
+    }
+
+
+    template<typename DataType>
+    void AddOptionalSwitch(DataType& p_target,
+                           const std::string& p_representStringShort,
+                           const std::string& p_representString,
+                           const std::string& p_description,
+                           const DataType& p_switchAsValue)
+    {
+        m_arguments.emplace_back(std::shared_ptr<IArgument>(
+            new ArgumentT<DataType>(p_target,
+                                    p_representStringShort,
+                                    p_representString,
+                                    p_description,
+                                    false,
+                                    p_switchAsValue,
+                                    false)));
+    }
+
+private:
+    std::vector<std::shared_ptr<IArgument>> m_arguments;
+};
+
+
+} // namespace Helper
+} // namespace SPTAG
+
+#endif // _SPTAG_HELPER_ARGUMENTSPARSER_H_
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Helper/Base64Encode.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Helper/Base64Encode.h
new file mode 100644
index 0000000000..8e7919345d
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Helper/Base64Encode.h
@@ -0,0 +1,33 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_HELPER_BASE64ENCODE_H_
+#define _SPTAG_HELPER_BASE64ENCODE_H_
+
+#include <cstdint>
+#include <cstddef> 
+#include <ostream>
+
+namespace SPTAG
+{
+namespace Helper
+{
+namespace Base64
+{
+
+bool Encode(const std::uint8_t* p_in, std::size_t p_inLen, char* p_out, std::size_t& p_outLen);
+
+bool Encode(const std::uint8_t* p_in, std::size_t p_inLen, std::ostream& p_out, std::size_t& p_outLen);
+
+bool Decode(const char* p_in, std::size_t p_inLen, std::uint8_t* p_out, std::size_t& p_outLen);
+
+std::size_t CapacityForEncode(std::size_t p_inLen);
+
+std::size_t CapacityForDecode(std::size_t p_inLen);
+
+
+} // namespace Base64
+} // namespace Helper
+} // namespace SPTAG
+
+#endif // _SPTAG_HELPER_BASE64ENCODE_H_
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Helper/BufferStream.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Helper/BufferStream.h
new file mode 100644
index 0000000000..c97be04f12
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Helper/BufferStream.h
@@ -0,0 +1,39 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_HELPER_BUFFERSTREAM_H_
+#define _SPTAG_HELPER_BUFFERSTREAM_H_
+
+#include <streambuf>
+#include <ostream>
+#include <memory>
+
+namespace SPTAG
+{
+    namespace Helper
+    {
+        struct streambuf : public std::basic_streambuf<char> 
+        {
+            streambuf(char* buffer, size_t size)
+            {
+                setp(buffer, buffer + size);
+            }
+        };
+
+        class obufferstream : public std::ostream
+        {
+        public:
+            obufferstream(streambuf* buf, bool transferOwnership) : std::ostream(buf)
+            {
+                if (transferOwnership)
+                    m_bufHolder.reset(buf, std::default_delete<streambuf>());
+            }
+
+        private:
+            std::shared_ptr<streambuf> m_bufHolder;
+        };
+    } // namespace Helper
+} // namespace SPTAG
+
+#endif // _SPTAG_HELPER_BUFFERSTREAM_H_
+
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Helper/CommonHelper.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Helper/CommonHelper.h
new file mode 100644
index 0000000000..7f14784707
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Helper/CommonHelper.h
@@ -0,0 +1,40 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_HELPER_COMMONHELPER_H_
+#define _SPTAG_HELPER_COMMONHELPER_H_
+
+#include "../Core/Common.h"
+
+#include <string>
+#include <vector>
+#include <cctype>
+#include <functional>
+#include <limits>
+#include <cerrno>
+
+
+namespace SPTAG
+{
+namespace Helper
+{
+namespace StrUtils
+{
+
+void ToLowerInPlace(std::string& p_str);
+
+std::vector<std::string> SplitString(const std::string& p_str, const std::string& p_separator);
+
+std::pair<const char*, const char*> FindTrimmedSegment(const char* p_begin,
+                                                       const char* p_end,
+                                                       const std::function<bool(char)>& p_isSkippedChar);
+
+bool StartsWith(const char* p_str, const char* p_prefix);
+
+bool StrEqualIgnoreCase(const char* p_left, const char* p_right);
+
+} // namespace StrUtils
+} // namespace Helper
+} // namespace SPTAG
+
+#endif // _SPTAG_HELPER_COMMONHELPER_H_
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Helper/Concurrent.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Helper/Concurrent.h
new file mode 100644
index 0000000000..35c7cc93e4
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Helper/Concurrent.h
@@ -0,0 +1,97 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_HELPER_CONCURRENT_H_
+#define _SPTAG_HELPER_CONCURRENT_H_
+
+
+#include <atomic>
+#include <condition_variable>
+#include <mutex>
+
+
+namespace SPTAG
+{
+namespace Helper
+{
+namespace Concurrent
+{
+
+class SpinLock
+{
+public:
+    SpinLock() = default;
+
+    void Lock() noexcept 
+    {
+        while (m_lock.test_and_set(std::memory_order_acquire))
+        {
+        }
+    }
+
+    void Unlock() noexcept 
+    {
+        m_lock.clear(std::memory_order_release);
+    }
+
+    SpinLock(const SpinLock&) = delete;
+    SpinLock& operator = (const SpinLock&) = delete;
+
+private:
+    std::atomic_flag m_lock = ATOMIC_FLAG_INIT;
+};
+
+template<typename Lock>
+class LockGuard {
+public:
+    LockGuard(Lock& lock) noexcept 
+        : m_lock(lock) {
+        lock.Lock();
+    }
+
+    LockGuard(Lock& lock, std::adopt_lock_t) noexcept
+        : m_lock(lock) {}
+
+    ~LockGuard() {
+        m_lock.Unlock();
+    }
+
+    LockGuard(const LockGuard&) = delete;
+    LockGuard& operator=(const LockGuard&) = delete;
+
+private:
+    Lock& m_lock;
+};
+
+
+class WaitSignal
+{
+public:
+    WaitSignal();
+
+    WaitSignal(std::uint32_t p_unfinished);
+
+    ~WaitSignal();
+
+    void Reset(std::uint32_t p_unfinished);
+
+    void Wait();
+
+    void FinishOne();
+
+private:
+    std::atomic<std::uint32_t> m_unfinished;
+
+    std::atomic_bool m_isWaiting;
+
+    std::mutex m_mutex;
+
+    std::condition_variable m_cv;
+};
+
+
+} // namespace Base64
+} // namespace Helper
+} // namespace SPTAG
+
+#endif // _SPTAG_HELPER_CONCURRENT_H_
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Helper/ConcurrentSet.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Helper/ConcurrentSet.h
new file mode 100644
index 0000000000..61254dc2eb
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Helper/ConcurrentSet.h
@@ -0,0 +1,148 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_HELPER_CONCURRENTSET_H_
+#define _SPTAG_HELPER_CONCURRENTSET_H_
+
+#include <shared_mutex>
+#include <unordered_set>
+
+namespace SPTAG
+{
+    namespace Helper
+    {
+        namespace Concurrent
+        {
+            template <typename T>
+            class ConcurrentSet
+            {
+            public:
+                ConcurrentSet();
+
+                ~ConcurrentSet();
+
+                size_t size() const;
+
+                bool contains(const T& key) const;
+
+                void insert(const T& key);
+
+                std::shared_timed_mutex& getLock();
+
+                bool save(std::ostream& output);
+
+                bool save(std::string filename);
+
+                bool load(std::string filename);
+
+                bool load(char* pmemoryFile);
+
+                std::uint64_t bufferSize() const;
+
+            private:
+                std::unique_ptr<std::shared_timed_mutex> m_lock;
+                std::unordered_set<T> m_data;
+            };
+
+            template<typename T>
+            ConcurrentSet<T>::ConcurrentSet()
+            {
+                m_lock.reset(new std::shared_timed_mutex);
+            }
+
+            template<typename T>
+            ConcurrentSet<T>::~ConcurrentSet()
+            {
+            }
+
+            template<typename T>
+            size_t ConcurrentSet<T>::size() const
+            {
+                std::shared_lock<std::shared_timed_mutex> lock(*m_lock);
+                return m_data.size();
+            }
+
+            template<typename T>
+            bool ConcurrentSet<T>::contains(const T& key) const
+            {
+                std::shared_lock<std::shared_timed_mutex> lock(*m_lock);
+                return (m_data.find(key) != m_data.end());
+            }
+
+            template<typename T>
+            void ConcurrentSet<T>::insert(const T& key)
+            {
+                std::unique_lock<std::shared_timed_mutex> lock(*m_lock);
+                m_data.insert(key);
+            }
+
+            template<typename T>
+            std::shared_timed_mutex& ConcurrentSet<T>::getLock()
+            {
+                return *m_lock;
+            }
+
+            template<typename T>
+            std::uint64_t ConcurrentSet<T>::bufferSize() const
+            {
+                return sizeof(SizeType) + sizeof(T) * m_data.size();
+            }
+
+            template<typename T>
+            bool ConcurrentSet<T>::save(std::ostream& output)
+            {
+                SizeType count = (SizeType)m_data.size();
+                output.write((char*)&count, sizeof(SizeType));
+                for (auto iter = m_data.begin(); iter != m_data.end(); iter++)
+                    output.write((char*)&(*iter), sizeof(T));
+                std::cout << "Save DeleteID (" << count << ") Finish!" << std::endl;
+                return true;
+            }
+
+            template<typename T>
+            bool ConcurrentSet<T>::save(std::string filename)
+            {
+                std::cout << "Save DeleteID To " << filename << std::endl;
+                std::ofstream output(filename, std::ios::binary);
+                if (!output.is_open()) return false;
+                save(output);
+                output.close();
+                return true;
+            }
+
+            template<typename T>
+            bool ConcurrentSet<T>::load(std::string filename)
+            {
+                std::cout << "Load DeleteID From " << filename << std::endl;
+                std::ifstream input(filename, std::ios::binary);
+                if (!input.is_open()) return false;
+
+                SizeType count;
+                T ID;
+                input.read((char*)&count, sizeof(SizeType));
+                for (SizeType i = 0; i < count; i++)
+                {
+                    input.read((char*)&ID, sizeof(T));
+                    m_data.insert(ID);
+                }
+                input.close();
+                std::cout << "Load DeleteID (" << count << ") Finish!" << std::endl;
+                return true;
+            }
+
+            template<typename T>
+            bool ConcurrentSet<T>::load(char* pmemoryFile)
+            {
+                SizeType count;
+                count = *((SizeType*)pmemoryFile);
+                pmemoryFile += sizeof(SizeType);
+
+                m_data.insert((T*)pmemoryFile, ((T*)pmemoryFile) + count);
+                pmemoryFile += sizeof(T) * count;
+                std::cout << "Load DeleteID (" << count << ") Finish!" << std::endl;
+                return true;
+            }
+        }
+    }
+}
+#endif // _SPTAG_HELPER_CONCURRENTSET_H_
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Helper/SimpleIniReader.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Helper/SimpleIniReader.h
new file mode 100644
index 0000000000..ad8d58f6f7
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Helper/SimpleIniReader.h
@@ -0,0 +1,99 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_HELPER_INIREADER_H_
+#define _SPTAG_HELPER_INIREADER_H_
+
+#include "../Core/Common.h"
+#include "StringConvert.h"
+
+#include <vector>
+#include <map>
+#include <memory>
+#include <string>
+#include <sstream>
+
+
+namespace SPTAG
+{
+namespace Helper
+{
+
+// Simple INI Reader with basic functions. Case insensitive.
+class IniReader
+{
+public:
+    typedef std::map<std::string, std::string> ParameterValueMap;
+
+    IniReader();
+
+    ~IniReader();
+
+    ErrorCode LoadIniFile(const std::string& p_iniFilePath);
+
+    ErrorCode LoadIni(std::istream& p_input);
+
+    bool DoesSectionExist(const std::string& p_section) const;
+
+    bool DoesParameterExist(const std::string& p_section, const std::string& p_param) const;
+
+    const ParameterValueMap& GetParameters(const std::string& p_section) const;
+
+    template <typename DataType>
+    DataType GetParameter(const std::string& p_section, const std::string& p_param, const DataType& p_defaultVal) const;
+
+    void SetParameter(const std::string& p_section, const std::string& p_param, const std::string& p_val);
+
+private:
+    bool GetRawValue(const std::string& p_section, const std::string& p_param, std::string& p_value) const;
+
+    template <typename DataType>
+    static inline DataType ConvertStringTo(std::string&& p_str, const DataType& p_defaultVal);
+
+private:
+    const static ParameterValueMap c_emptyParameters;
+
+    std::map<std::string, std::shared_ptr<ParameterValueMap>> m_parameters;
+};
+
+
+template <typename DataType>
+DataType
+IniReader::GetParameter(const std::string& p_section, const std::string& p_param, const DataType& p_defaultVal) const
+{
+    std::string value;
+    if (!GetRawValue(p_section, p_param, value))
+    {
+        return p_defaultVal;
+    }
+
+    return ConvertStringTo<DataType>(std::move(value), p_defaultVal);
+}
+
+
+template <typename DataType>
+inline DataType
+IniReader::ConvertStringTo(std::string&& p_str, const DataType& p_defaultVal)
+{
+    DataType value;
+    if (Convert::ConvertStringTo<DataType>(p_str.c_str(), value))
+    {
+        return value;
+    }
+
+    return p_defaultVal;
+}
+
+
+template <>
+inline std::string
+IniReader::ConvertStringTo<std::string>(std::string&& p_str, const std::string& p_defaultVal)
+{
+    return std::move(p_str);
+}
+
+
+} // namespace Helper
+} // namespace SPTAG
+
+#endif // _SPTAG_HELPER_INIREADER_H_
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Helper/StringConvert.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Helper/StringConvert.h
new file mode 100644
index 0000000000..b6e53df785
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Helper/StringConvert.h
@@ -0,0 +1,374 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_HELPER_STRINGCONVERTHELPER_H_
+#define _SPTAG_HELPER_STRINGCONVERTHELPER_H_
+
+#include "inc/Core/Common.h"
+#include "CommonHelper.h"
+
+#include <string>
+#include <cstring>
+#include <sstream>
+#include <cctype>
+#include <limits>
+#include <cerrno>
+
+namespace SPTAG
+{
+namespace Helper
+{
+namespace Convert
+{
+
+template <typename DataType>
+inline bool ConvertStringTo(const char* p_str, DataType& p_value)
+{
+    if (nullptr == p_str)
+    {
+        return false;
+    }
+
+    std::istringstream sstream;
+    sstream.str(p_str);
+    if (p_str >> p_value)
+    {
+        return true;
+    }
+
+    return false;
+}
+
+
+template<typename DataType>
+inline std::string ConvertToString(const DataType& p_value)
+{
+    return std::to_string(p_value);
+}
+
+
+// Specialization of ConvertStringTo<>().
+
+template <typename DataType>
+inline bool ConvertStringToSignedInt(const char* p_str, DataType& p_value)
+{
+    static_assert(std::is_integral<DataType>::value && std::is_signed<DataType>::value, "type check");
+
+    if (nullptr == p_str)
+    {
+        return false;
+    }
+
+    char* end = nullptr;
+    errno = 0;
+    auto val = std::strtoll(p_str, &end, 10);
+    if (errno == ERANGE || end == p_str || *end != '\0')
+    {
+        return false;
+    }
+
+    if (val < (std::numeric_limits<DataType>::min)() || val >(std::numeric_limits<DataType>::max)())
+    {
+        return false;
+    }
+
+    p_value = static_cast<DataType>(val);
+    return true;
+}
+
+
+template <typename DataType>
+inline bool ConvertStringToUnsignedInt(const char* p_str, DataType& p_value)
+{
+    static_assert(std::is_integral<DataType>::value && std::is_unsigned<DataType>::value, "type check");
+
+    if (nullptr == p_str)
+    {
+        return false;
+    }
+
+    char* end = nullptr;
+    errno = 0;
+    auto val = std::strtoull(p_str, &end, 10);
+    if (errno == ERANGE || end == p_str || *end != '\0')
+    {
+        return false;
+    }
+
+    if (val < (std::numeric_limits<DataType>::min)() || val >(std::numeric_limits<DataType>::max)())
+    {
+        return false;
+    }
+
+    p_value = static_cast<DataType>(val);
+    return true;
+}
+
+
+template <>
+inline bool ConvertStringTo<std::string>(const char* p_str, std::string& p_value)
+{
+    if (nullptr == p_str)
+    {
+        return false;
+    }
+
+    p_value = p_str;
+    return true;
+}
+
+
+template <>
+inline bool ConvertStringTo<float>(const char* p_str, float& p_value)
+{
+    if (nullptr == p_str)
+    {
+        return false;
+    }
+
+    char* end = nullptr;
+    errno = 0;
+    p_value = std::strtof(p_str, &end);
+    return (errno != ERANGE && end != p_str && *end == '\0');
+}
+
+
+template <>
+inline bool ConvertStringTo<double>(const char* p_str, double& p_value)
+{
+    if (nullptr == p_str)
+    {
+        return false;
+    }
+
+    char* end = nullptr;
+    errno = 0;
+    p_value = std::strtod(p_str, &end);
+    return (errno != ERANGE && end != p_str && *end == '\0');
+}
+
+
+template <>
+inline bool ConvertStringTo<std::int8_t>(const char* p_str, std::int8_t& p_value)
+{
+    return ConvertStringToSignedInt(p_str, p_value);
+}
+
+
+template <>
+inline bool ConvertStringTo<std::int16_t>(const char* p_str, std::int16_t& p_value)
+{
+    return ConvertStringToSignedInt(p_str, p_value);
+}
+
+
+template <>
+inline bool ConvertStringTo<std::int32_t>(const char* p_str, std::int32_t& p_value)
+{
+    return ConvertStringToSignedInt(p_str, p_value);
+}
+
+
+template <>
+inline bool ConvertStringTo<std::int64_t>(const char* p_str, std::int64_t& p_value)
+{
+    return ConvertStringToSignedInt(p_str, p_value);
+}
+
+
+template <>
+inline bool ConvertStringTo<std::uint8_t>(const char* p_str, std::uint8_t& p_value)
+{
+    return ConvertStringToUnsignedInt(p_str, p_value);
+}
+
+
+template <>
+inline bool ConvertStringTo<std::uint16_t>(const char* p_str, std::uint16_t& p_value)
+{
+    return ConvertStringToUnsignedInt(p_str, p_value);
+}
+
+
+template <>
+inline bool ConvertStringTo<std::uint32_t>(const char* p_str, std::uint32_t& p_value)
+{
+    return ConvertStringToUnsignedInt(p_str, p_value);
+}
+
+
+template <>
+inline bool ConvertStringTo<std::uint64_t>(const char* p_str, std::uint64_t& p_value)
+{
+    return ConvertStringToUnsignedInt(p_str, p_value);
+}
+
+
+template <>
+inline bool ConvertStringTo<bool>(const char* p_str, bool& p_value)
+{
+    if (StrUtils::StrEqualIgnoreCase(p_str, "true"))
+    {
+        p_value = true;
+        
+    }
+    else if (StrUtils::StrEqualIgnoreCase(p_str, "false"))
+    {
+        p_value = false;
+    }
+    else
+    {
+        return false;
+    }
+
+    return true;
+}
+
+
+template <>
+inline bool ConvertStringTo<IndexAlgoType>(const char* p_str, IndexAlgoType& p_value)
+{
+    if (nullptr == p_str)
+    {
+        return false;
+    }
+
+#define DefineIndexAlgo(Name) \
+    else if (StrUtils::StrEqualIgnoreCase(p_str, #Name)) \
+    { \
+        p_value = IndexAlgoType::Name; \
+        return true; \
+    } \
+
+#include "inc/Core/DefinitionList.h"
+#undef DefineIndexAlgo
+
+    return false;
+}
+
+
+template <>
+inline bool ConvertStringTo<DistCalcMethod>(const char* p_str, DistCalcMethod& p_value)
+{
+    if (nullptr == p_str)
+    {
+        return false;
+    }
+
+#define DefineDistCalcMethod(Name) \
+    else if (StrUtils::StrEqualIgnoreCase(p_str, #Name)) \
+    { \
+        p_value = DistCalcMethod::Name; \
+        return true; \
+    } \
+
+#include "inc/Core/DefinitionList.h"
+#undef DefineDistCalcMethod
+
+    return false;
+}
+
+
+template <>
+inline bool ConvertStringTo<VectorValueType>(const char* p_str, VectorValueType& p_value)
+{
+    if (nullptr == p_str)
+    {
+        return false;
+    }
+
+#define DefineVectorValueType(Name, Type) \
+    else if (StrUtils::StrEqualIgnoreCase(p_str, #Name)) \
+    { \
+        p_value = VectorValueType::Name; \
+        return true; \
+    } \
+
+#include "inc/Core/DefinitionList.h"
+#undef DefineVectorValueType
+
+    return false;
+}
+
+
+// Specialization of ConvertToString<>().
+
+template<>
+inline std::string ConvertToString<std::string>(const std::string& p_value)
+{
+    return p_value;
+}
+
+
+template<>
+inline std::string ConvertToString<bool>(const bool& p_value)
+{
+    return p_value ? "true" : "false";
+}
+
+
+template <>
+inline std::string ConvertToString<IndexAlgoType>(const IndexAlgoType& p_value)
+{
+    switch (p_value)
+    {
+#define DefineIndexAlgo(Name) \
+    case IndexAlgoType::Name: \
+        return #Name; \
+
+#include "inc/Core/DefinitionList.h"
+#undef DefineIndexAlgo
+
+    default:
+        break;
+    }
+
+    return "Undefined";
+}
+
+
+template <>
+inline std::string ConvertToString<DistCalcMethod>(const DistCalcMethod& p_value)
+{
+    switch (p_value)
+    {
+#define DefineDistCalcMethod(Name) \
+    case DistCalcMethod::Name: \
+        return #Name; \
+
+#include "inc/Core/DefinitionList.h"
+#undef DefineDistCalcMethod
+
+    default:
+        break;
+    }
+
+    return "Undefined";
+}
+
+
+template <>
+inline std::string ConvertToString<VectorValueType>(const VectorValueType& p_value)
+{
+    switch (p_value)
+    {
+#define DefineVectorValueType(Name, Type) \
+    case VectorValueType::Name: \
+        return #Name; \
+
+#include "inc/Core/DefinitionList.h"
+#undef DefineVectorValueType
+
+    default:
+        break;
+    }
+
+    return "Undefined";
+}
+
+
+} // namespace Convert
+} // namespace Helper
+} // namespace SPTAG
+
+#endif // _SPTAG_HELPER_STRINGCONVERTHELPER_H_
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Helper/VectorSetReader.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Helper/VectorSetReader.h
new file mode 100644
index 0000000000..cd148c1d04
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Helper/VectorSetReader.h
@@ -0,0 +1,59 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_HELPER_VECTORSETREADER_H_
+#define _SPTAG_HELPER_VECTORSETREADER_H_
+
+#include "inc/Core/Common.h"
+#include "inc/Core/VectorSet.h"
+#include "inc/Core/MetadataSet.h"
+#include "inc/Helper/ArgumentsParser.h"
+
+#include <memory>
+
+namespace SPTAG
+{
+namespace Helper
+{
+
+class ReaderOptions : public ArgumentsParser
+{
+public:
+    ReaderOptions(VectorValueType p_valueType, DimensionType p_dimension, std::string p_vectorDelimiter = "|", std::uint32_t p_threadNum = 32);
+
+    ~ReaderOptions();
+
+    std::uint32_t m_threadNum;
+
+    DimensionType m_dimension;
+
+    std::string m_vectorDelimiter;
+
+    SPTAG::VectorValueType m_inputValueType;
+};
+
+class VectorSetReader
+{
+public:
+    VectorSetReader(std::shared_ptr<ReaderOptions> p_options);
+
+    virtual ~VectorSetReader();
+
+    virtual ErrorCode LoadFile(const std::string& p_filePath) = 0;
+
+    virtual std::shared_ptr<VectorSet> GetVectorSet() const = 0;
+
+    virtual std::shared_ptr<MetadataSet> GetMetadataSet() const = 0;
+
+    static std::shared_ptr<VectorSetReader> CreateInstance(std::shared_ptr<ReaderOptions> p_options);
+
+protected:
+    std::shared_ptr<ReaderOptions> m_options;
+};
+
+
+
+} // namespace Helper
+} // namespace SPTAG
+
+#endif // _SPTAG_HELPER_VECTORSETREADER_H_
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Helper/VectorSetReaders/DefaultReader.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Helper/VectorSetReaders/DefaultReader.h
new file mode 100644
index 0000000000..52c8404caf
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Helper/VectorSetReaders/DefaultReader.h
@@ -0,0 +1,108 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_HELPER_VECTORSETREADERS_DEFAULTREADER_H_
+#define _SPTAG_HELPER_VECTORSETREADERS_DEFAULTREADER_H_
+
+#include "../VectorSetReader.h"
+#include "inc/Helper/Concurrent.h"
+
+#include <atomic>
+#include <condition_variable>
+#include <mutex>
+
+namespace SPTAG
+{
+namespace Helper
+{
+
+class DefaultReader : public VectorSetReader
+{
+public:
+    DefaultReader(std::shared_ptr<ReaderOptions> p_options);
+
+    virtual ~DefaultReader();
+
+    virtual ErrorCode LoadFile(const std::string& p_filePaths);
+
+    virtual std::shared_ptr<VectorSet> GetVectorSet() const;
+
+    virtual std::shared_ptr<MetadataSet> GetMetadataSet() const;
+
+private:
+    typedef std::pair<std::string, std::size_t> FileInfoPair;
+
+    static std::vector<FileInfoPair> GetFileSizes(const std::string& p_filePaths);
+
+    void LoadFileInternal(const std::string& p_filePath,
+                          std::uint32_t p_subtaskID,
+                          std::uint32_t p_fileBlockID,
+                          std::size_t p_fileBlockSize);
+
+    void MergeData();
+
+    template<typename DataType>
+    bool TranslateVector(char* p_str, DataType* p_vector)
+    {
+        DimensionType eleCount = 0;
+        char* next = p_str;
+        while ((*next) != '\0')
+        {
+            while ((*next) != '\0' && m_options->m_vectorDelimiter.find(*next) == std::string::npos)
+            {
+                ++next;
+            }
+
+            bool reachEnd = ('\0' == (*next));
+            *next = '\0';
+            if (p_str != next)
+            {
+                if (eleCount >= m_options->m_dimension)
+                {
+                    return false;
+                }
+
+                if (!Helper::Convert::ConvertStringTo(p_str, p_vector[eleCount++]))
+                {
+                    return false;
+                }
+            }
+
+            if (reachEnd)
+            {
+                break;
+            }
+
+            ++next;
+            p_str = next;
+        }
+
+        return eleCount == m_options->m_dimension;
+    }
+
+private:
+    std::uint32_t m_subTaskCount;
+
+    std::size_t m_subTaskBlocksize;
+
+    std::atomic<SizeType> m_totalRecordCount;
+
+    std::atomic<std::size_t> m_totalRecordVectorBytes;
+
+    std::vector<SizeType> m_subTaskRecordCount;
+
+    std::string m_vectorOutput;
+
+    std::string m_metadataConentOutput;
+
+    std::string m_metadataIndexOutput;
+
+    Helper::Concurrent::WaitSignal m_waitSignal;
+};
+
+
+
+} // namespace Helper
+} // namespace SPTAG
+
+#endif // _SPTAG_HELPER_VECTORSETREADERS_DEFAULT_H_
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/IndexBuilder/Options.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/IndexBuilder/Options.h
new file mode 100644
index 0000000000..b3b3e21e58
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/IndexBuilder/Options.h
@@ -0,0 +1,39 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_INDEXBUILDER_OPTIONS_H_
+#define _SPTAG_INDEXBUILDER_OPTIONS_H_
+
+#include "inc/Core/Common.h"
+#include "inc/Helper/VectorSetReader.h"
+
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace SPTAG
+{
+namespace IndexBuilder
+{
+
+class BuilderOptions : public Helper::ReaderOptions
+{
+public:
+    BuilderOptions();
+
+    ~BuilderOptions();
+
+    std::string m_inputFiles;
+
+    std::string m_outputFolder;
+
+    SPTAG::IndexAlgoType m_indexAlgoType;
+
+    std::string m_builderConfigFile;
+};
+
+
+} // namespace IndexBuilder
+} // namespace SPTAG
+
+#endif // _SPTAG_INDEXBUILDER_OPTIONS_H_
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/IndexBuilder/ThreadPool.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/IndexBuilder/ThreadPool.h
new file mode 100644
index 0000000000..7256f71ae5
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/IndexBuilder/ThreadPool.h
@@ -0,0 +1,27 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_INDEXBUILDER_THREADPOOL_H_
+#define _SPTAG_INDEXBUILDER_THREADPOOL_H_
+
+#include <functional>
+#include <cstdint>
+
+namespace SPTAG
+{
+namespace IndexBuilder
+{
+namespace ThreadPool
+{
+
+void Init(std::uint32_t p_threadNum);
+
+bool Queue(std::function<void()> p_workItem);
+
+std::uint32_t CurrentThreadNum();
+
+}
+} // namespace IndexBuilder
+} // namespace SPTAG
+
+#endif // _SPTAG_INDEXBUILDER_THREADPOOL_H_
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Server/QueryParser.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Server/QueryParser.h
new file mode 100644
index 0000000000..9444e40862
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Server/QueryParser.h
@@ -0,0 +1,56 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_SERVER_QUERYPARSER_H_
+#define _SPTAG_SERVER_QUERYPARSER_H_
+
+#include "../Core/Common.h"
+#include "../Core/CommonDataStructure.h"
+
+#include <vector>
+
+namespace SPTAG
+{
+namespace Service
+{
+
+
+class QueryParser
+{
+public:
+    typedef std::pair<const char*, const char*> OptionPair;
+
+    QueryParser();
+
+    ~QueryParser();
+
+    ErrorCode Parse(const std::string& p_query, const char* p_vectorSeparator);
+
+    const std::vector<const char*>& GetVectorElements() const;
+
+    const std::vector<OptionPair>& GetOptions() const;
+
+    const char* GetVectorBase64() const;
+
+    SizeType GetVectorBase64Length() const;
+
+private:
+    std::vector<OptionPair> m_options;
+
+    std::vector<const char*> m_vectorElements;
+
+    const char* m_vectorBase64;
+
+    SizeType m_vectorBase64Length;
+
+    ByteArray m_dataHolder;
+
+    static const char* c_defaultVectorSeparator;
+};
+
+
+} // namespace Server
+} // namespace AnnService
+
+
+#endif // _SPTAG_SERVER_QUERYPARSER_H_
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Server/SearchExecutionContext.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Server/SearchExecutionContext.h
new file mode 100644
index 0000000000..cba4df4651
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Server/SearchExecutionContext.h
@@ -0,0 +1,80 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_SERVER_SEARCHEXECUTIONCONTEXT_H_
+#define _SPTAG_SERVER_SEARCHEXECUTIONCONTEXT_H_
+
+#include "inc/Core/VectorIndex.h"
+#include "inc/Core/SearchQuery.h"
+#include "inc/Socket/RemoteSearchQuery.h"
+#include "ServiceSettings.h"
+#include "QueryParser.h"
+
+#include <vector>
+#include <string>
+#include <memory>
+
+
+namespace SPTAG
+{
+namespace Service
+{
+
+typedef Socket::IndexSearchResult SearchResult;
+
+class SearchExecutionContext
+{
+public:
+    SearchExecutionContext(const std::shared_ptr<const ServiceSettings>& p_serviceSettings);
+
+    ~SearchExecutionContext();
+
+    ErrorCode ParseQuery(const std::string& p_query);
+
+    ErrorCode ExtractOption();
+
+    ErrorCode ExtractVector(VectorValueType p_targetType);
+
+    void AddResults(std::string p_indexName, QueryResult& p_results);
+
+    std::vector<SearchResult>& GetResults();
+
+    const std::vector<SearchResult>& GetResults() const;
+
+    const ByteArray& GetVector() const;
+
+    const std::vector<std::string>& GetSelectedIndexNames() const;
+
+    const SizeType GetVectorDimension() const;
+
+    const std::vector<QueryParser::OptionPair>& GetOptions() const;
+
+    const SizeType GetResultNum() const;
+
+    const bool GetExtractMetadata() const;
+
+private:
+    const std::shared_ptr<const ServiceSettings> c_serviceSettings;
+
+    QueryParser m_queryParser;
+
+    std::vector<std::string> m_indexNames;
+
+    ByteArray m_vector;
+
+    SizeType m_vectorDimension;
+
+    std::vector<SearchResult> m_results;
+
+    VectorValueType m_inputValueType;
+
+    bool m_extractMetadata;
+
+    SizeType m_resultNum;
+};
+
+} // namespace Server
+} // namespace AnnService
+
+
+#endif // _SPTAG_SERVER_SEARCHEXECUTIONCONTEXT_H_
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Server/SearchExecutor.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Server/SearchExecutor.h
new file mode 100644
index 0000000000..201832651b
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Server/SearchExecutor.h
@@ -0,0 +1,56 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_SERVER_SEARCHEXECUTOR_H_
+#define _SPTAG_SERVER_SEARCHEXECUTOR_H_
+
+#include "ServiceContext.h"
+#include "ServiceSettings.h"
+#include "SearchExecutionContext.h"
+#include "QueryParser.h"
+
+#include <functional>
+#include <memory>
+#include <vector>
+
+namespace SPTAG
+{
+namespace Service
+{
+
+class SearchExecutor
+{
+public:
+    typedef std::function<void(std::shared_ptr<SearchExecutionContext>)> CallBack;
+
+    SearchExecutor(std::string p_queryString,
+                   std::shared_ptr<ServiceContext> p_serviceContext,
+                   const CallBack& p_callback);
+
+    ~SearchExecutor();
+
+    void Execute();
+
+private:
+    void ExecuteInternal();
+
+    void SelectIndex();
+
+private:
+    CallBack m_callback;
+
+    const std::shared_ptr<ServiceContext> c_serviceContext;
+
+    std::shared_ptr<SearchExecutionContext> m_executionContext;
+
+    std::string m_queryString;
+
+    std::vector<std::shared_ptr<VectorIndex>> m_selectedIndex;
+};
+
+
+} // namespace Server
+} // namespace AnnService
+
+
+#endif // _SPTAG_SERVER_SEARCHEXECUTOR_H_
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Server/SearchService.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Server/SearchService.h
new file mode 100644
index 0000000000..34d0c6064c
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Server/SearchService.h
@@ -0,0 +1,73 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_SERVER_SERVICE_H_
+#define _SPTAG_SERVER_SERVICE_H_
+
+#include "ServiceContext.h"
+#include "../Socket/Server.h"
+
+#include <boost/asio.hpp>
+
+#include <memory>
+#include <vector>
+#include <thread>
+#include <condition_variable>
+
+namespace SPTAG
+{
+namespace Service
+{
+
+class SearchExecutionContext;
+
+class SearchService
+{
+public:
+    SearchService();
+
+    ~SearchService();
+
+    bool Initialize(int p_argNum, char* p_args[]);
+
+    void Run();
+
+private:
+    void RunSocketMode();
+
+    void RunInteractiveMode();
+
+    void SearchHanlder(Socket::ConnectionID p_localConnectionID, Socket::Packet p_packet);
+
+    void SearchHanlderCallback(std::shared_ptr<SearchExecutionContext> p_exeContext,
+                               Socket::Packet p_srcPacket);
+
+private:
+    enum class ServeMode : std::uint8_t
+    {
+        Interactive,
+
+        Socket
+    };
+
+    std::shared_ptr<ServiceContext> m_serviceContext;
+
+    std::shared_ptr<Socket::Server> m_socketServer;
+
+    bool m_initialized;
+
+    ServeMode m_serveMode;
+
+    std::unique_ptr<boost::asio::thread_pool> m_threadPool;
+
+    boost::asio::io_context m_ioContext;
+
+    boost::asio::signal_set m_shutdownSignals;
+};
+
+
+} // namespace Server
+} // namespace AnnService
+
+
+#endif // _SPTAG_SERVER_SERVICE_H_
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Server/ServiceContext.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Server/ServiceContext.h
new file mode 100644
index 0000000000..b1a7b84045
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Server/ServiceContext.h
@@ -0,0 +1,44 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_SERVER_SERVICECONTEX_H_
+#define _SPTAG_SERVER_SERVICECONTEX_H_
+
+#include "inc/Core/VectorIndex.h"
+#include "ServiceSettings.h"
+
+#include <memory>
+#include <map>
+
+namespace SPTAG
+{
+namespace Service
+{
+
+class ServiceContext
+{
+public:
+    ServiceContext(const std::string& p_configFilePath);
+
+    ~ServiceContext();
+
+    const std::map<std::string, std::shared_ptr<VectorIndex>>& GetIndexMap() const;
+
+    const std::shared_ptr<ServiceSettings>& GetServiceSettings() const;
+
+    bool IsInitialized() const;
+
+private:
+    bool m_initialized;
+
+    std::shared_ptr<ServiceSettings> m_settings;
+
+    std::map<std::string, std::shared_ptr<VectorIndex>> m_fullIndexList;
+};
+
+
+} // namespace Server
+} // namespace AnnService
+
+#endif // _SPTAG_SERVER_SERVICECONTEX_H_
+
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Server/ServiceSettings.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Server/ServiceSettings.h
new file mode 100644
index 0000000000..9077487355
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Server/ServiceSettings.h
@@ -0,0 +1,41 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_SERVER_SERVICESTTINGS_H_
+#define _SPTAG_SERVER_SERVICESTTINGS_H_
+
+#include "../Core/Common.h"
+
+#include <string>
+
+namespace SPTAG
+{
+namespace Service
+{
+
+struct ServiceSettings
+{
+    ServiceSettings();
+
+    std::string m_vectorSeparator;
+
+    std::string m_listenAddr;
+
+    std::string m_listenPort;
+
+    SizeType m_defaultMaxResultNumber;
+
+    SizeType m_threadNum;
+
+    SizeType m_socketThreadNum;
+};
+
+
+
+
+} // namespace Server
+} // namespace AnnService
+
+
+#endif // _SPTAG_SERVER_SERVICESTTINGS_H_
+
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Socket/Client.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Socket/Client.h
new file mode 100644
index 0000000000..a57465dfd7
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Socket/Client.h
@@ -0,0 +1,68 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_SOCKET_CLIENT_H_
+#define _SPTAG_SOCKET_CLIENT_H_
+
+#include "inc/Core/Common.h"
+#include "Connection.h"
+#include "ConnectionManager.h"
+#include "Packet.h"
+
+#include <string>
+#include <memory>
+#include <atomic>
+#include <boost/asio.hpp>
+
+namespace SPTAG
+{
+namespace Socket
+{
+
+class Client
+{
+public:
+    typedef std::function<void(ConnectionID p_cid, SPTAG::ErrorCode)> ConnectCallback;
+
+    Client(const PacketHandlerMapPtr& p_handlerMap,
+           std::size_t p_threadNum,
+           std::uint32_t p_heartbeatIntervalSeconds);
+
+    ~Client();
+
+    ConnectionID ConnectToServer(const std::string& p_address,
+                                 const std::string& p_port,
+                                 SPTAG::ErrorCode& p_ec);
+
+    void AsyncConnectToServer(const std::string& p_address,
+                              const std::string& p_port,
+                              ConnectCallback p_callback);
+
+    void SendPacket(ConnectionID p_connection, Packet p_packet, std::function<void(bool)> p_callback);
+
+    void SetEventOnConnectionClose(std::function<void(ConnectionID)> p_event);
+
+private:
+    void KeepIoContext();
+
+private:
+    std::atomic_bool m_stopped;
+
+    std::uint32_t m_heartbeatIntervalSeconds;
+
+    boost::asio::io_context m_ioContext;
+
+    boost::asio::deadline_timer m_deadlineTimer;
+
+    std::shared_ptr<ConnectionManager> m_connectionManager;
+
+    std::vector<std::thread> m_threadPool;
+
+    const PacketHandlerMapPtr c_requestHandlerMap;
+};
+
+
+} // namespace Socket
+} // namespace SPTAG
+
+#endif // _SPTAG_SOCKET_CLIENT_H_
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Socket/Common.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Socket/Common.h
new file mode 100644
index 0000000000..dc06af1bb4
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Socket/Common.h
@@ -0,0 +1,25 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_SOCKET_COMMON_H_
+#define _SPTAG_SOCKET_COMMON_H_
+
+#include <cstdint>
+
+namespace SPTAG
+{
+namespace Socket
+{
+
+typedef std::uint32_t ConnectionID;
+
+typedef std::uint32_t ResourceID;
+
+extern const ConnectionID c_invalidConnectionID;
+
+extern const ResourceID c_invalidResourceID;
+
+} // namespace Socket
+} // namespace SPTAG
+
+#endif // _SPTAG_SOCKET_COMMON_H_
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Socket/Connection.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Socket/Connection.h
new file mode 100644
index 0000000000..1d75d093b3
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Socket/Connection.h
@@ -0,0 +1,100 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_SOCKET_CONNECTION_H_
+#define _SPTAG_SOCKET_CONNECTION_H_
+
+#include "Packet.h"
+
+#include <cstdint>
+#include <memory>
+#include <atomic>
+
+#include <boost/asio/ip/tcp.hpp>
+#include <boost/asio/io_service_strand.hpp>
+#include <boost/asio/deadline_timer.hpp>
+
+namespace SPTAG
+{
+namespace Socket
+{
+
+class ConnectionManager;
+
+class Connection : public std::enable_shared_from_this<Connection>
+{
+public:
+    typedef std::shared_ptr<Connection> Ptr;
+
+    Connection(ConnectionID p_connectionID,
+               boost::asio::ip::tcp::socket&& p_socket,
+               const PacketHandlerMapPtr& p_handlerMap,
+               std::weak_ptr<ConnectionManager> p_connectionManager);
+
+    void Start();
+
+    void Stop();
+
+    void StartHeartbeat(std::size_t p_intervalSeconds);
+
+    void AsyncSend(Packet p_packet, std::function<void(bool)> p_callback);
+
+    ConnectionID GetConnectionID() const;
+
+    ConnectionID GetRemoteConnectionID() const;
+
+    Connection(const Connection&) = delete;
+    Connection& operator=(const Connection&) = delete;
+
+private:
+    void AsyncReadHeader();
+
+    void AsyncReadBody();
+
+    void HandleReadHeader(boost::system::error_code p_ec, std::size_t p_bytesTransferred);
+
+    void HandleReadBody(boost::system::error_code p_ec, std::size_t p_bytesTransferred);
+
+    void SendHeartbeat(std::size_t p_intervalSeconds);
+
+    void SendRegister();
+
+    void HandleHeartbeatRequest();
+
+    void HandleRegisterRequest();
+
+    void HandleRegisterResponse();
+
+    void HandleNoHandlerResponse();
+
+    void OnConnectionFail(const boost::system::error_code& p_ec);
+
+private:
+    const ConnectionID c_connectionID;
+
+    ConnectionID m_remoteConnectionID;
+
+    const std::weak_ptr<ConnectionManager> c_connectionManager;
+
+    const PacketHandlerMapPtr c_handlerMap;
+
+    boost::asio::ip::tcp::socket m_socket;
+
+    boost::asio::io_context::strand m_strand;
+
+    boost::asio::deadline_timer m_heartbeatTimer;
+
+    std::uint8_t m_packetHeaderReadBuffer[PacketHeader::c_bufferSize];
+
+    Packet m_packetRead;
+
+    std::atomic_bool m_stopped;
+
+    std::atomic_bool m_heartbeatStarted;
+};
+
+
+} // namespace Socket
+} // namespace SPTAG
+
+#endif // _SPTAG_SOCKET_CONNECTION_H_
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Socket/ConnectionManager.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Socket/ConnectionManager.h
new file mode 100644
index 0000000000..e487c61053
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Socket/ConnectionManager.h
@@ -0,0 +1,73 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_SOCKET_CONNECTIONMANAGER_H_
+#define _SPTAG_SOCKET_CONNECTIONMANAGER_H_
+
+#include "Connection.h"
+#include "inc/Helper/Concurrent.h"
+
+#include <cstdint>
+#include <memory>
+#include <atomic>
+#include <mutex>
+#include <array>
+
+#include <boost/asio/ip/tcp.hpp>
+
+namespace SPTAG
+{
+namespace Socket
+{
+
+class ConnectionManager : public std::enable_shared_from_this<ConnectionManager>
+{
+public:
+    ConnectionManager();
+
+    ConnectionID AddConnection(boost::asio::ip::tcp::socket&& p_socket,
+                               const PacketHandlerMapPtr& p_handlerMap,
+                               std::uint32_t p_heartbeatIntervalSeconds);
+
+    void RemoveConnection(ConnectionID p_connectionID);
+
+    Connection::Ptr GetConnection(ConnectionID p_connectionID);
+
+    void SetEventOnRemoving(std::function<void(ConnectionID)> p_event);
+
+    void StopAll();
+
+private:
+    inline static std::uint32_t GetPosition(ConnectionID p_connectionID);
+
+private:
+    static constexpr std::uint32_t c_connectionPoolSize = 1 << 8;
+
+    static constexpr std::uint32_t c_connectionPoolMask = c_connectionPoolSize - 1;
+
+    struct ConnectionItem
+    {
+        ConnectionItem();
+
+        std::atomic_bool m_isEmpty;
+
+        Connection::Ptr m_connection;
+    };
+
+    // Start from 1. 0 means not assigned.
+    std::atomic<ConnectionID> m_nextConnectionID;
+
+    std::atomic<std::uint32_t> m_connectionCount;
+
+    std::array<ConnectionItem, c_connectionPoolSize> m_connections;
+
+    Helper::Concurrent::SpinLock m_spinLock;
+
+    std::function<void(ConnectionID)> m_eventOnRemoving;
+};
+
+
+} // namespace Socket
+} // namespace SPTAG
+
+#endif // _SPTAG_SOCKET_CONNECTIONMANAGER_H_
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Socket/Packet.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Socket/Packet.h
new file mode 100644
index 0000000000..8c99b09fed
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Socket/Packet.h
@@ -0,0 +1,142 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_SOCKET_PACKET_H_
+#define _SPTAG_SOCKET_PACKET_H_
+
+#include "Common.h"
+
+#include <cstdint>
+#include <memory>
+#include <functional>
+#include <array>
+#include <unordered_map>
+
+namespace SPTAG
+{
+namespace Socket
+{
+
+enum class PacketType : std::uint8_t
+{
+    Undefined = 0x00,
+
+    HeartbeatRequest = 0x01,
+
+    RegisterRequest = 0x02,
+
+    SearchRequest = 0x03,
+
+    ResponseMask = 0x80,
+
+    HeartbeatResponse = ResponseMask | HeartbeatRequest,
+
+    RegisterResponse = ResponseMask | RegisterRequest,
+
+    SearchResponse = ResponseMask | SearchRequest
+};
+
+
+enum class PacketProcessStatus : std::uint8_t
+{
+    Ok = 0x00,
+
+    Timeout = 0x01,
+
+    Dropped = 0x02,
+
+    Failed = 0x03
+};
+
+
+struct PacketHeader
+{
+    static constexpr std::size_t c_bufferSize = 16;
+
+    PacketHeader();
+    PacketHeader(PacketHeader&& p_right);
+    PacketHeader(const PacketHeader& p_right);
+
+    std::size_t WriteBuffer(std::uint8_t* p_buffer);
+
+    void ReadBuffer(const std::uint8_t* p_buffer);
+
+    PacketType m_packetType;
+
+    PacketProcessStatus m_processStatus;
+
+    std::uint32_t m_bodyLength;
+
+    // Meaning of this is different with different PacketType.
+    // In most request case, it means connection expeced for response.
+    // In most response case, it means connection which handled request.
+    ConnectionID m_connectionID;
+
+    ResourceID m_resourceID;
+};
+
+
+static_assert(sizeof(PacketHeader) <= PacketHeader::c_bufferSize, "");
+
+
+class Packet
+{
+public:
+    Packet();
+    Packet(Packet&& p_right);
+    Packet(const Packet& p_right);
+
+    PacketHeader& Header();
+
+    std::uint8_t* HeaderBuffer() const;
+
+    std::uint8_t* Body() const;
+
+    std::uint8_t* Buffer() const;
+
+    std::uint32_t BufferLength() const;
+
+    std::uint32_t BufferCapacity() const;
+
+    void AllocateBuffer(std::uint32_t p_bodyCapacity);
+
+private:
+    PacketHeader m_header;
+
+    std::shared_ptr<std::uint8_t> m_buffer;
+
+    std::uint32_t m_bufferCapacity;
+};
+
+
+struct PacketTypeHash
+{
+    std::size_t operator()(const PacketType& p_val) const
+    {
+        return static_cast<std::size_t>(p_val);
+    }
+};
+
+
+typedef std::function<void(ConnectionID, Packet)> PacketHandler;
+
+typedef std::unordered_map<PacketType, PacketHandler, PacketTypeHash> PacketHandlerMap;
+typedef std::shared_ptr<PacketHandlerMap> PacketHandlerMapPtr;
+
+
+namespace PacketTypeHelper
+{
+
+bool IsRequestPacket(PacketType p_type);
+
+bool IsResponsePacket(PacketType p_type);
+
+PacketType GetCrosspondingResponseType(PacketType p_type);
+
+}
+
+
+} // namespace SPTAG
+} // namespace Socket
+
+#endif // _SPTAG_SOCKET_SOCKETSERVER_H_
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Socket/RemoteSearchQuery.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Socket/RemoteSearchQuery.h
new file mode 100644
index 0000000000..900aa6cb16
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Socket/RemoteSearchQuery.h
@@ -0,0 +1,99 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_SOCKET_REMOTESEARCHQUERY_H_
+#define _SPTAG_SOCKET_REMOTESEARCHQUERY_H_
+
+#include "inc/Core/CommonDataStructure.h"
+#include "inc/Core/SearchQuery.h"
+
+#include <cstdint>
+#include <memory>
+#include <functional>
+#include <vector>
+#include <unordered_map>
+
+namespace SPTAG
+{
+namespace Socket
+{
+
+// TODO: use Bond replace below structures.
+
+struct RemoteQuery
+{
+    static constexpr std::uint16_t MajorVersion() { return 1; }
+    static constexpr std::uint16_t MirrorVersion() { return 0; }
+
+    enum class QueryType : std::uint8_t
+    {
+        String = 0
+    };
+
+    RemoteQuery();
+
+    std::size_t EstimateBufferSize() const;
+
+    std::uint8_t* Write(std::uint8_t* p_buffer) const;
+
+    const std::uint8_t* Read(const std::uint8_t* p_buffer);
+
+
+    QueryType m_type;
+
+    std::string m_queryString;
+};
+
+
+struct IndexSearchResult
+{
+    std::string m_indexName;
+
+    QueryResult m_results;
+};
+
+
+struct RemoteSearchResult
+{
+    static constexpr std::uint16_t MajorVersion() { return 1; }
+    static constexpr std::uint16_t MirrorVersion() { return 0; }
+
+    enum class ResultStatus : std::uint8_t
+    {
+        Success = 0,
+
+        Timeout = 1,
+
+        FailedNetwork = 2,
+
+        FailedExecute = 3,
+
+        Dropped = 4
+    };
+
+    RemoteSearchResult();
+
+    RemoteSearchResult(const RemoteSearchResult& p_right);
+
+    RemoteSearchResult(RemoteSearchResult&& p_right);
+
+    RemoteSearchResult& operator=(RemoteSearchResult&& p_right);
+
+    std::size_t EstimateBufferSize() const;
+
+    std::uint8_t* Write(std::uint8_t* p_buffer) const;
+
+    const std::uint8_t* Read(const std::uint8_t* p_buffer);
+
+
+    ResultStatus m_status;
+
+    std::vector<IndexSearchResult> m_allIndexResults;
+};
+
+
+
+} // namespace SPTAG
+} // namespace Socket
+
+#endif // _SPTAG_SOCKET_REMOTESEARCHQUERY_H_
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Socket/ResourceManager.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Socket/ResourceManager.h
new file mode 100644
index 0000000000..404cac830f
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Socket/ResourceManager.h
@@ -0,0 +1,190 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_SOCKET_RESOURCEMANAGER_H_
+#define _SPTAG_SOCKET_RESOURCEMANAGER_H_
+
+#include "Common.h"
+
+#include <boost/asio/io_context.hpp>
+
+#include <memory>
+#include <chrono>
+#include <functional>
+#include <atomic>
+#include <mutex>
+#include <deque>
+#include <unordered_map>
+#include <thread>
+
+namespace std
+{
+typedef atomic<uint32_t> atomic_uint32_t;
+}
+
+namespace SPTAG
+{
+namespace Socket
+{
+
+template<typename ResourceType>
+class ResourceManager : public std::enable_shared_from_this<ResourceManager<ResourceType>>
+{
+public:
+    typedef std::function<void(std::shared_ptr<ResourceType>)> TimeoutCallback;
+
+    ResourceManager()
+        : m_nextResourceID(1),
+          m_isStopped(false),
+          m_timeoutItemCount(0)
+    {
+        m_timeoutChecker = std::thread(&ResourceManager::StartCheckTimeout, this);
+    }
+
+
+    ~ResourceManager()
+    {
+        m_isStopped = true;
+        m_timeoutChecker.join();
+    }
+
+
+    ResourceID Add(const std::shared_ptr<ResourceType>& p_resource,
+                   std::uint32_t p_timeoutMilliseconds,
+                   TimeoutCallback p_timeoutCallback)
+    {
+        ResourceID rid = m_nextResourceID.fetch_add(1);
+        while (c_invalidResourceID == rid)
+        {
+            rid = m_nextResourceID.fetch_add(1);
+        }
+
+        {
+            std::lock_guard<std::mutex> guard(m_resourcesMutex);
+            m_resources.emplace(rid, p_resource);
+        }
+
+        if (p_timeoutMilliseconds > 0)
+        {
+            std::unique_ptr<ResourceItem> item(new ResourceItem);
+
+            item->m_resourceID = rid;
+            item->m_callback = std::move(p_timeoutCallback);
+            item->m_expireTime = m_clock.now() + std::chrono::milliseconds(p_timeoutMilliseconds);
+
+            {
+                std::lock_guard<std::mutex> guard(m_timeoutListMutex);
+                m_timeoutList.emplace_back(std::move(item));
+            }
+
+            ++m_timeoutItemCount;
+        }
+
+        return rid;
+    }
+
+
+    std::shared_ptr<ResourceType> GetAndRemove(ResourceID p_resourceID)
+    {
+        std::shared_ptr<ResourceType> ret;
+        std::lock_guard<std::mutex> guard(m_resourcesMutex);
+        auto iter = m_resources.find(p_resourceID);
+        if (iter != m_resources.end())
+        {
+            ret = iter->second;
+            m_resources.erase(iter);
+        }
+
+        return ret;
+    }
+
+
+    void Remove(ResourceID p_resourceID)
+    {
+        std::lock_guard<std::mutex> guard(m_resourcesMutex);
+        auto iter = m_resources.find(p_resourceID);
+        if (iter != m_resources.end())
+        {
+            m_resources.erase(iter);
+        }
+    }
+
+private:
+    void StartCheckTimeout()
+    {
+        std::vector<std::unique_ptr<ResourceItem>> timeouted;
+        timeouted.reserve(1024);
+        while (!m_isStopped)
+        {
+            if (m_timeoutItemCount > 0)
+            {
+                std::lock_guard<std::mutex> guard(m_timeoutListMutex);
+                while (!m_timeoutList.empty()
+                       && m_timeoutList.front()->m_expireTime <= m_clock.now())
+                {
+                    timeouted.emplace_back(std::move(m_timeoutList.front()));
+                    m_timeoutList.pop_front();
+                    --m_timeoutItemCount;
+                }
+            }
+
+            if (timeouted.empty())
+            {
+                std::this_thread::sleep_for(std::chrono::milliseconds(1));
+            }
+            else
+            {
+                for (auto& item : timeouted)
+                {
+                    auto resource = GetAndRemove(item->m_resourceID);
+                    if (nullptr != resource)
+                    {
+                        item->m_callback(std::move(resource));
+                    }
+                }
+
+                timeouted.clear();
+            }
+        }
+    }
+
+
+private:
+    struct ResourceItem
+    {
+        ResourceItem()
+            : m_resourceID(c_invalidResourceID)
+        {
+        }
+
+        ResourceID m_resourceID;
+
+        TimeoutCallback m_callback;
+
+        std::chrono::time_point<std::chrono::high_resolution_clock> m_expireTime;
+    };
+
+    std::deque<std::unique_ptr<ResourceItem>> m_timeoutList;
+
+    std::atomic<std::uint32_t> m_timeoutItemCount;
+
+    std::mutex m_timeoutListMutex;
+
+    std::unordered_map<ResourceID, std::shared_ptr<ResourceType>> m_resources;
+
+    std::atomic<ResourceID> m_nextResourceID;
+
+    std::mutex m_resourcesMutex;
+
+    std::chrono::high_resolution_clock m_clock;
+
+    std::thread m_timeoutChecker;
+
+    bool m_isStopped;
+};
+
+
+} // namespace Socket
+} // namespace SPTAG
+
+#endif // _SPTAG_SOCKET_RESOURCEMANAGER_H_
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Socket/Server.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Socket/Server.h
new file mode 100644
index 0000000000..aac97bf84b
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Socket/Server.h
@@ -0,0 +1,55 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_SOCKET_SERVER_H_
+#define _SPTAG_SOCKET_SERVER_H_
+
+#include "Connection.h"
+#include "ConnectionManager.h"
+#include "Packet.h"
+
+#include <string>
+#include <memory>
+#include <boost/asio.hpp>
+
+namespace SPTAG
+{
+namespace Socket
+{
+
+class Server
+{
+public:
+    Server(const std::string& p_address,
+           const std::string& p_port,
+           const PacketHandlerMapPtr& p_handlerMap,
+           std::size_t p_threadNum);
+
+    ~Server();
+
+    void StartListen();
+
+    void SendPacket(ConnectionID p_connection, Packet p_packet, std::function<void(bool)> p_callback);
+
+    void SetEventOnConnectionClose(std::function<void(ConnectionID)> p_event);
+
+private:
+    void StartAccept();
+
+private:
+    boost::asio::io_context m_ioContext;
+
+    boost::asio::ip::tcp::acceptor m_acceptor;
+
+    std::shared_ptr<ConnectionManager> m_connectionManager;
+
+    std::vector<std::thread> m_threadPool;
+
+    const PacketHandlerMapPtr m_requestHandlerMap;
+};
+
+
+} // namespace Socket
+} // namespace SPTAG
+
+#endif // _SPTAG_SOCKET_SERVER_H_
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/inc/Socket/SimpleSerialization.h b/core/src/index/thirdparty/SPTAG/AnnService/inc/Socket/SimpleSerialization.h
new file mode 100644
index 0000000000..6da925625b
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/inc/Socket/SimpleSerialization.h
@@ -0,0 +1,174 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_SOCKET_SIMPLESERIALIZATION_H_
+#define _SPTAG_SOCKET_SIMPLESERIALIZATION_H_
+
+#include "inc/Core/CommonDataStructure.h"
+
+#include <type_traits>
+#include <cstdint>
+#include <memory>
+#include <cstring>
+
+namespace SPTAG
+{
+namespace Socket
+{
+namespace SimpleSerialization
+{
+
+    template<typename T>
+    inline std::uint8_t*
+    SimpleWriteBuffer(const T& p_val, std::uint8_t* p_buffer)
+    {
+        static_assert(std::is_fundamental<T>::value || std::is_enum<T>::value,
+                      "Only applied for fundanmental type.");
+
+        *(reinterpret_cast<T*>(p_buffer)) = p_val;
+        return p_buffer + sizeof(T);
+    }
+
+
+    template<typename T>
+    inline const std::uint8_t*
+    SimpleReadBuffer(const std::uint8_t* p_buffer, T& p_val)
+    {
+        static_assert(std::is_fundamental<T>::value || std::is_enum<T>::value,
+                      "Only applied for fundanmental type.");
+
+        p_val = *(reinterpret_cast<const T*>(p_buffer));
+        return p_buffer + sizeof(T);
+    }
+
+
+    template<typename T>
+    inline std::size_t
+    EstimateBufferSize(const T& p_val)
+    {
+        static_assert(std::is_fundamental<T>::value || std::is_enum<T>::value,
+                      "Only applied for fundanmental type.");
+
+        return sizeof(T);
+    }
+
+
+    template<>
+    inline std::uint8_t*
+    SimpleWriteBuffer<std::string>(const std::string& p_val, std::uint8_t* p_buffer)
+    {
+        p_buffer = SimpleWriteBuffer(static_cast<std::uint32_t>(p_val.size()), p_buffer);
+
+        std::memcpy(p_buffer, p_val.c_str(), p_val.size());
+        return p_buffer + p_val.size();
+    }
+
+
+    template<>
+    inline const std::uint8_t*
+    SimpleReadBuffer<std::string>(const std::uint8_t* p_buffer, std::string& p_val)
+    {
+        p_val.clear();
+        std::uint32_t len = 0;
+        p_buffer = SimpleReadBuffer(p_buffer, len);
+
+        if (len > 0)
+        {
+            p_val.reserve(len);
+            p_val.assign(reinterpret_cast<const char*>(p_buffer), len);
+        }
+
+        return p_buffer + len;
+    }
+
+
+    template<>
+    inline std::size_t
+    EstimateBufferSize<std::string>(const std::string& p_val)
+    {
+        return sizeof(std::uint32_t) + p_val.size();
+    }
+
+
+    template<>
+    inline std::uint8_t*
+    SimpleWriteBuffer<ByteArray>(const ByteArray& p_val, std::uint8_t* p_buffer)
+    {
+        p_buffer = SimpleWriteBuffer(static_cast<std::uint32_t>(p_val.Length()), p_buffer);
+
+        std::memcpy(p_buffer, p_val.Data(), p_val.Length());
+        return p_buffer + p_val.Length();
+    }
+
+
+    template<>
+    inline const std::uint8_t*
+    SimpleReadBuffer<ByteArray>(const std::uint8_t* p_buffer, ByteArray& p_val)
+    {
+        p_val.Clear();
+        std::uint32_t len = 0;
+        p_buffer = SimpleReadBuffer(p_buffer, len);
+
+        if (len > 0)
+        {
+            p_val = ByteArray::Alloc(len);
+            std::memcpy(p_val.Data(), p_buffer, len);
+        }
+
+        return p_buffer + len;
+    }
+
+
+    template<>
+    inline std::size_t
+    EstimateBufferSize<ByteArray>(const ByteArray& p_val)
+    {
+        return sizeof(std::uint32_t) + p_val.Length();
+    }
+
+
+    template<typename T>
+    inline std::uint8_t*
+    SimpleWriteSharedPtrBuffer(const std::shared_ptr<T>& p_val, std::uint8_t* p_buffer)
+    {
+        if (nullptr == p_val)
+        {
+            return SimpleWriteBuffer(false, p_buffer);
+        }
+
+        p_buffer = SimpleWriteBuffer(true, p_buffer);
+        p_buffer = SimpleWriteBuffer(*p_val, p_buffer);
+        return p_buffer;
+    }
+
+
+    template<typename T>
+    inline const std::uint8_t*
+    SimpleReadSharedPtrBuffer(const std::uint8_t* p_buffer, std::shared_ptr<T>& p_val)
+    {
+        p_val.reset();
+        bool isNotNull = false;
+        p_buffer = SimpleReadBuffer(p_buffer, isNotNull);
+
+        if (isNotNull)
+        {
+            p_val.reset(new T);
+            p_buffer = SimpleReadBuffer(p_buffer, *p_val);
+        }
+
+        return p_buffer;
+    }
+
+
+    template<typename T>
+    inline std::size_t
+    EstimateSharedPtrBufferSize(const std::shared_ptr<T>& p_val)
+    {
+        return sizeof(bool) + (nullptr == p_val ? 0 : EstimateBufferSize(*p_val));
+    }
+
+} // namespace SimpleSerialization
+} // namespace SPTAG
+} // namespace Socket
+
+#endif // _SPTAG_SOCKET_SIMPLESERIALIZATION_H_
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/packages.config b/core/src/index/thirdparty/SPTAG/AnnService/packages.config
new file mode 100644
index 0000000000..2dbed9b530
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/packages.config
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="boost" version="1.67.0.0" targetFramework="native" />
+  <package id="boost_date_time-vc140" version="1.67.0.0" targetFramework="native" />
+  <package id="boost_regex-vc140" version="1.67.0.0" targetFramework="native" />
+  <package id="boost_serialization-vc140" version="1.67.0.0" targetFramework="native" />
+  <package id="boost_system-vc140" version="1.67.0.0" targetFramework="native" />
+  <package id="boost_thread-vc140" version="1.67.0.0" targetFramework="native" />
+  <package id="boost_wserialization-vc140" version="1.67.0.0" targetFramework="native" />
+</packages>
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/src/Aggregator/AggregatorContext.cpp b/core/src/index/thirdparty/SPTAG/AnnService/src/Aggregator/AggregatorContext.cpp
new file mode 100644
index 0000000000..a36c2c61e9
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/src/Aggregator/AggregatorContext.cpp
@@ -0,0 +1,86 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Aggregator/AggregatorContext.h"
+#include "inc/Helper/SimpleIniReader.h"
+
+using namespace SPTAG;
+using namespace SPTAG::Aggregator;
+
+RemoteMachine::RemoteMachine()
+    : m_connectionID(Socket::c_invalidConnectionID),
+      m_status(RemoteMachineStatus::Disconnected)
+{
+}
+
+
+AggregatorContext::AggregatorContext(const std::string& p_filePath)
+    : m_initialized(false)
+{
+    Helper::IniReader iniReader;
+    if (ErrorCode::Success != iniReader.LoadIniFile(p_filePath))
+    {
+        return;
+    }
+
+    m_settings.reset(new AggregatorSettings);
+
+    m_settings->m_listenAddr = iniReader.GetParameter("Service", "ListenAddr", std::string("0.0.0.0"));
+    m_settings->m_listenPort = iniReader.GetParameter("Service", "ListenPort", std::string("8100"));
+    m_settings->m_threadNum = iniReader.GetParameter("Service", "ThreadNumber", static_cast<std::uint32_t>(8));
+    m_settings->m_socketThreadNum = iniReader.GetParameter("Service", "SocketThreadNumber", static_cast<std::uint32_t>(8));
+
+    const std::string emptyStr;
+
+    std::uint32_t serverNum = iniReader.GetParameter("Servers", "Number", static_cast<std::uint32_t>(0));
+
+    for (std::uint32_t i = 0; i < serverNum; ++i)
+    {
+        std::string sectionName("Server_");
+        sectionName += std::to_string(i);
+        if (!iniReader.DoesSectionExist(sectionName))
+        {
+            continue;
+        }
+
+        std::shared_ptr<RemoteMachine> remoteMachine(new RemoteMachine);
+
+        remoteMachine->m_address = iniReader.GetParameter(sectionName, "Address", emptyStr);
+        remoteMachine->m_port = iniReader.GetParameter(sectionName, "Port", emptyStr);
+
+        if (remoteMachine->m_address.empty() || remoteMachine->m_port.empty())
+        {
+            continue;
+        }
+
+        m_remoteServers.push_back(std::move(remoteMachine));
+    }
+
+    m_initialized = true;
+}
+
+
+AggregatorContext::~AggregatorContext()
+{
+}
+
+
+bool
+AggregatorContext::IsInitialized() const
+{
+    return m_initialized;
+}
+
+
+const std::vector<std::shared_ptr<RemoteMachine>>&
+AggregatorContext::GetRemoteServers() const
+{
+    return m_remoteServers;
+}
+
+
+const std::shared_ptr<AggregatorSettings>&
+AggregatorContext::GetSettings() const
+{
+    return m_settings;
+}
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/src/Aggregator/AggregatorExecutionContext.cpp b/core/src/index/thirdparty/SPTAG/AnnService/src/Aggregator/AggregatorExecutionContext.cpp
new file mode 100644
index 0000000000..8f7a28375a
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/src/Aggregator/AggregatorExecutionContext.cpp
@@ -0,0 +1,51 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Aggregator/AggregatorExecutionContext.h"
+
+using namespace SPTAG;
+using namespace SPTAG::Aggregator;
+
+AggregatorExecutionContext::AggregatorExecutionContext(std::size_t p_totalServerNumber,
+                                                       Socket::PacketHeader p_requestHeader)
+    : m_requestHeader(std::move(p_requestHeader))
+{
+    m_results.clear();
+    m_results.resize(p_totalServerNumber);
+
+    m_unfinishedCount = static_cast<std::uint32_t>(p_totalServerNumber);
+}
+
+
+AggregatorExecutionContext::~AggregatorExecutionContext()
+{
+}
+
+
+std::size_t
+AggregatorExecutionContext::GetServerNumber() const
+{
+    return m_results.size();
+}
+
+
+AggregatorResult&
+AggregatorExecutionContext::GetResult(std::size_t p_num)
+{
+    return m_results[p_num];
+}
+
+
+const Socket::PacketHeader&
+AggregatorExecutionContext::GetRequestHeader() const
+{
+    return m_requestHeader;
+}
+
+
+bool
+AggregatorExecutionContext::IsCompletedAfterFinsh(std::uint32_t p_finishedCount)
+{
+    auto lastCount = m_unfinishedCount.fetch_sub(p_finishedCount);
+    return lastCount <= p_finishedCount;
+}
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/src/Aggregator/AggregatorService.cpp b/core/src/index/thirdparty/SPTAG/AnnService/src/Aggregator/AggregatorService.cpp
new file mode 100644
index 0000000000..24c1672cde
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/src/Aggregator/AggregatorService.cpp
@@ -0,0 +1,366 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Aggregator/AggregatorService.h"
+
+using namespace SPTAG;
+using namespace SPTAG::Aggregator;
+
+AggregatorService::AggregatorService()
+    : m_shutdownSignals(m_ioContext),
+      m_pendingConnectServersTimer(m_ioContext)
+{
+}
+
+
+AggregatorService::~AggregatorService()
+{
+}
+
+
+bool
+AggregatorService::Initialize()
+{
+    std::string configFilePath = "Aggregator.ini";
+    m_aggregatorContext.reset(new AggregatorContext(configFilePath));
+
+    m_initalized = m_aggregatorContext->IsInitialized();
+
+    return m_initalized;
+}
+
+
+void
+AggregatorService::Run()
+{
+    auto threadNum = max((SPTAG::SizeType)1, GetContext()->GetSettings()->m_threadNum);
+    m_threadPool.reset(new boost::asio::thread_pool(threadNum));
+
+    StartClient();
+    StartListen();
+    WaitForShutdown();
+}
+
+
+void
+AggregatorService::StartClient()
+{
+    auto context = GetContext();
+    Socket::PacketHandlerMapPtr handlerMap(new Socket::PacketHandlerMap);
+    handlerMap->emplace(Socket::PacketType::SearchResponse,
+                        [this](Socket::ConnectionID p_srcID, Socket::Packet p_packet)
+                        {
+                            boost::asio::post(*m_threadPool,
+                                              std::bind(&AggregatorService::SearchResponseHanlder,
+                                                        this,
+                                                        p_srcID,
+                                                        std::move(p_packet)));
+                        });
+
+
+    m_socketClient.reset(new Socket::Client(handlerMap,
+                                            context->GetSettings()->m_socketThreadNum,
+                                            30));
+
+    m_socketClient->SetEventOnConnectionClose([this](Socket::ConnectionID p_cid)
+                                              {
+                                                  auto context = this->GetContext();
+                                                  for (const auto& server : context->GetRemoteServers())
+                                                  {
+                                                      if (nullptr != server && p_cid == server->m_connectionID)
+                                                      {
+                                                          server->m_status = RemoteMachineStatus::Disconnected;
+                                                          this->AddToPendingServers(server);
+                                                      }
+                                                  }
+                                              });
+
+    {
+        std::lock_guard<std::mutex> guard(m_pendingConnectServersMutex);
+        m_pendingConnectServers = context->GetRemoteServers();
+    }
+
+    ConnectToPendingServers();
+}
+
+
+void
+AggregatorService::StartListen()
+{
+    auto context = GetContext();
+    Socket::PacketHandlerMapPtr handlerMap(new Socket::PacketHandlerMap);
+    handlerMap->emplace(Socket::PacketType::SearchRequest,
+                        [this](Socket::ConnectionID p_srcID, Socket::Packet p_packet)
+                        {
+                            boost::asio::post(*m_threadPool,
+                                              std::bind(&AggregatorService::SearchRequestHanlder,
+                                                        this,
+                                                        p_srcID,
+                                                        std::move(p_packet)));
+                        });
+
+    m_socketServer.reset(new Socket::Server(context->GetSettings()->m_listenAddr,
+                                            context->GetSettings()->m_listenPort,
+                                            handlerMap,
+                                            context->GetSettings()->m_socketThreadNum));
+
+    fprintf(stderr,
+            "Start to listen %s:%s ...\n",
+            context->GetSettings()->m_listenAddr.c_str(),
+            context->GetSettings()->m_listenPort.c_str());
+}
+
+
+void
+AggregatorService::WaitForShutdown()
+{
+    m_shutdownSignals.add(SIGINT);
+    m_shutdownSignals.add(SIGTERM);
+#ifdef SIGQUIT
+    m_shutdownSignals.add(SIGQUIT);
+#endif
+
+    m_shutdownSignals.async_wait([this](boost::system::error_code p_ec, int p_signal)
+    {
+        fprintf(stderr, "Received shutdown signals.\n");
+        m_pendingConnectServersTimer.cancel();
+    });
+
+    m_ioContext.run();
+    fprintf(stderr, "Start shutdown procedure.\n");
+
+    m_socketServer.reset();
+    m_threadPool->stop();
+    m_threadPool->join();
+}
+
+
+void
+AggregatorService::ConnectToPendingServers()
+{
+    auto context = GetContext();
+    std::vector<std::shared_ptr<RemoteMachine>> pendingList;
+    pendingList.reserve(context->GetRemoteServers().size());
+
+    {
+        std::lock_guard<std::mutex> guard(m_pendingConnectServersMutex);
+        pendingList.swap(m_pendingConnectServers);
+    }
+
+    for (auto& pendingServer : pendingList)
+    {
+        if (pendingServer->m_status != RemoteMachineStatus::Disconnected)
+        {
+            continue;
+        }
+
+        pendingServer->m_status = RemoteMachineStatus::Connecting;
+        std::shared_ptr<RemoteMachine> server = pendingServer;
+        auto runner = [server, this]()
+                      {
+                          ErrorCode errCode;
+                          auto cid = m_socketClient->ConnectToServer(server->m_address, server->m_port, errCode);
+                          if (Socket::c_invalidConnectionID == cid)
+                          {
+                              if (ErrorCode::Socket_FailedResolveEndPoint == errCode)
+                              {
+                                  fprintf(stderr,
+                                          "[Error] Failed to resolve %s %s.\n",
+                                          server->m_address.c_str(),
+                                          server->m_port.c_str());
+                              }
+                              else
+                              {
+                                  this->AddToPendingServers(std::move(server));
+                              }
+                          }
+                          else
+                          {
+                              server->m_connectionID = cid;
+                              server->m_status = RemoteMachineStatus::Connected;
+                          }
+                      };
+        boost::asio::post(*m_threadPool, std::move(runner));
+    }
+
+    m_pendingConnectServersTimer.expires_from_now(boost::posix_time::seconds(30));
+    m_pendingConnectServersTimer.async_wait([this](const boost::system::error_code& p_ec)
+                                            {
+                                                if (boost::asio::error::operation_aborted != p_ec)
+                                                {
+                                                    ConnectToPendingServers();
+                                                }
+                                            });
+}
+
+
+void
+AggregatorService::AddToPendingServers(std::shared_ptr<RemoteMachine> p_remoteServer)
+{
+    std::lock_guard<std::mutex> guard(m_pendingConnectServersMutex);
+    m_pendingConnectServers.emplace_back(std::move(p_remoteServer));
+}
+
+
+void
+AggregatorService::SearchRequestHanlder(Socket::ConnectionID p_localConnectionID, Socket::Packet p_packet)
+{
+    auto context = GetContext();
+    std::vector<Socket::ConnectionID> remoteServers;
+    remoteServers.reserve(context->GetRemoteServers().size());
+
+    for (const auto& server : context->GetRemoteServers())
+    {
+        if (RemoteMachineStatus::Connected != server->m_status)
+        {
+            continue;
+        }
+
+        remoteServers.push_back(server->m_connectionID);
+    }
+
+    Socket::PacketHeader requestHeader = p_packet.Header();
+    if (Socket::c_invalidConnectionID == requestHeader.m_connectionID)
+    {
+        requestHeader.m_connectionID = p_localConnectionID;
+    }
+
+    std::shared_ptr<AggregatorExecutionContext> executionContext(
+        new AggregatorExecutionContext(remoteServers.size(), requestHeader));
+
+    for (std::uint32_t i = 0; i < remoteServers.size(); ++i)
+    {
+        AggregatorCallback callback = [this, executionContext, i](Socket::RemoteSearchResult p_result)
+        {
+            executionContext->GetResult(i).reset(new Socket::RemoteSearchResult(std::move(p_result)));
+            if (executionContext->IsCompletedAfterFinsh(1))
+            {
+                this->AggregateResults(std::move(executionContext));
+            }
+        };
+
+        auto timeoutCallback = [](std::shared_ptr<AggregatorCallback> p_callback)
+        {
+            if (nullptr != p_callback)
+            {
+                Socket::RemoteSearchResult result;
+                result.m_status = Socket::RemoteSearchResult::ResultStatus::Timeout;
+
+                (*p_callback)(std::move(result));
+            }
+        };
+
+        auto connectCallback = [callback](bool p_connectSucc)
+        {
+            if (!p_connectSucc)
+            {
+                Socket::RemoteSearchResult result;
+                result.m_status = Socket::RemoteSearchResult::ResultStatus::FailedNetwork;
+
+                callback(std::move(result));
+            }
+        };
+
+        Socket::Packet packet;
+        packet.Header().m_packetType = Socket::PacketType::SearchRequest;
+        packet.Header().m_processStatus = Socket::PacketProcessStatus::Ok;
+        packet.Header().m_bodyLength = p_packet.Header().m_bodyLength;
+        packet.Header().m_connectionID = Socket::c_invalidConnectionID;
+        packet.Header().m_resourceID = m_aggregatorCallbackManager.Add(std::make_shared<AggregatorCallback>(std::move(callback)),
+                                                                       context->GetSettings()->m_searchTimeout,
+                                                                       std::move(timeoutCallback));
+
+        packet.AllocateBuffer(packet.Header().m_bodyLength);
+        packet.Header().WriteBuffer(packet.HeaderBuffer());
+        memcpy(packet.Body(), p_packet.Body(), packet.Header().m_bodyLength);
+
+        m_socketClient->SendPacket(remoteServers[i], std::move(packet), connectCallback);
+    }
+}
+
+
+void
+AggregatorService::SearchResponseHanlder(Socket::ConnectionID p_localConnectionID, Socket::Packet p_packet)
+{
+    auto callback = m_aggregatorCallbackManager.GetAndRemove(p_packet.Header().m_resourceID);
+    if (nullptr == callback)
+    {
+        return;
+    }
+
+    if (p_packet.Header().m_processStatus != Socket::PacketProcessStatus::Ok || 0 == p_packet.Header().m_bodyLength)
+    {
+        Socket::RemoteSearchResult result;
+        result.m_status = Socket::RemoteSearchResult::ResultStatus::FailedExecute;
+
+        (*callback)(std::move(result));
+    }
+    else
+    {
+        Socket::RemoteSearchResult result;
+        result.Read(p_packet.Body());
+        (*callback)(std::move(result));
+    }
+}
+
+
+std::shared_ptr<AggregatorContext>
+AggregatorService::GetContext()
+{
+    // Add mutex if necessary.
+    return m_aggregatorContext;
+}
+
+
+void
+AggregatorService::AggregateResults(std::shared_ptr<AggregatorExecutionContext> p_exectionContext)
+{
+    if (nullptr == p_exectionContext)
+    {
+        return;
+    }
+
+    Socket::Packet packet;
+    packet.Header().m_packetType = Socket::PacketType::SearchResponse;
+    packet.Header().m_processStatus = Socket::PacketProcessStatus::Ok;
+    packet.Header().m_resourceID = p_exectionContext->GetRequestHeader().m_resourceID;
+
+    Socket::RemoteSearchResult remoteResult;
+    remoteResult.m_status = Socket::RemoteSearchResult::ResultStatus::Success;
+
+    std::size_t resultNum = 0;
+    for (std::size_t i = 0; i < p_exectionContext->GetServerNumber(); ++i)
+    {
+        const auto& result = p_exectionContext->GetResult(i);
+        if (nullptr == result)
+        {
+            continue;
+        }
+
+        resultNum += result->m_allIndexResults.size();
+    }
+
+    remoteResult.m_allIndexResults.reserve(resultNum);
+    for (std::size_t i = 0; i < p_exectionContext->GetServerNumber(); ++i)
+    {
+        const auto& result = p_exectionContext->GetResult(i);
+        if (nullptr == result)
+        {
+            continue;
+        }
+
+        for (auto& indexRes : result->m_allIndexResults)
+        {
+            remoteResult.m_allIndexResults.emplace_back(std::move(indexRes));
+        }
+    }
+
+    std::uint32_t cap = static_cast<std::uint32_t>(remoteResult.EstimateBufferSize());
+    packet.AllocateBuffer(cap);
+    packet.Header().m_bodyLength = static_cast<std::uint32_t>(remoteResult.Write(packet.Body()) - packet.Body());
+    packet.Header().WriteBuffer(packet.HeaderBuffer());
+
+    m_socketServer->SendPacket(p_exectionContext->GetRequestHeader().m_connectionID,
+                               std::move(packet),
+                               nullptr);
+}
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/src/Aggregator/AggregatorSettings.cpp b/core/src/index/thirdparty/SPTAG/AnnService/src/Aggregator/AggregatorSettings.cpp
new file mode 100644
index 0000000000..a3e2bc6806
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/src/Aggregator/AggregatorSettings.cpp
@@ -0,0 +1,14 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Aggregator/AggregatorSettings.h"
+
+using namespace SPTAG;
+using namespace SPTAG::Aggregator;
+
+AggregatorSettings::AggregatorSettings()
+    : m_searchTimeout(100),
+      m_threadNum(8),
+      m_socketThreadNum(8)
+{
+}
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/src/Aggregator/main.cpp b/core/src/index/thirdparty/SPTAG/AnnService/src/Aggregator/main.cpp
new file mode 100644
index 0000000000..2a06025d5e
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/src/Aggregator/main.cpp
@@ -0,0 +1,19 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Aggregator/AggregatorService.h"
+
+SPTAG::Aggregator::AggregatorService g_service;
+
+int main(int argc, char* argv[])
+{
+    if (!g_service.Initialize())
+    {
+        return 1;
+    }
+
+    g_service.Run();
+
+    return 0;
+}
+
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/src/Client/ClientWrapper.cpp b/core/src/index/thirdparty/SPTAG/AnnService/src/Client/ClientWrapper.cpp
new file mode 100644
index 0000000000..7e91c63195
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/src/Client/ClientWrapper.cpp
@@ -0,0 +1,235 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Client/ClientWrapper.h"
+
+using namespace SPTAG;
+using namespace SPTAG::Socket;
+using namespace SPTAG::Client;
+
+ClientWrapper::ClientWrapper(const ClientOptions& p_options)
+    : m_options(p_options),
+      m_unfinishedJobCount(0),
+      m_isWaitingFinish(false)
+{
+    m_client.reset(new SPTAG::Socket::Client(GetHandlerMap(), p_options.m_socketThreadNum, 30));
+    m_client->SetEventOnConnectionClose(std::bind(&ClientWrapper::HandleDeadConnection,
+                                                  this,
+                                                  std::placeholders::_1));
+
+    m_connections.reserve(m_options.m_threadNum);
+    for (std::uint32_t i = 0; i < m_options.m_threadNum; ++i)
+    {
+        SPTAG::ErrorCode errCode;
+        ConnectionPair conn(c_invalidConnectionID, c_invalidConnectionID);
+        conn.first = m_client->ConnectToServer(p_options.m_serverAddr, p_options.m_serverPort, errCode);
+        if (SPTAG::ErrorCode::Socket_FailedResolveEndPoint == errCode)
+        {
+            fprintf(stderr, "Unable to resolve remote address.\n");
+            return;
+        }
+
+        if (c_invalidConnectionID != conn.first)
+        {
+            m_connections.emplace_back(std::move(conn));
+        }
+    }
+}
+
+
+ClientWrapper::~ClientWrapper()
+{
+}
+
+
+void
+ClientWrapper::SendQueryAsync(const Socket::RemoteQuery& p_query,
+                              Callback p_callback,
+                              const ClientOptions& p_options)
+{
+    if (!bool(p_callback))
+    {
+        return;
+    }
+
+    auto conn = GetConnection();
+
+    auto timeoutCallback = [this](std::shared_ptr<Callback> p_callback)
+    {
+        DecreaseUnfnishedJobCount();
+        if (nullptr != p_callback)
+        {
+            Socket::RemoteSearchResult result;
+            result.m_status = Socket::RemoteSearchResult::ResultStatus::Timeout;
+
+            (*p_callback)(std::move(result));
+        }
+    };
+
+
+    auto connectCallback = [p_callback, this](bool p_connectSucc)
+    {
+        if (!p_connectSucc)
+        {
+            Socket::RemoteSearchResult result;
+            result.m_status = Socket::RemoteSearchResult::ResultStatus::FailedNetwork;
+
+            p_callback(std::move(result));
+            DecreaseUnfnishedJobCount();
+        }
+    };
+
+    Socket::Packet packet;
+    packet.Header().m_connectionID = c_invalidConnectionID;
+    packet.Header().m_packetType = PacketType::SearchRequest;
+    packet.Header().m_processStatus = PacketProcessStatus::Ok;
+    packet.Header().m_resourceID = m_callbackManager.Add(std::make_shared<Callback>(std::move(p_callback)),
+                                                         p_options.m_searchTimeout,
+                                                         std::move(timeoutCallback));
+
+    packet.Header().m_bodyLength = static_cast<std::uint32_t>(p_query.EstimateBufferSize());
+    packet.AllocateBuffer(packet.Header().m_bodyLength);
+    p_query.Write(packet.Body());
+    packet.Header().WriteBuffer(packet.HeaderBuffer());
+
+    ++m_unfinishedJobCount;
+    m_client->SendPacket(conn.first, std::move(packet), connectCallback);
+}
+
+
+void
+ClientWrapper::WaitAllFinished()
+{
+    if (m_unfinishedJobCount > 0)
+    {
+        std::unique_lock<std::mutex> lock(m_waitingMutex);
+        if (m_unfinishedJobCount > 0)
+        {
+            m_isWaitingFinish = true;
+            m_waitingQueue.wait(lock);
+        }
+    }
+}
+
+
+PacketHandlerMapPtr
+ClientWrapper::GetHandlerMap()
+{
+    PacketHandlerMapPtr handlerMap(new PacketHandlerMap);
+    handlerMap->emplace(PacketType::RegisterResponse,
+                        [this](ConnectionID p_localConnectionID, Packet p_packet) -> void
+    {
+        for (auto& conn : m_connections)
+        {
+            if (conn.first == p_localConnectionID)
+            {
+                conn.second = p_packet.Header().m_connectionID;
+                return;
+            }
+        }
+    });
+
+    handlerMap->emplace(PacketType::SearchResponse,
+                        std::bind(&ClientWrapper::SearchResponseHanlder,
+                                  this,
+                                  std::placeholders::_1,
+                                  std::placeholders::_2));
+
+    return handlerMap;
+}
+
+
+void
+ClientWrapper::DecreaseUnfnishedJobCount()
+{
+    --m_unfinishedJobCount;
+    if (0 == m_unfinishedJobCount)
+    {
+        std::lock_guard<std::mutex> guard(m_waitingMutex);
+        if (0 == m_unfinishedJobCount && m_isWaitingFinish)
+        {
+            m_waitingQueue.notify_all();
+            m_isWaitingFinish = false;
+        }
+    }
+}
+
+
+const ClientWrapper::ConnectionPair&
+ClientWrapper::GetConnection()
+{
+    if (m_connections.size() == 1)
+    {
+        return m_connections.front();
+    }
+
+    std::size_t triedCount = 0;
+    std::uint32_t pos = m_spinCountOfConnection.fetch_add(1) % m_connections.size();
+    while (c_invalidConnectionID == m_connections[pos].first && triedCount < m_connections.size())
+    {
+        pos = m_spinCountOfConnection.fetch_add(1) % m_connections.size();
+        ++triedCount;
+    }
+
+    return m_connections[pos];
+}
+
+
+void
+ClientWrapper::SearchResponseHanlder(Socket::ConnectionID p_localConnectionID, Socket::Packet p_packet)
+{
+    std::shared_ptr<Callback> callback = m_callbackManager.GetAndRemove(p_packet.Header().m_resourceID);
+    if (nullptr == callback)
+    {
+        return;
+    }
+
+    if (p_packet.Header().m_processStatus != PacketProcessStatus::Ok || 0 == p_packet.Header().m_bodyLength)
+    {
+        Socket::RemoteSearchResult result;
+        result.m_status = Socket::RemoteSearchResult::ResultStatus::FailedExecute;
+
+        (*callback)(std::move(result));
+    }
+    else
+    {
+        Socket::RemoteSearchResult result;
+        result.Read(p_packet.Body());
+        (*callback)(std::move(result));
+    }
+
+    DecreaseUnfnishedJobCount();
+}
+
+
+void
+ClientWrapper::HandleDeadConnection(Socket::ConnectionID p_cid)
+{
+    for (auto& conn : m_connections)
+    {
+        if (conn.first == p_cid)
+        {
+            conn.first = c_invalidConnectionID;
+            conn.second = c_invalidConnectionID;
+
+            SPTAG::ErrorCode errCode;
+            while (c_invalidConnectionID == conn.first)
+            {
+                conn.first = m_client->ConnectToServer(m_options.m_serverAddr, m_options.m_serverPort, errCode);
+                if (SPTAG::ErrorCode::Socket_FailedResolveEndPoint == errCode)
+                {
+                    break;
+                }
+            }
+
+            return;
+        }
+    }
+}
+
+
+bool
+ClientWrapper::IsAvailable() const
+{
+    return !m_connections.empty();
+}
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/src/Client/Options.cpp b/core/src/index/thirdparty/SPTAG/AnnService/src/Client/Options.cpp
new file mode 100644
index 0000000000..bb067d3d58
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/src/Client/Options.cpp
@@ -0,0 +1,27 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Client/Options.h"
+#include "inc/Helper/StringConvert.h"
+
+#include <cassert>
+
+using namespace SPTAG;
+using namespace SPTAG::Client;
+
+ClientOptions::ClientOptions()
+    : m_searchTimeout(9000),
+      m_threadNum(1),
+      m_socketThreadNum(2)
+{
+    AddRequiredOption(m_serverAddr, "-s", "--server", "Server address.");
+    AddRequiredOption(m_serverPort, "-p", "--port", "Server port.");
+    AddOptionalOption(m_searchTimeout, "-t", "", "Search timeout.");
+    AddOptionalOption(m_threadNum, "-cth", "", "Client Thread Number.");
+    AddOptionalOption(m_socketThreadNum, "-sth", "", "Socket Thread Number.");
+}
+
+
+ClientOptions::~ClientOptions()
+{
+}
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/src/Client/main.cpp b/core/src/index/thirdparty/SPTAG/AnnService/src/Client/main.cpp
new file mode 100644
index 0000000000..52888e3374
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/src/Client/main.cpp
@@ -0,0 +1,78 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Client/Options.h"
+#include "inc/Client/ClientWrapper.h"
+
+#include <cstdio>
+#include <atomic>
+#include <iostream>
+
+std::unique_ptr<SPTAG::Client::ClientWrapper> g_client;
+
+int main(int argc, char** argv)
+{
+    SPTAG::Client::ClientOptions options;
+    if (!options.Parse(argc - 1, argv + 1))
+    {
+        return 1;
+    }
+
+    g_client.reset(new SPTAG::Client::ClientWrapper(options));
+    if (!g_client->IsAvailable())
+    {
+        return 1;
+    }
+
+    g_client->WaitAllFinished();
+    fprintf(stdout, "connection done\n");
+
+    std::string line;
+    std::cout << "Query: " << std::flush;
+    while (std::getline(std::cin, line))
+    {
+        if (line.empty())
+        {
+            break;
+        }
+
+        SPTAG::Socket::RemoteQuery query;
+        query.m_type = SPTAG::Socket::RemoteQuery::QueryType::String;
+        query.m_queryString = std::move(line);
+
+        SPTAG::Socket::RemoteSearchResult result;
+        auto callback = [&result](SPTAG::Socket::RemoteSearchResult p_result)
+        {
+            result = std::move(p_result);
+        };
+
+        g_client->SendQueryAsync(query, callback, options);
+        g_client->WaitAllFinished();
+
+        std::cout << "Status: " << static_cast<std::uint32_t>(result.m_status) << std::endl;
+
+        for (const auto& indexRes : result.m_allIndexResults)
+        {
+            std::cout << "Index: " << indexRes.m_indexName << std::endl;
+
+            int idx = 0;
+            for (const auto& res : indexRes.m_results)
+            {
+                std::cout << "------------------" << std::endl;
+                std::cout << "DocIndex: " << res.VID << " Distance: " << res.Dist;
+                if (indexRes.m_results.WithMeta())
+                {
+                    const auto& metadata = indexRes.m_results.GetMetadata(idx);
+                    std::cout << " MetaData: " << std::string((char*)metadata.Data(), metadata.Length());
+                }
+                std::cout << std::endl;
+                ++idx;
+            }
+        }
+
+        std::cout << "Query: " << std::flush;
+    }
+
+    return 0;
+}
+
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/src/Core/BKT/BKTIndex.cpp b/core/src/index/thirdparty/SPTAG/AnnService/src/Core/BKT/BKTIndex.cpp
new file mode 100644
index 0000000000..e8928726f4
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/src/Core/BKT/BKTIndex.cpp
@@ -0,0 +1,403 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Core/BKT/Index.h"
+
+#pragma warning(disable:4996)  // 'fopen': This function or variable may be unsafe. Consider using fopen_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details.
+#pragma warning(disable:4242)  // '=' : conversion from 'int' to 'short', possible loss of data
+#pragma warning(disable:4244)  // '=' : conversion from 'int' to 'short', possible loss of data
+#pragma warning(disable:4127)  // conditional expression is constant
+
+namespace SPTAG
+{
+    namespace BKT
+    {
+        template <typename T>
+        ErrorCode Index<T>::LoadConfig(Helper::IniReader& p_reader)
+        {
+#define DefineBKTParameter(VarName, VarType, DefaultValue, RepresentStr) \
+            SetParameter(RepresentStr, \
+                         p_reader.GetParameter("Index", \
+                         RepresentStr, \
+                         std::string(#DefaultValue)).c_str()); \
+
+#include "inc/Core/BKT/ParameterDefinitionList.h"
+#undef DefineBKTParameter
+            return ErrorCode::Success;
+        }
+
+        template <typename T>
+        ErrorCode Index<T>::LoadIndexDataFromMemory(const std::vector<ByteArray>& p_indexBlobs)
+        {
+            if (p_indexBlobs.size() < 3) return ErrorCode::LackOfInputs;
+
+            if (!m_pSamples.Load((char*)p_indexBlobs[0].Data())) return ErrorCode::FailedParseValue;
+            if (!m_pTrees.LoadTrees((char*)p_indexBlobs[1].Data())) return ErrorCode::FailedParseValue;
+            if (!m_pGraph.LoadGraph((char*)p_indexBlobs[2].Data())) return ErrorCode::FailedParseValue;
+            if (p_indexBlobs.size() > 3 && !m_deletedID.load((char*)p_indexBlobs[3].Data())) return ErrorCode::FailedParseValue;
+
+            m_workSpacePool.reset(new COMMON::WorkSpacePool(m_iMaxCheck, GetNumSamples()));
+            m_workSpacePool->Init(m_iNumberOfThreads);
+            return ErrorCode::Success;
+        }
+
+        template <typename T>
+        ErrorCode Index<T>::LoadIndexData(const std::string& p_folderPath)
+        {
+            if (!m_pSamples.Load(p_folderPath + m_sDataPointsFilename)) return ErrorCode::Fail;
+            if (!m_pTrees.LoadTrees(p_folderPath + m_sBKTFilename)) return ErrorCode::Fail;
+            if (!m_pGraph.LoadGraph(p_folderPath + m_sGraphFilename)) return ErrorCode::Fail;
+            if (!m_deletedID.load(p_folderPath + m_sDeleteDataPointsFilename)) return ErrorCode::Fail;
+
+            m_workSpacePool.reset(new COMMON::WorkSpacePool(m_iMaxCheck, GetNumSamples()));
+            m_workSpacePool->Init(m_iNumberOfThreads);
+            return ErrorCode::Success;
+        }
+
+        template <typename T>
+        ErrorCode Index<T>::SaveConfig(std::ostream& p_configOut) const
+        {
+#define DefineBKTParameter(VarName, VarType, DefaultValue, RepresentStr) \
+    p_configOut << RepresentStr << "=" << GetParameter(RepresentStr) << std::endl;
+
+#include "inc/Core/BKT/ParameterDefinitionList.h"
+#undef DefineBKTParameter
+            p_configOut << std::endl;
+            return ErrorCode::Success;
+        }
+
+        template<typename T>
+        ErrorCode
+            Index<T>::SaveIndexData(const std::string& p_folderPath)
+        {
+            std::lock_guard<std::mutex> lock(m_dataAddLock);
+            std::shared_lock<std::shared_timed_mutex> sharedlock(m_deletedID.getLock());
+
+            if (!m_pSamples.Save(p_folderPath + m_sDataPointsFilename)) return ErrorCode::Fail;
+            if (!m_pTrees.SaveTrees(p_folderPath + m_sBKTFilename)) return ErrorCode::Fail;
+            if (!m_pGraph.SaveGraph(p_folderPath + m_sGraphFilename)) return ErrorCode::Fail;
+            if (!m_deletedID.save(p_folderPath + m_sDeleteDataPointsFilename)) return ErrorCode::Fail;
+            return ErrorCode::Success;
+        }
+
+        template<typename T>
+        ErrorCode Index<T>::SaveIndexData(const std::vector<std::ostream*>& p_indexStreams)
+        {
+            if (p_indexStreams.size() < 4) return ErrorCode::LackOfInputs;
+            
+            std::lock_guard<std::mutex> lock(m_dataAddLock);
+            std::shared_lock<std::shared_timed_mutex> sharedlock(m_deletedID.getLock());
+
+            if (!m_pSamples.Save(*p_indexStreams[0])) return ErrorCode::Fail;
+            if (!m_pTrees.SaveTrees(*p_indexStreams[1])) return ErrorCode::Fail;
+            if (!m_pGraph.SaveGraph(*p_indexStreams[2])) return ErrorCode::Fail;
+            if (!m_deletedID.save(*p_indexStreams[3])) return ErrorCode::Fail;
+            return ErrorCode::Success;
+        }
+
+#pragma region K-NN search
+
+#define Search(CheckDeleted1) \
+        m_pTrees.InitSearchTrees(this, p_query, p_space); \
+        const DimensionType checkPos = m_pGraph.m_iNeighborhoodSize - 1; \
+        while (!p_space.m_SPTQueue.empty()) { \
+            m_pTrees.SearchTrees(this, p_query, p_space, m_iNumberOfOtherDynamicPivots + p_space.m_iNumberOfCheckedLeaves); \
+            while (!p_space.m_NGQueue.empty()) { \
+                COMMON::HeapCell gnode = p_space.m_NGQueue.pop(); \
+                const SizeType *node = m_pGraph[gnode.node]; \
+                _mm_prefetch((const char *)node, _MM_HINT_T0); \
+                CheckDeleted1 { \
+                    if (p_query.AddPoint(gnode.node, gnode.distance)) { \
+                        p_space.m_iNumOfContinuousNoBetterPropagation = 0; \
+                        SizeType checkNode = node[checkPos]; \
+                        if (checkNode < -1) { \
+                            const COMMON::BKTNode& tnode = m_pTrees[-2 - checkNode]; \
+                            for (SizeType i = -tnode.childStart; i < tnode.childEnd; i++) { \
+                                if (!p_query.AddPoint(m_pTrees[i].centerid, gnode.distance)) break; \
+                            } \
+                        } \
+                    } \
+                    else { \
+                        p_space.m_iNumOfContinuousNoBetterPropagation++; \
+                        if (p_space.m_iNumOfContinuousNoBetterPropagation > p_space.m_iContinuousLimit || p_space.m_iNumberOfCheckedLeaves > p_space.m_iMaxCheck) { \
+                            p_query.SortResult(); return; \
+                        } \
+                    } \
+                } \
+                for (DimensionType i = 0; i <= checkPos; i++) { \
+                    _mm_prefetch((const char *)(m_pSamples)[node[i]], _MM_HINT_T0); \
+                } \
+                for (DimensionType i = 0; i <= checkPos; i++) { \
+                    SizeType nn_index = node[i]; \
+                    if (nn_index < 0) break; \
+                    if (p_space.CheckAndSet(nn_index)) continue; \
+                    float distance2leaf = m_fComputeDistance(p_query.GetTarget(), (m_pSamples)[nn_index], GetFeatureDim()); \
+                    p_space.m_iNumberOfCheckedLeaves++; \
+                    p_space.m_NGQueue.insert(COMMON::HeapCell(nn_index, distance2leaf)); \
+                } \
+                if (p_space.m_NGQueue.Top().distance > p_space.m_SPTQueue.Top().distance) { \
+                    break; \
+                } \
+            } \
+        } \
+        p_query.SortResult(); \
+
+        template <typename T>
+        void Index<T>::SearchIndexWithDeleted(COMMON::QueryResultSet<T> &p_query, COMMON::WorkSpace &p_space, const Helper::Concurrent::ConcurrentSet<SizeType> &p_deleted) const
+        {
+            Search(if (!p_deleted.contains(gnode.node)))
+        }
+
+        template <typename T>
+        void Index<T>::SearchIndexWithoutDeleted(COMMON::QueryResultSet<T> &p_query, COMMON::WorkSpace &p_space) const
+        {
+            Search(;)
+        }
+
+        template<typename T>
+        ErrorCode
+            Index<T>::SearchIndex(QueryResult &p_query) const
+        {
+            auto workSpace = m_workSpacePool->Rent();
+            workSpace->Reset(m_iMaxCheck);
+
+            if (m_deletedID.size() > 0)
+                SearchIndexWithDeleted(*((COMMON::QueryResultSet<T>*)&p_query), *workSpace, m_deletedID);
+            else
+                SearchIndexWithoutDeleted(*((COMMON::QueryResultSet<T>*)&p_query), *workSpace);
+
+            m_workSpacePool->Return(workSpace);
+
+            if (p_query.WithMeta() && nullptr != m_pMetadata)
+            {
+                for (int i = 0; i < p_query.GetResultNum(); ++i)
+                {
+                    SizeType result = p_query.GetResult(i)->VID;
+                    p_query.SetMetadata(i, (result < 0) ? ByteArray::c_empty : m_pMetadata->GetMetadata(result));
+                }
+            }
+            return ErrorCode::Success;
+        }
+#pragma endregion
+
+        template <typename T>
+        ErrorCode Index<T>::BuildIndex(const void* p_data, SizeType p_vectorNum, DimensionType p_dimension)
+        {
+            omp_set_num_threads(m_iNumberOfThreads);
+
+            m_pSamples.Initialize(p_vectorNum, p_dimension, (T*)p_data, false);
+
+            if (DistCalcMethod::Cosine == m_iDistCalcMethod)
+            {
+                int base = COMMON::Utils::GetBase<T>();
+#pragma omp parallel for
+                for (SizeType i = 0; i < GetNumSamples(); i++) {
+                    COMMON::Utils::Normalize(m_pSamples[i], GetFeatureDim(), base);
+                }
+            }
+
+            m_workSpacePool.reset(new COMMON::WorkSpacePool(m_iMaxCheck, GetNumSamples()));
+            m_workSpacePool->Init(m_iNumberOfThreads);
+            
+            m_pTrees.BuildTrees<T>(this);
+            m_pGraph.BuildGraph<T>(this, &(m_pTrees.GetSampleMap()));
+
+            return ErrorCode::Success;
+        }
+
+        template <typename T>
+        ErrorCode Index<T>::RefineIndex(const std::vector<std::ostream*>& p_indexStreams)
+        {
+            std::lock_guard<std::mutex> lock(m_dataAddLock);
+            std::shared_lock<std::shared_timed_mutex> sharedlock(m_deletedID.getLock());
+
+            SizeType newR = GetNumSamples();
+
+            std::vector<SizeType> indices;
+            std::vector<SizeType> reverseIndices(newR);
+            for (SizeType i = 0; i < newR; i++) {
+                if (!m_deletedID.contains(i)) {
+                    indices.push_back(i);
+                    reverseIndices[i] = i;
+                }
+                else {
+                    while (m_deletedID.contains(newR - 1) && newR > i) newR--;
+                    if (newR == i) break;
+                    indices.push_back(newR - 1);
+                    reverseIndices[newR - 1] = i;
+                    newR--;
+                }
+            }
+
+            std::cout << "Refine... from " << GetNumSamples() << "->" << newR << std::endl;
+
+            if (false == m_pSamples.Refine(indices, *p_indexStreams[0])) return ErrorCode::Fail;
+            if (nullptr != m_pMetadata && (p_indexStreams.size() < 6 || ErrorCode::Success != m_pMetadata->RefineMetadata(indices, *p_indexStreams[4], *p_indexStreams[5]))) return ErrorCode::Fail;
+
+            COMMON::BKTree newTrees(m_pTrees);
+            newTrees.BuildTrees<T>(this, &indices);
+#pragma omp parallel for
+            for (SizeType i = 0; i < newTrees.size(); i++) {
+                newTrees[i].centerid = reverseIndices[newTrees[i].centerid];
+            }
+            newTrees.SaveTrees(*p_indexStreams[1]);
+
+            m_pGraph.RefineGraph<T>(this, indices, reverseIndices, *p_indexStreams[2], &(newTrees.GetSampleMap()));
+
+            Helper::Concurrent::ConcurrentSet<SizeType> newDeletedID;
+            newDeletedID.save(*p_indexStreams[3]);
+            return ErrorCode::Success;
+        }
+
+        template <typename T>
+        ErrorCode Index<T>::RefineIndex(const std::string& p_folderPath)
+        {
+            std::string folderPath(p_folderPath);
+            if (!folderPath.empty() && *(folderPath.rbegin()) != FolderSep)
+            {
+                folderPath += FolderSep;
+            }
+
+            if (!direxists(folderPath.c_str()))
+            {
+                mkdir(folderPath.c_str());
+            }
+
+            std::vector<std::ostream*> streams;
+            streams.push_back(new std::ofstream(folderPath + m_sDataPointsFilename, std::ios::binary));
+            streams.push_back(new std::ofstream(folderPath + m_sBKTFilename, std::ios::binary));
+            streams.push_back(new std::ofstream(folderPath + m_sGraphFilename, std::ios::binary));
+            streams.push_back(new std::ofstream(folderPath + m_sDeleteDataPointsFilename, std::ios::binary));
+            if (nullptr != m_pMetadata)
+            {
+                streams.push_back(new std::ofstream(folderPath + m_sMetadataFile, std::ios::binary));
+                streams.push_back(new std::ofstream(folderPath + m_sMetadataIndexFile, std::ios::binary));
+            }
+
+            for (size_t i = 0; i < streams.size(); i++)
+                if (!(((std::ofstream*)streams[i])->is_open())) return ErrorCode::FailedCreateFile;
+
+            ErrorCode ret = RefineIndex(streams);
+
+            for (size_t i = 0; i < streams.size(); i++)
+            {
+                ((std::ofstream*)streams[i])->close();
+                delete streams[i];
+            }
+            return ret;
+        }
+
+        template <typename T>
+        ErrorCode Index<T>::DeleteIndex(const void* p_vectors, SizeType p_vectorNum) {
+            const T* ptr_v = (const T*)p_vectors;
+#pragma omp parallel for schedule(dynamic)
+            for (SizeType i = 0; i < p_vectorNum; i++) {
+                COMMON::QueryResultSet<T> query(ptr_v + i * GetFeatureDim(), m_pGraph.m_iCEF);
+                SearchIndex(query);
+
+                for (int i = 0; i < m_pGraph.m_iCEF; i++) {
+                    if (query.GetResult(i)->Dist < 1e-6) {
+                        m_deletedID.insert(query.GetResult(i)->VID);
+                    }
+                }
+            }
+            return ErrorCode::Success;
+        }
+
+        template <typename T>
+        ErrorCode Index<T>::DeleteIndex(const SizeType& p_id) {
+            m_deletedID.insert(p_id);
+            return ErrorCode::Success;
+        }
+
+        template <typename T>
+        ErrorCode Index<T>::AddIndex(const void* p_vectors, SizeType p_vectorNum, DimensionType p_dimension, SizeType* p_start)
+        {
+            SizeType begin, end;
+            {
+                std::lock_guard<std::mutex> lock(m_dataAddLock);
+
+                begin = GetNumSamples();
+                end = GetNumSamples() + p_vectorNum;
+
+                if (p_start != nullptr) *p_start = begin;
+                
+                if (begin == 0) return BuildIndex(p_vectors, p_vectorNum, p_dimension);
+
+                if (p_dimension != GetFeatureDim()) return ErrorCode::FailedParseValue;
+
+                if (m_pSamples.AddBatch((const T*)p_vectors, p_vectorNum) != ErrorCode::Success || m_pGraph.AddBatch(p_vectorNum) != ErrorCode::Success) {
+                    std::cout << "Memory Error: Cannot alloc space for vectors" << std::endl;
+                    m_pSamples.SetR(begin);
+                    m_pGraph.SetR(begin);
+                    return ErrorCode::MemoryOverFlow;
+                }
+                if (DistCalcMethod::Cosine == m_iDistCalcMethod)
+                {
+                    int base = COMMON::Utils::GetBase<T>();
+                    for (SizeType i = begin; i < end; i++) {
+                        COMMON::Utils::Normalize((T*)m_pSamples[i], GetFeatureDim(), base);
+                    }
+                }
+            }
+
+            for (SizeType node = begin; node < end; node++)
+            {
+                m_pGraph.RefineNode<T>(this, node, true);
+            }
+            std::cout << "Add " << p_vectorNum << " vectors" << std::endl;
+            return ErrorCode::Success;
+        }
+
+        template <typename T>
+        ErrorCode
+            Index<T>::SetParameter(const char* p_param, const char* p_value)
+        {
+            if (nullptr == p_param || nullptr == p_value) return ErrorCode::Fail;
+
+#define DefineBKTParameter(VarName, VarType, DefaultValue, RepresentStr) \
+    else if (SPTAG::Helper::StrUtils::StrEqualIgnoreCase(p_param, RepresentStr)) \
+    { \
+        fprintf(stderr, "Setting %s with value %s\n", RepresentStr, p_value); \
+        VarType tmp; \
+        if (SPTAG::Helper::Convert::ConvertStringTo<VarType>(p_value, tmp)) \
+        { \
+            VarName = tmp; \
+        } \
+    } \
+
+#include "inc/Core/BKT/ParameterDefinitionList.h"
+#undef DefineBKTParameter
+
+            m_fComputeDistance = COMMON::DistanceCalcSelector<T>(m_iDistCalcMethod);
+            return ErrorCode::Success;
+        }
+
+
+        template <typename T>
+        std::string
+            Index<T>::GetParameter(const char* p_param) const
+        {
+            if (nullptr == p_param) return std::string();
+
+#define DefineBKTParameter(VarName, VarType, DefaultValue, RepresentStr) \
+    else if (SPTAG::Helper::StrUtils::StrEqualIgnoreCase(p_param, RepresentStr)) \
+    { \
+        return SPTAG::Helper::Convert::ConvertToString(VarName); \
+    } \
+
+#include "inc/Core/BKT/ParameterDefinitionList.h"
+#undef DefineBKTParameter
+
+            return std::string();
+        }
+    }
+}
+
+#define DefineVectorValueType(Name, Type) \
+template class SPTAG::BKT::Index<Type>; \
+
+#include "inc/Core/DefinitionList.h"
+#undef DefineVectorValueType
+
+
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/src/Core/Common/NeighborhoodGraph.cpp b/core/src/index/thirdparty/SPTAG/AnnService/src/Core/Common/NeighborhoodGraph.cpp
new file mode 100644
index 0000000000..94115dd0a3
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/src/Core/Common/NeighborhoodGraph.cpp
@@ -0,0 +1,17 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Core/Common/NeighborhoodGraph.h"
+#include "inc/Core/Common/RelativeNeighborhoodGraph.h"
+
+using namespace SPTAG::COMMON;
+
+std::shared_ptr<NeighborhoodGraph> NeighborhoodGraph::CreateInstance(std::string type)
+{
+    std::shared_ptr<NeighborhoodGraph> res;
+    if (type == "RNG")
+    {
+        res.reset(new RelativeNeighborhoodGraph);
+    }
+    return res;
+}
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/src/Core/Common/WorkSpacePool.cpp b/core/src/index/thirdparty/SPTAG/AnnService/src/Core/Common/WorkSpacePool.cpp
new file mode 100644
index 0000000000..a88dbdb2d5
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/src/Core/Common/WorkSpacePool.cpp
@@ -0,0 +1,66 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Core/Common/WorkSpacePool.h"
+
+using namespace SPTAG;
+using namespace SPTAG::COMMON;
+
+
+WorkSpacePool::WorkSpacePool(int p_maxCheck, SizeType p_vectorCount)
+    : m_maxCheck(p_maxCheck),
+      m_vectorCount(p_vectorCount)
+{
+}
+
+
+WorkSpacePool::~WorkSpacePool()
+{
+    for (auto& workSpace : m_workSpacePool)
+        workSpace.reset();
+    m_workSpacePool.clear();
+}
+
+
+std::shared_ptr<WorkSpace>
+WorkSpacePool::Rent()
+{
+    std::shared_ptr<WorkSpace> workSpace;
+
+    {
+        std::lock_guard<std::mutex> lock(m_workSpacePoolMutex);
+        if (!m_workSpacePool.empty())
+        {
+            workSpace = m_workSpacePool.front();
+            m_workSpacePool.pop_front();
+        }
+        else
+        {
+            workSpace.reset(new WorkSpace);
+            workSpace->Initialize(m_maxCheck, m_vectorCount);
+        }
+    }
+    return workSpace;
+}
+
+
+void
+WorkSpacePool::Return(const std::shared_ptr<WorkSpace>& p_workSpace)
+{
+    {
+        std::lock_guard<std::mutex> lock(m_workSpacePoolMutex);
+        m_workSpacePool.push_back(p_workSpace);
+    }
+}
+
+
+void
+WorkSpacePool::Init(int size)
+{
+    for (int i = 0; i < size; i++) 
+    {
+        std::shared_ptr<WorkSpace> workSpace(new WorkSpace);
+        workSpace->Initialize(m_maxCheck, m_vectorCount);
+        m_workSpacePool.push_back(std::move(workSpace));
+    }
+}
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/src/Core/KDT/KDTIndex.cpp b/core/src/index/thirdparty/SPTAG/AnnService/src/Core/KDT/KDTIndex.cpp
new file mode 100644
index 0000000000..da3c10e095
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/src/Core/KDT/KDTIndex.cpp
@@ -0,0 +1,396 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Core/KDT/Index.h"
+
+#pragma warning(disable:4996)  // 'fopen': This function or variable may be unsafe. Consider using fopen_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details.
+#pragma warning(disable:4242)  // '=' : conversion from 'int' to 'short', possible loss of data
+#pragma warning(disable:4244)  // '=' : conversion from 'int' to 'short', possible loss of data
+#pragma warning(disable:4127)  // conditional expression is constant
+
+namespace SPTAG
+{
+    namespace KDT
+    {
+        template <typename T>
+        ErrorCode Index<T>::LoadConfig(Helper::IniReader& p_reader)
+        {
+#define DefineKDTParameter(VarName, VarType, DefaultValue, RepresentStr) \
+            SetParameter(RepresentStr, \
+                         p_reader.GetParameter("Index", \
+                         RepresentStr, \
+                         std::string(#DefaultValue)).c_str()); \
+
+#include "inc/Core/KDT/ParameterDefinitionList.h"
+#undef DefineKDTParameter
+            return ErrorCode::Success;
+        }
+
+        template <typename T>
+        ErrorCode Index<T>::LoadIndexDataFromMemory(const std::vector<ByteArray>& p_indexBlobs)
+        {
+            if (p_indexBlobs.size() < 3) return ErrorCode::LackOfInputs;
+
+            if (!m_pSamples.Load((char*)p_indexBlobs[0].Data())) return ErrorCode::FailedParseValue;
+            if (!m_pTrees.LoadTrees((char*)p_indexBlobs[1].Data())) return ErrorCode::FailedParseValue;
+            if (!m_pGraph.LoadGraph((char*)p_indexBlobs[2].Data())) return ErrorCode::FailedParseValue;
+            if (p_indexBlobs.size() > 3 && !m_deletedID.load((char*)p_indexBlobs[3].Data())) return ErrorCode::FailedParseValue;
+
+            m_workSpacePool.reset(new COMMON::WorkSpacePool(m_iMaxCheck, GetNumSamples()));
+            m_workSpacePool->Init(m_iNumberOfThreads);
+            return ErrorCode::Success;
+        }
+
+        template <typename T>
+        ErrorCode Index<T>::LoadIndexData(const std::string& p_folderPath)
+        {
+            if (!m_pSamples.Load(p_folderPath + m_sDataPointsFilename)) return ErrorCode::Fail;
+            if (!m_pTrees.LoadTrees(p_folderPath + m_sKDTFilename)) return ErrorCode::Fail;
+            if (!m_pGraph.LoadGraph(p_folderPath + m_sGraphFilename)) return ErrorCode::Fail;
+            if (!m_deletedID.load(p_folderPath + m_sDeleteDataPointsFilename)) return ErrorCode::Fail;
+
+            m_workSpacePool.reset(new COMMON::WorkSpacePool(m_iMaxCheck, GetNumSamples()));
+            m_workSpacePool->Init(m_iNumberOfThreads);
+            return ErrorCode::Success;
+        }
+
+        template<typename T>
+        ErrorCode Index<T>::SaveConfig(std::ostream& p_configOut) const
+        {
+#define DefineKDTParameter(VarName, VarType, DefaultValue, RepresentStr) \
+    p_configOut << RepresentStr << "=" << GetParameter(RepresentStr) << std::endl;
+
+#include "inc/Core/KDT/ParameterDefinitionList.h"
+#undef DefineKDTParameter
+            p_configOut << std::endl;
+            return ErrorCode::Success;
+        }
+
+        template<typename T>
+        ErrorCode Index<T>::SaveIndexData(const std::string& p_folderPath)
+        {
+            std::lock_guard<std::mutex> lock(m_dataAddLock);
+            std::shared_lock<std::shared_timed_mutex> sharedlock(m_deletedID.getLock());
+
+            if (!m_pSamples.Save(p_folderPath + m_sDataPointsFilename)) return ErrorCode::Fail;
+            if (!m_pTrees.SaveTrees(p_folderPath + m_sKDTFilename)) return ErrorCode::Fail;
+            if (!m_pGraph.SaveGraph(p_folderPath + m_sGraphFilename)) return ErrorCode::Fail;
+            if (!m_deletedID.save(p_folderPath + m_sDeleteDataPointsFilename)) return ErrorCode::Fail;
+            return ErrorCode::Success;
+        }
+
+        template<typename T>
+        ErrorCode Index<T>::SaveIndexData(const std::vector<std::ostream*>& p_indexStreams)
+        {
+            if (p_indexStreams.size() < 4) return ErrorCode::LackOfInputs;
+
+            std::lock_guard<std::mutex> lock(m_dataAddLock);
+            std::shared_lock<std::shared_timed_mutex> sharedlock(m_deletedID.getLock());
+
+            if (!m_pSamples.Save(*p_indexStreams[0])) return ErrorCode::Fail;
+            if (!m_pTrees.SaveTrees(*p_indexStreams[1])) return ErrorCode::Fail;
+            if (!m_pGraph.SaveGraph(*p_indexStreams[2])) return ErrorCode::Fail;
+            if (!m_deletedID.save(*p_indexStreams[3])) return ErrorCode::Fail;
+            return ErrorCode::Success;
+        }
+
+#pragma region K-NN search
+
+#define Search(CheckDeleted1) \
+        m_pTrees.InitSearchTrees(this, p_query, p_space, m_iNumberOfInitialDynamicPivots); \
+        while (!p_space.m_NGQueue.empty()) { \
+            COMMON::HeapCell gnode = p_space.m_NGQueue.pop(); \
+            const SizeType *node = m_pGraph[gnode.node]; \
+            _mm_prefetch((const char *)node, _MM_HINT_T0); \
+            CheckDeleted1 { \
+                if (!p_query.AddPoint(gnode.node, gnode.distance) && p_space.m_iNumberOfCheckedLeaves > p_space.m_iMaxCheck) { \
+                    p_query.SortResult(); return; \
+                } \
+            } \
+            for (DimensionType i = 0; i < m_pGraph.m_iNeighborhoodSize; i++) \
+                _mm_prefetch((const char *)(m_pSamples)[node[i]], _MM_HINT_T0); \
+            float upperBound = max(p_query.worstDist(), gnode.distance); \
+            bool bLocalOpt = true; \
+            for (DimensionType i = 0; i < m_pGraph.m_iNeighborhoodSize; i++) { \
+                SizeType nn_index = node[i]; \
+                if (nn_index < 0) break; \
+                if (p_space.CheckAndSet(nn_index)) continue; \
+                float distance2leaf = m_fComputeDistance(p_query.GetTarget(), (m_pSamples)[nn_index], GetFeatureDim()); \
+                if (distance2leaf <= upperBound) bLocalOpt = false; \
+                p_space.m_iNumberOfCheckedLeaves++; \
+                p_space.m_NGQueue.insert(COMMON::HeapCell(nn_index, distance2leaf)); \
+            } \
+            if (bLocalOpt) p_space.m_iNumOfContinuousNoBetterPropagation++; \
+            else p_space.m_iNumOfContinuousNoBetterPropagation = 0; \
+            if (p_space.m_iNumOfContinuousNoBetterPropagation > m_iThresholdOfNumberOfContinuousNoBetterPropagation) { \
+                if (p_space.m_iNumberOfTreeCheckedLeaves <= p_space.m_iNumberOfCheckedLeaves / 10) { \
+                    m_pTrees.SearchTrees(this, p_query, p_space, m_iNumberOfOtherDynamicPivots + p_space.m_iNumberOfCheckedLeaves); \
+                } else if (gnode.distance > p_query.worstDist()) { \
+                    break; \
+                } \
+            } \
+        } \
+        p_query.SortResult(); \
+
+        template <typename T>
+        void Index<T>::SearchIndexWithDeleted(COMMON::QueryResultSet<T> &p_query, COMMON::WorkSpace &p_space, const Helper::Concurrent::ConcurrentSet<SizeType> &p_deleted) const
+        {
+            Search(if (!p_deleted.contains(gnode.node)))
+        }
+
+        template <typename T>
+        void Index<T>::SearchIndexWithoutDeleted(COMMON::QueryResultSet<T> &p_query, COMMON::WorkSpace &p_space) const
+        {
+            Search(;)
+        }
+
+        template<typename T>
+        ErrorCode
+            Index<T>::SearchIndex(QueryResult &p_query) const
+        {
+            auto workSpace = m_workSpacePool->Rent();
+            workSpace->Reset(m_iMaxCheck);
+
+            if (m_deletedID.size() > 0)
+                SearchIndexWithDeleted(*((COMMON::QueryResultSet<T>*)&p_query), *workSpace, m_deletedID);
+            else
+                SearchIndexWithoutDeleted(*((COMMON::QueryResultSet<T>*)&p_query), *workSpace);
+
+            m_workSpacePool->Return(workSpace);
+
+            if (p_query.WithMeta() && nullptr != m_pMetadata)
+            {
+                for (int i = 0; i < p_query.GetResultNum(); ++i)
+                {
+                    SizeType result = p_query.GetResult(i)->VID;
+                    p_query.SetMetadata(i, (result < 0) ? ByteArray::c_empty : m_pMetadata->GetMetadata(result));
+                }
+            }
+            return ErrorCode::Success;
+        }
+#pragma endregion
+
+        template <typename T>
+        ErrorCode Index<T>::BuildIndex(const void* p_data, SizeType p_vectorNum, DimensionType p_dimension)
+        {
+            omp_set_num_threads(m_iNumberOfThreads);
+
+            m_pSamples.Initialize(p_vectorNum, p_dimension, (T*)p_data, false);
+
+            if (DistCalcMethod::Cosine == m_iDistCalcMethod)
+            {
+                int base = COMMON::Utils::GetBase<T>();
+#pragma omp parallel for
+                for (SizeType i = 0; i < GetNumSamples(); i++) {
+                    COMMON::Utils::Normalize(m_pSamples[i], GetFeatureDim(), base);
+                }
+            }
+
+            m_workSpacePool.reset(new COMMON::WorkSpacePool(m_iMaxCheck, GetNumSamples()));
+            m_workSpacePool->Init(m_iNumberOfThreads);
+
+            m_pTrees.BuildTrees<T>(this);
+            m_pGraph.BuildGraph<T>(this);
+            
+            return ErrorCode::Success;
+        }
+
+        template <typename T>
+        ErrorCode Index<T>::RefineIndex(const std::vector<std::ostream*>& p_indexStreams)
+        {
+            std::lock_guard<std::mutex> lock(m_dataAddLock);
+            std::shared_lock<std::shared_timed_mutex> sharedlock(m_deletedID.getLock());
+
+            SizeType newR = GetNumSamples();
+
+            std::vector<SizeType> indices;
+            std::vector<SizeType> reverseIndices(newR);
+            for (SizeType i = 0; i < newR; i++) {
+                if (!m_deletedID.contains(i)) {
+                    indices.push_back(i);
+                    reverseIndices[i] = i;
+                }
+                else {
+                    while (m_deletedID.contains(newR - 1) && newR > i) newR--;
+                    if (newR == i) break;
+                    indices.push_back(newR - 1);
+                    reverseIndices[newR - 1] = i;
+                    newR--;
+                }
+            }
+
+            std::cout << "Refine... from " << GetNumSamples() << "->" << newR << std::endl;
+
+            if (false == m_pSamples.Refine(indices, *p_indexStreams[0])) return ErrorCode::Fail;
+            if (nullptr != m_pMetadata && (p_indexStreams.size() < 6 || ErrorCode::Success != m_pMetadata->RefineMetadata(indices, *p_indexStreams[4], *p_indexStreams[5]))) return ErrorCode::Fail;
+
+            m_pGraph.RefineGraph<T>(this, indices, reverseIndices, *p_indexStreams[2]);
+
+            COMMON::KDTree newTrees(m_pTrees);
+            newTrees.BuildTrees<T>(this, &indices);
+#pragma omp parallel for
+            for (SizeType i = 0; i < newTrees.size(); i++) {
+                if (newTrees[i].left < 0)
+                    newTrees[i].left = -reverseIndices[-newTrees[i].left - 1] - 1;
+                if (newTrees[i].right < 0)
+                    newTrees[i].right = -reverseIndices[-newTrees[i].right - 1] - 1;
+            }
+            newTrees.SaveTrees(*p_indexStreams[1]);
+
+            Helper::Concurrent::ConcurrentSet<SizeType> newDeletedID;
+            newDeletedID.save(*p_indexStreams[3]);
+            return ErrorCode::Success;
+        }
+
+        template <typename T>
+        ErrorCode Index<T>::RefineIndex(const std::string& p_folderPath)
+        {
+            std::string folderPath(p_folderPath);
+            if (!folderPath.empty() && *(folderPath.rbegin()) != FolderSep)
+            {
+                folderPath += FolderSep;
+            }
+
+            if (!direxists(folderPath.c_str()))
+            {
+                mkdir(folderPath.c_str());
+            }
+
+            std::vector<std::ostream*> streams;
+            streams.push_back(new std::ofstream(folderPath + m_sDataPointsFilename, std::ios::binary));
+            streams.push_back(new std::ofstream(folderPath + m_sKDTFilename, std::ios::binary));
+            streams.push_back(new std::ofstream(folderPath + m_sGraphFilename, std::ios::binary));
+            streams.push_back(new std::ofstream(folderPath + m_sDeleteDataPointsFilename, std::ios::binary));
+            if (nullptr != m_pMetadata)
+            {
+                streams.push_back(new std::ofstream(folderPath + m_sMetadataFile, std::ios::binary));
+                streams.push_back(new std::ofstream(folderPath + m_sMetadataIndexFile, std::ios::binary));
+            }
+
+            for (size_t i = 0; i < streams.size(); i++) 
+                if (!(((std::ofstream*)streams[i])->is_open())) return ErrorCode::FailedCreateFile;
+
+            ErrorCode ret = RefineIndex(streams);
+            
+            for (size_t i = 0; i < streams.size(); i++) 
+            {
+                ((std::ofstream*)streams[i])->close();
+                delete streams[i];
+            }
+            return ret;
+        }
+
+        template <typename T>
+        ErrorCode Index<T>::DeleteIndex(const void* p_vectors, SizeType p_vectorNum) {
+            const T* ptr_v = (const T*)p_vectors;
+#pragma omp parallel for schedule(dynamic)
+            for (SizeType i = 0; i < p_vectorNum; i++) {
+                COMMON::QueryResultSet<T> query(ptr_v + i * GetFeatureDim(), m_pGraph.m_iCEF);
+                SearchIndex(query);
+
+                for (int i = 0; i < m_pGraph.m_iCEF; i++) {
+                    if (query.GetResult(i)->Dist < 1e-6) {
+                        m_deletedID.insert(query.GetResult(i)->VID);
+                    }
+                }
+            }
+            return ErrorCode::Success;
+        }
+
+        template <typename T>
+        ErrorCode Index<T>::DeleteIndex(const SizeType& p_id) {
+            m_deletedID.insert(p_id);
+            return ErrorCode::Success;
+        }
+
+        template <typename T>
+        ErrorCode Index<T>::AddIndex(const void* p_vectors, SizeType p_vectorNum, DimensionType p_dimension, SizeType* p_start)
+        {
+            SizeType begin, end;
+            {
+                std::lock_guard<std::mutex> lock(m_dataAddLock);
+
+                begin = GetNumSamples();
+                end = GetNumSamples() + p_vectorNum;
+
+                if (p_start != nullptr) *p_start = begin;
+
+                if (begin == 0) return BuildIndex(p_vectors, p_vectorNum, p_dimension);
+
+                if (p_dimension != GetFeatureDim()) return ErrorCode::FailedParseValue;
+
+                if (m_pSamples.AddBatch((const T*)p_vectors, p_vectorNum) != ErrorCode::Success || m_pGraph.AddBatch(p_vectorNum) != ErrorCode::Success) {
+                    std::cout << "Memory Error: Cannot alloc space for vectors" << std::endl;
+                    m_pSamples.SetR(begin);
+                    m_pGraph.SetR(begin);
+                    return ErrorCode::MemoryOverFlow;
+                }
+                if (DistCalcMethod::Cosine == m_iDistCalcMethod)
+                {
+                    int base = COMMON::Utils::GetBase<T>();
+                    for (SizeType i = begin; i < end; i++) {
+                        COMMON::Utils::Normalize((T*)m_pSamples[i], GetFeatureDim(), base);
+                    }
+                }
+            }
+
+            for (SizeType node = begin; node < end; node++)
+            {
+                m_pGraph.RefineNode<T>(this, node, true);
+            }
+            std::cout << "Add " << p_vectorNum << " vectors" << std::endl;
+            return ErrorCode::Success;
+        }
+
+        template <typename T>
+        ErrorCode
+            Index<T>::SetParameter(const char* p_param, const char* p_value)
+        {
+            if (nullptr == p_param || nullptr == p_value) return ErrorCode::Fail;
+
+#define DefineKDTParameter(VarName, VarType, DefaultValue, RepresentStr) \
+    else if (SPTAG::Helper::StrUtils::StrEqualIgnoreCase(p_param, RepresentStr)) \
+    { \
+        fprintf(stderr, "Setting %s with value %s\n", RepresentStr, p_value); \
+        VarType tmp; \
+        if (SPTAG::Helper::Convert::ConvertStringTo<VarType>(p_value, tmp)) \
+        { \
+            VarName = tmp; \
+        } \
+    } \
+
+#include "inc/Core/KDT/ParameterDefinitionList.h"
+#undef DefineKDTParameter
+
+            m_fComputeDistance = COMMON::DistanceCalcSelector<T>(m_iDistCalcMethod);
+            return ErrorCode::Success;
+        }
+
+
+        template <typename T>
+        std::string
+            Index<T>::GetParameter(const char* p_param) const
+        {
+            if (nullptr == p_param) return std::string();
+
+#define DefineKDTParameter(VarName, VarType, DefaultValue, RepresentStr) \
+    else if (SPTAG::Helper::StrUtils::StrEqualIgnoreCase(p_param, RepresentStr)) \
+    { \
+        return SPTAG::Helper::Convert::ConvertToString(VarName); \
+    } \
+
+#include "inc/Core/KDT/ParameterDefinitionList.h"
+#undef DefineKDTParameter
+
+            return std::string();
+        }
+    }
+}
+
+#define DefineVectorValueType(Name, Type) \
+template class SPTAG::KDT::Index<Type>; \
+
+#include "inc/Core/DefinitionList.h"
+#undef DefineVectorValueType
+
+
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/src/Core/MetadataSet.cpp b/core/src/index/thirdparty/SPTAG/AnnService/src/Core/MetadataSet.cpp
new file mode 100644
index 0000000000..137eb5d13a
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/src/Core/MetadataSet.cpp
@@ -0,0 +1,280 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Core/MetadataSet.h"
+
+#include <fstream>
+#include <iostream>
+
+using namespace SPTAG;
+
+ErrorCode
+MetadataSet::RefineMetadata(std::vector<SizeType>& indices, std::ostream& p_metaOut, std::ostream& p_metaIndexOut)
+{
+    SizeType R = (SizeType)indices.size();
+    p_metaIndexOut.write((char*)&R, sizeof(SizeType));
+    std::uint64_t offset = 0;
+    for (SizeType i = 0; i < R; i++) {
+        p_metaIndexOut.write((char*)&offset, sizeof(std::uint64_t));
+        ByteArray meta = GetMetadata(indices[i]);
+        p_metaOut.write((char*)meta.Data(), sizeof(uint8_t)*meta.Length());
+        offset += meta.Length();
+    }
+    p_metaIndexOut.write((char*)&offset, sizeof(std::uint64_t));
+    return ErrorCode::Success;
+}
+
+
+ErrorCode 
+MetadataSet::RefineMetadata(std::vector<SizeType>& indices, const std::string& p_metaFile, const std::string& p_metaindexFile)
+{
+    std::ofstream metaOut(p_metaFile + "_tmp", std::ios::binary);
+    std::ofstream metaIndexOut(p_metaindexFile, std::ios::binary);
+    if (!metaOut.is_open() || !metaIndexOut.is_open()) return ErrorCode::FailedCreateFile;
+
+    RefineMetadata(indices, metaOut, metaIndexOut);
+    metaOut.close();
+    metaIndexOut.close();
+
+    if (fileexists(p_metaFile.c_str())) std::remove(p_metaFile.c_str());
+    std::rename((p_metaFile + "_tmp").c_str(), p_metaFile.c_str());
+    return ErrorCode::Success;
+}
+
+
+MetadataSet::MetadataSet()
+{
+}
+
+
+MetadataSet:: ~MetadataSet()
+{
+}
+
+
+FileMetadataSet::FileMetadataSet(const std::string& p_metafile, const std::string& p_metaindexfile)
+    : m_metaFile(p_metafile),
+      m_metaindexFile(p_metaindexfile)
+{
+    m_fp = new std::ifstream(p_metafile, std::ifstream::binary);
+    std::ifstream fpidx(p_metaindexfile, std::ifstream::binary);
+    if (!m_fp->is_open() || !fpidx.is_open())
+    {
+        std::cerr << "ERROR: Cannot open meta files " << p_metafile << " and " << p_metaindexfile << "!" << std::endl;
+        return;
+    }
+
+    fpidx.read((char *)&m_count, sizeof(m_count));
+    m_pOffsets.resize(m_count + 1);
+    fpidx.read((char *)m_pOffsets.data(), sizeof(std::uint64_t) * (m_count + 1));
+    fpidx.close();
+}
+
+
+FileMetadataSet::~FileMetadataSet()
+{
+    if (m_fp)
+    {
+        m_fp->close();
+        delete m_fp;
+    }
+}
+
+
+ByteArray
+FileMetadataSet::GetMetadata(SizeType p_vectorID) const
+{
+    std::uint64_t startoff = m_pOffsets[p_vectorID];
+    std::uint64_t bytes = m_pOffsets[p_vectorID + 1] - startoff;
+    if (p_vectorID < m_count) {
+        m_fp->seekg(startoff, std::ios_base::beg);
+        ByteArray b = ByteArray::Alloc(bytes);
+        m_fp->read((char*)b.Data(), bytes);
+        return b;
+    }
+    else {
+        startoff -= m_pOffsets[m_count];
+        return ByteArray((std::uint8_t*)m_newdata.data() + startoff, bytes, false);
+    }
+}
+
+
+SizeType
+FileMetadataSet::Count() const
+{
+    return static_cast<SizeType>(m_pOffsets.size() - 1);
+}
+
+
+bool
+FileMetadataSet::Available() const
+{
+    return m_fp && m_fp->is_open() && m_pOffsets.size() > 1;
+}
+
+
+std::pair<std::uint64_t, std::uint64_t> 
+FileMetadataSet::BufferSize() const
+{
+    return std::make_pair(m_pOffsets[m_pOffsets.size() - 1], 
+        sizeof(SizeType) + sizeof(std::uint64_t) * m_pOffsets.size());
+}
+
+
+void
+FileMetadataSet::AddBatch(MetadataSet& data)
+{
+    for (SizeType i = 0; i < data.Count(); i++) 
+    {
+        ByteArray newdata = data.GetMetadata(i);
+        m_newdata.insert(m_newdata.end(), newdata.Data(), newdata.Data() + newdata.Length());
+        m_pOffsets.push_back(m_pOffsets[m_pOffsets.size() - 1] + newdata.Length());
+    }
+}
+
+
+
+ErrorCode
+FileMetadataSet::SaveMetadata(std::ostream& p_metaOut, std::ostream& p_metaIndexOut)
+{
+    m_fp->seekg(0, std::ios_base::beg);
+
+    int bufsize = 1000000;
+    char* buf = new char[bufsize];
+    while (!m_fp->eof()) {
+        m_fp->read(buf, bufsize);
+        p_metaOut.write(buf, m_fp->gcount());
+    }
+    delete[] buf;
+    
+    if (m_newdata.size() > 0) {
+        p_metaOut.write((char*)m_newdata.data(), m_newdata.size());
+    }
+
+    SizeType count = Count();
+    p_metaIndexOut.write((char*)&count, sizeof(SizeType));
+    p_metaIndexOut.write((char*)m_pOffsets.data(), sizeof(std::uint64_t) * m_pOffsets.size());
+    return ErrorCode::Success;
+}
+
+
+ErrorCode
+FileMetadataSet::SaveMetadata(const std::string& p_metaFile, const std::string& p_metaindexFile)
+{
+    std::ofstream metaOut(p_metaFile + "_tmp", std::ios::binary);
+    std::ofstream metaIndexOut(p_metaindexFile, std::ios::binary);
+    if (!metaOut.is_open() || !metaIndexOut.is_open()) return ErrorCode::FailedCreateFile;
+
+    SaveMetadata(metaOut, metaIndexOut);
+    metaOut.close();
+    metaIndexOut.close();
+
+    m_fp->close();
+    if (fileexists(p_metaFile.c_str())) std::remove(p_metaFile.c_str());
+    std::rename((p_metaFile + "_tmp").c_str(), p_metaFile.c_str());
+    m_fp->open(p_metaFile, std::ifstream::binary);
+    m_count = Count();
+    m_newdata.clear();
+    return ErrorCode::Success;
+}
+
+
+MemMetadataSet::MemMetadataSet(ByteArray p_metadata, ByteArray p_offsets, SizeType p_count)
+    : m_metadataHolder(std::move(p_metadata)),
+      m_offsetHolder(std::move(p_offsets)),
+      m_count(p_count)
+{
+    const std::uint64_t* newdata = reinterpret_cast<const std::uint64_t*>(m_offsetHolder.Data());
+    m_offsets.insert(m_offsets.end(), newdata, newdata + p_count + 1);
+}
+
+
+MemMetadataSet::~MemMetadataSet()
+{
+}
+
+
+ByteArray
+MemMetadataSet::GetMetadata(SizeType p_vectorID) const
+{
+    if (p_vectorID < m_count)
+    {
+        return ByteArray(m_metadataHolder.Data() + m_offsets[p_vectorID],
+                         m_offsets[p_vectorID + 1] - m_offsets[p_vectorID],
+                         false);
+    }
+    else if (p_vectorID < (SizeType)(m_offsets.size() - 1)) {
+        return ByteArray((std::uint8_t*)m_newdata.data() + m_offsets[p_vectorID] - m_offsets[m_count],
+            m_offsets[p_vectorID + 1] - m_offsets[p_vectorID],
+            false);
+    }
+
+    return ByteArray::c_empty;
+}
+
+
+SizeType
+MemMetadataSet::Count() const
+{
+    return static_cast<SizeType>(m_offsets.size() - 1);
+}
+
+
+bool
+MemMetadataSet::Available() const
+{
+    return m_metadataHolder.Length() > 0 && m_offsetHolder.Length() > 0;
+}
+
+
+std::pair<std::uint64_t, std::uint64_t>
+MemMetadataSet::BufferSize() const
+{
+    return std::make_pair(m_offsets[m_offsets.size() - 1],
+        sizeof(SizeType) + sizeof(std::uint64_t) * m_offsets.size());
+}
+
+void
+MemMetadataSet::AddBatch(MetadataSet& data)
+{
+    for (SizeType i = 0; i < data.Count(); i++)
+    {
+        ByteArray newdata = data.GetMetadata(i);
+        m_newdata.insert(m_newdata.end(), newdata.Data(), newdata.Data() + newdata.Length());
+        m_offsets.push_back(m_offsets[m_offsets.size() - 1] + newdata.Length());
+    }
+}
+
+
+ErrorCode
+MemMetadataSet::SaveMetadata(std::ostream& p_metaOut, std::ostream& p_metaIndexOut)
+{
+    p_metaOut.write(reinterpret_cast<const char*>(m_metadataHolder.Data()), m_metadataHolder.Length());
+    if (m_newdata.size() > 0) {
+        p_metaOut.write((char*)m_newdata.data(), m_newdata.size());
+    }
+
+    SizeType count = Count();
+    p_metaIndexOut.write((char*)&count, sizeof(SizeType));
+    p_metaIndexOut.write((char*)m_offsets.data(), sizeof(std::uint64_t) * m_offsets.size());
+    return ErrorCode::Success;
+}
+
+
+
+ErrorCode
+MemMetadataSet::SaveMetadata(const std::string& p_metaFile, const std::string& p_metaindexFile)
+{
+    std::ofstream metaOut(p_metaFile + "_tmp", std::ios::binary);
+    std::ofstream metaIndexOut(p_metaindexFile, std::ios::binary);
+    if (!metaOut.is_open() || !metaIndexOut.is_open()) return ErrorCode::FailedCreateFile;
+
+    SaveMetadata(metaOut, metaIndexOut);
+    metaOut.close();
+    metaIndexOut.close();
+
+    if (fileexists(p_metaFile.c_str())) std::remove(p_metaFile.c_str());
+    std::rename((p_metaFile + "_tmp").c_str(), p_metaFile.c_str());
+    return ErrorCode::Success;
+}
+
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/src/Core/VectorIndex.cpp b/core/src/index/thirdparty/SPTAG/AnnService/src/Core/VectorIndex.cpp
new file mode 100644
index 0000000000..9c7ccf5492
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/src/Core/VectorIndex.cpp
@@ -0,0 +1,428 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Core/VectorIndex.h"
+#include "inc/Core/Common/DataUtils.h"
+#include "inc/Helper/CommonHelper.h"
+#include "inc/Helper/StringConvert.h"
+#include "inc/Helper/SimpleIniReader.h"
+#include "inc/Helper/BufferStream.h"
+
+#include "inc/Core/BKT/Index.h"
+#include "inc/Core/KDT/Index.h"
+#include <fstream>
+
+
+using namespace SPTAG;
+
+
+VectorIndex::VectorIndex()
+{
+}
+
+
+VectorIndex::~VectorIndex()
+{
+}
+
+
+std::string 
+VectorIndex::GetParameter(const std::string& p_param) const
+{
+    return GetParameter(p_param.c_str());
+}
+
+
+ErrorCode
+VectorIndex::SetParameter(const std::string& p_param, const std::string& p_value)
+{
+    return SetParameter(p_param.c_str(), p_value.c_str());
+}
+
+
+void 
+VectorIndex::SetMetadata(const std::string& p_metadataFilePath, const std::string& p_metadataIndexPath) {
+    m_pMetadata.reset(new FileMetadataSet(p_metadataFilePath, p_metadataIndexPath));
+}
+
+
+ByteArray 
+VectorIndex::GetMetadata(SizeType p_vectorID) const {
+    if (nullptr != m_pMetadata)
+    {
+        return m_pMetadata->GetMetadata(p_vectorID);
+    }
+    return ByteArray::c_empty;
+}
+
+
+std::shared_ptr<std::vector<std::uint64_t>> VectorIndex::CalculateBufferSize() const
+{
+    std::shared_ptr<std::vector<std::uint64_t>> ret = BufferSize();
+    if (m_pMetadata != nullptr)
+    {
+        auto metasize = m_pMetadata->BufferSize();
+        ret->push_back(metasize.first);
+        ret->push_back(metasize.second);
+    }
+    return std::move(ret);
+}
+
+
+ErrorCode
+VectorIndex::LoadIndexConfig(Helper::IniReader& p_reader)
+{
+    std::string metadataSection("MetaData");
+    if (p_reader.DoesSectionExist(metadataSection))
+    {
+        m_sMetadataFile = p_reader.GetParameter(metadataSection, "MetaDataFilePath", std::string());
+        m_sMetadataIndexFile = p_reader.GetParameter(metadataSection, "MetaDataIndexPath", std::string());
+    }
+
+    if (DistCalcMethod::Undefined == p_reader.GetParameter("Index", "DistCalcMethod", DistCalcMethod::Undefined))
+    {
+        std::cerr << "Error: Failed to load parameter DistCalcMethod." << std::endl;
+        return ErrorCode::Fail;
+    }
+    return LoadConfig(p_reader);
+}
+
+
+ErrorCode
+VectorIndex::SaveIndexConfig(std::ostream& p_configOut)
+{
+    if (nullptr != m_pMetadata)
+    {
+        p_configOut << "[MetaData]" << std::endl;
+        p_configOut << "MetaDataFilePath=" << m_sMetadataFile << std::endl;
+        p_configOut << "MetaDataIndexPath=" << m_sMetadataIndexFile << std::endl;
+        if (nullptr != m_pMetaToVec) p_configOut << "MetaDataToVectorIndex=true" << std::endl;
+        p_configOut << std::endl;
+    }
+
+    p_configOut << "[Index]" << std::endl;
+    p_configOut << "IndexAlgoType=" << Helper::Convert::ConvertToString(GetIndexAlgoType()) << std::endl;
+    p_configOut << "ValueType=" << Helper::Convert::ConvertToString(GetVectorValueType()) << std::endl;
+    p_configOut << std::endl;
+
+    return SaveConfig(p_configOut);
+}
+
+
+void
+VectorIndex::BuildMetaMapping()
+{
+    m_pMetaToVec.reset(new std::unordered_map<std::string, SizeType>);
+    for (SizeType i = 0; i < m_pMetadata->Count(); i++) {
+        ByteArray meta = m_pMetadata->GetMetadata(i);
+        m_pMetaToVec->emplace(std::string((char*)meta.Data(), meta.Length()), i);
+    }
+}
+
+
+ErrorCode 
+VectorIndex::LoadIndex(const std::string& p_config, const std::vector<ByteArray>& p_indexBlobs)
+{
+    SPTAG::Helper::IniReader p_reader;
+    std::istringstream p_configin(p_config);
+    if (SPTAG::ErrorCode::Success != p_reader.LoadIni(p_configin)) return ErrorCode::FailedParseValue;
+    LoadIndexConfig(p_reader);
+    
+    if (p_reader.DoesSectionExist("MetaData") && p_indexBlobs.size() > 4)
+    {
+        ByteArray pMetaIndex = p_indexBlobs[p_indexBlobs.size() - 1];
+        m_pMetadata.reset(new MemMetadataSet(p_indexBlobs[p_indexBlobs.size() - 2],
+            ByteArray(pMetaIndex.Data() + sizeof(SizeType), pMetaIndex.Length() - sizeof(SizeType), false),
+            *((SizeType*)pMetaIndex.Data())));
+
+        if (!m_pMetadata->Available())
+        {
+            std::cerr << "Error: Failed to load metadata." << std::endl;
+            return ErrorCode::Fail;
+        }
+
+        if (p_reader.GetParameter("MetaData", "MetaDataToVectorIndex", std::string()) == "true")
+        {
+            BuildMetaMapping();
+        }
+    }
+    return LoadIndexDataFromMemory(p_indexBlobs);
+}
+
+
+ErrorCode 
+VectorIndex::LoadIndex(const std::string& p_folderPath)
+{
+    std::string folderPath(p_folderPath);
+    if (!folderPath.empty() && *(folderPath.rbegin()) != FolderSep)
+    {
+        folderPath += FolderSep;
+    }
+
+    Helper::IniReader p_configReader;
+    if (ErrorCode::Success != p_configReader.LoadIniFile(folderPath + "/indexloader.ini")) return ErrorCode::FailedOpenFile;
+    LoadIndexConfig(p_configReader);
+    
+    if (p_configReader.DoesSectionExist("MetaData"))
+    {
+        m_pMetadata.reset(new FileMetadataSet(folderPath + m_sMetadataFile, folderPath + m_sMetadataIndexFile));
+
+        if (!m_pMetadata->Available())
+        {
+            std::cerr << "Error: Failed to load metadata." << std::endl;
+            return ErrorCode::Fail;
+        }
+
+        if (p_configReader.GetParameter("MetaData", "MetaDataToVectorIndex", std::string()) == "true")
+        {
+            BuildMetaMapping();
+        }
+    }
+    return LoadIndexData(folderPath);
+}
+
+
+ErrorCode
+VectorIndex::SaveIndex(std::string& p_config, const std::vector<ByteArray>& p_indexBlobs)
+{
+    std::ostringstream p_configStream;
+    SaveIndexConfig(p_configStream);
+    p_config = p_configStream.str();
+    
+    std::vector<std::ostream*> p_indexStreams;
+    for (size_t i = 0; i < p_indexBlobs.size(); i++)
+    {
+        p_indexStreams.push_back(new Helper::obufferstream(new Helper::streambuf((char*)p_indexBlobs[i].Data(), p_indexBlobs[i].Length()), true));
+    }
+
+    ErrorCode ret = ErrorCode::Success;
+    if (NeedRefine()) 
+    {
+        ret = RefineIndex(p_indexStreams);
+    }
+    else 
+    {
+        if (m_pMetadata != nullptr && p_indexStreams.size() > 5)
+        {
+            ret = m_pMetadata->SaveMetadata(*p_indexStreams[p_indexStreams.size() - 2], *p_indexStreams[p_indexStreams.size() - 1]);
+        }
+        if (ErrorCode::Success == ret) ret = SaveIndexData(p_indexStreams);
+    }
+    for (size_t i = 0; i < p_indexStreams.size(); i++)
+    {
+        delete p_indexStreams[i];
+    }
+    return ret;
+}
+
+
+ErrorCode
+VectorIndex::SaveIndex(const std::string& p_folderPath)
+{
+    std::string folderPath(p_folderPath);
+    if (!folderPath.empty() && *(folderPath.rbegin()) != FolderSep)
+    {
+        folderPath += FolderSep;
+    }
+
+    if (!direxists(folderPath.c_str()))
+    {
+        mkdir(folderPath.c_str());
+    }
+
+    std::ofstream configFile(folderPath + "indexloader.ini");
+    if (!configFile.is_open()) return ErrorCode::FailedCreateFile;
+    SaveIndexConfig(configFile);
+    configFile.close();
+    
+    if (NeedRefine()) return RefineIndex(p_folderPath);
+
+    if (m_pMetadata != nullptr)
+    {
+        ErrorCode ret = m_pMetadata->SaveMetadata(folderPath + m_sMetadataFile, folderPath + m_sMetadataIndexFile);
+        if (ErrorCode::Success != ret) return ret;
+    }
+    return SaveIndexData(folderPath);
+}
+
+ErrorCode
+VectorIndex::BuildIndex(std::shared_ptr<VectorSet> p_vectorSet,
+    std::shared_ptr<MetadataSet> p_metadataSet, bool p_withMetaIndex)
+{
+    if (nullptr == p_vectorSet || p_vectorSet->Count() == 0 || p_vectorSet->Dimension() == 0 || p_vectorSet->GetValueType() != GetVectorValueType())
+    {
+        return ErrorCode::Fail;
+    }
+
+    BuildIndex(p_vectorSet->GetData(), p_vectorSet->Count(), p_vectorSet->Dimension());
+    m_pMetadata = std::move(p_metadataSet);
+    if (p_withMetaIndex && m_pMetadata != nullptr) 
+    {
+        BuildMetaMapping();
+    }
+    return ErrorCode::Success;
+}
+
+
+ErrorCode
+VectorIndex::SearchIndex(const void* p_vector, int p_neighborCount, bool p_withMeta, BasicResult* p_results) const {
+    QueryResult res(p_vector, p_neighborCount, p_withMeta, p_results);
+    SearchIndex(res);
+    return ErrorCode::Success;
+}
+
+
+ErrorCode 
+VectorIndex::AddIndex(std::shared_ptr<VectorSet> p_vectorSet, std::shared_ptr<MetadataSet> p_metadataSet) {
+    if (nullptr == p_vectorSet || p_vectorSet->Count() == 0 || p_vectorSet->Dimension() == 0 || p_vectorSet->GetValueType() != GetVectorValueType())
+    {
+        return ErrorCode::Fail;
+    }
+
+    SizeType currStart;
+    ErrorCode ret = AddIndex(p_vectorSet->GetData(), p_vectorSet->Count(), p_vectorSet->Dimension(), &currStart);
+    if (ret != ErrorCode::Success) return ret;
+
+    if (m_pMetadata == nullptr) {
+        if (currStart == 0)
+            m_pMetadata = std::move(p_metadataSet);
+        else
+            return ErrorCode::Success;
+    }
+    else {
+        m_pMetadata->AddBatch(*p_metadataSet);
+    }
+    
+    if (m_pMetaToVec != nullptr) {
+        for (SizeType i = 0; i < p_vectorSet->Count(); i++) {
+            ByteArray meta = m_pMetadata->GetMetadata(currStart + i);
+            DeleteIndex(meta);
+            m_pMetaToVec->emplace(std::string((char*)meta.Data(), meta.Length()), currStart + i);
+        }
+    }
+    return ErrorCode::Success;
+}
+
+
+ErrorCode
+VectorIndex::DeleteIndex(ByteArray p_meta) {
+    if (m_pMetaToVec == nullptr) return ErrorCode::Fail;
+
+    std::string meta((char*)p_meta.Data(), p_meta.Length());
+    auto iter = m_pMetaToVec->find(meta);
+    if (iter != m_pMetaToVec->end()) DeleteIndex(iter->second);
+    return ErrorCode::Success;
+}
+
+
+const void* VectorIndex::GetSample(ByteArray p_meta)
+{
+    if (m_pMetaToVec == nullptr) return nullptr;
+
+    std::string meta((char*)p_meta.Data(), p_meta.Length());
+    auto iter = m_pMetaToVec->find(meta);
+    if (iter != m_pMetaToVec->end()) return GetSample(iter->second);
+    return nullptr;
+}
+
+
+std::shared_ptr<VectorIndex>
+VectorIndex::CreateInstance(IndexAlgoType p_algo, VectorValueType p_valuetype)
+{
+    if (IndexAlgoType::Undefined == p_algo || VectorValueType::Undefined == p_valuetype)
+    {
+        return nullptr;
+    }
+
+    if (p_algo == IndexAlgoType::BKT) {
+        switch (p_valuetype)
+        {
+#define DefineVectorValueType(Name, Type) \
+    case VectorValueType::Name: \
+        return std::shared_ptr<VectorIndex>(new BKT::Index<Type>); \
+
+#include "inc/Core/DefinitionList.h"
+#undef DefineVectorValueType
+
+        default: break;
+        }
+    }
+    else if (p_algo == IndexAlgoType::KDT) {
+        switch (p_valuetype)
+        {
+#define DefineVectorValueType(Name, Type) \
+    case VectorValueType::Name: \
+        return std::shared_ptr<VectorIndex>(new KDT::Index<Type>); \
+
+#include "inc/Core/DefinitionList.h"
+#undef DefineVectorValueType
+
+        default: break;
+        }
+    }
+    return nullptr;
+}
+
+
+ErrorCode
+VectorIndex::LoadIndex(const std::string& p_loaderFilePath, std::shared_ptr<VectorIndex>& p_vectorIndex)
+{
+    Helper::IniReader iniReader;
+    if (ErrorCode::Success != iniReader.LoadIniFile(p_loaderFilePath + "/indexloader.ini")) return ErrorCode::FailedOpenFile;
+
+    IndexAlgoType algoType = iniReader.GetParameter("Index", "IndexAlgoType", IndexAlgoType::Undefined);
+    VectorValueType valueType = iniReader.GetParameter("Index", "ValueType", VectorValueType::Undefined);
+
+    p_vectorIndex = CreateInstance(algoType, valueType);
+    if (p_vectorIndex == nullptr) return ErrorCode::FailedParseValue;
+
+    return p_vectorIndex->LoadIndex(p_loaderFilePath);
+}
+
+
+
+ErrorCode
+VectorIndex::LoadIndex(const std::string& p_config, const std::vector<ByteArray>& p_indexBlobs, std::shared_ptr<VectorIndex>& p_vectorIndex)
+{
+    SPTAG::Helper::IniReader iniReader;
+    std::istringstream p_configin(p_config);
+    if (SPTAG::ErrorCode::Success != iniReader.LoadIni(p_configin)) return ErrorCode::FailedParseValue;
+
+    IndexAlgoType algoType = iniReader.GetParameter("Index", "IndexAlgoType", IndexAlgoType::Undefined);
+    VectorValueType valueType = iniReader.GetParameter("Index", "ValueType", VectorValueType::Undefined);
+
+    p_vectorIndex = CreateInstance(algoType, valueType);
+    if (p_vectorIndex == nullptr) return ErrorCode::FailedParseValue;
+
+    return p_vectorIndex->LoadIndex(p_config, p_indexBlobs);
+}
+
+
+ErrorCode
+VectorIndex::MergeIndex(const char* p_indexFilePath1, const char* p_indexFilePath2)
+{
+    std::string folderPath1(p_indexFilePath1), folderPath2(p_indexFilePath2);
+
+    std::shared_ptr<VectorIndex> index1, index2;
+    LoadIndex(folderPath1, index1);
+    LoadIndex(folderPath2, index2);
+
+    std::shared_ptr<VectorSet> p_vectorSet;
+    std::shared_ptr<MetadataSet> p_metaSet;
+    size_t vectorSize = GetValueTypeSize(index2->GetVectorValueType()) * index2->GetFeatureDim();
+    std::uint64_t offsets[2] = { 0 };
+    ByteArray metaoffset((std::uint8_t*)offsets, 2 * sizeof(std::uint64_t), false);
+    for (SizeType i = 0; i < index2->GetNumSamples(); i++)
+        if (index2->ContainSample(i))
+        {
+            p_vectorSet.reset(new BasicVectorSet(ByteArray((std::uint8_t*)index2->GetSample(i), vectorSize, false),
+                index2->GetVectorValueType(), index2->GetFeatureDim(), 1));
+            ByteArray meta = index2->GetMetadata(i);
+            offsets[1] = meta.Length();
+            p_metaSet.reset(new MemMetadataSet(meta, metaoffset, 1));
+            index1->AddIndex(p_vectorSet, p_metaSet);
+        }
+
+    index1->SaveIndex(folderPath1);
+    return ErrorCode::Success;
+}
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/src/Core/VectorSet.cpp b/core/src/index/thirdparty/SPTAG/AnnService/src/Core/VectorSet.cpp
new file mode 100644
index 0000000000..45dd74dd78
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/src/Core/VectorSet.cpp
@@ -0,0 +1,96 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Core/VectorSet.h"
+
+using namespace SPTAG;
+
+#pragma warning(disable:4996)  // 'fopen': This function or variable may be unsafe. Consider using fopen_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details.
+
+VectorSet::VectorSet()
+{
+}
+
+
+VectorSet::~VectorSet()
+{
+}
+
+
+BasicVectorSet::BasicVectorSet(const ByteArray& p_bytesArray,
+                               VectorValueType p_valueType,
+                               DimensionType p_dimension,
+                               SizeType p_vectorCount)
+    : m_data(p_bytesArray),
+      m_valueType(p_valueType),
+      m_dimension(p_dimension),
+      m_vectorCount(p_vectorCount),
+      m_perVectorDataSize(static_cast<SizeType>(p_dimension * GetValueTypeSize(p_valueType)))
+{
+}
+
+
+BasicVectorSet::~BasicVectorSet()
+{
+}
+
+
+VectorValueType
+BasicVectorSet::GetValueType() const
+{
+    return m_valueType;
+}
+
+
+void*
+BasicVectorSet::GetVector(SizeType p_vectorID) const
+{
+    if (p_vectorID < 0 || p_vectorID >= m_vectorCount)
+    {
+        return nullptr;
+    }
+
+    return reinterpret_cast<void*>(m_data.Data() + ((size_t)p_vectorID) * m_perVectorDataSize);
+}
+
+
+void*
+BasicVectorSet::GetData() const
+{
+    return reinterpret_cast<void*>(m_data.Data());
+}
+
+DimensionType
+BasicVectorSet::Dimension() const
+{
+    return m_dimension;
+}
+
+
+SizeType
+BasicVectorSet::Count() const
+{
+    return m_vectorCount;
+}
+
+
+bool
+BasicVectorSet::Available() const
+{
+    return m_data.Data() != nullptr;
+}
+
+
+ErrorCode 
+BasicVectorSet::Save(const std::string& p_vectorFile) const
+{
+    FILE * fp = fopen(p_vectorFile.c_str(), "wb");
+    if (fp == NULL) return ErrorCode::FailedOpenFile;
+
+    fwrite(&m_vectorCount, sizeof(SizeType), 1, fp);
+    fwrite(&m_dimension, sizeof(DimensionType), 1, fp);
+
+    fwrite((const void*)(m_data.Data()), m_data.Length(), 1, fp);
+    fclose(fp);
+    return ErrorCode::Success;
+}
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/src/Helper/ArgumentsParser.cpp b/core/src/index/thirdparty/SPTAG/AnnService/src/Helper/ArgumentsParser.cpp
new file mode 100644
index 0000000000..4f630ec01c
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/src/Helper/ArgumentsParser.cpp
@@ -0,0 +1,86 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Helper/ArgumentsParser.h"
+
+using namespace SPTAG::Helper;
+
+
+ArgumentsParser::IArgument::IArgument()
+{
+}
+
+
+ArgumentsParser::IArgument::~IArgument()
+{
+}
+
+
+ArgumentsParser::ArgumentsParser()
+{
+}
+
+
+ArgumentsParser::~ArgumentsParser()
+{
+}
+
+
+bool
+ArgumentsParser::Parse(int p_argc, char** p_args)
+{
+    while (p_argc > 0)
+    {
+        int last = p_argc;
+        for (auto& option : m_arguments)
+        {
+            if (!option->ParseValue(p_argc, p_args))
+            {
+                fprintf(stderr, "Failed to parse args around \"%s\"\n", *p_args);
+                PrintHelp();
+                return false;
+            }
+        }
+
+        if (last == p_argc)
+        {
+            p_argc -= 1;
+            p_args += 1;
+        }
+    }
+
+    bool isValid = true;
+    for (auto& option : m_arguments)
+    {
+        if (option->IsRequiredButNotSet())
+        {
+            fprintf(stderr, "Required option not set:\n  ");
+            option->PrintDescription(stderr);
+            fprintf(stderr, "\n");
+            isValid = false;
+        }
+    }
+
+    if (!isValid)
+    {
+        fprintf(stderr, "\n");
+        PrintHelp();
+        return false;
+    }
+
+    return true;
+}
+
+
+void
+ArgumentsParser::PrintHelp()
+{
+    fprintf(stderr, "Usage: ");
+    for (auto& option : m_arguments)
+    {
+        fprintf(stderr, "\n  ");
+        option->PrintDescription(stderr);
+    }
+
+    fprintf(stderr, "\n\n");
+}
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/src/Helper/Base64Encode.cpp b/core/src/index/thirdparty/SPTAG/AnnService/src/Helper/Base64Encode.cpp
new file mode 100644
index 0000000000..5992fa5a31
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/src/Helper/Base64Encode.cpp
@@ -0,0 +1,240 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Helper/Base64Encode.h"
+
+using namespace SPTAG;
+using namespace SPTAG::Helper;
+
+namespace
+{
+namespace Local
+{
+const char c_encTable[] =
+{
+    'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z',
+    'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z',
+    '0','1','2','3','4','5','6','7','8','9','+','/'
+};
+
+
+const std::uint8_t c_decTable[] =
+{
+    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, // 0x00 - 0x0f
+    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, // 0x10 - 0x1f
+    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 62, 64, 64, 64, 63, // 0x20 - 0x2f
+    52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 64, 64, 64, 64, 64, 64, // 0x30 - 0x3f
+    64,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, // 0x40 - 0x4f
+    15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 64, 64, 64, 64, 64, // 0x50 - 0x5f
+    64, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, // 0x60 - 0x6f
+    41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 64, 64, 64, 64, 64, // 0x70 - 0x7f
+    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, // 0x80 - 0x8f
+    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, // 0x90 - 0x9f
+    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, // 0xa0 - 0xaf
+    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, // 0xb0 - 0xbf
+    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, // 0xc0 - 0xcf
+    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, // 0xd0 - 0xdf
+    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, // 0xe0 - 0xef
+    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, // 0xf0 - 0xff
+};
+
+
+const char c_paddingChar = '=';
+}
+}
+
+
+bool
+Base64::Encode(const std::uint8_t* p_in, std::size_t p_inLen, char* p_out, std::size_t& p_outLen)
+{
+    using namespace Local;
+
+    p_outLen = 0;
+    while (p_inLen >= 3)
+    {
+        p_out[0] = c_encTable[p_in[0] >> 2];
+        p_out[1] = c_encTable[((p_in[0] & 0x03) << 4) | ((p_in[1] & 0xf0) >> 4)];
+        p_out[2] = c_encTable[((p_in[1] & 0x0f) << 2) | ((p_in[2] & 0xc0) >> 6)];
+        p_out[3] = c_encTable[p_in[2] & 0x3f];
+
+        p_in += 3;
+        p_inLen -= 3;
+        p_out += 4;
+        p_outLen += 4;
+    }
+
+    switch (p_inLen)
+    {
+    case 1:
+        p_out[0] = c_encTable[p_in[0] >> 2];
+        p_out[1] = c_encTable[(p_in[0] & 0x03) << 4];
+        p_out[2] = c_paddingChar;
+        p_out[3] = c_paddingChar;
+
+        p_outLen += 4;
+        break;
+
+    case 2:
+        p_out[0] = c_encTable[p_in[0] >> 2];
+        p_out[1] = c_encTable[((p_in[0] & 0x03) << 4) | ((p_in[1] & 0xf0) >> 4)];
+        p_out[2] = c_encTable[(p_in[1] & 0x0f) << 2];
+        p_out[3] = c_paddingChar;
+
+        p_outLen += 4;
+        break;
+    }
+
+    return true;
+}
+
+
+bool
+Base64::Encode(const std::uint8_t* p_in, std::size_t p_inLen, std::ostream& p_out, std::size_t& p_outLen)
+{
+        using namespace Local;
+
+    p_outLen = 0;
+    while (p_inLen >= 3)
+    {
+        p_out << c_encTable[p_in[0] >> 2];
+        p_out << c_encTable[((p_in[0] & 0x03) << 4) | ((p_in[1] & 0xf0) >> 4)];
+        p_out << c_encTable[((p_in[1] & 0x0f) << 2) | ((p_in[2] & 0xc0) >> 6)];
+        p_out << c_encTable[p_in[2] & 0x3f];
+
+        p_in += 3;
+        p_inLen -= 3;
+        p_outLen += 4;
+    }
+
+    switch (p_inLen)
+    {
+    case 1:
+        p_out << c_encTable[p_in[0] >> 2];
+        p_out << c_encTable[(p_in[0] & 0x03) << 4];
+        p_out << c_paddingChar;
+        p_out << c_paddingChar;
+
+        p_outLen += 4;
+        break;
+
+    case 2:
+        p_out << c_encTable[p_in[0] >> 2];
+        p_out << c_encTable[((p_in[0] & 0x03) << 4) | ((p_in[1] & 0xf0) >> 4)];
+        p_out << c_encTable[(p_in[1] & 0x0f) << 2];
+        p_out << c_paddingChar;
+
+        p_outLen += 4;
+        break;
+
+    default:
+        break;
+    }
+
+    return true;
+}
+
+
+bool
+Base64::Decode(const char* p_in, std::size_t p_inLen, std::uint8_t* p_out, std::size_t& p_outLen)
+{
+    using namespace Local;
+
+    // Should always be padding.
+    if ((p_inLen & 0x03) != 0)
+    {
+        return false;
+    }
+
+    std::uint8_t u0 = 0;
+    std::uint8_t u1 = 0;
+    std::uint8_t u2 = 0;
+    std::uint8_t u3 = 0;
+
+    p_outLen = 0;
+    while (p_inLen > 4)
+    {
+        u0 = c_decTable[static_cast<std::size_t>(p_in[0])];
+        u1 = c_decTable[static_cast<std::size_t>(p_in[1])];
+        u2 = c_decTable[static_cast<std::size_t>(p_in[2])];
+        u3 = c_decTable[static_cast<std::size_t>(p_in[3])];
+
+        if (u0 > 63 || u1 > 63 || u2 > 63 || u3 > 63)
+        {
+            return false;
+        }
+
+        p_out[0] = (u0 << 2) | (u1 >> 4);
+        p_out[1] = (u1 << 4) | (u2 >> 2);
+        p_out[2] = (u2 << 6) | u3;
+
+        p_inLen -= 4;
+        p_in += 4;
+        p_out += 3;
+        p_outLen += 3;
+    }
+
+    u0 = c_decTable[static_cast<std::size_t>(p_in[0])];
+    u1 = c_decTable[static_cast<std::size_t>(p_in[1])];
+    u2 = c_decTable[static_cast<std::size_t>(p_in[2])];
+    u3 = c_decTable[static_cast<std::size_t>(p_in[3])];
+
+    if (u0 > 63 || u1 > 63 || (c_paddingChar == p_in[2] && c_paddingChar != p_in[3]))
+    {
+        return false;
+    }
+
+    if (u2 > 63 && c_paddingChar != p_in[2])
+    {
+        return false;
+    }
+
+    if (u3 > 63 && c_paddingChar != p_in[3])
+    {
+        return false;
+    }
+
+
+    p_out[0] = (u0 << 2) | (u1 >> 4);
+    ++p_outLen;
+    if (c_paddingChar == p_in[2])
+    {
+        if ((u1 & 0x0F) != 0)
+        {
+            return false;
+        }
+    }
+    else
+    {
+        p_out[1] = (u1 << 4) | (u2 >> 2);
+        ++p_outLen;
+        if (c_paddingChar == p_in[3])
+        {
+            if ((u3 & 0x03) != 0)
+            {
+                return false;
+            }
+        }
+        else
+        {
+            p_out[2] = (u2 << 6) | u3;
+            ++p_outLen;
+        }
+    }
+
+    return true;
+}
+
+
+std::size_t
+Base64::CapacityForEncode(std::size_t p_inLen)
+{
+    return ((p_inLen + 2) / 3) * 4;
+}
+
+
+std::size_t
+Base64::CapacityForDecode(std::size_t p_inLen)
+{
+    return (p_inLen / 4) * 3 + ((p_inLen % 4) * 2) / 3;
+}
+
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/src/Helper/CommonHelper.cpp b/core/src/index/thirdparty/SPTAG/AnnService/src/Helper/CommonHelper.cpp
new file mode 100644
index 0000000000..2d4dc0de5c
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/src/Helper/CommonHelper.cpp
@@ -0,0 +1,144 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Helper/CommonHelper.h"
+
+#include <iostream>
+#include <fstream>
+#include <cctype>
+#include <functional>
+
+using namespace SPTAG;
+using namespace SPTAG::Helper;
+
+void
+StrUtils::ToLowerInPlace(std::string& p_str)
+{
+    for (char& ch : p_str)
+    {
+        if (std::isupper(ch))
+        {
+            ch = ch | 0x20;
+        }
+    }
+}
+
+
+std::vector<std::string>
+StrUtils::SplitString(const std::string& p_str, const std::string& p_separator)
+{
+    std::vector<std::string> ret;
+
+    std::size_t begin = p_str.find_first_not_of(p_separator);
+    while (std::string::npos != begin)
+    {
+        std::size_t end = p_str.find_first_of(p_separator, begin);
+        if (std::string::npos == end)
+        {
+            ret.emplace_back(p_str.substr(begin, p_str.size() - begin));
+            break;
+        }
+        else
+        {
+            ret.emplace_back(p_str.substr(begin, end - begin));
+        }
+
+        begin = p_str.find_first_not_of(p_separator, end);
+    }
+
+    return ret;
+}
+
+
+std::pair<const char*, const char*>
+StrUtils::FindTrimmedSegment(const char* p_begin,
+                             const char* p_end,
+                             const std::function<bool(char)>& p_isSkippedChar)
+{
+    while (p_begin < p_end)
+    {
+        if (!p_isSkippedChar(*p_begin))
+        {
+            break;
+        }
+
+        ++p_begin;
+    }
+
+    while (p_end > p_begin)
+    {
+        if (!p_isSkippedChar(*(p_end - 1)))
+        {
+            break;
+        }
+
+        --p_end;
+    }
+
+    return std::make_pair(p_begin, p_end);
+}
+
+
+bool
+StrUtils::StartsWith(const char* p_str, const char* p_prefix)
+{
+    if (nullptr == p_prefix)
+    {
+        return true;
+    }
+
+    if (nullptr == p_str)
+    {
+        return false;
+    }
+
+    while ('\0' != (*p_prefix) && '\0' != (*p_str))
+    {
+        if (*p_prefix != *p_str)
+        {
+            return false;
+        }
+        ++p_prefix;
+        ++p_str;
+    }
+
+    return '\0' == *p_prefix;
+}
+
+
+bool
+StrUtils::StrEqualIgnoreCase(const char* p_left, const char* p_right)
+{
+    if (p_left == p_right)
+    {
+        return true;
+    }
+
+    if (p_left == nullptr || p_right == nullptr)
+    {
+        return false;
+    }
+
+    auto tryConv = [](char p_ch) -> char
+    {
+        if ('a' <= p_ch && p_ch <= 'z')
+        {
+            return p_ch - 32;
+        }
+
+        return p_ch;
+    };
+
+    while (*p_left != '\0' && *p_right != '\0')
+    {
+        if (tryConv(*p_left) != tryConv(*p_right))
+        {
+            return false;
+        }
+
+        ++p_left;
+        ++p_right;
+    }
+
+    return *p_left == *p_right;
+}
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/src/Helper/Concurrent.cpp b/core/src/index/thirdparty/SPTAG/AnnService/src/Helper/Concurrent.cpp
new file mode 100644
index 0000000000..cbb1bdb643
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/src/Helper/Concurrent.cpp
@@ -0,0 +1,71 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Helper/Concurrent.h"
+
+using namespace SPTAG;
+using namespace SPTAG::Helper::Concurrent;
+
+WaitSignal::WaitSignal()
+    : m_isWaiting(false),
+      m_unfinished(0)
+{
+}
+
+
+WaitSignal::WaitSignal(std::uint32_t p_unfinished)
+    : m_isWaiting(false),
+      m_unfinished(p_unfinished)
+{
+}
+
+
+WaitSignal::~WaitSignal()
+{
+    std::lock_guard<std::mutex> guard(m_mutex);
+    if (m_isWaiting)
+    {
+        m_cv.notify_all();
+    }
+}
+
+
+void
+WaitSignal::Reset(std::uint32_t p_unfinished)
+{
+    std::lock_guard<std::mutex> guard(m_mutex);
+    if (m_isWaiting)
+    {
+        m_cv.notify_all();
+    }
+
+    m_isWaiting = false;
+    m_unfinished = p_unfinished;
+}
+
+
+void
+WaitSignal::Wait()
+{
+    std::unique_lock<std::mutex> lock(m_mutex);
+    if (m_unfinished > 0)
+    {
+        m_isWaiting = true;
+        m_cv.wait(lock);
+    }
+}
+
+
+void
+WaitSignal::FinishOne()
+{
+    if (1 == m_unfinished.fetch_sub(1))
+    {
+        std::lock_guard<std::mutex> guard(m_mutex);
+        if (m_isWaiting)
+        {
+            m_isWaiting = false;
+            m_cv.notify_all();
+        }
+    }
+}
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/src/Helper/SimpleIniReader.cpp b/core/src/index/thirdparty/SPTAG/AnnService/src/Helper/SimpleIniReader.cpp
new file mode 100644
index 0000000000..28610dbe19
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/src/Helper/SimpleIniReader.cpp
@@ -0,0 +1,242 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Helper/SimpleIniReader.h"
+#include "inc/Helper/CommonHelper.h"
+
+#include <iostream>
+#include <fstream>
+#include <cctype>
+#include <functional>
+
+using namespace SPTAG;
+using namespace SPTAG::Helper;
+
+const IniReader::ParameterValueMap IniReader::c_emptyParameters;
+
+
+IniReader::IniReader()
+{
+}
+
+
+IniReader::~IniReader()
+{
+}
+
+
+ErrorCode IniReader::LoadIni(std::istream& p_input)
+{
+    const std::size_t c_bufferSize = 1 << 16;
+
+    std::unique_ptr<char[]> line(new char[c_bufferSize]);
+
+    std::string currSection;
+    std::shared_ptr<ParameterValueMap> currParamMap(new ParameterValueMap);
+
+    if (m_parameters.count(currSection) == 0)
+    {
+        m_parameters.emplace(currSection, currParamMap);
+    }
+
+    auto isSpace = [](char p_ch) -> bool
+    {
+        return std::isspace(p_ch) != 0;
+    };
+
+    while (!p_input.eof())
+    {
+        if (!p_input.getline(line.get(), c_bufferSize))
+        {
+            break;
+        }
+
+        std::size_t len = 0;
+        while (len < c_bufferSize && line[len] != '\0')
+        {
+            ++len;
+        }
+
+        auto nonSpaceSeg = StrUtils::FindTrimmedSegment(line.get(), line.get() + len, isSpace);
+
+        if (nonSpaceSeg.second <= nonSpaceSeg.first)
+        {
+            // Blank line.
+            continue;
+        }
+
+        if (';' == *nonSpaceSeg.first)
+        {
+            // Comments.
+            continue;
+        }
+        else if ('[' == *nonSpaceSeg.first)
+        {
+            // Parse Section
+            if (']' != *(nonSpaceSeg.second - 1))
+            {
+                return ErrorCode::ReadIni_FailedParseSection;
+            }
+
+            auto sectionSeg = StrUtils::FindTrimmedSegment(nonSpaceSeg.first + 1, nonSpaceSeg.second - 1, isSpace);
+
+            if (sectionSeg.second <= sectionSeg.first)
+            {
+                // Empty section name.
+                return ErrorCode::ReadIni_FailedParseSection;
+            }
+
+            currSection.assign(sectionSeg.first, sectionSeg.second);
+            StrUtils::ToLowerInPlace(currSection);
+
+            if (m_parameters.count(currSection) == 0)
+            {
+                currParamMap.reset(new ParameterValueMap);
+                m_parameters.emplace(currSection, currParamMap);
+            }
+            else
+            {
+                return ErrorCode::ReadIni_DuplicatedSection;
+            }
+        }
+        else
+        {
+            // Parameter Value Pair.
+            const char* equalSignLoc = nonSpaceSeg.first;
+            while (equalSignLoc < nonSpaceSeg.second && '=' != *equalSignLoc)
+            {
+                ++equalSignLoc;
+            }
+
+            if (equalSignLoc >= nonSpaceSeg.second)
+            {
+                return ErrorCode::ReadIni_FailedParseParam;
+            }
+
+            auto paramSeg = StrUtils::FindTrimmedSegment(nonSpaceSeg.first, equalSignLoc, isSpace);
+
+            if (paramSeg.second <= paramSeg.first)
+            {
+                // Empty parameter name.
+                return ErrorCode::ReadIni_FailedParseParam;
+            }
+
+            std::string paramName(paramSeg.first, paramSeg.second);
+            StrUtils::ToLowerInPlace(paramName);
+
+            if (currParamMap->count(paramName) == 0)
+            {
+                currParamMap->emplace(std::move(paramName), std::string(equalSignLoc + 1, nonSpaceSeg.second));
+            }
+            else
+            {
+                return ErrorCode::ReadIni_DuplicatedParam;
+            }
+        }
+    }
+    return ErrorCode::Success;
+}
+
+
+ErrorCode
+IniReader::LoadIniFile(const std::string& p_iniFilePath)
+{
+    std::ifstream input(p_iniFilePath);
+    if (!input.is_open()) return ErrorCode::FailedOpenFile;
+    ErrorCode ret = LoadIni(input);
+    input.close();
+    return ret;
+}
+
+
+bool
+IniReader::DoesSectionExist(const std::string& p_section) const
+{
+    std::string section(p_section);
+    StrUtils::ToLowerInPlace(section);
+    return m_parameters.count(section) != 0;
+}
+
+
+bool
+IniReader::DoesParameterExist(const std::string& p_section, const std::string& p_param) const
+{
+    std::string name(p_section);
+    StrUtils::ToLowerInPlace(name);
+    auto iter = m_parameters.find(name);
+    if (iter == m_parameters.cend())
+    {
+        return false;
+    }
+
+    const auto& paramMap = iter->second;
+    if (paramMap == nullptr)
+    {
+        return false;
+    }
+
+    name = p_param;
+    StrUtils::ToLowerInPlace(name);
+    return paramMap->count(name) != 0;
+}
+
+
+bool
+IniReader::GetRawValue(const std::string& p_section, const std::string& p_param, std::string& p_value) const
+{
+    std::string name(p_section);
+    StrUtils::ToLowerInPlace(name);
+    auto sectionIter = m_parameters.find(name);
+    if (sectionIter == m_parameters.cend())
+    {
+        return false;
+    }
+
+    const auto& paramMap = sectionIter->second;
+    if (paramMap == nullptr)
+    {
+        return false;
+    }
+
+    name = p_param;
+    StrUtils::ToLowerInPlace(name);
+    auto paramIter = paramMap->find(name);
+    if (paramIter == paramMap->cend())
+    {
+        return false;
+    }
+
+    p_value = paramIter->second;
+    return true;
+}
+
+
+const IniReader::ParameterValueMap&
+IniReader::GetParameters(const std::string& p_section) const
+{
+    std::string name(p_section);
+    StrUtils::ToLowerInPlace(name);
+    auto sectionIter = m_parameters.find(name);
+    if (sectionIter == m_parameters.cend() || nullptr == sectionIter->second)
+    {
+        return c_emptyParameters;
+    }
+
+    return *(sectionIter->second);
+}
+
+void
+IniReader::SetParameter(const std::string& p_section, const std::string& p_param, const std::string& p_val)
+{
+    std::string name(p_section);
+    StrUtils::ToLowerInPlace(name);
+    auto sectionIter = m_parameters.find(name);
+    if (sectionIter == m_parameters.cend() || sectionIter->second == nullptr) 
+    {
+        m_parameters[name] = std::shared_ptr<ParameterValueMap>(new ParameterValueMap);
+    }
+
+    std::string param(p_param);
+    StrUtils::ToLowerInPlace(param);
+    (*m_parameters[name])[param] = p_val;
+}
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/src/Helper/VectorSetReader.cpp b/core/src/index/thirdparty/SPTAG/AnnService/src/Helper/VectorSetReader.cpp
new file mode 100644
index 0000000000..44371ae242
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/src/Helper/VectorSetReader.cpp
@@ -0,0 +1,44 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Helper/VectorSetReader.h"
+#include "inc/Helper/VectorSetReaders/DefaultReader.h"
+
+
+using namespace SPTAG;
+using namespace SPTAG::Helper;
+
+
+ReaderOptions::ReaderOptions(VectorValueType p_valueType, DimensionType p_dimension, std::string p_vectorDelimiter, std::uint32_t p_threadNum)
+    : m_threadNum(p_threadNum), m_dimension(p_dimension), m_vectorDelimiter(p_vectorDelimiter), m_inputValueType(p_valueType)
+{
+    AddOptionalOption(m_threadNum, "-t", "--thread", "Thread Number.");
+    AddOptionalOption(m_vectorDelimiter, "", "--delimiter", "Vector delimiter.");
+    AddRequiredOption(m_dimension, "-d", "--dimension", "Dimension of vector.");
+    AddRequiredOption(m_inputValueType, "-v", "--vectortype", "Input vector data type. Default is float.");
+}
+
+
+ReaderOptions::~ReaderOptions()
+{
+}
+
+
+VectorSetReader::VectorSetReader(std::shared_ptr<ReaderOptions> p_options)
+    : m_options(p_options)
+{
+}
+
+
+VectorSetReader:: ~VectorSetReader()
+{
+}
+
+
+std::shared_ptr<VectorSetReader>
+VectorSetReader::CreateInstance(std::shared_ptr<ReaderOptions> p_options)
+{
+    return std::shared_ptr<VectorSetReader>(new DefaultReader(std::move(p_options)));
+}
+
+
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/src/Helper/VectorSetReaders/DefaultReader.cpp b/core/src/index/thirdparty/SPTAG/AnnService/src/Helper/VectorSetReaders/DefaultReader.cpp
new file mode 100644
index 0000000000..4d775f4a50
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/src/Helper/VectorSetReaders/DefaultReader.cpp
@@ -0,0 +1,514 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Helper/VectorSetReaders/DefaultReader.h"
+#include "inc/Helper/StringConvert.h"
+#include "inc/Helper/CommonHelper.h"
+
+#include <fstream>
+#include <sstream>
+#include <iostream>
+#include <omp.h>
+
+using namespace SPTAG;
+using namespace SPTAG::Helper;
+
+namespace
+{
+namespace Local
+{
+
+class BinaryLineReader
+{
+public:
+    BinaryLineReader(std::istream& p_inStream)
+        : m_inStream(p_inStream)
+    {
+        m_buffer.reset(new char[c_bufferSize]);
+    }
+
+
+    bool Eof()
+    {
+        return m_inStream.eof() && (m_curOffset == m_curTotal);
+    }
+
+
+    std::size_t GetLine(std::unique_ptr<char[]>& p_buffer, std::size_t& p_bufferSize, std::size_t& p_length)
+    {
+        std::size_t consumedCount = 0;
+        p_length = 0;
+        while (true)
+        {
+            while (m_curOffset < m_curTotal)
+            {
+                if (p_bufferSize > p_length)
+                {
+                    ++consumedCount;
+                    if (!IsDelimiter(m_buffer[m_curOffset]))
+                    {
+                        p_buffer[p_length++] = m_buffer[m_curOffset++];
+                    }
+                    else
+                    {
+                        ++m_curOffset;
+                        p_buffer[p_length] = '\0';
+                        return consumedCount + MoveToNextValid();
+                    }
+                }
+                else
+                {
+                    p_bufferSize *= 2;
+                    std::unique_ptr<char[]> newBuffer(new char[p_bufferSize]);
+                    memcpy(newBuffer.get(), p_buffer.get(), p_length);
+                    p_buffer.swap(newBuffer);
+                }
+            }
+
+            if (m_inStream.eof())
+            {
+                break;
+            }
+
+            m_inStream.read(m_buffer.get(), c_bufferSize);
+            m_curTotal = m_inStream.gcount();
+            m_curOffset = 0;
+        }
+
+        if (p_bufferSize <= p_length)
+        {
+            p_bufferSize *= 2;
+            std::unique_ptr<char[]> newBuffer(new char[p_bufferSize]);
+            memcpy(newBuffer.get(), p_buffer.get(), p_length);
+            p_buffer.swap(newBuffer);
+        }
+
+        p_buffer[p_length] = '\0';
+        return consumedCount;
+    }
+
+
+private:
+    std::size_t MoveToNextValid()
+    {
+        std::size_t skipped = 0;
+        while (true)
+        {
+            while (m_curOffset < m_curTotal)
+            {
+                if (IsDelimiter(m_buffer[m_curOffset]))
+                {
+                    ++skipped;
+                    ++m_curOffset;
+                }
+                else
+                {
+                    return skipped;
+                }
+            }
+
+            if (m_inStream.eof())
+            {
+                break;
+            }
+
+            m_inStream.read(m_buffer.get(), c_bufferSize);
+            m_curTotal = m_inStream.gcount();
+            m_curOffset = 0;
+        }
+
+        return skipped;
+    }
+
+    bool IsDelimiter(char p_ch)
+    {
+        return p_ch == '\r' || p_ch == '\n';
+    }
+
+    static const std::size_t c_bufferSize = 1 << 10;
+
+    std::unique_ptr<char[]> m_buffer;
+
+    std::istream& m_inStream;
+
+    std::size_t m_curOffset;
+
+    std::size_t m_curTotal;
+};
+
+} // namespace Local
+} // namespace
+
+
+DefaultReader::DefaultReader(std::shared_ptr<ReaderOptions> p_options)
+    : VectorSetReader(std::move(p_options)),
+    m_subTaskBlocksize(0)
+{
+    omp_set_num_threads(m_options->m_threadNum);
+
+    std::string tempFolder("tempfolder");
+    if (!direxists(tempFolder.c_str()))
+    {
+        mkdir(tempFolder.c_str());
+    }
+
+    tempFolder += FolderSep;
+    m_vectorOutput = tempFolder + "vectorset.bin";
+    m_metadataConentOutput = tempFolder + "metadata.bin";
+    m_metadataIndexOutput = tempFolder + "metadataindex.bin";
+}
+
+
+DefaultReader::~DefaultReader()
+{
+    if (fileexists(m_vectorOutput.c_str()))
+    {
+        remove(m_vectorOutput.c_str());
+    }
+
+    if (fileexists(m_metadataIndexOutput.c_str()))
+    {
+        remove(m_metadataIndexOutput.c_str());
+    }
+
+    if (fileexists(m_metadataConentOutput.c_str()))
+    {
+        remove(m_metadataConentOutput.c_str());
+    }
+}
+
+
+ErrorCode
+DefaultReader::LoadFile(const std::string& p_filePaths)
+{
+    const auto& files = GetFileSizes(p_filePaths);
+    std::vector<std::function<void()>> subWorks;
+    subWorks.reserve(files.size() * m_options->m_threadNum);
+
+    m_subTaskCount = 0;
+    for (const auto& fileInfo : files)
+    {
+        if (fileInfo.second == (std::numeric_limits<std::size_t>::max)())
+        {
+            std::stringstream msg;
+            msg << "File " << fileInfo.first << " not exists or can't access.";
+            std::cerr << msg.str() << std::endl;
+            exit(1);
+        }
+
+        std::uint32_t fileTaskCount = 0;
+        std::size_t blockSize = m_subTaskBlocksize;
+        if (0 == blockSize)
+        {
+            fileTaskCount = m_options->m_threadNum;
+            blockSize = (fileInfo.second + fileTaskCount - 1) / fileTaskCount;
+        }
+        else
+        {
+            fileTaskCount = static_cast<std::uint32_t>((fileInfo.second + blockSize - 1) / blockSize);
+        }
+
+        for (std::uint32_t i = 0; i < fileTaskCount; ++i)
+        {
+            subWorks.emplace_back(std::bind(&DefaultReader::LoadFileInternal,
+                                            this,
+                                            fileInfo.first,
+                                            m_subTaskCount++,
+                                            i,
+                                            blockSize));
+        }
+    }
+
+    m_totalRecordCount = 0;
+    m_totalRecordVectorBytes = 0;
+    m_subTaskRecordCount.clear();
+    m_subTaskRecordCount.resize(m_subTaskCount, 0);
+
+    m_waitSignal.Reset(m_subTaskCount);
+
+#pragma omp parallel for schedule(dynamic)
+    for (int64_t i = 0; i < (int64_t)subWorks.size(); i++)
+    {
+        subWorks[i]();
+    }
+
+    m_waitSignal.Wait();
+
+    MergeData();
+
+    return ErrorCode::Success;
+}
+
+
+std::shared_ptr<VectorSet>
+DefaultReader::GetVectorSet() const
+{
+    ByteArray vectorSet = ByteArray::Alloc(m_totalRecordVectorBytes);
+    char* vecBuf = reinterpret_cast<char*>(vectorSet.Data());
+
+    std::ifstream inputStream;
+    inputStream.open(m_vectorOutput, std::ifstream::binary);
+    inputStream.seekg(sizeof(SizeType) + sizeof(DimensionType), std::ifstream::beg);
+    inputStream.read(vecBuf, m_totalRecordVectorBytes);
+    inputStream.close();
+
+    return std::shared_ptr<VectorSet>(new BasicVectorSet(vectorSet,
+                                                         m_options->m_inputValueType,
+                                                         m_options->m_dimension,
+                                                         m_totalRecordCount));
+}
+
+
+std::shared_ptr<MetadataSet>
+DefaultReader::GetMetadataSet() const
+{
+    return std::shared_ptr<MetadataSet>(new FileMetadataSet(m_metadataConentOutput, m_metadataIndexOutput));
+}
+
+
+void
+DefaultReader::LoadFileInternal(const std::string& p_filePath,
+                                std::uint32_t p_subTaskID,
+                                std::uint32_t p_fileBlockID,
+                                std::size_t p_fileBlockSize)
+{
+    std::size_t lineBufferSize = 1 << 16;
+    std::unique_ptr<char[]> currentLine(new char[lineBufferSize]);
+
+    std::ifstream inputStream;
+    std::ofstream outputStream;
+    std::ofstream metaStreamContent;
+    std::ofstream metaStreamIndex;
+
+    SizeType recordCount = 0;
+    std::uint64_t metaOffset = 0;
+    std::size_t totalRead = 0;
+    std::streamoff startpos = p_fileBlockID * p_fileBlockSize;
+
+    inputStream.open(p_filePath, std::ios_base::in | std::ios_base::binary);
+    if (inputStream.is_open() == false)
+    {
+        std::stringstream msg;
+        msg << "Unable to open file: " << p_filePath << std::endl;
+        const auto& msgStr = msg.str();
+        std::cerr << msgStr;
+        throw MyException(msgStr);
+        exit(1);
+    }
+
+    {
+        std::stringstream msg;
+        msg << "Begin Subtask: " << p_subTaskID << ", start offset position:" << startpos << std::endl;
+        std::cout << msg.str();
+    }
+
+    std::string subFileSuffix("_");
+    subFileSuffix += std::to_string(p_subTaskID);
+    subFileSuffix += ".tmp";
+
+    outputStream.open(m_vectorOutput + subFileSuffix, std::ofstream::binary);
+    metaStreamContent.open(m_metadataConentOutput + subFileSuffix, std::ofstream::binary);
+    metaStreamIndex.open(m_metadataIndexOutput + subFileSuffix, std::ofstream::binary);
+
+    inputStream.seekg(startpos, std::ifstream::beg);
+
+    Local::BinaryLineReader lineReader(inputStream);
+
+    std::size_t lineLength;
+    if (p_fileBlockID != 0)
+    {
+        totalRead += lineReader.GetLine(currentLine, lineBufferSize, lineLength);
+    }
+
+    std::size_t vectorByteSize = GetValueTypeSize(m_options->m_inputValueType) * m_options->m_dimension;
+    std::unique_ptr<std::uint8_t[]> vector;
+    vector.reset(new std::uint8_t[vectorByteSize]);
+
+    while (!lineReader.Eof() && totalRead <= p_fileBlockSize)
+    {
+        totalRead += lineReader.GetLine(currentLine, lineBufferSize, lineLength);
+        if (0 == lineLength)
+        {
+            continue;
+        }
+
+        std::size_t tabIndex = lineLength - 1;
+        while (tabIndex > 0 && currentLine[tabIndex] != '\t')
+        {
+            --tabIndex;
+        }
+
+        if (0 == tabIndex && currentLine[tabIndex] != '\t')
+        {
+            std::stringstream msg;
+            msg << "Subtask: " << p_subTaskID << " cannot parsing line:" << currentLine.get() << std::endl;
+            std::cout << msg.str();
+            exit(1);
+        }
+
+        bool parseSuccess = false;
+        switch (m_options->m_inputValueType)
+        {
+#define DefineVectorValueType(Name, Type) \
+        case VectorValueType::Name: \
+            parseSuccess = TranslateVector(currentLine.get() + tabIndex + 1, reinterpret_cast<Type*>(vector.get())); \
+            break; \
+
+#include "inc/Core/DefinitionList.h"
+#undef DefineVectorValueType
+
+        default:
+            parseSuccess = false;
+            break;
+        }
+
+        if (!parseSuccess)
+        {
+            std::stringstream msg;
+            msg << "Subtask: " << p_subTaskID << " cannot parsing vector:" << (currentLine.get() + tabIndex + 1) << std::endl;
+            std::cout << msg.str();
+            exit(1);
+        }
+
+        ++recordCount;
+        outputStream.write(reinterpret_cast<const char*>(vector.get()), vectorByteSize);
+        metaStreamContent.write(currentLine.get(), tabIndex);
+        metaStreamIndex.write(reinterpret_cast<const char*>(&metaOffset), sizeof(metaOffset));
+
+        metaOffset += tabIndex;
+    }
+
+    metaStreamIndex.write(reinterpret_cast<const char*>(&metaOffset), sizeof(metaOffset));
+
+    inputStream.close();
+    outputStream.close();
+    metaStreamContent.close();
+    metaStreamIndex.close();
+
+    m_totalRecordCount += recordCount;
+    m_subTaskRecordCount[p_subTaskID] = recordCount;
+    m_totalRecordVectorBytes += recordCount * vectorByteSize;
+
+    m_waitSignal.FinishOne();
+}
+
+
+void
+DefaultReader::MergeData()
+{
+    const std::size_t bufferSize = 1 << 30;
+    const std::size_t bufferSizeTrim64 = (bufferSize / sizeof(std::uint64_t)) * sizeof(std::uint64_t);
+    std::ifstream inputStream;
+    std::ofstream outputStream;
+
+    std::unique_ptr<char[]> bufferHolder(new char[bufferSize]);
+    char* buf = bufferHolder.get();
+
+    SizeType totalRecordCount = m_totalRecordCount;
+
+    outputStream.open(m_vectorOutput, std::ofstream::binary);
+
+    outputStream.write(reinterpret_cast<char*>(&totalRecordCount), sizeof(totalRecordCount));
+    outputStream.write(reinterpret_cast<char*>(&(m_options->m_dimension)), sizeof(m_options->m_dimension));
+
+    for (std::uint32_t i = 0; i < m_subTaskCount; ++i)
+    {
+        std::string file = m_vectorOutput;
+        file += "_";
+        file += std::to_string(i);
+        file += ".tmp";
+
+        inputStream.open(file, std::ifstream::binary);
+        outputStream << inputStream.rdbuf();
+
+        inputStream.close();
+        remove(file.c_str());
+    }
+
+    outputStream.close();
+
+    outputStream.open(m_metadataConentOutput, std::ofstream::binary);
+    for (std::uint32_t i = 0; i < m_subTaskCount; ++i)
+    {
+        std::string file = m_metadataConentOutput;
+        file += "_";
+        file += std::to_string(i);
+        file += ".tmp";
+
+        inputStream.open(file, std::ifstream::binary);
+        outputStream << inputStream.rdbuf();
+
+        inputStream.close();
+        remove(file.c_str());
+    }
+
+    outputStream.close();
+
+    outputStream.open(m_metadataIndexOutput, std::ofstream::binary);
+
+    outputStream.write(reinterpret_cast<char*>(&totalRecordCount), sizeof(totalRecordCount));
+
+    std::uint64_t totalOffset = 0;
+    for (std::uint32_t i = 0; i < m_subTaskCount; ++i)
+    {
+        std::string file = m_metadataIndexOutput;
+        file += "_";
+        file += std::to_string(i);
+        file += ".tmp";
+
+        inputStream.open(file, std::ifstream::binary);
+        for (SizeType remains = m_subTaskRecordCount[i]; remains > 0;)
+        {
+            std::size_t readBytesCount = min(remains * sizeof(std::uint64_t), bufferSizeTrim64);
+            inputStream.read(buf, readBytesCount);
+            std::uint64_t* offset = reinterpret_cast<std::uint64_t*>(buf);
+            for (std::uint64_t i = 0; i < readBytesCount / sizeof(std::uint64_t); ++i)
+            {
+                offset[i] += totalOffset;
+            }
+
+            outputStream.write(buf, readBytesCount);
+            remains -= static_cast<SizeType>(readBytesCount / sizeof(std::uint64_t));
+        }
+
+        inputStream.read(buf, sizeof(std::uint64_t));
+        totalOffset += *(reinterpret_cast<std::uint64_t*>(buf));
+
+        inputStream.close();
+        remove(file.c_str());
+    }
+
+    outputStream.write(reinterpret_cast<char*>(&totalOffset), sizeof(totalOffset));
+    outputStream.close();
+}
+
+
+std::vector<DefaultReader::FileInfoPair>
+DefaultReader::GetFileSizes(const std::string& p_filePaths)
+{
+    const auto& files = Helper::StrUtils::SplitString(p_filePaths, ",");
+    std::vector<DefaultReader::FileInfoPair> res;
+    res.reserve(files.size());
+
+    for (const auto& filePath : files)
+    {
+        if (!fileexists(filePath.c_str()))
+        {
+            res.emplace_back(filePath, (std::numeric_limits<std::size_t>::max)());
+            continue;
+        }
+#ifndef _MSC_VER
+        struct stat stat_buf;
+        stat(filePath.c_str(), &stat_buf);
+#else
+        struct _stat64 stat_buf;
+        _stat64(filePath.c_str(), &stat_buf);
+#endif
+        std::size_t fileSize = stat_buf.st_size;
+        res.emplace_back(filePath, static_cast<std::size_t>(fileSize));
+    }
+
+    return res;
+}
+
+
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/src/IndexBuilder/Options.cpp b/core/src/index/thirdparty/SPTAG/AnnService/src/IndexBuilder/Options.cpp
new file mode 100644
index 0000000000..6360b73c2a
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/src/IndexBuilder/Options.cpp
@@ -0,0 +1,25 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/IndexBuilder/Options.h"
+#include "inc/Helper/StringConvert.h"
+
+#include <cassert>
+
+using namespace SPTAG;
+using namespace SPTAG::IndexBuilder;
+
+
+BuilderOptions::BuilderOptions()
+    : Helper::ReaderOptions(VectorValueType::Float, 0, "|", 32)
+{
+    AddRequiredOption(m_inputFiles, "-i", "--input", "Input raw data.");
+    AddRequiredOption(m_outputFolder, "-o", "--outputfolder", "Output folder.");
+    AddRequiredOption(m_indexAlgoType, "-a", "--algo", "Index Algorithm type.");
+    AddOptionalOption(m_builderConfigFile, "-c", "--config", "Config file for builder.");
+}
+
+
+BuilderOptions::~BuilderOptions()
+{
+}
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/src/IndexBuilder/ThreadPool.cpp b/core/src/index/thirdparty/SPTAG/AnnService/src/IndexBuilder/ThreadPool.cpp
new file mode 100644
index 0000000000..0ecddc1279
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/src/IndexBuilder/ThreadPool.cpp
@@ -0,0 +1,54 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/IndexBuilder/ThreadPool.h"
+
+#include <boost/asio.hpp>
+
+#include <memory>
+#include <atomic>
+
+using namespace SPTAG::IndexBuilder;
+
+namespace Local
+{
+std::unique_ptr<boost::asio::thread_pool> g_threadPool;
+
+std::atomic_bool g_initialized(false);
+
+std::uint32_t g_threadNum = 1;
+}
+
+
+void
+ThreadPool::Init(std::uint32_t p_threadNum)
+{
+    if (Local::g_initialized.exchange(true))
+    {
+        return;
+    }
+
+    Local::g_threadNum = std::max((std::uint32_t)1, p_threadNum);
+
+    Local::g_threadPool.reset(new boost::asio::thread_pool(Local::g_threadNum));
+}
+
+
+bool
+ThreadPool::Queue(std::function<void()> p_workItem)
+{
+    if (nullptr == Local::g_threadPool)
+    {
+        return false;
+    }
+
+    boost::asio::post(*Local::g_threadPool, std::move(p_workItem));
+    return true;
+}
+
+
+std::uint32_t
+ThreadPool::CurrentThreadNum()
+{
+    return Local::g_threadNum;
+}
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/src/IndexBuilder/main.cpp b/core/src/index/thirdparty/SPTAG/AnnService/src/IndexBuilder/main.cpp
new file mode 100644
index 0000000000..040703c3ca
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/src/IndexBuilder/main.cpp
@@ -0,0 +1,100 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/IndexBuilder/Options.h"
+#include "inc/Helper/VectorSetReader.h"
+#include "inc/Core/VectorIndex.h"
+#include "inc/Core/Common.h"
+#include "inc/Helper/SimpleIniReader.h"
+
+#include <memory>
+#include <iostream>
+
+using namespace SPTAG;
+
+int main(int argc, char* argv[])
+{
+    std::shared_ptr<IndexBuilder::BuilderOptions> options(new IndexBuilder::BuilderOptions);
+    if (!options->Parse(argc - 1, argv + 1))
+    {
+        exit(1);
+    }
+
+    auto indexBuilder = VectorIndex::CreateInstance(options->m_indexAlgoType, options->m_inputValueType);
+
+    Helper::IniReader iniReader;
+    if (!options->m_builderConfigFile.empty())
+    {
+        iniReader.LoadIniFile(options->m_builderConfigFile);
+    }
+
+    for (int i = 1; i < argc; i++)
+    {
+        std::string param(argv[i]);
+        size_t idx = param.find("=");
+        if (idx == std::string::npos) continue;
+
+        std::string paramName = param.substr(0, idx);
+        std::string paramVal = param.substr(idx + 1);
+        std::string sectionName;
+        idx = paramName.find(".");
+        if (idx != std::string::npos) {
+            sectionName = paramName.substr(0, idx);
+            paramName = paramName.substr(idx + 1);
+        }
+        iniReader.SetParameter(sectionName, paramName, paramVal);
+        std::cout << "Set [" << sectionName << "]" << paramName << " = " << paramVal << std::endl;
+    }
+
+    if (!iniReader.DoesParameterExist("Index", "NumberOfThreads")) {
+        iniReader.SetParameter("Index", "NumberOfThreads", std::to_string(options->m_threadNum));
+    }
+    for (const auto& iter : iniReader.GetParameters("Index"))
+    {
+        indexBuilder->SetParameter(iter.first.c_str(), iter.second.c_str());
+    }
+
+    ErrorCode code;
+    if (options->m_inputFiles.find("BIN:") == 0) {
+        std::vector<std::string> files = SPTAG::Helper::StrUtils::SplitString(options->m_inputFiles.substr(4), ",");
+        std::ifstream inputStream(files[0], std::ifstream::binary);
+        if (!inputStream.is_open()) {
+            fprintf(stderr, "Failed to read input file.\n");
+            exit(1);
+        }
+        SizeType row;
+        DimensionType col;
+        inputStream.read((char*)&row, sizeof(SizeType));
+        inputStream.read((char*)&col, sizeof(DimensionType));
+        std::uint64_t totalRecordVectorBytes = ((std::uint64_t)GetValueTypeSize(options->m_inputValueType)) * row * col;
+        ByteArray vectorSet = ByteArray::Alloc(totalRecordVectorBytes);
+        char* vecBuf = reinterpret_cast<char*>(vectorSet.Data());
+        inputStream.read(vecBuf, totalRecordVectorBytes);
+        inputStream.close();
+        std::shared_ptr<VectorSet> p_vectorSet(new BasicVectorSet(vectorSet, options->m_inputValueType, col, row));
+        
+        std::shared_ptr<MetadataSet> p_metaSet = nullptr;
+        if (files.size() >= 3) {
+            p_metaSet.reset(new FileMetadataSet(files[1], files[2]));
+        }
+        code = indexBuilder->BuildIndex(p_vectorSet, p_metaSet);
+        indexBuilder->SaveIndex(options->m_outputFolder);
+    }
+    else {
+        auto vectorReader = Helper::VectorSetReader::CreateInstance(options);
+        if (ErrorCode::Success != vectorReader->LoadFile(options->m_inputFiles))
+        {
+            fprintf(stderr, "Failed to read input file.\n");
+            exit(1);
+        }
+        code = indexBuilder->BuildIndex(vectorReader->GetVectorSet(), vectorReader->GetMetadataSet());
+        indexBuilder->SaveIndex(options->m_outputFolder);
+    }
+
+    if (ErrorCode::Success != code)
+    {
+        fprintf(stderr, "Failed to build index.\n");
+        exit(1);
+    }
+    return 0;
+}
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/src/IndexSearcher/main.cpp b/core/src/index/thirdparty/SPTAG/AnnService/src/IndexSearcher/main.cpp
new file mode 100644
index 0000000000..0a8c84c2e3
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/src/IndexSearcher/main.cpp
@@ -0,0 +1,278 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Helper/SimpleIniReader.h"
+#include "inc/Helper/CommonHelper.h"
+#include "inc/Core/Common.h"
+#include "inc/Core/MetadataSet.h"
+#include "inc/Core/VectorIndex.h"
+#include "inc/Core/SearchQuery.h"
+#include "inc/Core/Common/WorkSpace.h"
+#include "inc/Core/Common/DataUtils.h"
+#include <iomanip>
+#include <set>
+
+using namespace SPTAG;
+
+template <typename T>
+float CalcRecall(std::vector<QueryResult> &results, const std::vector<std::set<SizeType>> &truth, SizeType NumQuerys, int K, std::ofstream& log)
+{
+    float meanrecall = 0, minrecall = MaxDist, maxrecall = 0, stdrecall = 0;
+    std::vector<float> thisrecall(NumQuerys, 0);
+    for (SizeType i = 0; i < NumQuerys; i++)
+    {
+        for (SizeType id : truth[i])
+        {
+            for (int j = 0; j < K; j++)
+            {
+                if (results[i].GetResult(j)->VID == id)
+                {
+                    thisrecall[i] += 1;
+                    break;
+                }
+            }
+        }
+        thisrecall[i] /= K;
+        meanrecall += thisrecall[i];
+        if (thisrecall[i] < minrecall) minrecall = thisrecall[i];
+        if (thisrecall[i] > maxrecall) maxrecall = thisrecall[i];
+    }
+    meanrecall /= NumQuerys;
+    for (SizeType i = 0; i < NumQuerys; i++)
+    {
+        stdrecall += (thisrecall[i] - meanrecall) * (thisrecall[i] - meanrecall);
+    }
+    stdrecall = std::sqrt(stdrecall / NumQuerys);
+    log << meanrecall << " " << stdrecall << " " << minrecall << " " << maxrecall << std::endl;
+    return meanrecall;
+}
+
+void LoadTruth(std::ifstream& fp, std::vector<std::set<SizeType>>& truth, SizeType NumQuerys, int K)
+{
+    SizeType get;
+    std::string line;
+    for (SizeType i = 0; i < NumQuerys; ++i)
+    {
+        truth[i].clear();
+        for (int j = 0; j < K; ++j)
+        {
+            fp >> get;
+            truth[i].insert(get);
+        }
+        std::getline(fp, line);
+    }
+}
+
+template <typename T>
+int Process(Helper::IniReader& reader, VectorIndex& index)
+{
+    std::string queryFile = reader.GetParameter("Index", "QueryFile", std::string("querys.bin"));
+    std::string truthFile = reader.GetParameter("Index", "TruthFile", std::string("truth.txt"));
+    std::string outputFile = reader.GetParameter("Index", "ResultFile", std::string(""));
+
+    SizeType numBatchQuerys = reader.GetParameter("Index", "NumBatchQuerys", (SizeType)10000);
+    SizeType numDebugQuerys = reader.GetParameter("Index", "NumDebugQuerys", (SizeType)-1);
+    int K = reader.GetParameter("Index", "K", 32);
+
+    std::vector<std::string> maxCheck = Helper::StrUtils::SplitString(reader.GetParameter("Index", "MaxCheck", std::string("2048")), "#");
+
+    std::ifstream inStream(queryFile);
+    std::ifstream ftruth(truthFile);
+    std::ofstream fp;
+    if (!inStream.is_open())
+    {
+        std::cout << "ERROR: Cannot Load Query file " << queryFile << "!" << std::endl;
+        return -1;
+    }
+    if (outputFile != "")
+    {
+        fp.open(outputFile);
+        if (!fp.is_open())
+        {
+            std::cout << "ERROR: Cannot open " << outputFile << " for write!" << std::endl;
+        }
+    }
+
+    std::ofstream log(index.GetIndexName() + "_" + std::to_string(K) + ".txt");
+    if (!log.is_open())
+    {
+        std::cout << "ERROR: Cannot open logging file!" << std::endl;
+        return -1;
+    }
+
+    SizeType numQuerys = (numDebugQuerys >= 0) ? numDebugQuerys : numBatchQuerys;
+
+    std::vector<std::vector<T>> Query(numQuerys, std::vector<T>(index.GetFeatureDim(), 0)); 
+    std::vector<std::set<SizeType>> truth(numQuerys);
+    std::vector<QueryResult> results(numQuerys, QueryResult(NULL, K, 0));
+
+    clock_t * latencies = new clock_t[numQuerys + 1];
+
+    int base = 1;
+    if (index.GetDistCalcMethod() == DistCalcMethod::Cosine) {
+        base = COMMON::Utils::GetBase<T>();
+    }
+    int basesquare = base * base;
+
+    DimensionType dims = index.GetFeatureDim();
+    std::vector<std::string> QStrings;
+    while (!inStream.eof())
+    {
+        QStrings.clear();
+        COMMON::Utils::PrepareQuerys(inStream, QStrings, Query, numQuerys, dims, index.GetDistCalcMethod(), base);
+        if (numQuerys == 0) break;
+
+        for (SizeType i = 0; i < numQuerys; i++) results[i].SetTarget(Query[i].data());
+        if (ftruth.is_open()) LoadTruth(ftruth, truth, numQuerys, K);
+
+        std::cout << "    \t[avg]      \t[99%] \t[95%] \t[recall] \t[mem]" << std::endl;
+
+        SizeType subSize = (numQuerys - 1) / omp_get_num_threads() + 1;
+        for (std::string& mc : maxCheck)
+        {
+            index.SetParameter("MaxCheck", mc.c_str());
+            for (SizeType i = 0; i < numQuerys; i++) results[i].Reset();
+
+#pragma omp parallel for
+            for (int tid = 0; tid < omp_get_num_threads(); tid++)
+            {
+                SizeType start = tid * subSize;
+                SizeType end = min((tid + 1) * subSize, numQuerys);
+                for (SizeType i = start; i < end; i++)
+                {
+                    latencies[i] = clock();
+                    index.SearchIndex(results[i]);
+                }
+            }
+
+            latencies[numQuerys] = clock();
+
+            float timeMean = 0, timeMin = MaxDist, timeMax = 0, timeStd = 0;
+            for (SizeType i = 0; i < numQuerys; i++)
+            {
+                if (latencies[i + 1] >= latencies[i])
+                    latencies[i] = latencies[i + 1] - latencies[i];
+                else
+                    latencies[i] = latencies[numQuerys] - latencies[i];
+                timeMean += latencies[i];
+                if (latencies[i] > timeMax) timeMax = (float)latencies[i];
+                if (latencies[i] < timeMin) timeMin = (float)latencies[i];
+            }
+            timeMean /= numQuerys;
+            for (SizeType i = 0; i < numQuerys; i++) timeStd += ((float)latencies[i] - timeMean) * ((float)latencies[i] - timeMean);
+            timeStd = std::sqrt(timeStd / numQuerys);
+            log << timeMean << " " << timeStd << " " << timeMin << " " << timeMax << " ";
+
+            std::sort(latencies, latencies + numQuerys, [](clock_t x, clock_t y)
+            {
+                return x < y;
+            });
+            float l99 = float(latencies[SizeType(numQuerys * 0.99)]) / CLOCKS_PER_SEC;
+            float l95 = float(latencies[SizeType(numQuerys * 0.95)]) / CLOCKS_PER_SEC;
+
+            float recall = 0;
+            if (ftruth.is_open())
+            {
+                recall = CalcRecall<T>(results, truth, numQuerys, K, log);
+            }
+
+#ifndef _MSC_VER
+            struct rusage rusage;
+            getrusage(RUSAGE_SELF, &rusage);
+            unsigned long long peakWSS = rusage.ru_maxrss * 1024 / 1000000000;
+#else
+            PROCESS_MEMORY_COUNTERS pmc;
+            GetProcessMemoryInfo(GetCurrentProcess(), &pmc, sizeof(pmc));
+            unsigned long long peakWSS = pmc.PeakWorkingSetSize / 1000000000;
+#endif
+            std::cout << mc << "\t" << std::fixed << std::setprecision(6) << (timeMean / CLOCKS_PER_SEC) << "\t" << std::setprecision(4) << l99 << "\t" << l95 << "\t" << recall << "\t\t" << peakWSS << "GB" << std::endl;
+
+        }
+        
+        if (fp.is_open())
+        {
+            fp << std::setprecision(3) << std::fixed;
+            for (SizeType i = 0; i < numQuerys; i++)
+            {
+                fp << QStrings[i] << ":";
+                for (int j = 0; j < K; j++)
+                {
+                    if (results[i].GetResult(j)->VID < 0) {
+                        fp << results[i].GetResult(j)->Dist << "@" << results[i].GetResult(j)->VID << std::endl;
+                    }
+                    else {
+                        ByteArray vm = index.GetMetadata(results[i].GetResult(j)->VID);
+                        fp << (results[i].GetResult(j)->Dist / basesquare) << "@";
+                        fp.write((const char*)vm.Data(), vm.Length());
+                    }
+                    fp << "|";
+                }
+                fp << std::endl;
+            }
+        }
+        
+        if (numQuerys < numBatchQuerys || numDebugQuerys >= 0) break;
+    }
+    std::cout << "Output results finish!" << std::endl;
+
+    inStream.close();
+    fp.close();
+    log.close();
+    ftruth.close();
+    delete[] latencies;
+
+    QStrings.clear();
+    results.clear();
+
+    return 0;
+}
+
+int main(int argc, char** argv)
+{
+    if (argc < 2)
+    {
+        std::cerr << "IndexSearcher.exe folder" << std::endl;
+        return -1;
+    }
+
+    std::shared_ptr<SPTAG::VectorIndex> vecIndex;
+    auto ret = SPTAG::VectorIndex::LoadIndex(argv[1], vecIndex);
+    if (SPTAG::ErrorCode::Success != ret || nullptr == vecIndex)
+    {
+        std::cerr << "Cannot open configure file!" << std::endl;
+        return -1;
+    }
+
+    Helper::IniReader iniReader;
+    for (int i = 1; i < argc; i++)
+    {
+        std::string param(argv[i]);
+        size_t idx = param.find("=");
+        if (idx == std::string::npos) continue;
+
+        std::string paramName = param.substr(0, idx);
+        std::string paramVal = param.substr(idx + 1);
+        std::string sectionName;
+        idx = paramName.find(".");
+        if (idx != std::string::npos) {
+            sectionName = paramName.substr(0, idx);
+            paramName = paramName.substr(idx + 1);
+        }
+        iniReader.SetParameter(sectionName, paramName, paramVal);
+        std::cout << "Set [" << sectionName << "]" << paramName << " = " << paramVal << std::endl;
+    }
+
+    switch (vecIndex->GetVectorValueType())
+    {
+#define DefineVectorValueType(Name, Type) \
+    case VectorValueType::Name: \
+        Process<Type>(iniReader, *(vecIndex.get())); \
+        break; \
+
+#include "inc/Core/DefinitionList.h"
+#undef DefineVectorValueType
+
+    default: break;
+    }
+    return 0;
+}
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/src/Server/QueryParser.cpp b/core/src/index/thirdparty/SPTAG/AnnService/src/Server/QueryParser.cpp
new file mode 100644
index 0000000000..0fb47e9390
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/src/Server/QueryParser.cpp
@@ -0,0 +1,209 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Server/QueryParser.h"
+
+#include <cctype>
+#include <cstring>
+
+using namespace SPTAG;
+using namespace SPTAG::Service;
+
+
+const char* QueryParser::c_defaultVectorSeparator = "|";
+
+
+QueryParser::QueryParser()
+    : m_vectorBase64(nullptr),
+      m_vectorBase64Length(0)
+{
+}
+
+
+QueryParser::~QueryParser()
+{
+}
+
+
+ErrorCode
+QueryParser::Parse(const std::string& p_query, const char* p_vectorSeparator)
+{
+    if (p_vectorSeparator == nullptr)
+    {
+        p_vectorSeparator = c_defaultVectorSeparator;
+    }
+
+    m_vectorElements.clear();
+    m_options.clear();
+
+    m_dataHolder = ByteArray::Alloc(p_query.size() + 1);
+    memcpy(m_dataHolder.Data(), p_query.c_str(), p_query.size() + 1);
+
+    enum class State : uint8_t
+    {
+        OptionNameBegin,
+        OptionName,
+        OptionValueBegin,
+        OptionValue,
+        Vector,
+        VectorBase64,
+        None
+    };
+
+    State currState = State::None;
+
+    char* optionName = nullptr;
+    char* vectorStrBegin = nullptr;
+    char* vectorStrEnd = nullptr;
+    SizeType estDimension = 0;
+
+    char* iter = nullptr;
+
+    for (iter = reinterpret_cast<char*>(m_dataHolder.Data()); *iter != '\0'; ++iter)
+    {
+        if (std::isspace(*iter))
+        {
+            *iter = '\0';
+            if (State::Vector == currState)
+            {
+                ++estDimension;
+                vectorStrEnd = iter;
+            }
+            else if (State::VectorBase64 == currState)
+            {
+                m_vectorBase64Length = iter - m_vectorBase64;
+            }
+
+            currState = State::None;
+            continue;
+        }
+
+        switch (currState)
+        {
+        case State::None:
+            if ('$' == *iter)
+            {
+                currState = State::OptionNameBegin;
+            }
+            else if ('#' == *iter)
+            {
+                currState = State::VectorBase64;
+                m_vectorBase64 = iter + 1;
+            }
+            else
+            {
+                currState = State::Vector;
+                vectorStrBegin = iter;
+            }
+
+            break;
+
+        case State::OptionNameBegin:
+            optionName = iter;
+            currState = State::OptionName;
+            break;
+
+        case State::OptionName:
+            if (':' == *iter || '=' == *iter)
+            {
+                *iter = '\0';
+                currState = State::OptionValueBegin;
+            }
+            else if (std::isupper(*iter))
+            {
+                // Convert OptionName to lowercase.
+                *iter = (*iter) | 0x20;
+            }
+
+            break;
+
+        case State::OptionValueBegin:
+            currState = State::OptionValue;
+            m_options.emplace_back(optionName, iter);
+            break;
+
+        case State::Vector:
+            if (std::strchr(p_vectorSeparator, *iter) != nullptr)
+            {
+                ++estDimension;
+                *iter = '\0';
+            }
+
+            break;
+
+        default:
+            break;
+        }
+    }
+
+    if (State::Vector == currState)
+    {
+        ++estDimension;
+        vectorStrEnd = iter;
+    }
+    else if (State::VectorBase64 == currState)
+    {
+        m_vectorBase64Length = iter - m_vectorBase64;
+    }
+
+    if (vectorStrBegin == nullptr || 0 == estDimension)
+    {
+        return ErrorCode::Fail;
+    }
+
+    m_vectorElements.reserve(estDimension);
+    while (vectorStrBegin < vectorStrEnd)
+    {
+        while (vectorStrBegin < vectorStrEnd && '\0' == *vectorStrBegin)
+        {
+            ++vectorStrBegin;
+        }
+
+        if (vectorStrBegin >= vectorStrEnd)
+        {
+            break;
+        }
+
+        m_vectorElements.push_back(vectorStrBegin);
+
+        while (vectorStrBegin < vectorStrEnd && '\0' != *vectorStrBegin)
+        {
+            ++vectorStrBegin;
+        }
+    }
+
+    if (m_vectorElements.empty())
+    {
+        return ErrorCode::Fail;
+    }
+
+    return ErrorCode::Success;
+}
+
+
+const std::vector<const char*>&
+QueryParser::GetVectorElements() const
+{
+    return m_vectorElements;
+}
+
+
+const std::vector<QueryParser::OptionPair>&
+QueryParser::GetOptions() const
+{
+    return m_options;
+}
+
+
+const char*
+QueryParser::GetVectorBase64() const
+{
+    return m_vectorBase64;
+}
+
+
+SizeType
+QueryParser::GetVectorBase64Length() const
+{
+    return m_vectorBase64Length;
+}
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/src/Server/SearchExecutionContext.cpp b/core/src/index/thirdparty/SPTAG/AnnService/src/Server/SearchExecutionContext.cpp
new file mode 100644
index 0000000000..36ff082404
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/src/Server/SearchExecutionContext.cpp
@@ -0,0 +1,220 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Server/SearchExecutionContext.h"
+#include "inc/Helper/StringConvert.h"
+#include "inc/Helper/CommonHelper.h"
+#include "inc/Helper/Base64Encode.h"
+
+using namespace SPTAG;
+using namespace SPTAG::Service;
+
+namespace
+{
+namespace Local
+{
+
+template<typename ValueType>
+ErrorCode
+ConvertVectorFromString(const std::vector<const char*>& p_source, ByteArray& p_dest, SizeType& p_dimension)
+{
+    p_dimension = 0;
+    p_dest = ByteArray::Alloc(p_source.size() * sizeof(ValueType));
+    ValueType* arr = reinterpret_cast<ValueType*>(p_dest.Data());
+    for (std::size_t i = 0; i < p_source.size(); ++i)
+    {
+        if (!Helper::Convert::ConvertStringTo<ValueType>(p_source[i], arr[i]))
+        {
+            p_dest.Clear();
+            p_dimension = 0;
+            return ErrorCode::Fail;
+        }
+
+        ++p_dimension;
+    }
+
+    return ErrorCode::Success;
+}
+
+}
+}
+
+
+SearchExecutionContext::SearchExecutionContext(const std::shared_ptr<const ServiceSettings>& p_serviceSettings)
+    : c_serviceSettings(p_serviceSettings),
+      m_vectorDimension(0),
+      m_inputValueType(VectorValueType::Undefined),
+      m_extractMetadata(false),
+      m_resultNum(p_serviceSettings->m_defaultMaxResultNumber)
+{
+}
+
+
+SearchExecutionContext::~SearchExecutionContext()
+{
+    m_results.clear();
+}
+
+
+ErrorCode
+SearchExecutionContext::ParseQuery(const std::string& p_query)
+{
+    return m_queryParser.Parse(p_query, c_serviceSettings->m_vectorSeparator.c_str());
+}
+
+
+ErrorCode
+SearchExecutionContext::ExtractOption()
+{
+    for (const auto& optionPair : m_queryParser.GetOptions())
+    {
+        if (Helper::StrUtils::StrEqualIgnoreCase(optionPair.first, "indexname"))
+        {
+            const char* begin = optionPair.second;
+            const char* end = optionPair.second;
+            while (*end != '\0')
+            {
+                while (*end != '\0' && *end != ',')
+                {
+                    ++end;
+                }
+
+                if (end != begin)
+                {
+                    m_indexNames.emplace_back(begin, end - begin);
+                }
+
+                if (*end != '\0')
+                {
+                    ++end;
+                    begin = end;
+                }
+            }
+        }
+        else if (Helper::StrUtils::StrEqualIgnoreCase(optionPair.first, "datatype"))
+        {
+            Helper::Convert::ConvertStringTo<VectorValueType>(optionPair.second, m_inputValueType);
+        }
+        else if (Helper::StrUtils::StrEqualIgnoreCase(optionPair.first, "extractmetadata"))
+        {
+            Helper::Convert::ConvertStringTo<bool>(optionPair.second, m_extractMetadata);
+        }
+        else if (Helper::StrUtils::StrEqualIgnoreCase(optionPair.first, "resultnum"))
+        {
+            Helper::Convert::ConvertStringTo<SizeType>(optionPair.second, m_resultNum);
+        }
+    }
+
+    return ErrorCode::Success;
+}
+
+
+ErrorCode
+SearchExecutionContext::ExtractVector(VectorValueType p_targetType)
+{
+    if (!m_queryParser.GetVectorElements().empty())
+    {
+        switch (p_targetType)
+        {
+#define DefineVectorValueType(Name, Type) \
+        case VectorValueType::Name: \
+            return Local::ConvertVectorFromString<Type>( \
+                        m_queryParser.GetVectorElements(), m_vector, m_vectorDimension); \
+            break; \
+
+#include "inc/Core/DefinitionList.h"
+#undef DefineVectorValueType
+
+        default:
+            break;
+        }
+    }
+    else if (m_queryParser.GetVectorBase64() != nullptr
+             && m_queryParser.GetVectorBase64Length() != 0)
+    {
+        SizeType estLen = m_queryParser.GetVectorBase64Length();
+        auto temp = ByteArray::Alloc(Helper::Base64::CapacityForDecode(estLen));
+        std::size_t outLen = 0;
+        if (!Helper::Base64::Decode(m_queryParser.GetVectorBase64(), estLen, temp.Data(), outLen))
+        {
+            return ErrorCode::Fail;
+        }
+
+        if (outLen % GetValueTypeSize(p_targetType) != 0)
+        {
+            return ErrorCode::Fail;
+        }
+
+        m_vectorDimension = outLen / GetValueTypeSize(p_targetType);
+        m_vector = ByteArray(temp.Data(), outLen, temp.DataHolder());
+
+        return ErrorCode::Success;
+    }
+
+    return ErrorCode::Fail;
+}
+
+
+const std::vector<std::string>&
+SearchExecutionContext::GetSelectedIndexNames() const
+{
+    return m_indexNames;
+}
+
+
+void
+SearchExecutionContext::AddResults(std::string p_indexName, QueryResult& p_results)
+{
+    m_results.emplace_back();
+    m_results.back().m_indexName.swap(p_indexName);
+    m_results.back().m_results = p_results;
+}
+
+
+std::vector<SearchResult>&
+SearchExecutionContext::GetResults()
+{
+    return m_results;
+}
+
+
+const std::vector<SearchResult>&
+SearchExecutionContext::GetResults() const
+{
+    return m_results;
+}
+
+
+const ByteArray&
+SearchExecutionContext::GetVector() const
+{
+    return m_vector;
+}
+
+
+const SizeType
+SearchExecutionContext::GetVectorDimension() const
+{
+    return m_vectorDimension;
+}
+
+
+const std::vector<QueryParser::OptionPair>&
+SearchExecutionContext::GetOptions() const
+{
+    return m_queryParser.GetOptions();
+}
+
+
+const SizeType
+SearchExecutionContext::GetResultNum() const
+{
+    return m_resultNum;
+}
+
+
+const bool
+SearchExecutionContext::GetExtractMetadata() const
+{
+    return m_extractMetadata;
+}
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/src/Server/SearchExecutor.cpp b/core/src/index/thirdparty/SPTAG/AnnService/src/Server/SearchExecutor.cpp
new file mode 100644
index 0000000000..2bc3832d88
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/src/Server/SearchExecutor.cpp
@@ -0,0 +1,113 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Server/SearchExecutor.h"
+
+using namespace SPTAG;
+using namespace SPTAG::Service;
+
+
+SearchExecutor::SearchExecutor(std::string p_queryString,
+                               std::shared_ptr<ServiceContext> p_serviceContext,
+                               const CallBack& p_callback)
+    : m_callback(p_callback),
+      c_serviceContext(std::move(p_serviceContext)),
+      m_queryString(std::move(p_queryString))
+{
+}
+
+
+SearchExecutor::~SearchExecutor()
+{
+}
+
+
+void
+SearchExecutor::Execute()
+{
+    ExecuteInternal();
+    if (bool(m_callback))
+    {
+        m_callback(std::move(m_executionContext));
+    }
+}
+
+
+void
+SearchExecutor::ExecuteInternal()
+{
+    m_executionContext.reset(new SearchExecutionContext(c_serviceContext->GetServiceSettings()));
+
+    m_executionContext->ParseQuery(m_queryString);
+    m_executionContext->ExtractOption();
+
+    SelectIndex();
+
+    if (m_selectedIndex.empty())
+    {
+        return;
+    }
+
+    const auto& firstIndex = m_selectedIndex.front();
+
+    if (ErrorCode::Success != m_executionContext->ExtractVector(firstIndex->GetVectorValueType()))
+    {
+        return;
+    }
+
+    if (m_executionContext->GetVectorDimension() != firstIndex->GetFeatureDim())
+    {
+        return;
+    } 
+
+    QueryResult query(m_executionContext->GetVector().Data(),
+                      m_executionContext->GetResultNum(),
+                      m_executionContext->GetExtractMetadata());
+
+    for (const auto& vectorIndex : m_selectedIndex)
+    {
+        if (vectorIndex->GetVectorValueType() != firstIndex->GetVectorValueType()
+            || vectorIndex->GetFeatureDim() != firstIndex->GetFeatureDim())
+        {
+            continue;
+        }
+
+        query.Reset();
+        if (ErrorCode::Success == vectorIndex->SearchIndex(query))
+        {
+            m_executionContext->AddResults(vectorIndex->GetIndexName(), query);
+        }
+    }
+}
+
+
+void
+SearchExecutor::SelectIndex()
+{
+    const auto& indexNames = m_executionContext->GetSelectedIndexNames();
+    const auto& indexMap = c_serviceContext->GetIndexMap();
+    if (indexMap.empty())
+    {
+        return;
+    }
+
+    if (indexNames.empty())
+    {
+        if (indexMap.size() == 1)
+        {
+            m_selectedIndex.push_back(indexMap.begin()->second);
+        }
+    }
+    else
+    {
+        for (const auto& indexName : indexNames)
+        {
+            auto iter = indexMap.find(indexName);
+            if (iter != indexMap.cend())
+            {
+                m_selectedIndex.push_back(iter->second);
+            }
+        }
+    }
+}
+
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/src/Server/SearchService.cpp b/core/src/index/thirdparty/SPTAG/AnnService/src/Server/SearchService.cpp
new file mode 100644
index 0000000000..83096fbcde
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/src/Server/SearchService.cpp
@@ -0,0 +1,262 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Server/SearchService.h"
+#include "inc/Server/SearchExecutor.h"
+#include "inc/Socket/RemoteSearchQuery.h"
+#include "inc/Helper/CommonHelper.h"
+#include "inc/Helper/ArgumentsParser.h"
+
+#include <iostream>
+
+using namespace SPTAG;
+using namespace SPTAG::Service;
+
+
+namespace
+{
+namespace Local
+{
+
+class SerivceCmdOptions : public Helper::ArgumentsParser
+{
+public:
+    SerivceCmdOptions()
+        : m_serveMode("interactive"),
+          m_configFile("AnnService.ini")
+    {
+        AddOptionalOption(m_serveMode, "-m", "--mode", "Service mode, interactive or socket.");
+        AddOptionalOption(m_configFile, "-c", "--config", "Service config file path.");
+    }
+
+    virtual ~SerivceCmdOptions()
+    {
+    }
+
+    std::string m_serveMode;
+
+    std::string m_configFile;
+};
+
+}
+
+} // namespace
+
+
+SearchService::SearchService()
+    : m_initialized(false),
+      m_shutdownSignals(m_ioContext),
+      m_serveMode(ServeMode::Interactive)
+{
+}
+
+
+SearchService::~SearchService()
+{
+}
+
+
+bool
+SearchService::Initialize(int p_argNum, char* p_args[])
+{
+    Local::SerivceCmdOptions cmdOptions;
+    if (!cmdOptions.Parse(p_argNum - 1, p_args + 1))
+    {
+        return false;
+    }
+
+    if (Helper::StrUtils::StrEqualIgnoreCase(cmdOptions.m_serveMode.c_str(), "interactive"))
+    {
+        m_serveMode = ServeMode::Interactive;
+    }
+    else if (Helper::StrUtils::StrEqualIgnoreCase(cmdOptions.m_serveMode.c_str(), "socket"))
+    {
+        m_serveMode = ServeMode::Socket;
+    }
+    else
+    {
+        fprintf(stderr, "Failed parse Serve Mode!\n");
+        return false;
+    }
+
+    m_serviceContext.reset(new ServiceContext(cmdOptions.m_configFile));
+
+    m_initialized = m_serviceContext->IsInitialized();
+
+    return m_initialized;
+}
+
+
+void
+SearchService::Run()
+{
+    if (!m_initialized)
+    {
+        return;
+    }
+
+    switch (m_serveMode)
+    {
+    case ServeMode::Interactive:
+        RunInteractiveMode();
+        break;
+
+    case ServeMode::Socket:
+        RunSocketMode();
+        break;
+
+    default:
+        break;
+    }
+}
+
+
+void
+SearchService::RunSocketMode()
+{
+    auto threadNum = max((SizeType)1, m_serviceContext->GetServiceSettings()->m_threadNum);
+    m_threadPool.reset(new boost::asio::thread_pool(threadNum));
+
+    Socket::PacketHandlerMapPtr handlerMap(new Socket::PacketHandlerMap);
+    handlerMap->emplace(Socket::PacketType::SearchRequest,
+                        [this](Socket::ConnectionID p_srcID, Socket::Packet p_packet)
+                        {
+                            boost::asio::post(*m_threadPool, std::bind(&SearchService::SearchHanlder, this, p_srcID, std::move(p_packet)));
+                        });
+
+    m_socketServer.reset(new Socket::Server(m_serviceContext->GetServiceSettings()->m_listenAddr,
+                                            m_serviceContext->GetServiceSettings()->m_listenPort,
+                                            handlerMap,
+                                            m_serviceContext->GetServiceSettings()->m_socketThreadNum));
+
+    fprintf(stderr,
+            "Start to listen %s:%s ...\n",
+            m_serviceContext->GetServiceSettings()->m_listenAddr.c_str(),
+            m_serviceContext->GetServiceSettings()->m_listenPort.c_str());
+
+    m_shutdownSignals.add(SIGINT);
+    m_shutdownSignals.add(SIGTERM);
+#ifdef SIGQUIT
+    m_shutdownSignals.add(SIGQUIT);
+#endif
+
+    m_shutdownSignals.async_wait([this](boost::system::error_code p_ec, int p_signal)
+                                 {
+                                     fprintf(stderr, "Received shutdown signals.\n");
+                                 });
+
+    m_ioContext.run();
+    fprintf(stderr, "Start shutdown procedure.\n");
+
+    m_socketServer.reset();
+    m_threadPool->stop();
+    m_threadPool->join();
+}
+
+
+void
+SearchService::RunInteractiveMode()
+{
+    const std::size_t bufferSize = 1 << 16;
+    std::unique_ptr<char[]> inputBuffer(new char[bufferSize]);
+    while (true)
+    {
+        std::cout << "Query: ";
+        if (!fgets(inputBuffer.get(), bufferSize, stdin))
+        {
+            break;
+        }
+
+        auto callback = [](std::shared_ptr<SearchExecutionContext> p_exeContext)
+        {
+            std::cout << "Result:" << std::endl;
+            if (nullptr == p_exeContext)
+            {
+                std::cout << "Not Executed." << std::endl;
+                return;
+            }
+
+            const auto& results = p_exeContext->GetResults();
+            for (const auto& result : results)
+            {
+                std::cout << "Index: " << result.m_indexName << std::endl;
+                int idx = 0;
+                for (const auto& res : result.m_results)
+                {
+                    std::cout << "------------------" << std::endl;
+                    std::cout << "DocIndex: " << res.VID << " Distance: " << res.Dist;
+                    if (result.m_results.WithMeta())
+                    {
+                        const auto& metadata = result.m_results.GetMetadata(idx);
+                        std::cout << " MetaData: " << std::string((char*)metadata.Data(), metadata.Length());
+                    } 
+                    std::cout << std::endl;
+                    ++idx;
+                }
+            }
+        };
+
+        SearchExecutor executor(inputBuffer.get(), m_serviceContext, callback);
+        executor.Execute();
+    }
+}
+
+
+void
+SearchService::SearchHanlder(Socket::ConnectionID p_localConnectionID, Socket::Packet p_packet)
+{
+    if (p_packet.Header().m_bodyLength == 0)
+    {
+        return;
+    }
+
+    if (Socket::c_invalidConnectionID == p_packet.Header().m_connectionID)
+    {
+        p_packet.Header().m_connectionID = p_localConnectionID;
+    }
+
+    Socket::RemoteQuery remoteQuery;
+    remoteQuery.Read(p_packet.Body());
+
+    auto callback = std::bind(&SearchService::SearchHanlderCallback,
+                              this,
+                              std::placeholders::_1,
+                              std::move(p_packet));
+
+    SearchExecutor executor(std::move(remoteQuery.m_queryString),
+                            m_serviceContext,
+                            callback);
+    executor.Execute();
+}
+
+
+void
+SearchService::SearchHanlderCallback(std::shared_ptr<SearchExecutionContext> p_exeContext,
+                                     Socket::Packet p_srcPacket)
+{
+    Socket::Packet ret;
+    ret.Header().m_packetType = Socket::PacketType::SearchResponse;
+    ret.Header().m_processStatus = Socket::PacketProcessStatus::Ok;
+    ret.Header().m_connectionID = p_srcPacket.Header().m_connectionID;
+    ret.Header().m_resourceID = p_srcPacket.Header().m_resourceID;
+
+    if (nullptr == p_exeContext)
+    {
+        ret.Header().m_processStatus = Socket::PacketProcessStatus::Failed;
+        ret.AllocateBuffer(0);
+        ret.Header().WriteBuffer(ret.HeaderBuffer());
+    }
+    else
+    {
+        Socket::RemoteSearchResult remoteResult;
+        remoteResult.m_status = Socket::RemoteSearchResult::ResultStatus::Success;
+        remoteResult.m_allIndexResults.swap(p_exeContext->GetResults());
+        ret.AllocateBuffer(static_cast<std::uint32_t>(remoteResult.EstimateBufferSize()));
+        auto bodyEnd = remoteResult.Write(ret.Body());
+        
+        ret.Header().m_bodyLength = static_cast<std::uint32_t>(bodyEnd - ret.Body());
+        ret.Header().WriteBuffer(ret.HeaderBuffer());
+    }
+
+    m_socketServer->SendPacket(p_srcPacket.Header().m_connectionID, std::move(ret), nullptr);
+}
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/src/Server/ServiceContext.cpp b/core/src/index/thirdparty/SPTAG/AnnService/src/Server/ServiceContext.cpp
new file mode 100644
index 0000000000..8d62b2c7af
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/src/Server/ServiceContext.cpp
@@ -0,0 +1,88 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Server/ServiceContext.h"
+#include "inc/Helper/SimpleIniReader.h"
+#include "inc/Helper/CommonHelper.h"
+#include "inc/Helper/StringConvert.h"
+
+using namespace SPTAG;
+using namespace SPTAG::Service;
+
+
+ServiceContext::ServiceContext(const std::string& p_configFilePath)
+    : m_initialized(false)
+{
+    Helper::IniReader iniReader;
+    if (ErrorCode::Success != iniReader.LoadIniFile(p_configFilePath))
+    {
+        return;
+    }
+
+    m_settings.reset(new ServiceSettings);
+
+    m_settings->m_listenAddr = iniReader.GetParameter("Service", "ListenAddr", std::string("0.0.0.0"));
+    m_settings->m_listenPort = iniReader.GetParameter("Service", "ListenPort", std::string("8000"));
+    m_settings->m_threadNum = iniReader.GetParameter("Service", "ThreadNumber", static_cast<std::uint32_t>(8));
+    m_settings->m_socketThreadNum = iniReader.GetParameter("Service", "SocketThreadNumber", static_cast<std::uint32_t>(8));
+
+    m_settings->m_defaultMaxResultNumber = iniReader.GetParameter("QueryConfig", "DefaultMaxResultNumber", static_cast<SizeType>(10));
+    m_settings->m_vectorSeparator = iniReader.GetParameter("QueryConfig", "DefaultSeparator", std::string("|"));
+
+    const std::string emptyStr;
+
+    std::string indexListStr = iniReader.GetParameter("Index", "List", emptyStr);
+    const auto& indexList = Helper::StrUtils::SplitString(indexListStr, ",");
+
+    for (const auto& indexName : indexList)
+    {
+        std::string sectionName("Index_");
+        sectionName += indexName.c_str();
+        if (!iniReader.DoesParameterExist(sectionName, "IndexFolder"))
+        {
+            continue;
+        }
+
+        std::string indexFolder = iniReader.GetParameter(sectionName, "IndexFolder", emptyStr);
+
+        std::shared_ptr<VectorIndex> vectorIndex;
+        if (ErrorCode::Success == VectorIndex::LoadIndex(indexFolder, vectorIndex))
+        {
+            vectorIndex->SetIndexName(indexName);
+            m_fullIndexList.emplace(indexName, vectorIndex);
+        }
+        else
+        {
+            fprintf(stderr, "Failed loading index: %s\n", indexName.c_str());
+        }
+    }
+
+    m_initialized = true;
+}
+
+
+ServiceContext::~ServiceContext()
+{
+
+}
+
+
+const std::map<std::string, std::shared_ptr<VectorIndex>>&
+ServiceContext::GetIndexMap() const
+{
+    return m_fullIndexList;
+}
+
+
+const std::shared_ptr<ServiceSettings>&
+ServiceContext::GetServiceSettings() const
+{
+    return m_settings;
+}
+
+
+bool
+ServiceContext::IsInitialized() const
+{
+    return m_initialized;
+}
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/src/Server/ServiceSettings.cpp b/core/src/index/thirdparty/SPTAG/AnnService/src/Server/ServiceSettings.cpp
new file mode 100644
index 0000000000..d51153195b
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/src/Server/ServiceSettings.cpp
@@ -0,0 +1,14 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Server/ServiceSettings.h"
+
+using namespace SPTAG;
+using namespace SPTAG::Service;
+
+
+ServiceSettings::ServiceSettings()
+    : m_defaultMaxResultNumber(10),
+      m_threadNum(12)
+{
+}
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/src/Server/main.cpp b/core/src/index/thirdparty/SPTAG/AnnService/src/Server/main.cpp
new file mode 100644
index 0000000000..5aa5dc1e59
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/src/Server/main.cpp
@@ -0,0 +1,19 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Server/SearchService.h"
+
+SPTAG::Service::SearchService g_service;
+
+int main(int argc, char* argv[])
+{
+    if (!g_service.Initialize(argc, argv))
+    {
+        return 1;
+    }
+
+    g_service.Run();
+
+    return 0;
+}
+
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/src/Socket/Client.cpp b/core/src/index/thirdparty/SPTAG/AnnService/src/Socket/Client.cpp
new file mode 100644
index 0000000000..9c4101e4f4
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/src/Socket/Client.cpp
@@ -0,0 +1,141 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Socket/Client.h"
+
+#include <limits>
+
+using namespace SPTAG::Socket;
+
+
+Client::Client(const PacketHandlerMapPtr& p_handlerMap,
+               std::size_t p_threadNum,
+               std::uint32_t p_heartbeatIntervalSeconds)
+    : c_requestHandlerMap(p_handlerMap),
+      m_connectionManager(new ConnectionManager),
+      m_deadlineTimer(m_ioContext),
+      m_heartbeatIntervalSeconds(p_heartbeatIntervalSeconds),
+      m_stopped(false)
+{
+    KeepIoContext();
+    m_threadPool.reserve(p_threadNum);
+    for (std::size_t i = 0; i < p_threadNum; ++i)
+    {
+        m_threadPool.emplace_back(std::move(std::thread([this]() { m_ioContext.run(); })));
+    }
+}
+
+
+Client::~Client()
+{
+    m_stopped = true;
+
+    m_deadlineTimer.cancel();
+    m_connectionManager->StopAll();
+    while (!m_ioContext.stopped())
+    {
+        m_ioContext.stop();
+    }
+
+    for (auto& t : m_threadPool)
+    {
+        t.join();
+    }
+}
+
+
+ConnectionID
+Client::ConnectToServer(const std::string& p_address,
+                        const std::string& p_port,
+                        SPTAG::ErrorCode& p_ec)
+{
+    boost::asio::ip::tcp::resolver resolver(m_ioContext);
+
+    boost::system::error_code errCode;
+    auto endPoints = resolver.resolve(p_address, p_port, errCode);
+    if (errCode || endPoints.empty())
+    {
+        p_ec = ErrorCode::Socket_FailedResolveEndPoint;
+        return c_invalidConnectionID;
+    }
+
+    boost::asio::ip::tcp::socket socket(m_ioContext);
+    for (const auto ep : endPoints)
+    {
+        errCode.clear();
+        socket.connect(ep, errCode);
+        if (!errCode)
+        {
+            break;
+        }
+
+        socket.close(errCode);
+    }
+
+    if (socket.is_open())
+    {
+        p_ec = ErrorCode::Success;
+        return m_connectionManager->AddConnection(std::move(socket),
+                                                  c_requestHandlerMap,
+                                                  m_heartbeatIntervalSeconds);
+    }
+
+    p_ec = ErrorCode::Socket_FailedConnectToEndPoint;
+    return c_invalidConnectionID;
+}
+
+
+void 
+Client::AsyncConnectToServer(const std::string& p_address,
+                             const std::string& p_port,
+                             ConnectCallback p_callback)
+{
+    boost::asio::post(m_ioContext,
+                      [this, p_address, p_port, p_callback]()
+    {
+        SPTAG::ErrorCode errCode;
+        auto connID = ConnectToServer(p_address, p_port, errCode);
+        if (bool(p_callback))
+        {
+            p_callback(connID, errCode);
+        }
+    });
+}
+
+
+void
+Client::SendPacket(ConnectionID p_connection, Packet p_packet, std::function<void(bool)> p_callback)
+{
+    auto connection = m_connectionManager->GetConnection(p_connection);
+    if (nullptr != connection)
+    {
+        connection->AsyncSend(std::move(p_packet), std::move(p_callback));
+    }
+    else if (bool(p_callback))
+    {
+        p_callback(false);
+    }
+}
+
+
+void
+Client::SetEventOnConnectionClose(std::function<void(ConnectionID)> p_event)
+{
+    m_connectionManager->SetEventOnRemoving(std::move(p_event));
+}
+
+
+void
+Client::KeepIoContext()
+{
+    if (m_stopped)
+    {
+        return;
+    }
+
+    m_deadlineTimer.expires_from_now(boost::posix_time::hours(24));
+    m_deadlineTimer.async_wait([this](boost::system::error_code p_ec)
+    {
+        this->KeepIoContext();
+    });
+}
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/src/Socket/Common.cpp b/core/src/index/thirdparty/SPTAG/AnnService/src/Socket/Common.cpp
new file mode 100644
index 0000000000..2cfc1178ed
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/src/Socket/Common.cpp
@@ -0,0 +1,11 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Socket/Common.h"
+
+
+using namespace SPTAG::Socket;
+
+const ConnectionID SPTAG::Socket::c_invalidConnectionID = 0;
+
+const ResourceID SPTAG::Socket::c_invalidResourceID = 0;
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/src/Socket/Connection.cpp b/core/src/index/thirdparty/SPTAG/AnnService/src/Socket/Connection.cpp
new file mode 100644
index 0000000000..6e536cbfcf
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/src/Socket/Connection.cpp
@@ -0,0 +1,403 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Socket/Connection.h"
+#include "inc/Socket/ConnectionManager.h"
+
+#include <boost/asio/read.hpp>
+#include <boost/asio/write.hpp>
+#include <boost/asio/bind_executor.hpp>
+#include <boost/asio/placeholders.hpp>
+#include <boost/bind.hpp>
+
+#include <chrono>
+
+using namespace SPTAG::Socket;
+
+Connection::Connection(ConnectionID p_connectionID,
+                       boost::asio::ip::tcp::socket&& p_socket,
+                       const PacketHandlerMapPtr& p_handlerMap,
+                       std::weak_ptr<ConnectionManager> p_connectionManager)
+    : c_connectionID(p_connectionID),
+      c_handlerMap(p_handlerMap),
+      c_connectionManager(std::move(p_connectionManager)),
+      m_socket(std::move(p_socket)),
+      m_strand(p_socket.get_executor().context()),
+      m_heartbeatTimer(p_socket.get_executor().context()),
+      m_remoteConnectionID(c_invalidConnectionID),
+      m_stopped(true),
+      m_heartbeatStarted(false)
+{
+}
+
+
+void
+Connection::Start()
+{
+#ifdef _DEBUG
+    fprintf(stderr, "Connection Start, local: %u, remote: %s:%u\n",
+            static_cast<uint32_t>(m_socket.local_endpoint().port()),
+            m_socket.remote_endpoint().address().to_string().c_str(),
+            static_cast<uint32_t>(m_socket.remote_endpoint().port()));
+#endif
+
+    if (!m_stopped.exchange(false))
+    {
+        return;
+    }
+
+    SendRegister();
+    AsyncReadHeader();
+}
+
+
+void
+Connection::Stop()
+{
+#ifdef _DEBUG
+    fprintf(stderr, "Connection Stop, local: %u, remote: %s:%u\n",
+            static_cast<uint32_t>(m_socket.local_endpoint().port()),
+            m_socket.remote_endpoint().address().to_string().c_str(),
+            static_cast<uint32_t>(m_socket.remote_endpoint().port()));
+#endif
+
+    if (m_stopped.exchange(true))
+    {
+        return;
+    }
+
+    boost::system::error_code errCode;
+    if (m_heartbeatStarted.exchange(false))
+    {
+        m_heartbeatTimer.cancel(errCode);
+    }
+    
+    m_socket.shutdown(boost::asio::ip::tcp::socket::shutdown_both, errCode);
+    m_socket.close(errCode);
+}
+
+
+void
+Connection::StartHeartbeat(std::size_t p_intervalSeconds)
+{
+    if (m_stopped || m_heartbeatStarted.exchange(true))
+    {
+        return;
+    }
+
+    SendHeartbeat(p_intervalSeconds);
+}
+
+
+ConnectionID
+Connection::GetConnectionID() const
+{
+    return c_connectionID;
+}
+
+
+ConnectionID
+Connection::GetRemoteConnectionID() const
+{
+    return m_remoteConnectionID;
+}
+
+
+void
+Connection::AsyncSend(Packet p_packet, std::function<void(bool)> p_callback)
+{
+    if (m_stopped)
+    {
+        if (bool(p_callback))
+        {
+            p_callback(false);
+        }
+
+        return;
+    }
+
+    auto sharedThis = shared_from_this();
+    boost::asio::post(m_strand,
+                      [sharedThis, p_packet, p_callback]()
+                      {
+                          auto handler = [p_callback, p_packet, sharedThis](boost::system::error_code p_ec,
+                                                                            std::size_t p_bytesTransferred)
+                                         {
+                                             if (p_ec && boost::asio::error::operation_aborted != p_ec)
+                                             {
+                                                 sharedThis->OnConnectionFail(p_ec);
+                                             }
+
+                                             if (bool(p_callback))
+                                             {
+                                                 p_callback(!p_ec);
+                                             }
+                                         };
+
+                          boost::asio::async_write(sharedThis->m_socket,
+                                                   boost::asio::buffer(p_packet.Buffer(),
+                                                                       p_packet.BufferLength()),
+                                                   std::move(handler));
+                      });
+}
+
+
+void
+Connection::AsyncReadHeader()
+{
+    if (m_stopped)
+    {
+        return;
+    }
+
+    auto sharedThis = shared_from_this();
+    boost::asio::post(m_strand,
+                      [sharedThis]()
+                      {
+                          auto handler = boost::bind(&Connection::HandleReadHeader,
+                                                     sharedThis,
+                                                     boost::asio::placeholders::error,
+                                                     boost::asio::placeholders::bytes_transferred);
+                  
+                          boost::asio::async_read(sharedThis->m_socket,
+                                                  boost::asio::buffer(sharedThis->m_packetHeaderReadBuffer),
+                                                  std::move(handler));
+                      });
+}
+
+
+void
+Connection::AsyncReadBody()
+{
+    if (m_stopped)
+    {
+        return;
+    }
+
+    auto sharedThis = shared_from_this();
+    boost::asio::post(m_strand,
+                      [sharedThis]()
+                      {
+                          auto handler = boost::bind(&Connection::HandleReadBody,
+                                                     sharedThis,
+                                                     boost::asio::placeholders::error,
+                                                     boost::asio::placeholders::bytes_transferred);
+
+                          boost::asio::async_read(sharedThis->m_socket,
+                                                  boost::asio::buffer(sharedThis->m_packetRead.Body(),
+                                                                      sharedThis->m_packetRead.Header().m_bodyLength),
+                                                  std::move(handler));
+                      });
+}
+
+
+void
+Connection::HandleReadHeader(boost::system::error_code p_ec, std::size_t p_bytesTransferred)
+{
+    if (!p_ec)
+    {
+        m_packetRead.Header().ReadBuffer(m_packetHeaderReadBuffer);
+        if (m_packetRead.Header().m_bodyLength > 0)
+        {
+            m_packetRead.AllocateBuffer(m_packetRead.Header().m_bodyLength);
+            AsyncReadBody();
+        }
+        else
+        {
+            HandleReadBody(p_ec, p_bytesTransferred);
+        }
+
+        return;
+    }
+    else if (boost::asio::error::operation_aborted != p_ec)
+    {
+        OnConnectionFail(p_ec);
+        return;
+    }
+
+    AsyncReadHeader();
+}
+
+
+void
+Connection::HandleReadBody(boost::system::error_code p_ec, std::size_t p_bytesTransferred)
+{
+    if (!p_ec)
+    {
+        bool foundHanlder = true;
+        switch (m_packetRead.Header().m_packetType)
+        {
+        case PacketType::HeartbeatRequest:
+            HandleHeartbeatRequest();
+            break;
+
+        case PacketType::HeartbeatResponse:
+            break;
+
+        case PacketType::RegisterRequest:
+            HandleRegisterRequest();
+            break;
+
+        case PacketType::RegisterResponse:
+            HandleRegisterResponse();
+            break;
+
+        default:
+            foundHanlder = false;
+            break;
+        }
+
+        if (nullptr != c_handlerMap)
+        {
+            auto iter = c_handlerMap->find(m_packetRead.Header().m_packetType);
+            if (c_handlerMap->cend() != iter && bool(iter->second))
+            {
+                (iter->second)(c_connectionID, std::move(m_packetRead));
+                foundHanlder = true;
+            }
+        }
+
+        if (!foundHanlder)
+        {
+            HandleNoHandlerResponse();
+        }
+    }
+    else if (boost::asio::error::operation_aborted != p_ec)
+    {
+        OnConnectionFail(p_ec);
+        return;
+    }
+
+    AsyncReadHeader();
+}
+
+
+void
+Connection::SendHeartbeat(std::size_t p_intervalSeconds)
+{
+    if (m_stopped)
+    {
+        return;
+    }
+
+    Packet msg;
+    msg.Header().m_packetType = PacketType::HeartbeatRequest;
+    msg.Header().m_processStatus = PacketProcessStatus::Ok;
+    msg.Header().m_connectionID = 0;
+    
+    msg.AllocateBuffer(0);
+    msg.Header().WriteBuffer(msg.HeaderBuffer());
+
+    AsyncSend(std::move(msg), nullptr);
+
+    m_heartbeatTimer.expires_from_now(boost::posix_time::seconds(p_intervalSeconds));
+    m_heartbeatTimer.async_wait(boost::bind(&Connection::SendHeartbeat,
+                                            shared_from_this(),
+                                            p_intervalSeconds));
+}
+
+
+void
+Connection::SendRegister()
+{
+    Packet msg;
+    msg.Header().m_packetType = PacketType::RegisterRequest;
+    msg.Header().m_processStatus = PacketProcessStatus::Ok;
+    msg.Header().m_connectionID = 0;
+
+    msg.AllocateBuffer(0);
+    msg.Header().WriteBuffer(msg.HeaderBuffer());
+
+    AsyncSend(std::move(msg), nullptr);
+}
+
+
+void
+Connection::HandleHeartbeatRequest()
+{
+    Packet msg;
+    msg.Header().m_packetType = PacketType::HeartbeatResponse;
+    msg.Header().m_processStatus = PacketProcessStatus::Ok;
+
+    msg.AllocateBuffer(0);
+
+    if (0 == m_packetRead.Header().m_connectionID
+        || c_connectionID == m_packetRead.Header().m_connectionID)
+    {
+        m_packetRead.Header().m_connectionID;
+        msg.Header().WriteBuffer(msg.HeaderBuffer());
+
+        AsyncSend(std::move(msg), nullptr);
+    }
+    else
+    {
+        msg.Header().m_connectionID = m_packetRead.Header().m_connectionID;
+        msg.Header().WriteBuffer(msg.HeaderBuffer());
+
+        auto mgr = c_connectionManager.lock();
+        if (nullptr != mgr)
+        {
+            auto con = mgr->GetConnection(m_packetRead.Header().m_connectionID);
+            if (nullptr != con)
+            {
+                con->AsyncSend(std::move(msg), nullptr);
+            }
+        }
+    }
+}
+
+
+void
+Connection::HandleRegisterRequest()
+{
+    Packet msg;
+    msg.Header().m_packetType = PacketType::RegisterResponse;
+    msg.Header().m_processStatus = PacketProcessStatus::Ok;
+    msg.Header().m_connectionID = c_connectionID;
+    msg.Header().m_resourceID = m_packetRead.Header().m_resourceID;
+
+    msg.AllocateBuffer(0);
+    msg.Header().WriteBuffer(msg.HeaderBuffer());
+
+    AsyncSend(std::move(msg), nullptr);
+}
+
+
+void
+Connection::HandleRegisterResponse()
+{
+    m_remoteConnectionID = m_packetRead.Header().m_connectionID;
+}
+
+
+void
+Connection::HandleNoHandlerResponse()
+{
+    auto packetType = m_packetRead.Header().m_packetType;
+    if (!PacketTypeHelper::IsRequestPacket(packetType))
+    {
+        return;
+    }
+
+    Packet msg;
+    msg.Header().m_packetType = PacketTypeHelper::GetCrosspondingResponseType(packetType);
+    msg.Header().m_processStatus = PacketProcessStatus::Dropped;
+    msg.Header().m_connectionID = c_connectionID;
+    msg.Header().m_resourceID = m_packetRead.Header().m_resourceID;
+
+    msg.AllocateBuffer(0);
+    msg.Header().WriteBuffer(msg.HeaderBuffer());
+
+    AsyncSend(std::move(msg), nullptr);
+}
+
+
+void
+Connection::OnConnectionFail(const boost::system::error_code& p_ec)
+{
+    auto mgr = c_connectionManager.lock();
+    if (nullptr != mgr)
+    {
+        mgr->RemoveConnection(c_connectionID);
+    }
+}
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/src/Socket/ConnectionManager.cpp b/core/src/index/thirdparty/SPTAG/AnnService/src/Socket/ConnectionManager.cpp
new file mode 100644
index 0000000000..9d52dbc8b1
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/src/Socket/ConnectionManager.cpp
@@ -0,0 +1,133 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Socket/ConnectionManager.h"
+
+using namespace SPTAG::Socket;
+
+
+ConnectionManager::ConnectionItem::ConnectionItem()
+    : m_isEmpty(true)
+{
+}
+
+
+ConnectionManager::ConnectionManager()
+    : m_nextConnectionID(1),
+      m_connectionCount(0)
+{
+}
+
+
+ConnectionID
+ConnectionManager::AddConnection(boost::asio::ip::tcp::socket&& p_socket,
+                                 const PacketHandlerMapPtr& p_handler,
+                                 std::uint32_t p_heartbeatIntervalSeconds)
+{
+    ConnectionID currID = m_nextConnectionID.fetch_add(1);
+    while (c_invalidConnectionID == currID || !m_connections[GetPosition(currID)].m_isEmpty.exchange(false))
+    {
+        if (m_connectionCount >= c_connectionPoolSize)
+        {
+            return c_invalidConnectionID;
+        }
+
+        currID = m_nextConnectionID.fetch_add(1);
+    }
+
+    ++m_connectionCount;
+
+    auto connection = std::make_shared<Connection>(currID,
+                                                   std::move(p_socket),
+                                                   p_handler,
+                                                   std::weak_ptr<ConnectionManager>(shared_from_this()));
+
+    {
+        Helper::Concurrent::LockGuard<Helper::Concurrent::SpinLock> guard(m_spinLock);
+        m_connections[GetPosition(currID)].m_connection = connection;
+    }
+
+    connection->Start();
+    if (p_heartbeatIntervalSeconds > 0)
+    {
+        connection->StartHeartbeat(p_heartbeatIntervalSeconds);
+    }
+
+    return currID;
+}
+
+
+void
+ConnectionManager::RemoveConnection(ConnectionID p_connectionID)
+{
+    auto position = GetPosition(p_connectionID);
+    if (m_connections[position].m_isEmpty.exchange(true))
+    {
+        return;
+    }
+
+    Connection::Ptr conn;
+
+    {
+        Helper::Concurrent::LockGuard<Helper::Concurrent::SpinLock> guard(m_spinLock);
+        conn = std::move(m_connections[position].m_connection);
+    }
+
+    --m_connectionCount;
+
+    conn->Stop();
+    conn.reset();
+
+    if (bool(m_eventOnRemoving))
+    {
+        m_eventOnRemoving(p_connectionID);
+    }
+}
+
+
+Connection::Ptr
+ConnectionManager::GetConnection(ConnectionID p_connectionID)
+{
+    auto position = GetPosition(p_connectionID);
+    Connection::Ptr ret;
+
+    {
+        Helper::Concurrent::LockGuard<Helper::Concurrent::SpinLock> guard(m_spinLock);
+        ret = m_connections[position].m_connection;
+    }
+
+    if (nullptr == ret || ret->GetConnectionID() != p_connectionID)
+    {
+        return nullptr;
+    }
+
+    return ret;
+}
+
+
+void
+ConnectionManager::SetEventOnRemoving(std::function<void(ConnectionID)> p_event)
+{
+    m_eventOnRemoving = std::move(p_event);
+}
+
+
+void
+ConnectionManager::StopAll()
+{
+    Helper::Concurrent::LockGuard<Helper::Concurrent::SpinLock> guard(m_spinLock);
+    for (auto& connection : m_connections)
+    {
+        if (nullptr != connection.m_connection)
+        {
+            connection.m_connection->Stop();
+        }
+    }
+}
+
+
+std::uint32_t
+ConnectionManager::GetPosition(ConnectionID p_connectionID)
+{
+    return static_cast<std::uint32_t>(p_connectionID) & c_connectionPoolMask;
+}
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/src/Socket/Packet.cpp b/core/src/index/thirdparty/SPTAG/AnnService/src/Socket/Packet.cpp
new file mode 100644
index 0000000000..335400bbd8
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/src/Socket/Packet.cpp
@@ -0,0 +1,177 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Socket/Packet.h"
+#include "inc/Socket/SimpleSerialization.h"
+
+#include <type_traits>
+
+using namespace SPTAG::Socket;
+
+PacketHeader::PacketHeader()
+    : m_packetType(PacketType::Undefined),
+      m_processStatus(PacketProcessStatus::Ok),
+      m_bodyLength(0),
+      m_connectionID(c_invalidConnectionID),
+      m_resourceID(c_invalidResourceID)
+{
+}
+
+
+PacketHeader::PacketHeader(PacketHeader&& p_right)
+    : m_packetType(std::move(p_right.m_packetType)),
+      m_processStatus(std::move(p_right.m_processStatus)),
+      m_bodyLength(std::move(p_right.m_bodyLength)),
+      m_connectionID(std::move(p_right.m_connectionID)),
+      m_resourceID(std::move(p_right.m_resourceID))
+{
+}
+
+
+PacketHeader::PacketHeader(const PacketHeader& p_right)
+    : m_packetType(p_right.m_packetType),
+      m_processStatus(p_right.m_processStatus),
+      m_bodyLength(p_right.m_bodyLength),
+      m_connectionID(p_right.m_connectionID),
+      m_resourceID(p_right.m_resourceID)
+{
+}
+
+
+std::size_t
+PacketHeader::WriteBuffer(std::uint8_t* p_buffer)
+{
+    std::uint8_t* buff = p_buffer;
+    buff = SimpleSerialization::SimpleWriteBuffer(m_packetType, buff);
+    buff = SimpleSerialization::SimpleWriteBuffer(m_processStatus, buff);
+    buff = SimpleSerialization::SimpleWriteBuffer(m_bodyLength, buff);
+    buff = SimpleSerialization::SimpleWriteBuffer(m_connectionID, buff);
+    buff = SimpleSerialization::SimpleWriteBuffer(m_resourceID, buff);
+
+    return p_buffer - buff;
+}
+
+
+void
+PacketHeader::ReadBuffer(const std::uint8_t* p_buffer)
+{
+    const std::uint8_t* buff = p_buffer;
+    buff = SimpleSerialization::SimpleReadBuffer(buff, m_packetType);
+    buff = SimpleSerialization::SimpleReadBuffer(buff, m_processStatus);
+    buff = SimpleSerialization::SimpleReadBuffer(buff, m_bodyLength);
+    buff = SimpleSerialization::SimpleReadBuffer(buff, m_connectionID);
+    buff = SimpleSerialization::SimpleReadBuffer(buff, m_resourceID);
+}
+
+
+Packet::Packet()
+{
+}
+
+
+Packet::Packet(Packet&& p_right)
+    : m_header(std::move(p_right.m_header)),
+      m_buffer(std::move(p_right.m_buffer)),
+      m_bufferCapacity(std::move(p_right.m_bufferCapacity))
+{
+}
+
+
+Packet::Packet(const Packet& p_right)
+    : m_header(p_right.m_header),
+      m_buffer(p_right.m_buffer),
+      m_bufferCapacity(p_right.m_bufferCapacity)
+{
+}
+
+
+PacketHeader&
+Packet::Header()
+{
+    return m_header;
+}
+
+
+std::uint8_t*
+Packet::HeaderBuffer() const
+{
+    return m_buffer.get();
+}
+
+
+std::uint8_t*
+Packet::Body() const
+{
+    if (nullptr != m_buffer && PacketHeader::c_bufferSize < m_bufferCapacity)
+    {
+        return m_buffer.get() + PacketHeader::c_bufferSize;
+    }
+
+    return nullptr;
+}
+
+
+std::uint8_t*
+Packet::Buffer() const
+{
+    return m_buffer.get();
+}
+
+
+std::uint32_t
+Packet::BufferLength() const
+{
+    return PacketHeader::c_bufferSize + m_header.m_bodyLength;
+}
+
+
+std::uint32_t
+Packet::BufferCapacity() const
+{
+    return m_bufferCapacity;
+}
+
+
+void
+Packet::AllocateBuffer(std::uint32_t p_bodyCapacity)
+{
+    m_bufferCapacity = PacketHeader::c_bufferSize + p_bodyCapacity;
+    m_buffer.reset(new std::uint8_t[m_bufferCapacity], std::default_delete<std::uint8_t[]>());
+}
+
+
+bool
+PacketTypeHelper::IsRequestPacket(PacketType p_type)
+{
+    if (PacketType::Undefined == p_type || PacketType::ResponseMask == p_type)
+    {
+        return false;
+    }
+
+    return (static_cast<std::uint8_t>(p_type) & static_cast<std::uint8_t>(PacketType::ResponseMask)) == 0;
+}
+
+
+bool
+PacketTypeHelper::IsResponsePacket(PacketType p_type)
+{
+    if (PacketType::Undefined == p_type || PacketType::ResponseMask == p_type)
+    {
+        return false;
+    }
+
+    return (static_cast<std::uint8_t>(p_type) & static_cast<std::uint8_t>(PacketType::ResponseMask)) != 0;
+}
+
+
+PacketType
+PacketTypeHelper::GetCrosspondingResponseType(PacketType p_type)
+{
+    if (PacketType::Undefined == p_type || PacketType::ResponseMask == p_type)
+    {
+        return PacketType::Undefined;
+    }
+
+    auto ret = static_cast<std::uint8_t>(p_type) | static_cast<std::uint8_t>(PacketType::ResponseMask);
+    return static_cast<PacketType>(ret);
+}
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/src/Socket/RemoteSearchQuery.cpp b/core/src/index/thirdparty/SPTAG/AnnService/src/Socket/RemoteSearchQuery.cpp
new file mode 100644
index 0000000000..2cb450328e
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/src/Socket/RemoteSearchQuery.cpp
@@ -0,0 +1,210 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Socket/RemoteSearchQuery.h"
+#include "inc/Socket/SimpleSerialization.h"
+
+using namespace SPTAG;
+using namespace SPTAG::Socket;
+
+
+RemoteQuery::RemoteQuery()
+    : m_type(QueryType::String)
+{
+}
+
+
+std::size_t
+RemoteQuery::EstimateBufferSize() const
+{
+    std::size_t sum = 0;
+    sum += SimpleSerialization::EstimateBufferSize(MajorVersion());
+    sum += SimpleSerialization::EstimateBufferSize(MirrorVersion());
+    sum += SimpleSerialization::EstimateBufferSize(m_type);
+    sum += SimpleSerialization::EstimateBufferSize(m_queryString);
+
+    return sum;
+}
+
+
+std::uint8_t*
+RemoteQuery::Write(std::uint8_t* p_buffer) const
+{
+    p_buffer = SimpleSerialization::SimpleWriteBuffer(MajorVersion(), p_buffer);
+    p_buffer = SimpleSerialization::SimpleWriteBuffer(MirrorVersion(), p_buffer);
+
+    p_buffer = SimpleSerialization::SimpleWriteBuffer(m_type, p_buffer);
+    p_buffer = SimpleSerialization::SimpleWriteBuffer(m_queryString, p_buffer);
+
+    return p_buffer;
+}
+
+
+const std::uint8_t*
+RemoteQuery::Read(const std::uint8_t* p_buffer)
+{
+    decltype(MajorVersion()) majorVer = 0;
+    decltype(MirrorVersion()) mirrorVer = 0;
+
+    p_buffer = SimpleSerialization::SimpleReadBuffer(p_buffer, majorVer);
+    p_buffer = SimpleSerialization::SimpleReadBuffer(p_buffer, mirrorVer);
+    if (majorVer != MajorVersion())
+    {
+        return nullptr;
+    }
+
+    p_buffer = SimpleSerialization::SimpleReadBuffer(p_buffer, m_type);
+    p_buffer = SimpleSerialization::SimpleReadBuffer(p_buffer, m_queryString);
+
+    return p_buffer;
+}
+
+
+RemoteSearchResult::RemoteSearchResult()
+    : m_status(ResultStatus::Timeout)
+{
+}
+
+
+RemoteSearchResult::RemoteSearchResult(const RemoteSearchResult& p_right)
+    : m_status(p_right.m_status),
+      m_allIndexResults(p_right.m_allIndexResults)
+{
+}
+
+
+RemoteSearchResult::RemoteSearchResult(RemoteSearchResult&& p_right)
+    : m_status(std::move(p_right.m_status)),
+      m_allIndexResults(std::move(p_right.m_allIndexResults))
+{
+}
+
+
+RemoteSearchResult&
+RemoteSearchResult::operator=(RemoteSearchResult&& p_right)
+{
+    m_status = p_right.m_status;
+    m_allIndexResults = std::move(p_right.m_allIndexResults);
+
+    return *this;
+}
+
+
+std::size_t
+RemoteSearchResult::EstimateBufferSize() const
+{
+    std::size_t sum = 0;
+    sum += SimpleSerialization::EstimateBufferSize(MajorVersion());
+    sum += SimpleSerialization::EstimateBufferSize(MirrorVersion());
+
+    sum += SimpleSerialization::EstimateBufferSize(m_status);
+
+    sum += sizeof(std::uint32_t);
+    for (const auto& indexRes : m_allIndexResults)
+    {
+        sum += SimpleSerialization::EstimateBufferSize(indexRes.m_indexName);
+        sum += sizeof(std::uint32_t);
+        sum += sizeof(bool);
+
+        for (const auto& res : indexRes.m_results)
+        {
+            sum += SimpleSerialization::EstimateBufferSize(res.VID);
+            sum += SimpleSerialization::EstimateBufferSize(res.Dist);
+        }
+
+        if (indexRes.m_results.WithMeta())
+        {
+            for (int i = 0; i < indexRes.m_results.GetResultNum(); ++i)
+            {
+                sum += SimpleSerialization::EstimateBufferSize(indexRes.m_results.GetMetadata(i));
+            }
+        }
+    }
+
+    return sum;
+}
+
+
+std::uint8_t*
+RemoteSearchResult::Write(std::uint8_t* p_buffer) const
+{
+    p_buffer = SimpleSerialization::SimpleWriteBuffer(MajorVersion(), p_buffer);
+    p_buffer = SimpleSerialization::SimpleWriteBuffer(MirrorVersion(), p_buffer);
+
+    p_buffer = SimpleSerialization::SimpleWriteBuffer(m_status, p_buffer);
+    p_buffer = SimpleSerialization::SimpleWriteBuffer(static_cast<std::uint32_t>(m_allIndexResults.size()), p_buffer);
+    for (const auto& indexRes : m_allIndexResults)
+    {
+        p_buffer = SimpleSerialization::SimpleWriteBuffer(indexRes.m_indexName, p_buffer);
+
+        p_buffer = SimpleSerialization::SimpleWriteBuffer(static_cast<std::uint32_t>(indexRes.m_results.GetResultNum()), p_buffer);
+        p_buffer = SimpleSerialization::SimpleWriteBuffer(indexRes.m_results.WithMeta(), p_buffer);
+
+        for (const auto& res : indexRes.m_results)
+        {
+            p_buffer = SimpleSerialization::SimpleWriteBuffer(res.VID, p_buffer);
+            p_buffer = SimpleSerialization::SimpleWriteBuffer(res.Dist, p_buffer);
+        }
+
+        if (indexRes.m_results.WithMeta())
+        {
+            for (int i = 0; i < indexRes.m_results.GetResultNum(); ++i)
+            {
+                p_buffer = SimpleSerialization::SimpleWriteBuffer(indexRes.m_results.GetMetadata(i), p_buffer);
+            }
+        }
+    }
+
+    return p_buffer;
+}
+
+
+const std::uint8_t*
+RemoteSearchResult::Read(const std::uint8_t* p_buffer)
+{
+    decltype(MajorVersion()) majorVer = 0;
+    decltype(MirrorVersion()) mirrorVer = 0;
+
+    p_buffer = SimpleSerialization::SimpleReadBuffer(p_buffer, majorVer);
+    p_buffer = SimpleSerialization::SimpleReadBuffer(p_buffer, mirrorVer);
+    if (majorVer != MajorVersion())
+    {
+        return nullptr;
+    }
+
+    p_buffer = SimpleSerialization::SimpleReadBuffer(p_buffer, m_status);
+
+    std::uint32_t len = 0;
+    p_buffer = SimpleSerialization::SimpleReadBuffer(p_buffer, len);
+    m_allIndexResults.resize(len);
+
+    for (auto& indexRes : m_allIndexResults)
+    {
+        p_buffer = SimpleSerialization::SimpleReadBuffer(p_buffer, indexRes.m_indexName);
+
+        std::uint32_t resNum = 0;
+        p_buffer = SimpleSerialization::SimpleReadBuffer(p_buffer, resNum);
+
+        bool withMeta = false;
+        p_buffer = SimpleSerialization::SimpleReadBuffer(p_buffer, withMeta);
+
+        indexRes.m_results.Init(nullptr, resNum, withMeta);
+        for (auto& res : indexRes.m_results)
+        {
+            p_buffer = SimpleSerialization::SimpleReadBuffer(p_buffer, res.VID);
+            p_buffer = SimpleSerialization::SimpleReadBuffer(p_buffer, res.Dist);
+        }
+
+        if (withMeta)
+        {
+            for (int i = 0; i < indexRes.m_results.GetResultNum(); ++i)
+            {
+                ByteArray meta;
+                p_buffer = SimpleSerialization::SimpleReadBuffer(p_buffer, meta);
+                indexRes.m_results.SetMetadata(i, std::move(meta));
+            }
+        }
+    }
+
+    return p_buffer;
+}
diff --git a/core/src/index/thirdparty/SPTAG/AnnService/src/Socket/Server.cpp b/core/src/index/thirdparty/SPTAG/AnnService/src/Socket/Server.cpp
new file mode 100644
index 0000000000..86d60040bf
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/AnnService/src/Socket/Server.cpp
@@ -0,0 +1,136 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Socket/Server.h"
+
+#include <exception>
+
+using namespace SPTAG::Socket;
+
+Server::Server(const std::string& p_address,
+               const std::string& p_port,
+               const PacketHandlerMapPtr& p_handlerMap,
+               std::size_t p_threadNum)
+    : m_requestHandlerMap(p_handlerMap),
+      m_connectionManager(new ConnectionManager),
+      m_acceptor(m_ioContext)
+{
+    boost::asio::ip::tcp::resolver resolver(m_ioContext);
+
+    boost::system::error_code errCode;
+    auto endPoints = resolver.resolve(p_address, p_port, errCode);
+    if (errCode)
+    {
+        fprintf(stderr,
+                "Failed to resolve %s %s, error: %s",
+                p_address.c_str(),
+                p_port.c_str(),
+                errCode.message().c_str());
+
+        throw std::runtime_error("Failed to resolve address.");
+    }
+
+    boost::asio::ip::tcp::endpoint endpoint = *(endPoints.begin());
+    m_acceptor.open(endpoint.protocol());
+    m_acceptor.set_option(boost::asio::ip::tcp::acceptor::reuse_address(false));
+
+    m_acceptor.bind(endpoint, errCode);
+    if (errCode)
+    {
+        fprintf(stderr,
+                "Failed to bind %s %s, error: %s",
+                p_address.c_str(),
+                p_port.c_str(),
+                errCode.message().c_str());
+
+        throw std::runtime_error("Failed to bind port.");
+    }
+
+    m_acceptor.listen(boost::asio::socket_base::max_listen_connections, errCode);
+    if (errCode)
+    {
+        fprintf(stderr,
+                "Failed to listen %s %s, error: %s",
+                p_address.c_str(),
+                p_port.c_str(),
+                errCode.message().c_str());
+
+        throw std::runtime_error("Failed to listen port.");
+    }
+
+    StartAccept();
+ 
+    m_threadPool.reserve(p_threadNum);
+    for (std::size_t i = 0; i < p_threadNum; ++i)
+    {
+        m_threadPool.emplace_back(std::move(std::thread([this]() { StartListen(); })));
+    }
+}
+
+
+Server::~Server()
+{
+    m_acceptor.close();
+    m_connectionManager->StopAll();
+    while (!m_ioContext.stopped())
+    {
+        m_ioContext.stop();
+    }
+
+    for (auto& t : m_threadPool)
+    {
+        t.join();
+    }
+}
+
+
+void
+Server::SetEventOnConnectionClose(std::function<void(ConnectionID)> p_event)
+{
+    m_connectionManager->SetEventOnRemoving(std::move(p_event));
+}
+
+
+void
+Server::StartAccept()
+{
+    m_acceptor.async_accept([this](boost::system::error_code p_ec,
+                                   boost::asio::ip::tcp::socket p_socket)
+                            {
+                                if (!m_acceptor.is_open())
+                                {
+                                    return;
+                                }
+
+                                if (!p_ec)
+                                {
+                                    m_connectionManager->AddConnection(std::move(p_socket),
+                                                                       m_requestHandlerMap,
+                                                                       0);
+                                }
+
+                                StartAccept();
+                            });
+}
+
+
+void
+Server::StartListen()
+{
+    m_ioContext.run();
+}
+
+
+void
+Server::SendPacket(ConnectionID p_connection, Packet p_packet, std::function<void(bool)> p_callback)
+{
+    auto connection = m_connectionManager->GetConnection(p_connection);
+    if (nullptr != connection)
+    {
+        connection->AsyncSend(std::move(p_packet), std::move(p_callback));
+    }
+    else if (bool(p_callback))
+    {
+        p_callback(false);
+    }
+}
diff --git a/core/src/index/thirdparty/SPTAG/CMakeLists.txt b/core/src/index/thirdparty/SPTAG/CMakeLists.txt
new file mode 100644
index 0000000000..44544bf7e9
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/CMakeLists.txt
@@ -0,0 +1,91 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+
+cmake_minimum_required (VERSION 3.12)
+
+project (SPTAGLib)
+
+function(CXX_COMPILER_DUMPVERSION _OUTPUT_VERSION)
+  exec_program(${CMAKE_CXX_COMPILER}
+    ARGS ${CMAKE_CXX_COMPILER_ARG1} -dumpversion
+    OUTPUT_VARIABLE COMPILER_VERSION
+  )
+
+  set(${_OUTPUT_VERSION} ${COMPILER_VERSION} PARENT_SCOPE)
+endfunction()
+
+if(NOT WIN32)
+    CXX_COMPILER_DUMPVERSION(CXX_COMPILER_VERSION)
+endif()
+
+if(${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU")
+    # require at least gcc 5.0
+    if (CXX_COMPILER_VERSION VERSION_LESS 5.0)
+        message(FATAL_ERROR "GCC version must be at least 5.0!")
+    endif()
+    set (CMAKE_CXX_FLAGS_RELEASE "-Wall -Wunreachable-code -Wno-reorder -Wno-sign-compare -Wno-unknown-pragmas -Wcast-align -lm -lrt -DNDEBUG -std=c++14 -fopenmp -march=native")
+    set (CMAKE_CXX_FLAGS_DEBUG   "-Wall -Wunreachable-code -Wno-reorder -Wno-sign-compare -Wno-unknown-pragmas -Wcast-align -ggdb -lm -lrt -DNDEBUG -std=c++14 -fopenmp -march=native")
+elseif(WIN32)
+    if(NOT MSVC14)
+         message(FATAL_ERROR "On Windows, only MSVC version 14 are supported!") 
+    endif()
+else ()
+    message(FATAL_ERROR "Unrecognized compiler (use GCC or MSVC)!")
+endif()
+
+if (NOT CMAKE_BUILD_TYPE)
+    set (CMAKE_BUILD_TYPE Release CACHE STRING "Build types: Release Debug" FORCE)
+endif()
+message (STATUS "Build type: ${CMAKE_BUILD_TYPE}")
+
+if (${CMAKE_SIZEOF_VOID_P} EQUAL "8")
+    set (PROJECTNAME_ARCHITECTURE "x64")
+else ()
+    set (PROJECTNAME_ARCHITECTURE "x86")
+endif ()
+message (STATUS "Platform type: ${PROJECTNAME_ARCHITECTURE}")
+
+set(Boost_USE_MULTITHREADED ON)
+
+if (WIN32)
+    set(Boost_USE_STATIC_LIBS ON)
+
+    set(CMAKE_CONFIGURATION_TYPES ${CMAKE_BUILD_TYPE})
+    set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
+    set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
+    set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
+
+    set (LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR}/${CMAKE_CFG_INTDIR})
+    set (EXECUTABLE_OUTPUT_PATH ${CMAKE_BINARY_DIR}/${CMAKE_CFG_INTDIR})
+else()
+    set (LIBRARY_OUTPUT_PATH "${PROJECT_SOURCE_DIR}/${CMAKE_BUILD_TYPE}/")
+    set (EXECUTABLE_OUTPUT_PATH "${PROJECT_SOURCE_DIR}/${CMAKE_BUILD_TYPE}/")
+endif()
+
+set (CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR})
+
+find_package(OpenMP)
+if (OpenMP_FOUND)
+    set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OpenMP_C_FLAGS}")
+    set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
+    set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${OpenMP_EXE_LINKER_FLAGS}")
+    message (STATUS "Found openmp.")
+else()
+    message (FATAL_ERROR "Could no find openmp!")
+endif()
+
+find_package(Boost 1.67 COMPONENTS system thread serialization wserialization regex)
+if (Boost_FOUND)
+    include_directories (${Boost_INCLUDE_DIR})
+    link_directories (${Boost_LIBRARY_DIR} "/usr/lib")
+    message (STATUS "Found Boost.")
+    message (STATUS "Include Path: ${Boost_INCLUDE_DIRS}")
+    message (STATUS "Library Path: ${Boost_LIBRARY_DIRS}")
+    message (STATUS "Library: ${Boost_LIBRARIES}")
+else()
+    message (FATAL_ERROR "Could not find Boost 1.67!")
+endif()
+
+add_subdirectory (AnnService)
+add_subdirectory (Wrappers)
+add_subdirectory (Test)
diff --git a/core/src/index/thirdparty/SPTAG/Dockerfile b/core/src/index/thirdparty/SPTAG/Dockerfile
new file mode 100644
index 0000000000..7c1acd25e4
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/Dockerfile
@@ -0,0 +1,31 @@
+FROM ubuntu:18.04
+
+WORKDIR /app
+COPY CMakeLists.txt ./
+COPY AnnService ./AnnService/
+COPY Test ./Test/
+COPY Wrappers ./Wrappers/
+
+RUN apt-get update && apt-get -y install wget build-essential \
+    # remove the following if you don't want to build the wrappers
+    openjdk-8-jdk python3-pip swig
+
+# cmake >= 3.12 is required
+RUN wget "https://github.com/Kitware/CMake/releases/download/v3.14.4/cmake-3.14.4-Linux-x86_64.tar.gz" -q -O - \
+        | tar -xz --strip-components=1 -C /usr/local
+
+# specific version of boost
+RUN wget "https://dl.bintray.com/boostorg/release/1.67.0/source/boost_1_67_0.tar.gz" -q -O - \
+        | tar -xz && \
+        cd boost_1_67_0 && \
+        ./bootstrap.sh && \
+        ./b2 install && \
+        # update ld cache so it finds boost in /usr/local/lib
+        ldconfig && \
+        cd .. && rm -rf boost_1_67_0
+
+# build
+RUN mkdir build && cd build && cmake .. && make && cd ..
+
+# so python can find the SPTAG module
+ENV PYTHONPATH=/app/Release
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/LICENSE b/core/src/index/thirdparty/SPTAG/LICENSE
new file mode 100644
index 0000000000..d1ca00f20a
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/LICENSE
@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation. All rights reserved.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/README.md b/core/src/index/thirdparty/SPTAG/README.md
new file mode 100644
index 0000000000..ae4f0aab9b
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/README.md
@@ -0,0 +1,144 @@
+# SPTAG: A library for fast approximate nearest neighbor search
+
+[![MIT licensed](https://img.shields.io/badge/license-MIT-yellow.svg)](https://github.com/Microsoft/SPTAG/blob/master/LICENSE)
+[![Build status](https://sysdnn.visualstudio.com/SPTAG/_apis/build/status/SPTAG-GITHUB)](https://sysdnn.visualstudio.com/SPTAG/_build/latest?definitionId=2)
+
+## **SPTAG**
+ SPTAG (Space Partition Tree And Graph) is a library for large scale vector approximate nearest neighbor search scenario released by [Microsoft Research (MSR)](https://www.msra.cn/) and [Microsoft Bing](http://bing.com). 
+
+ <p align="center">
+ <img src="docs/img/sptag.png" alt="architecture" width="500"/>
+ </p>
+
+
+
+## **Introduction**
+ 
+This library assumes that the samples are represented as vectors and that the vectors can be compared by L2 distances or cosine distances. 
+Vectors returned for a query vector are the vectors that have smallest L2 distance or cosine distances with the query vector. 
+
+SPTAG provides two methods: kd-tree and relative neighborhood graph (SPTAG-KDT) 
+and balanced k-means tree and relative neighborhood graph (SPTAG-BKT).
+SPTAG-KDT is advantageous in index building cost, and SPTAG-BKT is advantageous in search accuracy in very high-dimensional data.
+
+
+
+## **How it works**
+
+SPTAG is inspired by the NGS approach [[WangL12](#References)]. It contains two basic modules: index builder and searcher. 
+The RNG is built on the k-nearest neighborhood graph [[WangWZTG12](#References), [WangWJLZZH14](#References)] 
+for boosting the connectivity. Balanced k-means trees are used to replace kd-trees to avoid the inaccurate distance bound estimation in kd-trees for very high-dimensional vectors.
+The search begins with the search in the space partition trees for 
+finding several seeds to start the search in the RNG. 
+The searches in the trees and the graph are iteratively conducted. 
+
+ ## **Highlights**
+  * Fresh update: Support online vector deletion and insertion
+  * Distributed serving: Search over multiple machines
+
+ ## **Build**
+
+### **Requirements**
+
+* swig >= 3.0
+* cmake >= 3.12.0
+* boost >= 1.67.0
+
+### **Install**
+
+> For Linux:
+```bash
+mkdir build
+cd build && cmake .. && make
+```
+It will generate a Release folder in the code directory which contains all the build targets.
+
+> For Windows:
+```bash
+mkdir build
+cd build && cmake -A x64 ..
+```
+It will generate a SPTAGLib.sln in the build directory. 
+Compiling the ALL_BUILD project in the Visual Studio (at least 2015) will generate a Release directory which contains all the build targets.
+
+> Using Docker:
+```bash
+docker build -t sptag .
+```
+Will build a docker container with binaries in `/app/Release/`.
+
+### **Verify** 
+
+Run the test (or Test.exe) in the Release folder to verify all the tests have passed.
+
+### **Usage**
+
+The detailed usage can be found in [Get started](docs/GettingStart.md).
+The detailed parameters tunning can be found in [Parameters](docs/Parameters.md).
+
+## **References**
+Please cite SPTAG in your publications if it helps your research:
+```
+@manual{ChenW18,
+  author    = {Qi Chen and
+               Haidong Wang and
+               Mingqin Li and 
+               Gang Ren and
+               Scarlett Li and
+               Jeffery Zhu and
+               Jason Li and
+               Chuanjie Liu and
+               Lintao Zhang and
+               Jingdong Wang},
+  title     = {SPTAG: A library for fast approximate nearest neighbor search},
+  url       = {https://github.com/Microsoft/SPTAG},
+  year      = {2018}
+}
+
+@inproceedings{WangL12,
+  author    = {Jingdong Wang and
+               Shipeng Li},
+  title     = {Query-driven iterated neighborhood graph search for large scale indexing},
+  booktitle = {ACM Multimedia 2012},
+  pages     = {179--188},
+  year      = {2012}
+}
+
+@inproceedings{WangWZTGL12,
+  author    = {Jing Wang and
+               Jingdong Wang and
+               Gang Zeng and
+               Zhuowen Tu and
+               Rui Gan and
+               Shipeng Li},
+  title     = {Scalable k-NN graph construction for visual descriptors},
+  booktitle = {CVPR 2012},
+  pages     = {1106--1113},
+  year      = {2012}
+}
+
+@article{WangWJLZZH14,
+  author    = {Jingdong Wang and
+               Naiyan Wang and
+               You Jia and
+               Jian Li and
+               Gang Zeng and
+               Hongbin Zha and
+               Xian{-}Sheng Hua},
+  title     = {Trinary-Projection Trees for Approximate Nearest Neighbor Search},
+  journal   = {{IEEE} Trans. Pattern Anal. Mach. Intell.},
+  volume    = {36},
+  number    = {2},
+  pages     = {388--403},
+  year      = {2014
+}
+```
+
+## **Contribute**
+
+This project welcomes contributions and suggestions from all the users.
+
+We use [GitHub issues](https://github.com/Microsoft/SPTAG/issues) for tracking suggestions and bugs.
+
+## **License**
+The entire codebase is under [MIT license](https://github.com/Microsoft/SPTAG/blob/master/LICENSE)
diff --git a/core/src/index/thirdparty/SPTAG/SPTAG.sdf b/core/src/index/thirdparty/SPTAG/SPTAG.sdf
new file mode 100644
index 0000000000..254a44ece6
Binary files /dev/null and b/core/src/index/thirdparty/SPTAG/SPTAG.sdf differ
diff --git a/core/src/index/thirdparty/SPTAG/SPTAG.sln b/core/src/index/thirdparty/SPTAG/SPTAG.sln
new file mode 100644
index 0000000000..5fdfd0297c
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/SPTAG.sln
@@ -0,0 +1,211 @@
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 14
+VisualStudioVersion = 14.0.25420.1
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "CoreLibrary", "AnnService\CoreLibrary.vcxproj", "{C2BC5FDE-C853-4F3D-B7E4-2C9B5524DDF9}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Server", "AnnService\Server.vcxproj", "{E28B1222-8BEA-4A92-8FE0-088EBDAA7FE0}"
+	ProjectSection(ProjectDependencies) = postProject
+		{F9A72303-6381-4C80-86FF-606A2F6F7B96} = {F9A72303-6381-4C80-86FF-606A2F6F7B96}
+		{C2BC5FDE-C853-4F3D-B7E4-2C9B5524DDF9} = {C2BC5FDE-C853-4F3D-B7E4-2C9B5524DDF9}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "PythonCore", "Wrappers\PythonCore.vcxproj", "{AF31947C-0495-42FE-A1AD-8F0DA2A679C7}"
+	ProjectSection(ProjectDependencies) = postProject
+		{C2BC5FDE-C853-4F3D-B7E4-2C9B5524DDF9} = {C2BC5FDE-C853-4F3D-B7E4-2C9B5524DDF9}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "SocketLib", "AnnService\SocketLib.vcxproj", "{F9A72303-6381-4C80-86FF-606A2F6F7B96}"
+	ProjectSection(ProjectDependencies) = postProject
+		{C2BC5FDE-C853-4F3D-B7E4-2C9B5524DDF9} = {C2BC5FDE-C853-4F3D-B7E4-2C9B5524DDF9}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Client", "AnnService\Client.vcxproj", "{A89D70C3-C53B-42DE-A5CE-9A472540F5CB}"
+	ProjectSection(ProjectDependencies) = postProject
+		{F9A72303-6381-4C80-86FF-606A2F6F7B96} = {F9A72303-6381-4C80-86FF-606A2F6F7B96}
+		{C2BC5FDE-C853-4F3D-B7E4-2C9B5524DDF9} = {C2BC5FDE-C853-4F3D-B7E4-2C9B5524DDF9}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Aggregator", "AnnService\Aggregator.vcxproj", "{D7F09A63-BDCA-4F6C-A864-8551D1FE447A}"
+	ProjectSection(ProjectDependencies) = postProject
+		{F9A72303-6381-4C80-86FF-606A2F6F7B96} = {F9A72303-6381-4C80-86FF-606A2F6F7B96}
+		{C2BC5FDE-C853-4F3D-B7E4-2C9B5524DDF9} = {C2BC5FDE-C853-4F3D-B7E4-2C9B5524DDF9}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "PythonClient", "Wrappers\PythonClient.vcxproj", "{9B014CF6-E3FB-4BD4-B3B1-D26297BB31AA}"
+	ProjectSection(ProjectDependencies) = postProject
+		{F9A72303-6381-4C80-86FF-606A2F6F7B96} = {F9A72303-6381-4C80-86FF-606A2F6F7B96}
+		{C2BC5FDE-C853-4F3D-B7E4-2C9B5524DDF9} = {C2BC5FDE-C853-4F3D-B7E4-2C9B5524DDF9}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "IndexBuilder", "AnnService\IndexBuilder.vcxproj", "{F492F794-E78B-4B1F-A556-5E045B9163D5}"
+	ProjectSection(ProjectDependencies) = postProject
+		{C2BC5FDE-C853-4F3D-B7E4-2C9B5524DDF9} = {C2BC5FDE-C853-4F3D-B7E4-2C9B5524DDF9}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "IndexSearcher", "AnnService\IndexSearcher.vcxproj", "{97615D3B-9FA0-469E-B229-95A91A5087E0}"
+	ProjectSection(ProjectDependencies) = postProject
+		{C2BC5FDE-C853-4F3D-B7E4-2C9B5524DDF9} = {C2BC5FDE-C853-4F3D-B7E4-2C9B5524DDF9}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Test", "Test\Test.vcxproj", "{29A25655-CCF2-47F8-8BC8-DFE1B5CF993C}"
+	ProjectSection(ProjectDependencies) = postProject
+		{F9A72303-6381-4C80-86FF-606A2F6F7B96} = {F9A72303-6381-4C80-86FF-606A2F6F7B96}
+		{C2BC5FDE-C853-4F3D-B7E4-2C9B5524DDF9} = {C2BC5FDE-C853-4F3D-B7E4-2C9B5524DDF9}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "JavaCore", "Wrappers\JavaCore.vcxproj", "{93FEB26B-965E-4157-8BE5-052F5CA112BB}"
+	ProjectSection(ProjectDependencies) = postProject
+		{C2BC5FDE-C853-4F3D-B7E4-2C9B5524DDF9} = {C2BC5FDE-C853-4F3D-B7E4-2C9B5524DDF9}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "JavaClient", "Wrappers\JavaClient.vcxproj", "{8866BF98-AA2E-450F-9F33-083E007CCA74}"
+	ProjectSection(ProjectDependencies) = postProject
+		{F9A72303-6381-4C80-86FF-606A2F6F7B96} = {F9A72303-6381-4C80-86FF-606A2F6F7B96}
+		{C2BC5FDE-C853-4F3D-B7E4-2C9B5524DDF9} = {C2BC5FDE-C853-4F3D-B7E4-2C9B5524DDF9}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "CsharpCore", "Wrappers\CsharpCore.vcxproj", "{1896C009-AD46-4A70-B83C-4652A7F37503}"
+	ProjectSection(ProjectDependencies) = postProject
+		{C2BC5FDE-C853-4F3D-B7E4-2C9B5524DDF9} = {C2BC5FDE-C853-4F3D-B7E4-2C9B5524DDF9}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "CsharpClient", "Wrappers\CsharpClient.vcxproj", "{363BA3BB-75C4-4CC7-AECB-28C7534B3710}"
+	ProjectSection(ProjectDependencies) = postProject
+		{F9A72303-6381-4C80-86FF-606A2F6F7B96} = {F9A72303-6381-4C80-86FF-606A2F6F7B96}
+		{C2BC5FDE-C853-4F3D-B7E4-2C9B5524DDF9} = {C2BC5FDE-C853-4F3D-B7E4-2C9B5524DDF9}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "CLRCore", "Wrappers\CLRCore.vcxproj", "{38ACBA6C-2E50-44D4-9A6D-DC735B56E38F}"
+	ProjectSection(ProjectDependencies) = postProject
+		{C2BC5FDE-C853-4F3D-B7E4-2C9B5524DDF9} = {C2BC5FDE-C853-4F3D-B7E4-2C9B5524DDF9}
+	EndProjectSection
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Debug|x86 = Debug|x86
+		Release|x64 = Release|x64
+		Release|x86 = Release|x86
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{C2BC5FDE-C853-4F3D-B7E4-2C9B5524DDF9}.Debug|x64.ActiveCfg = Debug|x64
+		{C2BC5FDE-C853-4F3D-B7E4-2C9B5524DDF9}.Debug|x64.Build.0 = Debug|x64
+		{C2BC5FDE-C853-4F3D-B7E4-2C9B5524DDF9}.Debug|x86.ActiveCfg = Debug|x64
+		{C2BC5FDE-C853-4F3D-B7E4-2C9B5524DDF9}.Debug|x86.Build.0 = Debug|x64
+		{C2BC5FDE-C853-4F3D-B7E4-2C9B5524DDF9}.Release|x64.ActiveCfg = Release|x64
+		{C2BC5FDE-C853-4F3D-B7E4-2C9B5524DDF9}.Release|x64.Build.0 = Release|x64
+		{C2BC5FDE-C853-4F3D-B7E4-2C9B5524DDF9}.Release|x86.ActiveCfg = Debug|x64
+		{C2BC5FDE-C853-4F3D-B7E4-2C9B5524DDF9}.Release|x86.Build.0 = Debug|x64
+		{E28B1222-8BEA-4A92-8FE0-088EBDAA7FE0}.Debug|x64.ActiveCfg = Debug|x64
+		{E28B1222-8BEA-4A92-8FE0-088EBDAA7FE0}.Debug|x64.Build.0 = Debug|x64
+		{E28B1222-8BEA-4A92-8FE0-088EBDAA7FE0}.Debug|x86.ActiveCfg = Debug|x64
+		{E28B1222-8BEA-4A92-8FE0-088EBDAA7FE0}.Debug|x86.Build.0 = Debug|x64
+		{E28B1222-8BEA-4A92-8FE0-088EBDAA7FE0}.Release|x64.ActiveCfg = Release|x64
+		{E28B1222-8BEA-4A92-8FE0-088EBDAA7FE0}.Release|x64.Build.0 = Release|x64
+		{E28B1222-8BEA-4A92-8FE0-088EBDAA7FE0}.Release|x86.ActiveCfg = Debug|x64
+		{E28B1222-8BEA-4A92-8FE0-088EBDAA7FE0}.Release|x86.Build.0 = Debug|x64
+		{AF31947C-0495-42FE-A1AD-8F0DA2A679C7}.Debug|x64.ActiveCfg = Debug|x64
+		{AF31947C-0495-42FE-A1AD-8F0DA2A679C7}.Debug|x64.Build.0 = Debug|x64
+		{AF31947C-0495-42FE-A1AD-8F0DA2A679C7}.Debug|x86.ActiveCfg = Debug|x64
+		{AF31947C-0495-42FE-A1AD-8F0DA2A679C7}.Debug|x86.Build.0 = Debug|x64
+		{AF31947C-0495-42FE-A1AD-8F0DA2A679C7}.Release|x64.ActiveCfg = Release|x64
+		{AF31947C-0495-42FE-A1AD-8F0DA2A679C7}.Release|x64.Build.0 = Release|x64
+		{AF31947C-0495-42FE-A1AD-8F0DA2A679C7}.Release|x86.ActiveCfg = Debug|x64
+		{AF31947C-0495-42FE-A1AD-8F0DA2A679C7}.Release|x86.Build.0 = Debug|x64
+		{F9A72303-6381-4C80-86FF-606A2F6F7B96}.Debug|x64.ActiveCfg = Debug|x64
+		{F9A72303-6381-4C80-86FF-606A2F6F7B96}.Debug|x64.Build.0 = Debug|x64
+		{F9A72303-6381-4C80-86FF-606A2F6F7B96}.Debug|x86.ActiveCfg = Debug|x64
+		{F9A72303-6381-4C80-86FF-606A2F6F7B96}.Debug|x86.Build.0 = Debug|x64
+		{F9A72303-6381-4C80-86FF-606A2F6F7B96}.Release|x64.ActiveCfg = Release|x64
+		{F9A72303-6381-4C80-86FF-606A2F6F7B96}.Release|x64.Build.0 = Release|x64
+		{F9A72303-6381-4C80-86FF-606A2F6F7B96}.Release|x86.ActiveCfg = Debug|x64
+		{F9A72303-6381-4C80-86FF-606A2F6F7B96}.Release|x86.Build.0 = Debug|x64
+		{A89D70C3-C53B-42DE-A5CE-9A472540F5CB}.Debug|x64.ActiveCfg = Debug|x64
+		{A89D70C3-C53B-42DE-A5CE-9A472540F5CB}.Debug|x64.Build.0 = Debug|x64
+		{A89D70C3-C53B-42DE-A5CE-9A472540F5CB}.Debug|x86.ActiveCfg = Debug|x64
+		{A89D70C3-C53B-42DE-A5CE-9A472540F5CB}.Debug|x86.Build.0 = Debug|x64
+		{A89D70C3-C53B-42DE-A5CE-9A472540F5CB}.Release|x64.ActiveCfg = Release|x64
+		{A89D70C3-C53B-42DE-A5CE-9A472540F5CB}.Release|x64.Build.0 = Release|x64
+		{A89D70C3-C53B-42DE-A5CE-9A472540F5CB}.Release|x86.ActiveCfg = Debug|x64
+		{A89D70C3-C53B-42DE-A5CE-9A472540F5CB}.Release|x86.Build.0 = Debug|x64
+		{D7F09A63-BDCA-4F6C-A864-8551D1FE447A}.Debug|x64.ActiveCfg = Debug|x64
+		{D7F09A63-BDCA-4F6C-A864-8551D1FE447A}.Debug|x64.Build.0 = Debug|x64
+		{D7F09A63-BDCA-4F6C-A864-8551D1FE447A}.Debug|x86.ActiveCfg = Debug|x64
+		{D7F09A63-BDCA-4F6C-A864-8551D1FE447A}.Debug|x86.Build.0 = Debug|x64
+		{D7F09A63-BDCA-4F6C-A864-8551D1FE447A}.Release|x64.ActiveCfg = Release|x64
+		{D7F09A63-BDCA-4F6C-A864-8551D1FE447A}.Release|x64.Build.0 = Release|x64
+		{D7F09A63-BDCA-4F6C-A864-8551D1FE447A}.Release|x86.ActiveCfg = Debug|x64
+		{D7F09A63-BDCA-4F6C-A864-8551D1FE447A}.Release|x86.Build.0 = Debug|x64
+		{9B014CF6-E3FB-4BD4-B3B1-D26297BB31AA}.Debug|x64.ActiveCfg = Debug|x64
+		{9B014CF6-E3FB-4BD4-B3B1-D26297BB31AA}.Debug|x64.Build.0 = Debug|x64
+		{9B014CF6-E3FB-4BD4-B3B1-D26297BB31AA}.Debug|x86.ActiveCfg = Debug|Win32
+		{9B014CF6-E3FB-4BD4-B3B1-D26297BB31AA}.Debug|x86.Build.0 = Debug|Win32
+		{9B014CF6-E3FB-4BD4-B3B1-D26297BB31AA}.Release|x64.ActiveCfg = Release|x64
+		{9B014CF6-E3FB-4BD4-B3B1-D26297BB31AA}.Release|x64.Build.0 = Release|x64
+		{9B014CF6-E3FB-4BD4-B3B1-D26297BB31AA}.Release|x86.ActiveCfg = Release|Win32
+		{9B014CF6-E3FB-4BD4-B3B1-D26297BB31AA}.Release|x86.Build.0 = Release|Win32
+		{F492F794-E78B-4B1F-A556-5E045B9163D5}.Debug|x64.ActiveCfg = Debug|x64
+		{F492F794-E78B-4B1F-A556-5E045B9163D5}.Debug|x64.Build.0 = Debug|x64
+		{F492F794-E78B-4B1F-A556-5E045B9163D5}.Debug|x86.ActiveCfg = Debug|Win32
+		{F492F794-E78B-4B1F-A556-5E045B9163D5}.Debug|x86.Build.0 = Debug|Win32
+		{F492F794-E78B-4B1F-A556-5E045B9163D5}.Release|x64.ActiveCfg = Release|x64
+		{F492F794-E78B-4B1F-A556-5E045B9163D5}.Release|x64.Build.0 = Release|x64
+		{F492F794-E78B-4B1F-A556-5E045B9163D5}.Release|x86.ActiveCfg = Release|Win32
+		{F492F794-E78B-4B1F-A556-5E045B9163D5}.Release|x86.Build.0 = Release|Win32
+		{97615D3B-9FA0-469E-B229-95A91A5087E0}.Debug|x64.ActiveCfg = Debug|x64
+		{97615D3B-9FA0-469E-B229-95A91A5087E0}.Debug|x64.Build.0 = Debug|x64
+		{97615D3B-9FA0-469E-B229-95A91A5087E0}.Debug|x86.ActiveCfg = Debug|Win32
+		{97615D3B-9FA0-469E-B229-95A91A5087E0}.Debug|x86.Build.0 = Debug|Win32
+		{97615D3B-9FA0-469E-B229-95A91A5087E0}.Release|x64.ActiveCfg = Release|x64
+		{97615D3B-9FA0-469E-B229-95A91A5087E0}.Release|x64.Build.0 = Release|x64
+		{97615D3B-9FA0-469E-B229-95A91A5087E0}.Release|x86.ActiveCfg = Release|Win32
+		{97615D3B-9FA0-469E-B229-95A91A5087E0}.Release|x86.Build.0 = Release|Win32
+		{29A25655-CCF2-47F8-8BC8-DFE1B5CF993C}.Debug|x64.ActiveCfg = Debug|x64
+		{29A25655-CCF2-47F8-8BC8-DFE1B5CF993C}.Debug|x64.Build.0 = Debug|x64
+		{29A25655-CCF2-47F8-8BC8-DFE1B5CF993C}.Debug|x86.ActiveCfg = Debug|Win32
+		{29A25655-CCF2-47F8-8BC8-DFE1B5CF993C}.Debug|x86.Build.0 = Debug|Win32
+		{29A25655-CCF2-47F8-8BC8-DFE1B5CF993C}.Release|x64.ActiveCfg = Release|x64
+		{29A25655-CCF2-47F8-8BC8-DFE1B5CF993C}.Release|x64.Build.0 = Release|x64
+		{29A25655-CCF2-47F8-8BC8-DFE1B5CF993C}.Release|x86.ActiveCfg = Release|Win32
+		{29A25655-CCF2-47F8-8BC8-DFE1B5CF993C}.Release|x86.Build.0 = Release|Win32
+		{93FEB26B-965E-4157-8BE5-052F5CA112BB}.Debug|x64.ActiveCfg = Debug|x64
+		{93FEB26B-965E-4157-8BE5-052F5CA112BB}.Debug|x86.ActiveCfg = Debug|Win32
+		{93FEB26B-965E-4157-8BE5-052F5CA112BB}.Release|x64.ActiveCfg = Release|x64
+		{93FEB26B-965E-4157-8BE5-052F5CA112BB}.Release|x86.ActiveCfg = Release|Win32
+		{8866BF98-AA2E-450F-9F33-083E007CCA74}.Debug|x64.ActiveCfg = Debug|x64
+		{8866BF98-AA2E-450F-9F33-083E007CCA74}.Debug|x86.ActiveCfg = Debug|Win32
+		{8866BF98-AA2E-450F-9F33-083E007CCA74}.Release|x64.ActiveCfg = Release|x64
+		{8866BF98-AA2E-450F-9F33-083E007CCA74}.Release|x86.ActiveCfg = Release|Win32
+		{1896C009-AD46-4A70-B83C-4652A7F37503}.Debug|x64.ActiveCfg = Debug|x64
+		{1896C009-AD46-4A70-B83C-4652A7F37503}.Debug|x64.Build.0 = Debug|x64
+		{1896C009-AD46-4A70-B83C-4652A7F37503}.Debug|x86.ActiveCfg = Debug|Win32
+		{1896C009-AD46-4A70-B83C-4652A7F37503}.Debug|x86.Build.0 = Debug|Win32
+		{1896C009-AD46-4A70-B83C-4652A7F37503}.Release|x64.ActiveCfg = Release|x64
+		{1896C009-AD46-4A70-B83C-4652A7F37503}.Release|x64.Build.0 = Release|x64
+		{1896C009-AD46-4A70-B83C-4652A7F37503}.Release|x86.ActiveCfg = Release|Win32
+		{1896C009-AD46-4A70-B83C-4652A7F37503}.Release|x86.Build.0 = Release|Win32
+		{363BA3BB-75C4-4CC7-AECB-28C7534B3710}.Debug|x64.ActiveCfg = Debug|x64
+		{363BA3BB-75C4-4CC7-AECB-28C7534B3710}.Debug|x64.Build.0 = Debug|x64
+		{363BA3BB-75C4-4CC7-AECB-28C7534B3710}.Debug|x86.ActiveCfg = Debug|Win32
+		{363BA3BB-75C4-4CC7-AECB-28C7534B3710}.Debug|x86.Build.0 = Debug|Win32
+		{363BA3BB-75C4-4CC7-AECB-28C7534B3710}.Release|x64.ActiveCfg = Release|x64
+		{363BA3BB-75C4-4CC7-AECB-28C7534B3710}.Release|x64.Build.0 = Release|x64
+		{363BA3BB-75C4-4CC7-AECB-28C7534B3710}.Release|x86.ActiveCfg = Release|Win32
+		{363BA3BB-75C4-4CC7-AECB-28C7534B3710}.Release|x86.Build.0 = Release|Win32
+		{38ACBA6C-2E50-44D4-9A6D-DC735B56E38F}.Debug|x64.ActiveCfg = Debug|x64
+		{38ACBA6C-2E50-44D4-9A6D-DC735B56E38F}.Debug|x64.Build.0 = Debug|x64
+		{38ACBA6C-2E50-44D4-9A6D-DC735B56E38F}.Debug|x86.ActiveCfg = Debug|Win32
+		{38ACBA6C-2E50-44D4-9A6D-DC735B56E38F}.Debug|x86.Build.0 = Debug|Win32
+		{38ACBA6C-2E50-44D4-9A6D-DC735B56E38F}.Release|x64.ActiveCfg = Release|x64
+		{38ACBA6C-2E50-44D4-9A6D-DC735B56E38F}.Release|x64.Build.0 = Release|x64
+		{38ACBA6C-2E50-44D4-9A6D-DC735B56E38F}.Release|x86.ActiveCfg = Release|Win32
+		{38ACBA6C-2E50-44D4-9A6D-DC735B56E38F}.Release|x86.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {38BDFF12-6FEC-4B67-A7BD-436D9E2544FD}
+	EndGlobalSection
+EndGlobal
diff --git a/core/src/index/thirdparty/SPTAG/Test/CMakeLists.txt b/core/src/index/thirdparty/SPTAG/Test/CMakeLists.txt
new file mode 100644
index 0000000000..39166b32a9
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/Test/CMakeLists.txt
@@ -0,0 +1,32 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+
+if(NOT WIN32)
+  ADD_DEFINITIONS(-DBOOST_TEST_DYN_LINK)
+  message (STATUS "BOOST_TEST_DYN_LINK")
+endif()
+
+find_package(Boost 1.67 COMPONENTS system thread serialization wserialization regex filesystem unit_test_framework)
+if (Boost_FOUND)
+    include_directories (${Boost_INCLUDE_DIR})
+    link_directories (${Boost_LIBRARY_DIR})
+    message (STATUS "Found Boost.")
+    message (STATUS "Include Path: ${Boost_INCLUDE_DIRS}")
+    message (STATUS "Library Path: ${Boost_LIBRARY_DIRS}")
+    message (STATUS "Library: ${Boost_LIBRARIES}")
+else()
+    message (FATAL_ERROR "Could not find Boost 1.67!")
+endif()
+
+include_directories(${PYTHON_INCLUDE_PATH} ${PROJECT_SOURCE_DIR}/AnnService ${PROJECT_SOURCE_DIR}/PythonWrapper ${PROJECT_SOURCE_DIR}/Test)
+
+file(GLOB TEST_HDR_FILES ${PROJECT_SOURCE_DIR}/Test/inc/Test.h)
+file(GLOB TEST_SRC_FILES ${PROJECT_SOURCE_DIR}/Test/src/*.cpp)
+add_executable (test ${TEST_SRC_FILES} ${TEST_HDR_FILES})
+target_link_libraries(test SPTAGLib ${Boost_LIBRARIES})
+
+install(TARGETS test
+  RUNTIME DESTINATION bin  
+  ARCHIVE DESTINATION lib
+  LIBRARY DESTINATION lib)
+
diff --git a/core/src/index/thirdparty/SPTAG/Test/Test.vcxproj b/core/src/index/thirdparty/SPTAG/Test/Test.vcxproj
new file mode 100644
index 0000000000..c479ae5be1
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/Test/Test.vcxproj
@@ -0,0 +1,183 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>15.0</VCProjectVersion>
+    <ProjectGuid>{29A25655-CCF2-47F8-8BC8-DFE1B5CF993C}</ProjectGuid>
+    <RootNamespace>Test</RootNamespace>
+    <WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <Import Project="$(SolutionDir)\AnnService.users.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <IntDir>$(SolutionDir)obj\$(Platform)_$(Configuration)\$(ProjectName)\</IntDir>
+    <IncludePath>$(ProjectDir);$(SolutionDir)AnnService\;$(IncludePath)</IncludePath>
+    <OutDir>$(OutAppDir)</OutDir>
+    <LibraryPath>$(OutLibDir);$(LibraryPath)</LibraryPath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <Link>
+      <AdditionalDependencies>CoreLibrary.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <ConformanceMode>true</ConformanceMode>
+      <PreprocessorDefinitions>_MBCS;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <EntryPointSymbol>
+      </EntryPointSymbol>
+      <SubSystem>Console</SubSystem>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <SDLCheck>true</SDLCheck>
+      <ConformanceMode>true</ConformanceMode>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <SDLCheck>true</SDLCheck>
+      <ConformanceMode>true</ConformanceMode>
+      <PreprocessorDefinitions>_MBCS;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ControlFlowGuard>Guard</ControlFlowGuard>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <AdditionalOptions>/guard:cf %(AdditionalOptions)</AdditionalOptions>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <ConformanceMode>true</ConformanceMode>
+    </ClCompile>
+    <Link>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="src\AlgoTest.cpp" />
+	<ClCompile Include="src\Base64HelperTest.cpp" />
+	<ClCompile Include="src\CommonHelperTest.cpp" />
+    <ClCompile Include="src\DistanceTest.cpp" />
+	<ClCompile Include="src\IniReaderTest.cpp" />
+    <ClCompile Include="src\main.cpp" />
+	<ClCompile Include="src\StringConvertTest.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="inc\Test.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config">
+      <SubType>Designer</SubType>
+    </None>
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="..\packages\boost.1.67.0.0\build\boost.targets" Condition="Exists('..\packages\boost.1.67.0.0\build\boost.targets')" />
+    <Import Project="..\packages\boost_date_time-vc140.1.67.0.0\build\boost_date_time-vc140.targets" Condition="Exists('..\packages\boost_date_time-vc140.1.67.0.0\build\boost_date_time-vc140.targets')" />
+    <Import Project="..\packages\boost_regex-vc140.1.67.0.0\build\boost_regex-vc140.targets" Condition="Exists('..\packages\boost_regex-vc140.1.67.0.0\build\boost_regex-vc140.targets')" />
+    <Import Project="..\packages\boost_serialization-vc140.1.67.0.0\build\boost_serialization-vc140.targets" Condition="Exists('..\packages\boost_serialization-vc140.1.67.0.0\build\boost_serialization-vc140.targets')" />
+    <Import Project="..\packages\boost_system-vc140.1.67.0.0\build\boost_system-vc140.targets" Condition="Exists('..\packages\boost_system-vc140.1.67.0.0\build\boost_system-vc140.targets')" />
+    <Import Project="..\packages\boost_thread-vc140.1.67.0.0\build\boost_thread-vc140.targets" Condition="Exists('..\packages\boost_thread-vc140.1.67.0.0\build\boost_thread-vc140.targets')" />
+    <Import Project="..\packages\boost_wserialization-vc140.1.67.0.0\build\boost_wserialization-vc140.targets" Condition="Exists('..\packages\boost_wserialization-vc140.1.67.0.0\build\boost_wserialization-vc140.targets')" />
+    <Import Project="..\packages\boost_unit_test_framework-vc140.1.67.0.0\build\boost_unit_test_framework-vc140.targets" Condition="Exists('..\packages\boost_unit_test_framework-vc140.1.67.0.0\build\boost_unit_test_framework-vc140.targets')" />
+  </ImportGroup>
+  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
+    <PropertyGroup>
+      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
+    </PropertyGroup>
+    <Error Condition="!Exists('..\packages\boost.1.67.0.0\build\boost.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost.1.67.0.0\build\boost.targets'))" />
+    <Error Condition="!Exists('..\packages\boost_date_time-vc140.1.67.0.0\build\boost_date_time-vc140.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost_date_time-vc140.1.67.0.0\build\boost_date_time-vc140.targets'))" />
+    <Error Condition="!Exists('..\packages\boost_regex-vc140.1.67.0.0\build\boost_regex-vc140.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost_regex-vc140.1.67.0.0\build\boost_regex-vc140.targets'))" />
+    <Error Condition="!Exists('..\packages\boost_serialization-vc140.1.67.0.0\build\boost_serialization-vc140.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost_serialization-vc140.1.67.0.0\build\boost_serialization-vc140.targets'))" />
+    <Error Condition="!Exists('..\packages\boost_system-vc140.1.67.0.0\build\boost_system-vc140.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost_system-vc140.1.67.0.0\build\boost_system-vc140.targets'))" />
+    <Error Condition="!Exists('..\packages\boost_thread-vc140.1.67.0.0\build\boost_thread-vc140.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost_thread-vc140.1.67.0.0\build\boost_thread-vc140.targets'))" />
+    <Error Condition="!Exists('..\packages\boost_wserialization-vc140.1.67.0.0\build\boost_wserialization-vc140.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost_wserialization-vc140.1.67.0.0\build\boost_wserialization-vc140.targets'))" />
+    <Error Condition="!Exists('..\packages\boost_unit_test_framework-vc140.1.67.0.0\build\boost_unit_test_framework-vc140.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost_unit_test_framework-vc140.1.67.0.0\build\boost_unit_test_framework-vc140.targets'))" />
+  </Target>
+</Project>
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/Test/Test.vcxproj.filters b/core/src/index/thirdparty/SPTAG/Test/Test.vcxproj.filters
new file mode 100644
index 0000000000..a814c3ec3f
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/Test/Test.vcxproj.filters
@@ -0,0 +1,48 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
+    </Filter>
+    <Filter Include="Resource Files">
+      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="src\main.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\DistanceTest.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\AlgoTest.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+	<ClCompile Include="src\StringConvertTest.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+	<ClCompile Include="src\IniReaderTest.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+	<ClCompile Include="src\Base64HelperTest.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+	<ClCompile Include="src\CommonHelperTest.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="inc\Test.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+  </ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/Test/Test.vcxproj.user b/core/src/index/thirdparty/SPTAG/Test/Test.vcxproj.user
new file mode 100644
index 0000000000..10f0fcf2d9
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/Test/Test.vcxproj.user
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LocalDebuggerWorkingDirectory>$(OutLibDir)</LocalDebuggerWorkingDirectory>
+    <DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>
+  </PropertyGroup>
+</Project>
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/Test/inc/Test.h b/core/src/index/thirdparty/SPTAG/Test/inc/Test.h
new file mode 100644
index 0000000000..da6c096ba2
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/Test/inc/Test.h
@@ -0,0 +1,7 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <iostream>
+#include <boost/test/unit_test.hpp>
diff --git a/core/src/index/thirdparty/SPTAG/Test/packages.config b/core/src/index/thirdparty/SPTAG/Test/packages.config
new file mode 100644
index 0000000000..651c754779
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/Test/packages.config
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="boost" version="1.67.0.0" targetFramework="native" />
+  <package id="boost_unit_test_framework-vc140" version="1.67.0.0" targetFramework="native" />
+</packages>
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/Test/src/AlgoTest.cpp b/core/src/index/thirdparty/SPTAG/Test/src/AlgoTest.cpp
new file mode 100644
index 0000000000..a93cd38bed
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/Test/src/AlgoTest.cpp
@@ -0,0 +1,159 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Test.h"
+#include "inc/Helper/SimpleIniReader.h"
+#include "inc/Core/VectorIndex.h"
+
+#include <unordered_set>
+
+template <typename T>
+void Build(SPTAG::IndexAlgoType algo, std::string distCalcMethod, std::shared_ptr<SPTAG::VectorSet>& vec, std::shared_ptr<SPTAG::MetadataSet>& meta, const std::string out)
+{
+
+    std::shared_ptr<SPTAG::VectorIndex> vecIndex = SPTAG::VectorIndex::CreateInstance(algo, SPTAG::GetEnumValueType<T>());
+    BOOST_CHECK(nullptr != vecIndex);
+
+    vecIndex->SetParameter("DistCalcMethod", distCalcMethod);
+
+    BOOST_CHECK(SPTAG::ErrorCode::Success == vecIndex->BuildIndex(vec, meta));
+    BOOST_CHECK(SPTAG::ErrorCode::Success == vecIndex->SaveIndex(out));
+}
+
+template <typename T>
+void BuildWithMetaMapping(SPTAG::IndexAlgoType algo, std::string distCalcMethod, std::shared_ptr<SPTAG::VectorSet>& vec, std::shared_ptr<SPTAG::MetadataSet>& meta, const std::string out)
+{
+
+    std::shared_ptr<SPTAG::VectorIndex> vecIndex = SPTAG::VectorIndex::CreateInstance(algo, SPTAG::GetEnumValueType<T>());
+    BOOST_CHECK(nullptr != vecIndex);
+
+    vecIndex->SetParameter("DistCalcMethod", distCalcMethod);
+
+    BOOST_CHECK(SPTAG::ErrorCode::Success == vecIndex->BuildIndex(vec, meta, true));
+    BOOST_CHECK(SPTAG::ErrorCode::Success == vecIndex->SaveIndex(out));
+}
+
+template <typename T>
+void Search(const std::string folder, T* vec, SPTAG::SizeType n, int k, std::string* truthmeta)
+{
+    std::shared_ptr<SPTAG::VectorIndex> vecIndex;
+    BOOST_CHECK(SPTAG::ErrorCode::Success == SPTAG::VectorIndex::LoadIndex(folder, vecIndex));
+    BOOST_CHECK(nullptr != vecIndex);
+
+    for (SPTAG::SizeType i = 0; i < n; i++) 
+    {
+        SPTAG::QueryResult res(vec, k, true);
+        vecIndex->SearchIndex(res);
+        std::unordered_set<std::string> resmeta;
+        for (int j = 0; j < k; j++)
+        {
+            resmeta.insert(std::string((char*)res.GetMetadata(j).Data(), res.GetMetadata(j).Length()));
+            std::cout << res.GetResult(j)->Dist << "@(" << res.GetResult(j)->VID << "," << std::string((char*)res.GetMetadata(j).Data(), res.GetMetadata(j).Length()) << ") ";
+        }
+        std::cout << std::endl;
+        for (int j = 0; j < k; j++)
+        {
+            BOOST_CHECK(resmeta.find(truthmeta[i * k + j]) != resmeta.end());
+        }
+        vec += vecIndex->GetFeatureDim();
+    }
+    vecIndex.reset();
+}
+
+template <typename T>
+void Add(const std::string folder, std::shared_ptr<SPTAG::VectorSet>& vec, std::shared_ptr<SPTAG::MetadataSet>& meta, const std::string out)
+{
+    std::shared_ptr<SPTAG::VectorIndex> vecIndex;
+    BOOST_CHECK(SPTAG::ErrorCode::Success == SPTAG::VectorIndex::LoadIndex(folder, vecIndex));
+    BOOST_CHECK(nullptr != vecIndex);
+
+    BOOST_CHECK(SPTAG::ErrorCode::Success == vecIndex->AddIndex(vec, meta));
+    BOOST_CHECK(SPTAG::ErrorCode::Success == vecIndex->SaveIndex(out));
+    vecIndex.reset();
+}
+
+template <typename T>
+void Delete(const std::string folder, T* vec, SPTAG::SizeType n, const std::string out)
+{
+    std::shared_ptr<SPTAG::VectorIndex> vecIndex;
+    BOOST_CHECK(SPTAG::ErrorCode::Success == SPTAG::VectorIndex::LoadIndex(folder, vecIndex));
+    BOOST_CHECK(nullptr != vecIndex);
+
+    BOOST_CHECK(SPTAG::ErrorCode::Success == vecIndex->DeleteIndex((const void*)vec, n));
+    BOOST_CHECK(SPTAG::ErrorCode::Success == vecIndex->SaveIndex(out));
+    vecIndex.reset();
+}
+
+template <typename T>
+void Test(SPTAG::IndexAlgoType algo, std::string distCalcMethod)
+{
+    SPTAG::SizeType n = 100, q = 3;
+    SPTAG::DimensionType m = 10;
+    int k = 3;
+    std::vector<T> vec;
+    for (SPTAG::SizeType i = 0; i < n; i++) {
+        for (SPTAG::DimensionType j = 0; j < m; j++) {
+            vec.push_back((T)i);
+        }
+    }
+    
+    std::vector<T> query;
+    for (SPTAG::SizeType i = 0; i < q; i++) {
+        for (SPTAG::DimensionType j = 0; j < m; j++) {
+            query.push_back((T)i*2);
+        }
+    }
+    
+    std::vector<char> meta;
+    std::vector<std::uint64_t> metaoffset;
+    for (SPTAG::SizeType i = 0; i < n; i++) {
+        metaoffset.push_back((std::uint64_t)meta.size());
+        std::string a = std::to_string(i);
+        for (size_t j = 0; j < a.length(); j++)
+            meta.push_back(a[j]);
+    }
+    metaoffset.push_back((std::uint64_t)meta.size());
+
+    std::shared_ptr<SPTAG::VectorSet> vecset(new SPTAG::BasicVectorSet(
+        SPTAG::ByteArray((std::uint8_t*)vec.data(), sizeof(T) * n * m, false),
+        SPTAG::GetEnumValueType<T>(), m, n));
+
+    std::shared_ptr<SPTAG::MetadataSet> metaset(new SPTAG::MemMetadataSet(
+        SPTAG::ByteArray((std::uint8_t*)meta.data(), meta.size() * sizeof(char), false),
+        SPTAG::ByteArray((std::uint8_t*)metaoffset.data(), metaoffset.size() * sizeof(std::uint64_t), false),
+        n));
+
+    Build<T>(algo, distCalcMethod, vecset, metaset, "testindices");
+    std::string truthmeta1[] = { "0", "1", "2", "2", "1", "3", "4", "3", "5" };
+    Search<T>("testindices", query.data(), q, k, truthmeta1);
+
+    Add<T>("testindices", vecset, metaset, "testindices");
+    std::string truthmeta2[] = { "0", "0", "1", "2", "2", "1", "4", "4", "3" };
+    Search<T>("testindices", query.data(), q, k, truthmeta2);
+
+    Delete<T>("testindices", query.data(), q, "testindices");
+    std::string truthmeta3[] = { "1", "1", "3", "1", "3", "1", "3", "5", "3" };
+    Search<T>("testindices", query.data(), q, k, truthmeta3);
+
+    BuildWithMetaMapping<T>(algo, distCalcMethod, vecset, metaset, "testindices");
+    std::string truthmeta4[] = { "0", "1", "2", "2", "1", "3", "4", "3", "5" };
+    Search<T>("testindices", query.data(), q, k, truthmeta4);
+
+    Add<T>("testindices", vecset, metaset, "testindices");
+    std::string truthmeta5[] = { "0", "1", "2", "2", "1", "3", "4", "3", "5" };
+    Search<T>("testindices", query.data(), q, k, truthmeta5);
+}
+
+BOOST_AUTO_TEST_SUITE (AlgoTest)
+
+BOOST_AUTO_TEST_CASE(KDTTest)
+{
+    Test<float>(SPTAG::IndexAlgoType::KDT, "L2");
+}
+
+BOOST_AUTO_TEST_CASE(BKTTest)
+{
+    Test<float>(SPTAG::IndexAlgoType::BKT, "L2");
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/core/src/index/thirdparty/SPTAG/Test/src/Base64HelperTest.cpp b/core/src/index/thirdparty/SPTAG/Test/src/Base64HelperTest.cpp
new file mode 100644
index 0000000000..2ead4753e5
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/Test/src/Base64HelperTest.cpp
@@ -0,0 +1,43 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Test.h"
+#include "inc/Helper/Base64Encode.h"
+
+#include <memory>
+
+BOOST_AUTO_TEST_SUITE(Base64Test)
+
+BOOST_AUTO_TEST_CASE(Base64EncDec)
+{
+    using namespace SPTAG::Helper::Base64;
+
+    const size_t bufferSize = 1 << 10;
+    std::unique_ptr<uint8_t[]> rawBuffer(new uint8_t[bufferSize]);
+    std::unique_ptr<char[]> encBuffer(new char[bufferSize]);
+    std::unique_ptr<uint8_t[]> rawBuffer2(new uint8_t[bufferSize]);
+
+    for (size_t inputSize = 1; inputSize < 128; ++inputSize)
+    {
+        for (size_t i = 0; i < inputSize; ++i)
+        {
+            rawBuffer[i] = static_cast<uint8_t>(i);
+        }
+
+        size_t encBufLen = CapacityForEncode(inputSize);
+        BOOST_CHECK(encBufLen < bufferSize);
+
+        size_t encOutLen = 0;
+        BOOST_CHECK(Encode(rawBuffer.get(), inputSize, encBuffer.get(), encOutLen));
+        BOOST_CHECK(encBufLen >= encOutLen);
+
+        size_t decBufLen = CapacityForDecode(encOutLen);
+        BOOST_CHECK(decBufLen < bufferSize);
+
+        size_t decOutLen = 0;
+        BOOST_CHECK(Decode(encBuffer.get(), encOutLen, rawBuffer.get(), decOutLen));
+        BOOST_CHECK(decBufLen >= decOutLen);
+    }
+}
+
+BOOST_AUTO_TEST_SUITE_END()
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/Test/src/CommonHelperTest.cpp b/core/src/index/thirdparty/SPTAG/Test/src/CommonHelperTest.cpp
new file mode 100644
index 0000000000..17015642cc
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/Test/src/CommonHelperTest.cpp
@@ -0,0 +1,93 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Test.h"
+#include "inc/Helper/CommonHelper.h"
+
+#include <memory>
+
+BOOST_AUTO_TEST_SUITE(CommonHelperTest)
+
+
+BOOST_AUTO_TEST_CASE(ToLowerInPlaceTest)
+{
+    auto runTestCase = [](std::string p_input, const std::string& p_expected)
+    {
+        SPTAG::Helper::StrUtils::ToLowerInPlace(p_input);
+        BOOST_CHECK(p_input == p_expected);
+    };
+
+    runTestCase("abc", "abc");
+    runTestCase("ABC", "abc");
+    runTestCase("abC", "abc");
+    runTestCase("Upper-Case", "upper-case");
+    runTestCase("123!-=aBc", "123!-=abc");
+}
+
+
+BOOST_AUTO_TEST_CASE(SplitStringTest)
+{
+    std::string input("seg1 seg2 seg3  seg4");
+
+    const auto& segs = SPTAG::Helper::StrUtils::SplitString(input, " ");
+    BOOST_CHECK(segs.size() == 4);
+    BOOST_CHECK(segs[0] == "seg1");
+    BOOST_CHECK(segs[1] == "seg2");
+    BOOST_CHECK(segs[2] == "seg3");
+    BOOST_CHECK(segs[3] == "seg4");
+}
+
+
+BOOST_AUTO_TEST_CASE(FindTrimmedSegmentTest)
+{
+    using namespace SPTAG::Helper::StrUtils;
+    std::string input("\t Space   End    \r\n\t");
+
+    const auto& pos = FindTrimmedSegment(input.c_str(),
+        input.c_str() + input.size(),
+        [](char p_val)->bool
+    {
+        return std::isspace(p_val) > 0;
+    });
+
+    BOOST_CHECK(pos.first == input.c_str() + 2);
+    BOOST_CHECK(pos.second == input.c_str() + 13);
+}
+
+
+BOOST_AUTO_TEST_CASE(StartsWithTest)
+{
+    using namespace SPTAG::Helper::StrUtils;
+
+    BOOST_CHECK(StartsWith("Abcd", "A"));
+    BOOST_CHECK(StartsWith("Abcd", "Ab"));
+    BOOST_CHECK(StartsWith("Abcd", "Abc"));
+    BOOST_CHECK(StartsWith("Abcd", "Abcd"));
+
+    BOOST_CHECK(!StartsWith("Abcd", "a"));
+    BOOST_CHECK(!StartsWith("Abcd", "F"));
+    BOOST_CHECK(!StartsWith("Abcd", "AF"));
+    BOOST_CHECK(!StartsWith("Abcd", "AbF"));
+    BOOST_CHECK(!StartsWith("Abcd", "AbcF"));
+    BOOST_CHECK(!StartsWith("Abcd", "Abcde"));
+}
+
+
+BOOST_AUTO_TEST_CASE(StrEqualIgnoreCaseTest)
+{
+    using namespace SPTAG::Helper::StrUtils;
+
+    BOOST_CHECK(StrEqualIgnoreCase("Abcd", "Abcd"));
+    BOOST_CHECK(StrEqualIgnoreCase("Abcd", "abcd"));
+    BOOST_CHECK(StrEqualIgnoreCase("Abcd", "abCD"));
+    BOOST_CHECK(StrEqualIgnoreCase("Abcd-123", "abcd-123"));
+    BOOST_CHECK(StrEqualIgnoreCase(" ZZZ", " zzz"));
+
+    BOOST_CHECK(!StrEqualIgnoreCase("abcd", "abcd1"));
+    BOOST_CHECK(!StrEqualIgnoreCase("Abcd", " abcd"));
+    BOOST_CHECK(!StrEqualIgnoreCase("000", "OOO"));
+}
+
+
+
+BOOST_AUTO_TEST_SUITE_END()
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/Test/src/DistanceTest.cpp b/core/src/index/thirdparty/SPTAG/Test/src/DistanceTest.cpp
new file mode 100644
index 0000000000..97602a2a8d
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/Test/src/DistanceTest.cpp
@@ -0,0 +1,58 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include <bitset>
+#include "inc/Test.h"
+#include "inc/Core/Common/DistanceUtils.h"
+
+template<typename T>
+static float ComputeCosineDistance(const T *pX, const T *pY, SPTAG::DimensionType length) {
+    float diff = 0;
+    const T* pEnd1 = pX + length;
+    while (pX < pEnd1) diff += (*pX++) * (*pY++);
+    return diff;
+}
+
+template<typename T>
+static float ComputeL2Distance(const T *pX, const T *pY, SPTAG::DimensionType length)
+{
+    float diff = 0;
+    const T* pEnd1 = pX + length;
+    while (pX < pEnd1) {
+        float c1 = ((float)(*pX++) - (float)(*pY++)); diff += c1 * c1;
+    }
+    return diff;
+}
+
+template<typename T>
+T random(int high = RAND_MAX, int low = 0)   // Generates a random value.
+{
+    return (T)(low + float(high - low)*(std::rand()/static_cast<float>(RAND_MAX + 1.0)));
+}
+
+template<typename T>
+void test(int high) {
+    SPTAG::DimensionType dimension = random<SPTAG::DimensionType>(256, 2);
+    T *X = new T[dimension], *Y = new T[dimension];
+    BOOST_ASSERT(X != nullptr && Y != nullptr);
+    for (SPTAG::DimensionType i = 0; i < dimension; i++) {
+        X[i] = random<T>(high, -high);
+        Y[i] = random<T>(high, -high);
+    }
+    BOOST_CHECK_CLOSE_FRACTION(ComputeL2Distance(X, Y, dimension), SPTAG::COMMON::DistanceUtils::ComputeL2Distance(X, Y, dimension), 1e-5);
+    BOOST_CHECK_CLOSE_FRACTION(high*high - ComputeCosineDistance(X, Y, dimension), SPTAG::COMMON::DistanceUtils::ComputeCosineDistance(X, Y, dimension), 1e-5);
+
+    delete[] X;
+    delete[] Y;
+}
+
+BOOST_AUTO_TEST_SUITE(DistanceTest)
+
+BOOST_AUTO_TEST_CASE(TestDistanceComputation)
+{
+    test<float>(1);
+    test<std::int8_t>(127);
+    test<std::int16_t>(32767);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/Test/src/IniReaderTest.cpp b/core/src/index/thirdparty/SPTAG/Test/src/IniReaderTest.cpp
new file mode 100644
index 0000000000..c5dd0baaf5
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/Test/src/IniReaderTest.cpp
@@ -0,0 +1,40 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Test.h"
+#include "inc/Helper/SimpleIniReader.h"
+
+#include <fstream>
+
+BOOST_AUTO_TEST_SUITE(IniReaderTest)
+
+BOOST_AUTO_TEST_CASE(IniReaderLoadTest)
+{
+    std::ofstream tmpIni("temp.ini");
+    tmpIni << "[Common]" << std::endl;
+    tmpIni << "; Comment " << std::endl;
+    tmpIni << "Param1=1" << std::endl;
+    tmpIni << "Param2=Exp=2" << std::endl;
+
+    tmpIni.close();
+
+    SPTAG::Helper::IniReader reader;
+    BOOST_CHECK(SPTAG::ErrorCode::Success == reader.LoadIniFile("temp.ini"));
+
+    BOOST_CHECK(reader.DoesSectionExist("Common"));
+    BOOST_CHECK(reader.DoesParameterExist("Common", "Param1"));
+    BOOST_CHECK(reader.DoesParameterExist("Common", "Param2"));
+
+    BOOST_CHECK(!reader.DoesSectionExist("NotExist"));
+    BOOST_CHECK(!reader.DoesParameterExist("NotExist", "Param1"));
+    BOOST_CHECK(!reader.DoesParameterExist("Common", "ParamNotExist"));
+
+    BOOST_CHECK(1 == reader.GetParameter<int>("Common", "Param1", 0));
+    BOOST_CHECK(0 == reader.GetParameter<int>("Common", "ParamNotExist", 0));
+
+    BOOST_CHECK(std::string("Exp=2") == reader.GetParameter<std::string>("Common", "Param2", std::string()));
+    BOOST_CHECK(std::string("1") == reader.GetParameter<std::string>("Common", "Param1", std::string()));
+    BOOST_CHECK(std::string() == reader.GetParameter<std::string>("Common", "ParamNotExist", std::string()));
+}
+
+BOOST_AUTO_TEST_SUITE_END()
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/Test/src/StringConvertTest.cpp b/core/src/index/thirdparty/SPTAG/Test/src/StringConvertTest.cpp
new file mode 100644
index 0000000000..fa457debe2
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/Test/src/StringConvertTest.cpp
@@ -0,0 +1,128 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/Test.h"
+#include "inc/Helper/StringConvert.h"
+
+namespace
+{
+    namespace Local
+    {
+
+        template <typename ValueType>
+        void TestConvertSuccCase(ValueType p_val, const char* p_valStr)
+        {
+            using namespace SPTAG::Helper::Convert;
+
+            std::string str = ConvertToString<ValueType>(p_val);
+            if (nullptr != p_valStr)
+            {
+                BOOST_CHECK(str == p_valStr);
+            }
+
+            ValueType val;
+            BOOST_CHECK(ConvertStringTo<ValueType>(str.c_str(), val));
+            BOOST_CHECK(val == p_val);
+        }
+
+    }
+}
+
+BOOST_AUTO_TEST_SUITE(StringConvertTest)
+
+BOOST_AUTO_TEST_CASE(ConvertInt8)
+{
+    Local::TestConvertSuccCase<int8_t>(static_cast<int8_t>(-1), "-1");
+    Local::TestConvertSuccCase<int8_t>(static_cast<int8_t>(0), "0");
+    Local::TestConvertSuccCase<int8_t>(static_cast<int8_t>(3), "3");
+    Local::TestConvertSuccCase<int8_t>(static_cast<int8_t>(100), "100");
+}
+
+BOOST_AUTO_TEST_CASE(ConvertInt16)
+{
+    Local::TestConvertSuccCase<int16_t>(static_cast<int16_t>(-1), "-1");
+    Local::TestConvertSuccCase<int16_t>(static_cast<int16_t>(0), "0");
+    Local::TestConvertSuccCase<int16_t>(static_cast<int16_t>(3), "3");
+    Local::TestConvertSuccCase<int16_t>(static_cast<int16_t>(100), "100");
+}
+
+BOOST_AUTO_TEST_CASE(ConvertInt32)
+{
+    Local::TestConvertSuccCase<int32_t>(static_cast<int32_t>(-1), "-1");
+    Local::TestConvertSuccCase<int32_t>(static_cast<int32_t>(0), "0");
+    Local::TestConvertSuccCase<int32_t>(static_cast<int32_t>(3), "3");
+    Local::TestConvertSuccCase<int32_t>(static_cast<int32_t>(100), "100");
+}
+
+BOOST_AUTO_TEST_CASE(ConvertInt64)
+{
+    Local::TestConvertSuccCase<int64_t>(static_cast<int64_t>(-1), "-1");
+    Local::TestConvertSuccCase<int64_t>(static_cast<int64_t>(0), "0");
+    Local::TestConvertSuccCase<int64_t>(static_cast<int64_t>(3), "3");
+    Local::TestConvertSuccCase<int64_t>(static_cast<int64_t>(100), "100");
+}
+
+BOOST_AUTO_TEST_CASE(ConvertUInt8)
+{
+    Local::TestConvertSuccCase<uint8_t>(static_cast<uint8_t>(0), "0");
+    Local::TestConvertSuccCase<uint8_t>(static_cast<uint8_t>(3), "3");
+    Local::TestConvertSuccCase<uint8_t>(static_cast<uint8_t>(100), "100");
+}
+
+BOOST_AUTO_TEST_CASE(ConvertUInt16)
+{
+    Local::TestConvertSuccCase<uint16_t>(static_cast<uint16_t>(0), "0");
+    Local::TestConvertSuccCase<uint16_t>(static_cast<uint16_t>(3), "3");
+    Local::TestConvertSuccCase<uint16_t>(static_cast<uint16_t>(100), "100");
+}
+
+BOOST_AUTO_TEST_CASE(ConvertUInt32)
+{
+    Local::TestConvertSuccCase<uint32_t>(static_cast<uint32_t>(0), "0");
+    Local::TestConvertSuccCase<uint32_t>(static_cast<uint32_t>(3), "3");
+    Local::TestConvertSuccCase<uint32_t>(static_cast<uint32_t>(100), "100");
+}
+
+BOOST_AUTO_TEST_CASE(ConvertUInt64)
+{
+    Local::TestConvertSuccCase<uint64_t>(static_cast<uint64_t>(0), "0");
+    Local::TestConvertSuccCase<uint64_t>(static_cast<uint64_t>(3), "3");
+    Local::TestConvertSuccCase<uint64_t>(static_cast<uint64_t>(100), "100");
+}
+
+BOOST_AUTO_TEST_CASE(ConvertFloat)
+{
+    Local::TestConvertSuccCase<float>(static_cast<float>(-1), nullptr);
+    Local::TestConvertSuccCase<float>(static_cast<float>(0), nullptr);
+    Local::TestConvertSuccCase<float>(static_cast<float>(3), nullptr);
+    Local::TestConvertSuccCase<float>(static_cast<float>(100), nullptr);
+}
+
+BOOST_AUTO_TEST_CASE(ConvertDouble)
+{
+    Local::TestConvertSuccCase<double>(static_cast<double>(-1), nullptr);
+    Local::TestConvertSuccCase<double>(static_cast<double>(0), nullptr);
+    Local::TestConvertSuccCase<double>(static_cast<double>(3), nullptr);
+    Local::TestConvertSuccCase<double>(static_cast<double>(100), nullptr);
+}
+
+BOOST_AUTO_TEST_CASE(ConvertIndexAlgoType)
+{
+    Local::TestConvertSuccCase<SPTAG::IndexAlgoType>(SPTAG::IndexAlgoType::BKT, "BKT");
+    Local::TestConvertSuccCase<SPTAG::IndexAlgoType>(SPTAG::IndexAlgoType::KDT, "KDT");
+}
+
+BOOST_AUTO_TEST_CASE(ConvertVectorValueType)
+{
+    Local::TestConvertSuccCase<SPTAG::VectorValueType>(SPTAG::VectorValueType::Float, "Float");
+    Local::TestConvertSuccCase<SPTAG::VectorValueType>(SPTAG::VectorValueType::Int8, "Int8");
+    Local::TestConvertSuccCase<SPTAG::VectorValueType>(SPTAG::VectorValueType::Int16, "Int16");
+}
+
+BOOST_AUTO_TEST_CASE(ConvertDistCalcMethod)
+{
+    Local::TestConvertSuccCase<SPTAG::DistCalcMethod>(SPTAG::DistCalcMethod::Cosine, "Cosine");
+    Local::TestConvertSuccCase<SPTAG::DistCalcMethod>(SPTAG::DistCalcMethod::L2, "L2");
+}
+
+BOOST_AUTO_TEST_SUITE_END()
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/Test/src/main.cpp b/core/src/index/thirdparty/SPTAG/Test/src/main.cpp
new file mode 100644
index 0000000000..7bf61ea119
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/Test/src/main.cpp
@@ -0,0 +1,41 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#define BOOST_TEST_MAIN
+#define BOOST_TEST_MODULE Main
+#include "inc/Test.h"
+
+#include <string>
+#include <boost/test/tree/visitor.hpp>
+
+using namespace boost::unit_test;
+
+class SPTAGVisitor : public test_tree_visitor
+{
+public:
+    void visit(test_case const& test)
+    {
+        std::string prefix(2, '\t');
+        std::cout << prefix << "Case: " << test.p_name << std::endl;
+    }
+
+    bool test_suite_start(test_suite const& suite)
+    {
+        std::string prefix(1, '\t');
+        std::cout << prefix << "Suite: " << suite.p_name << std::endl;
+        return true;
+    }
+};
+
+struct GlobalFixture
+{
+    GlobalFixture()
+    {
+        SPTAGVisitor visitor;
+        traverse_test_tree(framework::master_test_suite(), visitor, false);
+    }
+
+};
+
+BOOST_TEST_GLOBAL_FIXTURE(GlobalFixture);
+
diff --git a/core/src/index/thirdparty/SPTAG/Wrappers/CLRCore.vcxproj b/core/src/index/thirdparty/SPTAG/Wrappers/CLRCore.vcxproj
new file mode 100644
index 0000000000..efb4d0f259
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/Wrappers/CLRCore.vcxproj
@@ -0,0 +1,141 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>15.0</VCProjectVersion>
+    <ProjectGuid>{38ACBA6C-2E50-44D4-9A6D-DC735B56E38F}</ProjectGuid>
+    <TargetFrameworkVersion>v4.5.2</TargetFrameworkVersion>
+    <Keyword>ManagedCProj</Keyword>
+    <RootNamespace>CLRCore</RootNamespace>
+    <WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <Import Project="$(SolutionDir)\AnnService.users.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <CLRSupport>true</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <CLRSupport>true</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <CLRSupport>true</CLRSupport>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <CLRSupport>true</CLRSupport>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup>
+    <TargetName>Microsoft.ANN.SPTAGManaged</TargetName>
+    <TargetExt>.dll</TargetExt>
+    <IntDir>$(SolutionDir)obj\$(Platform)_$(Configuration)\$(ProjectName)\</IntDir>
+    <IncludePath>$(ProjectDir);$(SolutionDir)AnnService\;$(IncludePath)</IncludePath>
+    <LibraryPath>$(OutLibDir);$(LibraryPath)</LibraryPath>
+    <OutDir>$(OutAppDir)</OutDir>
+  </PropertyGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>_DEBUG;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <OpenMPSupport>true</OpenMPSupport>
+    </ClCompile>
+    <Link>
+      <AdditionalDependencies>CoreLibrary.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>NDEBUG;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <OpenMPSupport>true</OpenMPSupport>
+    </ClCompile>
+    <Link>
+      <AdditionalDependencies>CoreLibrary.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="inc\CLRCoreInterface.h" />
+    <ClInclude Include="inc\ManagedObject.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="src\AssemblyInfo.cpp" />
+    <ClCompile Include="src\CLRCoreInterface.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="$(SolutionDir)AnnService\CoreLibrary.vcxproj">
+      <Project>{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}</Project>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/Wrappers/CLRCore.vcxproj.filters b/core/src/index/thirdparty/SPTAG/Wrappers/CLRCore.vcxproj.filters
new file mode 100644
index 0000000000..c0c35e9683
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/Wrappers/CLRCore.vcxproj.filters
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
+    </Filter>
+    <Filter Include="Resources">
+      <UniqueIdentifier>{ba4289c4-f872-4dbc-a57f-7b415614afb3}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="inc\CLRCoreInterface.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\ManagedObject.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="src\CLRCoreInterface.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="src\AssemblyInfo.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/Wrappers/CMakeLists.txt b/core/src/index/thirdparty/SPTAG/Wrappers/CMakeLists.txt
new file mode 100644
index 0000000000..514367978e
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/Wrappers/CMakeLists.txt
@@ -0,0 +1,171 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+
+find_package(Python2 COMPONENTS Development)
+if (Python2_FOUND)    
+    include_directories (${Python2_INCLUDE_DIRS})
+    link_directories (${Python2_LIBRARY_DIRS})
+    set (Python_INCLUDE_DIRS ${Python2_INCLUDE_DIRS})
+    set (Python_LIBRARIES ${Python2_LIBRARIES})
+    set (Python_FOUND true)
+else()
+    find_package(Python3 COMPONENTS Development)
+    if (Python3_FOUND)
+        include_directories (${Python3_INCLUDE_DIRS})
+        link_directories (${Python3_LIBRARY_DIRS})
+        set (Python_INCLUDE_DIRS ${Python3_INCLUDE_DIRS})
+        set (Python_LIBRARIES ${Python3_LIBRARIES})
+        set (Python_FOUND true)
+    endif()
+endif()
+
+if (Python_FOUND)
+    message (STATUS "Found Python.")
+    message (STATUS "Include Path: ${Python_INCLUDE_DIRS}")
+    message (STATUS "Library Path: ${Python_LIBRARIES}")
+
+    if (WIN32)
+        set(PY_SUFFIX .pyd)
+    else()
+        set(PY_SUFFIX .so)
+    endif()
+
+    execute_process(COMMAND swig -python -c++ -I${PROJECT_SOURCE_DIR}/Wrappers/inc -o ${PROJECT_SOURCE_DIR}/Wrappers/inc/CoreInterface_pwrap.cpp ${PROJECT_SOURCE_DIR}/Wrappers/inc/PythonCore.i)
+    execute_process(COMMAND swig -python -c++ -I${PROJECT_SOURCE_DIR}/Wrappers/inc -o ${PROJECT_SOURCE_DIR}/Wrappers/inc/ClientInterface_pwrap.cpp ${PROJECT_SOURCE_DIR}/Wrappers/inc/PythonClient.i)
+
+    include_directories(${PYTHON_INCLUDE_PATH} ${PROJECT_SOURCE_DIR}/AnnService ${PROJECT_SOURCE_DIR}/Wrappers)
+
+    file(GLOB CORE_HDR_FILES ${PROJECT_SOURCE_DIR}/Wrappers/inc/CoreInterface.h)
+    file(GLOB CORE_SRC_FILES ${PROJECT_SOURCE_DIR}/Wrappers/src/CoreInterface.cpp ${PROJECT_SOURCE_DIR}/Wrappers/inc/CoreInterface_pwrap.cpp)
+    add_library (_SPTAG SHARED ${CORE_SRC_FILES} ${CORE_HDR_FILES})
+    set_target_properties(_SPTAG PROPERTIES PREFIX "" SUFFIX ${PY_SUFFIX})
+    target_link_libraries(_SPTAG SPTAGLib ${Python_LIBRARIES})
+    add_custom_command(TARGET _SPTAG POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy ${PROJECT_SOURCE_DIR}/Wrappers/inc/SPTAG.py ${EXECUTABLE_OUTPUT_PATH})
+
+    file(GLOB CLIENT_HDR_FILES ${PROJECT_SOURCE_DIR}/Wrappers/inc/ClientInterface.h ${PROJECT_SOURCE_DIR}/AnnService/inc/Socket/*.h ${PROJECT_SOURCE_DIR}/AnnService/inc/Client/*.h)
+    file(GLOB CLIENT_SRC_FILES ${PROJECT_SOURCE_DIR}/Wrappers/src/ClientInterface.cpp ${PROJECT_SOURCE_DIR}/AnnService/src/Socket/*.cpp ${PROJECT_SOURCE_DIR}/AnnService/src/Client/*.cpp ${PROJECT_SOURCE_DIR}/Wrappers/inc/ClientInterface_pwrap.cpp)
+    add_library (_SPTAGClient SHARED ${CLIENT_SRC_FILES} ${CLIENT_HDR_FILES})
+    set_target_properties(_SPTAGClient PROPERTIES PREFIX "" SUFFIX ${PY_SUFFIX})
+    target_link_libraries(_SPTAGClient SPTAGLib ${Python_LIBRARIES} ${Boost_LIBRARIES})
+    add_custom_command(TARGET _SPTAGClient POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy ${PROJECT_SOURCE_DIR}/Wrappers/inc/SPTAGClient.py ${EXECUTABLE_OUTPUT_PATH})
+
+    install(TARGETS _SPTAG _SPTAGClient
+    RUNTIME DESTINATION bin
+    ARCHIVE DESTINATION lib
+    LIBRARY DESTINATION lib)
+    install(FILES ${PROJECT_SOURCE_DIR}/Wrappers/src/SPTAG.py ${PROJECT_SOURCE_DIR}/Wrappers/inc/SPTAGClient.py DESTINATION bin)
+else()
+    message (STATUS "Could not find Python.")
+endif()
+
+find_package(JNI)
+if (JNI_FOUND)
+    include_directories (${JNI_INCLUDE_DIRS})
+    link_directories (${JNI_LIBRARY_DIRS})
+    message (STATUS "Found JNI.")
+    message (STATUS "Include Path: ${JNI_INCLUDE_DIRS}")
+    message (STATUS "Library Path: ${JNI_LIBRARIES}")
+
+    if (WIN32)
+        set (JAVA_SUFFIX .dll)
+    else()
+        set (JAVA_SUFFIX .so)
+    endif()
+
+    execute_process(COMMAND swig -java -c++ -I${PROJECT_SOURCE_DIR}/Wrappers/inc -o ${PROJECT_SOURCE_DIR}/Wrappers/inc/CoreInterface_jwrap.cpp ${PROJECT_SOURCE_DIR}/Wrappers/inc/JavaCore.i)
+    execute_process(COMMAND swig -java -c++ -I${PROJECT_SOURCE_DIR}/Wrappers/inc -o ${PROJECT_SOURCE_DIR}/Wrappers/inc/ClientInterface_jwrap.cpp ${PROJECT_SOURCE_DIR}/Wrappers/inc/JavaClient.i)
+
+    include_directories(${JNI_INCLUDE_DIRS} ${PROJECT_SOURCE_DIR}/AnnService ${PROJECT_SOURCE_DIR}/Wrappers)
+
+    file(GLOB CORE_HDR_FILES ${PROJECT_SOURCE_DIR}/Wrappers/inc/CoreInterface.h)
+    file(GLOB CORE_SRC_FILES ${PROJECT_SOURCE_DIR}/Wrappers/src/CoreInterface.cpp ${PROJECT_SOURCE_DIR}/Wrappers/inc/CoreInterface_jwrap.cpp)
+    add_library (JAVASPTAG SHARED ${CORE_SRC_FILES} ${CORE_HDR_FILES})
+    set_target_properties(JAVASPTAG PROPERTIES SUFFIX ${JAVA_SUFFIX})
+    target_link_libraries(JAVASPTAG SPTAGLib ${JNI_LIBRARIES})
+
+    file(GLOB CLIENT_HDR_FILES ${PROJECT_SOURCE_DIR}/Wrappers/inc/ClientInterface.h ${PROJECT_SOURCE_DIR}/AnnService/inc/Socket/*.h ${PROJECT_SOURCE_DIR}/AnnService/inc/Client/*.h)
+    file(GLOB CLIENT_SRC_FILES ${PROJECT_SOURCE_DIR}/Wrappers/src/ClientInterface.cpp ${PROJECT_SOURCE_DIR}/AnnService/src/Socket/*.cpp ${PROJECT_SOURCE_DIR}/AnnService/src/Client/*.cpp ${PROJECT_SOURCE_DIR}/Wrappers/inc/ClientInterface_jwrap.cpp)
+    add_library (JAVASPTAGClient SHARED ${CLIENT_SRC_FILES} ${CLIENT_HDR_FILES})
+    set_target_properties(JAVASPTAGClient PROPERTIES SUFFIX ${JAVA_SUFFIX})
+    target_link_libraries(JAVASPTAGClient SPTAGLib ${JNI_LIBRARIES} ${Boost_LIBRARIES})
+
+    file(GLOB JAVA_FILES ${PROJECT_SOURCE_DIR}/Wrappers/inc/*.java)
+    foreach(JAVA_FILE ${JAVA_FILES})
+        message (STATUS "Add copy post-command for file " ${JAVA_FILE})
+        add_custom_command(TARGET JAVASPTAGClient POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy ${JAVA_FILE} ${EXECUTABLE_OUTPUT_PATH})
+    endforeach(JAVA_FILE)
+
+    install(TARGETS JAVASPTAG JAVASPTAGClient
+    RUNTIME DESTINATION bin
+    ARCHIVE DESTINATION lib
+    LIBRARY DESTINATION lib)
+    install(FILES ${PROJECT_SOURCE_DIR}/Wrappers/inc/*.java DESTINATION bin)
+else()
+    message (STATUS "Could not find JNI.")
+endif()
+
+if (WIN32)
+    if (${PROJECTNAME_ARCHITECTURE} MATCHES "x64")
+        set (csharp_dotnet_framework_hints "$ENV{windir}\\Microsoft.NET\\Framework64")
+    else()
+        set (csharp_dotnet_framework_hints "$ENV{windir}\\Microsoft.NET\\Framework")
+    endif()
+
+    file(GLOB_RECURSE csharp_dotnet_executables ${csharp_dotnet_framework_hints}/csc.exe)
+    list(SORT csharp_dotnet_executables)
+    list(REVERSE csharp_dotnet_executables)
+    foreach (csharp_dotnet_executable ${csharp_dotnet_executables})
+        if (NOT DEFINED DOTNET_FOUND)
+            string(REPLACE "${csharp_dotnet_framework_hints}/" "" csharp_dotnet_version_temp ${csharp_dotnet_executable})
+            string(REPLACE "/csc.exe" "" csharp_dotnet_version_temp ${csharp_dotnet_version_temp})
+        
+            set (DOTNET_EXECUTABLE_VERSION "${csharp_dotnet_version_temp}" CACHE STRING "C# .NET compiler version" FORCE)
+            set (DOTNET_FOUND ${csharp_dotnet_executable})
+        endif()
+    endforeach(csharp_dotnet_executable)
+else()
+    FIND_PROGRAM(DOTNET_FOUND dotnet)
+endif()
+
+if (DOTNET_FOUND)
+    message (STATUS "Found dotnet.")
+    message (STATUS "DOTNET_EXECUTABLE: " ${DOTNET_FOUND})
+
+    if (WIN32)
+        set (CSHARP_SUFFIX .dll)
+    else()
+        set (CSHARP_SUFFIX .so)
+    endif()
+
+    execute_process(COMMAND swig -csharp -c++ -I${PROJECT_SOURCE_DIR}/Wrappers/inc -o ${PROJECT_SOURCE_DIR}/Wrappers/inc/CoreInterface_cwrap.cpp ${PROJECT_SOURCE_DIR}/Wrappers/inc/CsharpCore.i)
+    execute_process(COMMAND swig -csharp -c++ -I${PROJECT_SOURCE_DIR}/Wrappers/inc -o ${PROJECT_SOURCE_DIR}/Wrappers/inc/ClientInterface_cwrap.cpp ${PROJECT_SOURCE_DIR}/Wrappers/inc/CsharpClient.i)
+
+    include_directories(${PROJECT_SOURCE_DIR}/AnnService ${PROJECT_SOURCE_DIR}/Wrappers)
+
+    file(GLOB CORE_HDR_FILES ${PROJECT_SOURCE_DIR}/Wrappers/inc/CoreInterface.h)
+    file(GLOB CORE_SRC_FILES ${PROJECT_SOURCE_DIR}/Wrappers/src/CoreInterface.cpp ${PROJECT_SOURCE_DIR}/Wrappers/inc/CoreInterface_cwrap.cpp)
+    add_library (CSHARPSPTAG SHARED ${CORE_SRC_FILES} ${CORE_HDR_FILES})
+    set_target_properties(CSHARPSPTAG PROPERTIES SUFFIX ${CSHARP_SUFFIX})
+    target_link_libraries(CSHARPSPTAG SPTAGLib)
+
+    file(GLOB CLIENT_HDR_FILES ${PROJECT_SOURCE_DIR}/Wrappers/inc/ClientInterface.h ${PROJECT_SOURCE_DIR}/AnnService/inc/Socket/*.h ${PROJECT_SOURCE_DIR}/AnnService/inc/Client/*.h)
+    file(GLOB CLIENT_SRC_FILES ${PROJECT_SOURCE_DIR}/Wrappers/src/ClientInterface.cpp ${PROJECT_SOURCE_DIR}/AnnService/src/Socket/*.cpp ${PROJECT_SOURCE_DIR}/AnnService/src/Client/*.cpp ${PROJECT_SOURCE_DIR}/Wrappers/inc/ClientInterface_cwrap.cpp)
+    add_library (CSHARPSPTAGClient SHARED ${CLIENT_SRC_FILES} ${CLIENT_HDR_FILES})
+    set_target_properties(CSHARPSPTAGClient PROPERTIES SUFFIX ${CSHARP_SUFFIX})
+    target_link_libraries(CSHARPSPTAGClient SPTAGLib ${Boost_LIBRARIES})
+
+    file(GLOB CSHARP_FILES ${PROJECT_SOURCE_DIR}/Wrappers/inc/*.cs)
+    foreach(CSHARP_FILE ${CSHARP_FILES})
+        message (STATUS "Add copy post-command for file " ${CSHARP_FILE})
+        add_custom_command(TARGET CSHARPSPTAGClient POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy ${CSHARP_FILE} ${EXECUTABLE_OUTPUT_PATH})
+    endforeach(CSHARP_FILE)
+
+    install(TARGETS CSHARPSPTAG CSHARPSPTAGClient
+    RUNTIME DESTINATION bin
+    ARCHIVE DESTINATION lib
+    LIBRARY DESTINATION lib)
+    install(FILES ${PROJECT_SOURCE_DIR}/Wrappers/inc/*.cs DESTINATION bin)
+else()
+    message (STATUS "Could not find C#.")
+endif()
+
diff --git a/core/src/index/thirdparty/SPTAG/Wrappers/CsharpClient.vcxproj b/core/src/index/thirdparty/SPTAG/Wrappers/CsharpClient.vcxproj
new file mode 100644
index 0000000000..d7d17102d8
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/Wrappers/CsharpClient.vcxproj
@@ -0,0 +1,191 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>15.0</VCProjectVersion>
+    <ProjectGuid>{363BA3BB-75C4-4CC7-AECB-28C7534B3710}</ProjectGuid>
+    <RootNamespace>CsharpClient</RootNamespace>
+    <WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <Import Project="$(SolutionDir)\AnnService.users.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup>
+    <TargetName>CSHARPSPTAGClient</TargetName>
+    <TargetExt>.dll</TargetExt>
+    <IntDir>$(SolutionDir)obj\$(Platform)_$(Configuration)\$(ProjectName)\</IntDir>
+    <IncludePath>$(ProjectDir);$(SolutionDir)AnnService\;$(IncludePath)</IncludePath>
+    <LibraryPath>$(OutLibDir);$(LibraryPath)</LibraryPath>
+    <OutDir>$(OutAppDir)</OutDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <Link>
+      <AdditionalDependencies>CoreLibrary.lib;SocketLib.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <AdditionalIncludeDirectories>%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <ConformanceMode>true</ConformanceMode>
+      <PreprocessorDefinitions>_WINDLL;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <SDLCheck>true</SDLCheck>
+      <ConformanceMode>true</ConformanceMode>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <SDLCheck>true</SDLCheck>
+      <ConformanceMode>true</ConformanceMode>
+      <PreprocessorDefinitions>_WINDLL;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ControlFlowGuard>Guard</ControlFlowGuard>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+    </ClCompile>
+    <Link>
+      <AdditionalOptions>/guard:cf %(AdditionalOptions)</AdditionalOptions>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <ConformanceMode>true</ConformanceMode>
+    </ClCompile>
+    <Link>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="inc\ClientInterface.h" />
+    <ClInclude Include="inc\TransferDataType.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="src\ClientInterface.cpp" />
+    <ClCompile Include="$(IntDir)ClientInterface_cwrap.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="inc\CsharpClient.i">
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">false</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">false</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">false</ExcludedFromBuild>
+    </None>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="inc\CsharpCommon.i" />
+    <None Include="packages.config" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="..\packages\boost.1.67.0.0\build\boost.targets" Condition="Exists('..\packages\boost.1.67.0.0\build\boost.targets')" />
+    <Import Project="..\packages\boost_system-vc140.1.67.0.0\build\boost_system-vc140.targets" Condition="Exists('..\packages\boost_system-vc140.1.67.0.0\build\boost_system-vc140.targets')" />
+    <Import Project="..\packages\boost_date_time-vc140.1.67.0.0\build\boost_date_time-vc140.targets" Condition="Exists('..\packages\boost_date_time-vc140.1.67.0.0\build\boost_date_time-vc140.targets')" />
+    <Import Project="..\packages\boost_regex-vc140.1.67.0.0\build\boost_regex-vc140.targets" Condition="Exists('..\packages\boost_regex-vc140.1.67.0.0\build\boost_regex-vc140.targets')" />
+  </ImportGroup>
+  <Target Name="BeforeBuild" BeforeTargets="PrepareForBuild">
+    <MakeDir Directories="$(IntDir)" />
+    <Exec Command="$(SolutionDir)packages\swigwin.3.0.9\tools\swigwin-3.0.9\swig.exe -csharp -c++ -I$(IntDir) -outdir $(IntDir) -o $(IntDir)/ClientInterface_cwrap.cpp inc\CsharpClient.i" />
+  </Target>
+  <ItemGroup>
+    <MySourceFiles Include="$(IntDir)\*.cs" />
+  </ItemGroup>
+  <Target Name="CopyFiles" AfterTargets="BeforeBuild">
+    <Copy SourceFiles="@(MySourceFiles)" DestinationFolder="$(Outdir)" />
+  </Target>
+  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
+    <PropertyGroup>
+      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
+    </PropertyGroup>
+    <Error Condition="!Exists('..\packages\swigwin.3.0.9\tools\swigwin-3.0.9\swig.exe')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\swigwin.3.0.9\tools\swigwin-3.0.9\swig.exe'))" />
+    <Error Condition="!Exists('..\packages\boost.1.67.0.0\build\boost.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost.1.67.0.0\build\boost.targets'))" />
+    <Error Condition="!Exists('..\packages\boost_system-vc140.1.67.0.0\build\boost_system-vc140.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost_system-vc140.1.67.0.0\build\boost_system-vc140.targets'))" />
+    <Error Condition="!Exists('..\packages\boost_date_time-vc140.1.67.0.0\build\boost_date_time-vc140.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost_date_time-vc140.1.67.0.0\build\boost_date_time-vc140.targets'))" />
+    <Error Condition="!Exists('..\packages\boost_regex-vc140.1.67.0.0\build\boost_regex-vc140.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost_regex-vc140.1.67.0.0\build\boost_regex-vc140.targets'))" />
+  </Target>
+</Project>
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/Wrappers/CsharpClient.vcxproj.filters b/core/src/index/thirdparty/SPTAG/Wrappers/CsharpClient.vcxproj.filters
new file mode 100644
index 0000000000..589c50014d
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/Wrappers/CsharpClient.vcxproj.filters
@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
+    </Filter>
+    <Filter Include="Resource Files">
+      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="inc\ClientInterface.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\TransferDataType.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="src\ClientInterface.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="$(IntDir)ClientInterface_cwrap.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="inc\CsharpClient.i">
+      <Filter>Resource Files</Filter>
+    </None>
+    <None Include="inc\CsharpCommon.i">
+      <Filter>Resource Files</Filter>
+    </None>
+  </ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/Wrappers/CsharpCore.vcxproj b/core/src/index/thirdparty/SPTAG/Wrappers/CsharpCore.vcxproj
new file mode 100644
index 0000000000..e809d8b901
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/Wrappers/CsharpCore.vcxproj
@@ -0,0 +1,134 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>15.0</VCProjectVersion>
+    <ProjectGuid>{1896C009-AD46-4A70-B83C-4652A7F37503}</ProjectGuid>
+    <RootNamespace>CsharpCore</RootNamespace>
+    <WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <Import Project="$(SolutionDir)\AnnService.users.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup>
+    <TargetName>CSHARPSPTAG</TargetName>
+    <TargetExt>.dll</TargetExt>
+    <IntDir>$(SolutionDir)obj\$(Platform)_$(Configuration)\$(ProjectName)\</IntDir>
+    <IncludePath>$(ProjectDir);$(SolutionDir)AnnService\;$(IncludePath)</IncludePath>
+    <LibraryPath>$(OutLibDir);$(LibraryPath)</LibraryPath>
+    <OutDir>$(OutAppDir)</OutDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <Link>
+      <AdditionalDependencies>CoreLibrary.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">_WINDLL;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <ControlFlowGuard Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Guard</ControlFlowGuard>
+      <DebugInformationFormat Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">ProgramDatabase</DebugInformationFormat>
+      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Release|x64'">_WINDLL;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <AdditionalOptions Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">/guard:cf %(AdditionalOptions)</AdditionalOptions>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="inc\CoreInterface.h" />
+    <ClInclude Include="inc\TransferDataType.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="src\CoreInterface.cpp" />
+    <ClCompile Include="$(IntDir)CoreInterface_cwrap.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="inc\CsharpCommon.i" />
+    <None Include="inc\CsharpCore.i" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+  <Target Name="BeforeBuild" BeforeTargets="PrepareForBuild">
+    <MakeDir Directories="$(IntDir)" />
+    <Exec Command="$(SolutionDir)packages\swigwin.3.0.9\tools\swigwin-3.0.9\swig.exe -csharp -c++ -I$(IntDir) -outdir $(IntDir) -o $(IntDir)CoreInterface_cwrap.cpp inc\CsharpCore.i" />
+  </Target>
+  <ItemGroup>
+    <MySourceFiles Include="$(IntDir)\*.cs" />
+  </ItemGroup>
+  <Target Name="CopyFiles" AfterTargets="BeforeBuild">
+    <Copy SourceFiles="@(MySourceFiles)" DestinationFolder="$(Outdir)" />
+  </Target>
+  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
+    <PropertyGroup>
+      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
+    </PropertyGroup>
+    <Error Condition="!Exists('..\packages\swigwin.3.0.9\tools\swigwin-3.0.9\swig.exe')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\swigwin.3.0.9\tools\swigwin-3.0.9\swig.exe'))" />
+  </Target>
+</Project>
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/Wrappers/CsharpCore.vcxproj.filters b/core/src/index/thirdparty/SPTAG/Wrappers/CsharpCore.vcxproj.filters
new file mode 100644
index 0000000000..51b1ec0ce6
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/Wrappers/CsharpCore.vcxproj.filters
@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
+    </Filter>
+    <Filter Include="Resources">
+      <UniqueIdentifier>{ba4289c4-f872-4dbc-a57f-7b415614afb3}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="inc\CoreInterface.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\TransferDataType.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="src\CoreInterface.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="$(IntDir)CoreInterface_cwrap.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="inc\CsharpCore.i">
+      <Filter>Resources</Filter>
+    </None>
+    <None Include="inc\CsharpCommon.i">
+      <Filter>Resources</Filter>
+    </None>
+  </ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/Wrappers/JavaClient.vcxproj b/core/src/index/thirdparty/SPTAG/Wrappers/JavaClient.vcxproj
new file mode 100644
index 0000000000..2ee36ac620
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/Wrappers/JavaClient.vcxproj
@@ -0,0 +1,191 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>15.0</VCProjectVersion>
+    <ProjectGuid>{8866BF98-AA2E-450F-9F33-083E007CCA74}</ProjectGuid>
+    <RootNamespace>JavaClient</RootNamespace>
+    <WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <Import Project="$(SolutionDir)\AnnService.users.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup>
+    <TargetName>JAVASPTAGClient</TargetName>
+    <TargetExt>.dll</TargetExt>
+    <IntDir>$(SolutionDir)obj\$(Platform)_$(Configuration)\$(ProjectName)\</IntDir>
+    <IncludePath>$(ProjectDir);$(SolutionDir)AnnService\;$(IncludePath)</IncludePath>
+    <LibraryPath>$(OutLibDir);$(LibraryPath)</LibraryPath>
+    <OutDir>$(OutAppDir)</OutDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <Link>
+      <AdditionalDependencies>$(JavaLib);CoreLibrary.lib;SocketLib.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <AdditionalIncludeDirectories>$(JavaIncDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <ConformanceMode>true</ConformanceMode>
+      <PreprocessorDefinitions>_WINDLL;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <SDLCheck>true</SDLCheck>
+      <ConformanceMode>true</ConformanceMode>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <SDLCheck>true</SDLCheck>
+      <ConformanceMode>true</ConformanceMode>
+      <PreprocessorDefinitions>_WINDLL;_SCL_SECURE_NO_WARNINGS;SWIG_JAVA_INTERPRETER_NO_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ControlFlowGuard>Guard</ControlFlowGuard>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+    </ClCompile>
+    <Link>
+      <AdditionalOptions>/guard:cf %(AdditionalOptions)</AdditionalOptions>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <ConformanceMode>true</ConformanceMode>
+    </ClCompile>
+    <Link>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="inc\ClientInterface.h" />
+    <ClInclude Include="inc\TransferDataType.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="src\ClientInterface.cpp" />
+    <ClCompile Include="$(IntDir)ClientInterface_jwrap.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="inc\JavaClient.i">
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">false</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">false</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">false</ExcludedFromBuild>
+    </None>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="inc\JavaCommon.i" />
+    <None Include="packages.config" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="..\packages\boost.1.67.0.0\build\boost.targets" Condition="Exists('..\packages\boost.1.67.0.0\build\boost.targets')" />
+    <Import Project="..\packages\boost_system-vc140.1.67.0.0\build\boost_system-vc140.targets" Condition="Exists('..\packages\boost_system-vc140.1.67.0.0\build\boost_system-vc140.targets')" />
+    <Import Project="..\packages\boost_date_time-vc140.1.67.0.0\build\boost_date_time-vc140.targets" Condition="Exists('..\packages\boost_date_time-vc140.1.67.0.0\build\boost_date_time-vc140.targets')" />
+    <Import Project="..\packages\boost_regex-vc140.1.67.0.0\build\boost_regex-vc140.targets" Condition="Exists('..\packages\boost_regex-vc140.1.67.0.0\build\boost_regex-vc140.targets')" />
+  </ImportGroup>
+  <Target Name="BeforeBuild" BeforeTargets="PrepareForBuild">
+    <MakeDir Directories="$(IntDir)" />
+    <Exec Command="$(SolutionDir)packages\swigwin.3.0.9\tools\swigwin-3.0.9\swig.exe -java -c++ -I$(IntDir) -outdir $(IntDir) -o $(IntDir)/ClientInterface_jwrap.cpp inc\JavaClient.i" />
+  </Target>
+  <ItemGroup>
+    <MySourceFiles Include="$(IntDir)\*.java" />
+  </ItemGroup>
+  <Target Name="CopyFiles" AfterTargets="BeforeBuild">
+    <Copy SourceFiles="@(MySourceFiles)" DestinationFolder="$(Outdir)" />
+  </Target>
+  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
+    <PropertyGroup>
+      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
+    </PropertyGroup>
+    <Error Condition="!Exists('..\packages\swigwin.3.0.9\tools\swigwin-3.0.9\swig.exe')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\swigwin.3.0.9\tools\swigwin-3.0.9\swig.exe'))" />
+    <Error Condition="!Exists('..\packages\boost.1.67.0.0\build\boost.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost.1.67.0.0\build\boost.targets'))" />
+    <Error Condition="!Exists('..\packages\boost_system-vc140.1.67.0.0\build\boost_system-vc140.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost_system-vc140.1.67.0.0\build\boost_system-vc140.targets'))" />
+    <Error Condition="!Exists('..\packages\boost_date_time-vc140.1.67.0.0\build\boost_date_time-vc140.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost_date_time-vc140.1.67.0.0\build\boost_date_time-vc140.targets'))" />
+    <Error Condition="!Exists('..\packages\boost_regex-vc140.1.67.0.0\build\boost_regex-vc140.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost_regex-vc140.1.67.0.0\build\boost_regex-vc140.targets'))" />
+  </Target>
+</Project>
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/Wrappers/JavaClient.vcxproj.filters b/core/src/index/thirdparty/SPTAG/Wrappers/JavaClient.vcxproj.filters
new file mode 100644
index 0000000000..0d047923aa
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/Wrappers/JavaClient.vcxproj.filters
@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
+    </Filter>
+    <Filter Include="Resource Files">
+      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="inc\ClientInterface.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\TransferDataType.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="src\ClientInterface.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="$(IntDir)ClientInterface_jwrap.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="inc\JavaClient.i">
+      <Filter>Resource Files</Filter>
+    </None>
+    <None Include="inc\JavaCommon.i">
+      <Filter>Resource Files</Filter>
+    </None>
+  </ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/Wrappers/JavaCore.vcxproj b/core/src/index/thirdparty/SPTAG/Wrappers/JavaCore.vcxproj
new file mode 100644
index 0000000000..f15c0e005f
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/Wrappers/JavaCore.vcxproj
@@ -0,0 +1,134 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>15.0</VCProjectVersion>
+    <ProjectGuid>{93FEB26B-965E-4157-8BE5-052F5CA112BB}</ProjectGuid>
+    <RootNamespace>JavaCore</RootNamespace>
+    <WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <Import Project="$(SolutionDir)\AnnService.users.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup>
+    <TargetName>JAVASPTAG</TargetName>
+    <TargetExt>.dll</TargetExt>
+    <IntDir>$(SolutionDir)obj\$(Platform)_$(Configuration)\$(ProjectName)\</IntDir>
+    <IncludePath>$(ProjectDir);$(SolutionDir)AnnService\;$(IncludePath)</IncludePath>
+    <LibraryPath>$(OutLibDir);$(LibraryPath)</LibraryPath>
+    <OutDir>$(OutAppDir)</OutDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <Link>
+      <AdditionalDependencies>$(JavaLib);CoreLibrary.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">_WINDLL;SWIG_JAVA_INTERPRETER_NO_DEBUG;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>$(JavaIncDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <ControlFlowGuard Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Guard</ControlFlowGuard>
+      <DebugInformationFormat Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">ProgramDatabase</DebugInformationFormat>
+      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Release|x64'">_WINDLL;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <AdditionalOptions Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">/guard:cf %(AdditionalOptions)</AdditionalOptions>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="inc\CoreInterface.h" />
+    <ClInclude Include="inc\TransferDataType.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="src\CoreInterface.cpp" />
+    <ClCompile Include="$(IntDir)CoreInterface_jwrap.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="inc\JavaCommon.i" />
+    <None Include="inc\JavaCore.i" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+  <Target Name="BeforeBuild" BeforeTargets="PrepareForBuild">
+    <MakeDir Directories="$(IntDir)" />
+    <Exec Command="$(SolutionDir)packages\swigwin.3.0.9\tools\swigwin-3.0.9\swig.exe -java -c++ -I$(IntDir) -outdir $(IntDir) -o $(IntDir)CoreInterface_jwrap.cpp inc\JavaCore.i" />
+  </Target>
+  <ItemGroup>
+    <MySourceFiles Include="$(IntDir)\*.java" />
+  </ItemGroup>
+  <Target Name="CopyFiles" AfterTargets="BeforeBuild">
+    <Copy SourceFiles="@(MySourceFiles)" DestinationFolder="$(Outdir)" />
+  </Target>
+  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
+    <PropertyGroup>
+      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
+    </PropertyGroup>
+    <Error Condition="!Exists('..\packages\swigwin.3.0.9\tools\swigwin-3.0.9\swig.exe')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\swigwin.3.0.9\tools\swigwin-3.0.9\swig.exe'))" />
+  </Target>
+</Project>
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/Wrappers/JavaCore.vcxproj.filters b/core/src/index/thirdparty/SPTAG/Wrappers/JavaCore.vcxproj.filters
new file mode 100644
index 0000000000..851552684d
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/Wrappers/JavaCore.vcxproj.filters
@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
+    </Filter>
+    <Filter Include="Resources">
+      <UniqueIdentifier>{ba4289c4-f872-4dbc-a57f-7b415614afb3}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="inc\CoreInterface.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\TransferDataType.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="src\CoreInterface.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="$(IntDir)CoreInterface_jwrap.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="inc\JavaCore.i">
+      <Filter>Resources</Filter>
+    </None>
+    <None Include="inc\JavaCommon.i">
+      <Filter>Resources</Filter>
+    </None>
+  </ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/Wrappers/PythonClient.vcxproj b/core/src/index/thirdparty/SPTAG/Wrappers/PythonClient.vcxproj
new file mode 100644
index 0000000000..5cf2c2a9cf
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/Wrappers/PythonClient.vcxproj
@@ -0,0 +1,189 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>15.0</VCProjectVersion>
+    <ProjectGuid>{9B014CF6-E3FB-4BD4-B3B1-D26297BB31AA}</ProjectGuid>
+    <RootNamespace>PythonClient</RootNamespace>
+    <WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <Import Project="$(SolutionDir)\AnnService.users.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup>
+    <TargetName>_SPTAGClient</TargetName>
+    <TargetExt>.pyd</TargetExt>
+    <IntDir>$(SolutionDir)obj\$(Platform)_$(Configuration)\$(ProjectName)\</IntDir>
+    <IncludePath>$(ProjectDir);$(SolutionDir)AnnService\;$(IncludePath)</IncludePath>
+    <LibraryPath>$(OutLibDir);$(LibraryPath)</LibraryPath>
+    <OutDir>$(OutAppDir)</OutDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <Link>
+      <AdditionalDependencies>CoreLibrary.lib;SocketLib.lib;$(SolutionDir)packages\python2.2.7.15\tools\libs\python27.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <AdditionalIncludeDirectories>$(SolutionDir)packages\python2.2.7.15\tools\include\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <ConformanceMode>true</ConformanceMode>
+      <PreprocessorDefinitions>_WINDLL;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <SDLCheck>true</SDLCheck>
+      <ConformanceMode>true</ConformanceMode>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <SDLCheck>true</SDLCheck>
+      <ConformanceMode>true</ConformanceMode>
+      <PreprocessorDefinitions>_WINDLL;_SCL_SECURE_NO_WARNINGS;SWIG_PYTHON_INTERPRETER_NO_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ControlFlowGuard>Guard</ControlFlowGuard>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+    </ClCompile>
+    <Link>
+      <AdditionalOptions>/guard:cf %(AdditionalOptions)</AdditionalOptions>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <ConformanceMode>true</ConformanceMode>
+    </ClCompile>
+    <Link>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="inc\ClientInterface.h" />
+    <ClInclude Include="inc\TransferDataType.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="src\ClientInterface.cpp" />
+    <ClCompile Include="$(IntDir)ClientInterface_pwrap.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="inc\PythonClient.i">
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">false</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">false</ExcludedFromBuild>
+      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">false</ExcludedFromBuild>
+    </None>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="inc\PythonCommon.i" />
+    <None Include="packages.config" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+    <Import Project="..\packages\boost.1.67.0.0\build\boost.targets" Condition="Exists('..\packages\boost.1.67.0.0\build\boost.targets')" />
+    <Import Project="..\packages\boost_system-vc140.1.67.0.0\build\boost_system-vc140.targets" Condition="Exists('..\packages\boost_system-vc140.1.67.0.0\build\boost_system-vc140.targets')" />
+    <Import Project="..\packages\boost_date_time-vc140.1.67.0.0\build\boost_date_time-vc140.targets" Condition="Exists('..\packages\boost_date_time-vc140.1.67.0.0\build\boost_date_time-vc140.targets')" />
+    <Import Project="..\packages\boost_regex-vc140.1.67.0.0\build\boost_regex-vc140.targets" Condition="Exists('..\packages\boost_regex-vc140.1.67.0.0\build\boost_regex-vc140.targets')" />
+  </ImportGroup>
+  <Target Name="BeforeBuild" BeforeTargets="PrepareForBuild">
+    <MakeDir Directories="$(IntDir)" />
+    <Exec Command="$(SolutionDir)packages\swigwin.3.0.9\tools\swigwin-3.0.9\swig.exe -python -c++ -I$(IntDir) -outdir $(IntDir) -o $(IntDir)/ClientInterface_pwrap.cpp inc\PythonClient.i" />
+  </Target>
+  <Target Name="CopyFiles" AfterTargets="BeforeBuild">
+    <Copy SourceFiles="$(IntDir)SPTAGClient.py" DestinationFolder="$(Outdir)" />
+  </Target>
+  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
+    <PropertyGroup>
+      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
+    </PropertyGroup>
+    <Error Condition="!Exists('..\packages\python2.2.7.15\tools\python.exe')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\python2.2.7.15\tools\python.exe'))" />
+    <Error Condition="!Exists('..\packages\swigwin.3.0.9\tools\swigwin-3.0.9\swig.exe')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\swigwin.3.0.9\tools\swigwin-3.0.9\swig.exe'))" />
+    <Error Condition="!Exists('..\packages\boost.1.67.0.0\build\boost.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost.1.67.0.0\build\boost.targets'))" />
+    <Error Condition="!Exists('..\packages\boost_system-vc140.1.67.0.0\build\boost_system-vc140.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost_system-vc140.1.67.0.0\build\boost_system-vc140.targets'))" />
+    <Error Condition="!Exists('..\packages\boost_date_time-vc140.1.67.0.0\build\boost_date_time-vc140.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost_date_time-vc140.1.67.0.0\build\boost_date_time-vc140.targets'))" />
+    <Error Condition="!Exists('..\packages\boost_regex-vc140.1.67.0.0\build\boost_regex-vc140.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\boost_regex-vc140.1.67.0.0\build\boost_regex-vc140.targets'))" />
+  </Target>
+</Project>
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/Wrappers/PythonClient.vcxproj.filters b/core/src/index/thirdparty/SPTAG/Wrappers/PythonClient.vcxproj.filters
new file mode 100644
index 0000000000..84c71f0977
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/Wrappers/PythonClient.vcxproj.filters
@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
+    </Filter>
+    <Filter Include="Resource Files">
+      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="inc\ClientInterface.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\TransferDataType.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="src\ClientInterface.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="$(IntDir)ClientInterface_pwrap.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="inc\PythonClient.i">
+      <Filter>Resource Files</Filter>
+    </None>
+    <None Include="inc\PythonCommon.i">
+      <Filter>Resource Files</Filter>
+    </None>
+  </ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/Wrappers/PythonCore.vcxproj b/core/src/index/thirdparty/SPTAG/Wrappers/PythonCore.vcxproj
new file mode 100644
index 0000000000..7555ba97f4
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/Wrappers/PythonCore.vcxproj
@@ -0,0 +1,132 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>15.0</VCProjectVersion>
+    <ProjectGuid>{AF31947C-0495-42FE-A1AD-8F0DA2A679C7}</ProjectGuid>
+    <RootNamespace>PythonCore</RootNamespace>
+    <WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <Import Project="$(SolutionDir)\AnnService.users.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v140</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup>
+    <TargetName>_SPTAG</TargetName>
+    <TargetExt>.pyd</TargetExt>
+    <IntDir>$(SolutionDir)obj\$(Platform)_$(Configuration)\$(ProjectName)\</IntDir>
+    <IncludePath>$(ProjectDir);$(SolutionDir)AnnService\;$(IncludePath)</IncludePath>
+    <LibraryPath>$(OutLibDir);$(LibraryPath)</LibraryPath>
+    <OutDir>$(OutAppDir)</OutDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <Link>
+      <AdditionalDependencies>CoreLibrary.lib;$(SolutionDir)packages\python2.2.7.15\tools\libs\python27.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">_WINDLL;SWIG_PYTHON_INTERPRETER_NO_DEBUG;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <AdditionalIncludeDirectories>$(SolutionDir)packages\python2.2.7.15\tools\include\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <ControlFlowGuard Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Guard</ControlFlowGuard>
+      <DebugInformationFormat Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">ProgramDatabase</DebugInformationFormat>
+      <PreprocessorDefinitions Condition="'$(Configuration)|$(Platform)'=='Release|x64'">_WINDLL;_SCL_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <AdditionalOptions Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">/guard:cf %(AdditionalOptions)</AdditionalOptions>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="inc\CoreInterface.h" />
+    <ClInclude Include="inc\TransferDataType.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="src\CoreInterface.cpp" />
+    <ClCompile Include="$(IntDir)CoreInterface_pwrap.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="inc\PythonCommon.i" />
+    <None Include="inc\PythonCore.i" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+  <Target Name="BeforeBuild" BeforeTargets="PrepareForBuild">
+    <MakeDir Directories="$(IntDir)" />
+    <Exec Command="$(SolutionDir)packages\swigwin.3.0.9\tools\swigwin-3.0.9\swig.exe -python -c++ -I$(IntDir) -outdir $(IntDir) -o $(IntDir)CoreInterface_pwrap.cpp inc\PythonCore.i" />
+  </Target>
+  <Target Name="CopyFiles" AfterTargets="BeforeBuild">
+    <Copy SourceFiles="$(IntDir)SPTAG.py" DestinationFolder="$(Outdir)" />
+  </Target>
+  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
+    <PropertyGroup>
+      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
+    </PropertyGroup>
+    <Error Condition="!Exists('..\packages\python2.2.7.15\tools\python.exe')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\python2.2.7.15\tools\python.exe'))" />
+    <Error Condition="!Exists('..\packages\swigwin.3.0.9\tools\swigwin-3.0.9\swig.exe')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\swigwin.3.0.9\tools\swigwin-3.0.9\swig.exe'))" />
+  </Target>
+</Project>
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/Wrappers/PythonCore.vcxproj.filters b/core/src/index/thirdparty/SPTAG/Wrappers/PythonCore.vcxproj.filters
new file mode 100644
index 0000000000..8d0ee1d7b9
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/Wrappers/PythonCore.vcxproj.filters
@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
+    </Filter>
+    <Filter Include="Resources">
+      <UniqueIdentifier>{ba4289c4-f872-4dbc-a57f-7b415614afb3}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="inc\CoreInterface.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="inc\TransferDataType.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="src\CoreInterface.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="$(IntDir)CoreInterface_pwrap.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="inc\PythonCore.i">
+      <Filter>Resources</Filter>
+    </None>
+    <None Include="inc\PythonCommon.i">
+      <Filter>Resources</Filter>
+    </None>
+  </ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/Wrappers/PythonCore.vcxproj.user b/core/src/index/thirdparty/SPTAG/Wrappers/PythonCore.vcxproj.user
new file mode 100644
index 0000000000..abe8dd8961
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/Wrappers/PythonCore.vcxproj.user
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup />
+</Project>
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/Wrappers/inc/CLRCoreInterface.h b/core/src/index/thirdparty/SPTAG/Wrappers/inc/CLRCoreInterface.h
new file mode 100644
index 0000000000..1a273ba8d7
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/Wrappers/inc/CLRCoreInterface.h
@@ -0,0 +1,113 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "ManagedObject.h"
+#include "inc/Core/VectorIndex.h"
+
+using namespace System;
+
+namespace Microsoft
+{
+    namespace ANN
+    {
+        namespace SPTAGManaged
+        {
+
+            public ref class BasicResult :
+                public ManagedObject<SPTAG::BasicResult>
+            {
+            public:
+                BasicResult(SPTAG::BasicResult* p_instance) : ManagedObject(p_instance)
+                {
+                }
+
+                property int VID
+                {
+                public:
+                    int get()
+                    {
+                        return m_Instance->VID;
+                    }
+                private:
+                    void set(int p_vid)
+                    {
+                    }
+                }
+
+                property float Dist
+                {
+                public:
+                    float get()
+                    {
+                        return m_Instance->Dist;
+                    }
+                private:
+                    void set(float p_dist)
+                    {
+                    }
+                }
+
+                property array<Byte>^ Meta
+                {
+                public:
+                    array<Byte>^ get()
+                    {
+                        array<Byte>^ buf = gcnew array<Byte>(m_Instance->Meta.Length());
+                        Marshal::Copy((IntPtr)m_Instance->Meta.Data(), buf, 0, (int)m_Instance->Meta.Length());
+                        return buf;
+                    }
+                private:
+                    void set(array<Byte>^ p_meta)
+                    {
+                    }
+                }
+            };
+
+            public ref class AnnIndex :
+                public ManagedObject<std::shared_ptr<SPTAG::VectorIndex>>
+            {
+            public:
+                AnnIndex(std::shared_ptr<SPTAG::VectorIndex> p_index);
+
+                AnnIndex(String^ p_algoType, String^ p_valueType, int p_dimension);
+
+                void SetBuildParam(String^ p_name, String^ p_value);
+
+                void SetSearchParam(String^ p_name, String^ p_value);
+
+                bool Build(array<Byte>^ p_data, int p_num);
+
+                bool BuildWithMetaData(array<Byte>^ p_data, array<Byte>^ p_meta, int p_num, bool p_withMetaIndex);
+
+                array<BasicResult^>^ Search(array<Byte>^ p_data, int p_resultNum);
+
+                array<BasicResult^>^ SearchWithMetaData(array<Byte>^ p_data, int p_resultNum);
+
+                bool Save(String^ p_saveFile);
+
+                array<array<Byte>^>^ Dump();
+
+                bool Add(array<Byte>^ p_data, int p_num);
+
+                bool AddWithMetaData(array<Byte>^ p_data, array<Byte>^ p_meta, int p_num);
+
+                bool Delete(array<Byte>^ p_data, int p_num);
+
+                bool DeleteByMetaData(array<Byte>^ p_meta);
+
+                static AnnIndex^ Load(String^ p_loaderFile);
+
+                static AnnIndex^ Load(array<array<Byte>^>^ p_index);
+
+                static bool Merge(String^ p_indexFilePath1, String^ p_indexFilePath2);
+
+            private:
+
+                int m_dimension;
+
+                size_t m_inputVectorSize;
+            };
+        }
+    }
+}
diff --git a/core/src/index/thirdparty/SPTAG/Wrappers/inc/ClientInterface.h b/core/src/index/thirdparty/SPTAG/Wrappers/inc/ClientInterface.h
new file mode 100644
index 0000000000..94d46bcad3
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/Wrappers/inc/ClientInterface.h
@@ -0,0 +1,63 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_PW_CLIENTINTERFACE_H_
+#define _SPTAG_PW_CLIENTINTERFACE_H_
+
+#include "TransferDataType.h"
+#include "inc/Socket/Client.h"
+#include "inc/Socket/ResourceManager.h"
+
+#include <unordered_map>
+#include <atomic>
+#include <mutex>
+
+class AnnClient
+{
+public:
+    AnnClient(const char* p_serverAddr, const char* p_serverPort);
+
+    ~AnnClient();
+
+    void SetTimeoutMilliseconds(int p_timeout);
+
+    void SetSearchParam(const char* p_name, const char* p_value);
+
+    void ClearSearchParam();
+
+    std::shared_ptr<RemoteSearchResult> Search(ByteArray p_data, int p_resultNum, const char* p_valueType, bool p_withMetaData);
+
+    bool IsConnected() const;
+
+private:
+    std::string CreateSearchQuery(const ByteArray& p_data,
+                                  int p_resultNum,
+                                  bool p_extractMetadata,
+                                  SPTAG::VectorValueType p_valueType);
+
+    SPTAG::Socket::PacketHandlerMapPtr GetHandlerMap();
+
+    void SearchResponseHanlder(SPTAG::Socket::ConnectionID p_localConnectionID,
+                               SPTAG::Socket::Packet p_packet);
+
+private:
+    typedef std::function<void(SPTAG::Socket::RemoteSearchResult)> Callback;
+
+    std::uint32_t m_timeoutInMilliseconds;
+
+    std::string m_server;
+
+    std::string m_port;
+
+    std::unique_ptr<SPTAG::Socket::Client> m_socketClient;
+
+    std::atomic<SPTAG::Socket::ConnectionID> m_connectionID;
+
+    SPTAG::Socket::ResourceManager<Callback> m_callbackManager;
+
+    std::unordered_map<std::string, std::string> m_params;
+
+    std::mutex m_paramMutex;
+};
+
+#endif // _SPTAG_PW_CLIENTINTERFACE_H_
diff --git a/core/src/index/thirdparty/SPTAG/Wrappers/inc/CoreInterface.h b/core/src/index/thirdparty/SPTAG/Wrappers/inc/CoreInterface.h
new file mode 100644
index 0000000000..bc69874746
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/Wrappers/inc/CoreInterface.h
@@ -0,0 +1,65 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_PW_COREINTERFACE_H_
+#define _SPTAG_PW_COREINTERFACE_H_
+
+#include "TransferDataType.h"
+#include "inc/Core/Common.h"
+#include "inc/Core/VectorIndex.h"
+
+typedef int SizeType;
+typedef int DimensionType;
+
+class AnnIndex
+{
+public:
+    AnnIndex(DimensionType p_dimension);
+
+    AnnIndex(const char* p_algoType, const char* p_valueType, DimensionType p_dimension);
+
+    ~AnnIndex();
+
+    void SetBuildParam(const char* p_name, const char* p_value);
+
+    void SetSearchParam(const char* p_name, const char* p_value);
+
+    bool Build(ByteArray p_data, SizeType p_num);
+
+    bool BuildWithMetaData(ByteArray p_data, ByteArray p_meta, SizeType p_num, bool p_withMetaIndex);
+
+    std::shared_ptr<QueryResult> Search(ByteArray p_data, int p_resultNum);
+
+    std::shared_ptr<QueryResult> SearchWithMetaData(ByteArray p_data, int p_resultNum);
+
+    bool ReadyToServe() const;
+
+    bool Save(const char* p_saveFile) const;
+
+    bool Add(ByteArray p_data, SizeType p_num);
+
+    bool AddWithMetaData(ByteArray p_data, ByteArray p_meta, SizeType p_num);
+
+    bool Delete(ByteArray p_data, SizeType p_num);
+
+    bool DeleteByMetaData(ByteArray p_meta);
+
+    static AnnIndex Load(const char* p_loaderFile);
+
+    static bool Merge(const char* p_indexFilePath1, const char* p_indexFilePath2);
+
+private:
+    AnnIndex(const std::shared_ptr<SPTAG::VectorIndex>& p_index);
+    
+    std::shared_ptr<SPTAG::VectorIndex> m_index;
+
+    size_t m_inputVectorSize;
+    
+    DimensionType m_dimension;
+
+    SPTAG::IndexAlgoType m_algoType;
+
+    SPTAG::VectorValueType m_inputValueType;
+};
+
+#endif // _SPTAG_PW_COREINTERFACE_H_
diff --git a/core/src/index/thirdparty/SPTAG/Wrappers/inc/CsharpClient.i b/core/src/index/thirdparty/SPTAG/Wrappers/inc/CsharpClient.i
new file mode 100644
index 0000000000..481627a97f
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/Wrappers/inc/CsharpClient.i
@@ -0,0 +1,16 @@
+%module CSHARPSPTAGClient
+
+%{
+#include "inc/ClientInterface.h"
+%}
+
+%include <std_shared_ptr.i>
+%shared_ptr(AnnClient)
+%shared_ptr(RemoteSearchResult)
+%include "CsharpCommon.i"
+
+%{
+#define SWIG_FILE_WITH_INIT
+%}
+
+%include "ClientInterface.h"
diff --git a/core/src/index/thirdparty/SPTAG/Wrappers/inc/CsharpCommon.i b/core/src/index/thirdparty/SPTAG/Wrappers/inc/CsharpCommon.i
new file mode 100644
index 0000000000..6251d6f245
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/Wrappers/inc/CsharpCommon.i
@@ -0,0 +1,125 @@
+#ifdef SWIGCSHARP
+
+%{
+    struct WrapperArray
+    {
+        void * _data;
+        size_t _size;
+    };
+
+	void deleteArrayOfWrapperArray(void* ptr) {
+		delete[] (WrapperArray*)ptr;
+	}
+%}
+
+%pragma(csharp) imclasscode=%{ 
+    [System.Runtime.InteropServices.StructLayout(System.Runtime.InteropServices.LayoutKind.Sequential)] 
+    public struct WrapperArray 
+    { 
+        public System.IntPtr _data; 
+        public ulong _size;
+        public WrapperArray(System.IntPtr in_data, ulong in_size) { _data = in_data; _size = in_size; } 
+    } 
+%} 
+
+%apply void *VOID_INT_PTR { void * }
+void deleteArrayOfWrapperArray(void* ptr);
+
+%typemap(ctype) ByteArray "WrapperArray"
+%typemap(imtype) ByteArray "WrapperArray"
+%typemap(cstype) ByteArray "byte[]"
+%typemap(in) ByteArray {
+    $1.Set((std::uint8_t*)$input._data, $input._size, false);
+}
+%typemap(out) ByteArray {
+    $result._data = $1.Data();
+    $result._size = $1.Length();
+}
+%typemap(csin,
+         pre="unsafe { fixed(byte* ptr$csinput = $csinput) { $modulePINVOKE.WrapperArray temp$csinput = new $modulePINVOKE.WrapperArray( (System.IntPtr)ptr$csinput, (ulong)$csinput.LongLength );",
+         terminator="} }"
+         ) ByteArray %{ temp$csinput %}
+
+%typemap(csvarin) ByteArray %{ 
+    set {
+         unsafe { fixed(byte* ptr$csinput = $csinput) 
+             {
+                 $modulePINVOKE.WrapperArray temp$csinput = new $modulePINVOKE.WrapperArray( (System.IntPtr)ptr$csinput, (ulong)$csinput.LongLength );
+                 $imcall;
+             }
+         }
+    }
+%}
+
+%typemap(csout, excode=SWIGEXCODE) ByteArray %{
+    $modulePINVOKE.WrapperArray data = $imcall;$excode
+    byte[] ret = new byte[data._size];
+    System.Runtime.InteropServices.Marshal.Copy(data._data, ret, 0, (int)data._size);
+    return ret; 
+%}
+
+%typemap(csvarout) ByteArray %{
+    get {
+        $modulePINVOKE.WrapperArray data = $imcall;
+        byte[] ret = new byte[data._size];
+        System.Runtime.InteropServices.Marshal.Copy(data._data, ret, 0, (int)data._size);
+        return ret; 
+    }
+%}
+
+%typemap(ctype) std::shared_ptr<QueryResult> "WrapperArray"
+%typemap(imtype) std::shared_ptr<QueryResult> "WrapperArray"
+%typemap(cstype) std::shared_ptr<QueryResult> "BasicResult[]"
+%typemap(out) std::shared_ptr<QueryResult> {
+    $result._data = new WrapperArray[$1->GetResultNum()];
+    $result._size = $1->GetResultNum();
+    for (int i = 0; i < $1->GetResultNum(); i++)
+	    (((WrapperArray*)$result._data) + i)->_data = new BasicResult(*($1->GetResult(i)));
+}
+%typemap(csout, excode=SWIGEXCODE) std::shared_ptr<QueryResult> {
+    $modulePINVOKE.WrapperArray data = $imcall;
+    BasicResult[] ret = new BasicResult[data._size];
+    System.IntPtr ptr = data._data;
+    for (ulong i = 0; i < data._size; i++) {
+        $modulePINVOKE.WrapperArray arr = ($modulePINVOKE.WrapperArray)System.Runtime.InteropServices.Marshal.PtrToStructure(ptr, typeof($modulePINVOKE.WrapperArray));
+        ret[i] = new BasicResult(arr._data, true);
+        ptr += sizeof($modulePINVOKE.WrapperArray);
+    }
+    $modulePINVOKE.deleteArrayOfWrapperArray(data._data);
+    $excode
+    return ret;
+}
+
+%typemap(ctype) std::shared_ptr<RemoteSearchResult> "WrapperArray"
+%typemap(imtype) std::shared_ptr<RemoteSearchResult> "WrapperArray"
+%typemap(cstype) std::shared_ptr<RemoteSearchResult> "BasicResult[]"
+%typemap(out) std::shared_ptr<RemoteSearchResult> {
+    int combinelen = 0;
+    int nodelen = (int)(($1->m_allIndexResults).size());
+    for (int i = 0; i < nodelen; i++) {
+        combinelen += $1->m_allIndexResults[i].m_results.GetResultNum();
+    }
+    $result._data = new WrapperArray[combinelen];
+    $result._size = combinelen;
+    size_t copyed = 0;
+    for (int i = 0; i < nodelen; i++) {
+        auto& queryResult = $1->m_allIndexResults[i].m_results;
+		for (int j = 0; j < queryResult.GetResultNum(); j++)
+		    (((WrapperArray*)$result._data) + copyed + j)->_data = new BasicResult(*(queryResult.GetResult(j)));
+        copyed += queryResult.GetResultNum();
+    }
+}
+%typemap(csout, excode=SWIGEXCODE) std::shared_ptr<RemoteSearchResult> {
+    $modulePINVOKE.WrapperArray data = $imcall;
+    BasicResult[] ret = new BasicResult[data._size];
+    System.IntPtr ptr = data._data;
+    for (ulong i = 0; i < data._size; i++) {
+        $modulePINVOKE.WrapperArray arr = ($modulePINVOKE.WrapperArray)System.Runtime.InteropServices.Marshal.PtrToStructure(ptr, typeof($modulePINVOKE.WrapperArray));
+        ret[i] = new BasicResult(arr._data, true);
+        ptr += sizeof($modulePINVOKE.WrapperArray);
+    }
+    $modulePINVOKE.deleteArrayOfWrapperArray(data._data);
+    $excode
+    return ret;
+}
+#endif
diff --git a/core/src/index/thirdparty/SPTAG/Wrappers/inc/CsharpCore.i b/core/src/index/thirdparty/SPTAG/Wrappers/inc/CsharpCore.i
new file mode 100644
index 0000000000..6434239b90
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/Wrappers/inc/CsharpCore.i
@@ -0,0 +1,17 @@
+%module CSHARPSPTAG
+
+%{
+#include "inc/CoreInterface.h"
+%}
+
+%include <std_shared_ptr.i>
+%shared_ptr(AnnIndex)
+%shared_ptr(QueryResult)
+%include "CsharpCommon.i"
+
+%{
+#define SWIG_FILE_WITH_INIT
+%}
+
+%include "CoreInterface.h"
+%include "../../AnnService/inc/Core/SearchResult.h"
diff --git a/core/src/index/thirdparty/SPTAG/Wrappers/inc/JavaClient.i b/core/src/index/thirdparty/SPTAG/Wrappers/inc/JavaClient.i
new file mode 100644
index 0000000000..62a274e51a
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/Wrappers/inc/JavaClient.i
@@ -0,0 +1,16 @@
+%module JAVASPTAGClient
+
+%{
+#include "inc/ClientInterface.h"
+%}
+
+%include <std_shared_ptr.i>
+%shared_ptr(AnnClient)
+%shared_ptr(RemoteSearchResult)
+%include "JavaCommon.i"
+
+%{
+#define SWIG_FILE_WITH_INIT
+%}
+
+%include "ClientInterface.h"
diff --git a/core/src/index/thirdparty/SPTAG/Wrappers/inc/JavaCommon.i b/core/src/index/thirdparty/SPTAG/Wrappers/inc/JavaCommon.i
new file mode 100644
index 0000000000..366052d4f9
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/Wrappers/inc/JavaCommon.i
@@ -0,0 +1,60 @@
+#ifdef SWIGJAVA
+
+%typemap(jni) ByteArray "jbyteArray"
+%typemap(jtype) ByteArray "byte[]"
+%typemap(jstype) ByteArray "byte[]"
+%typemap(in) ByteArray {
+    $1.Set((std::uint8_t*)JCALL2(GetByteArrayElements, jenv, $input, 0), 
+           JCALL1(GetArrayLength, jenv, $input), false);
+}
+%typemap(out) ByteArray {
+    $result = JCALL1(NewByteArray, jenv, $1.Length());
+    JCALL4(SetByteArrayRegion, jenv, $result, 0, $1.Length(), (jbyte *)$1.Data());
+}
+%typemap(javain) ByteArray "$javainput"
+%typemap(javaout) ByteArray { return $jnicall; }
+
+%typemap(jni) std::shared_ptr<QueryResult> "jobjectArray"
+%typemap(jtype) std::shared_ptr<QueryResult> "BasicResult[]"
+%typemap(jstype) std::shared_ptr<QueryResult> "BasicResult[]"
+%typemap(out) std::shared_ptr<QueryResult> {
+    jclass retClass = jenv->FindClass("BasicResult");
+    int len = $1->GetResultNum();
+    $result = jenv->NewObjectArray(len, retClass, NULL);
+    for (int i = 0; i < len; i++) {
+        auto& meta = $1->GetMetadata(i);
+        jbyteArray bptr = jenv->NewByteArray(meta.Length());
+        jenv->SetByteArrayRegion(bptr, 0, meta.Length(), (jbyte *)meta.Data());
+        jenv->SetObjectArrayElement(jresult, i, jenv->NewObject(retClass, jenv->GetMethodID(retClass, "<init>", "(IF[B)V"), (jint)($1->GetResult(i)->VID), (jfloat)($1->GetResult(i)->Dist), bptr));
+    }
+}
+%typemap(javaout) std::shared_ptr<QueryResult> { return $jnicall; }
+
+%typemap(jni) std::shared_ptr<RemoteSearchResult> "jobjectArray"
+%typemap(jtype) std::shared_ptr<RemoteSearchResult> "BasicResult[]"
+%typemap(jstype) std::shared_ptr<RemoteSearchResult> "BasicResult[]"
+%typemap(out) std::shared_ptr<RemoteSearchResult> {
+    int combinelen = 0;
+    int nodelen = (int)(($1->m_allIndexResults).size());
+    for (int i = 0; i < nodelen; i++) {
+        combinelen += $1->m_allIndexResults[i].m_results.GetResultNum();
+    }
+    jclass retClass = jenv->FindClass("BasicResult");
+    $result = jenv->NewObjectArray(combinelen, retClass, NULL);
+    int id = 0;
+    for (int i = 0; i < nodelen; i++) {
+        for (int j = 0; j < $1->m_allIndexResults[i].m_results.GetResultNum(); j++) {
+            auto& ptr = $1->m_allIndexResults[i].m_results;
+            auto& meta = ptr.GetMetadata(j);
+            jbyteArray bptr = jenv->NewByteArray(meta.Length());
+            jenv->SetByteArrayRegion(bptr, 0, meta.Length(), (jbyte *)meta.Data());
+            jenv->SetObjectArrayElement(jresult, id, jenv->NewObject(retClass, jenv->GetMethodID(retClass, "<init>", "(IF[B)V"), (jint)(ptr.GetResult(j)->VID), (jfloat)(ptr.GetResult(j)->Dist), bptr));
+            id++;
+        }
+    }
+}
+%typemap(javaout) std::shared_ptr<RemoteSearchResult> {
+    return $jnicall;
+}
+
+#endif
diff --git a/core/src/index/thirdparty/SPTAG/Wrappers/inc/JavaCore.i b/core/src/index/thirdparty/SPTAG/Wrappers/inc/JavaCore.i
new file mode 100644
index 0000000000..78d9dd72e3
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/Wrappers/inc/JavaCore.i
@@ -0,0 +1,17 @@
+%module JAVASPTAG
+
+%{
+#include "inc/CoreInterface.h"
+%}
+
+%include <std_shared_ptr.i>
+%shared_ptr(AnnIndex)
+%shared_ptr(QueryResult)
+%include "JavaCommon.i"
+
+%{
+#define SWIG_FILE_WITH_INIT
+%}
+
+%include "CoreInterface.h"
+%include "../../AnnService/inc/Core/SearchResult.h"
diff --git a/core/src/index/thirdparty/SPTAG/Wrappers/inc/ManagedObject.h b/core/src/index/thirdparty/SPTAG/Wrappers/inc/ManagedObject.h
new file mode 100644
index 0000000000..266d84b440
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/Wrappers/inc/ManagedObject.h
@@ -0,0 +1,80 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#pragma once
+#include "inc/Helper/StringConvert.h"
+
+using namespace System;
+using namespace System::Runtime::InteropServices;
+
+namespace Microsoft
+{
+    namespace ANN
+    {
+        namespace SPTAGManaged
+        {
+            ///<summary>
+            /// hold a pointer to an umnanaged object from the core project
+            ///</summary>
+            template<class T>
+            public ref class ManagedObject
+            {
+            protected:
+                T* m_Instance;
+
+            public:
+                ManagedObject(T* instance)
+                    :m_Instance(instance)
+                {
+                }
+
+                ManagedObject(T& instance)
+                {
+                    m_Instance = new T(instance);
+                }
+
+                /// <summary>
+                /// destructor, which is called whenever delete an object with delete keyword
+                /// </summary>
+                virtual ~ManagedObject()
+                {
+                    if (m_Instance != nullptr)
+                    {
+                        delete m_Instance;
+                    }
+                }
+
+                /// <summary>
+                /// finalizer which is called by Garbage Collector whenever it destroys the wrapper object.
+                /// </summary>
+                !ManagedObject()
+                {
+                    if (m_Instance != nullptr)
+                    {
+                        delete m_Instance;
+                    }
+                }
+
+                T* GetInstance()
+                {
+                    return m_Instance;
+                }
+
+                static const char* string_to_char_array(String^ string)
+                {
+                    const char* str = (const char*)(Marshal::StringToHGlobalAnsi(string)).ToPointer();
+                    return str;
+                }
+
+                template<typename T>
+                static T string_to(String^ string)
+                {
+                    T data;
+                    SPTAG::Helper::Convert::ConvertStringTo<T>(string_to_char_array(string), data);
+                    return data;
+                }
+            };
+        }
+    }
+}
+
diff --git a/core/src/index/thirdparty/SPTAG/Wrappers/inc/PythonClient.i b/core/src/index/thirdparty/SPTAG/Wrappers/inc/PythonClient.i
new file mode 100644
index 0000000000..a70e2fdeb7
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/Wrappers/inc/PythonClient.i
@@ -0,0 +1,16 @@
+%module SPTAGClient
+
+%{
+#include "inc/ClientInterface.h"
+%}
+
+%include <std_shared_ptr.i>
+%shared_ptr(AnnClient)
+%shared_ptr(RemoteSearchResult)
+%include "PythonCommon.i"
+
+%{
+#define SWIG_FILE_WITH_INIT
+%}
+
+%include "ClientInterface.h"
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/Wrappers/inc/PythonCommon.i b/core/src/index/thirdparty/SPTAG/Wrappers/inc/PythonCommon.i
new file mode 100644
index 0000000000..7b10d50b99
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/Wrappers/inc/PythonCommon.i
@@ -0,0 +1,117 @@
+#ifdef SWIGPYTHON
+
+%typemap(out) std::shared_ptr<QueryResult>
+%{
+    {
+        $result = PyTuple_New(3);
+        int resNum = $1->GetResultNum();
+        auto dstVecIDs = PyList_New(resNum);
+        auto dstVecDists = PyList_New(resNum);
+        auto dstMetadata = PyList_New(resNum);
+        int i = 0;
+        for (const auto& res : *($1))
+        {
+            PyList_SetItem(dstVecIDs, i, PyInt_FromLong(res.VID));
+            PyList_SetItem(dstVecDists, i, PyFloat_FromDouble(res.Dist));
+            i++;
+        }
+    
+        if ($1->WithMeta()) 
+        {
+            for (i = 0; i < resNum; ++i)
+            {
+                const auto& metadata = $1->GetMetadata(i);
+                PyList_SetItem(dstMetadata, i, PyBytes_FromStringAndSize(reinterpret_cast<const char*>(metadata.Data()),
+                                                                         metadata.Length()));
+            }
+        }
+
+        PyTuple_SetItem($result, 0, dstVecIDs);
+        PyTuple_SetItem($result, 1, dstVecDists);
+        PyTuple_SetItem($result, 2, dstMetadata);
+    }
+%}
+
+%typemap(out) std::shared_ptr<RemoteSearchResult>
+%{
+    {
+        $result = PyTuple_New(3);
+        auto dstVecIDs = PyList_New(0);
+        auto dstVecDists = PyList_New(0);
+        auto dstMetadata = PyList_New(0);
+        for (const auto& indexRes : $1->m_allIndexResults)
+        {
+            for (const auto& res : indexRes.m_results)
+            {
+                PyList_Append(dstVecIDs, PyInt_FromLong(res.VID));
+                PyList_Append(dstVecDists, PyFloat_FromDouble(res.Dist));
+            }
+
+            if (indexRes.m_results.WithMeta()) 
+            {
+                for (int i = 0; i < indexRes.m_results.GetResultNum(); ++i)
+                {
+                    const auto& metadata = indexRes.m_results.GetMetadata(i);
+                    PyList_Append(dstMetadata, PyBytes_FromStringAndSize(reinterpret_cast<const char*>(metadata.Data()),
+                                                                         metadata.Length()));
+                }
+            }
+        }
+        PyTuple_SetItem($result, 0, dstVecIDs);
+        PyTuple_SetItem($result, 1, dstVecDists);
+        PyTuple_SetItem($result, 2, dstMetadata);
+    }
+%}
+
+
+%{
+struct PyBufferHolder
+{
+    PyBufferHolder() : shouldRelease(false) { }
+
+    ~PyBufferHolder()
+    {
+        if (shouldRelease)
+        {
+            PyBuffer_Release(&buff);
+        }
+    }
+
+    Py_buffer buff;
+
+    bool shouldRelease;
+};
+%}
+
+%typemap(in) ByteArray (PyBufferHolder bufferHolder)
+%{
+    if (PyBytes_Check($input))
+    {
+        $1 = SPTAG::ByteArray((std::uint8_t*)PyBytes_AsString($input), PyBytes_Size($input), false);
+    }
+    else if (PyObject_CheckBuffer($input))
+    {
+        if (PyObject_GetBuffer($input, &bufferHolder.buff, PyBUF_SIMPLE | PyBUF_C_CONTIGUOUS) == -1)
+        {
+            PyErr_SetString(PyExc_ValueError, "Failed get buffer.");
+            return NULL;
+        }
+
+        bufferHolder.shouldRelease = true;
+        $1 = SPTAG::ByteArray((std::uint8_t*)bufferHolder.buff.buf, bufferHolder.buff.len, false);
+    }
+#if (PY_VERSION_HEX >= 0x03030000)
+    else if (PyUnicode_Check($input))
+    {
+        $1 = SPTAG::ByteArray((std::uint8_t*)PyUnicode_DATA($input), PyUnicode_GET_LENGTH($input), false);
+    }
+#endif
+
+    if (nullptr == $1.Data())
+    {
+        PyErr_SetString(PyExc_ValueError, "Expected Bytes, Data Structure with Buffer Protocol, or Unicode String after Python 3.3 .");
+        return NULL;
+    }
+%}
+
+#endif
diff --git a/core/src/index/thirdparty/SPTAG/Wrappers/inc/PythonCore.i b/core/src/index/thirdparty/SPTAG/Wrappers/inc/PythonCore.i
new file mode 100644
index 0000000000..d2f38ca856
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/Wrappers/inc/PythonCore.i
@@ -0,0 +1,16 @@
+%module SPTAG
+
+%{
+#include "inc/CoreInterface.h"
+%}
+
+%include <std_shared_ptr.i>
+%shared_ptr(AnnIndex)
+%shared_ptr(QueryResult)
+%include "PythonCommon.i"
+
+%{
+#define SWIG_FILE_WITH_INIT
+%}
+
+%include "CoreInterface.h"
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/Wrappers/inc/TransferDataType.h b/core/src/index/thirdparty/SPTAG/Wrappers/inc/TransferDataType.h
new file mode 100644
index 0000000000..51ef9614ab
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/Wrappers/inc/TransferDataType.h
@@ -0,0 +1,19 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#ifndef _SPTAG_PW_TRANSFERDATATYPE_H_
+#define _SPTAG_PW_TRANSFERDATATYPE_H_
+
+#include "inc/Core/CommonDataStructure.h"
+#include "inc/Core/SearchQuery.h"
+#include "inc/Socket/RemoteSearchQuery.h"
+
+typedef SPTAG::ByteArray ByteArray;
+
+typedef SPTAG::QueryResult QueryResult;
+
+typedef SPTAG::BasicResult BasicResult;
+
+typedef SPTAG::Socket::RemoteSearchResult RemoteSearchResult;
+
+#endif // _SPTAG_PW_TRANSFERDATATYPE_H_
diff --git a/core/src/index/thirdparty/SPTAG/Wrappers/packages.config b/core/src/index/thirdparty/SPTAG/Wrappers/packages.config
new file mode 100644
index 0000000000..d780ec4a8e
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/Wrappers/packages.config
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="boost" version="1.67.0.0" targetFramework="native" />
+  <package id="python2" version="2.7.15" targetFramework="native" />
+  <package id="swigwin" version="3.0.9" targetFramework="native" />
+</packages>
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/Wrappers/src/AssemblyInfo.cpp b/core/src/index/thirdparty/SPTAG/Wrappers/src/AssemblyInfo.cpp
new file mode 100644
index 0000000000..43759a83ef
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/Wrappers/src/AssemblyInfo.cpp
@@ -0,0 +1,36 @@
+using namespace System;
+using namespace System::Reflection;
+using namespace System::Runtime::CompilerServices;
+using namespace System::Runtime::InteropServices;
+using namespace System::Security::Permissions;
+
+//
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+//
+[assembly:AssemblyTitleAttribute(L"CLRCore")];
+[assembly:AssemblyDescriptionAttribute(L"")];
+[assembly:AssemblyConfigurationAttribute(L"")];
+[assembly:AssemblyCompanyAttribute(L"")];
+[assembly:AssemblyProductAttribute(L"CLRCore")];
+[assembly:AssemblyCopyrightAttribute(L"Copyright (c)  2019")];
+[assembly:AssemblyTrademarkAttribute(L"")];
+[assembly:AssemblyCultureAttribute(L"")];
+
+//
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version
+//      Build Number
+//      Revision
+//
+// You can specify all the value or you can default the Revision and Build Numbers
+// by using the '*' as shown below:
+
+[assembly:AssemblyVersionAttribute("1.0.*")];
+
+[assembly:ComVisible(false)];
+
+[assembly:CLSCompliantAttribute(true)];
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/Wrappers/src/CLRCoreInterface.cpp b/core/src/index/thirdparty/SPTAG/Wrappers/src/CLRCoreInterface.cpp
new file mode 100644
index 0000000000..39e62baf44
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/Wrappers/src/CLRCoreInterface.cpp
@@ -0,0 +1,212 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/CLRCoreInterface.h"
+
+
+namespace Microsoft
+{
+    namespace ANN
+    {
+        namespace SPTAGManaged
+        {
+            AnnIndex::AnnIndex(std::shared_ptr<SPTAG::VectorIndex> p_index) :
+                ManagedObject(p_index)
+            {
+                m_dimension = p_index->GetFeatureDim();
+                m_inputVectorSize = SPTAG::GetValueTypeSize(p_index->GetVectorValueType()) * m_dimension;
+            }
+
+            AnnIndex::AnnIndex(String^ p_algoType, String^ p_valueType, int p_dimension) :
+                ManagedObject(SPTAG::VectorIndex::CreateInstance(string_to<SPTAG::IndexAlgoType>(p_algoType), string_to<SPTAG::VectorValueType>(p_valueType)))
+            {
+                m_dimension = p_dimension;
+                m_inputVectorSize = SPTAG::GetValueTypeSize((*m_Instance)->GetVectorValueType()) * m_dimension;
+            }
+
+            void AnnIndex::SetBuildParam(String^ p_name, String^ p_value)
+            {
+                if (m_Instance != nullptr)
+                    (*m_Instance)->SetParameter(string_to_char_array(p_name), string_to_char_array(p_value));
+            }
+
+            void AnnIndex::SetSearchParam(String^ p_name, String^ p_value)
+            {
+                if (m_Instance != nullptr)
+                    (*m_Instance)->SetParameter(string_to_char_array(p_name), string_to_char_array(p_value));
+            }
+
+            bool AnnIndex::Build(array<Byte>^ p_data, int p_num)
+            {
+                if (m_Instance == nullptr || p_num == 0 || m_dimension == 0 || p_data->LongLength != p_num * m_inputVectorSize)
+                    return false;
+
+                pin_ptr<Byte> ptr = &p_data[0];
+                return (SPTAG::ErrorCode::Success == (*m_Instance)->BuildIndex(ptr, p_num, m_dimension));
+            }
+
+            bool AnnIndex::BuildWithMetaData(array<Byte>^ p_data, array<Byte>^ p_meta, int p_num, bool p_withMetaIndex)
+            {
+                if (m_Instance == nullptr || p_num == 0 || m_dimension == 0 || p_data->LongLength != p_num * m_inputVectorSize)
+                    return false;
+
+                pin_ptr<Byte> dataptr = &p_data[0];
+                std::shared_ptr<SPTAG::VectorSet> vectors(new SPTAG::BasicVectorSet(SPTAG::ByteArray(dataptr, p_data->LongLength, false), (*m_Instance)->GetVectorValueType(), m_dimension, p_num));
+
+                pin_ptr<Byte> metaptr = &p_meta[0];
+                std::uint64_t* offsets = new std::uint64_t[p_num + 1]{ 0 };
+                int current = 0;
+                for (long long i = 0; i < p_meta->LongLength; i++) {
+                    if (((char)metaptr[i]) == '\n')
+                        offsets[++current] = (std::uint64_t)(i + 1);
+                }
+                std::shared_ptr<SPTAG::MetadataSet> meta(new SPTAG::MemMetadataSet(SPTAG::ByteArray(metaptr, p_meta->LongLength, false), SPTAG::ByteArray((std::uint8_t*)offsets, (p_num + 1) * sizeof(std::uint64_t), true), p_num));
+                return (SPTAG::ErrorCode::Success == (*m_Instance)->BuildIndex(vectors, meta, p_withMetaIndex));
+            }
+
+            array<BasicResult^>^ AnnIndex::Search(array<Byte>^ p_data, int p_resultNum)
+            {
+                array<BasicResult^>^ res;
+                if (m_Instance == nullptr || m_dimension == 0 || p_data->LongLength != m_inputVectorSize)
+                    return res;
+
+                pin_ptr<Byte> ptr = &p_data[0];
+                SPTAG::QueryResult results(ptr, p_resultNum, false);
+                (*m_Instance)->SearchIndex(results);
+
+                res = gcnew array<BasicResult^>(p_resultNum);
+                for (int i = 0; i < p_resultNum; i++)
+                    res[i] = gcnew BasicResult(new SPTAG::BasicResult(*(results.GetResult(i))));
+
+                return res;
+            }
+
+            array<BasicResult^>^ AnnIndex::SearchWithMetaData(array<Byte>^ p_data, int p_resultNum)
+            {
+                array<BasicResult^>^ res;
+                if (m_Instance == nullptr || m_dimension == 0 || p_data->LongLength != m_inputVectorSize)
+                    return res;
+
+                pin_ptr<Byte> ptr = &p_data[0];
+                SPTAG::QueryResult results(ptr, p_resultNum, true);
+                (*m_Instance)->SearchIndex(results);
+
+                res = gcnew array<BasicResult^>(p_resultNum);
+                for (int i = 0; i < p_resultNum; i++)
+                    res[i] = gcnew BasicResult(new SPTAG::BasicResult(*(results.GetResult(i))));
+
+                return res;
+            }
+
+            bool AnnIndex::Save(String^ p_saveFile)
+            {
+                return SPTAG::ErrorCode::Success == (*m_Instance)->SaveIndex(string_to_char_array(p_saveFile));
+            }
+
+            array<array<Byte>^>^ AnnIndex::Dump()
+            {
+                std::shared_ptr<std::vector<std::uint64_t>> buffersize = (*m_Instance)->CalculateBufferSize();
+                array<array<Byte>^>^ res = gcnew array<array<Byte>^>(buffersize->size() + 1);
+                std::vector<SPTAG::ByteArray> indexBlobs;
+                for (int i = 1; i < res->Length; i++)
+                {
+                    res[i] = gcnew array<Byte>(buffersize->at(i-1));
+                    pin_ptr<Byte> ptr = &res[i][0];
+                    indexBlobs.push_back(SPTAG::ByteArray((std::uint8_t*)ptr, res[i]->LongLength, false));
+                }
+                std::string config;
+                if (SPTAG::ErrorCode::Success != (*m_Instance)->SaveIndex(config, indexBlobs)) 
+                {
+                    array<array<Byte>^>^ null;
+                    return null;
+                }
+                res[0] = gcnew array<Byte>(config.size());
+                Marshal::Copy(IntPtr(&config[0]), res[0], 0, config.size());
+                return res;
+            }
+
+            bool AnnIndex::Add(array<Byte>^ p_data, int p_num)
+            {
+                if (m_Instance == nullptr || p_num == 0 || m_dimension == 0 || p_data->LongLength != p_num * m_inputVectorSize)
+                    return false;
+
+                pin_ptr<Byte> ptr = &p_data[0];
+                return (SPTAG::ErrorCode::Success == (*m_Instance)->AddIndex(ptr, p_num, m_dimension));
+            }
+
+            bool AnnIndex::AddWithMetaData(array<Byte>^ p_data, array<Byte>^ p_meta, int p_num)
+            {
+                if (m_Instance == nullptr || p_num == 0 || m_dimension == 0 || p_data->LongLength != p_num * m_inputVectorSize)
+                    return false;
+
+                pin_ptr<Byte> dataptr = &p_data[0];
+                std::shared_ptr<SPTAG::VectorSet> vectors(new SPTAG::BasicVectorSet(SPTAG::ByteArray(dataptr, p_data->LongLength, false), (*m_Instance)->GetVectorValueType(), m_dimension, p_num));
+
+                pin_ptr<Byte> metaptr = &p_meta[0];
+                std::uint64_t* offsets = new std::uint64_t[p_num + 1]{ 0 };
+                int current = 0;
+                for (long long i = 0; i < p_meta->LongLength; i++) {
+                    if (((char)metaptr[i]) == '\n')
+                        offsets[++current] = (std::uint64_t)(i + 1);
+                }
+                std::shared_ptr<SPTAG::MetadataSet> meta(new SPTAG::MemMetadataSet(SPTAG::ByteArray(metaptr, p_meta->LongLength, false), SPTAG::ByteArray((std::uint8_t*)offsets, (p_num + 1) * sizeof(std::uint64_t), true), p_num));
+                return (SPTAG::ErrorCode::Success == (*m_Instance)->AddIndex(vectors, meta));
+            }
+
+            bool AnnIndex::Delete(array<Byte>^ p_data, int p_num)
+            {
+                if (m_Instance == nullptr || p_num == 0 || m_dimension == 0 || p_data->LongLength != p_num * m_inputVectorSize)
+                    return false;
+
+                pin_ptr<Byte> ptr = &p_data[0];
+                return (SPTAG::ErrorCode::Success == (*m_Instance)->DeleteIndex(ptr, p_num));
+            }
+
+            bool AnnIndex::DeleteByMetaData(array<Byte>^ p_meta)
+            {
+                if (m_Instance == nullptr)
+                    return false;
+
+                pin_ptr<Byte> metaptr = &p_meta[0];
+                return (SPTAG::ErrorCode::Success == (*m_Instance)->DeleteIndex(SPTAG::ByteArray(metaptr, p_meta->LongLength, false)));
+            }
+
+            AnnIndex^ AnnIndex::Load(String^ p_loaderFile)
+            {
+                std::shared_ptr<SPTAG::VectorIndex> vecIndex;
+                AnnIndex^ res;
+                if (SPTAG::ErrorCode::Success != SPTAG::VectorIndex::LoadIndex(string_to_char_array(p_loaderFile), vecIndex) || nullptr == vecIndex)
+                {
+                    res = gcnew AnnIndex(nullptr);
+                }
+                else {
+                    res = gcnew AnnIndex(vecIndex);
+                }
+                return res;
+            }
+
+            AnnIndex^ AnnIndex::Load(array<array<Byte>^>^ p_index)
+            {
+                std::vector<SPTAG::ByteArray> p_indexBlobs;
+                for (int i = 1; i < p_index->Length; i++)
+                {
+                    pin_ptr<Byte> ptr = &p_index[i][0];
+                    p_indexBlobs.push_back(SPTAG::ByteArray((std::uint8_t*)ptr, p_index[i]->LongLength, false));
+                }
+                pin_ptr<Byte> configptr = &p_index[0][0];
+
+                std::shared_ptr<SPTAG::VectorIndex> vecIndex;
+                if (SPTAG::ErrorCode::Success != SPTAG::VectorIndex::LoadIndex(std::string((char*)configptr, p_index[0]->LongLength), p_indexBlobs, vecIndex) || nullptr == vecIndex)
+                {
+                    return gcnew AnnIndex(nullptr);
+                }
+                return gcnew AnnIndex(vecIndex);
+            }
+
+            bool AnnIndex::Merge(String^ p_indexFilePath1, String^ p_indexFilePath2)
+            {
+                return (SPTAG::ErrorCode::Success == SPTAG::VectorIndex::MergeIndex(string_to_char_array(p_indexFilePath1), string_to_char_array(p_indexFilePath2)));
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/Wrappers/src/ClientInterface.cpp b/core/src/index/thirdparty/SPTAG/Wrappers/src/ClientInterface.cpp
new file mode 100644
index 0000000000..65a1d4cf17
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/Wrappers/src/ClientInterface.cpp
@@ -0,0 +1,250 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/ClientInterface.h"
+#include "inc/Helper/CommonHelper.h"
+#include "inc/Helper/Concurrent.h"
+#include "inc/Helper/Base64Encode.h"
+#include "inc/Helper/StringConvert.h"
+
+#include <boost/asio.hpp>
+
+
+AnnClient::AnnClient(const char* p_serverAddr, const char* p_serverPort)
+    : m_connectionID(SPTAG::Socket::c_invalidConnectionID),
+      m_timeoutInMilliseconds(9000)
+{
+    using namespace SPTAG;
+
+    m_socketClient.reset(new Socket::Client(GetHandlerMap(), 2, 30));
+
+    if (nullptr == p_serverAddr || nullptr == p_serverPort)
+    {
+        return;
+    }
+
+    m_server = p_serverAddr;
+    m_port = p_serverPort;
+
+    auto connectCallback = [this](Socket::ConnectionID p_cid, ErrorCode p_ec)
+    {
+        m_connectionID = p_cid;
+
+        if (ErrorCode::Socket_FailedResolveEndPoint == p_ec)
+        {
+            return;
+        }
+
+        while (Socket::c_invalidConnectionID == m_connectionID)
+        {
+            ErrorCode errCode;
+            std::this_thread::sleep_for(std::chrono::seconds(10));
+            m_connectionID = m_socketClient->ConnectToServer(m_server, m_port, errCode);
+        }
+    };
+
+    m_socketClient->AsyncConnectToServer(m_server, m_port, connectCallback);
+
+    m_socketClient->SetEventOnConnectionClose([this](Socket::ConnectionID p_cid)
+    {
+        ErrorCode errCode;
+        m_connectionID = Socket::c_invalidConnectionID;
+        while (Socket::c_invalidConnectionID == m_connectionID)
+        {
+            std::this_thread::sleep_for(std::chrono::seconds(10));
+            m_connectionID = m_socketClient->ConnectToServer(m_server, m_port, errCode);
+        }
+    });
+}
+
+
+AnnClient::~AnnClient()
+{
+}
+
+
+void
+AnnClient::SetTimeoutMilliseconds(int p_timeout)
+{
+    m_timeoutInMilliseconds = p_timeout;
+}
+
+
+void
+AnnClient::SetSearchParam(const char* p_name, const char* p_value)
+{
+    std::lock_guard<std::mutex> guard(m_paramMutex);
+
+    if (nullptr == p_name || '\0' == *p_name)
+    {
+        return;
+    }
+
+    std::string name(p_name);
+    SPTAG::Helper::StrUtils::ToLowerInPlace(name);
+
+    if (nullptr == p_value || '\0' == *p_value)
+    {
+        m_params.erase(name);
+        return;
+    }
+
+    m_params[name] = p_value;
+}
+
+
+void
+AnnClient::ClearSearchParam()
+{
+    std::lock_guard<std::mutex> guard(m_paramMutex);
+    m_params.clear();
+}
+
+
+std::shared_ptr<RemoteSearchResult>
+AnnClient::Search(ByteArray p_data, int p_resultNum, const char* p_valueType, bool p_withMetaData)
+{
+    using namespace SPTAG;
+
+    SPTAG::Socket::RemoteSearchResult ret;
+    if (Socket::c_invalidConnectionID != m_connectionID)
+    {
+
+        auto signal = std::make_shared<Helper::Concurrent::WaitSignal>(1);
+
+        auto callback = [&ret, signal](RemoteSearchResult p_result)
+        {
+            if (RemoteSearchResult::ResultStatus::Success == p_result.m_status)
+            {
+                ret = std::move(p_result);
+            }
+
+            signal->FinishOne();
+        };
+
+        auto timeoutCallback = [this](std::shared_ptr<Callback> p_callback)
+        {
+            if (nullptr != p_callback)
+            {
+                RemoteSearchResult result;
+                result.m_status = RemoteSearchResult::ResultStatus::Timeout;
+
+                (*p_callback)(std::move(result));
+            }
+        };
+
+        auto connectCallback = [callback, this](bool p_connectSucc)
+        {
+            if (!p_connectSucc)
+            {
+                RemoteSearchResult result;
+                result.m_status = RemoteSearchResult::ResultStatus::FailedNetwork;
+
+                callback(std::move(result));
+            }
+        };
+
+        Socket::Packet packet;
+        packet.Header().m_connectionID = Socket::c_invalidConnectionID;
+        packet.Header().m_packetType = Socket::PacketType::SearchRequest;
+        packet.Header().m_processStatus = Socket::PacketProcessStatus::Ok;
+        packet.Header().m_resourceID = m_callbackManager.Add(std::make_shared<Callback>(std::move(callback)),
+            m_timeoutInMilliseconds,
+            std::move(timeoutCallback));
+
+        Socket::RemoteQuery query;
+        SPTAG::VectorValueType valueType;
+        SPTAG::Helper::Convert::ConvertStringTo<SPTAG::VectorValueType>(p_valueType, valueType);
+        query.m_queryString = CreateSearchQuery(p_data, p_resultNum, p_withMetaData, valueType);
+
+        packet.Header().m_bodyLength = static_cast<std::uint32_t>(query.EstimateBufferSize());
+        packet.AllocateBuffer(packet.Header().m_bodyLength);
+        query.Write(packet.Body());
+        packet.Header().WriteBuffer(packet.HeaderBuffer());
+
+        m_socketClient->SendPacket(m_connectionID, std::move(packet), connectCallback);
+
+        signal->Wait();
+    }
+    return std::make_shared<RemoteSearchResult>(ret);
+}
+
+
+bool
+AnnClient::IsConnected() const
+{
+    return m_connectionID != SPTAG::Socket::c_invalidConnectionID;
+}
+
+
+SPTAG::Socket::PacketHandlerMapPtr
+AnnClient::GetHandlerMap()
+{
+    using namespace SPTAG;
+
+    Socket::PacketHandlerMapPtr handlerMap(new Socket::PacketHandlerMap);
+    handlerMap->emplace(Socket::PacketType::SearchResponse,
+                        std::bind(&AnnClient::SearchResponseHanlder,
+                                  this,
+                                  std::placeholders::_1,
+                                  std::placeholders::_2));
+
+    return handlerMap;
+}
+
+
+void
+AnnClient::SearchResponseHanlder(SPTAG::Socket::ConnectionID p_localConnectionID,
+                                 SPTAG::Socket::Packet p_packet)
+{
+    using namespace SPTAG;
+
+    std::shared_ptr<Callback> callback = m_callbackManager.GetAndRemove(p_packet.Header().m_resourceID);
+    if (nullptr == callback)
+    {
+        return;
+    }
+
+    if (p_packet.Header().m_processStatus != Socket::PacketProcessStatus::Ok || 0 == p_packet.Header().m_bodyLength)
+    {
+        Socket::RemoteSearchResult result;
+        result.m_status = Socket::RemoteSearchResult::ResultStatus::FailedExecute;
+
+        (*callback)(std::move(result));
+    }
+    else
+    {
+        Socket::RemoteSearchResult result;
+        result.Read(p_packet.Body());
+        (*callback)(std::move(result));
+    }
+}
+
+
+std::string
+AnnClient::CreateSearchQuery(const ByteArray& p_data,
+                             int p_resultNum,
+                             bool p_extractMetadata,
+                             SPTAG::VectorValueType p_valueType)
+{
+    std::stringstream out;
+
+    out << "#";
+    std::size_t encLen;
+    SPTAG::Helper::Base64::Encode(p_data.Data(), p_data.Length(), out, encLen);
+
+    out << " $datatype:" << SPTAG::Helper::Convert::ConvertToString(p_valueType);
+    out << " $resultnum:" << std::to_string(p_resultNum);
+    out << " $extractmetadata:" << (p_extractMetadata ? "true" : "false");
+
+    {
+        std::lock_guard<std::mutex> guard(m_paramMutex);
+        for (const auto& param : m_params)
+        {
+            out << " $" << param.first << ":" << param.second;
+        }
+    }
+
+    return out.str();
+}
+
diff --git a/core/src/index/thirdparty/SPTAG/Wrappers/src/CoreInterface.cpp b/core/src/index/thirdparty/SPTAG/Wrappers/src/CoreInterface.cpp
new file mode 100644
index 0000000000..5a62fe0315
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/Wrappers/src/CoreInterface.cpp
@@ -0,0 +1,230 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+#include "inc/CoreInterface.h"
+#include "inc/Helper/StringConvert.h"
+
+
+AnnIndex::AnnIndex(DimensionType p_dimension)
+    : m_algoType(SPTAG::IndexAlgoType::BKT),
+      m_inputValueType(SPTAG::VectorValueType::Float),
+      m_dimension(p_dimension)
+{
+    m_inputVectorSize = SPTAG::GetValueTypeSize(m_inputValueType) * m_dimension;
+}
+
+
+AnnIndex::AnnIndex(const char* p_algoType, const char* p_valueType, DimensionType p_dimension)
+    : m_algoType(SPTAG::IndexAlgoType::Undefined),
+      m_inputValueType(SPTAG::VectorValueType::Undefined),
+      m_dimension(p_dimension)
+{
+    SPTAG::Helper::Convert::ConvertStringTo<SPTAG::IndexAlgoType>(p_algoType, m_algoType);
+    SPTAG::Helper::Convert::ConvertStringTo<SPTAG::VectorValueType>(p_valueType, m_inputValueType);
+    m_inputVectorSize = SPTAG::GetValueTypeSize(m_inputValueType) * m_dimension;
+}
+
+
+AnnIndex::AnnIndex(const std::shared_ptr<SPTAG::VectorIndex>& p_index)
+    : m_algoType(p_index->GetIndexAlgoType()),
+      m_inputValueType(p_index->GetVectorValueType()),
+      m_dimension(p_index->GetFeatureDim()),
+      m_index(p_index)
+{
+    m_inputVectorSize = SPTAG::GetValueTypeSize(m_inputValueType) * m_dimension;
+}
+
+
+AnnIndex::~AnnIndex()
+{
+}
+
+
+bool
+AnnIndex::Build(ByteArray p_data, SizeType p_num)
+{
+    if (nullptr == m_index)
+    {
+        m_index = SPTAG::VectorIndex::CreateInstance(m_algoType, m_inputValueType);
+    }
+    if (nullptr == m_index || p_num == 0 || m_dimension == 0 || p_data.Length() != p_num * m_inputVectorSize)
+    {
+        return false;
+    }
+    return (SPTAG::ErrorCode::Success == m_index->BuildIndex(p_data.Data(), (SPTAG::SizeType)p_num, (SPTAG::DimensionType)m_dimension));
+}
+
+
+bool
+AnnIndex::BuildWithMetaData(ByteArray p_data, ByteArray p_meta, SizeType p_num, bool p_withMetaIndex)
+{
+    if (nullptr == m_index)
+    {
+        m_index = SPTAG::VectorIndex::CreateInstance(m_algoType, m_inputValueType);
+    }
+    if (nullptr == m_index || p_num == 0 || m_dimension == 0 || p_data.Length() != p_num * m_inputVectorSize)
+    {
+        return false;
+    }
+
+    std::shared_ptr<SPTAG::VectorSet> vectors(new SPTAG::BasicVectorSet(p_data,
+        m_inputValueType,
+        static_cast<SPTAG::DimensionType>(m_dimension),
+        static_cast<SPTAG::SizeType>(p_num)));
+
+    std::uint64_t* offsets = new std::uint64_t[p_num + 1]{ 0 };
+    SizeType current = 1;
+    for (size_t i = 0; i < p_meta.Length(); i++) {
+        if (((char)p_meta.Data()[i]) == '\n')
+            offsets[current++] = (std::uint64_t)(i + 1);
+    }
+    std::shared_ptr<SPTAG::MetadataSet> meta(new SPTAG::MemMetadataSet(p_meta, ByteArray((std::uint8_t*)offsets, (p_num + 1) * sizeof(std::uint64_t), true), (SPTAG::SizeType)p_num));
+    return (SPTAG::ErrorCode::Success == m_index->BuildIndex(vectors, meta, p_withMetaIndex));
+}
+
+
+void
+AnnIndex::SetBuildParam(const char* p_name, const char* p_value)
+{
+    if (nullptr == m_index) 
+    {
+        if (SPTAG::IndexAlgoType::Undefined == m_algoType || 
+            SPTAG::VectorValueType::Undefined == m_inputValueType)
+        {
+            return;    
+        }
+        m_index = SPTAG::VectorIndex::CreateInstance(m_algoType, m_inputValueType);
+
+    }
+    m_index->SetParameter(p_name, p_value);
+}
+
+
+void
+AnnIndex::SetSearchParam(const char* p_name, const char* p_value)
+{
+    if (nullptr != m_index) m_index->SetParameter(p_name, p_value);
+}
+
+
+std::shared_ptr<QueryResult>
+AnnIndex::Search(ByteArray p_data, int p_resultNum)
+{
+    std::shared_ptr<QueryResult> results = std::make_shared<QueryResult>(p_data.Data(), p_resultNum, false);
+
+    if (nullptr != m_index && p_data.Length() == m_inputVectorSize)
+    {
+        m_index->SearchIndex(*results);
+    }
+    return std::move(results);
+}
+
+std::shared_ptr<QueryResult>
+AnnIndex::SearchWithMetaData(ByteArray p_data, int p_resultNum)
+{
+    std::shared_ptr<QueryResult> results = std::make_shared<QueryResult>(p_data.Data(), p_resultNum, true);
+
+    if (nullptr != m_index && p_data.Length() == m_inputVectorSize)
+    {
+        m_index->SearchIndex(*results);
+    }
+    return std::move(results);
+}
+
+bool
+AnnIndex::ReadyToServe() const
+{
+    return m_index != nullptr;
+}
+
+
+bool
+AnnIndex::Save(const char* p_savefile) const
+{
+    return SPTAG::ErrorCode::Success == m_index->SaveIndex(p_savefile);
+}
+
+
+AnnIndex
+AnnIndex::Load(const char* p_loaderFile)
+{
+    std::shared_ptr<SPTAG::VectorIndex> vecIndex;
+    auto ret = SPTAG::VectorIndex::LoadIndex(p_loaderFile, vecIndex);
+    if (SPTAG::ErrorCode::Success != ret || nullptr == vecIndex)
+    {
+        return AnnIndex(0);
+    }
+
+    return AnnIndex(vecIndex);
+}
+
+
+bool 
+AnnIndex::Add(ByteArray p_data, SizeType p_num)
+{
+    if (nullptr == m_index)
+    {
+        m_index = SPTAG::VectorIndex::CreateInstance(m_algoType, m_inputValueType);
+    }
+    if (nullptr == m_index || p_num == 0 || m_dimension == 0 || p_data.Length() != p_num * m_inputVectorSize)
+    {
+        return false;
+    }
+    return (SPTAG::ErrorCode::Success == m_index->AddIndex(p_data.Data(), (SPTAG::SizeType)p_num, (SPTAG::DimensionType)m_dimension));
+}
+
+
+bool
+AnnIndex::AddWithMetaData(ByteArray p_data, ByteArray p_meta, SizeType p_num)
+{
+    if (nullptr == m_index)
+    {
+        m_index = SPTAG::VectorIndex::CreateInstance(m_algoType, m_inputValueType);
+    }
+    if (nullptr == m_index || p_num == 0 || m_dimension == 0 || p_data.Length() != p_num * m_inputVectorSize)
+    {
+        return false;
+    }
+
+    std::shared_ptr<SPTAG::VectorSet> vectors(new SPTAG::BasicVectorSet(p_data,
+        m_inputValueType,
+        static_cast<SPTAG::DimensionType>(m_dimension),
+        static_cast<SPTAG::SizeType>(p_num)));
+
+    std::uint64_t* offsets = new std::uint64_t[p_num + 1]{ 0 };
+    SizeType current = 1;
+    for (size_t i = 0; i < p_meta.Length(); i++) {
+        if (((char)p_meta.Data()[i]) == '\n')
+            offsets[current++] = (std::uint64_t)(i + 1);
+    }
+    std::shared_ptr<SPTAG::MetadataSet> meta(new SPTAG::MemMetadataSet(p_meta, ByteArray((std::uint8_t*)offsets, (p_num + 1) * sizeof(std::uint64_t), true), (SPTAG::SizeType)p_num));
+    return (SPTAG::ErrorCode::Success == m_index->AddIndex(vectors, meta));
+}
+
+
+bool
+AnnIndex::Delete(ByteArray p_data, SizeType p_num)
+{
+    if (nullptr == m_index || p_num == 0 || m_dimension == 0 || p_data.Length() != p_num * m_inputVectorSize)
+    {
+        return false;
+    }
+
+    return (SPTAG::ErrorCode::Success == m_index->DeleteIndex(p_data.Data(), (SPTAG::SizeType)p_num));
+}
+
+
+bool
+AnnIndex::DeleteByMetaData(ByteArray p_meta)
+{
+    if (nullptr == m_index) return false;
+    
+    return (SPTAG::ErrorCode::Success == m_index->DeleteIndex(p_meta));
+}
+
+
+bool
+AnnIndex::Merge(const char* p_indexFilePath1, const char* p_indexFilePath2)
+{
+    return (SPTAG::ErrorCode::Success == SPTAG::VectorIndex::MergeIndex(p_indexFilePath1, p_indexFilePath2));
+}
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/azure-pipelines.yml b/core/src/index/thirdparty/SPTAG/azure-pipelines.yml
new file mode 100644
index 0000000000..22f697bdd4
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/azure-pipelines.yml
@@ -0,0 +1,230 @@
+resources:
+
+- repo: self
+
+phases:
+
+- phase: Phase_1
+
+  displayName: Agent job
+
+
+
+  condition: succeeded()
+
+  queue:
+
+    name: SPTAGBuild
+
+  steps:
+
+  - script: |  
+       mkdir build
+       cd build
+       cmake ..
+       make
+       cd ../Release
+       ./test 
+
+    displayName: 'Command Line Script'
+
+
+
+
+
+- phase: Phase_2
+
+  displayName: Agent job
+
+
+
+  condition: succeeded()
+
+  queue:
+
+    name: Hosted
+
+    demands: 
+
+   - msbuild
+
+   - visualstudio
+
+
+
+  steps:
+
+  - task: NuGetToolInstaller@0
+
+    displayName: 'Use NuGet 4.3.0'
+
+
+
+
+
+  - task: NuGetCommand@2
+
+    displayName: 'NuGet restore'
+
+    inputs:
+
+      restoreSolution: SPTAG.sln
+
+
+
+      vstsFeed: 'bae5097f-8d64-4f8f-913e-24a4eb8302c3'
+
+
+
+
+
+  - task: VSBuild@1
+
+    displayName: 'Build solution SPTAG.sln'
+
+    inputs:
+
+      solution: SPTAG.sln
+
+
+
+      vsVersion: 14.0
+
+
+
+      platform: x64
+
+
+
+      configuration: debug
+
+
+
+      msbuildArchitecture: x64
+
+
+
+      createLogFile: true
+
+
+
+
+
+  - script: '.\x64\Debug\Test.exe' 
+
+    displayName: 'Command Line Script'
+
+
+
+  - task: CopyFiles@2
+
+    displayName: 'Copy Files to: $(Build.ArtifactStagingDirectory)'
+
+    inputs:
+
+      SourceFolder: x64/Debug/
+
+
+
+      Contents: '*'
+
+
+
+      TargetFolder: '$(Build.ArtifactStagingDirectory)'
+
+
+
+
+
+  - task: PublishBuildArtifacts@1
+
+    displayName: 'Publish Artifact: drop'
+
+
+
+
+
+  - task: securedevelopmentteam.vss-secure-development-tools.build-task-binskim.BinSkim@3
+
+    displayName: 'Run BinSkim '
+
+    inputs:
+
+      InputType: Basic
+
+
+
+
+
+  - task: securedevelopmentteam.vss-secure-development-tools.build-task-credscan.CredScan@2
+
+    displayName: 'Run CredScan'
+
+    inputs:
+
+      scanFolder: AnnService
+
+
+
+      suppressAsError: true
+
+
+
+      verboseOutput: true
+
+
+
+      debugMode: false
+
+
+
+
+
+  - task: securedevelopmentteam.vss-secure-development-tools.build-task-autoapplicability.AutoApplicability@1
+
+    displayName: 'Run AutoApplicability'
+
+    inputs:
+
+      IsSoftware: true
+
+
+
+
+
+  - task: securedevelopmentteam.vss-secure-development-tools.build-task-publishsecurityanalysislogs.PublishSecurityAnalysisLogs@2
+
+    displayName: 'Publish Security Analysis Logs'
+
+
+
+
+
+  - task: securedevelopmentteam.vss-secure-development-tools.build-task-report.SdtReport@1
+
+    displayName: 'Create Security Analysis Report'
+
+    inputs:
+
+      AllTools: true
+
+
+
+
+
+  - task: securedevelopmentteam.vss-secure-development-tools.build-task-postanalysis.PostAnalysis@1
+
+    displayName: 'Post Analysis'
+
+    inputs:
+
+      AllTools: true
+
+
+
+
+
+  - task: ms.vss-governance-buildtask.governance-build-task-component-detection.ComponentGovernanceComponentDetection@0
+
+    displayName: 'Component Detection'
+
diff --git a/core/src/index/thirdparty/SPTAG/docs/GettingStart.md b/core/src/index/thirdparty/SPTAG/docs/GettingStart.md
new file mode 100644
index 0000000000..9f82b680ac
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/docs/GettingStart.md
@@ -0,0 +1,286 @@
+## **Quick start**
+
+### **Index Build**
+ ```bash
+ Usage:
+ ./IndexBuiler [options]
+ Options:
+  -d, --dimension <value>       Dimension of vector, required.
+  -v, --vectortype <value>      Input vector data type (e.g. Float, Int8, Int16), required.
+  -i, --input <value>           Input raw data, required.
+  -o, --outputfolder <value>    Output folder, required.
+  -a, --algo <value>            Index Algorithm type (e.g. BKT, KDT), required.
+
+  -t, --thread <value>          Thread Number, default is 32.
+  --delimiter <value>           Vector delimiter, default is |.
+  Index.<ArgName>=<ArgValue>    Set the algorithm parameter ArgName with value ArgValue.
+  ```
+
+  ### **Index Search**
+  ```bash
+  Usage:
+  ./IndexSearcher <index folder> [options]
+  Options
+   Index.QueryFile=XXX           Input Query file
+   Index.ResultFile=XXX	       Output result file
+   Index.TruthFile=XXX           Truth file that can help to calculate the recall
+   Index.K=XXX                   How many nearest neighbors return
+   Index.MaxCheck=XXX            The maxcheck of the search
+  ```
+
+### ** Input File format **
+> Input raw data for index build and input query file for index search (suppose vector dimension is 3):
+```
+<metadata1>\t<v11>|<v12>|<v13>|
+<metadata2>\t<v21>|<v22>|<v23>|
+... 
+```
+where each line represents a vector with its metadata and its value separated by a tab space. Each dimension of a vector is separated by | or use --delimiter to define the separator.
+
+> Truth file to calculate recall (suppose K is 2):
+```
+<t11> <t12>
+<t21> <t22>
+...
+```
+where each line represents the K nearest neighbors of a query separated by a blank space. Each neighbor is given by its vector id.
+
+### **Server**
+```bash
+Usage:
+./Server [options]
+Options: 
+  -m, --mode <value>              Service mode, interactive or socket.
+  -c, --config <value>            Configure file of the index
+
+Write a server configuration file service.ini as follows:
+
+[Service]
+ListenAddr=0.0.0.0
+ListenPort=8000
+ThreadNumber=8
+SocketThreadNumber=8
+
+[QueryConfig]
+DefaultMaxResultNumber=6
+DefaultSeparator=|
+
+[Index]
+List=BKT
+
+[Index_BKT]
+IndexFolder=BKT_gist
+```
+
+### **Client**
+```bash
+Usage:
+./Client [options]
+Options:
+-s, --server                       Server address
+-p, --port                         Server port
+-t,                                Search timeout
+-cth,                              Client Thread Number
+-sth                               Socket Thread Number
+```
+
+### **Aggregator**
+```bash
+Usage:
+./Aggregator
+
+Write Aggregator.ini as follows:
+
+[Service]
+ListenAddr=0.0.0.0
+ListenPort=8100
+ThreadNumber=8
+SocketThreadNumber=8
+
+[Servers]
+Number=2
+
+[Server_0]
+Address=127.0.0.1
+Port=8000
+
+[Server_1]
+Address=127.0.0.1
+Port=8010
+```
+
+### **Python Support**
+> Singlebox PythonWrapper
+ ```python
+ 
+import SPTAG
+import numpy as np
+
+n = 100
+k = 3
+r = 3
+
+def testBuild(algo, distmethod, x, out):
+    i = SPTAG.AnnIndex(algo, 'Float', x.shape[1])
+    i.SetBuildParam("NumberOfThreads", '4')
+    i.SetBuildParam("DistCalcMethod", distmethod)
+    ret = i.Build(x, x.shape[0])
+    i.Save(out)
+
+def testBuildWithMetaData(algo, distmethod, x, s, out):
+    i = SPTAG.AnnIndex(algo, 'Float', x.shape[1])
+    i.SetBuildParam("NumberOfThreads", '4')
+    i.SetBuildParam("DistCalcMethod", distmethod)
+    if i.BuildWithMetaData(x, s, x.shape[0]):
+        i.Save(out)
+
+def testSearch(index, q, k):
+    j = SPTAG.AnnIndex.Load(index)
+    for t in range(q.shape[0]):
+        result = j.Search(q[t], k)
+        print (result[0]) # ids
+        print (result[1]) # distances
+
+def testSearchWithMetaData(index, q, k):
+    j = SPTAG.AnnIndex.Load(index)
+    j.SetSearchParam("MaxCheck", '1024')
+    for t in range(q.shape[0]):
+        result = j.SearchWithMetaData(q[t], k)
+        print (result[0]) # ids
+        print (result[1]) # distances
+        print (result[2]) # metadata
+
+def testAdd(index, x, out, algo, distmethod):
+    if index != None:
+        i = SPTAG.AnnIndex.Load(index)
+    else:
+        i = SPTAG.AnnIndex(algo, 'Float', x.shape[1])
+    i.SetBuildParam("NumberOfThreads", '4')
+    i.SetBuildParam("DistCalcMethod", distmethod)
+    if i.Add(x, x.shape[0]):
+        i.Save(out)
+
+def testAddWithMetaData(index, x, s, out, algo, distmethod):
+    if index != None:
+        i = SPTAG.AnnIndex.Load(index)
+    else:
+        i = SPTAG.AnnIndex(algo, 'Float', x.shape[1])
+    i = SPTAG.AnnIndex(algo, 'Float', x.shape[1])
+    i.SetBuildParam("NumberOfThreads", '4')
+    i.SetBuildParam("DistCalcMethod", distmethod)
+    if i.AddWithMetaData(x, s, x.shape[0]):
+        i.Save(out)
+
+def testDelete(index, x, out):
+    i = SPTAG.AnnIndex.Load(index)
+    ret = i.Delete(x, x.shape[0])
+    print (ret)
+    i.Save(out)
+    
+def Test(algo, distmethod):
+    x = np.ones((n, 10), dtype=np.float32) * np.reshape(np.arange(n, dtype=np.float32), (n, 1))
+    q = np.ones((r, 10), dtype=np.float32) * np.reshape(np.arange(r, dtype=np.float32), (r, 1)) * 2
+    m = ''
+    for i in range(n):
+        m += str(i) + '\n'
+
+    m = m.encode()
+
+    print ("Build.............................")
+    testBuild(algo, distmethod, x, 'testindices')
+    testSearch('testindices', q, k)
+    print ("Add.............................")
+    testAdd('testindices', x, 'testindices', algo, distmethod)
+    testSearch('testindices', q, k)
+    print ("Delete.............................")
+    testDelete('testindices', q, 'testindices')
+    testSearch('testindices', q, k)
+
+    print ("AddWithMetaData.............................")
+    testAddWithMetaData(None, x, m, 'testindices', algo, distmethod)
+    print ("Delete.............................")
+    testSearchWithMetaData('testindices', q, k)
+    testDelete('testindices', q, 'testindices')
+    testSearchWithMetaData('testindices', q, k)
+
+if __name__ == '__main__':
+    Test('BKT', 'L2')
+    Test('KDT', 'L2')
+
+ ```
+
+ > Python Client Wrapper, Suppose there is a sever run at 127.0.0.1:8000 serving ten-dimensional vector datasets:
+ ```python
+import SPTAGClient
+import numpy as np
+import time
+
+def testSPTAGClient():
+    index = SPTAGClient.AnnClient('127.0.0.1', '8100')
+    while not index.IsConnected():
+        time.sleep(1)
+    index.SetTimeoutMilliseconds(18000)
+
+    q = np.ones((10, 10), dtype=np.float32)
+    for t in range(q.shape[0]):
+        result = index.Search(q[t], 6, 'Float', False)
+        print (result[0])
+        print (result[1])
+
+if __name__ == '__main__':
+    testSPTAGClient()
+
+ ```
+ 
+ ### **C# Support**
+> Singlebox CsharpWrapper
+ ```C#
+using System;
+using System.Text;
+
+public class test
+{
+    static int dimension = 10;
+    static int n = 10;
+    static int k = 3;
+
+    static byte[] createFloatArray(int n)
+    {
+        byte[] data = new byte[n * dimension * sizeof(float)];
+        for (int i = 0; i < n; i++)
+            for (int j = 0; j < dimension; j++)
+                Array.Copy(BitConverter.GetBytes((float)i), 0, data, (i * dimension + j) * sizeof(float), 4);
+        return data;
+    }
+
+    static byte[] createMetadata(int n)
+    {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < n; i++)
+            sb.Append(i.ToString() + '\n');
+        return Encoding.ASCII.GetBytes(sb.ToString());
+    }
+
+    static void Main()
+    {
+        {
+            AnnIndex idx = new AnnIndex("BKT", "Float", dimension);
+            idx.SetBuildParam("DistCalcMethod", "L2");
+            byte[] data = createFloatArray(n);
+            byte[] meta = createMetadata(n);
+            idx.BuildWithMetaData(data, meta, n);
+            idx.Save("testcsharp");
+        }
+
+        AnnIndex index = AnnIndex.Load("testcsharp");
+        BasicResult[] res = index.SearchWithMetaData(createFloatArray(1), k);
+        for (int i = 0; i < res.Length; i++)
+            Console.WriteLine("result " + i.ToString() + ":" + res[i].Dist.ToString() + "@(" + res[i].VID.ToString() + "," + Encoding.ASCII.GetString(res[i].Meta) + ")"); 
+        Console.WriteLine("test finish!");
+    }
+}
+
+ ```
+
+  
+  
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/docs/Parameters.md b/core/src/index/thirdparty/SPTAG/docs/Parameters.md
new file mode 100644
index 0000000000..9e2fa93715
--- /dev/null
+++ b/core/src/index/thirdparty/SPTAG/docs/Parameters.md
@@ -0,0 +1,159 @@
+## **Parameters**
+
+> Common Parameters
+
+|  ParametersName | type  |  default | definition|
+|---|---|---|---|
+| Samples | int | 1000 | how many points will be sampled to do tree node split |
+|TPTNumber | int | 32 | number of TPT trees to help with graph construction |
+|TPTLeafSize | int | 2000 | TPT tree leaf size |
+NeighborhoodSize | int | 32 | number of neighbors each node has in the neighborhood graph |
+|GraphNeighborhoodScale | int | 2 | number of neighborhood size scale in the build stage |
+|CEF | int | 1000 | number of results used to construct RNG | 
+|MaxCheckForRefineGraph| int | 10000 | how many nodes each node will visit during graph refine in the build stage | 
+|NumberOfThreads | int | 1 | number of threads to uses for speed up the build |
+|DistCalcMethod | string | Cosine | choose from Cosine and L2 |
+|MaxCheck | int | 8192 | how many nodes will be visited for a query in the search stage
+
+> BKT
+
+|  ParametersName | type  |  default | definition|
+|---|---|---|---|
+| BKTNumber | int | 1 | number of BKT trees |
+| BKTKMeansK | int | 32 | how many childs each tree node has |
+
+> KDT
+
+|  ParametersName | type  |  default | definition|
+|---|---|---|---|
+| KDTNumber | int | 1 | number of KDT trees |
+
+> Parameters that will affect the index size
+* NeighborhoodSize
+* BKTNumber
+* KDTNumber
+
+> Parameters that will affect the index build time
+* NumberOfThreads
+* TPTNumber
+* TPTLeafSize
+* GraphNeighborhoodScale
+* CEF
+* MaxCheckForRefineGraph
+
+> Parameters that will affect the index quality
+* TPTNumber
+* TPTLeafSize
+* GraphNeighborhoodScale
+* CEF
+* MaxCheckForRefineGraph
+* NeighborhoodSize
+* KDTNumber
+
+> Parameters that will affect search latency and recall
+* MaxCheck
+
+## **NNI for parameters tuning**
+
+Prepare vector data file **data.tsv**, query data file **query.tsv**, and truth file **truth.txt** following the format introduced in the [Get Started](GettingStart.md). 
+
+Install [microsoft nni](https://github.com/microsoft/nni) and write the following python code (nni_sptag.py), parameter search space configuration (search_space.json) and nni environment configuration (config.yml).
+
+> nni_sptag.py
+
+```Python
+import nni
+import os
+
+vector_dimension = 10
+vector_type = 'Float'
+index_algo = 'BKT'
+threads = 32
+k = 3
+
+def main():
+    para = nni.get_next_parameter()
+    cmd_build = "./indexbuilder -d %d -v %s -i data.tsv -o index -a %s -t %d " % (vector_dimension, vector_type, index_algo, threads)
+    for p, v in para.items():
+        cmd_build += "Index." + p + "=" + str(v)
+    cmd_test = "./indexsearcher index Index.QueryFile=query.tsv Index.TruthFile=truth.txt Index.K=%d" % (k)
+    os.system(cmd_build)
+    os.system(cmd_test + " > out.txt")
+    with open("out.txt", "r") as fd:
+        lines = fd.readlines()
+        res = lines[-2]
+        segs = res.split()
+        recall = float(segs[-2])
+        avg_latency = float(segs[-5])
+    score = recall
+    nni.report_final_result(score)
+
+if __name__ == '__main__':
+    main()
+```
+> search_space.json
+
+```json
+{
+        "BKTKmeansK": {"_type": "choice", "_value": [2, 4, 8, 16, 32]},
+        "GraphNeighborhoodScale": {"_type": "choice", "_value": [2, 4, 8, 16, 32]}
+}
+
+```
+
+> config.yml
+
+```yaml
+authorName: default
+
+experimentName: example_sptag
+
+trialConcurrency: 1
+
+maxExecDuration: 1h
+
+maxTrialNum: 10
+
+#choice: local, remote, pai
+
+trainingServicePlatform: local
+
+searchSpacePath: search_space.json
+
+#choice: true, false
+
+useAnnotation: false
+
+tuner:
+
+  #choice: TPE, Random, Anneal, Evolution, BatchTuner, MetisTuner
+
+  #SMAC (SMAC should be installed through nnictl)
+
+  builtinTunerName: TPE
+
+  classArgs:
+
+    #choice: maximize, minimize
+
+    optimize_mode: maximize
+
+trial:
+
+  command: python3 nni_sptag.py
+
+  codeDir: .
+
+  gpuNum: 0
+
+```
+
+Then start the tuning (tunning results can be found in the Web UI urls in the command output):
+```bash
+nnictl create --config config.yml
+```
+
+stop the tunning:
+```bash
+nnictl stop
+```
\ No newline at end of file
diff --git a/core/src/index/thirdparty/SPTAG/docs/img/sptag.png b/core/src/index/thirdparty/SPTAG/docs/img/sptag.png
new file mode 100644
index 0000000000..dc21bdf3dc
Binary files /dev/null and b/core/src/index/thirdparty/SPTAG/docs/img/sptag.png differ
diff --git a/core/src/index/thirdparty/build.sh b/core/src/index/thirdparty/build.sh
new file mode 100755
index 0000000000..a0af3349d5
--- /dev/null
+++ b/core/src/index/thirdparty/build.sh
@@ -0,0 +1,42 @@
+#!/bin/bash
+
+BUILD_TYPE="Release"
+
+while getopts "p:t:d:h" arg
+do
+        case $arg in
+             t)
+                BUILD_TYPE=$OPTARG # BUILD_TYPE
+                ;;
+             h) # help
+                echo "
+
+parameter:
+-p: postgresql install path.
+-t: build type
+
+usage:
+./build.sh -t \${BUILD_TYPE}
+                "
+                exit 0
+                ;;
+             ?)
+                echo "unknown argument"
+        exit 1
+        ;;
+        esac
+done
+
+if [[ -d build ]]; then
+	rm ./build -r
+fi
+
+while IFS='' read -r line || [[ -n "$line" ]]; do
+    cd $line
+	./build.sh -t ${BUILD_TYPE}
+        if [ $? -ne 0 ];then
+           exit 1
+        fi
+	cd ../
+done < project.conf
+
diff --git a/core/src/index/thirdparty/faiss_cache_check_lists.txt b/core/src/index/thirdparty/faiss_cache_check_lists.txt
new file mode 100644
index 0000000000..ce75614ca5
--- /dev/null
+++ b/core/src/index/thirdparty/faiss_cache_check_lists.txt
@@ -0,0 +1,13 @@
+# source
+src/
+include/
+
+# third party
+thirdparty/
+
+# cmake
+cmake/
+CMakeLists.txt
+
+# script
+build.sh
\ No newline at end of file
diff --git a/core/src/index/thirdparty/versions.txt b/core/src/index/thirdparty/versions.txt
new file mode 100644
index 0000000000..9ee845f1e3
--- /dev/null
+++ b/core/src/index/thirdparty/versions.txt
@@ -0,0 +1,6 @@
+ARROW_VERSION=apache-arrow-0.14.0
+BOOST_VERSION=1.70.0
+GTEST_VERSION=1.8.1
+LAPACK_VERSION=v3.8.0
+OPENBLAS_VERSION=v0.3.6
+FAISS_VERSION=branch-0.2.1
\ No newline at end of file
diff --git a/core/src/index/unittest/CMakeLists.txt b/core/src/index/unittest/CMakeLists.txt
new file mode 100644
index 0000000000..8a5e089486
--- /dev/null
+++ b/core/src/index/unittest/CMakeLists.txt
@@ -0,0 +1,90 @@
+include_directories(${INDEX_SOURCE_DIR}/thirdparty)
+include_directories(${INDEX_SOURCE_DIR}/thirdparty/SPTAG/AnnService)
+include_directories(${INDEX_SOURCE_DIR}/knowhere)
+include_directories(${INDEX_SOURCE_DIR})
+include_directories(/usr/local/cuda/include)
+link_directories(/usr/local/cuda/lib64)
+
+message(STATUS "arrow prefix: ${ARROW_PREFIX}")
+message(STATUS "libjemalloc_pic path: ${ARROW_PREFIX}/lib/libjemalloc_pic.a")
+
+set(depend_libs
+        gtest gmock gtest_main gmock_main
+        faiss openblas lapack
+        arrow "${ARROW_PREFIX}/lib/libjemalloc_pic.a"
+        )
+
+set(basic_libs
+        cudart cublas
+        gomp gfortran pthread
+        )
+
+set(util_srcs
+        ${MILVUS_ENGINE_SRC}/utils/easylogging++.cc
+        ${INDEX_SOURCE_DIR}/knowhere/knowhere/index/vector_index/helpers/FaissGpuResourceMgr.cpp
+        ${INDEX_SOURCE_DIR}/knowhere/knowhere/index/vector_index/helpers/FaissIO.cpp
+        ${INDEX_SOURCE_DIR}/knowhere/knowhere/index/vector_index/helpers/IndexParameter.cpp
+        ${INDEX_SOURCE_DIR}/knowhere/knowhere/adapter/Structure.cpp
+        ${INDEX_SOURCE_DIR}/knowhere/knowhere/adapter/ArrowAdapter.cpp
+        ${INDEX_SOURCE_DIR}/knowhere/knowhere/common/Exception.cpp
+        ${INDEX_SOURCE_DIR}/knowhere/knowhere/common/Timer.cpp
+        ${INDEX_SOURCE_DIR}/unittest/utils.cpp
+        )
+
+#<IVF-TEST>
+set(ivf_srcs
+        ${INDEX_SOURCE_DIR}/knowhere/knowhere/index/vector_index/helpers/Cloner.cpp
+        ${INDEX_SOURCE_DIR}/knowhere/knowhere/index/vector_index/IndexIVF.cpp
+        ${INDEX_SOURCE_DIR}/knowhere/knowhere/index/vector_index/IndexGPUIVF.cpp
+        ${INDEX_SOURCE_DIR}/knowhere/knowhere/index/vector_index/IndexIVFSQ.cpp
+        ${INDEX_SOURCE_DIR}/knowhere/knowhere/index/vector_index/IndexGPUIVFSQ.cpp
+        ${INDEX_SOURCE_DIR}/knowhere/knowhere/index/vector_index/IndexIVFPQ.cpp
+        ${INDEX_SOURCE_DIR}/knowhere/knowhere/index/vector_index/IndexGPUIVFPQ.cpp
+        ${INDEX_SOURCE_DIR}/knowhere/knowhere/index/vector_index/IndexIVFSQHybrid.cpp
+        ${INDEX_SOURCE_DIR}/knowhere/knowhere/index/vector_index/IndexIDMAP.cpp
+        ${INDEX_SOURCE_DIR}/knowhere/knowhere/index/vector_index/FaissBaseIndex.cpp
+        )
+if(NOT TARGET test_ivf)
+    add_executable(test_ivf test_ivf.cpp ${ivf_srcs} ${util_srcs})
+endif()
+target_link_libraries(test_ivf ${depend_libs} ${unittest_libs} ${basic_libs})
+
+
+#<IDMAP-TEST>
+set(idmap_srcs
+        ${INDEX_SOURCE_DIR}/knowhere/knowhere/index/vector_index/IndexIDMAP.cpp
+        )
+if(NOT TARGET test_idmap)
+    add_executable(test_idmap test_idmap.cpp ${idmap_srcs} ${ivf_srcs} ${util_srcs})
+endif()
+target_link_libraries(test_idmap ${depend_libs} ${unittest_libs} ${basic_libs})
+
+#<KDT-TEST>
+set(kdt_srcs
+        ${INDEX_SOURCE_DIR}/knowhere/knowhere/adapter/SptagAdapter.cpp
+        ${INDEX_SOURCE_DIR}/knowhere/knowhere/index/preprocessor/Normalize.cpp
+        ${INDEX_SOURCE_DIR}/knowhere/knowhere/index/vector_index/helpers/KDTParameterMgr.cpp
+        ${INDEX_SOURCE_DIR}/knowhere/knowhere/index/vector_index/IndexKDT.cpp
+        )
+if(NOT TARGET test_kdt)
+    add_executable(test_kdt test_kdt.cpp ${kdt_srcs} ${util_srcs})
+endif()
+target_link_libraries(test_kdt
+        SPTAGLibStatic
+        ${depend_libs} ${unittest_libs} ${basic_libs})
+
+add_executable(test_gpuresource test_gpuresource.cpp ${util_srcs} ${ivf_srcs})
+target_link_libraries(test_gpuresource ${depend_libs} ${unittest_libs} ${basic_libs})
+
+add_executable(test_customized_index test_customized_index.cpp ${util_srcs} ${ivf_srcs})
+target_link_libraries(test_customized_index ${depend_libs} ${unittest_libs} ${basic_libs})
+
+install(TARGETS test_ivf DESTINATION unittest)
+install(TARGETS test_idmap DESTINATION unittest)
+install(TARGETS test_kdt DESTINATION unittest)
+install(TARGETS test_gpuresource DESTINATION unittest)
+install(TARGETS test_customized_index DESTINATION unittest)
+
+#add_subdirectory(faiss_ori)
+add_subdirectory(test_nsg)
+
diff --git a/core/src/index/unittest/Helper.h b/core/src/index/unittest/Helper.h
new file mode 100644
index 0000000000..d11a484c03
--- /dev/null
+++ b/core/src/index/unittest/Helper.h
@@ -0,0 +1,120 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 <memory>
+#include <string>
+
+#include "knowhere/index/vector_index/IndexGPUIVF.h"
+#include "knowhere/index/vector_index/IndexGPUIVFPQ.h"
+#include "knowhere/index/vector_index/IndexGPUIVFSQ.h"
+#include "knowhere/index/vector_index/IndexIVF.h"
+#include "knowhere/index/vector_index/IndexIVFPQ.h"
+#include "knowhere/index/vector_index/IndexIVFSQ.h"
+#include "knowhere/index/vector_index/IndexIVFSQHybrid.h"
+
+constexpr int DEVICEID = 0;
+constexpr int64_t DIM = 128;
+constexpr int64_t NB = 10000;
+constexpr int64_t NQ = 10;
+constexpr int64_t K = 10;
+constexpr int64_t PINMEM = 1024 * 1024 * 200;
+constexpr int64_t TEMPMEM = 1024 * 1024 * 300;
+constexpr int64_t RESNUM = 2;
+
+knowhere::IVFIndexPtr
+IndexFactory(const std::string& type) {
+    if (type == "IVF") {
+        return std::make_shared<knowhere::IVF>();
+    } else if (type == "IVFPQ") {
+        return std::make_shared<knowhere::IVFPQ>();
+    } else if (type == "GPUIVF") {
+        return std::make_shared<knowhere::GPUIVF>(DEVICEID);
+    } else if (type == "GPUIVFPQ") {
+        return std::make_shared<knowhere::GPUIVFPQ>(DEVICEID);
+    } else if (type == "IVFSQ") {
+        return std::make_shared<knowhere::IVFSQ>();
+    } else if (type == "GPUIVFSQ") {
+        return std::make_shared<knowhere::GPUIVFSQ>(DEVICEID);
+    } else if (type == "IVFSQHybrid") {
+        return std::make_shared<knowhere::IVFSQHybrid>(DEVICEID);
+    }
+}
+
+enum class ParameterType {
+    ivf,
+    ivfpq,
+    ivfsq,
+};
+
+class ParamGenerator {
+ public:
+    static ParamGenerator&
+    GetInstance() {
+        static ParamGenerator instance;
+        return instance;
+    }
+
+    knowhere::Config
+    Gen(const ParameterType& type) {
+        if (type == ParameterType::ivf) {
+            auto tempconf = std::make_shared<knowhere::IVFCfg>();
+            tempconf->d = DIM;
+            tempconf->gpu_id = DEVICEID;
+            tempconf->nlist = 100;
+            tempconf->nprobe = 4;
+            tempconf->k = K;
+            tempconf->metric_type = knowhere::METRICTYPE::L2;
+            return tempconf;
+        } else if (type == ParameterType::ivfpq) {
+            auto tempconf = std::make_shared<knowhere::IVFPQCfg>();
+            tempconf->d = DIM;
+            tempconf->gpu_id = DEVICEID;
+            tempconf->nlist = 100;
+            tempconf->nprobe = 4;
+            tempconf->k = K;
+            tempconf->m = 4;
+            tempconf->nbits = 8;
+            tempconf->metric_type = knowhere::METRICTYPE::L2;
+            return tempconf;
+        } else if (type == ParameterType::ivfsq) {
+            auto tempconf = std::make_shared<knowhere::IVFSQCfg>();
+            tempconf->d = DIM;
+            tempconf->gpu_id = DEVICEID;
+            tempconf->nlist = 100;
+            tempconf->nprobe = 4;
+            tempconf->k = K;
+            tempconf->nbits = 8;
+            tempconf->metric_type = knowhere::METRICTYPE::L2;
+            return tempconf;
+        }
+    }
+};
+
+#include <gtest/gtest.h>
+
+class TestGpuIndexBase : public ::testing::Test {
+ protected:
+    void
+    SetUp() override {
+        knowhere::FaissGpuResourceMgr::GetInstance().InitDevice(DEVICEID, PINMEM, TEMPMEM, RESNUM);
+    }
+
+    void
+    TearDown() override {
+        knowhere::FaissGpuResourceMgr::GetInstance().Free();
+    }
+};
diff --git a/core/src/index/unittest/SPTAG.cpp b/core/src/index/unittest/SPTAG.cpp
new file mode 100644
index 0000000000..62198d5495
--- /dev/null
+++ b/core/src/index/unittest/SPTAG.cpp
@@ -0,0 +1,50 @@
+//// Licensed to the Apache Software Foundation (ASF) under one
+//// or more contributor license agreements.  See the NOTICE file
+//// distributed with this work for additional information
+//// regarding copyright ownership.  The ASF licenses this file
+//// to you 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 <iostream>
+//#include <memory>
+//#include <random>
+//#include <SPTAG/AnnService/inc/Core/Common.h>
+//#include <SPTAG/AnnService/inc/Core/VectorIndex.h>
+//
+// int
+// main(int argc, char* argv[]) {
+//    using namespace SPTAG;
+//    const int d = 128;
+//    const int n = 100;
+//
+//    auto p_data = new float[n * d];
+//
+//    auto index = VectorIndex::CreateInstance(IndexAlgoType::KDT, VectorValueType::Float);
+//
+//    std::random_device rd;
+//    std::mt19937 mt(rd());
+//    std::uniform_real_distribution<double> dist(1.0, 2.0);
+//
+//    for (auto i = 0; i < n; i++) {
+//        for (auto j = 0; j < d; j++) {
+//            p_data[i * d + j] = dist(mt) - 1;
+//        }
+//    }
+//    std::cout << "generate random n * d finished.";
+//    ByteArray data((uint8_t*)p_data, n * d * sizeof(float), true);
+//
+//    auto vectorset = std::make_shared<BasicVectorSet>(data, VectorValueType::Float, d, n);
+//    index->BuildIndex(vectorset, nullptr);
+//
+//    std::cout << index->GetFeatureDim();
+//}
diff --git a/core/src/index/unittest/faiss_ori/CMakeLists.txt b/core/src/index/unittest/faiss_ori/CMakeLists.txt
new file mode 100644
index 0000000000..d01463aaab
--- /dev/null
+++ b/core/src/index/unittest/faiss_ori/CMakeLists.txt
@@ -0,0 +1,26 @@
+include_directories(${INDEX_SOURCE_DIR}/thirdparty)
+include_directories(${INDEX_SOURCE_DIR}/include)
+include_directories(/usr/local/cuda/include)
+link_directories(/usr/local/cuda/lib64)
+
+set(unittest_libs
+        gtest gmock gtest_main gmock_main)
+
+set(depend_libs
+        faiss openblas lapack
+        arrow ${ARROW_PREFIX}/lib/libjemalloc_pic.a
+        )
+
+set(basic_libs
+        cudart cublas
+        gomp gfortran pthread
+        )
+
+
+#<GPU-TEST>
+if(NOT TARGET test_gpu)
+    add_executable(test_gpu gpuresource_test.cpp)
+endif()
+target_link_libraries(test_gpu ${depend_libs} ${unittest_libs} ${basic_libs})
+
+install(TARGETS test_gpu DESTINATION unittest)
\ No newline at end of file
diff --git a/core/src/index/unittest/faiss_ori/gpuresource_test.cpp b/core/src/index/unittest/faiss_ori/gpuresource_test.cpp
new file mode 100644
index 0000000000..90383b944c
--- /dev/null
+++ b/core/src/index/unittest/faiss_ori/gpuresource_test.cpp
@@ -0,0 +1,176 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 <gtest/gtest.h>
+
+#include <faiss/AutoTune.h>
+#include <faiss/Index.h>
+#include <faiss/gpu/GpuAutoTune.h>
+#include <faiss/gpu/GpuIndexIVFFlat.h>
+#include <faiss/gpu/StandardGpuResources.h>
+#include <faiss/index_io.h>
+
+#include <chrono>
+#include <iostream>
+#include <thread>
+
+class TestGpuRes {
+ public:
+    TestGpuRes() {
+        res_ = new faiss::gpu::StandardGpuResources;
+    }
+
+    ~TestGpuRes() {
+        delete res_;
+        delete index_;
+    }
+
+    std::shared_ptr<faiss::Index>
+    Do() {
+        int d = 128;      // dimension
+        int nb = 100000;  // database size
+        int nq = 100;     // nb of queries
+        int nlist = 1638;
+
+        float* xb = new float[d * nb];
+        float* xq = new float[d * nq];
+
+        for (int i = 0; i < nb; i++) {
+            for (int j = 0; j < d; j++) xb[d * i + j] = drand48();
+            xb[d * i] += i / 1000.;
+        }
+
+        for (int i = 0; i < nq; i++) {
+            for (int j = 0; j < d; j++) xq[d * i + j] = drand48();
+            xq[d * i] += i / 1000.;
+        }
+
+        index_ = new faiss::gpu::GpuIndexIVFFlat(res_, d, nlist, faiss::METRIC_L2);
+        index_->train(nb, xb);
+        index_->add(nb, xb);
+
+        std::shared_ptr<faiss::Index> host_index = nullptr;
+        host_index.reset(faiss::gpu::index_gpu_to_cpu(index_));
+        return host_index;
+    }
+
+ private:
+    faiss::gpu::GpuResources* res_ = nullptr;
+    faiss::Index* index_ = nullptr;
+};
+
+TEST(gpuresource, resource) {
+    TestGpuRes t;
+    t.Do();
+}
+
+TEST(test, resource_re) {
+    int d = 128;       // dimension
+    int nb = 1000000;  // database size
+    int nq = 100;      // nb of queries
+    int nlist = 16384;
+    int k = 100;
+
+    float* xb = new float[d * nb];
+    float* xq = new float[d * nq];
+
+    for (int i = 0; i < nb; i++) {
+        for (int j = 0; j < d; j++) xb[d * i + j] = drand48();
+        xb[d * i] += i / 1000.;
+    }
+
+    for (int i = 0; i < nq; i++) {
+        for (int j = 0; j < d; j++) xq[d * i + j] = drand48();
+        xq[d * i] += i / 1000.;
+    }
+
+    auto elems = nq * k;
+    auto res_ids = (int64_t*)malloc(sizeof(int64_t) * elems);
+    auto res_dis = (float*)malloc(sizeof(float) * elems);
+
+    faiss::gpu::StandardGpuResources res;
+    auto cpu_index = faiss::index_factory(d, "IVF16384, Flat");
+    auto device_index = faiss::gpu::index_cpu_to_gpu(&res, 0, cpu_index);
+    device_index->train(nb, xb);
+    device_index->add(nb, xb);
+    auto new_index = faiss::gpu::index_gpu_to_cpu(device_index);
+
+    delete device_index;
+
+    std::cout << "start clone" << std::endl;
+    auto load = [&] {
+        std::cout << "start" << std::endl;
+        faiss::gpu::StandardGpuResources res;
+        // res.noTempMemory();
+        for (int l = 0; l < 100; ++l) {
+            auto x = faiss::gpu::index_cpu_to_gpu(&res, 1, new_index);
+            delete x;
+        }
+        std::cout << "load finish" << std::endl;
+    };
+
+    auto search = [&] {
+        faiss::gpu::StandardGpuResources res;
+        auto device_index = faiss::gpu::index_cpu_to_gpu(&res, 1, new_index);
+        std::cout << "search start" << std::endl;
+        for (int l = 0; l < 10000; ++l) {
+            device_index->search(nq, xq, 10, res_dis, res_ids);
+        }
+        std::cout << "search finish" << std::endl;
+        delete device_index;
+        delete cpu_index;
+    };
+
+    load();
+    search();
+    std::thread t1(search);
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+    std::thread t2(load);
+    t1.join();
+    t2.join();
+    std::cout << "finish clone" << std::endl;
+
+    // std::this_thread::sleep_for(5s);
+    //
+    // auto device_index_2 = faiss::gpu::index_cpu_to_gpu(&res, 1, cpu_index);
+    // device_index->train(nb, xb);
+    // device_index->add(nb, xb);
+
+    // std::cout << "finish clone" << std::endl;
+    // std::this_thread::sleep_for(5s);
+
+    // std::this_thread::sleep_for(2s);
+    // std::cout << "start clone" << std::endl;
+    // auto new_index = faiss::clone_index(device_index);
+    // std::cout << "start search" << std::endl;
+    // new_index->search(nq, xq, k, res_dis, res_ids);
+
+    // std::cout << "start clone" << std::endl;
+    //{
+    //    faiss::gpu::StandardGpuResources res;
+    //    auto cpu_index = faiss::index_factory(d, "IVF1638, Flat");
+    //    auto device_index = faiss::gpu::index_cpu_to_gpu(&res, 1, cpu_index);
+    //    device_index->train(nb, xb);
+    //    device_index->add(nb, xb);
+    //    std::cout << "finish clone" << std::endl;
+    //    delete device_index;
+    //    delete cpu_index;
+    //    std::cout << "finish clone" << std::endl;
+    //}
+    //
+    // std::cout << "finish clone" << std::endl;
+}
diff --git a/core/src/index/unittest/kdtree.cpp b/core/src/index/unittest/kdtree.cpp
new file mode 100644
index 0000000000..6b209919ef
--- /dev/null
+++ b/core/src/index/unittest/kdtree.cpp
@@ -0,0 +1,144 @@
+//// Licensed to the Apache Software Foundation (ASF) under one
+//// or more contributor license agreements.  See the NOTICE file
+//// distributed with this work for additional information
+//// regarding copyright ownership.  The ASF licenses this file
+//// to you 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 <iostream>
+//#include <sstream>
+//#include "knowhere/adapter/sptag.h"
+//#include "knowhere/adapter/structure.h"
+//#include "knowhere/index/vector_index/cpu_kdt_rng.h"
+//#include "knowhere/index/vector_index/definitions.h"
+//
+//
+// knowhere::DatasetPtr
+// generate_dataset(int64_t n, int64_t d, int64_t base) {
+//    auto elems = n * d;
+//    auto p_data = (float*)malloc(elems * sizeof(float));
+//    auto p_id = (int64_t*)malloc(elems * sizeof(int64_t));
+//    assert(p_data != nullptr && p_id != nullptr);
+//
+//    for (auto i = 0; i < n; ++i) {
+//        for (auto j = 0; j < d; ++j) {
+//            p_data[i * d + j] = float(base + i);
+//        }
+//        p_id[i] = i;
+//    }
+//
+//    std::vector<int64_t> shape{n, d};
+//    auto tensor = ConstructFloatTensorSmart((uint8_t*)p_data, elems * sizeof(float), shape);
+//    std::vector<TensorPtr> tensors{tensor};
+//    std::vector<FieldPtr> tensor_fields{ConstructFloatField("data")};
+//    auto tensor_schema = std::make_shared<Schema>(tensor_fields);
+//
+//    auto id_array = ConstructInt64ArraySmart((uint8_t*)p_id, n * sizeof(int64_t));
+//    std::vector<ArrayPtr> arrays{id_array};
+//    std::vector<FieldPtr> array_fields{ConstructInt64Field("id")};
+//    auto array_schema = std::make_shared<Schema>(tensor_fields);
+//
+//    auto dataset = std::make_shared<Dataset>(std::move(arrays), array_schema, std::move(tensors), tensor_schema);
+//
+//    return dataset;
+//}
+//
+// knowhere::DatasetPtr
+// generate_queries(int64_t n, int64_t d, int64_t k, int64_t base) {
+//    size_t size = sizeof(float) * n * d;
+//    auto v = (float*)malloc(size);
+//    // TODO(lxj): check malloc
+//    for (auto i = 0; i < n; ++i) {
+//        for (auto j = 0; j < d; ++j) {
+//            v[i * d + j] = float(base + i);
+//        }
+//    }
+//
+//    std::vector<TensorPtr> data;
+//    auto buffer = MakeMutableBufferSmart((uint8_t*)v, size);
+//    std::vector<int64_t> shape{n, d};
+//    auto float_type = std::make_shared<arrow::FloatType>();
+//    auto tensor = std::make_shared<Tensor>(float_type, buffer, shape);
+//    data.push_back(tensor);
+//
+//    Config meta;
+//    meta[META_ROWS] = int64_t(n);
+//    meta[META_DIM] = int64_t(d);
+//    meta[META_K] = int64_t(k);
+//
+//    auto type = std::make_shared<arrow::FloatType>();
+//    auto field = std::make_shared<Field>("data", type);
+//    std::vector<FieldPtr> fields{field};
+//    auto schema = std::make_shared<Schema>(fields);
+//
+//    return std::make_shared<knowhere::Dataset>(data, schema);
+//}
+//
+// int
+// main(int argc, char* argv[]) {
+//    auto kdt_index = std::make_shared<CPUKDTRNG>();
+//
+//    const auto d = 10;
+//    const auto k = 3;
+//    const auto nquery = 10;
+//
+//    // ID [0, 99]
+//    auto train = generate_dataset(100, d, 0);
+//    // ID [100]
+//    auto base = generate_dataset(1, d, 0);
+//    auto queries = generate_queries(nquery, d, k, 0);
+//
+//    // Build Preprocessor
+//    auto preprocessor = kdt_index->BuildPreprocessor(train, Config());
+//
+//    // Set Preprocessor
+//    kdt_index->set_preprocessor(preprocessor);
+//
+//    Config train_config;
+//    train_config["TPTNumber"] = "64";
+//    // Train
+//    kdt_index->Train(train, train_config);
+//
+//    // Add
+//    kdt_index->Add(base, Config());
+//
+//    auto binary = kdt_index->Serialize();
+//    auto new_index = std::make_shared<CPUKDTRNG>();
+//    new_index->Load(binary);
+//    //    auto new_index = kdt_index;
+//
+//    Config search_config;
+//    search_config[META_K] = int64_t(k);
+//
+//    // Search
+//    auto result = new_index->Search(queries, search_config);
+//
+//    // Print Result
+//    {
+//        auto ids = result->array()[0];
+//        auto dists = result->array()[1];
+//
+//        std::stringstream ss_id;
+//        std::stringstream ss_dist;
+//        for (auto i = 0; i < nquery; i++) {
+//            for (auto j = 0; j < k; ++j) {
+//                ss_id << *ids->data()->GetValues<int64_t>(1, i * k + j) << " ";
+//                ss_dist << *dists->data()->GetValues<float>(1, i * k + j) << " ";
+//            }
+//            ss_id << std::endl;
+//            ss_dist << std::endl;
+//        }
+//        std::cout << "id\n" << ss_id.str() << std::endl;
+//        std::cout << "dist\n" << ss_dist.str() << std::endl;
+//    }
+//}
diff --git a/core/src/index/unittest/sift.50NN.graph b/core/src/index/unittest/sift.50NN.graph
new file mode 100644
index 0000000000..bf7ba7555d
Binary files /dev/null and b/core/src/index/unittest/sift.50NN.graph differ
diff --git a/core/src/index/unittest/siftsmall_base.fvecs b/core/src/index/unittest/siftsmall_base.fvecs
new file mode 100644
index 0000000000..e3b90ae1ee
Binary files /dev/null and b/core/src/index/unittest/siftsmall_base.fvecs differ
diff --git a/core/src/index/unittest/test_customized_index.cpp b/core/src/index/unittest/test_customized_index.cpp
new file mode 100644
index 0000000000..1e0b1d932d
--- /dev/null
+++ b/core/src/index/unittest/test_customized_index.cpp
@@ -0,0 +1,122 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 <gtest/gtest.h>
+
+#include "unittest/Helper.h"
+#include "unittest/utils.h"
+
+class SingleIndexTest : public DataGen, public TestGpuIndexBase {
+ protected:
+    void
+    SetUp() override {
+        TestGpuIndexBase::SetUp();
+        Generate(DIM, NB, NQ);
+        k = K;
+    }
+
+    void
+    TearDown() override {
+        TestGpuIndexBase::TearDown();
+    }
+
+ protected:
+    std::string index_type;
+    knowhere::IVFIndexPtr index_ = nullptr;
+};
+
+#ifdef CUSTOMIZATION
+TEST_F(SingleIndexTest, IVFSQHybrid) {
+    assert(!xb.empty());
+
+    index_type = "IVFSQHybrid";
+    index_ = IndexFactory(index_type);
+    auto conf = ParamGenerator::GetInstance().Gen(ParameterType::ivfsq);
+    auto preprocessor = index_->BuildPreprocessor(base_dataset, conf);
+    index_->set_preprocessor(preprocessor);
+
+    auto model = index_->Train(base_dataset, conf);
+    index_->set_index_model(model);
+    index_->Add(base_dataset, conf);
+    EXPECT_EQ(index_->Count(), nb);
+    EXPECT_EQ(index_->Dimension(), dim);
+
+    auto binaryset = index_->Serialize();
+    {
+        // copy cpu to gpu
+        auto cpu_idx = std::make_shared<knowhere::IVFSQHybrid>(DEVICEID);
+        cpu_idx->Load(binaryset);
+
+        {
+            for (int i = 0; i < 3; ++i) {
+                auto gpu_idx = cpu_idx->CopyCpuToGpu(DEVICEID, conf);
+                auto result = gpu_idx->Search(query_dataset, conf);
+                AssertAnns(result, nq, conf->k);
+                // PrintResult(result, nq, k);
+            }
+        }
+    }
+
+    {
+        // quantization already in gpu, only copy data
+        auto cpu_idx = std::make_shared<knowhere::IVFSQHybrid>(DEVICEID);
+        cpu_idx->Load(binaryset);
+
+        auto pair = cpu_idx->CopyCpuToGpuWithQuantizer(DEVICEID, conf);
+        auto gpu_idx = pair.first;
+        auto quantization = pair.second;
+
+        auto result = gpu_idx->Search(query_dataset, conf);
+        AssertAnns(result, nq, conf->k);
+        //        PrintResult(result, nq, k);
+
+        auto quantizer_conf = std::make_shared<knowhere::QuantizerCfg>();
+        quantizer_conf->mode = 2;  // only copy data
+        quantizer_conf->gpu_id = DEVICEID;
+        for (int i = 0; i < 2; ++i) {
+            auto hybrid_idx = std::make_shared<knowhere::IVFSQHybrid>(DEVICEID);
+            hybrid_idx->Load(binaryset);
+
+            auto new_idx = hybrid_idx->LoadData(quantization, quantizer_conf);
+            auto result = new_idx->Search(query_dataset, conf);
+            AssertAnns(result, nq, conf->k);
+            //            PrintResult(result, nq, k);
+        }
+    }
+
+    {
+        // quantization already in gpu, only set quantization
+        auto cpu_idx = std::make_shared<knowhere::IVFSQHybrid>(DEVICEID);
+        cpu_idx->Load(binaryset);
+
+        auto pair = cpu_idx->CopyCpuToGpuWithQuantizer(DEVICEID, conf);
+        auto quantization = pair.second;
+
+        for (int i = 0; i < 2; ++i) {
+            auto hybrid_idx = std::make_shared<knowhere::IVFSQHybrid>(DEVICEID);
+            hybrid_idx->Load(binaryset);
+
+            hybrid_idx->SetQuantizer(quantization);
+            auto result = hybrid_idx->Search(query_dataset, conf);
+            AssertAnns(result, nq, conf->k);
+            //            PrintResult(result, nq, k);
+            hybrid_idx->UnsetQuantizer();
+        }
+    }
+}
+
+#endif
diff --git a/core/src/index/unittest/test_gpuresource.cpp b/core/src/index/unittest/test_gpuresource.cpp
new file mode 100644
index 0000000000..e3485d26ba
--- /dev/null
+++ b/core/src/index/unittest/test_gpuresource.cpp
@@ -0,0 +1,309 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 <gtest/gtest.h>
+
+#include <iostream>
+#include <thread>
+
+#include <faiss/AutoTune.h>
+#include <faiss/gpu/GpuAutoTune.h>
+#include <faiss/gpu/GpuIndexIVFFlat.h>
+
+#include "knowhere/common/Exception.h"
+#include "knowhere/common/Timer.h"
+#include "knowhere/index/vector_index/IndexGPUIVF.h"
+#include "knowhere/index/vector_index/IndexGPUIVFPQ.h"
+#include "knowhere/index/vector_index/IndexGPUIVFSQ.h"
+#include "knowhere/index/vector_index/IndexIVF.h"
+#include "knowhere/index/vector_index/IndexIVFPQ.h"
+#include "knowhere/index/vector_index/IndexIVFSQ.h"
+#include "knowhere/index/vector_index/IndexIVFSQHybrid.h"
+#include "knowhere/index/vector_index/helpers/Cloner.h"
+
+#include "unittest/Helper.h"
+#include "unittest/utils.h"
+
+class GPURESTEST : public DataGen, public TestGpuIndexBase {
+ protected:
+    void
+    SetUp() override {
+        TestGpuIndexBase::SetUp();
+        Generate(DIM, NB, NQ);
+
+        k = K;
+        elems = nq * k;
+        ids = (int64_t*)malloc(sizeof(int64_t) * elems);
+        dis = (float*)malloc(sizeof(float) * elems);
+    }
+
+    void
+    TearDown() override {
+        delete ids;
+        delete dis;
+        TestGpuIndexBase::TearDown();
+    }
+
+ protected:
+    std::string index_type;
+    knowhere::IVFIndexPtr index_ = nullptr;
+
+    int64_t* ids = nullptr;
+    float* dis = nullptr;
+    int64_t elems = 0;
+};
+
+TEST_F(GPURESTEST, copyandsearch) {
+    // search and copy at the same time
+    printf("==================\n");
+
+    index_type = "GPUIVF";
+    index_ = IndexFactory(index_type);
+
+    auto conf = ParamGenerator::GetInstance().Gen(ParameterType::ivf);
+    auto preprocessor = index_->BuildPreprocessor(base_dataset, conf);
+    index_->set_preprocessor(preprocessor);
+    auto model = index_->Train(base_dataset, conf);
+    index_->set_index_model(model);
+    index_->Add(base_dataset, conf);
+    auto result = index_->Search(query_dataset, conf);
+    AssertAnns(result, nq, k);
+
+    auto cpu_idx = knowhere::cloner::CopyGpuToCpu(index_, knowhere::Config());
+    cpu_idx->Seal();
+    auto search_idx = knowhere::cloner::CopyCpuToGpu(cpu_idx, DEVICEID, knowhere::Config());
+
+    constexpr int64_t search_count = 50;
+    constexpr int64_t load_count = 15;
+    auto search_func = [&] {
+        // TimeRecorder tc("search&load");
+        for (int i = 0; i < search_count; ++i) {
+            search_idx->Search(query_dataset, conf);
+            // if (i > search_count - 6 || i == 0)
+            //    tc.RecordSection("search once");
+        }
+        // tc.ElapseFromBegin("search finish");
+    };
+    auto load_func = [&] {
+        // TimeRecorder tc("search&load");
+        for (int i = 0; i < load_count; ++i) {
+            knowhere::cloner::CopyCpuToGpu(cpu_idx, DEVICEID, knowhere::Config());
+            // if (i > load_count -5 || i < 5)
+            // tc.RecordSection("Copy to gpu");
+        }
+        // tc.ElapseFromBegin("load finish");
+    };
+
+    knowhere::TimeRecorder tc("Basic");
+    knowhere::cloner::CopyCpuToGpu(cpu_idx, DEVICEID, knowhere::Config());
+    tc.RecordSection("Copy to gpu once");
+    search_idx->Search(query_dataset, conf);
+    tc.RecordSection("Search once");
+    search_func();
+    tc.RecordSection("Search total cost");
+    load_func();
+    tc.RecordSection("Copy total cost");
+
+    std::thread search_thread(search_func);
+    std::thread load_thread(load_func);
+    search_thread.join();
+    load_thread.join();
+    tc.RecordSection("Copy&Search total");
+}
+
+TEST_F(GPURESTEST, trainandsearch) {
+    index_type = "GPUIVF";
+    index_ = IndexFactory(index_type);
+
+    auto conf = ParamGenerator::GetInstance().Gen(ParameterType::ivf);
+    auto preprocessor = index_->BuildPreprocessor(base_dataset, conf);
+    index_->set_preprocessor(preprocessor);
+    auto model = index_->Train(base_dataset, conf);
+    auto new_index = IndexFactory(index_type);
+    new_index->set_index_model(model);
+    new_index->Add(base_dataset, conf);
+    auto cpu_idx = knowhere::cloner::CopyGpuToCpu(new_index, knowhere::Config());
+    cpu_idx->Seal();
+    auto search_idx = knowhere::cloner::CopyCpuToGpu(cpu_idx, DEVICEID, knowhere::Config());
+
+    constexpr int train_count = 5;
+    constexpr int search_count = 200;
+    auto train_stage = [&] {
+        for (int i = 0; i < train_count; ++i) {
+            auto model = index_->Train(base_dataset, conf);
+            auto test_idx = IndexFactory(index_type);
+            test_idx->set_index_model(model);
+            test_idx->Add(base_dataset, conf);
+        }
+    };
+    auto search_stage = [&](knowhere::VectorIndexPtr& search_idx) {
+        for (int i = 0; i < search_count; ++i) {
+            auto result = search_idx->Search(query_dataset, conf);
+            AssertAnns(result, nq, k);
+        }
+    };
+
+    // TimeRecorder tc("record");
+    // train_stage();
+    // tc.RecordSection("train cost");
+    // search_stage(search_idx);
+    // tc.RecordSection("search cost");
+
+    {
+        // search and build parallel
+        std::thread search_thread(search_stage, std::ref(search_idx));
+        std::thread train_thread(train_stage);
+        train_thread.join();
+        search_thread.join();
+    }
+    {
+        // build parallel
+        std::thread train_1(train_stage);
+        std::thread train_2(train_stage);
+        train_1.join();
+        train_2.join();
+    }
+    {
+        // search parallel
+        auto search_idx_2 = knowhere::cloner::CopyCpuToGpu(cpu_idx, DEVICEID, knowhere::Config());
+        std::thread search_1(search_stage, std::ref(search_idx));
+        std::thread search_2(search_stage, std::ref(search_idx_2));
+        search_1.join();
+        search_2.join();
+    }
+}
+
+#ifdef CompareToOriFaiss
+TEST_F(GPURESTEST, gpu_ivf_resource_test) {
+    assert(!xb.empty());
+
+    {
+        index_ = std::make_shared<knowhere::GPUIVF>(-1);
+        ASSERT_EQ(std::dynamic_pointer_cast<knowhere::GPUIVF>(index_)->GetGpuDevice(), -1);
+        std::dynamic_pointer_cast<knowhere::GPUIVF>(index_)->SetGpuDevice(DEVICEID);
+        ASSERT_EQ(std::dynamic_pointer_cast<knowhere::GPUIVF>(index_)->GetGpuDevice(), DEVICEID);
+
+        auto conf = ParamGenerator::GetInstance().Gen(ParameterType::ivfsq);
+        auto preprocessor = index_->BuildPreprocessor(base_dataset, conf);
+        index_->set_preprocessor(preprocessor);
+        auto model = index_->Train(base_dataset, conf);
+        index_->set_index_model(model);
+        index_->Add(base_dataset, conf);
+        EXPECT_EQ(index_->Count(), nb);
+        EXPECT_EQ(index_->Dimension(), dim);
+
+        //        knowhere::TimeRecorder tc("knowere GPUIVF");
+        for (int i = 0; i < search_count; ++i) {
+            index_->Search(query_dataset, conf);
+            if (i > search_count - 6 || i < 5)
+            //                tc.RecordSection("search once");
+        }
+        //        tc.ElapseFromBegin("search all");
+    }
+    knowhere::FaissGpuResourceMgr::GetInstance().Dump();
+
+    //    {
+    //        // ori faiss IVF-Search
+    //        faiss::gpu::StandardGpuResources res;
+    //        faiss::gpu::GpuIndexIVFFlatConfig idx_config;
+    //        idx_config.device = DEVICEID;
+    //        faiss::gpu::GpuIndexIVFFlat device_index(&res, dim, 1638, faiss::METRIC_L2, idx_config);
+    //        device_index.train(nb, xb.data());
+    //        device_index.add(nb, xb.data());
+    //
+    //        knowhere::TimeRecorder tc("ori IVF");
+    //        for (int i = 0; i < search_count; ++i) {
+    //            device_index.search(nq, xq.data(), k, dis, ids);
+    //            if (i > search_count - 6 || i < 5)
+    //                tc.RecordSection("search once");
+    //        }
+    //        tc.ElapseFromBegin("search all");
+    //    }
+}
+
+TEST_F(GPURESTEST, gpuivfsq) {
+    {
+        // knowhere gpu ivfsq
+        index_type = "GPUIVFSQ";
+        index_ = IndexFactory(index_type);
+
+        auto conf = std::make_shared<knowhere::IVFSQCfg>();
+        conf->nlist = 1638;
+        conf->d = dim;
+        conf->gpu_id = DEVICEID;
+        conf->metric_type = knowhere::METRICTYPE::L2;
+        conf->k = k;
+        conf->nbits = 8;
+        conf->nprobe = 1;
+
+        auto preprocessor = index_->BuildPreprocessor(base_dataset, conf);
+        index_->set_preprocessor(preprocessor);
+        auto model = index_->Train(base_dataset, conf);
+        index_->set_index_model(model);
+        index_->Add(base_dataset, conf);
+        //        auto result = index_->Search(query_dataset, conf);
+        //        AssertAnns(result, nq, k);
+
+        auto cpu_idx = knowhere::cloner::CopyGpuToCpu(index_, knowhere::Config());
+        cpu_idx->Seal();
+
+        knowhere::TimeRecorder tc("knowhere GPUSQ8");
+        auto search_idx = knowhere::cloner::CopyCpuToGpu(cpu_idx, DEVICEID, knowhere::Config());
+        tc.RecordSection("Copy to gpu");
+        for (int i = 0; i < search_count; ++i) {
+            search_idx->Search(query_dataset, conf);
+            if (i > search_count - 6 || i < 5)
+                tc.RecordSection("search once");
+        }
+        tc.ElapseFromBegin("search all");
+    }
+
+    {
+        // Ori gpuivfsq Test
+        const char* index_description = "IVF1638,SQ8";
+        faiss::Index* ori_index = faiss::index_factory(dim, index_description, faiss::METRIC_L2);
+
+        faiss::gpu::StandardGpuResources res;
+        auto device_index = faiss::gpu::index_cpu_to_gpu(&res, DEVICEID, ori_index);
+        device_index->train(nb, xb.data());
+        device_index->add(nb, xb.data());
+
+        auto cpu_index = faiss::gpu::index_gpu_to_cpu(device_index);
+        auto idx = dynamic_cast<faiss::IndexIVF*>(cpu_index);
+        if (idx != nullptr) {
+            idx->to_readonly();
+        }
+        delete device_index;
+        delete ori_index;
+
+        faiss::gpu::GpuClonerOptions option;
+        option.allInGpu = true;
+
+        knowhere::TimeRecorder tc("ori GPUSQ8");
+        faiss::Index* search_idx = faiss::gpu::index_cpu_to_gpu(&res, DEVICEID, cpu_index, &option);
+        tc.RecordSection("Copy to gpu");
+        for (int i = 0; i < search_count; ++i) {
+            search_idx->search(nq, xq.data(), k, dis, ids);
+            if (i > search_count - 6 || i < 5)
+                tc.RecordSection("search once");
+        }
+        tc.ElapseFromBegin("search all");
+        delete cpu_index;
+        delete search_idx;
+    }
+}
+#endif
diff --git a/core/src/index/unittest/test_idmap.cpp b/core/src/index/unittest/test_idmap.cpp
new file mode 100644
index 0000000000..d1ff3ee046
--- /dev/null
+++ b/core/src/index/unittest/test_idmap.cpp
@@ -0,0 +1,177 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 <gtest/gtest.h>
+#include <iostream>
+
+#include "knowhere/adapter/Structure.h"
+#include "knowhere/common/Exception.h"
+#include "knowhere/index/vector_index/IndexIDMAP.h"
+#include "knowhere/index/vector_index/helpers/Cloner.h"
+
+#include "Helper.h"
+#include "unittest/utils.h"
+
+class IDMAPTest : public DataGen, public TestGpuIndexBase {
+ protected:
+    void
+    SetUp() override {
+        TestGpuIndexBase::SetUp();
+
+        Init_with_default();
+        index_ = std::make_shared<knowhere::IDMAP>();
+    }
+
+    void
+    TearDown() override {
+        TestGpuIndexBase::TearDown();
+    }
+
+ protected:
+    knowhere::IDMAPPtr index_ = nullptr;
+};
+
+TEST_F(IDMAPTest, idmap_basic) {
+    ASSERT_TRUE(!xb.empty());
+
+    auto conf = std::make_shared<knowhere::Cfg>();
+    conf->d = dim;
+    conf->k = k;
+    conf->metric_type = knowhere::METRICTYPE::L2;
+
+    index_->Train(conf);
+    index_->Add(base_dataset, conf);
+    EXPECT_EQ(index_->Count(), nb);
+    EXPECT_EQ(index_->Dimension(), dim);
+    ASSERT_TRUE(index_->GetRawVectors() != nullptr);
+    ASSERT_TRUE(index_->GetRawIds() != nullptr);
+    auto result = index_->Search(query_dataset, conf);
+    AssertAnns(result, nq, k);
+    //    PrintResult(result, nq, k);
+
+    index_->Seal();
+    auto binaryset = index_->Serialize();
+    auto new_index = std::make_shared<knowhere::IDMAP>();
+    new_index->Load(binaryset);
+    auto re_result = index_->Search(query_dataset, conf);
+    AssertAnns(re_result, nq, k);
+    //    PrintResult(re_result, nq, k);
+}
+
+TEST_F(IDMAPTest, idmap_serialize) {
+    auto serialize = [](const std::string& filename, knowhere::BinaryPtr& bin, uint8_t* ret) {
+        FileIOWriter writer(filename);
+        writer(static_cast<void*>(bin->data.get()), bin->size);
+
+        FileIOReader reader(filename);
+        reader(ret, bin->size);
+    };
+
+    auto conf = std::make_shared<knowhere::Cfg>();
+    conf->d = dim;
+    conf->k = k;
+    conf->metric_type = knowhere::METRICTYPE::L2;
+
+    {
+        // serialize index
+        index_->Train(conf);
+        index_->Add(base_dataset, knowhere::Config());
+        auto re_result = index_->Search(query_dataset, conf);
+        AssertAnns(re_result, nq, k);
+        //        PrintResult(re_result, nq, k);
+        EXPECT_EQ(index_->Count(), nb);
+        EXPECT_EQ(index_->Dimension(), dim);
+        auto binaryset = index_->Serialize();
+        auto bin = binaryset.GetByName("IVF");
+
+        std::string filename = "/tmp/idmap_test_serialize.bin";
+        auto load_data = new uint8_t[bin->size];
+        serialize(filename, bin, load_data);
+
+        binaryset.clear();
+        auto data = std::make_shared<uint8_t>();
+        data.reset(load_data);
+        binaryset.Append("IVF", data, bin->size);
+
+        index_->Load(binaryset);
+        EXPECT_EQ(index_->Count(), nb);
+        EXPECT_EQ(index_->Dimension(), dim);
+        auto result = index_->Search(query_dataset, conf);
+        AssertAnns(result, nq, k);
+        //        PrintResult(result, nq, k);
+    }
+}
+
+TEST_F(IDMAPTest, copy_test) {
+    ASSERT_TRUE(!xb.empty());
+
+    auto conf = std::make_shared<knowhere::Cfg>();
+    conf->d = dim;
+    conf->k = k;
+    conf->metric_type = knowhere::METRICTYPE::L2;
+
+    index_->Train(conf);
+    index_->Add(base_dataset, conf);
+    EXPECT_EQ(index_->Count(), nb);
+    EXPECT_EQ(index_->Dimension(), dim);
+    ASSERT_TRUE(index_->GetRawVectors() != nullptr);
+    ASSERT_TRUE(index_->GetRawIds() != nullptr);
+    auto result = index_->Search(query_dataset, conf);
+    AssertAnns(result, nq, k);
+    // PrintResult(result, nq, k);
+
+    {
+        // clone
+        auto clone_index = index_->Clone();
+        auto clone_result = clone_index->Search(query_dataset, conf);
+        AssertAnns(clone_result, nq, k);
+    }
+
+    {
+        // cpu to gpu
+        auto clone_index = knowhere::cloner::CopyCpuToGpu(index_, DEVICEID, conf);
+        auto clone_result = clone_index->Search(query_dataset, conf);
+        AssertAnns(clone_result, nq, k);
+        ASSERT_THROW({ std::static_pointer_cast<knowhere::GPUIDMAP>(clone_index)->GetRawVectors(); },
+                     knowhere::KnowhereException);
+        ASSERT_THROW({ std::static_pointer_cast<knowhere::GPUIDMAP>(clone_index)->GetRawIds(); },
+                     knowhere::KnowhereException);
+
+        auto binary = clone_index->Serialize();
+        clone_index->Load(binary);
+        auto new_result = clone_index->Search(query_dataset, conf);
+        AssertAnns(new_result, nq, k);
+
+        auto clone_gpu_idx = clone_index->Clone();
+        auto clone_gpu_res = clone_gpu_idx->Search(query_dataset, conf);
+        AssertAnns(clone_gpu_res, nq, k);
+
+        // gpu to cpu
+        auto host_index = knowhere::cloner::CopyGpuToCpu(clone_index, conf);
+        auto host_result = host_index->Search(query_dataset, conf);
+        AssertAnns(host_result, nq, k);
+        ASSERT_TRUE(std::static_pointer_cast<knowhere::IDMAP>(host_index)->GetRawVectors() != nullptr);
+        ASSERT_TRUE(std::static_pointer_cast<knowhere::IDMAP>(host_index)->GetRawIds() != nullptr);
+
+        // gpu to gpu
+        auto device_index = knowhere::cloner::CopyCpuToGpu(index_, DEVICEID, conf);
+        auto new_device_index =
+            std::static_pointer_cast<knowhere::GPUIDMAP>(device_index)->CopyGpuToGpu(DEVICEID, conf);
+        auto device_result = new_device_index->Search(query_dataset, conf);
+        AssertAnns(device_result, nq, k);
+    }
+}
diff --git a/core/src/index/unittest/test_ivf.cpp b/core/src/index/unittest/test_ivf.cpp
new file mode 100644
index 0000000000..fae27b0dd3
--- /dev/null
+++ b/core/src/index/unittest/test_ivf.cpp
@@ -0,0 +1,296 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 <gtest/gtest.h>
+
+#include <iostream>
+#include <thread>
+
+#include <faiss/AutoTune.h>
+#include <faiss/gpu/GpuAutoTune.h>
+#include <faiss/gpu/GpuIndexIVFFlat.h>
+
+#include "knowhere/common/Exception.h"
+#include "knowhere/common/Timer.h"
+#include "knowhere/index/vector_index/IndexGPUIVF.h"
+#include "knowhere/index/vector_index/IndexGPUIVFPQ.h"
+#include "knowhere/index/vector_index/IndexGPUIVFSQ.h"
+#include "knowhere/index/vector_index/IndexIVF.h"
+#include "knowhere/index/vector_index/IndexIVFPQ.h"
+#include "knowhere/index/vector_index/IndexIVFSQ.h"
+#include "knowhere/index/vector_index/IndexIVFSQHybrid.h"
+#include "knowhere/index/vector_index/helpers/Cloner.h"
+
+#include "unittest/Helper.h"
+#include "unittest/utils.h"
+
+using ::testing::Combine;
+using ::testing::TestWithParam;
+using ::testing::Values;
+
+class IVFTest : public DataGen, public TestWithParam<::std::tuple<std::string, ParameterType>> {
+ protected:
+    void
+    SetUp() override {
+        knowhere::FaissGpuResourceMgr::GetInstance().InitDevice(DEVICEID, PINMEM, TEMPMEM, RESNUM);
+
+        ParameterType parameter_type;
+        std::tie(index_type, parameter_type) = GetParam();
+        // Init_with_default();
+        Generate(DIM, NB, NQ);
+        index_ = IndexFactory(index_type);
+        conf = ParamGenerator::GetInstance().Gen(parameter_type);
+    }
+
+    void
+    TearDown() override {
+        knowhere::FaissGpuResourceMgr::GetInstance().Free();
+    }
+
+    knowhere::VectorIndexPtr
+    ChooseTodo() {
+        std::vector<std::string> gpu_idx{"GPUIVFSQ"};
+        auto finder = std::find(gpu_idx.cbegin(), gpu_idx.cend(), index_type);
+        if (finder != gpu_idx.cend()) {
+            return knowhere::cloner::CopyCpuToGpu(index_, DEVICEID, knowhere::Config());
+        }
+        return index_;
+    }
+
+ protected:
+    std::string index_type;
+    knowhere::Config conf;
+    knowhere::IVFIndexPtr index_ = nullptr;
+};
+
+INSTANTIATE_TEST_CASE_P(IVFParameters, IVFTest,
+                        Values(std::make_tuple("IVF", ParameterType::ivf),
+                               std::make_tuple("GPUIVF", ParameterType::ivf),
+                               std::make_tuple("IVFPQ", ParameterType::ivfpq),
+                               std::make_tuple("GPUIVFPQ", ParameterType::ivfpq),
+                               std::make_tuple("IVFSQ", ParameterType::ivfsq),
+#ifdef CUSTOMIZATION
+                               std::make_tuple("IVFSQHybrid", ParameterType::ivfsq),
+#endif
+                               std::make_tuple("GPUIVFSQ", ParameterType::ivfsq)));
+
+TEST_P(IVFTest, ivf_basic) {
+    assert(!xb.empty());
+
+    auto preprocessor = index_->BuildPreprocessor(base_dataset, conf);
+    index_->set_preprocessor(preprocessor);
+
+    auto model = index_->Train(base_dataset, conf);
+    index_->set_index_model(model);
+    index_->Add(base_dataset, conf);
+    EXPECT_EQ(index_->Count(), nb);
+    EXPECT_EQ(index_->Dimension(), dim);
+
+    auto new_idx = ChooseTodo();
+    auto result = new_idx->Search(query_dataset, conf);
+    AssertAnns(result, nq, conf->k);
+    // PrintResult(result, nq, k);
+}
+
+TEST_P(IVFTest, ivf_serialize) {
+    auto serialize = [](const std::string& filename, knowhere::BinaryPtr& bin, uint8_t* ret) {
+        FileIOWriter writer(filename);
+        writer(static_cast<void*>(bin->data.get()), bin->size);
+
+        FileIOReader reader(filename);
+        reader(ret, bin->size);
+    };
+
+    {
+        // serialize index-model
+        auto model = index_->Train(base_dataset, conf);
+        auto binaryset = model->Serialize();
+        auto bin = binaryset.GetByName("IVF");
+
+        std::string filename = "/tmp/ivf_test_model_serialize.bin";
+        auto load_data = new uint8_t[bin->size];
+        serialize(filename, bin, load_data);
+
+        binaryset.clear();
+        auto data = std::make_shared<uint8_t>();
+        data.reset(load_data);
+        binaryset.Append("IVF", data, bin->size);
+
+        model->Load(binaryset);
+
+        index_->set_index_model(model);
+        index_->Add(base_dataset, conf);
+        auto new_idx = ChooseTodo();
+        auto result = new_idx->Search(query_dataset, conf);
+        AssertAnns(result, nq, conf->k);
+    }
+
+    {
+        // serialize index
+        auto model = index_->Train(base_dataset, conf);
+        index_->set_index_model(model);
+        index_->Add(base_dataset, conf);
+        auto binaryset = index_->Serialize();
+        auto bin = binaryset.GetByName("IVF");
+
+        std::string filename = "/tmp/ivf_test_serialize.bin";
+        auto load_data = new uint8_t[bin->size];
+        serialize(filename, bin, load_data);
+
+        binaryset.clear();
+        auto data = std::make_shared<uint8_t>();
+        data.reset(load_data);
+        binaryset.Append("IVF", data, bin->size);
+
+        index_->Load(binaryset);
+        EXPECT_EQ(index_->Count(), nb);
+        EXPECT_EQ(index_->Dimension(), dim);
+        auto new_idx = ChooseTodo();
+        auto result = new_idx->Search(query_dataset, conf);
+        AssertAnns(result, nq, conf->k);
+    }
+}
+
+TEST_P(IVFTest, clone_test) {
+    assert(!xb.empty());
+
+    auto preprocessor = index_->BuildPreprocessor(base_dataset, conf);
+    index_->set_preprocessor(preprocessor);
+
+    auto model = index_->Train(base_dataset, conf);
+    index_->set_index_model(model);
+    index_->Add(base_dataset, conf);
+    EXPECT_EQ(index_->Count(), nb);
+    EXPECT_EQ(index_->Dimension(), dim);
+    auto new_idx = ChooseTodo();
+    auto result = new_idx->Search(query_dataset, conf);
+    AssertAnns(result, nq, conf->k);
+    // PrintResult(result, nq, k);
+
+    auto AssertEqual = [&](knowhere::DatasetPtr p1, knowhere::DatasetPtr p2) {
+        auto ids_p1 = p1->array()[0];
+        auto ids_p2 = p2->array()[0];
+
+        for (int i = 0; i < nq * k; ++i) {
+            EXPECT_EQ(*(ids_p2->data()->GetValues<int64_t>(1, i)), *(ids_p1->data()->GetValues<int64_t>(1, i)));
+        }
+    };
+
+    //    {
+    //        // clone in place
+    //        std::vector<std::string> support_idx_vec{"IVF", "GPUIVF", "IVFPQ", "IVFSQ", "GPUIVFSQ"};
+    //        auto finder = std::find(support_idx_vec.cbegin(), support_idx_vec.cend(), index_type);
+    //        if (finder != support_idx_vec.cend()) {
+    //            EXPECT_NO_THROW({
+    //                                auto clone_index = index_->Clone();
+    //                                auto clone_result = clone_index->Search(query_dataset, conf);
+    //                                //AssertAnns(result, nq, conf->k);
+    //                                AssertEqual(result, clone_result);
+    //                                std::cout << "inplace clone [" << index_type << "] success" << std::endl;
+    //                            });
+    //        } else {
+    //            EXPECT_THROW({
+    //                             std::cout << "inplace clone [" << index_type << "] failed" << std::endl;
+    //                             auto clone_index = index_->Clone();
+    //                         }, KnowhereException);
+    //        }
+    //    }
+
+    {
+        if (index_type == "IVFSQHybrid") {
+            return;
+        }
+    }
+
+    {
+        // copy from gpu to cpu
+        std::vector<std::string> support_idx_vec{"GPUIVF", "GPUIVFSQ", "IVFSQHybrid"};
+        auto finder = std::find(support_idx_vec.cbegin(), support_idx_vec.cend(), index_type);
+        if (finder != support_idx_vec.cend()) {
+            EXPECT_NO_THROW({
+                auto clone_index = knowhere::cloner::CopyGpuToCpu(index_, knowhere::Config());
+                auto clone_result = clone_index->Search(query_dataset, conf);
+                AssertEqual(result, clone_result);
+                std::cout << "clone G <=> C [" << index_type << "] success" << std::endl;
+            });
+        } else {
+            EXPECT_THROW(
+                {
+                    std::cout << "clone G <=> C [" << index_type << "] failed" << std::endl;
+                    auto clone_index = knowhere::cloner::CopyGpuToCpu(index_, knowhere::Config());
+                },
+                knowhere::KnowhereException);
+        }
+    }
+
+    {
+        // copy to gpu
+        std::vector<std::string> support_idx_vec{"IVF", "GPUIVF", "IVFSQ", "GPUIVFSQ"};
+        auto finder = std::find(support_idx_vec.cbegin(), support_idx_vec.cend(), index_type);
+        if (finder != support_idx_vec.cend()) {
+            EXPECT_NO_THROW({
+                auto clone_index = knowhere::cloner::CopyCpuToGpu(index_, DEVICEID, knowhere::Config());
+                auto clone_result = clone_index->Search(query_dataset, conf);
+                AssertEqual(result, clone_result);
+                std::cout << "clone C <=> G [" << index_type << "] success" << std::endl;
+            });
+        } else {
+            EXPECT_THROW(
+                {
+                    std::cout << "clone C <=> G [" << index_type << "] failed" << std::endl;
+                    auto clone_index = knowhere::cloner::CopyCpuToGpu(index_, DEVICEID, knowhere::Config());
+                },
+                knowhere::KnowhereException);
+        }
+    }
+}
+
+#ifdef CUSTOMIZATION
+TEST_P(IVFTest, gpu_seal_test) {
+    std::vector<std::string> support_idx_vec{"GPUIVF", "GPUIVFSQ", "IVFSQHybrid"};
+    auto finder = std::find(support_idx_vec.cbegin(), support_idx_vec.cend(), index_type);
+    if (finder == support_idx_vec.cend()) {
+        return;
+    }
+
+    assert(!xb.empty());
+
+    auto preprocessor = index_->BuildPreprocessor(base_dataset, conf);
+    index_->set_preprocessor(preprocessor);
+
+    auto model = index_->Train(base_dataset, conf);
+    index_->set_index_model(model);
+    index_->Add(base_dataset, conf);
+    EXPECT_EQ(index_->Count(), nb);
+    EXPECT_EQ(index_->Dimension(), dim);
+    auto new_idx = ChooseTodo();
+    auto result = new_idx->Search(query_dataset, conf);
+    AssertAnns(result, nq, conf->k);
+
+    auto cpu_idx = knowhere::cloner::CopyGpuToCpu(index_, knowhere::Config());
+
+    knowhere::TimeRecorder tc("CopyToGpu");
+    knowhere::cloner::CopyCpuToGpu(cpu_idx, DEVICEID, knowhere::Config());
+    auto without_seal = tc.RecordSection("Without seal");
+    cpu_idx->Seal();
+    tc.RecordSection("seal cost");
+    knowhere::cloner::CopyCpuToGpu(cpu_idx, DEVICEID, knowhere::Config());
+    auto with_seal = tc.RecordSection("With seal");
+    ASSERT_GE(without_seal, with_seal);
+}
+
+#endif
diff --git a/core/src/index/unittest/test_kdt.cpp b/core/src/index/unittest/test_kdt.cpp
new file mode 100644
index 0000000000..5400881875
--- /dev/null
+++ b/core/src/index/unittest/test_kdt.cpp
@@ -0,0 +1,140 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 <gtest/gtest.h>
+
+#include <iostream>
+#include <sstream>
+
+#include "knowhere/adapter/SptagAdapter.h"
+#include "knowhere/adapter/Structure.h"
+#include "knowhere/common/Exception.h"
+#include "knowhere/index/vector_index/IndexKDT.h"
+#include "knowhere/index/vector_index/helpers/Definitions.h"
+
+#include "unittest/utils.h"
+
+using ::testing::Combine;
+using ::testing::TestWithParam;
+using ::testing::Values;
+
+class KDTTest : public DataGen, public ::testing::Test {
+ protected:
+    void
+    SetUp() override {
+        Generate(96, 1000, 10);
+        index_ = std::make_shared<knowhere::CPUKDTRNG>();
+
+        auto tempconf = std::make_shared<knowhere::KDTCfg>();
+        tempconf->tptnubmber = 1;
+        tempconf->k = 10;
+        conf = tempconf;
+
+        Init_with_default();
+    }
+
+ protected:
+    knowhere::Config conf;
+    std::shared_ptr<knowhere::CPUKDTRNG> index_ = nullptr;
+};
+
+// TODO(lxj): add test about count() and dimension()
+TEST_F(KDTTest, kdt_basic) {
+    assert(!xb.empty());
+
+    auto preprocessor = index_->BuildPreprocessor(base_dataset, conf);
+    index_->set_preprocessor(preprocessor);
+
+    auto model = index_->Train(base_dataset, conf);
+    index_->set_index_model(model);
+    index_->Add(base_dataset, conf);
+    auto result = index_->Search(query_dataset, conf);
+    AssertAnns(result, nq, k);
+
+    {
+        auto ids = result->array()[0];
+        auto dists = result->array()[1];
+
+        std::stringstream ss_id;
+        std::stringstream ss_dist;
+        for (auto i = 0; i < nq; i++) {
+            for (auto j = 0; j < k; ++j) {
+                ss_id << *ids->data()->GetValues<int64_t>(1, i * k + j) << " ";
+                ss_dist << *dists->data()->GetValues<float>(1, i * k + j) << " ";
+            }
+            ss_id << std::endl;
+            ss_dist << std::endl;
+        }
+        std::cout << "id\n" << ss_id.str() << std::endl;
+        std::cout << "dist\n" << ss_dist.str() << std::endl;
+    }
+}
+
+// TODO(zirui): enable test
+// TEST_F(KDTTest, kdt_serialize) {
+//    assert(!xb.empty());
+//
+//    auto preprocessor = index_->BuildPreprocessor(base_dataset, conf);
+//    index_->set_preprocessor(preprocessor);
+//
+//    auto model = index_->Train(base_dataset, conf);
+//    // index_->Add(base_dataset, conf);
+//    auto binaryset = index_->Serialize();
+//    auto new_index = std::make_shared<knowhere::CPUKDTRNG>();
+//    new_index->Load(binaryset);
+//    auto result = new_index->Search(query_dataset, conf);
+//    AssertAnns(result, nq, k);
+//    PrintResult(result, nq, k);
+//    ASSERT_EQ(new_index->Count(), nb);
+//    ASSERT_EQ(new_index->Dimension(), dim);
+//    ASSERT_THROW({ new_index->Clone(); }, knowhere::KnowhereException);
+//    ASSERT_NO_THROW({ new_index->Seal(); });
+//
+//    {
+//        int fileno = 0;
+//        const std::string& base_name = "/tmp/kdt_serialize_test_bin_";
+//        std::vector<std::string> filename_list;
+//        std::vector<std::pair<std::string, size_t>> meta_list;
+//        for (auto& iter : binaryset.binary_map_) {
+//            const std::string& filename = base_name + std::to_string(fileno);
+//            FileIOWriter writer(filename);
+//            writer(iter.second->data.get(), iter.second->size);
+//
+//            meta_list.emplace_back(std::make_pair(iter.first, iter.second->size));
+//            filename_list.push_back(filename);
+//            ++fileno;
+//        }
+//
+//        knowhere::BinarySet load_data_list;
+//        for (int i = 0; i < filename_list.size() && i < meta_list.size(); ++i) {
+//            auto bin_size = meta_list[i].second;
+//            FileIOReader reader(filename_list[i]);
+//
+//            auto load_data = new uint8_t[bin_size];
+//            reader(load_data, bin_size);
+//            auto data = std::make_shared<uint8_t>();
+//            data.reset(load_data);
+//            load_data_list.Append(meta_list[i].first, data, bin_size);
+//        }
+//
+//        auto new_index = std::make_shared<knowhere::CPUKDTRNG>();
+//        new_index->Load(load_data_list);
+//        auto result = new_index->Search(query_dataset, conf);
+//        AssertAnns(result, nq, k);
+//        PrintResult(result, nq, k);
+//    }
+//}
diff --git a/core/src/index/unittest/test_nsg/CMakeLists.txt b/core/src/index/unittest/test_nsg/CMakeLists.txt
new file mode 100644
index 0000000000..3d22051d82
--- /dev/null
+++ b/core/src/index/unittest/test_nsg/CMakeLists.txt
@@ -0,0 +1,30 @@
+##############################
+#include_directories(/usr/local/include/gperftools)
+#link_directories(/usr/local/lib)
+
+add_definitions(-std=c++11 -O3 -lboost -march=native -Wall -DINFO)
+
+find_package(OpenMP)
+if (OPENMP_FOUND)
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OpenMP_C_FLAGS}")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
+else ()
+    message(FATAL_ERROR "no OpenMP supprot")
+endif ()
+message(${OpenMP_CXX_FLAGS})
+
+include_directories(${INDEX_SOURCE_DIR}/knowhere/knowhere/index/vector_index/nsg)
+aux_source_directory(${INDEX_SOURCE_DIR}/knowhere/knowhere/index/vector_index/nsg nsg_src)
+
+set(interface_src
+        ${INDEX_SOURCE_DIR}/knowhere/knowhere/index/vector_index/IndexNSG.cpp
+        )
+
+if(NOT TARGET test_nsg)
+    add_executable(test_nsg test_nsg.cpp ${interface_src} ${nsg_src} ${util_srcs} ${ivf_srcs})
+endif()
+
+target_link_libraries(test_nsg ${depend_libs} ${unittest_libs} ${basic_libs})
+##############################
+
+install(TARGETS test_nsg DESTINATION unittest)
\ No newline at end of file
diff --git a/core/src/index/unittest/test_nsg/test_nsg.cpp b/core/src/index/unittest/test_nsg/test_nsg.cpp
new file mode 100644
index 0000000000..11b9becce4
--- /dev/null
+++ b/core/src/index/unittest/test_nsg/test_nsg.cpp
@@ -0,0 +1,108 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 <gtest/gtest.h>
+#include <memory>
+
+#include "knowhere/common/Exception.h"
+#include "knowhere/index/vector_index/FaissBaseIndex.h"
+#include "knowhere/index/vector_index/IndexNSG.h"
+#include "knowhere/index/vector_index/helpers/FaissGpuResourceMgr.h"
+#include "knowhere/index/vector_index/nsg/NSGIO.h"
+
+#include "unittest/utils.h"
+
+using ::testing::Combine;
+using ::testing::TestWithParam;
+using ::testing::Values;
+
+constexpr int64_t DEVICEID = 0;
+
+class NSGInterfaceTest : public DataGen, public ::testing::Test {
+ protected:
+    void
+    SetUp() override {
+        // Init_with_default();
+        knowhere::FaissGpuResourceMgr::GetInstance().InitDevice(DEVICEID, 1024 * 1024 * 200, 1024 * 1024 * 600, 2);
+        Generate(256, 1000000 / 100, 1);
+        index_ = std::make_shared<knowhere::NSG>();
+
+        auto tmp_conf = std::make_shared<knowhere::NSGCfg>();
+        tmp_conf->gpu_id = DEVICEID;
+        tmp_conf->knng = 20;
+        tmp_conf->nprobe = 8;
+        tmp_conf->nlist = 163;
+        tmp_conf->search_length = 40;
+        tmp_conf->out_degree = 30;
+        tmp_conf->candidate_pool_size = 100;
+        tmp_conf->metric_type = knowhere::METRICTYPE::L2;
+        train_conf = tmp_conf;
+
+        auto tmp2_conf = std::make_shared<knowhere::NSGCfg>();
+        tmp2_conf->k = k;
+        tmp2_conf->search_length = 30;
+        search_conf = tmp2_conf;
+    }
+
+    void
+    TearDown() override {
+        knowhere::FaissGpuResourceMgr::GetInstance().Free();
+    }
+
+ protected:
+    std::shared_ptr<knowhere::NSG> index_;
+    knowhere::Config train_conf;
+    knowhere::Config search_conf;
+};
+
+TEST_F(NSGInterfaceTest, basic_test) {
+    assert(!xb.empty());
+
+    auto model = index_->Train(base_dataset, train_conf);
+    auto result = index_->Search(query_dataset, search_conf);
+    AssertAnns(result, nq, k);
+
+    auto binaryset = index_->Serialize();
+    auto new_index = std::make_shared<knowhere::NSG>();
+    new_index->Load(binaryset);
+    auto new_result = new_index->Search(query_dataset, search_conf);
+    AssertAnns(result, nq, k);
+
+    ASSERT_EQ(index_->Count(), nb);
+    ASSERT_EQ(index_->Dimension(), dim);
+    ASSERT_THROW({ index_->Clone(); }, knowhere::KnowhereException);
+    ASSERT_NO_THROW({
+        index_->Add(base_dataset, knowhere::Config());
+        index_->Seal();
+    });
+
+    {
+        // std::cout << "k = 1" << std::endl;
+        // new_index->Search(GenQuery(1), Config::object{{"k", 1}});
+        // new_index->Search(GenQuery(10), Config::object{{"k", 1}});
+        // new_index->Search(GenQuery(100), Config::object{{"k", 1}});
+        // new_index->Search(GenQuery(1000), Config::object{{"k", 1}});
+        // new_index->Search(GenQuery(10000), Config::object{{"k", 1}});
+
+        // std::cout << "k = 5" << std::endl;
+        // new_index->Search(GenQuery(1), Config::object{{"k", 5}});
+        // new_index->Search(GenQuery(20), Config::object{{"k", 5}});
+        // new_index->Search(GenQuery(100), Config::object{{"k", 5}});
+        // new_index->Search(GenQuery(300), Config::object{{"k", 5}});
+        // new_index->Search(GenQuery(500), Config::object{{"k", 5}});
+    }
+}
diff --git a/core/src/index/unittest/utils.cpp b/core/src/index/unittest/utils.cpp
new file mode 100644
index 0000000000..d4a59bafbb
--- /dev/null
+++ b/core/src/index/unittest/utils.cpp
@@ -0,0 +1,177 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "unittest/utils.h"
+
+#include <gtest/gtest.h>
+#include <memory>
+#include <string>
+#include <utility>
+
+INITIALIZE_EASYLOGGINGPP
+
+void
+InitLog() {
+    el::Configurations defaultConf;
+    defaultConf.setToDefault();
+    defaultConf.set(el::Level::Debug, el::ConfigurationType::Format, "[%thread-%datetime-%level]: %msg (%fbase:%line)");
+    el::Loggers::reconfigureLogger("default", defaultConf);
+}
+
+void
+DataGen::Init_with_default() {
+    Generate(dim, nb, nq);
+}
+
+void
+DataGen::Generate(const int& dim, const int& nb, const int& nq) {
+    this->nb = nb;
+    this->nq = nq;
+    this->dim = dim;
+
+    GenAll(dim, nb, xb, ids, nq, xq);
+    assert(xb.size() == (size_t)dim * nb);
+    assert(xq.size() == (size_t)dim * nq);
+
+    base_dataset = generate_dataset(nb, dim, xb.data(), ids.data());
+    query_dataset = generate_query_dataset(nq, dim, xq.data());
+}
+
+knowhere::DatasetPtr
+DataGen::GenQuery(const int& nq) {
+    xq.resize(nq * dim);
+    for (int i = 0; i < nq * dim; ++i) {
+        xq[i] = xb[i];
+    }
+    return generate_query_dataset(nq, dim, xq.data());
+}
+
+void
+GenAll(const int64_t dim, const int64_t& nb, std::vector<float>& xb, std::vector<int64_t>& ids, const int64_t& nq,
+       std::vector<float>& xq) {
+    xb.resize(nb * dim);
+    xq.resize(nq * dim);
+    ids.resize(nb);
+    GenAll(dim, nb, xb.data(), ids.data(), nq, xq.data());
+}
+
+void
+GenAll(const int64_t& dim, const int64_t& nb, float* xb, int64_t* ids, const int64_t& nq, float* xq) {
+    GenBase(dim, nb, xb, ids);
+    for (int64_t i = 0; i < nq * dim; ++i) {
+        xq[i] = xb[i];
+    }
+}
+
+void
+GenBase(const int64_t& dim, const int64_t& nb, float* xb, int64_t* ids) {
+    for (auto i = 0; i < nb; ++i) {
+        for (auto j = 0; j < dim; ++j) {
+            // p_data[i * d + j] = float(base + i);
+            xb[i * dim + j] = drand48();
+        }
+        xb[dim * i] += i / 1000.;
+        ids[i] = i;
+    }
+}
+
+FileIOReader::FileIOReader(const std::string& fname) {
+    name = fname;
+    fs = std::fstream(name, std::ios::in | std::ios::binary);
+}
+
+FileIOReader::~FileIOReader() {
+    fs.close();
+}
+
+size_t
+FileIOReader::operator()(void* ptr, size_t size) {
+    fs.read(reinterpret_cast<char*>(ptr), size);
+    return size;
+}
+
+FileIOWriter::FileIOWriter(const std::string& fname) {
+    name = fname;
+    fs = std::fstream(name, std::ios::out | std::ios::binary);
+}
+
+FileIOWriter::~FileIOWriter() {
+    fs.close();
+}
+
+size_t
+FileIOWriter::operator()(void* ptr, size_t size) {
+    fs.write(reinterpret_cast<char*>(ptr), size);
+    return size;
+}
+
+knowhere::DatasetPtr
+generate_dataset(int64_t nb, int64_t dim, float* xb, int64_t* ids) {
+    std::vector<int64_t> shape{nb, dim};
+    auto tensor = knowhere::ConstructFloatTensor((uint8_t*)xb, nb * dim * sizeof(float), shape);
+    std::vector<knowhere::TensorPtr> tensors{tensor};
+    std::vector<knowhere::FieldPtr> tensor_fields{knowhere::ConstructFloatField("data")};
+    auto tensor_schema = std::make_shared<knowhere::Schema>(tensor_fields);
+
+    auto id_array = knowhere::ConstructInt64Array((uint8_t*)ids, nb * sizeof(int64_t));
+    std::vector<knowhere::ArrayPtr> arrays{id_array};
+    std::vector<knowhere::FieldPtr> array_fields{knowhere::ConstructInt64Field("id")};
+    auto array_schema = std::make_shared<knowhere::Schema>(tensor_fields);
+
+    auto dataset =
+        std::make_shared<knowhere::Dataset>(std::move(arrays), array_schema, std::move(tensors), tensor_schema);
+    return dataset;
+}
+
+knowhere::DatasetPtr
+generate_query_dataset(int64_t nb, int64_t dim, float* xb) {
+    std::vector<int64_t> shape{nb, dim};
+    auto tensor = knowhere::ConstructFloatTensor((uint8_t*)xb, nb * dim * sizeof(float), shape);
+    std::vector<knowhere::TensorPtr> tensors{tensor};
+    std::vector<knowhere::FieldPtr> tensor_fields{knowhere::ConstructFloatField("data")};
+    auto tensor_schema = std::make_shared<knowhere::Schema>(tensor_fields);
+
+    auto dataset = std::make_shared<knowhere::Dataset>(std::move(tensors), tensor_schema);
+    return dataset;
+}
+
+void
+AssertAnns(const knowhere::DatasetPtr& result, const int& nq, const int& k) {
+    auto ids = result->array()[0];
+    for (auto i = 0; i < nq; i++) {
+        EXPECT_EQ(i, *(ids->data()->GetValues<int64_t>(1, i * k)));
+    }
+}
+
+void
+PrintResult(const knowhere::DatasetPtr& result, const int& nq, const int& k) {
+    auto ids = result->array()[0];
+    auto dists = result->array()[1];
+
+    std::stringstream ss_id;
+    std::stringstream ss_dist;
+    for (auto i = 0; i < 10; i++) {
+        for (auto j = 0; j < k; ++j) {
+            ss_id << *(ids->data()->GetValues<int64_t>(1, i * k + j)) << " ";
+            ss_dist << *(dists->data()->GetValues<float>(1, i * k + j)) << " ";
+        }
+        ss_id << std::endl;
+        ss_dist << std::endl;
+    }
+    std::cout << "id\n" << ss_id.str() << std::endl;
+    std::cout << "dist\n" << ss_dist.str() << std::endl;
+}
diff --git a/core/src/index/unittest/utils.h b/core/src/index/unittest/utils.h
new file mode 100644
index 0000000000..b39cf9ea14
--- /dev/null
+++ b/core/src/index/unittest/utils.h
@@ -0,0 +1,95 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <cstdio>
+#include <cstdlib>
+#include <fstream>
+#include <string>
+#include <vector>
+
+#include "knowhere/adapter/Structure.h"
+#include "knowhere/common/Log.h"
+
+class DataGen {
+ protected:
+    void
+    Init_with_default();
+
+    void
+    Generate(const int& dim, const int& nb, const int& nq);
+
+    knowhere::DatasetPtr
+    GenQuery(const int& nq);
+
+ protected:
+    int nb = 10000;
+    int nq = 10;
+    int dim = 64;
+    int k = 10;
+    std::vector<float> xb;
+    std::vector<float> xq;
+    std::vector<int64_t> ids;
+    knowhere::DatasetPtr base_dataset = nullptr;
+    knowhere::DatasetPtr query_dataset = nullptr;
+};
+
+extern void
+GenAll(const int64_t dim, const int64_t& nb, std::vector<float>& xb, std::vector<int64_t>& ids, const int64_t& nq,
+       std::vector<float>& xq);
+
+extern void
+GenAll(const int64_t& dim, const int64_t& nb, float* xb, int64_t* ids, const int64_t& nq, float* xq);
+
+extern void
+GenBase(const int64_t& dim, const int64_t& nb, float* xb, int64_t* ids);
+
+extern void
+InitLog();
+
+knowhere::DatasetPtr
+generate_dataset(int64_t nb, int64_t dim, float* xb, int64_t* ids);
+
+knowhere::DatasetPtr
+generate_query_dataset(int64_t nb, int64_t dim, float* xb);
+
+void
+AssertAnns(const knowhere::DatasetPtr& result, const int& nq, const int& k);
+
+void
+PrintResult(const knowhere::DatasetPtr& result, const int& nq, const int& k);
+
+struct FileIOWriter {
+    std::fstream fs;
+    std::string name;
+
+    explicit FileIOWriter(const std::string& fname);
+    ~FileIOWriter();
+    size_t
+    operator()(void* ptr, size_t size);
+};
+
+struct FileIOReader {
+    std::fstream fs;
+    std::string name;
+
+    explicit FileIOReader(const std::string& fname);
+    ~FileIOReader();
+    size_t
+    operator()(void* ptr, size_t size);
+};
diff --git a/core/src/main.cpp b/core/src/main.cpp
new file mode 100644
index 0000000000..d1c9ba6dfd
--- /dev/null
+++ b/core/src/main.cpp
@@ -0,0 +1,148 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 <getopt.h>
+#include <libgen.h>
+#include <signal.h>
+#include <unistd.h>
+#include <cstring>
+#include <string>
+
+#include "../version.h"
+#include "metrics/Metrics.h"
+#include "server/Server.h"
+#include "utils/CommonUtil.h"
+#include "utils/SignalUtil.h"
+#include "utils/easylogging++.h"
+
+INITIALIZE_EASYLOGGINGPP
+
+void
+print_help(const std::string& app_name) {
+    std::cout << std::endl << "Usage: " << app_name << " [OPTIONS]" << std::endl << std::endl;
+    std::cout << "  Options:" << std::endl;
+    std::cout << "   -h --help                 Print this help" << std::endl;
+    std::cout << "   -c --conf_file filename   Read configuration from the file" << std::endl;
+    std::cout << "   -d --daemon               Daemonize this application" << std::endl;
+    std::cout << "   -p --pid_file  filename   PID file used by daemonized app" << std::endl;
+    std::cout << std::endl;
+}
+
+void
+print_banner() {
+    std::cout << std::endl;
+    std::cout << "    __  _________ _   ____  ______    " << std::endl;
+    std::cout << "   /  |/  /  _/ /| | / / / / / __/    " << std::endl;
+    std::cout << "  / /|_/ // // /_| |/ / /_/ /\\ \\    " << std::endl;
+    std::cout << " /_/  /_/___/____/___/\\____/___/     " << std::endl;
+    std::cout << std::endl;
+    std::cout << "Welcome to Milvus!" << std::endl;
+    std::cout << "Milvus " << BUILD_TYPE << " version: v" << MILVUS_VERSION << ", built at " << BUILD_TIME << std::endl;
+    std::cout << std::endl;
+}
+
+int
+main(int argc, char* argv[]) {
+    print_banner();
+
+    static struct option long_options[] = {{"conf_file", required_argument, nullptr, 'c'},
+                                           {"log_conf_file", required_argument, nullptr, 'l'},
+                                           {"help", no_argument, nullptr, 'h'},
+                                           {"daemon", no_argument, nullptr, 'd'},
+                                           {"pid_file", required_argument, nullptr, 'p'},
+                                           {nullptr, 0, nullptr, 0}};
+
+    int option_index = 0;
+    int64_t start_daemonized = 0;
+
+    std::string config_filename, log_config_file;
+    std::string pid_filename;
+    std::string app_name = argv[0];
+
+    milvus::server::Server& server = milvus::server::Server::GetInstance();
+    milvus::Status s;
+
+    if (argc < 2) {
+        print_help(app_name);
+        goto FAIL;
+    }
+
+    int value;
+    while ((value = getopt_long(argc, argv, "c:l:p:dh", long_options, &option_index)) != -1) {
+        switch (value) {
+            case 'c': {
+                char* config_filename_ptr = strdup(optarg);
+                config_filename = config_filename_ptr;
+                free(config_filename_ptr);
+                std::cout << "Loading configuration from: " << config_filename << std::endl;
+                break;
+            }
+            case 'l': {
+                char* log_filename_ptr = strdup(optarg);
+                log_config_file = log_filename_ptr;
+                free(log_filename_ptr);
+                std::cout << "Initial log config from: " << log_config_file << std::endl;
+                break;
+            }
+            case 'p': {
+                char* pid_filename_ptr = strdup(optarg);
+                pid_filename = pid_filename_ptr;
+                free(pid_filename_ptr);
+                std::cout << pid_filename << std::endl;
+                break;
+            }
+            case 'd':
+                start_daemonized = 1;
+                break;
+            case 'h':
+                print_help(app_name);
+                return EXIT_SUCCESS;
+            case '?':
+                print_help(app_name);
+                return EXIT_FAILURE;
+            default:
+                print_help(app_name);
+                break;
+        }
+    }
+
+    /* Handle Signal */
+    signal(SIGHUP, milvus::server::SignalUtil::HandleSignal);
+    signal(SIGINT, milvus::server::SignalUtil::HandleSignal);
+    signal(SIGUSR1, milvus::server::SignalUtil::HandleSignal);
+    signal(SIGSEGV, milvus::server::SignalUtil::HandleSignal);
+    signal(SIGUSR2, milvus::server::SignalUtil::HandleSignal);
+    signal(SIGTERM, milvus::server::SignalUtil::HandleSignal);
+
+    server.Init(start_daemonized, pid_filename, config_filename, log_config_file);
+
+    s = server.Start();
+    if (s.ok()) {
+        std::cout << "Milvus server start successfully." << std::endl;
+    } else {
+        goto FAIL;
+    }
+
+    /* wait signal */
+    pause();
+
+    return EXIT_SUCCESS;
+
+FAIL:
+    std::cout << "Milvus server exit..." << std::endl;
+    return EXIT_FAILURE;
+}
diff --git a/core/src/metrics/MetricBase.h b/core/src/metrics/MetricBase.h
new file mode 100644
index 0000000000..eeca45e789
--- /dev/null
+++ b/core/src/metrics/MetricBase.h
@@ -0,0 +1,209 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "SystemInfo.h"
+#include "utils/Error.h"
+
+#include <string>
+
+namespace milvus {
+namespace server {
+class MetricsBase {
+ public:
+    static MetricsBase&
+    GetInstance() {
+        static MetricsBase instance;
+        return instance;
+    }
+
+    virtual ErrorCode
+    Init() {
+    }
+
+    virtual void
+    AddVectorsSuccessTotalIncrement(double value = 1) {
+    }
+
+    virtual void
+    AddVectorsFailTotalIncrement(double value = 1) {
+    }
+
+    virtual void
+    AddVectorsDurationHistogramOberve(double value) {
+    }
+
+    virtual void
+    RawFileSizeHistogramObserve(double value) {
+    }
+
+    virtual void
+    IndexFileSizeHistogramObserve(double value) {
+    }
+
+    virtual void
+    BuildIndexDurationSecondsHistogramObserve(double value) {
+    }
+
+    virtual void
+    CpuCacheUsageGaugeSet(double value) {
+    }
+
+    virtual void
+    GpuCacheUsageGaugeSet() {
+    }
+
+    virtual void
+    MetaAccessTotalIncrement(double value = 1) {
+    }
+
+    virtual void
+    MetaAccessDurationSecondsHistogramObserve(double value) {
+    }
+
+    virtual void
+    FaissDiskLoadDurationSecondsHistogramObserve(double value) {
+    }
+
+    virtual void
+    FaissDiskLoadSizeBytesHistogramObserve(double value) {
+    }
+
+    virtual void
+    CacheAccessTotalIncrement(double value = 1) {
+    }
+
+    virtual void
+    MemTableMergeDurationSecondsHistogramObserve(double value) {
+    }
+
+    virtual void
+    SearchIndexDataDurationSecondsHistogramObserve(double value) {
+    }
+
+    virtual void
+    SearchRawDataDurationSecondsHistogramObserve(double value) {
+    }
+
+    virtual void
+    IndexFileSizeTotalIncrement(double value = 1) {
+    }
+
+    virtual void
+    RawFileSizeTotalIncrement(double value = 1) {
+    }
+
+    virtual void
+    IndexFileSizeGaugeSet(double value) {
+    }
+
+    virtual void
+    RawFileSizeGaugeSet(double value) {
+    }
+
+    virtual void
+    FaissDiskLoadIOSpeedGaugeSet(double value) {
+    }
+
+    virtual void
+    QueryResponseSummaryObserve(double value) {
+    }
+
+    virtual void
+    DiskStoreIOSpeedGaugeSet(double value) {
+    }
+
+    virtual void
+    DataFileSizeGaugeSet(double value) {
+    }
+
+    virtual void
+    AddVectorsSuccessGaugeSet(double value) {
+    }
+
+    virtual void
+    AddVectorsFailGaugeSet(double value) {
+    }
+
+    virtual void
+    QueryVectorResponseSummaryObserve(double value, int count = 1) {
+    }
+
+    virtual void
+    QueryVectorResponsePerSecondGaugeSet(double value) {
+    }
+
+    virtual void
+    CPUUsagePercentSet() {
+    }
+
+    virtual void
+    RAMUsagePercentSet() {
+    }
+
+    virtual void
+    QueryResponsePerSecondGaugeSet(double value) {
+    }
+
+    virtual void
+    GPUPercentGaugeSet() {
+    }
+
+    virtual void
+    GPUMemoryUsageGaugeSet() {
+    }
+
+    virtual void
+    AddVectorsPerSecondGaugeSet(int num_vector, int dim, double time) {
+    }
+
+    virtual void
+    QueryIndexTypePerSecondSet(std::string type, double value) {
+    }
+
+    virtual void
+    ConnectionGaugeIncrement() {
+    }
+
+    virtual void
+    ConnectionGaugeDecrement() {
+    }
+
+    virtual void
+    KeepingAliveCounterIncrement(double value = 1) {
+    }
+
+    virtual void
+    OctetsSet() {
+    }
+
+    virtual void
+    CPUCoreUsagePercentSet() {
+    }
+
+    virtual void
+    GPUTemperature() {
+    }
+
+    virtual void
+    CPUTemperature() {
+    }
+};
+
+}  // namespace server
+}  // namespace milvus
diff --git a/core/src/metrics/Metrics.cpp b/core/src/metrics/Metrics.cpp
new file mode 100644
index 0000000000..51db5555b8
--- /dev/null
+++ b/core/src/metrics/Metrics.cpp
@@ -0,0 +1,48 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "metrics/Metrics.h"
+#include "PrometheusMetrics.h"
+#include "server/Config.h"
+
+#include <string>
+
+namespace milvus {
+namespace server {
+
+MetricsBase&
+Metrics::GetInstance() {
+    static MetricsBase& instance = CreateMetricsCollector();
+    return instance;
+}
+
+MetricsBase&
+Metrics::CreateMetricsCollector() {
+    Config& config = Config::GetInstance();
+    std::string collector_type_str;
+
+    config.GetMetricConfigCollector(collector_type_str);
+
+    if (collector_type_str == "prometheus") {
+        return PrometheusMetrics::GetInstance();
+    } else {
+        return MetricsBase::GetInstance();
+    }
+}
+
+}  // namespace server
+}  // namespace milvus
diff --git a/core/src/metrics/Metrics.h b/core/src/metrics/Metrics.h
new file mode 100644
index 0000000000..c207a50d9e
--- /dev/null
+++ b/core/src/metrics/Metrics.h
@@ -0,0 +1,256 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "MetricBase.h"
+#include "db/meta/MetaTypes.h"
+
+namespace milvus {
+namespace server {
+
+#define METRICS_NOW_TIME std::chrono::system_clock::now()
+#define METRICS_MICROSECONDS(a, b) (std::chrono::duration_cast<std::chrono::microseconds>(b - a)).count();
+
+enum class MetricCollectorType { INVALID, PROMETHEUS, ZABBIX };
+
+class Metrics {
+ public:
+    static MetricsBase&
+    GetInstance();
+
+ private:
+    static MetricsBase&
+    CreateMetricsCollector();
+};
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class CollectMetricsBase {
+ protected:
+    CollectMetricsBase() {
+        start_time_ = METRICS_NOW_TIME;
+    }
+
+    virtual ~CollectMetricsBase() = default;
+
+    double
+    TimeFromBegine() {
+        auto end_time = METRICS_NOW_TIME;
+        return METRICS_MICROSECONDS(start_time_, end_time);
+    }
+
+ protected:
+    using TIME_POINT = std::chrono::system_clock::time_point;
+    TIME_POINT start_time_;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class CollectInsertMetrics : CollectMetricsBase {
+ public:
+    CollectInsertMetrics(size_t n, Status& status) : n_(n), status_(status) {
+    }
+
+    ~CollectInsertMetrics() {
+        if (n_ > 0) {
+            auto total_time = TimeFromBegine();
+            double avg_time = total_time / n_;
+            for (int i = 0; i < n_; ++i) {
+                Metrics::GetInstance().AddVectorsDurationHistogramOberve(avg_time);
+            }
+
+            //    server::Metrics::GetInstance().add_vector_duration_seconds_quantiles().Observe((average_time));
+            if (status_.ok()) {
+                server::Metrics::GetInstance().AddVectorsSuccessTotalIncrement(n_);
+                server::Metrics::GetInstance().AddVectorsSuccessGaugeSet(n_);
+            } else {
+                server::Metrics::GetInstance().AddVectorsFailTotalIncrement(n_);
+                server::Metrics::GetInstance().AddVectorsFailGaugeSet(n_);
+            }
+        }
+    }
+
+ private:
+    size_t n_;
+    Status& status_;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class CollectQueryMetrics : CollectMetricsBase {
+ public:
+    explicit CollectQueryMetrics(size_t nq) : nq_(nq) {
+    }
+
+    ~CollectQueryMetrics() {
+        if (nq_ > 0) {
+            auto total_time = TimeFromBegine();
+            for (int i = 0; i < nq_; ++i) {
+                server::Metrics::GetInstance().QueryResponseSummaryObserve(total_time);
+            }
+            auto average_time = total_time / nq_;
+            server::Metrics::GetInstance().QueryVectorResponseSummaryObserve(average_time, nq_);
+            server::Metrics::GetInstance().QueryVectorResponsePerSecondGaugeSet(double(nq_) / total_time);
+        }
+    }
+
+ private:
+    size_t nq_;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class CollectMergeFilesMetrics : CollectMetricsBase {
+ public:
+    CollectMergeFilesMetrics() {
+    }
+
+    ~CollectMergeFilesMetrics() {
+        auto total_time = TimeFromBegine();
+        server::Metrics::GetInstance().MemTableMergeDurationSecondsHistogramObserve(total_time);
+    }
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class CollectBuildIndexMetrics : CollectMetricsBase {
+ public:
+    CollectBuildIndexMetrics() {
+    }
+
+    ~CollectBuildIndexMetrics() {
+        auto total_time = TimeFromBegine();
+        server::Metrics::GetInstance().BuildIndexDurationSecondsHistogramObserve(total_time);
+    }
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class CollectExecutionEngineMetrics : CollectMetricsBase {
+ public:
+    explicit CollectExecutionEngineMetrics(double physical_size) : physical_size_(physical_size) {
+    }
+
+    ~CollectExecutionEngineMetrics() {
+        auto total_time = TimeFromBegine();
+
+        server::Metrics::GetInstance().FaissDiskLoadDurationSecondsHistogramObserve(total_time);
+        server::Metrics::GetInstance().FaissDiskLoadSizeBytesHistogramObserve(physical_size_);
+        server::Metrics::GetInstance().FaissDiskLoadIOSpeedGaugeSet(physical_size_ / double(total_time));
+    }
+
+ private:
+    double physical_size_;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class CollectSerializeMetrics : CollectMetricsBase {
+ public:
+    explicit CollectSerializeMetrics(size_t size) : size_(size) {
+    }
+
+    ~CollectSerializeMetrics() {
+        auto total_time = TimeFromBegine();
+        server::Metrics::GetInstance().DiskStoreIOSpeedGaugeSet((double)size_ / total_time);
+    }
+
+ private:
+    size_t size_;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class CollectAddMetrics : CollectMetricsBase {
+ public:
+    CollectAddMetrics(size_t n, uint16_t dimension) : n_(n), dimension_(dimension) {
+    }
+
+    ~CollectAddMetrics() {
+        auto total_time = TimeFromBegine();
+        server::Metrics::GetInstance().AddVectorsPerSecondGaugeSet(static_cast<int>(n_), static_cast<int>(dimension_),
+                                                                   total_time);
+    }
+
+ private:
+    size_t n_;
+    uint16_t dimension_;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class CollectDurationMetrics : CollectMetricsBase {
+ public:
+    explicit CollectDurationMetrics(int index_type) : index_type_(index_type) {
+    }
+
+    ~CollectDurationMetrics() {
+        auto total_time = TimeFromBegine();
+        switch (index_type_) {
+            case engine::meta::TableFileSchema::RAW: {
+                server::Metrics::GetInstance().SearchRawDataDurationSecondsHistogramObserve(total_time);
+                break;
+            }
+            case engine::meta::TableFileSchema::TO_INDEX: {
+                server::Metrics::GetInstance().SearchRawDataDurationSecondsHistogramObserve(total_time);
+                break;
+            }
+            default: {
+                server::Metrics::GetInstance().SearchIndexDataDurationSecondsHistogramObserve(total_time);
+                break;
+            }
+        }
+    }
+
+ private:
+    int index_type_;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class CollectSearchTaskMetrics : CollectMetricsBase {
+ public:
+    explicit CollectSearchTaskMetrics(int index_type) : index_type_(index_type) {
+    }
+
+    ~CollectSearchTaskMetrics() {
+        auto total_time = TimeFromBegine();
+        switch (index_type_) {
+            case engine::meta::TableFileSchema::RAW: {
+                server::Metrics::GetInstance().SearchRawDataDurationSecondsHistogramObserve(total_time);
+                break;
+            }
+            case engine::meta::TableFileSchema::TO_INDEX: {
+                server::Metrics::GetInstance().SearchRawDataDurationSecondsHistogramObserve(total_time);
+                break;
+            }
+            default: {
+                server::Metrics::GetInstance().SearchIndexDataDurationSecondsHistogramObserve(total_time);
+                break;
+            }
+        }
+    }
+
+ private:
+    int index_type_;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class MetricCollector : CollectMetricsBase {
+ public:
+    MetricCollector() {
+        server::Metrics::GetInstance().MetaAccessTotalIncrement();
+    }
+
+    ~MetricCollector() {
+        auto total_time = TimeFromBegine();
+        server::Metrics::GetInstance().MetaAccessDurationSecondsHistogramObserve(total_time);
+    }
+};
+
+}  // namespace server
+}  // namespace milvus
diff --git a/core/src/metrics/PrometheusMetrics.cpp b/core/src/metrics/PrometheusMetrics.cpp
new file mode 100644
index 0000000000..770b34dc47
--- /dev/null
+++ b/core/src/metrics/PrometheusMetrics.cpp
@@ -0,0 +1,252 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "metrics/PrometheusMetrics.h"
+#include "SystemInfo.h"
+#include "cache/GpuCacheMgr.h"
+#include "server/Config.h"
+#include "utils/Log.h"
+
+#include <string>
+#include <utility>
+
+namespace milvus {
+namespace server {
+
+ErrorCode
+PrometheusMetrics::Init() {
+    try {
+        Config& config = Config::GetInstance();
+        Status s = config.GetMetricConfigEnableMonitor(startup_);
+        if (!s.ok()) {
+            return s.code();
+        }
+        if (!startup_) {
+            return SERVER_SUCCESS;
+        }
+
+        // Following should be read from config file.
+        std::string bind_address;
+        s = config.GetMetricConfigPrometheusPort(bind_address);
+        if (!s.ok()) {
+            return s.code();
+        }
+
+        const std::string uri = std::string("/metrics");
+        const std::size_t num_threads = 2;
+
+        // Init Exposer
+        exposer_ptr_ = std::make_shared<prometheus::Exposer>(bind_address, uri, num_threads);
+
+        // Exposer Registry
+        exposer_ptr_->RegisterCollectable(registry_);
+    } catch (std::exception& ex) {
+        SERVER_LOG_ERROR << "Failed to connect prometheus server: " << std::string(ex.what());
+        return SERVER_UNEXPECTED_ERROR;
+    }
+
+    return SERVER_SUCCESS;
+}
+
+void
+PrometheusMetrics::CPUUsagePercentSet() {
+    if (!startup_) {
+        return;
+    }
+
+    double usage_percent = server::SystemInfo::GetInstance().CPUPercent();
+    CPU_usage_percent_.Set(usage_percent);
+}
+
+void
+PrometheusMetrics::RAMUsagePercentSet() {
+    if (!startup_) {
+        return;
+    }
+
+    double usage_percent = server::SystemInfo::GetInstance().MemoryPercent();
+    RAM_usage_percent_.Set(usage_percent);
+}
+
+void
+PrometheusMetrics::GPUPercentGaugeSet() {
+    if (!startup_) {
+        return;
+    }
+
+    int numDevice = server::SystemInfo::GetInstance().num_device();
+    std::vector<uint64_t> used_total = server::SystemInfo::GetInstance().GPUMemoryTotal();
+    std::vector<uint64_t> used_memory = server::SystemInfo::GetInstance().GPUMemoryUsed();
+
+    for (int i = 0; i < numDevice; ++i) {
+        prometheus::Gauge& GPU_percent = GPU_percent_.Add({{"DeviceNum", std::to_string(i)}});
+        double percent = (double)used_memory[i] / (double)used_total[i];
+        GPU_percent.Set(percent * 100);
+    }
+}
+
+void
+PrometheusMetrics::GPUMemoryUsageGaugeSet() {
+    if (!startup_) {
+        return;
+    }
+
+    std::vector<uint64_t> values = server::SystemInfo::GetInstance().GPUMemoryUsed();
+    constexpr uint64_t MtoB = 1024 * 1024;
+    int numDevice = server::SystemInfo::GetInstance().num_device();
+
+    for (int i = 0; i < numDevice; ++i) {
+        prometheus::Gauge& GPU_memory = GPU_memory_usage_.Add({{"DeviceNum", std::to_string(i)}});
+        GPU_memory.Set(values[i] / MtoB);
+    }
+}
+
+void
+PrometheusMetrics::AddVectorsPerSecondGaugeSet(int num_vector, int dim, double time) {
+    // MB/s
+    if (!startup_) {
+        return;
+    }
+
+    int64_t MtoB = 1024 * 1024;
+    int64_t size = num_vector * dim * 4;
+    add_vectors_per_second_gauge_.Set(size / time / MtoB);
+}
+
+void
+PrometheusMetrics::QueryIndexTypePerSecondSet(std::string type, double value) {
+    if (!startup_) {
+        return;
+    }
+
+    if (type == "IVF") {
+        query_index_IVF_type_per_second_gauge_.Set(value);
+    } else if (type == "IDMap") {
+        query_index_IDMAP_type_per_second_gauge_.Set(value);
+    }
+}
+
+void
+PrometheusMetrics::ConnectionGaugeIncrement() {
+    if (!startup_) {
+        return;
+    }
+
+    connection_gauge_.Increment();
+}
+
+void
+PrometheusMetrics::ConnectionGaugeDecrement() {
+    if (!startup_) {
+        return;
+    }
+
+    connection_gauge_.Decrement();
+}
+
+void
+PrometheusMetrics::OctetsSet() {
+    if (!startup_) {
+        return;
+    }
+
+    // get old stats and reset them
+    uint64_t old_inoctets = SystemInfo::GetInstance().get_inoctets();
+    uint64_t old_outoctets = SystemInfo::GetInstance().get_octets();
+    auto old_time = SystemInfo::GetInstance().get_nettime();
+    std::pair<uint64_t, uint64_t> in_and_out_octets = SystemInfo::GetInstance().Octets();
+    SystemInfo::GetInstance().set_inoctets(in_and_out_octets.first);
+    SystemInfo::GetInstance().set_outoctets(in_and_out_octets.second);
+    SystemInfo::GetInstance().set_nettime();
+
+    //
+    constexpr double micro_to_second = 1e-6;
+    auto now_time = std::chrono::system_clock::now();
+    auto total_microsecond = METRICS_MICROSECONDS(old_time, now_time);
+    auto total_second = total_microsecond * micro_to_second;
+    if (total_second == 0) {
+        return;
+    }
+
+    inoctets_gauge_.Set((in_and_out_octets.first - old_inoctets) / total_second);
+    outoctets_gauge_.Set((in_and_out_octets.second - old_outoctets) / total_second);
+}
+
+void
+PrometheusMetrics::CPUCoreUsagePercentSet() {
+    if (!startup_) {
+        return;
+    }
+
+    std::vector<double> cpu_core_percent = server::SystemInfo::GetInstance().CPUCorePercent();
+
+    for (int i = 0; i < cpu_core_percent.size(); ++i) {
+        prometheus::Gauge& core_percent = CPU_.Add({{"CPU", std::to_string(i)}});
+        core_percent.Set(cpu_core_percent[i]);
+    }
+}
+
+void
+PrometheusMetrics::GPUTemperature() {
+    if (!startup_) {
+        return;
+    }
+
+    std::vector<uint64_t> GPU_temperatures = server::SystemInfo::GetInstance().GPUTemperature();
+
+    for (int i = 0; i < GPU_temperatures.size(); ++i) {
+        prometheus::Gauge& gpu_temp = GPU_temperature_.Add({{"GPU", std::to_string(i)}});
+        gpu_temp.Set(GPU_temperatures[i]);
+    }
+}
+
+void
+PrometheusMetrics::CPUTemperature() {
+    if (!startup_) {
+        return;
+    }
+
+    std::vector<float> CPU_temperatures = server::SystemInfo::GetInstance().CPUTemperature();
+
+    float avg_cpu_temp = 0;
+    for (int i = 0; i < CPU_temperatures.size(); ++i) {
+        avg_cpu_temp += CPU_temperatures[i];
+    }
+    avg_cpu_temp /= CPU_temperatures.size();
+
+    prometheus::Gauge& cpu_temp = CPU_temperature_.Add({{"CPU", std::to_string(0)}});
+    cpu_temp.Set(avg_cpu_temp);
+
+    //    for (int i = 0; i < CPU_temperatures.size(); ++i) {
+    //        prometheus::Gauge& cpu_temp = CPU_temperature_.Add({{"CPU", std::to_string(i)}});
+    //        cpu_temp.Set(CPU_temperatures[i]);
+    //    }
+}
+
+void
+PrometheusMetrics::GpuCacheUsageGaugeSet() {
+    //    std::vector<uint64_t > gpu_ids = {0};
+    //    for(auto i = 0; i < gpu_ids.size(); ++i) {
+    //        uint64_t cache_usage = cache::GpuCacheMgr::GetInstance(gpu_ids[i])->CacheUsage();
+    //        uint64_t cache_capacity = cache::GpuCacheMgr::GetInstance(gpu_ids[i])->CacheCapacity();
+    //        prometheus::Gauge &gpu_cache = gpu_cache_usage_.Add({{"GPU_Cache", std::to_string(i)}});
+    //        gpu_cache.Set(cache_usage * 100 / cache_capacity);
+    //    }
+}
+
+}  // namespace server
+}  // namespace milvus
diff --git a/core/src/metrics/PrometheusMetrics.h b/core/src/metrics/PrometheusMetrics.h
new file mode 100644
index 0000000000..ef60f9a231
--- /dev/null
+++ b/core/src/metrics/PrometheusMetrics.h
@@ -0,0 +1,655 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <prometheus/exposer.h>
+#include <prometheus/registry.h>
+#include <iostream>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "MetricBase.h"
+#include "utils/Error.h"
+
+#define METRICS_NOW_TIME std::chrono::system_clock::now()
+//#define server::Metrics::GetInstance() server::GetInstance()
+#define METRICS_MICROSECONDS(a, b) (std::chrono::duration_cast<std::chrono::microseconds>(b - a)).count();
+
+namespace milvus {
+namespace server {
+
+class PrometheusMetrics : public MetricsBase {
+ public:
+    static PrometheusMetrics&
+    GetInstance() {
+        static PrometheusMetrics instance;
+        return instance;
+    }
+
+    ErrorCode
+    Init();
+
+ private:
+    std::shared_ptr<prometheus::Exposer> exposer_ptr_;
+    std::shared_ptr<prometheus::Registry> registry_ = std::make_shared<prometheus::Registry>();
+    bool startup_ = false;
+
+ public:
+    void
+    SetStartup(bool startup) {
+        startup_ = startup;
+    }
+
+    void
+    AddVectorsSuccessTotalIncrement(double value = 1.0) override {
+        if (startup_) {
+            add_vectors_success_total_.Increment(value);
+        }
+    }
+
+    void
+    AddVectorsFailTotalIncrement(double value = 1.0) override {
+        if (startup_) {
+            add_vectors_fail_total_.Increment(value);
+        }
+    }
+
+    void
+    AddVectorsDurationHistogramOberve(double value) override {
+        if (startup_) {
+            add_vectors_duration_histogram_.Observe(value);
+        }
+    }
+
+    void
+    RawFileSizeHistogramObserve(double value) override {
+        if (startup_) {
+            raw_files_size_histogram_.Observe(value);
+        }
+    }
+
+    void
+    IndexFileSizeHistogramObserve(double value) override {
+        if (startup_) {
+            index_files_size_histogram_.Observe(value);
+        }
+    }
+
+    void
+    BuildIndexDurationSecondsHistogramObserve(double value) override {
+        if (startup_) {
+            build_index_duration_seconds_histogram_.Observe(value);
+        }
+    }
+
+    void
+    CpuCacheUsageGaugeSet(double value) override {
+        if (startup_) {
+            cpu_cache_usage_gauge_.Set(value);
+        }
+    }
+
+    void
+    GpuCacheUsageGaugeSet() override;
+
+    void
+    MetaAccessTotalIncrement(double value = 1) override {
+        if (startup_) {
+            meta_access_total_.Increment(value);
+        }
+    }
+
+    void
+    MetaAccessDurationSecondsHistogramObserve(double value) override {
+        if (startup_) {
+            meta_access_duration_seconds_histogram_.Observe(value);
+        }
+    }
+
+    void
+    FaissDiskLoadDurationSecondsHistogramObserve(double value) override {
+        if (startup_) {
+            faiss_disk_load_duration_seconds_histogram_.Observe(value);
+        }
+    }
+
+    void
+    FaissDiskLoadSizeBytesHistogramObserve(double value) override {
+        if (startup_) {
+            faiss_disk_load_size_bytes_histogram_.Observe(value);
+        }
+    }
+
+    void
+    FaissDiskLoadIOSpeedGaugeSet(double value) override {
+        if (startup_) {
+            faiss_disk_load_IO_speed_gauge_.Set(value);
+        }
+    }
+
+    void
+    CacheAccessTotalIncrement(double value = 1) override {
+        if (startup_) {
+            cache_access_total_.Increment(value);
+        }
+    }
+
+    void
+    MemTableMergeDurationSecondsHistogramObserve(double value) override {
+        if (startup_) {
+            mem_table_merge_duration_seconds_histogram_.Observe(value);
+        }
+    }
+
+    void
+    SearchIndexDataDurationSecondsHistogramObserve(double value) override {
+        if (startup_) {
+            search_index_data_duration_seconds_histogram_.Observe(value);
+        }
+    }
+
+    void
+    SearchRawDataDurationSecondsHistogramObserve(double value) override {
+        if (startup_) {
+            search_raw_data_duration_seconds_histogram_.Observe(value);
+        }
+    }
+
+    void
+    IndexFileSizeTotalIncrement(double value = 1) override {
+        if (startup_) {
+            index_file_size_total_.Increment(value);
+        }
+    }
+
+    void
+    RawFileSizeTotalIncrement(double value = 1) override {
+        if (startup_) {
+            raw_file_size_total_.Increment(value);
+        }
+    }
+
+    void
+    IndexFileSizeGaugeSet(double value) override {
+        if (startup_) {
+            index_file_size_gauge_.Set(value);
+        }
+    }
+
+    void
+    RawFileSizeGaugeSet(double value) override {
+        if (startup_) {
+            raw_file_size_gauge_.Set(value);
+        }
+    }
+
+    void
+    QueryResponseSummaryObserve(double value) override {
+        if (startup_) {
+            query_response_summary_.Observe(value);
+        }
+    }
+
+    void
+    DiskStoreIOSpeedGaugeSet(double value) override {
+        if (startup_) {
+            disk_store_IO_speed_gauge_.Set(value);
+        }
+    }
+
+    void
+    DataFileSizeGaugeSet(double value) override {
+        if (startup_) {
+            data_file_size_gauge_.Set(value);
+        }
+    }
+
+    void
+    AddVectorsSuccessGaugeSet(double value) override {
+        if (startup_) {
+            add_vectors_success_gauge_.Set(value);
+        }
+    }
+
+    void
+    AddVectorsFailGaugeSet(double value) override {
+        if (startup_) {
+            add_vectors_fail_gauge_.Set(value);
+        }
+    }
+
+    void
+    QueryVectorResponseSummaryObserve(double value, int count = 1) override {
+        if (startup_) {
+            for (int i = 0; i < count; ++i) {
+                query_vector_response_summary_.Observe(value);
+            }
+        }
+    }
+
+    void
+    QueryVectorResponsePerSecondGaugeSet(double value) override {
+        if (startup_) {
+            query_vector_response_per_second_gauge_.Set(value);
+        }
+    }
+
+    void
+    CPUUsagePercentSet() override;
+    void
+    CPUCoreUsagePercentSet() override;
+
+    void
+    RAMUsagePercentSet() override;
+
+    void
+    QueryResponsePerSecondGaugeSet(double value) override {
+        if (startup_) {
+            query_response_per_second_gauge.Set(value);
+        }
+    }
+
+    void
+    GPUPercentGaugeSet() override;
+    void
+    GPUMemoryUsageGaugeSet() override;
+    void
+    AddVectorsPerSecondGaugeSet(int num_vector, int dim, double time) override;
+    void
+    QueryIndexTypePerSecondSet(std::string type, double value) override;
+    void
+    ConnectionGaugeIncrement() override;
+    void
+    ConnectionGaugeDecrement() override;
+
+    void
+    KeepingAliveCounterIncrement(double value = 1) override {
+        if (startup_) {
+            keeping_alive_counter_.Increment(value);
+        }
+    }
+
+    void
+    OctetsSet() override;
+
+    void
+    GPUTemperature() override;
+    void
+    CPUTemperature() override;
+
+    std::shared_ptr<prometheus::Exposer>&
+    exposer_ptr() {
+        return exposer_ptr_;
+    }
+
+    //    prometheus::Exposer& exposer() { return exposer_;}
+    std::shared_ptr<prometheus::Registry>&
+    registry_ptr() {
+        return registry_;
+    }
+
+    // .....
+ private:
+    ////all from db_connection.cpp
+    //    prometheus::Family<prometheus::Counter> &connect_request_ = prometheus::BuildCounter()
+    //        .Name("connection_total")
+    //        .Help("total number of connection has been made")
+    //        .Register(*registry_);
+    //    prometheus::Counter &connection_total_ = connect_request_.Add({});
+
+    ////all from DBImpl.cpp
+    using BucketBoundaries = std::vector<double>;
+    // record add_group request
+    prometheus::Family<prometheus::Counter>& add_group_request_ = prometheus::BuildCounter()
+                                                                      .Name("add_group_request_total")
+                                                                      .Help("the number of add_group request")
+                                                                      .Register(*registry_);
+
+    prometheus::Counter& add_group_success_total_ = add_group_request_.Add({{"outcome", "success"}});
+    prometheus::Counter& add_group_fail_total_ = add_group_request_.Add({{"outcome", "fail"}});
+
+    // record get_group request
+    prometheus::Family<prometheus::Counter>& get_group_request_ = prometheus::BuildCounter()
+                                                                      .Name("get_group_request_total")
+                                                                      .Help("the number of get_group request")
+                                                                      .Register(*registry_);
+
+    prometheus::Counter& get_group_success_total_ = get_group_request_.Add({{"outcome", "success"}});
+    prometheus::Counter& get_group_fail_total_ = get_group_request_.Add({{"outcome", "fail"}});
+
+    // record has_group request
+    prometheus::Family<prometheus::Counter>& has_group_request_ = prometheus::BuildCounter()
+                                                                      .Name("has_group_request_total")
+                                                                      .Help("the number of has_group request")
+                                                                      .Register(*registry_);
+
+    prometheus::Counter& has_group_success_total_ = has_group_request_.Add({{"outcome", "success"}});
+    prometheus::Counter& has_group_fail_total_ = has_group_request_.Add({{"outcome", "fail"}});
+
+    // record get_group_files
+    prometheus::Family<prometheus::Counter>& get_group_files_request_ =
+        prometheus::BuildCounter()
+            .Name("get_group_files_request_total")
+            .Help("the number of get_group_files request")
+            .Register(*registry_);
+
+    prometheus::Counter& get_group_files_success_total_ = get_group_files_request_.Add({{"outcome", "success"}});
+    prometheus::Counter& get_group_files_fail_total_ = get_group_files_request_.Add({{"outcome", "fail"}});
+
+    // record add_vectors count and average time
+    // need to be considered
+    prometheus::Family<prometheus::Counter>& add_vectors_request_ = prometheus::BuildCounter()
+                                                                        .Name("add_vectors_request_total")
+                                                                        .Help("the number of vectors added")
+                                                                        .Register(*registry_);
+    prometheus::Counter& add_vectors_success_total_ = add_vectors_request_.Add({{"outcome", "success"}});
+    prometheus::Counter& add_vectors_fail_total_ = add_vectors_request_.Add({{"outcome", "fail"}});
+
+    prometheus::Family<prometheus::Histogram>& add_vectors_duration_seconds_ =
+        prometheus::BuildHistogram()
+            .Name("add_vector_duration_microseconds")
+            .Help("average time of adding every vector")
+            .Register(*registry_);
+    prometheus::Histogram& add_vectors_duration_histogram_ =
+        add_vectors_duration_seconds_.Add({}, BucketBoundaries{0, 0.01, 0.02, 0.03, 0.04, 0.05, 0.08, 0.1, 0.5, 1});
+
+    // record search count and average time
+    prometheus::Family<prometheus::Counter>& search_request_ = prometheus::BuildCounter()
+                                                                   .Name("search_request_total")
+                                                                   .Help("the number of search request")
+                                                                   .Register(*registry_);
+    prometheus::Counter& search_success_total_ = search_request_.Add({{"outcome", "success"}});
+    prometheus::Counter& search_fail_total_ = search_request_.Add({{"outcome", "fail"}});
+
+    prometheus::Family<prometheus::Histogram>& search_request_duration_seconds_ =
+        prometheus::BuildHistogram()
+            .Name("search_request_duration_microsecond")
+            .Help("histogram of processing time for each search")
+            .Register(*registry_);
+    prometheus::Histogram& search_duration_histogram_ =
+        search_request_duration_seconds_.Add({}, BucketBoundaries{0.1, 1.0, 10.0});
+
+    // record raw_files size histogram
+    prometheus::Family<prometheus::Histogram>& raw_files_size_ = prometheus::BuildHistogram()
+                                                                     .Name("search_raw_files_bytes")
+                                                                     .Help("histogram of raw files size by bytes")
+                                                                     .Register(*registry_);
+    prometheus::Histogram& raw_files_size_histogram_ =
+        raw_files_size_.Add({}, BucketBoundaries{1e9, 2e9, 4e9, 6e9, 8e9, 1e10});
+
+    // record index_files size histogram
+    prometheus::Family<prometheus::Histogram>& index_files_size_ = prometheus::BuildHistogram()
+                                                                       .Name("search_index_files_bytes")
+                                                                       .Help("histogram of index files size by bytes")
+                                                                       .Register(*registry_);
+    prometheus::Histogram& index_files_size_histogram_ =
+        index_files_size_.Add({}, BucketBoundaries{1e9, 2e9, 4e9, 6e9, 8e9, 1e10});
+
+    // record index and raw files size counter
+    prometheus::Family<prometheus::Counter>& file_size_total_ = prometheus::BuildCounter()
+                                                                    .Name("search_file_size_total")
+                                                                    .Help("searched index and raw file size")
+                                                                    .Register(*registry_);
+    prometheus::Counter& index_file_size_total_ = file_size_total_.Add({{"type", "index"}});
+    prometheus::Counter& raw_file_size_total_ = file_size_total_.Add({{"type", "raw"}});
+
+    // record index and raw files size counter
+    prometheus::Family<prometheus::Gauge>& file_size_gauge_ = prometheus::BuildGauge()
+                                                                  .Name("search_file_size_gauge")
+                                                                  .Help("searched current index and raw file size")
+                                                                  .Register(*registry_);
+    prometheus::Gauge& index_file_size_gauge_ = file_size_gauge_.Add({{"type", "index"}});
+    prometheus::Gauge& raw_file_size_gauge_ = file_size_gauge_.Add({{"type", "raw"}});
+
+    // record processing time for building index
+    prometheus::Family<prometheus::Histogram>& build_index_duration_seconds_ =
+        prometheus::BuildHistogram()
+            .Name("build_index_duration_microseconds")
+            .Help("histogram of processing time for building index")
+            .Register(*registry_);
+    prometheus::Histogram& build_index_duration_seconds_histogram_ =
+        build_index_duration_seconds_.Add({}, BucketBoundaries{5e5, 2e6, 4e6, 6e6, 8e6, 1e7});
+
+    // record processing time for all building index
+    prometheus::Family<prometheus::Histogram>& all_build_index_duration_seconds_ =
+        prometheus::BuildHistogram()
+            .Name("all_build_index_duration_microseconds")
+            .Help("histogram of processing time for building index")
+            .Register(*registry_);
+    prometheus::Histogram& all_build_index_duration_seconds_histogram_ =
+        all_build_index_duration_seconds_.Add({}, BucketBoundaries{2e6, 4e6, 6e6, 8e6, 1e7});
+
+    // record duration of merging mem table
+    prometheus::Family<prometheus::Histogram>& mem_table_merge_duration_seconds_ =
+        prometheus::BuildHistogram()
+            .Name("mem_table_merge_duration_microseconds")
+            .Help("histogram of processing time for merging mem tables")
+            .Register(*registry_);
+    prometheus::Histogram& mem_table_merge_duration_seconds_histogram_ =
+        mem_table_merge_duration_seconds_.Add({}, BucketBoundaries{5e4, 1e5, 2e5, 4e5, 6e5, 8e5, 1e6});
+
+    // record search index and raw data duration
+    prometheus::Family<prometheus::Histogram>& search_data_duration_seconds_ =
+        prometheus::BuildHistogram()
+            .Name("search_data_duration_microseconds")
+            .Help("histograms of processing time for search index and raw data")
+            .Register(*registry_);
+    prometheus::Histogram& search_index_data_duration_seconds_histogram_ =
+        search_data_duration_seconds_.Add({{"type", "index"}}, BucketBoundaries{1e5, 2e5, 4e5, 6e5, 8e5});
+    prometheus::Histogram& search_raw_data_duration_seconds_histogram_ =
+        search_data_duration_seconds_.Add({{"type", "raw"}}, BucketBoundaries{1e5, 2e5, 4e5, 6e5, 8e5});
+
+    ////all form Cache.cpp
+    // record cache usage, when insert/erase/clear/free
+
+    ////all from Meta.cpp
+    // record meta visit count and time
+    //    prometheus::Family<prometheus::Counter> &meta_visit_ = prometheus::BuildCounter()
+    //        .Name("meta_visit_total")
+    //        .Help("the number of accessing Meta")
+    //        .Register(*registry_);
+    //    prometheus::Counter &meta_visit_total_ = meta_visit_.Add({{}});
+    //
+    //    prometheus::Family<prometheus::Histogram> &meta_visit_duration_seconds_ = prometheus::BuildHistogram()
+    //        .Name("meta_visit_duration_seconds")
+    //        .Help("histogram of processing time to get data from mata")
+    //        .Register(*registry_);
+    //    prometheus::Histogram &meta_visit_duration_seconds_histogram_ =
+    //          meta_visit_duration_seconds_.Add({{}}, BucketBoundaries{0.1, 1.0, 10.0});
+
+    ////all from MemManager.cpp
+    // record memory usage percent
+    prometheus::Family<prometheus::Gauge>& mem_usage_percent_ =
+        prometheus::BuildGauge().Name("memory_usage_percent").Help("memory usage percent").Register(*registry_);
+    prometheus::Gauge& mem_usage_percent_gauge_ = mem_usage_percent_.Add({});
+
+    // record memory usage toal
+    prometheus::Family<prometheus::Gauge>& mem_usage_total_ =
+        prometheus::BuildGauge().Name("memory_usage_total").Help("memory usage total").Register(*registry_);
+    prometheus::Gauge& mem_usage_total_gauge_ = mem_usage_total_.Add({});
+
+    ////all from DBMetaImpl.cpp
+    // record meta access count
+    prometheus::Family<prometheus::Counter>& meta_access_ =
+        prometheus::BuildCounter().Name("meta_access_total").Help("the number of meta accessing").Register(*registry_);
+    prometheus::Counter& meta_access_total_ = meta_access_.Add({});
+
+    // record meta access duration
+    prometheus::Family<prometheus::Histogram>& meta_access_duration_seconds_ =
+        prometheus::BuildHistogram()
+            .Name("meta_access_duration_microseconds")
+            .Help("histogram of processing time for accessing mata")
+            .Register(*registry_);
+    prometheus::Histogram& meta_access_duration_seconds_histogram_ =
+        meta_access_duration_seconds_.Add({}, BucketBoundaries{100, 300, 500, 700, 900, 2000, 4000, 6000, 8000, 20000});
+
+    ////all from FaissExecutionEngine.cpp
+    // record data loading from disk count, size, duration, IO speed
+    prometheus::Family<prometheus::Histogram>& disk_load_duration_second_ =
+        prometheus::BuildHistogram()
+            .Name("disk_load_duration_microseconds")
+            .Help("Histogram of processing time for loading data from disk")
+            .Register(*registry_);
+    prometheus::Histogram& faiss_disk_load_duration_seconds_histogram_ =
+        disk_load_duration_second_.Add({{"DB", "Faiss"}}, BucketBoundaries{2e5, 4e5, 6e5, 8e5});
+
+    prometheus::Family<prometheus::Histogram>& disk_load_size_bytes_ =
+        prometheus::BuildHistogram()
+            .Name("disk_load_size_bytes")
+            .Help("Histogram of data size by bytes for loading data from disk")
+            .Register(*registry_);
+    prometheus::Histogram& faiss_disk_load_size_bytes_histogram_ =
+        disk_load_size_bytes_.Add({{"DB", "Faiss"}}, BucketBoundaries{1e9, 2e9, 4e9, 6e9, 8e9});
+
+    //    prometheus::Family<prometheus::Histogram> &disk_load_IO_speed_ = prometheus::BuildHistogram()
+    //        .Name("disk_load_IO_speed_byte_per_sec")
+    //        .Help("Histogram of IO speed for loading data from disk")
+    //        .Register(*registry_);
+    //    prometheus::Histogram &faiss_disk_load_IO_speed_histogram_ =
+    //          disk_load_IO_speed_.Add({{"DB","Faiss"}},BucketBoundaries{1000, 2000, 3000, 4000, 6000, 8000});
+
+    prometheus::Family<prometheus::Gauge>& faiss_disk_load_IO_speed_ = prometheus::BuildGauge()
+                                                                           .Name("disk_load_IO_speed_byte_per_microsec")
+                                                                           .Help("disk IO speed ")
+                                                                           .Register(*registry_);
+    prometheus::Gauge& faiss_disk_load_IO_speed_gauge_ = faiss_disk_load_IO_speed_.Add({{"DB", "Faiss"}});
+
+    ////all from CacheMgr.cpp
+    // record cache access count
+    prometheus::Family<prometheus::Counter>& cache_access_ = prometheus::BuildCounter()
+                                                                 .Name("cache_access_total")
+                                                                 .Help("the count of accessing cache ")
+                                                                 .Register(*registry_);
+    prometheus::Counter& cache_access_total_ = cache_access_.Add({});
+
+    // record CPU cache usage and %
+    prometheus::Family<prometheus::Gauge>& cpu_cache_usage_ =
+        prometheus::BuildGauge().Name("cache_usage_bytes").Help("current cache usage by bytes").Register(*registry_);
+    prometheus::Gauge& cpu_cache_usage_gauge_ = cpu_cache_usage_.Add({});
+
+    // record GPU cache usage and %
+    prometheus::Family<prometheus::Gauge>& gpu_cache_usage_ = prometheus::BuildGauge()
+                                                                  .Name("gpu_cache_usage_bytes")
+                                                                  .Help("current gpu cache usage by bytes")
+                                                                  .Register(*registry_);
+
+    // record query response
+    using Quantiles = std::vector<prometheus::detail::CKMSQuantiles::Quantile>;
+    prometheus::Family<prometheus::Summary>& query_response_ =
+        prometheus::BuildSummary().Name("query_response_summary").Help("query response summary").Register(*registry_);
+    prometheus::Summary& query_response_summary_ =
+        query_response_.Add({}, Quantiles{{0.95, 0.00}, {0.9, 0.05}, {0.8, 0.1}});
+
+    prometheus::Family<prometheus::Summary>& query_vector_response_ = prometheus::BuildSummary()
+                                                                          .Name("query_vector_response_summary")
+                                                                          .Help("query each vector response summary")
+                                                                          .Register(*registry_);
+    prometheus::Summary& query_vector_response_summary_ =
+        query_vector_response_.Add({}, Quantiles{{0.95, 0.00}, {0.9, 0.05}, {0.8, 0.1}});
+
+    prometheus::Family<prometheus::Gauge>& query_vector_response_per_second_ =
+        prometheus::BuildGauge()
+            .Name("query_vector_response_per_microsecond")
+            .Help("the number of vectors can be queried every second ")
+            .Register(*registry_);
+    prometheus::Gauge& query_vector_response_per_second_gauge_ = query_vector_response_per_second_.Add({});
+
+    prometheus::Family<prometheus::Gauge>& query_response_per_second_ =
+        prometheus::BuildGauge()
+            .Name("query_response_per_microsecond")
+            .Help("the number of queries can be processed every microsecond")
+            .Register(*registry_);
+    prometheus::Gauge& query_response_per_second_gauge = query_response_per_second_.Add({});
+
+    prometheus::Family<prometheus::Gauge>& disk_store_IO_speed_ =
+        prometheus::BuildGauge()
+            .Name("disk_store_IO_speed_bytes_per_microseconds")
+            .Help("disk_store_IO_speed")
+            .Register(*registry_);
+    prometheus::Gauge& disk_store_IO_speed_gauge_ = disk_store_IO_speed_.Add({});
+
+    prometheus::Family<prometheus::Gauge>& data_file_size_ =
+        prometheus::BuildGauge().Name("data_file_size_bytes").Help("data file size by bytes").Register(*registry_);
+    prometheus::Gauge& data_file_size_gauge_ = data_file_size_.Add({});
+
+    prometheus::Family<prometheus::Gauge>& add_vectors_ =
+        prometheus::BuildGauge().Name("add_vectors").Help("current added vectors").Register(*registry_);
+    prometheus::Gauge& add_vectors_success_gauge_ = add_vectors_.Add({{"outcome", "success"}});
+    prometheus::Gauge& add_vectors_fail_gauge_ = add_vectors_.Add({{"outcome", "fail"}});
+
+    prometheus::Family<prometheus::Gauge>& add_vectors_per_second_ = prometheus::BuildGauge()
+                                                                         .Name("add_vectors_throughput_per_microsecond")
+                                                                         .Help("add vectors throughput per microsecond")
+                                                                         .Register(*registry_);
+    prometheus::Gauge& add_vectors_per_second_gauge_ = add_vectors_per_second_.Add({});
+
+    prometheus::Family<prometheus::Gauge>& CPU_ = prometheus::BuildGauge()
+                                                      .Name("CPU_usage_percent")
+                                                      .Help("CPU usage percent by this this process")
+                                                      .Register(*registry_);
+    prometheus::Gauge& CPU_usage_percent_ = CPU_.Add({{"CPU", "avg"}});
+
+    prometheus::Family<prometheus::Gauge>& RAM_ = prometheus::BuildGauge()
+                                                      .Name("RAM_usage_percent")
+                                                      .Help("RAM usage percent by this process")
+                                                      .Register(*registry_);
+    prometheus::Gauge& RAM_usage_percent_ = RAM_.Add({});
+
+    // GPU Usage Percent
+    prometheus::Family<prometheus::Gauge>& GPU_percent_ =
+        prometheus::BuildGauge().Name("Gpu_usage_percent").Help("GPU_usage_percent ").Register(*registry_);
+
+    // GPU Mempry used
+    prometheus::Family<prometheus::Gauge>& GPU_memory_usage_ =
+        prometheus::BuildGauge().Name("GPU_memory_usage_total").Help("GPU memory usage total ").Register(*registry_);
+
+    prometheus::Family<prometheus::Gauge>& query_index_type_per_second_ =
+        prometheus::BuildGauge()
+            .Name("query_index_throughtout_per_microsecond")
+            .Help("query index throughtout per microsecond")
+            .Register(*registry_);
+    prometheus::Gauge& query_index_IVF_type_per_second_gauge_ =
+        query_index_type_per_second_.Add({{"IndexType", "IVF"}});
+    prometheus::Gauge& query_index_IDMAP_type_per_second_gauge_ =
+        query_index_type_per_second_.Add({{"IndexType", "IDMAP"}});
+
+    prometheus::Family<prometheus::Gauge>& connection_ =
+        prometheus::BuildGauge().Name("connection_number").Help("the number of connections").Register(*registry_);
+    prometheus::Gauge& connection_gauge_ = connection_.Add({});
+
+    prometheus::Family<prometheus::Counter>& keeping_alive_ = prometheus::BuildCounter()
+                                                                  .Name("keeping_alive_seconds_total")
+                                                                  .Help("total seconds of the serve alive")
+                                                                  .Register(*registry_);
+    prometheus::Counter& keeping_alive_counter_ = keeping_alive_.Add({});
+
+    prometheus::Family<prometheus::Gauge>& octets_ =
+        prometheus::BuildGauge().Name("octets_bytes_per_second").Help("octets bytes per second").Register(*registry_);
+    prometheus::Gauge& inoctets_gauge_ = octets_.Add({{"type", "inoctets"}});
+    prometheus::Gauge& outoctets_gauge_ = octets_.Add({{"type", "outoctets"}});
+
+    prometheus::Family<prometheus::Gauge>& GPU_temperature_ =
+        prometheus::BuildGauge().Name("GPU_temperature").Help("GPU temperature").Register(*registry_);
+
+    prometheus::Family<prometheus::Gauge>& CPU_temperature_ =
+        prometheus::BuildGauge().Name("CPU_temperature").Help("CPU temperature").Register(*registry_);
+};
+
+}  // namespace server
+}  // namespace milvus
diff --git a/core/src/metrics/SystemInfo.cpp b/core/src/metrics/SystemInfo.cpp
new file mode 100644
index 0000000000..154f7b0797
--- /dev/null
+++ b/core/src/metrics/SystemInfo.cpp
@@ -0,0 +1,332 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "metrics/SystemInfo.h"
+#include "utils/Log.h"
+
+#include <dirent.h>
+#include <nvml.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <fstream>
+#include <iostream>
+#include <string>
+#include <utility>
+
+namespace milvus {
+namespace server {
+
+void
+SystemInfo::Init() {
+    if (initialized_) {
+        return;
+    }
+
+    initialized_ = true;
+
+    // initialize CPU information
+    FILE* file;
+    struct tms time_sample;
+    char line[128];
+    last_cpu_ = times(&time_sample);
+    last_sys_cpu_ = time_sample.tms_stime;
+    last_user_cpu_ = time_sample.tms_utime;
+    file = fopen("/proc/cpuinfo", "r");
+    num_processors_ = 0;
+    while (fgets(line, 128, file) != nullptr) {
+        if (strncmp(line, "processor", 9) == 0) {
+            num_processors_++;
+        }
+        if (strncmp(line, "physical", 8) == 0) {
+            num_physical_processors_ = ParseLine(line);
+        }
+    }
+    total_ram_ = GetPhysicalMemory();
+    fclose(file);
+
+    // initialize GPU information
+    nvmlReturn_t nvmlresult;
+    nvmlresult = nvmlInit();
+    if (NVML_SUCCESS != nvmlresult) {
+        SERVER_LOG_ERROR << "System information initilization failed";
+        return;
+    }
+    nvmlresult = nvmlDeviceGetCount(&num_device_);
+    if (NVML_SUCCESS != nvmlresult) {
+        SERVER_LOG_ERROR << "Unable to get devidce number";
+        return;
+    }
+
+    // initialize network traffic information
+    std::pair<uint64_t, uint64_t> in_and_out_octets = Octets();
+    in_octets_ = in_and_out_octets.first;
+    out_octets_ = in_and_out_octets.second;
+    net_time_ = std::chrono::system_clock::now();
+}
+
+uint64_t
+SystemInfo::ParseLine(char* line) {
+    // This assumes that a digit will be found and the line ends in " Kb".
+    int i = strlen(line);
+    const char* p = line;
+    while (*p < '0' || *p > '9') {
+        p++;
+    }
+    line[i - 3] = '\0';
+    i = atoi(p);
+    return static_cast<uint64_t>(i);
+}
+
+uint64_t
+SystemInfo::GetPhysicalMemory() {
+    struct sysinfo memInfo;
+    sysinfo(&memInfo);
+    uint64_t totalPhysMem = memInfo.totalram;
+    // Multiply in next statement to avoid int overflow on right hand side...
+    totalPhysMem *= memInfo.mem_unit;
+    return totalPhysMem;
+}
+
+uint64_t
+SystemInfo::GetProcessUsedMemory() {
+    // Note: this value is in KB!
+    FILE* file = fopen("/proc/self/status", "r");
+    constexpr uint64_t line_length = 128;
+    uint64_t result = -1;
+    constexpr uint64_t KB_SIZE = 1024;
+    char line[line_length];
+
+    while (fgets(line, line_length, file) != nullptr) {
+        if (strncmp(line, "VmRSS:", 6) == 0) {
+            result = ParseLine(line);
+            break;
+        }
+    }
+    fclose(file);
+    // return value in Byte
+    return (result * KB_SIZE);
+}
+
+double
+SystemInfo::MemoryPercent() {
+    if (!initialized_) {
+        Init();
+    }
+
+    double mem_used = static_cast<double>(GetProcessUsedMemory() * 100);
+    return mem_used / static_cast<double>(total_ram_);
+}
+
+std::vector<double>
+SystemInfo::CPUCorePercent() {
+    std::vector<uint64_t> prev_work_time_array;
+    std::vector<uint64_t> prev_total_time_array = getTotalCpuTime(prev_work_time_array);
+    usleep(100000);
+    std::vector<uint64_t> cur_work_time_array;
+    std::vector<uint64_t> cur_total_time_array = getTotalCpuTime(cur_work_time_array);
+
+    std::vector<double> cpu_core_percent;
+    for (int i = 1; i < num_processors_; i++) {
+        double total_cpu_time = cur_total_time_array[i] - prev_total_time_array[i];
+        double cpu_work_time = cur_work_time_array[i] - prev_work_time_array[i];
+        cpu_core_percent.push_back((cpu_work_time / total_cpu_time) * 100);
+    }
+    return cpu_core_percent;
+}
+
+std::vector<uint64_t>
+SystemInfo::getTotalCpuTime(std::vector<uint64_t>& work_time_array) {
+    std::vector<uint64_t> total_time_array;
+    FILE* file = fopen("/proc/stat", "r");
+    if (file == NULL) {
+        SERVER_LOG_ERROR << "Could not open stat file";
+        return total_time_array;
+    }
+
+    uint64_t user = 0, nice = 0, system = 0, idle = 0;
+    uint64_t iowait = 0, irq = 0, softirq = 0, steal = 0, guest = 0, guestnice = 0;
+
+    for (int i = 0; i < num_processors_; i++) {
+        char buffer[1024];
+        char* ret = fgets(buffer, sizeof(buffer) - 1, file);
+        if (ret == NULL) {
+            SERVER_LOG_ERROR << "Could not read stat file";
+            fclose(file);
+            return total_time_array;
+        }
+
+        sscanf(buffer, "cpu  %16lu %16lu %16lu %16lu %16lu %16lu %16lu %16lu %16lu %16lu", &user, &nice, &system, &idle,
+               &iowait, &irq, &softirq, &steal, &guest, &guestnice);
+
+        work_time_array.push_back(user + nice + system);
+        total_time_array.push_back(user + nice + system + idle + iowait + irq + softirq + steal);
+    }
+
+    fclose(file);
+    return total_time_array;
+}
+
+double
+SystemInfo::CPUPercent() {
+    if (!initialized_) {
+        Init();
+    }
+    struct tms time_sample;
+    clock_t now;
+    double percent;
+
+    now = times(&time_sample);
+    if (now <= last_cpu_ || time_sample.tms_stime < last_sys_cpu_ || time_sample.tms_utime < last_user_cpu_) {
+        // Overflow detection. Just skip this value.
+        percent = -1.0;
+    } else {
+        percent = (time_sample.tms_stime - last_sys_cpu_) + (time_sample.tms_utime - last_user_cpu_);
+        percent /= (now - last_cpu_);
+        percent *= 100;
+    }
+    last_cpu_ = now;
+    last_sys_cpu_ = time_sample.tms_stime;
+    last_user_cpu_ = time_sample.tms_utime;
+
+    return percent;
+}
+
+std::vector<uint64_t>
+SystemInfo::GPUMemoryTotal() {
+    // get GPU usage percent
+    if (!initialized_)
+        Init();
+    std::vector<uint64_t> result;
+    nvmlMemory_t nvmlMemory;
+    for (int i = 0; i < num_device_; ++i) {
+        nvmlDevice_t device;
+        nvmlDeviceGetHandleByIndex(i, &device);
+        nvmlDeviceGetMemoryInfo(device, &nvmlMemory);
+        result.push_back(nvmlMemory.total);
+    }
+    return result;
+}
+
+std::vector<uint64_t>
+SystemInfo::GPUTemperature() {
+    if (!initialized_)
+        Init();
+    std::vector<uint64_t> result;
+    for (int i = 0; i < num_device_; i++) {
+        nvmlDevice_t device;
+        nvmlDeviceGetHandleByIndex(i, &device);
+        unsigned int temp;
+        nvmlDeviceGetTemperature(device, NVML_TEMPERATURE_GPU, &temp);
+        result.push_back(temp);
+    }
+    return result;
+}
+
+std::vector<float>
+SystemInfo::CPUTemperature() {
+    std::vector<float> result;
+    std::string path = "/sys/class/hwmon/";
+
+    DIR* dir = NULL;
+    dir = opendir(path.c_str());
+    if (!dir) {
+        SERVER_LOG_ERROR << "Could not open hwmon directory";
+        return result;
+    }
+
+    struct dirent* ptr = NULL;
+    while ((ptr = readdir(dir)) != NULL) {
+        std::string filename(path);
+        filename.append(ptr->d_name);
+
+        char buf[100];
+        if (readlink(filename.c_str(), buf, 100) != -1) {
+            std::string m(buf);
+            if (m.find("coretemp") != std::string::npos) {
+                std::string object = filename;
+                object += "/temp1_input";
+                FILE* file = fopen(object.c_str(), "r");
+                if (file == nullptr) {
+                    SERVER_LOG_ERROR << "Could not open temperature file";
+                    return result;
+                }
+                float temp;
+                fscanf(file, "%f", &temp);
+                result.push_back(temp / 1000);
+            }
+        }
+    }
+    closedir(dir);
+    return result;
+}
+
+std::vector<uint64_t>
+SystemInfo::GPUMemoryUsed() {
+    // get GPU memory used
+    if (!initialized_)
+        Init();
+
+    std::vector<uint64_t> result;
+    nvmlMemory_t nvmlMemory;
+    for (int i = 0; i < num_device_; ++i) {
+        nvmlDevice_t device;
+        nvmlDeviceGetHandleByIndex(i, &device);
+        nvmlDeviceGetMemoryInfo(device, &nvmlMemory);
+        result.push_back(nvmlMemory.used);
+    }
+    return result;
+}
+
+std::pair<uint64_t, uint64_t>
+SystemInfo::Octets() {
+    pid_t pid = getpid();
+    //    const std::string filename = "/proc/"+std::to_string(pid)+"/net/netstat";
+    const std::string filename = "/proc/net/netstat";
+    std::ifstream file(filename);
+    std::string lastline = "";
+    std::string line = "";
+    while (true) {
+        getline(file, line);
+        if (file.fail()) {
+            break;
+        }
+        lastline = line;
+    }
+    std::vector<size_t> space_position;
+    size_t space_pos = lastline.find(" ");
+    while (space_pos != std::string::npos) {
+        space_position.push_back(space_pos);
+        space_pos = lastline.find(" ", space_pos + 1);
+    }
+    // InOctets is between 6th and 7th " " and OutOctets is between 7th and 8th " "
+    size_t inoctets_begin = space_position[6] + 1;
+    size_t inoctets_length = space_position[7] - inoctets_begin;
+    size_t outoctets_begin = space_position[7] + 1;
+    size_t outoctets_length = space_position[8] - outoctets_begin;
+    std::string inoctets = lastline.substr(inoctets_begin, inoctets_length);
+    std::string outoctets = lastline.substr(outoctets_begin, outoctets_length);
+
+    uint64_t inoctets_bytes = std::stoull(inoctets);
+    uint64_t outoctets_bytes = std::stoull(outoctets);
+    std::pair<uint64_t, uint64_t> res(inoctets_bytes, outoctets_bytes);
+    return res;
+}
+
+}  // namespace server
+}  // namespace milvus
diff --git a/core/src/metrics/SystemInfo.h b/core/src/metrics/SystemInfo.h
new file mode 100644
index 0000000000..0176475232
--- /dev/null
+++ b/core/src/metrics/SystemInfo.h
@@ -0,0 +1,133 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/sysinfo.h>
+#include <sys/times.h>
+#include <sys/types.h>
+#include <sys/vtimes.h>
+#include <chrono>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+namespace milvus {
+namespace server {
+
+class SystemInfo {
+ private:
+    uint64_t total_ram_ = 0;
+    clock_t last_cpu_ = clock_t();
+    clock_t last_sys_cpu_ = clock_t();
+    clock_t last_user_cpu_ = clock_t();
+    std::chrono::system_clock::time_point net_time_ = std::chrono::system_clock::now();
+    int num_processors_ = 0;
+    int num_physical_processors_ = 0;
+    // number of GPU
+    uint32_t num_device_ = 0;
+    uint64_t in_octets_ = 0;
+    uint64_t out_octets_ = 0;
+    bool initialized_ = false;
+
+ public:
+    static SystemInfo&
+    GetInstance() {
+        static SystemInfo instance;
+        return instance;
+    }
+
+    void
+    Init();
+
+    int
+    num_processor() const {
+        return num_processors_;
+    }
+
+    int
+    num_physical_processors() const {
+        return num_physical_processors_;
+    }
+
+    uint32_t
+    num_device() const {
+        return num_device_;
+    }
+
+    uint64_t
+    get_inoctets() {
+        return in_octets_;
+    }
+
+    uint64_t
+    get_octets() {
+        return out_octets_;
+    }
+
+    std::chrono::system_clock::time_point
+    get_nettime() {
+        return net_time_;
+    }
+
+    void
+    set_inoctets(uint64_t value) {
+        in_octets_ = value;
+    }
+
+    void
+    set_outoctets(uint64_t value) {
+        out_octets_ = value;
+    }
+
+    void
+    set_nettime() {
+        net_time_ = std::chrono::system_clock::now();
+    }
+
+    uint64_t
+    ParseLine(char* line);
+    uint64_t
+    GetPhysicalMemory();
+    uint64_t
+    GetProcessUsedMemory();
+    double
+    MemoryPercent();
+    double
+    CPUPercent();
+    std::pair<uint64_t, uint64_t>
+    Octets();
+    std::vector<uint64_t>
+    GPUMemoryTotal();
+    std::vector<uint64_t>
+    GPUMemoryUsed();
+
+    std::vector<double>
+    CPUCorePercent();
+    std::vector<uint64_t>
+    getTotalCpuTime(std::vector<uint64_t>& workTime);
+    std::vector<uint64_t>
+    GPUTemperature();
+    std::vector<float>
+    CPUTemperature();
+};
+
+}  // namespace server
+}  // namespace milvus
diff --git a/core/src/scheduler/Algorithm.cpp b/core/src/scheduler/Algorithm.cpp
new file mode 100644
index 0000000000..b2156b3f97
--- /dev/null
+++ b/core/src/scheduler/Algorithm.cpp
@@ -0,0 +1,105 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "scheduler/Algorithm.h"
+
+#include <limits>
+#include <unordered_map>
+#include <utility>
+
+namespace milvus {
+namespace scheduler {
+
+constexpr uint64_t MAXINT = std::numeric_limits<uint32_t>::max();
+
+uint64_t
+ShortestPath(const ResourcePtr& src, const ResourcePtr& dest, const ResourceMgrPtr& res_mgr,
+             std::vector<std::string>& path) {
+    uint64_t num_of_resources = res_mgr->GetAllResources().size();
+    std::unordered_map<uint64_t, std::string> id_name_map;
+    std::unordered_map<std::string, uint64_t> name_id_map;
+    for (uint64_t i = 0; i < num_of_resources; ++i) {
+        id_name_map.insert(std::make_pair(i, res_mgr->GetAllResources().at(i)->name()));
+        name_id_map.insert(std::make_pair(res_mgr->GetAllResources().at(i)->name(), i));
+    }
+
+    std::vector<std::vector<uint64_t>> dis_matrix;
+    dis_matrix.resize(num_of_resources);
+    for (uint64_t i = 0; i < num_of_resources; ++i) {
+        dis_matrix[i].resize(num_of_resources);
+        for (uint64_t j = 0; j < num_of_resources; ++j) {
+            dis_matrix[i][j] = MAXINT;
+        }
+        dis_matrix[i][i] = 0;
+    }
+
+    std::vector<bool> vis(num_of_resources, false);
+    std::vector<uint64_t> dis(num_of_resources, MAXINT);
+    for (auto& res : res_mgr->GetAllResources()) {
+        auto cur_node = std::static_pointer_cast<Node>(res);
+        auto cur_neighbours = cur_node->GetNeighbours();
+
+        for (auto& neighbour : cur_neighbours) {
+            auto neighbour_res = std::static_pointer_cast<Resource>(neighbour.neighbour_node.lock());
+            dis_matrix[name_id_map.at(res->name())][name_id_map.at(neighbour_res->name())] =
+                neighbour.connection.transport_cost();
+        }
+    }
+
+    for (uint64_t i = 0; i < num_of_resources; ++i) {
+        dis[i] = dis_matrix[name_id_map.at(src->name())][i];
+    }
+
+    vis[name_id_map.at(src->name())] = true;
+    std::vector<int64_t> parent(num_of_resources, -1);
+
+    for (uint64_t i = 0; i < num_of_resources; ++i) {
+        uint64_t minn = MAXINT;
+        uint64_t temp = 0;
+        for (uint64_t j = 0; j < num_of_resources; ++j) {
+            if (!vis[j] && dis[j] < minn) {
+                minn = dis[j];
+                temp = j;
+            }
+        }
+        vis[temp] = true;
+
+        if (i == 0) {
+            parent[temp] = name_id_map.at(src->name());
+        }
+
+        for (uint64_t j = 0; j < num_of_resources; ++j) {
+            if (!vis[j] && dis_matrix[temp][j] != MAXINT && dis_matrix[temp][j] + dis[temp] < dis[j]) {
+                dis[j] = dis_matrix[temp][j] + dis[temp];
+                parent[j] = temp;
+            }
+        }
+    }
+
+    int64_t parent_idx = parent[name_id_map.at(dest->name())];
+    if (parent_idx != -1) {
+        path.push_back(dest->name());
+    }
+    while (parent_idx != -1) {
+        path.push_back(id_name_map.at(parent_idx));
+        parent_idx = parent[parent_idx];
+    }
+    return dis[name_id_map.at(dest->name())];
+}
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/Algorithm.h b/core/src/scheduler/Algorithm.h
new file mode 100644
index 0000000000..69ff8f3a70
--- /dev/null
+++ b/core/src/scheduler/Algorithm.h
@@ -0,0 +1,32 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "ResourceMgr.h"
+#include "resource/Resource.h"
+
+#include <string>
+#include <vector>
+
+namespace milvus {
+namespace scheduler {
+
+uint64_t
+ShortestPath(const ResourcePtr& src, const ResourcePtr& dest, const ResourceMgrPtr& res_mgr,
+             std::vector<std::string>& path);
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/BuildMgr.cpp b/core/src/scheduler/BuildMgr.cpp
new file mode 100644
index 0000000000..d90a074d30
--- /dev/null
+++ b/core/src/scheduler/BuildMgr.cpp
@@ -0,0 +1,22 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "scheduler/BuildMgr.h"
+
+namespace milvus {
+namespace scheduler {}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/BuildMgr.h b/core/src/scheduler/BuildMgr.h
new file mode 100644
index 0000000000..ee7ab38e25
--- /dev/null
+++ b/core/src/scheduler/BuildMgr.h
@@ -0,0 +1,63 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <atomic>
+#include <condition_variable>
+#include <deque>
+#include <list>
+#include <memory>
+#include <mutex>
+#include <queue>
+#include <string>
+#include <thread>
+#include <unordered_map>
+#include <vector>
+
+namespace milvus {
+namespace scheduler {
+
+class BuildMgr {
+ public:
+    explicit BuildMgr(int64_t numoftasks) : numoftasks_(numoftasks) {
+    }
+
+ public:
+    void
+    Put() {
+        ++numoftasks_;
+    }
+
+    void
+    take() {
+        --numoftasks_;
+    }
+
+    int64_t
+    numoftasks() {
+        return (int64_t)numoftasks_;
+    }
+
+ private:
+    std::atomic_long numoftasks_;
+};
+
+using BuildMgrPtr = std::shared_ptr<BuildMgr>;
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/Definition.h b/core/src/scheduler/Definition.h
new file mode 100644
index 0000000000..162988e90a
--- /dev/null
+++ b/core/src/scheduler/Definition.h
@@ -0,0 +1,45 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 <condition_variable>
+#include <deque>
+#include <list>
+#include <memory>
+#include <mutex>
+#include <queue>
+#include <string>
+#include <thread>
+#include <unordered_map>
+#include <vector>
+
+#include "db/engine/EngineFactory.h"
+#include "db/engine/ExecutionEngine.h"
+#include "db/meta/MetaTypes.h"
+
+namespace milvus {
+namespace scheduler {
+
+using TableFileSchemaPtr = engine::meta::TableFileSchemaPtr;
+using TableFileSchema = engine::meta::TableFileSchema;
+
+using ExecutionEnginePtr = engine::ExecutionEnginePtr;
+using EngineFactory = engine::EngineFactory;
+using EngineType = engine::EngineType;
+using MetricType = engine::MetricType;
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/JobMgr.cpp b/core/src/scheduler/JobMgr.cpp
new file mode 100644
index 0000000000..70f1352a5c
--- /dev/null
+++ b/core/src/scheduler/JobMgr.cpp
@@ -0,0 +1,115 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "scheduler/JobMgr.h"
+#include "SchedInst.h"
+#include "TaskCreator.h"
+#include "optimizer/Optimizer.h"
+#include "scheduler/Algorithm.h"
+#include "scheduler/optimizer/Optimizer.h"
+#include "scheduler/tasklabel/SpecResLabel.h"
+#include "task/Task.h"
+
+#include <utility>
+
+namespace milvus {
+namespace scheduler {
+
+JobMgr::JobMgr(ResourceMgrPtr res_mgr) : res_mgr_(std::move(res_mgr)) {
+}
+
+void
+JobMgr::Start() {
+    if (not running_) {
+        running_ = true;
+        worker_thread_ = std::thread(&JobMgr::worker_function, this);
+    }
+}
+
+void
+JobMgr::Stop() {
+    if (running_) {
+        this->Put(nullptr);
+        worker_thread_.join();
+        running_ = false;
+    }
+}
+
+void
+JobMgr::Put(const JobPtr& job) {
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        queue_.push(job);
+    }
+    cv_.notify_one();
+}
+
+void
+JobMgr::worker_function() {
+    while (running_) {
+        std::unique_lock<std::mutex> lock(mutex_);
+        cv_.wait(lock, [this] { return !queue_.empty(); });
+        auto job = queue_.front();
+        queue_.pop();
+        lock.unlock();
+        if (job == nullptr) {
+            break;
+        }
+
+        auto tasks = build_task(job);
+        for (auto& task : tasks) {
+            OptimizerInst::GetInstance()->Run(task);
+        }
+
+        for (auto& task : tasks) {
+            calculate_path(task);
+        }
+
+        // disk resources NEVER be empty.
+        if (auto disk = res_mgr_->GetDiskResources()[0].lock()) {
+            for (auto& task : tasks) {
+                disk->task_table().Put(task);
+            }
+        }
+    }
+}
+
+std::vector<TaskPtr>
+JobMgr::build_task(const JobPtr& job) {
+    return TaskCreator::Create(job);
+}
+
+void
+JobMgr::calculate_path(const TaskPtr& task) {
+    if (task->type_ != TaskType::SearchTask) {
+        return;
+    }
+
+    if (task->label()->Type() != TaskLabelType::SPECIFIED_RESOURCE) {
+        return;
+    }
+
+    std::vector<std::string> path;
+    auto spec_label = std::static_pointer_cast<SpecResLabel>(task->label());
+    auto src = res_mgr_->GetDiskResources()[0];
+    auto dest = spec_label->resource();
+    ShortestPath(src.lock(), dest.lock(), res_mgr_, path);
+    task->path() = Path(path, path.size() - 1);
+}
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/JobMgr.h b/core/src/scheduler/JobMgr.h
new file mode 100644
index 0000000000..b4c706d359
--- /dev/null
+++ b/core/src/scheduler/JobMgr.h
@@ -0,0 +1,76 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+#pragma once
+
+#include <condition_variable>
+#include <deque>
+#include <list>
+#include <memory>
+#include <mutex>
+#include <queue>
+#include <string>
+#include <thread>
+#include <unordered_map>
+#include <vector>
+
+#include "ResourceMgr.h"
+#include "job/Job.h"
+#include "task/Task.h"
+
+namespace milvus {
+namespace scheduler {
+
+class JobMgr {
+ public:
+    explicit JobMgr(ResourceMgrPtr res_mgr);
+
+    void
+    Start();
+
+    void
+    Stop();
+
+ public:
+    void
+    Put(const JobPtr& job);
+
+ private:
+    void
+    worker_function();
+
+    static std::vector<TaskPtr>
+    build_task(const JobPtr& job);
+
+    void
+    calculate_path(const TaskPtr& task);
+
+ private:
+    bool running_ = false;
+    std::queue<JobPtr> queue_;
+
+    std::thread worker_thread_;
+
+    std::mutex mutex_;
+    std::condition_variable cv_;
+
+    ResourceMgrPtr res_mgr_ = nullptr;
+};
+
+using JobMgrPtr = std::shared_ptr<JobMgr>;
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/ResourceFactory.cpp b/core/src/scheduler/ResourceFactory.cpp
new file mode 100644
index 0000000000..fad8571b61
--- /dev/null
+++ b/core/src/scheduler/ResourceFactory.cpp
@@ -0,0 +1,38 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "scheduler/ResourceFactory.h"
+
+namespace milvus {
+namespace scheduler {
+
+std::shared_ptr<Resource>
+ResourceFactory::Create(const std::string& name, const std::string& type, uint64_t device_id, bool enable_loader,
+                        bool enable_executor) {
+    if (type == "DISK") {
+        return std::make_shared<DiskResource>(name, device_id, enable_loader, enable_executor);
+    } else if (type == "CPU") {
+        return std::make_shared<CpuResource>(name, device_id, enable_loader, enable_executor);
+    } else if (type == "GPU") {
+        return std::make_shared<GpuResource>(name, device_id, enable_loader, enable_executor);
+    } else {
+        return nullptr;
+    }
+}
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/ResourceFactory.h b/core/src/scheduler/ResourceFactory.h
new file mode 100644
index 0000000000..3290cb023c
--- /dev/null
+++ b/core/src/scheduler/ResourceFactory.h
@@ -0,0 +1,39 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "resource/CpuResource.h"
+#include "resource/DiskResource.h"
+#include "resource/GpuResource.h"
+#include "resource/Resource.h"
+
+namespace milvus {
+namespace scheduler {
+
+class ResourceFactory {
+ public:
+    static std::shared_ptr<Resource>
+    Create(const std::string& name, const std::string& type, uint64_t device_id, bool enable_loader = true,
+           bool enable_executor = true);
+};
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/ResourceMgr.cpp b/core/src/scheduler/ResourceMgr.cpp
new file mode 100644
index 0000000000..6e839062ef
--- /dev/null
+++ b/core/src/scheduler/ResourceMgr.cpp
@@ -0,0 +1,260 @@
+
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "scheduler/ResourceMgr.h"
+#include "utils/Log.h"
+
+namespace milvus {
+namespace scheduler {
+
+void
+ResourceMgr::Start() {
+    if (not check_resource_valid()) {
+        ENGINE_LOG_ERROR << "Resources invalid, cannot start ResourceMgr.";
+        ENGINE_LOG_ERROR << Dump();
+        return;
+    }
+
+    std::lock_guard<std::mutex> lck(resources_mutex_);
+    for (auto& resource : resources_) {
+        resource->Start();
+    }
+    running_ = true;
+    worker_thread_ = std::thread(&ResourceMgr::event_process, this);
+}
+
+void
+ResourceMgr::Stop() {
+    {
+        std::lock_guard<std::mutex> lock(event_mutex_);
+        running_ = false;
+        queue_.push(nullptr);
+        event_cv_.notify_one();
+    }
+    worker_thread_.join();
+
+    std::lock_guard<std::mutex> lck(resources_mutex_);
+    for (auto& resource : resources_) {
+        resource->Stop();
+    }
+}
+
+ResourceWPtr
+ResourceMgr::Add(ResourcePtr&& resource) {
+    ResourceWPtr ret(resource);
+
+    std::lock_guard<std::mutex> lck(resources_mutex_);
+    if (running_) {
+        ENGINE_LOG_ERROR << "ResourceMgr is running, not allow to add resource";
+        return ret;
+    }
+
+    resource->RegisterSubscriber(std::bind(&ResourceMgr::post_event, this, std::placeholders::_1));
+
+    switch (resource->type()) {
+        case ResourceType::DISK: {
+            disk_resources_.emplace_back(ResourceWPtr(resource));
+            break;
+        }
+        case ResourceType::CPU: {
+            cpu_resources_.emplace_back(ResourceWPtr(resource));
+            break;
+        }
+        case ResourceType::GPU: {
+            gpu_resources_.emplace_back(ResourceWPtr(resource));
+            break;
+        }
+        default: { break; }
+    }
+    resources_.emplace_back(resource);
+
+    return ret;
+}
+
+bool
+ResourceMgr::Connect(const std::string& name1, const std::string& name2, Connection& connection) {
+    auto res1 = GetResource(name1);
+    auto res2 = GetResource(name2);
+    if (res1 && res2) {
+        res1->AddNeighbour(std::static_pointer_cast<Node>(res2), connection);
+        // TODO(wxyu): enable when task balance supported
+        //        res2->AddNeighbour(std::static_pointer_cast<Node>(res1), connection);
+        return true;
+    }
+    return false;
+}
+
+void
+ResourceMgr::Clear() {
+    std::lock_guard<std::mutex> lck(resources_mutex_);
+    if (running_) {
+        ENGINE_LOG_ERROR << "ResourceMgr is running, cannot clear.";
+        return;
+    }
+    disk_resources_.clear();
+    cpu_resources_.clear();
+    gpu_resources_.clear();
+    resources_.clear();
+}
+
+std::vector<ResourcePtr>
+ResourceMgr::GetComputeResources() {
+    std::vector<ResourcePtr> result;
+    for (auto& resource : resources_) {
+        if (resource->HasExecutor()) {
+            result.emplace_back(resource);
+        }
+    }
+    return result;
+}
+
+ResourcePtr
+ResourceMgr::GetResource(ResourceType type, uint64_t device_id) {
+    for (auto& resource : resources_) {
+        if (resource->type() == type && resource->device_id() == device_id) {
+            return resource;
+        }
+    }
+    return nullptr;
+}
+
+ResourcePtr
+ResourceMgr::GetResource(const std::string& name) {
+    for (auto& resource : resources_) {
+        if (resource->name() == name) {
+            return resource;
+        }
+    }
+    return nullptr;
+}
+
+uint64_t
+ResourceMgr::GetNumOfResource() const {
+    return resources_.size();
+}
+
+uint64_t
+ResourceMgr::GetNumOfComputeResource() const {
+    uint64_t count = 0;
+    for (auto& res : resources_) {
+        if (res->HasExecutor()) {
+            ++count;
+        }
+    }
+    return count;
+}
+
+uint64_t
+ResourceMgr::GetNumGpuResource() const {
+    uint64_t num = 0;
+    for (auto& res : resources_) {
+        if (res->type() == ResourceType::GPU) {
+            num++;
+        }
+    }
+    return num;
+}
+
+std::string
+ResourceMgr::Dump() {
+    std::stringstream ss;
+    ss << "ResourceMgr contains " << resources_.size() << " resources." << std::endl;
+
+    for (auto& res : resources_) {
+        ss << res->Dump();
+    }
+
+    return ss.str();
+}
+
+std::string
+ResourceMgr::DumpTaskTables() {
+    std::stringstream ss;
+    ss << ">>>>>>>>>>>>>>>ResourceMgr::DumpTaskTable<<<<<<<<<<<<<<<" << std::endl;
+    for (auto& resource : resources_) {
+        ss << resource->Dump() << std::endl;
+        ss << resource->task_table().Dump();
+        ss << resource->Dump() << std::endl << std::endl;
+    }
+    return ss.str();
+}
+
+bool
+ResourceMgr::check_resource_valid() {
+    {
+        // TODO: check one disk-resource, one cpu-resource, zero or more gpu-resource;
+        if (GetDiskResources().size() != 1) {
+            return false;
+        }
+        if (GetCpuResources().size() != 1) {
+            return false;
+        }
+    }
+
+    {
+        // TODO: one compute-resource at least;
+        if (GetNumOfComputeResource() < 1) {
+            return false;
+        }
+    }
+
+    {
+        // TODO: check disk only connect with cpu
+    }
+
+    {
+        // TODO: check gpu only connect with cpu
+    }
+
+    {
+        // TODO: check if exists isolated node
+    }
+
+    return true;
+}
+
+void
+ResourceMgr::post_event(const EventPtr& event) {
+    {
+        std::lock_guard<std::mutex> lock(event_mutex_);
+        queue_.emplace(event);
+    }
+    event_cv_.notify_one();
+}
+
+void
+ResourceMgr::event_process() {
+    while (running_) {
+        std::unique_lock<std::mutex> lock(event_mutex_);
+        event_cv_.wait(lock, [this] { return !queue_.empty(); });
+
+        auto event = queue_.front();
+        queue_.pop();
+        lock.unlock();
+        if (event == nullptr) {
+            break;
+        }
+
+        if (subscriber_) {
+            subscriber_(event);
+        }
+    }
+}
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/ResourceMgr.h b/core/src/scheduler/ResourceMgr.h
new file mode 100644
index 0000000000..7a8e1ca4ca
--- /dev/null
+++ b/core/src/scheduler/ResourceMgr.h
@@ -0,0 +1,143 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <condition_variable>
+#include <memory>
+#include <mutex>
+#include <queue>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "resource/Resource.h"
+#include "utils/Log.h"
+
+namespace milvus {
+namespace scheduler {
+
+class ResourceMgr {
+ public:
+    ResourceMgr() = default;
+
+ public:
+    /******** Management Interface ********/
+    void
+    Start();
+
+    void
+    Stop();
+
+    ResourceWPtr
+    Add(ResourcePtr&& resource);
+
+    bool
+    Connect(const std::string& name1, const std::string& name2, Connection& connection);
+
+    void
+    Clear();
+
+    inline void
+    RegisterSubscriber(std::function<void(EventPtr)> subscriber) {
+        subscriber_ = std::move(subscriber);
+    }
+
+ public:
+    /******** Management Interface ********/
+    inline std::vector<ResourceWPtr>&
+    GetDiskResources() {
+        return disk_resources_;
+    }
+
+    inline std::vector<ResourceWPtr>&
+    GetCpuResources() {
+        return cpu_resources_;
+    }
+
+    inline std::vector<ResourceWPtr>&
+    GetGpuResources() {
+        return gpu_resources_;
+    }
+
+    // TODO(wxyu): why return shared pointer
+    inline std::vector<ResourcePtr>
+    GetAllResources() {
+        return resources_;
+    }
+
+    std::vector<ResourcePtr>
+    GetComputeResources();
+
+    ResourcePtr
+    GetResource(ResourceType type, uint64_t device_id);
+
+    ResourcePtr
+    GetResource(const std::string& name);
+
+    uint64_t
+    GetNumOfResource() const;
+
+    uint64_t
+    GetNumOfComputeResource() const;
+
+    uint64_t
+    GetNumGpuResource() const;
+
+ public:
+    // TODO(wxyu): add stats interface(low)
+
+ public:
+    /******** Utility Functions ********/
+    std::string
+    Dump();
+
+    std::string
+    DumpTaskTables();
+
+ private:
+    bool
+    check_resource_valid();
+
+    void
+    post_event(const EventPtr& event);
+
+    void
+    event_process();
+
+ private:
+    bool running_ = false;
+
+    std::vector<ResourceWPtr> disk_resources_;
+    std::vector<ResourceWPtr> cpu_resources_;
+    std::vector<ResourceWPtr> gpu_resources_;
+    std::vector<ResourcePtr> resources_;
+    mutable std::mutex resources_mutex_;
+
+    std::queue<EventPtr> queue_;
+    std::function<void(EventPtr)> subscriber_ = nullptr;
+    std::mutex event_mutex_;
+    std::condition_variable event_cv_;
+
+    std::thread worker_thread_;
+};
+
+using ResourceMgrPtr = std::shared_ptr<ResourceMgr>;
+using ResourceMgrWPtr = std::weak_ptr<ResourceMgr>;
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/SchedInst.cpp b/core/src/scheduler/SchedInst.cpp
new file mode 100644
index 0000000000..f3f293a0f3
--- /dev/null
+++ b/core/src/scheduler/SchedInst.cpp
@@ -0,0 +1,171 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "scheduler/SchedInst.h"
+#include "ResourceFactory.h"
+#include "Utils.h"
+#include "knowhere/index/vector_index/IndexGPUIVF.h"
+#include "server/Config.h"
+
+#include <set>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace milvus {
+namespace scheduler {
+
+ResourceMgrPtr ResMgrInst::instance = nullptr;
+std::mutex ResMgrInst::mutex_;
+
+SchedulerPtr SchedInst::instance = nullptr;
+std::mutex SchedInst::mutex_;
+
+scheduler::JobMgrPtr JobMgrInst::instance = nullptr;
+std::mutex JobMgrInst::mutex_;
+
+OptimizerPtr OptimizerInst::instance = nullptr;
+std::mutex OptimizerInst::mutex_;
+
+BuildMgrPtr BuildMgrInst::instance = nullptr;
+std::mutex BuildMgrInst::mutex_;
+
+void
+load_simple_config() {
+    server::Config& config = server::Config::GetInstance();
+    std::string mode;
+    config.GetResourceConfigMode(mode);
+    std::vector<std::string> pool;
+    config.GetResourceConfigSearchResources(pool);
+
+    // get resources
+    auto gpu_ids = get_gpu_pool();
+
+    int32_t build_gpu_id;
+    config.GetResourceConfigIndexBuildDevice(build_gpu_id);
+
+    // create and connect
+    ResMgrInst::GetInstance()->Add(ResourceFactory::Create("disk", "DISK", 0, true, false));
+
+    auto io = Connection("io", 500);
+    ResMgrInst::GetInstance()->Add(ResourceFactory::Create("cpu", "CPU", 0, true, true));
+    ResMgrInst::GetInstance()->Connect("disk", "cpu", io);
+
+    auto pcie = Connection("pcie", 12000);
+    bool find_build_gpu_id = false;
+    for (auto& gpu_id : gpu_ids) {
+        ResMgrInst::GetInstance()->Add(ResourceFactory::Create(std::to_string(gpu_id), "GPU", gpu_id, true, true));
+        ResMgrInst::GetInstance()->Connect("cpu", std::to_string(gpu_id), pcie);
+        if (build_gpu_id == gpu_id) {
+            find_build_gpu_id = true;
+        }
+    }
+
+    if (not find_build_gpu_id) {
+        ResMgrInst::GetInstance()->Add(
+            ResourceFactory::Create(std::to_string(build_gpu_id), "GPU", build_gpu_id, true, true));
+        ResMgrInst::GetInstance()->Connect("cpu", std::to_string(build_gpu_id), pcie);
+    }
+}
+
+void
+load_advance_config() {
+    //    try {
+    //        server::ConfigNode &config = server::Config::GetInstance().GetConfig(server::CONFIG_RESOURCE);
+    //
+    //        if (config.GetChildren().empty()) throw "resource_config null exception";
+    //
+    //        auto resources = config.GetChild(server::CONFIG_RESOURCES).GetChildren();
+    //
+    //        if (resources.empty()) throw "Children of resource_config null exception";
+    //
+    //        for (auto &resource : resources) {
+    //            auto &resname = resource.first;
+    //            auto &resconf = resource.second;
+    //            auto type = resconf.GetValue(server::CONFIG_RESOURCE_TYPE);
+    ////        auto memory = resconf.GetInt64Value(server::CONFIG_RESOURCE_MEMORY);
+    //            auto device_id = resconf.GetInt64Value(server::CONFIG_RESOURCE_DEVICE_ID);
+    ////            auto enable_loader = resconf.GetBoolValue(server::CONFIG_RESOURCE_ENABLE_LOADER);
+    //            auto enable_loader = true;
+    //            auto enable_executor = resconf.GetBoolValue(server::CONFIG_RESOURCE_ENABLE_EXECUTOR);
+    //            auto pinned_memory = resconf.GetInt64Value(server::CONFIG_RESOURCE_PIN_MEMORY);
+    //            auto temp_memory = resconf.GetInt64Value(server::CONFIG_RESOURCE_TEMP_MEMORY);
+    //            auto resource_num = resconf.GetInt64Value(server::CONFIG_RESOURCE_NUM);
+    //
+    //            auto res = ResMgrInst::GetInstance()->Add(ResourceFactory::Create(resname,
+    //                                                                              type,
+    //                                                                              device_id,
+    //                                                                              enable_loader,
+    //                                                                              enable_executor));
+    //
+    //            if (res.lock()->type() == ResourceType::GPU) {
+    //                auto pinned_memory = resconf.GetInt64Value(server::CONFIG_RESOURCE_PIN_MEMORY, 300);
+    //                auto temp_memory = resconf.GetInt64Value(server::CONFIG_RESOURCE_TEMP_MEMORY, 300);
+    //                auto resource_num = resconf.GetInt64Value(server::CONFIG_RESOURCE_NUM, 2);
+    //                pinned_memory = 1024 * 1024 * pinned_memory;
+    //                temp_memory = 1024 * 1024 * temp_memory;
+    //                knowhere::FaissGpuResourceMgr::GetInstance().InitDevice(device_id,
+    //                                                                        pinned_memory,
+    //                                                                        temp_memory,
+    //                                                                        resource_num);
+    //            }
+    //        }
+    //
+    //        knowhere::FaissGpuResourceMgr::GetInstance().InitResource();
+    //
+    //        auto connections = config.GetChild(server::CONFIG_RESOURCE_CONNECTIONS).GetChildren();
+    //        if (connections.empty()) throw "connections config null exception";
+    //        for (auto &conn : connections) {
+    //            auto &connect_name = conn.first;
+    //            auto &connect_conf = conn.second;
+    //            auto connect_speed = connect_conf.GetInt64Value(server::CONFIG_SPEED_CONNECTIONS);
+    //            auto connect_endpoint = connect_conf.GetValue(server::CONFIG_ENDPOINT_CONNECTIONS);
+    //
+    //            std::string delimiter = "===";
+    //            std::string left = connect_endpoint.substr(0, connect_endpoint.find(delimiter));
+    //            std::string right = connect_endpoint.substr(connect_endpoint.find(delimiter) + 3,
+    //                                                        connect_endpoint.length());
+    //
+    //            auto connection = Connection(connect_name, connect_speed);
+    //            ResMgrInst::GetInstance()->Connect(left, right, connection);
+    //        }
+    //    } catch (const char *msg) {
+    //        SERVER_LOG_ERROR << msg;
+    //        // TODO(wxyu): throw exception instead
+    //        exit(-1);
+    ////        throw std::exception();
+    //    }
+}
+
+void
+StartSchedulerService() {
+    load_simple_config();
+    //    load_advance_config();
+    ResMgrInst::GetInstance()->Start();
+    SchedInst::GetInstance()->Start();
+    JobMgrInst::GetInstance()->Start();
+}
+
+void
+StopSchedulerService() {
+    JobMgrInst::GetInstance()->Stop();
+    SchedInst::GetInstance()->Stop();
+    ResMgrInst::GetInstance()->Stop();
+}
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/SchedInst.h b/core/src/scheduler/SchedInst.h
new file mode 100644
index 0000000000..60033731ae
--- /dev/null
+++ b/core/src/scheduler/SchedInst.h
@@ -0,0 +1,134 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "BuildMgr.h"
+#include "JobMgr.h"
+#include "ResourceMgr.h"
+#include "Scheduler.h"
+#include "optimizer/HybridPass.h"
+#include "optimizer/LargeSQ8HPass.h"
+#include "optimizer/Optimizer.h"
+
+#include <memory>
+#include <mutex>
+#include <vector>
+
+namespace milvus {
+namespace scheduler {
+
+class ResMgrInst {
+ public:
+    static ResourceMgrPtr
+    GetInstance() {
+        if (instance == nullptr) {
+            std::lock_guard<std::mutex> lock(mutex_);
+            if (instance == nullptr) {
+                instance = std::make_shared<ResourceMgr>();
+            }
+        }
+        return instance;
+    }
+
+ private:
+    static ResourceMgrPtr instance;
+    static std::mutex mutex_;
+};
+
+class SchedInst {
+ public:
+    static SchedulerPtr
+    GetInstance() {
+        if (instance == nullptr) {
+            std::lock_guard<std::mutex> lock(mutex_);
+            if (instance == nullptr) {
+                instance = std::make_shared<Scheduler>(ResMgrInst::GetInstance());
+            }
+        }
+        return instance;
+    }
+
+ private:
+    static SchedulerPtr instance;
+    static std::mutex mutex_;
+};
+
+class JobMgrInst {
+ public:
+    static scheduler::JobMgrPtr
+    GetInstance() {
+        if (instance == nullptr) {
+            std::lock_guard<std::mutex> lock(mutex_);
+            if (instance == nullptr) {
+                instance = std::make_shared<scheduler::JobMgr>(ResMgrInst::GetInstance());
+            }
+        }
+        return instance;
+    }
+
+ private:
+    static scheduler::JobMgrPtr instance;
+    static std::mutex mutex_;
+};
+
+class OptimizerInst {
+ public:
+    static OptimizerPtr
+    GetInstance() {
+        if (instance == nullptr) {
+            std::lock_guard<std::mutex> lock(mutex_);
+            if (instance == nullptr) {
+                std::vector<PassPtr> pass_list;
+                pass_list.push_back(std::make_shared<HybridPass>());
+                instance = std::make_shared<Optimizer>(pass_list);
+            }
+        }
+        return instance;
+    }
+
+ private:
+    static scheduler::OptimizerPtr instance;
+    static std::mutex mutex_;
+};
+
+class BuildMgrInst {
+ public:
+    static BuildMgrPtr
+    GetInstance() {
+        if (instance == nullptr) {
+            std::lock_guard<std::mutex> lock(mutex_);
+            if (instance == nullptr) {
+                instance = std::make_shared<BuildMgr>(4);
+            }
+        }
+        return instance;
+    }
+
+ private:
+    static BuildMgrPtr instance;
+    static std::mutex mutex_;
+};
+
+void
+StartSchedulerService();
+
+void
+StopSchedulerService();
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/Scheduler.cpp b/core/src/scheduler/Scheduler.cpp
new file mode 100644
index 0000000000..19197b4168
--- /dev/null
+++ b/core/src/scheduler/Scheduler.cpp
@@ -0,0 +1,147 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "scheduler/Scheduler.h"
+#include "Algorithm.h"
+#include "action/Action.h"
+#include "cache/GpuCacheMgr.h"
+#include "event/LoadCompletedEvent.h"
+
+#include <utility>
+
+namespace milvus {
+namespace scheduler {
+
+Scheduler::Scheduler(ResourceMgrWPtr res_mgr) : running_(false), res_mgr_(std::move(res_mgr)) {
+    if (auto mgr = res_mgr_.lock()) {
+        mgr->RegisterSubscriber(std::bind(&Scheduler::PostEvent, this, std::placeholders::_1));
+    }
+    event_register_.insert(std::make_pair(static_cast<uint64_t>(EventType::START_UP),
+                                          std::bind(&Scheduler::OnStartUp, this, std::placeholders::_1)));
+    event_register_.insert(std::make_pair(static_cast<uint64_t>(EventType::LOAD_COMPLETED),
+                                          std::bind(&Scheduler::OnLoadCompleted, this, std::placeholders::_1)));
+    event_register_.insert(std::make_pair(static_cast<uint64_t>(EventType::TASK_TABLE_UPDATED),
+                                          std::bind(&Scheduler::OnTaskTableUpdated, this, std::placeholders::_1)));
+    event_register_.insert(std::make_pair(static_cast<uint64_t>(EventType::FINISH_TASK),
+                                          std::bind(&Scheduler::OnFinishTask, this, std::placeholders::_1)));
+}
+
+void
+Scheduler::Start() {
+    running_ = true;
+    worker_thread_ = std::thread(&Scheduler::worker_function, this);
+}
+
+void
+Scheduler::Stop() {
+    {
+        std::lock_guard<std::mutex> lock(event_mutex_);
+        running_ = false;
+        event_queue_.push(nullptr);
+        event_cv_.notify_one();
+    }
+    worker_thread_.join();
+}
+
+void
+Scheduler::PostEvent(const EventPtr& event) {
+    {
+        std::lock_guard<std::mutex> lock(event_mutex_);
+        event_queue_.push(event);
+    }
+    event_cv_.notify_one();
+}
+
+std::string
+Scheduler::Dump() {
+    return std::string();
+}
+
+void
+Scheduler::worker_function() {
+    while (running_) {
+        std::unique_lock<std::mutex> lock(event_mutex_);
+        event_cv_.wait(lock, [this] { return !event_queue_.empty(); });
+        auto event = event_queue_.front();
+        event_queue_.pop();
+        if (event == nullptr) {
+            break;
+        }
+
+        Process(event);
+    }
+}
+
+void
+Scheduler::Process(const EventPtr& event) {
+    auto process_event = event_register_.at(static_cast<int>(event->Type()));
+    process_event(event);
+}
+
+// TODO(wxyu): refactor the function
+void
+Scheduler::OnLoadCompleted(const EventPtr& event) {
+    auto load_completed_event = std::static_pointer_cast<LoadCompletedEvent>(event);
+    if (auto resource = event->resource_.lock()) {
+        resource->WakeupExecutor();
+
+        auto task_table_type = load_completed_event->task_table_item_->task->label()->Type();
+        switch (task_table_type) {
+            case TaskLabelType::DEFAULT: {
+                Action::DefaultLabelTaskScheduler(res_mgr_, resource, load_completed_event);
+                break;
+            }
+            case TaskLabelType::SPECIFIED_RESOURCE: {
+                Action::SpecifiedResourceLabelTaskScheduler(res_mgr_, resource, load_completed_event);
+                break;
+            }
+            case TaskLabelType::BROADCAST: {
+                if (resource->HasExecutor() == false) {
+                    load_completed_event->task_table_item_->Move();
+                }
+                Action::PushTaskToAllNeighbour(load_completed_event->task_table_item_->task, resource);
+                break;
+            }
+            default: { break; }
+        }
+        resource->WakeupLoader();
+    }
+}
+
+void
+Scheduler::OnStartUp(const EventPtr& event) {
+    if (auto resource = event->resource_.lock()) {
+        resource->WakeupLoader();
+    }
+}
+
+void
+Scheduler::OnFinishTask(const EventPtr& event) {
+    if (auto resource = event->resource_.lock()) {
+        resource->WakeupLoader();
+    }
+}
+
+void
+Scheduler::OnTaskTableUpdated(const EventPtr& event) {
+    if (auto resource = event->resource_.lock()) {
+        resource->WakeupLoader();
+    }
+}
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/Scheduler.h b/core/src/scheduler/Scheduler.h
new file mode 100644
index 0000000000..5b222cc41a
--- /dev/null
+++ b/core/src/scheduler/Scheduler.h
@@ -0,0 +1,134 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <memory>
+#include <mutex>
+#include <queue>
+#include <string>
+#include <thread>
+#include <unordered_map>
+
+#include "ResourceMgr.h"
+#include "resource/Resource.h"
+#include "utils/Log.h"
+
+namespace milvus {
+namespace scheduler {
+
+// TODO(wxyu): refactor, not friendly to unittest, logical in framework code
+class Scheduler {
+ public:
+    explicit Scheduler(ResourceMgrWPtr res_mgr);
+
+    Scheduler(const Scheduler&) = delete;
+    Scheduler(Scheduler&&) = delete;
+
+    /*
+     * Start worker thread;
+     */
+    void
+    Start();
+
+    /*
+     * Stop worker thread, join it;
+     */
+    void
+    Stop();
+
+    /*
+     * Post event to scheduler event queue;
+     */
+    void
+    PostEvent(const EventPtr& event);
+
+    /*
+     * Dump as string;
+     */
+    std::string
+    Dump();
+
+ private:
+    /******** Events ********/
+
+    /*
+     * Process start up events;
+     *
+     * Actions:
+     * Pull task from neighbours;
+     */
+    void
+    OnStartUp(const EventPtr& event);
+
+    /*
+     * Process finish task events;
+     *
+     * Actions:
+     * Pull task from neighbours;
+     */
+    void
+    OnFinishTask(const EventPtr& event);
+
+    /*
+     * Process copy completed events;
+     *
+     * Actions:
+     * Mark task source MOVED;
+     * Pull task from neighbours;
+     */
+    void
+    OnLoadCompleted(const EventPtr& event);
+
+    /*
+     * Process task table updated events, which happened on task_table->put;
+     *
+     * Actions:
+     * Push task to neighbours;
+     */
+    void
+    OnTaskTableUpdated(const EventPtr& event);
+
+ private:
+    /*
+     * Dispatch event to event handler;
+     */
+    void
+    Process(const EventPtr& event);
+
+    /*
+     * Called by worker_thread_;
+     */
+    void
+    worker_function();
+
+ private:
+    bool running_;
+
+    std::unordered_map<uint64_t, std::function<void(EventPtr)>> event_register_;
+
+    ResourceMgrWPtr res_mgr_;
+    std::queue<EventPtr> event_queue_;
+    std::thread worker_thread_;
+    std::mutex event_mutex_;
+    std::condition_variable event_cv_;
+};
+
+using SchedulerPtr = std::shared_ptr<Scheduler>;
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/TaskCreator.cpp b/core/src/scheduler/TaskCreator.cpp
new file mode 100644
index 0000000000..40cfa9aac6
--- /dev/null
+++ b/core/src/scheduler/TaskCreator.cpp
@@ -0,0 +1,86 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "scheduler/TaskCreator.h"
+#include "SchedInst.h"
+#include "tasklabel/BroadcastLabel.h"
+#include "tasklabel/DefaultLabel.h"
+#include "tasklabel/SpecResLabel.h"
+
+namespace milvus {
+namespace scheduler {
+
+std::vector<TaskPtr>
+TaskCreator::Create(const JobPtr& job) {
+    switch (job->type()) {
+        case JobType::SEARCH: {
+            return Create(std::static_pointer_cast<SearchJob>(job));
+        }
+        case JobType::DELETE: {
+            return Create(std::static_pointer_cast<DeleteJob>(job));
+        }
+        case JobType::BUILD: {
+            return Create(std::static_pointer_cast<BuildIndexJob>(job));
+        }
+        default: {
+            // TODO(wxyu): error
+            return std::vector<TaskPtr>();
+        }
+    }
+}
+
+std::vector<TaskPtr>
+TaskCreator::Create(const SearchJobPtr& job) {
+    std::vector<TaskPtr> tasks;
+    for (auto& index_file : job->index_files()) {
+        auto label = std::make_shared<DefaultLabel>();
+        auto task = std::make_shared<XSearchTask>(index_file.second, label);
+        task->job_ = job;
+        tasks.emplace_back(task);
+    }
+
+    return tasks;
+}
+
+std::vector<TaskPtr>
+TaskCreator::Create(const DeleteJobPtr& job) {
+    std::vector<TaskPtr> tasks;
+    auto label = std::make_shared<BroadcastLabel>();
+    auto task = std::make_shared<XDeleteTask>(job, label);
+    task->job_ = job;
+    tasks.emplace_back(task);
+
+    return tasks;
+}
+
+std::vector<TaskPtr>
+TaskCreator::Create(const BuildIndexJobPtr& job) {
+    std::vector<TaskPtr> tasks;
+    // TODO(yukun): remove "disk" hardcode here
+    ResourcePtr res_ptr = ResMgrInst::GetInstance()->GetResource("disk");
+
+    for (auto& to_index_file : job->to_index_files()) {
+        auto label = std::make_shared<SpecResLabel>(std::weak_ptr<Resource>(res_ptr));
+        auto task = std::make_shared<XBuildIndexTask>(to_index_file.second, label);
+        task->job_ = job;
+        tasks.emplace_back(task);
+    }
+    return tasks;
+}
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/TaskCreator.h b/core/src/scheduler/TaskCreator.h
new file mode 100644
index 0000000000..ef71d9a3d3
--- /dev/null
+++ b/core/src/scheduler/TaskCreator.h
@@ -0,0 +1,58 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+#pragma once
+
+#include <condition_variable>
+#include <deque>
+#include <list>
+#include <memory>
+#include <mutex>
+#include <queue>
+#include <string>
+#include <thread>
+#include <unordered_map>
+#include <vector>
+
+#include "job/DeleteJob.h"
+#include "job/Job.h"
+#include "job/SearchJob.h"
+#include "task/BuildIndexTask.h"
+#include "task/DeleteTask.h"
+#include "task/SearchTask.h"
+#include "task/Task.h"
+
+namespace milvus {
+namespace scheduler {
+
+class TaskCreator {
+ public:
+    static std::vector<TaskPtr>
+    Create(const JobPtr& job);
+
+ public:
+    static std::vector<TaskPtr>
+    Create(const SearchJobPtr& job);
+
+    static std::vector<TaskPtr>
+    Create(const DeleteJobPtr& job);
+
+    static std::vector<TaskPtr>
+    Create(const BuildIndexJobPtr& job);
+};
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/TaskTable.cpp b/core/src/scheduler/TaskTable.cpp
new file mode 100644
index 0000000000..cad7ce3a74
--- /dev/null
+++ b/core/src/scheduler/TaskTable.cpp
@@ -0,0 +1,275 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "scheduler/TaskTable.h"
+#include "Utils.h"
+#include "event/TaskTableUpdatedEvent.h"
+#include "scheduler/SchedInst.h"
+#include "utils/Log.h"
+
+#include <ctime>
+#include <sstream>
+#include <vector>
+
+namespace milvus {
+namespace scheduler {
+
+std::string
+ToString(TaskTableItemState state) {
+    switch (state) {
+        case TaskTableItemState::INVALID:
+            return "INVALID";
+        case TaskTableItemState::START:
+            return "START";
+        case TaskTableItemState::LOADING:
+            return "LOADING";
+        case TaskTableItemState::LOADED:
+            return "LOADED";
+        case TaskTableItemState::EXECUTING:
+            return "EXECUTING";
+        case TaskTableItemState::EXECUTED:
+            return "EXECUTED";
+        case TaskTableItemState::MOVING:
+            return "MOVING";
+        case TaskTableItemState::MOVED:
+            return "MOVED";
+        default:
+            return "";
+    }
+}
+
+json
+TaskTimestamp::Dump() {
+    json ret{
+        {"start", start},       {"load", load}, {"loaded", loaded}, {"execute", execute},
+        {"executed", executed}, {"move", move}, {"moved", moved},   {"finish", finish},
+    };
+    return ret;
+}
+
+bool
+TaskTableItem::IsFinish() {
+    return state == TaskTableItemState::MOVED || state == TaskTableItemState::EXECUTED;
+}
+
+bool
+TaskTableItem::Load() {
+    std::unique_lock<std::mutex> lock(mutex);
+    if (state == TaskTableItemState::START) {
+        state = TaskTableItemState::LOADING;
+        lock.unlock();
+        timestamp.load = get_current_timestamp();
+        return true;
+    }
+    return false;
+}
+
+bool
+TaskTableItem::Loaded() {
+    std::unique_lock<std::mutex> lock(mutex);
+    if (state == TaskTableItemState::LOADING) {
+        state = TaskTableItemState::LOADED;
+        lock.unlock();
+        timestamp.loaded = get_current_timestamp();
+        return true;
+    }
+    return false;
+}
+
+bool
+TaskTableItem::Execute() {
+    std::unique_lock<std::mutex> lock(mutex);
+    if (state == TaskTableItemState::LOADED) {
+        state = TaskTableItemState::EXECUTING;
+        lock.unlock();
+        timestamp.execute = get_current_timestamp();
+        return true;
+    }
+    return false;
+}
+
+bool
+TaskTableItem::Executed() {
+    std::unique_lock<std::mutex> lock(mutex);
+    if (state == TaskTableItemState::EXECUTING) {
+        state = TaskTableItemState::EXECUTED;
+        lock.unlock();
+        timestamp.executed = get_current_timestamp();
+        timestamp.finish = get_current_timestamp();
+        return true;
+    }
+    return false;
+}
+
+bool
+TaskTableItem::Move() {
+    std::unique_lock<std::mutex> lock(mutex);
+    if (state == TaskTableItemState::LOADED) {
+        state = TaskTableItemState::MOVING;
+        lock.unlock();
+        timestamp.move = get_current_timestamp();
+        return true;
+    }
+    return false;
+}
+
+bool
+TaskTableItem::Moved() {
+    std::unique_lock<std::mutex> lock(mutex);
+    if (state == TaskTableItemState::MOVING) {
+        state = TaskTableItemState::MOVED;
+        lock.unlock();
+        timestamp.moved = get_current_timestamp();
+        timestamp.finish = get_current_timestamp();
+        return true;
+    }
+    return false;
+}
+
+json
+TaskTableItem::Dump() {
+    json ret{
+        {"id", id},
+        {"task", (int64_t)task.get()},
+        {"state", ToString(state)},
+        {"timestamp", timestamp.Dump()},
+    };
+    return ret;
+}
+
+std::vector<uint64_t>
+TaskTable::PickToLoad(uint64_t limit) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    size_t count = 0;
+    for (uint64_t j = last_finish_ + 1; j < table_.size(); ++j) {
+        if (not table_[j]) {
+            SERVER_LOG_WARNING << "table[" << j << "] is nullptr";
+        }
+
+        if (table_[j]->task->path().Current() == "cpu") {
+            if (table_[j]->task->Type() == TaskType::BuildIndexTask && BuildMgrInst::GetInstance()->numoftasks() < 1) {
+                return std::vector<uint64_t>();
+            }
+        }
+
+        if (table_[j]->state == TaskTableItemState::LOADED) {
+            ++count;
+            if (count > 2)
+                return std::vector<uint64_t>();
+        }
+    }
+
+    std::vector<uint64_t> indexes;
+    bool cross = false;
+    for (uint64_t i = last_finish_ + 1, count = 0; i < table_.size() && count < limit; ++i) {
+        if (not cross && table_[i]->IsFinish()) {
+            last_finish_ = i;
+        } else if (table_[i]->state == TaskTableItemState::START) {
+            auto task = table_[i]->task;
+            if (task->Type() == TaskType::BuildIndexTask && task->path().Current() == "cpu") {
+                if (BuildMgrInst::GetInstance()->numoftasks() == 0) {
+                    break;
+                } else {
+                    cross = true;
+                    indexes.push_back(i);
+                    ++count;
+                    BuildMgrInst::GetInstance()->take();
+                }
+            } else {
+                cross = true;
+                indexes.push_back(i);
+                ++count;
+            }
+        }
+    }
+    return indexes;
+}
+
+std::vector<uint64_t>
+TaskTable::PickToExecute(uint64_t limit) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    std::vector<uint64_t> indexes;
+    bool cross = false;
+    for (uint64_t i = last_finish_ + 1, count = 0; i < table_.size() && count < limit; ++i) {
+        if (not cross && table_[i]->IsFinish()) {
+            last_finish_ = i;
+        } else if (table_[i]->state == TaskTableItemState::LOADED) {
+            cross = true;
+            indexes.push_back(i);
+            ++count;
+        }
+    }
+    return indexes;
+}
+
+void
+TaskTable::Put(TaskPtr task) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    auto item = std::make_shared<TaskTableItem>();
+    item->id = id_++;
+    item->task = std::move(task);
+    item->state = TaskTableItemState::START;
+    item->timestamp.start = get_current_timestamp();
+    table_.push_back(item);
+    if (subscriber_) {
+        subscriber_();
+    }
+}
+
+void
+TaskTable::Put(std::vector<TaskPtr>& tasks) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    for (auto& task : tasks) {
+        auto item = std::make_shared<TaskTableItem>();
+        item->id = id_++;
+        item->task = std::move(task);
+        item->state = TaskTableItemState::START;
+        item->timestamp.start = get_current_timestamp();
+        table_.push_back(item);
+    }
+    if (subscriber_) {
+        subscriber_();
+    }
+}
+
+TaskTableItemPtr
+TaskTable::Get(uint64_t index) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    return table_[index];
+}
+
+// void
+// TaskTable::Clear() {
+//// find first task is NOT (done or moved), erase from begin to it;
+////        auto iterator = table_.begin();
+////        while (iterator->state == TaskTableItemState::EXECUTED or
+////            iterator->state == TaskTableItemState::MOVED)
+////            iterator++;
+////        table_.erase(table_.begin(), iterator);
+//}
+
+json
+TaskTable::Dump() {
+    json ret;
+    for (auto& item : table_) {
+        ret.push_back(item->Dump());
+    }
+    return ret;
+}
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/TaskTable.h b/core/src/scheduler/TaskTable.h
new file mode 100644
index 0000000000..307528fffb
--- /dev/null
+++ b/core/src/scheduler/TaskTable.h
@@ -0,0 +1,263 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <deque>
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "event/Event.h"
+#include "interface/interfaces.h"
+#include "task/SearchTask.h"
+
+namespace milvus {
+namespace scheduler {
+
+enum class TaskTableItemState {
+    INVALID,
+    START,      // idle
+    LOADING,    // loading data from other resource
+    LOADED,     // ready to exec or move
+    EXECUTING,  // executing, locking util executed or failed
+    EXECUTED,   // executed, termination state
+    MOVING,     // moving to another resource, locking util executed or failed
+    MOVED,      // moved, termination state
+};
+
+struct TaskTimestamp : public interface::dumpable {
+    uint64_t start = 0;
+    uint64_t move = 0;
+    uint64_t moved = 0;
+    uint64_t load = 0;
+    uint64_t loaded = 0;
+    uint64_t execute = 0;
+    uint64_t executed = 0;
+    uint64_t finish = 0;
+
+    json
+    Dump() override;
+};
+
+struct TaskTableItem : public interface::dumpable {
+    TaskTableItem() : id(0), task(nullptr), state(TaskTableItemState::INVALID), mutex() {
+    }
+
+    TaskTableItem(const TaskTableItem& src) = delete;
+    TaskTableItem(TaskTableItem&&) = delete;
+
+    uint64_t id;               // auto increment from 0;
+    TaskPtr task;              // the task;
+    TaskTableItemState state;  // the state;
+    std::mutex mutex;
+    TaskTimestamp timestamp;
+
+    bool
+    IsFinish();
+
+    bool
+    Load();
+
+    bool
+    Loaded();
+
+    bool
+    Execute();
+
+    bool
+    Executed();
+
+    bool
+    Move();
+
+    bool
+    Moved();
+
+    json
+    Dump() override;
+};
+
+using TaskTableItemPtr = std::shared_ptr<TaskTableItem>;
+
+class TaskTable : public interface::dumpable {
+ public:
+    TaskTable() = default;
+
+    TaskTable(const TaskTable&) = delete;
+    TaskTable(TaskTable&&) = delete;
+
+    inline void
+    RegisterSubscriber(std::function<void(void)> subscriber) {
+        subscriber_ = std::move(subscriber);
+    }
+
+    /*
+     * Put one task;
+     */
+    void
+    Put(TaskPtr task);
+
+    /*
+     * Put tasks back of task table;
+     * Called by DBImpl;
+     */
+    void
+    Put(std::vector<TaskPtr>& tasks);
+
+    /*
+     * Return task table item reference;
+     */
+    TaskTableItemPtr
+    Get(uint64_t index);
+
+    /*
+     * TODO(wxyu): BIG GC
+     * Remove sequence task which is DONE or MOVED from front;
+     * Called by ?
+     */
+    //    void
+    //    Clear();
+
+    /*
+     * Return true if task table empty, otherwise false;
+     */
+    inline bool
+    Empty() {
+        return table_.empty();
+    }
+
+    /*
+     * Return size of task table;
+     */
+    inline size_t
+    Size() {
+        return table_.size();
+    }
+
+ public:
+    TaskTableItemPtr& operator[](uint64_t index) {
+        std::lock_guard<std::mutex> lock(mutex_);
+        return table_[index];
+    }
+
+    std::deque<TaskTableItemPtr>::iterator
+    begin() {
+        return table_.begin();
+    }
+
+    std::deque<TaskTableItemPtr>::iterator
+    end() {
+        return table_.end();
+    }
+
+ public:
+    std::vector<uint64_t>
+    PickToLoad(uint64_t limit);
+
+    std::vector<uint64_t>
+    PickToExecute(uint64_t limit);
+
+ public:
+    /******** Action ********/
+
+    // TODO(wxyu): bool to Status
+    /*
+     * Load a task;
+     * Set state loading;
+     * Called by loader;
+     */
+    inline bool
+    Load(uint64_t index) {
+        return table_[index]->Load();
+    }
+
+    /*
+     * Load task finished;
+     * Set state loaded;
+     * Called by loader;
+     */
+    inline bool
+    Loaded(uint64_t index) {
+        return table_[index]->Loaded();
+    }
+
+    /*
+     * Execute a task;
+     * Set state executing;
+     * Called by executor;
+     */
+    inline bool
+    Execute(uint64_t index) {
+        return table_[index]->Execute();
+    }
+
+    /*
+     * Execute task finished;
+     * Set state executed;
+     * Called by executor;
+     */
+    inline bool
+    Executed(uint64_t index) {
+        return table_[index]->Executed();
+    }
+
+    /*
+     * Move a task;
+     * Set state moving;
+     * Called by scheduler;
+     */
+
+    inline bool
+    Move(uint64_t index) {
+        return table_[index]->Move();
+    }
+
+    /*
+     * Move task finished;
+     * Set state moved;
+     * Called by scheduler;
+     */
+    inline bool
+    Moved(uint64_t index) {
+        return table_[index]->Moved();
+    }
+
+ public:
+    /*
+     * Dump;
+     */
+    json
+    Dump() override;
+
+ private:
+    std::uint64_t id_ = 0;
+    mutable std::mutex mutex_;
+    std::deque<TaskTableItemPtr> table_;
+    std::function<void(void)> subscriber_ = nullptr;
+
+    // cache last finish avoid Pick task from begin always
+    // pick from (last_finish_ + 1)
+    // init with -1, pick from (last_finish_ + 1) = 0
+    uint64_t last_finish_ = -1;
+};
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/Utils.cpp b/core/src/scheduler/Utils.cpp
new file mode 100644
index 0000000000..998e545ba5
--- /dev/null
+++ b/core/src/scheduler/Utils.cpp
@@ -0,0 +1,83 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "scheduler/Utils.h"
+#include "server/Config.h"
+#include "utils/Log.h"
+
+#include <cuda_runtime.h>
+#include <chrono>
+#include <set>
+#include <string>
+
+namespace milvus {
+namespace scheduler {
+
+uint64_t
+get_current_timestamp() {
+    std::chrono::time_point<std::chrono::system_clock> now = std::chrono::system_clock::now();
+    auto duration = now.time_since_epoch();
+    auto millis = std::chrono::duration_cast<std::chrono::milliseconds>(duration).count();
+    return millis;
+}
+
+uint64_t
+get_num_gpu() {
+    int n_devices = 0;
+    cudaGetDeviceCount(&n_devices);
+    return n_devices;
+}
+
+std::vector<uint64_t>
+get_gpu_pool() {
+    std::vector<uint64_t> gpu_pool;
+
+    server::Config& config = server::Config::GetInstance();
+    std::vector<std::string> pool;
+    Status s = config.GetResourceConfigSearchResources(pool);
+    if (!s.ok()) {
+        SERVER_LOG_ERROR << s.message();
+    }
+
+    std::set<uint64_t> gpu_ids;
+
+    for (auto& resource : pool) {
+        if (resource == "cpu") {
+            continue;
+        } else {
+            if (resource.length() < 4 || resource.substr(0, 3) != "gpu") {
+                // error
+                exit(-1);
+            }
+            auto gpu_id = std::stoi(resource.substr(3));
+            if (gpu_id >= scheduler::get_num_gpu()) {
+                // error
+                exit(-1);
+            }
+            gpu_ids.insert(gpu_id);
+        }
+    }
+
+    for (auto& gpu_id : gpu_ids) {
+        gpu_pool.push_back(gpu_id);
+    }
+
+    return gpu_pool;
+}
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/Utils.h b/core/src/scheduler/Utils.h
new file mode 100644
index 0000000000..24876eeb96
--- /dev/null
+++ b/core/src/scheduler/Utils.h
@@ -0,0 +1,34 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 <cstdint>
+#include <vector>
+
+namespace milvus {
+namespace scheduler {
+
+uint64_t
+get_current_timestamp();
+
+uint64_t
+get_num_gpu();
+
+std::vector<uint64_t>
+get_gpu_pool();
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/action/Action.h b/core/src/scheduler/action/Action.h
new file mode 100644
index 0000000000..51c788f82f
--- /dev/null
+++ b/core/src/scheduler/action/Action.h
@@ -0,0 +1,48 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "scheduler/ResourceMgr.h"
+#include "scheduler/resource/Resource.h"
+
+#include <memory>
+
+namespace milvus {
+namespace scheduler {
+
+class Action {
+ public:
+    static void
+    PushTaskToNeighbourRandomly(const TaskPtr& task, const ResourcePtr& self);
+
+    static void
+    PushTaskToAllNeighbour(const TaskPtr& task, const ResourcePtr& self);
+
+    static void
+    PushTaskToResource(const TaskPtr& task, const ResourcePtr& dest);
+
+    static void
+    DefaultLabelTaskScheduler(ResourceMgrWPtr res_mgr, ResourcePtr resource, std::shared_ptr<LoadCompletedEvent> event);
+
+    static void
+    SpecifiedResourceLabelTaskScheduler(ResourceMgrWPtr res_mgr, ResourcePtr resource,
+                                        std::shared_ptr<LoadCompletedEvent> event);
+};
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/action/PushTaskToNeighbour.cpp b/core/src/scheduler/action/PushTaskToNeighbour.cpp
new file mode 100644
index 0000000000..c64e81dcfa
--- /dev/null
+++ b/core/src/scheduler/action/PushTaskToNeighbour.cpp
@@ -0,0 +1,221 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 <list>
+#include <random>
+#include "../Algorithm.h"
+#include "Action.h"
+#include "scheduler/tasklabel/SpecResLabel.h"
+#include "src/cache/GpuCacheMgr.h"
+#include "src/server/Config.h"
+
+namespace milvus {
+namespace scheduler {
+
+std::vector<ResourcePtr>
+get_neighbours(const ResourcePtr& self) {
+    std::vector<ResourcePtr> neighbours;
+    for (auto& neighbour_node : self->GetNeighbours()) {
+        auto node = neighbour_node.neighbour_node.lock();
+        if (not node)
+            continue;
+
+        auto resource = std::static_pointer_cast<Resource>(node);
+        //        if (not resource->HasExecutor()) continue;
+
+        neighbours.emplace_back(resource);
+    }
+    return neighbours;
+}
+
+std::vector<std::pair<ResourcePtr, Connection>>
+get_neighbours_with_connetion(const ResourcePtr& self) {
+    std::vector<std::pair<ResourcePtr, Connection>> neighbours;
+    for (auto& neighbour_node : self->GetNeighbours()) {
+        auto node = neighbour_node.neighbour_node.lock();
+        if (not node)
+            continue;
+
+        auto resource = std::static_pointer_cast<Resource>(node);
+        //        if (not resource->HasExecutor()) continue;
+        Connection conn = neighbour_node.connection;
+        neighbours.emplace_back(std::make_pair(resource, conn));
+    }
+    return neighbours;
+}
+
+void
+Action::PushTaskToNeighbourRandomly(const TaskPtr& task, const ResourcePtr& self) {
+    auto neighbours = get_neighbours_with_connetion(self);
+    if (not neighbours.empty()) {
+        std::vector<uint64_t> speeds;
+        uint64_t total_speed = 0;
+        for (auto& neighbour : neighbours) {
+            uint64_t speed = neighbour.second.speed();
+            speeds.emplace_back(speed);
+            total_speed += speed;
+        }
+
+        unsigned seed1 = std::chrono::system_clock::now().time_since_epoch().count();
+        std::mt19937 mt(seed1);
+        std::uniform_int_distribution<int> dist(0, total_speed);
+        uint64_t index = 0;
+        int64_t rd_speed = dist(mt);
+        for (uint64_t i = 0; i < speeds.size(); ++i) {
+            rd_speed -= speeds[i];
+            if (rd_speed <= 0) {
+                neighbours[i].first->task_table().Put(task);
+                return;
+            }
+        }
+
+    } else {
+        // TODO(wxyu): process
+    }
+}
+
+void
+Action::PushTaskToAllNeighbour(const TaskPtr& task, const ResourcePtr& self) {
+    auto neighbours = get_neighbours(self);
+    for (auto& neighbour : neighbours) {
+        neighbour->task_table().Put(task);
+    }
+}
+
+void
+Action::PushTaskToResource(const TaskPtr& task, const ResourcePtr& dest) {
+    dest->task_table().Put(task);
+}
+
+void
+Action::DefaultLabelTaskScheduler(ResourceMgrWPtr res_mgr, ResourcePtr resource,
+                                  std::shared_ptr<LoadCompletedEvent> event) {
+    if (not resource->HasExecutor() && event->task_table_item_->Move()) {
+        auto task = event->task_table_item_->task;
+        auto search_task = std::static_pointer_cast<XSearchTask>(task);
+        bool moved = false;
+
+        // to support test task, REFACTOR
+        if (resource->type() == ResourceType::CPU) {
+            if (auto index_engine = search_task->index_engine_) {
+                auto location = index_engine->GetLocation();
+
+                for (auto i = 0; i < res_mgr.lock()->GetNumGpuResource(); ++i) {
+                    auto index = milvus::cache::GpuCacheMgr::GetInstance(i)->GetIndex(location);
+                    if (index != nullptr) {
+                        moved = true;
+                        auto dest_resource = res_mgr.lock()->GetResource(ResourceType::GPU, i);
+                        PushTaskToResource(event->task_table_item_->task, dest_resource);
+                        break;
+                    }
+                }
+            }
+        }
+
+        if (not moved) {
+            PushTaskToNeighbourRandomly(task, resource);
+        }
+    }
+}
+
+void
+Action::SpecifiedResourceLabelTaskScheduler(ResourceMgrWPtr res_mgr, ResourcePtr resource,
+                                            std::shared_ptr<LoadCompletedEvent> event) {
+    auto task = event->task_table_item_->task;
+    if (resource->type() == ResourceType::DISK) {
+        // step 1: calculate shortest path per resource, from disk to compute resource
+        auto compute_resources = res_mgr.lock()->GetComputeResources();
+        std::vector<std::vector<std::string>> paths;
+        std::vector<uint64_t> transport_costs;
+        for (auto& res : compute_resources) {
+            std::vector<std::string> path;
+            uint64_t transport_cost = ShortestPath(resource, res, res_mgr.lock(), path);
+            transport_costs.push_back(transport_cost);
+            paths.emplace_back(path);
+        }
+        //        if (task->job_.lock()->type() == JobType::SEARCH) {
+        //            auto label = task->label();
+        //            auto spec_label = std::static_pointer_cast<SpecResLabel>(label);
+        //            if (spec_label->resource().lock()->type() == ResourceType::CPU) {
+        //                std::vector<std::string> spec_path;
+        //                spec_path.push_back(spec_label->resource().lock()->name());
+        //                spec_path.push_back(resource->name());
+        //                task->path() = Path(spec_path, spec_path.size() - 1);
+        //            } else {
+        //                // step 2: select min cost, cost(resource) = avg_cost * task_to_do + transport_cost
+        //                uint64_t min_cost = std::numeric_limits<uint64_t>::max();
+        //                uint64_t min_cost_idx = 0;
+        //                for (uint64_t i = 0; i < compute_resources.size(); ++i) {
+        //                    if (compute_resources[i]->TotalTasks() == 0) {
+        //                        min_cost_idx = i;
+        //                        break;
+        //                    }
+        //                    uint64_t cost = compute_resources[i]->TaskAvgCost() *
+        //                    compute_resources[i]->NumOfTaskToExec() +
+        //                                    transport_costs[i];
+        //                    if (min_cost > cost) {
+        //                        min_cost = cost;
+        //                        min_cost_idx = i;
+        //                    }
+        //                }
+        //
+        //                // step 3: set path in task
+        //                Path task_path(paths[min_cost_idx], paths[min_cost_idx].size() - 1);
+        //                task->path() = task_path;
+        //            }
+        //
+        //        } else
+        if (task->job_.lock()->type() == JobType::BUILD) {
+            // step2: Read device id in config
+            // get build index gpu resource
+            server::Config& config = server::Config::GetInstance();
+            int32_t build_index_gpu;
+            Status stat = config.GetResourceConfigIndexBuildDevice(build_index_gpu);
+
+            bool find_gpu_res = false;
+            if (res_mgr.lock()->GetResource(ResourceType::GPU, build_index_gpu) != nullptr) {
+                for (uint64_t i = 0; i < compute_resources.size(); ++i) {
+                    if (compute_resources[i]->name() ==
+                        res_mgr.lock()->GetResource(ResourceType::GPU, build_index_gpu)->name()) {
+                        find_gpu_res = true;
+                        Path task_path(paths[i], paths[i].size() - 1);
+                        task->path() = task_path;
+                        break;
+                    }
+                }
+            }
+            if (not find_gpu_res) {
+                task->path() = Path(paths[0], paths[0].size() - 1);
+            }
+        }
+    }
+
+    if (resource->name() == task->path().Last()) {
+        resource->WakeupExecutor();
+    } else {
+        auto next_res_name = task->path().Next();
+        auto next_res = res_mgr.lock()->GetResource(next_res_name);
+        //        if (event->task_table_item_->Move()) {
+        //            next_res->task_table().Put(task);
+        //        }
+        event->task_table_item_->Move();
+        next_res->task_table().Put(task);
+    }
+}
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/event/Event.h b/core/src/scheduler/event/Event.h
new file mode 100644
index 0000000000..5b1f37fb99
--- /dev/null
+++ b/core/src/scheduler/event/Event.h
@@ -0,0 +1,55 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include <utility>
+
+namespace milvus {
+namespace scheduler {
+
+enum class EventType { START_UP, LOAD_COMPLETED, FINISH_TASK, TASK_TABLE_UPDATED };
+
+class Resource;
+
+class Event {
+ public:
+    explicit Event(EventType type, std::weak_ptr<Resource> resource) : type_(type), resource_(std::move(resource)) {
+    }
+
+    inline EventType
+    Type() const {
+        return type_;
+    }
+
+    virtual std::string
+    Dump() const = 0;
+
+    friend std::ostream&
+    operator<<(std::ostream& out, const Event& event);
+
+ public:
+    EventType type_;
+    std::weak_ptr<Resource> resource_;
+};
+
+using EventPtr = std::shared_ptr<Event>;
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/event/EventDump.cpp b/core/src/scheduler/event/EventDump.cpp
new file mode 100644
index 0000000000..91e2da369a
--- /dev/null
+++ b/core/src/scheduler/event/EventDump.cpp
@@ -0,0 +1,58 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "Event.h"
+#include "FinishTaskEvent.h"
+#include "LoadCompletedEvent.h"
+#include "StartUpEvent.h"
+#include "TaskTableUpdatedEvent.h"
+
+namespace milvus {
+namespace scheduler {
+
+std::ostream&
+operator<<(std::ostream& out, const Event& event) {
+    out << event.Dump();
+    return out;
+}
+
+std::ostream&
+operator<<(std::ostream& out, const StartUpEvent& event) {
+    out << event.Dump();
+    return out;
+}
+
+std::ostream&
+operator<<(std::ostream& out, const LoadCompletedEvent& event) {
+    out << event.Dump();
+    return out;
+}
+
+std::ostream&
+operator<<(std::ostream& out, const FinishTaskEvent& event) {
+    out << event.Dump();
+    return out;
+}
+
+std::ostream&
+operator<<(std::ostream& out, const TaskTableUpdatedEvent& event) {
+    out << event.Dump();
+    return out;
+}
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/event/FinishTaskEvent.h b/core/src/scheduler/event/FinishTaskEvent.h
new file mode 100644
index 0000000000..1b2d8f9818
--- /dev/null
+++ b/core/src/scheduler/event/FinishTaskEvent.h
@@ -0,0 +1,49 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "scheduler/TaskTable.h"
+#include "scheduler/event/Event.h"
+
+#include <memory>
+#include <string>
+#include <utility>
+
+namespace milvus {
+namespace scheduler {
+
+class FinishTaskEvent : public Event {
+ public:
+    FinishTaskEvent(std::weak_ptr<Resource> resource, TaskTableItemPtr task_table_item)
+        : Event(EventType::FINISH_TASK, std::move(resource)), task_table_item_(std::move(task_table_item)) {
+    }
+
+    inline std::string
+    Dump() const override {
+        return "<FinishTaskEvent>";
+    }
+
+    friend std::ostream&
+    operator<<(std::ostream& out, const FinishTaskEvent& event);
+
+ public:
+    TaskTableItemPtr task_table_item_;
+};
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/event/LoadCompletedEvent.h b/core/src/scheduler/event/LoadCompletedEvent.h
new file mode 100644
index 0000000000..5a701e0dfc
--- /dev/null
+++ b/core/src/scheduler/event/LoadCompletedEvent.h
@@ -0,0 +1,49 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "scheduler/TaskTable.h"
+#include "scheduler/event/Event.h"
+
+#include <memory>
+#include <string>
+#include <utility>
+
+namespace milvus {
+namespace scheduler {
+
+class LoadCompletedEvent : public Event {
+ public:
+    LoadCompletedEvent(std::weak_ptr<Resource> resource, TaskTableItemPtr task_table_item)
+        : Event(EventType::LOAD_COMPLETED, std::move(resource)), task_table_item_(std::move(task_table_item)) {
+    }
+
+    inline std::string
+    Dump() const override {
+        return "<LoadCompletedEvent>";
+    }
+
+    friend std::ostream&
+    operator<<(std::ostream& out, const LoadCompletedEvent& event);
+
+ public:
+    TaskTableItemPtr task_table_item_;
+};
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/event/StartUpEvent.h b/core/src/scheduler/event/StartUpEvent.h
new file mode 100644
index 0000000000..c4abb4e27c
--- /dev/null
+++ b/core/src/scheduler/event/StartUpEvent.h
@@ -0,0 +1,44 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "scheduler/event/Event.h"
+
+#include <memory>
+#include <string>
+#include <utility>
+
+namespace milvus {
+namespace scheduler {
+
+class StartUpEvent : public Event {
+ public:
+    explicit StartUpEvent(std::weak_ptr<Resource> resource) : Event(EventType::START_UP, std::move(resource)) {
+    }
+
+    inline std::string
+    Dump() const override {
+        return "<StartUpEvent>";
+    }
+
+    friend std::ostream&
+    operator<<(std::ostream& out, const StartUpEvent& event);
+};
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/event/TaskTableUpdatedEvent.h b/core/src/scheduler/event/TaskTableUpdatedEvent.h
new file mode 100644
index 0000000000..ed64a42d89
--- /dev/null
+++ b/core/src/scheduler/event/TaskTableUpdatedEvent.h
@@ -0,0 +1,45 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "Event.h"
+
+#include <memory>
+#include <string>
+#include <utility>
+
+namespace milvus {
+namespace scheduler {
+
+class TaskTableUpdatedEvent : public Event {
+ public:
+    explicit TaskTableUpdatedEvent(std::weak_ptr<Resource> resource)
+        : Event(EventType::TASK_TABLE_UPDATED, std::move(resource)) {
+    }
+
+    inline std::string
+    Dump() const override {
+        return "<TaskTableUpdatedEvent>";
+    }
+
+    friend std::ostream&
+    operator<<(std::ostream& out, const TaskTableUpdatedEvent& event);
+};
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/interface/interfaces.h b/core/src/scheduler/interface/interfaces.h
new file mode 100644
index 0000000000..68e5af8cdb
--- /dev/null
+++ b/core/src/scheduler/interface/interfaces.h
@@ -0,0 +1,44 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+#pragma once
+
+#include <condition_variable>
+#include <deque>
+#include <list>
+#include <memory>
+#include <mutex>
+#include <queue>
+#include <string>
+#include <thread>
+#include <unordered_map>
+#include <vector>
+
+#include "utils/Json.h"
+
+namespace milvus {
+namespace interface {
+
+struct dumpable {
+    virtual ~dumpable() {
+    }
+
+    virtual json
+    Dump() = 0;
+};
+
+}  // namespace interface
+}  // namespace milvus
diff --git a/core/src/scheduler/job/BuildIndexJob.cpp b/core/src/scheduler/job/BuildIndexJob.cpp
new file mode 100644
index 0000000000..423121c5fb
--- /dev/null
+++ b/core/src/scheduler/job/BuildIndexJob.cpp
@@ -0,0 +1,58 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "scheduler/job/BuildIndexJob.h"
+#include "utils/Log.h"
+
+#include <utility>
+
+namespace milvus {
+namespace scheduler {
+
+BuildIndexJob::BuildIndexJob(JobId id, engine::meta::MetaPtr meta_ptr, engine::DBOptions options)
+    : Job(id, JobType::BUILD), meta_ptr_(std::move(meta_ptr)), options_(std::move(options)) {
+}
+
+bool
+BuildIndexJob::AddToIndexFiles(const engine::meta::TableFileSchemaPtr& to_index_file) {
+    std::unique_lock<std::mutex> lock(mutex_);
+    if (to_index_file == nullptr || to_index_files_.find(to_index_file->id_) != to_index_files_.end()) {
+        return false;
+    }
+
+    SERVER_LOG_DEBUG << "BuildIndexJob " << id() << " add to_index file: " << to_index_file->id_;
+
+    to_index_files_[to_index_file->id_] = to_index_file;
+}
+
+Status&
+BuildIndexJob::WaitBuildIndexFinish() {
+    std::unique_lock<std::mutex> lock(mutex_);
+    cv_.wait(lock, [this] { return to_index_files_.empty(); });
+    SERVER_LOG_DEBUG << "BuildIndexJob " << id() << " all done";
+}
+
+void
+BuildIndexJob::BuildIndexDone(size_t to_index_id) {
+    std::unique_lock<std::mutex> lock(mutex_);
+    to_index_files_.erase(to_index_id);
+    cv_.notify_all();
+    SERVER_LOG_DEBUG << "BuildIndexJob " << id() << " finish index file: " << to_index_id;
+}
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/job/BuildIndexJob.h b/core/src/scheduler/job/BuildIndexJob.h
new file mode 100644
index 0000000000..b6ca462537
--- /dev/null
+++ b/core/src/scheduler/job/BuildIndexJob.h
@@ -0,0 +1,90 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+#pragma once
+
+#include <condition_variable>
+#include <deque>
+#include <list>
+#include <memory>
+#include <mutex>
+#include <queue>
+#include <string>
+#include <thread>
+#include <unordered_map>
+#include <vector>
+
+#include "Job.h"
+#include "db/meta/Meta.h"
+#include "scheduler/Definition.h"
+
+namespace milvus {
+namespace scheduler {
+
+using engine::meta::TableFileSchemaPtr;
+
+using Id2ToIndexMap = std::unordered_map<size_t, TableFileSchemaPtr>;
+using Id2ToTableFileMap = std::unordered_map<size_t, TableFileSchema>;
+
+class BuildIndexJob : public Job {
+ public:
+    explicit BuildIndexJob(JobId id, engine::meta::MetaPtr meta_ptr, engine::DBOptions options);
+
+ public:
+    bool
+    AddToIndexFiles(const TableFileSchemaPtr& to_index_file);
+
+    Status&
+    WaitBuildIndexFinish();
+
+    void
+    BuildIndexDone(size_t to_index_id);
+
+ public:
+    Status&
+    GetStatus() {
+        return status_;
+    }
+
+    Id2ToIndexMap&
+    to_index_files() {
+        return to_index_files_;
+    }
+
+    engine::meta::MetaPtr
+    meta() const {
+        return meta_ptr_;
+    }
+
+    engine::DBOptions
+    options() const {
+        return options_;
+    }
+
+ private:
+    Id2ToIndexMap to_index_files_;
+    engine::meta::MetaPtr meta_ptr_;
+    engine::DBOptions options_;
+
+    Status status_;
+    std::mutex mutex_;
+    std::condition_variable cv_;
+};
+
+using BuildIndexJobPtr = std::shared_ptr<BuildIndexJob>;
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/job/DeleteJob.cpp b/core/src/scheduler/job/DeleteJob.cpp
new file mode 100644
index 0000000000..96a6bb1817
--- /dev/null
+++ b/core/src/scheduler/job/DeleteJob.cpp
@@ -0,0 +1,49 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "scheduler/job/DeleteJob.h"
+
+#include <utility>
+
+namespace milvus {
+namespace scheduler {
+
+DeleteJob::DeleteJob(JobId id, std::string table_id, engine::meta::MetaPtr meta_ptr, uint64_t num_resource)
+    : Job(id, JobType::DELETE),
+      table_id_(std::move(table_id)),
+      meta_ptr_(std::move(meta_ptr)),
+      num_resource_(num_resource) {
+}
+
+void
+DeleteJob::WaitAndDelete() {
+    std::unique_lock<std::mutex> lock(mutex_);
+    cv_.wait(lock, [&] { return done_resource == num_resource_; });
+    meta_ptr_->DeleteTableFiles(table_id_);
+}
+
+void
+DeleteJob::ResourceDone() {
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        ++done_resource;
+    }
+    cv_.notify_one();
+}
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/job/DeleteJob.h b/core/src/scheduler/job/DeleteJob.h
new file mode 100644
index 0000000000..4ac48f6913
--- /dev/null
+++ b/core/src/scheduler/job/DeleteJob.h
@@ -0,0 +1,71 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+#pragma once
+
+#include <condition_variable>
+#include <deque>
+#include <list>
+#include <memory>
+#include <mutex>
+#include <queue>
+#include <string>
+#include <thread>
+#include <unordered_map>
+#include <vector>
+
+#include "Job.h"
+#include "db/meta/Meta.h"
+
+namespace milvus {
+namespace scheduler {
+
+class DeleteJob : public Job {
+ public:
+    DeleteJob(JobId id, std::string table_id, engine::meta::MetaPtr meta_ptr, uint64_t num_resource);
+
+ public:
+    void
+    WaitAndDelete();
+
+    void
+    ResourceDone();
+
+ public:
+    std::string
+    table_id() const {
+        return table_id_;
+    }
+
+    engine::meta::MetaPtr
+    meta() const {
+        return meta_ptr_;
+    }
+
+ private:
+    std::string table_id_;
+    engine::meta::MetaPtr meta_ptr_;
+
+    uint64_t num_resource_ = 0;
+    uint64_t done_resource = 0;
+    std::mutex mutex_;
+    std::condition_variable cv_;
+};
+
+using DeleteJobPtr = std::shared_ptr<DeleteJob>;
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/job/Job.h b/core/src/scheduler/job/Job.h
new file mode 100644
index 0000000000..5fe645363f
--- /dev/null
+++ b/core/src/scheduler/job/Job.h
@@ -0,0 +1,67 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+#pragma once
+
+#include <condition_variable>
+#include <deque>
+#include <list>
+#include <memory>
+#include <mutex>
+#include <queue>
+#include <string>
+#include <thread>
+#include <unordered_map>
+#include <vector>
+
+namespace milvus {
+namespace scheduler {
+
+enum class JobType {
+    INVALID,
+    SEARCH,
+    DELETE,
+    BUILD,
+};
+
+using JobId = std::uint64_t;
+
+class Job {
+ public:
+    inline JobId
+    id() const {
+        return id_;
+    }
+
+    inline JobType
+    type() const {
+        return type_;
+    }
+
+ protected:
+    Job(JobId id, JobType type) : id_(id), type_(type) {
+    }
+
+ private:
+    JobId id_;
+    JobType type_;
+};
+
+using JobPtr = std::shared_ptr<Job>;
+using JobWPtr = std::weak_ptr<Job>;
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/job/SearchJob.cpp b/core/src/scheduler/job/SearchJob.cpp
new file mode 100644
index 0000000000..518e3111c0
--- /dev/null
+++ b/core/src/scheduler/job/SearchJob.cpp
@@ -0,0 +1,67 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "scheduler/job/SearchJob.h"
+#include "utils/Log.h"
+
+namespace milvus {
+namespace scheduler {
+
+SearchJob::SearchJob(milvus::scheduler::JobId id, uint64_t topk, uint64_t nq, uint64_t nprobe, const float* vectors)
+    : Job(id, JobType::SEARCH), topk_(topk), nq_(nq), nprobe_(nprobe), vectors_(vectors) {
+}
+
+bool
+SearchJob::AddIndexFile(const TableFileSchemaPtr& index_file) {
+    std::unique_lock<std::mutex> lock(mutex_);
+    if (index_file == nullptr || index_files_.find(index_file->id_) != index_files_.end()) {
+        return false;
+    }
+
+    SERVER_LOG_DEBUG << "SearchJob " << id() << " add index file: " << index_file->id_;
+
+    index_files_[index_file->id_] = index_file;
+    return true;
+}
+
+void
+SearchJob::WaitResult() {
+    std::unique_lock<std::mutex> lock(mutex_);
+    cv_.wait(lock, [this] { return index_files_.empty(); });
+    SERVER_LOG_DEBUG << "SearchJob " << id() << " all done";
+}
+
+void
+SearchJob::SearchDone(size_t index_id) {
+    std::unique_lock<std::mutex> lock(mutex_);
+    index_files_.erase(index_id);
+    cv_.notify_all();
+    SERVER_LOG_DEBUG << "SearchJob " << id() << " finish index file: " << index_id;
+}
+
+ResultSet&
+SearchJob::GetResult() {
+    return result_;
+}
+
+Status&
+SearchJob::GetStatus() {
+    return status_;
+}
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/job/SearchJob.h b/core/src/scheduler/job/SearchJob.h
new file mode 100644
index 0000000000..fb2d87d876
--- /dev/null
+++ b/core/src/scheduler/job/SearchJob.h
@@ -0,0 +1,109 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+#pragma once
+
+#include <condition_variable>
+#include <deque>
+#include <list>
+#include <memory>
+#include <mutex>
+#include <queue>
+#include <string>
+#include <thread>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include "Job.h"
+#include "db/meta/MetaTypes.h"
+
+namespace milvus {
+namespace scheduler {
+
+using engine::meta::TableFileSchemaPtr;
+
+using Id2IndexMap = std::unordered_map<size_t, TableFileSchemaPtr>;
+using IdDistPair = std::pair<int64_t, double>;
+using Id2DistVec = std::vector<IdDistPair>;
+using ResultSet = std::vector<Id2DistVec>;
+
+class SearchJob : public Job {
+ public:
+    SearchJob(JobId id, uint64_t topk, uint64_t nq, uint64_t nprobe, const float* vectors);
+
+ public:
+    bool
+    AddIndexFile(const TableFileSchemaPtr& index_file);
+
+    void
+    WaitResult();
+
+    void
+    SearchDone(size_t index_id);
+
+    ResultSet&
+    GetResult();
+
+    Status&
+    GetStatus();
+
+ public:
+    uint64_t
+    topk() const {
+        return topk_;
+    }
+
+    uint64_t
+    nq() const {
+        return nq_;
+    }
+
+    uint64_t
+    nprobe() const {
+        return nprobe_;
+    }
+
+    const float*
+    vectors() const {
+        return vectors_;
+    }
+
+    Id2IndexMap&
+    index_files() {
+        return index_files_;
+    }
+
+ private:
+    uint64_t topk_ = 0;
+    uint64_t nq_ = 0;
+    uint64_t nprobe_ = 0;
+    // TODO: smart pointer
+    const float* vectors_ = nullptr;
+
+    Id2IndexMap index_files_;
+    // TODO: column-base better ?
+    ResultSet result_;
+    Status status_;
+
+    std::mutex mutex_;
+    std::condition_variable cv_;
+};
+
+using SearchJobPtr = std::shared_ptr<SearchJob>;
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/optimizer/HybridPass.cpp b/core/src/scheduler/optimizer/HybridPass.cpp
new file mode 100644
index 0000000000..d63fc2e819
--- /dev/null
+++ b/core/src/scheduler/optimizer/HybridPass.cpp
@@ -0,0 +1,43 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "scheduler/optimizer/HybridPass.h"
+#include "scheduler/SchedInst.h"
+#include "scheduler/task/SearchTask.h"
+#include "scheduler/tasklabel/SpecResLabel.h"
+
+namespace milvus {
+namespace scheduler {
+
+bool
+HybridPass::Run(const TaskPtr& task) {
+    // TODO: future, Index::IVFSQ8H, if nq < threshold set cpu, else set gpu
+    if (task->Type() != TaskType::SearchTask)
+        return false;
+    auto search_task = std::static_pointer_cast<XSearchTask>(task);
+    if (search_task->file_->engine_type_ == (int)engine::EngineType::FAISS_IVFSQ8H) {
+        // TODO: remove "cpu" hardcode
+        ResourcePtr res_ptr = ResMgrInst::GetInstance()->GetResource("cpu");
+        auto label = std::make_shared<SpecResLabel>(std::weak_ptr<Resource>(res_ptr));
+        task->label() = label;
+        return true;
+    }
+    return false;
+}
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/optimizer/HybridPass.h b/core/src/scheduler/optimizer/HybridPass.h
new file mode 100644
index 0000000000..0d02a8bda9
--- /dev/null
+++ b/core/src/scheduler/optimizer/HybridPass.h
@@ -0,0 +1,47 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+#pragma once
+
+#include <condition_variable>
+#include <deque>
+#include <list>
+#include <memory>
+#include <mutex>
+#include <queue>
+#include <string>
+#include <thread>
+#include <unordered_map>
+#include <vector>
+
+#include "Pass.h"
+
+namespace milvus {
+namespace scheduler {
+
+class HybridPass : public Pass {
+ public:
+    HybridPass() = default;
+
+ public:
+    bool
+    Run(const TaskPtr& task) override;
+};
+
+using HybridPassPtr = std::shared_ptr<HybridPass>;
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/optimizer/LargeSQ8HPass.cpp b/core/src/scheduler/optimizer/LargeSQ8HPass.cpp
new file mode 100644
index 0000000000..8368a90000
--- /dev/null
+++ b/core/src/scheduler/optimizer/LargeSQ8HPass.cpp
@@ -0,0 +1,73 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "scheduler/optimizer/LargeSQ8HPass.h"
+#include "cache/GpuCacheMgr.h"
+#include "scheduler/SchedInst.h"
+#include "scheduler/Utils.h"
+#include "scheduler/task/SearchTask.h"
+#include "scheduler/tasklabel/SpecResLabel.h"
+#include "utils/Log.h"
+
+namespace milvus {
+namespace scheduler {
+
+// bool
+// LargeSQ8HPass::Run(const TaskPtr& task) {
+//    if (task->Type() != TaskType::SearchTask) {
+//        return false;
+//    }
+//
+//    auto search_task = std::static_pointer_cast<XSearchTask>(task);
+//    if (search_task->file_->engine_type_ != (int)engine::EngineType::FAISS_IVFSQ8H) {
+//        return false;
+//    }
+//
+//    auto search_job = std::static_pointer_cast<SearchJob>(search_task->job_.lock());
+//
+//    // TODO: future, Index::IVFSQ8H, if nq < threshold set cpu, else set gpu
+//    if (search_job->nq() < 100) {
+//        return false;
+//    }
+//
+//    std::vector<uint64_t> gpus = scheduler::get_gpu_pool();
+//    std::vector<int64_t> all_free_mem;
+//    for (auto& gpu : gpus) {
+//        auto cache = cache::GpuCacheMgr::GetInstance(gpu);
+//        auto free_mem = cache->CacheCapacity() - cache->CacheUsage();
+//        all_free_mem.push_back(free_mem);
+//    }
+//
+//    auto max_e = std::max_element(all_free_mem.begin(), all_free_mem.end());
+//    auto best_index = std::distance(all_free_mem.begin(), max_e);
+//    auto best_device_id = gpus[best_index];
+//
+//    ResourcePtr res_ptr = ResMgrInst::GetInstance()->GetResource(ResourceType::GPU, best_device_id);
+//    if (not res_ptr) {
+//        SERVER_LOG_ERROR << "GpuResource " << best_device_id << " invalid.";
+//        // TODO: throw critical error and exit
+//        return false;
+//    }
+//
+//    auto label = std::make_shared<SpecResLabel>(std::weak_ptr<Resource>(res_ptr));
+//    task->label() = label;
+//
+//    return true;
+// }
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/optimizer/LargeSQ8HPass.h b/core/src/scheduler/optimizer/LargeSQ8HPass.h
new file mode 100644
index 0000000000..3335a37cc7
--- /dev/null
+++ b/core/src/scheduler/optimizer/LargeSQ8HPass.h
@@ -0,0 +1,47 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+#pragma once
+
+#include <condition_variable>
+#include <deque>
+#include <list>
+#include <memory>
+#include <mutex>
+#include <queue>
+#include <string>
+#include <thread>
+#include <unordered_map>
+#include <vector>
+
+#include "Pass.h"
+
+namespace milvus {
+namespace scheduler {
+
+class LargeSQ8HPass : public Pass {
+ public:
+    LargeSQ8HPass() = default;
+
+ public:
+    //    bool
+    //    Run(const TaskPtr& task) override;
+};
+
+using LargeSQ8HPassPtr = std::shared_ptr<LargeSQ8HPass>;
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/optimizer/Optimizer.cpp b/core/src/scheduler/optimizer/Optimizer.cpp
new file mode 100644
index 0000000000..46f24ea712
--- /dev/null
+++ b/core/src/scheduler/optimizer/Optimizer.cpp
@@ -0,0 +1,42 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "scheduler/optimizer/Optimizer.h"
+
+namespace milvus {
+namespace scheduler {
+
+// void
+// Optimizer::Init() {
+//    for (auto& pass : pass_list_) {
+//        pass->Init();
+//    }
+// }
+
+bool
+Optimizer::Run(const TaskPtr& task) {
+    for (auto& pass : pass_list_) {
+        if (pass->Run(task)) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/optimizer/Optimizer.h b/core/src/scheduler/optimizer/Optimizer.h
new file mode 100644
index 0000000000..bfabbf7de3
--- /dev/null
+++ b/core/src/scheduler/optimizer/Optimizer.h
@@ -0,0 +1,54 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+#pragma once
+
+#include <condition_variable>
+#include <deque>
+#include <list>
+#include <memory>
+#include <mutex>
+#include <queue>
+#include <string>
+#include <thread>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include "Pass.h"
+
+namespace milvus {
+namespace scheduler {
+
+class Optimizer {
+ public:
+    explicit Optimizer(std::vector<PassPtr> pass_list) : pass_list_(std::move(pass_list)) {
+    }
+
+    //    void
+    //    Init();
+
+    bool
+    Run(const TaskPtr& task);
+
+ private:
+    std::vector<PassPtr> pass_list_;
+};
+
+using OptimizerPtr = std::shared_ptr<Optimizer>;
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/optimizer/Pass.h b/core/src/scheduler/optimizer/Pass.h
new file mode 100644
index 0000000000..016b05e457
--- /dev/null
+++ b/core/src/scheduler/optimizer/Pass.h
@@ -0,0 +1,47 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+#pragma once
+
+#include <condition_variable>
+#include <deque>
+#include <list>
+#include <memory>
+#include <mutex>
+#include <queue>
+#include <string>
+#include <thread>
+#include <unordered_map>
+#include <vector>
+
+#include "scheduler/task/Task.h"
+
+namespace milvus {
+namespace scheduler {
+
+class Pass {
+ public:
+    //    virtual void
+    //    Init() {
+    //    }
+
+    virtual bool
+    Run(const TaskPtr& task) = 0;
+};
+using PassPtr = std::shared_ptr<Pass>;
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/resource/Connection.h b/core/src/scheduler/resource/Connection.h
new file mode 100644
index 0000000000..421d32f768
--- /dev/null
+++ b/core/src/scheduler/resource/Connection.h
@@ -0,0 +1,62 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <sstream>
+#include <string>
+#include <utility>
+
+namespace milvus {
+namespace scheduler {
+
+class Connection {
+ public:
+    // TODO: update construct function, speed: double->uint64_t
+    Connection(std::string name, double speed) : name_(std::move(name)), speed_(speed) {
+    }
+
+    const std::string&
+    name() const {
+        return name_;
+    }
+
+    uint64_t
+    speed() const {
+        return speed_;
+    }
+
+    uint64_t
+    transport_cost() {
+        return 1024 / speed_;
+    }
+
+ public:
+    std::string
+    Dump() const {
+        std::stringstream ss;
+        ss << "<name: " << name_ << ", speed: " << speed_ << ">";
+        return ss.str();
+    }
+
+ private:
+    std::string name_;
+    uint64_t speed_;
+};
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/resource/CpuResource.cpp b/core/src/scheduler/resource/CpuResource.cpp
new file mode 100644
index 0000000000..500737a829
--- /dev/null
+++ b/core/src/scheduler/resource/CpuResource.cpp
@@ -0,0 +1,46 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "scheduler/resource/CpuResource.h"
+
+#include <utility>
+
+namespace milvus {
+namespace scheduler {
+
+std::ostream&
+operator<<(std::ostream& out, const CpuResource& resource) {
+    out << resource.Dump();
+    return out;
+}
+
+CpuResource::CpuResource(std::string name, uint64_t device_id, bool enable_loader, bool enable_executor)
+    : Resource(std::move(name), ResourceType::CPU, device_id, enable_loader, enable_executor) {
+}
+
+void
+CpuResource::LoadFile(TaskPtr task) {
+    task->Load(LoadType::DISK2CPU, 0);
+}
+
+void
+CpuResource::Process(TaskPtr task) {
+    task->Execute();
+}
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/resource/CpuResource.h b/core/src/scheduler/resource/CpuResource.h
new file mode 100644
index 0000000000..e3e4fc383f
--- /dev/null
+++ b/core/src/scheduler/resource/CpuResource.h
@@ -0,0 +1,48 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <string>
+
+#include "Resource.h"
+
+namespace milvus {
+namespace scheduler {
+
+class CpuResource : public Resource {
+ public:
+    explicit CpuResource(std::string name, uint64_t device_id, bool enable_loader, bool enable_executor);
+
+    inline std::string
+    Dump() const override {
+        return "<CpuResource, name=" + name_ + ">";
+    }
+
+    friend std::ostream&
+    operator<<(std::ostream& out, const CpuResource& resource);
+
+ protected:
+    void
+    LoadFile(TaskPtr task) override;
+
+    void
+    Process(TaskPtr task) override;
+};
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/resource/DiskResource.cpp b/core/src/scheduler/resource/DiskResource.cpp
new file mode 100644
index 0000000000..fe1fc9c8d9
--- /dev/null
+++ b/core/src/scheduler/resource/DiskResource.cpp
@@ -0,0 +1,45 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "scheduler/resource/DiskResource.h"
+
+#include <string>
+#include <utility>
+
+namespace milvus {
+namespace scheduler {
+
+std::ostream&
+operator<<(std::ostream& out, const DiskResource& resource) {
+    out << resource.Dump();
+    return out;
+}
+
+DiskResource::DiskResource(std::string name, uint64_t device_id, bool enable_loader, bool enable_executor)
+    : Resource(std::move(name), ResourceType::DISK, device_id, enable_loader, enable_executor) {
+}
+
+void
+DiskResource::LoadFile(TaskPtr task) {
+}
+
+void
+DiskResource::Process(TaskPtr task) {
+}
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/resource/DiskResource.h b/core/src/scheduler/resource/DiskResource.h
new file mode 100644
index 0000000000..2346cd115a
--- /dev/null
+++ b/core/src/scheduler/resource/DiskResource.h
@@ -0,0 +1,48 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "Resource.h"
+
+#include <string>
+
+namespace milvus {
+namespace scheduler {
+
+class DiskResource : public Resource {
+ public:
+    explicit DiskResource(std::string name, uint64_t device_id, bool enable_loader, bool enable_executor);
+
+    inline std::string
+    Dump() const override {
+        return "<DiskResource, name=" + name_ + ">";
+    }
+
+    friend std::ostream&
+    operator<<(std::ostream& out, const DiskResource& resource);
+
+ protected:
+    void
+    LoadFile(TaskPtr task) override;
+
+    void
+    Process(TaskPtr task) override;
+};
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/resource/GpuResource.cpp b/core/src/scheduler/resource/GpuResource.cpp
new file mode 100644
index 0000000000..20ed73e38c
--- /dev/null
+++ b/core/src/scheduler/resource/GpuResource.cpp
@@ -0,0 +1,44 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "scheduler/resource/GpuResource.h"
+
+namespace milvus {
+namespace scheduler {
+
+std::ostream&
+operator<<(std::ostream& out, const GpuResource& resource) {
+    out << resource.Dump();
+    return out;
+}
+
+GpuResource::GpuResource(std::string name, uint64_t device_id, bool enable_loader, bool enable_executor)
+    : Resource(std::move(name), ResourceType::GPU, device_id, enable_loader, enable_executor) {
+}
+
+void
+GpuResource::LoadFile(TaskPtr task) {
+    task->Load(LoadType::CPU2GPU, device_id_);
+}
+
+void
+GpuResource::Process(TaskPtr task) {
+    task->Execute();
+}
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/resource/GpuResource.h b/core/src/scheduler/resource/GpuResource.h
new file mode 100644
index 0000000000..e0df03d5a7
--- /dev/null
+++ b/core/src/scheduler/resource/GpuResource.h
@@ -0,0 +1,49 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "Resource.h"
+
+#include <string>
+#include <utility>
+
+namespace milvus {
+namespace scheduler {
+
+class GpuResource : public Resource {
+ public:
+    explicit GpuResource(std::string name, uint64_t device_id, bool enable_loader, bool enable_executor);
+
+    inline std::string
+    Dump() const override {
+        return "<GpuResource, name=" + name_ + ">";
+    }
+
+    friend std::ostream&
+    operator<<(std::ostream& out, const GpuResource& resource);
+
+ protected:
+    void
+    LoadFile(TaskPtr task) override;
+
+    void
+    Process(TaskPtr task) override;
+};
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/resource/Node.cpp b/core/src/scheduler/resource/Node.cpp
new file mode 100644
index 0000000000..5401c36441
--- /dev/null
+++ b/core/src/scheduler/resource/Node.cpp
@@ -0,0 +1,62 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "scheduler/resource/Node.h"
+
+#include <atomic>
+#include <utility>
+
+namespace milvus {
+namespace scheduler {
+
+Node::Node() {
+    static std::atomic_uint_fast8_t counter(0);
+    id_ = counter++;
+}
+
+std::vector<Neighbour>
+Node::GetNeighbours() {
+    std::lock_guard<std::mutex> lk(mutex_);
+    std::vector<Neighbour> ret;
+    for (auto& e : neighbours_) {
+        ret.push_back(e.second);
+    }
+    return ret;
+}
+
+std::string
+Node::Dump() {
+    std::stringstream ss;
+    ss << "<Node, id=" << std::to_string(id_) << ">::neighbours:" << std::endl;
+    for (auto& neighbour : neighbours_) {
+        ss << "\t<Neighbour, id=" << std::to_string(neighbour.first);
+        ss << ", connection: " << neighbour.second.connection.Dump() << ">" << std::endl;
+    }
+    return ss.str();
+}
+
+void
+Node::AddNeighbour(const NeighbourNodePtr& neighbour_node, Connection& connection) {
+    std::lock_guard<std::mutex> lk(mutex_);
+    if (auto s = neighbour_node.lock()) {
+        neighbours_.emplace(std::make_pair(s->id_, Neighbour(neighbour_node, connection)));
+    }
+    // else do nothing, consider it..
+}
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/resource/Node.h b/core/src/scheduler/resource/Node.h
new file mode 100644
index 0000000000..071ee9bab8
--- /dev/null
+++ b/core/src/scheduler/resource/Node.h
@@ -0,0 +1,68 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "Connection.h"
+#include "scheduler/TaskTable.h"
+
+namespace milvus {
+namespace scheduler {
+
+class Node;
+
+using NeighbourNodePtr = std::weak_ptr<Node>;
+
+struct Neighbour {
+    Neighbour(NeighbourNodePtr nei, Connection conn) : neighbour_node(nei), connection(conn) {
+    }
+
+    NeighbourNodePtr neighbour_node;
+    Connection connection;
+};
+
+// TODO(lxj): return type void -> Status
+class Node {
+ public:
+    Node();
+
+    void
+    AddNeighbour(const NeighbourNodePtr& neighbour_node, Connection& connection);
+
+    std::vector<Neighbour>
+    GetNeighbours();
+
+ public:
+    std::string
+    Dump();
+
+ private:
+    std::mutex mutex_;
+    uint8_t id_;
+    std::map<uint8_t, Neighbour> neighbours_;
+};
+
+using NodePtr = std::shared_ptr<Node>;
+using NodeWPtr = std::weak_ptr<Node>;
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/resource/Resource.cpp b/core/src/scheduler/resource/Resource.cpp
new file mode 100644
index 0000000000..59fd22b5d6
--- /dev/null
+++ b/core/src/scheduler/resource/Resource.cpp
@@ -0,0 +1,204 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "scheduler/resource/Resource.h"
+#include "scheduler/SchedInst.h"
+#include "scheduler/Utils.h"
+
+#include <iostream>
+#include <limits>
+#include <utility>
+
+namespace milvus {
+namespace scheduler {
+
+std::ostream&
+operator<<(std::ostream& out, const Resource& resource) {
+    out << resource.Dump();
+    return out;
+}
+
+Resource::Resource(std::string name, ResourceType type, uint64_t device_id, bool enable_loader, bool enable_executor)
+    : name_(std::move(name)),
+      type_(type),
+      device_id_(device_id),
+      enable_loader_(enable_loader),
+      enable_executor_(enable_executor) {
+    // register subscriber in tasktable
+    task_table_.RegisterSubscriber([&] {
+        if (subscriber_) {
+            auto event = std::make_shared<TaskTableUpdatedEvent>(shared_from_this());
+            subscriber_(std::static_pointer_cast<Event>(event));
+        }
+    });
+}
+
+void
+Resource::Start() {
+    running_ = true;
+    if (enable_loader_) {
+        loader_thread_ = std::thread(&Resource::loader_function, this);
+    }
+    if (enable_executor_) {
+        executor_thread_ = std::thread(&Resource::executor_function, this);
+    }
+}
+
+void
+Resource::Stop() {
+    running_ = false;
+    if (enable_loader_) {
+        WakeupLoader();
+        loader_thread_.join();
+    }
+    if (enable_executor_) {
+        WakeupExecutor();
+        executor_thread_.join();
+    }
+}
+
+void
+Resource::WakeupLoader() {
+    {
+        std::lock_guard<std::mutex> lock(load_mutex_);
+        load_flag_ = true;
+    }
+    load_cv_.notify_one();
+}
+
+void
+Resource::WakeupExecutor() {
+    {
+        std::lock_guard<std::mutex> lock(exec_mutex_);
+        exec_flag_ = true;
+    }
+    exec_cv_.notify_one();
+}
+
+uint64_t
+Resource::NumOfTaskToExec() {
+    uint64_t count = 0;
+    for (auto& task : task_table_) {
+        if (task->state == TaskTableItemState::LOADED)
+            ++count;
+    }
+    return count;
+}
+
+TaskTableItemPtr
+Resource::pick_task_load() {
+    auto indexes = task_table_.PickToLoad(10);
+    for (auto index : indexes) {
+        // try to set one task loading, then return
+        if (task_table_.Load(index))
+            return task_table_.Get(index);
+        // else try next
+    }
+    return nullptr;
+}
+
+TaskTableItemPtr
+Resource::pick_task_execute() {
+    auto indexes = task_table_.PickToExecute(std::numeric_limits<uint64_t>::max());
+    for (auto index : indexes) {
+        // try to set one task executing, then return
+        if (task_table_[index]->task->label()->Type() == TaskLabelType::SPECIFIED_RESOURCE) {
+            if (task_table_[index]->task->path().Last() != name()) {
+                continue;
+            }
+        }
+
+        if (task_table_.Execute(index)) {
+            return task_table_.Get(index);
+        }
+        //        if (task_table_[index]->task->label()->Type() == TaskLabelType::SPECIFIED_RESOURCE) {
+        //            if (task_table_.Get(index)->task->path().Current() == task_table_.Get(index)->task->path().Last()
+        //            &&
+        //                task_table_.Get(index)->task->path().Last() == name()) {
+        //                if (task_table_.Execute(index)) {
+        //                    return task_table_.Get(index);
+        //                }
+        //            }
+        //        }
+        // else try next
+    }
+    return nullptr;
+}
+
+void
+Resource::loader_function() {
+    while (running_) {
+        std::unique_lock<std::mutex> lock(load_mutex_);
+        load_cv_.wait(lock, [&] { return load_flag_; });
+        load_flag_ = false;
+        lock.unlock();
+        while (true) {
+            auto task_item = pick_task_load();
+            if (task_item == nullptr) {
+                break;
+            }
+            LoadFile(task_item->task);
+            task_item->Loaded();
+            if (subscriber_) {
+                auto event = std::make_shared<LoadCompletedEvent>(shared_from_this(), task_item);
+                subscriber_(std::static_pointer_cast<Event>(event));
+            }
+        }
+    }
+}
+
+void
+Resource::executor_function() {
+    if (subscriber_) {
+        auto event = std::make_shared<StartUpEvent>(shared_from_this());
+        subscriber_(std::static_pointer_cast<Event>(event));
+    }
+    while (running_) {
+        std::unique_lock<std::mutex> lock(exec_mutex_);
+        exec_cv_.wait(lock, [&] { return exec_flag_; });
+        exec_flag_ = false;
+        lock.unlock();
+        while (true) {
+            auto task_item = pick_task_execute();
+            if (task_item == nullptr) {
+                break;
+            }
+
+            auto start = get_current_timestamp();
+            Process(task_item->task);
+            auto finish = get_current_timestamp();
+            ++total_task_;
+            total_cost_ += finish - start;
+
+            task_item->Executed();
+
+            if (task_item->task->Type() == TaskType::BuildIndexTask) {
+                BuildMgrInst::GetInstance()->Put();
+                ResMgrInst::GetInstance()->GetResource("cpu")->WakeupLoader();
+                ResMgrInst::GetInstance()->GetResource("disk")->WakeupLoader();
+            }
+
+            if (subscriber_) {
+                auto event = std::make_shared<FinishTaskEvent>(shared_from_this(), task_item);
+                subscriber_(std::static_pointer_cast<Event>(event));
+            }
+        }
+    }
+}
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/resource/Resource.h b/core/src/scheduler/resource/Resource.h
new file mode 100644
index 0000000000..c9026f13b6
--- /dev/null
+++ b/core/src/scheduler/resource/Resource.h
@@ -0,0 +1,212 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <condition_variable>
+#include <functional>
+#include <memory>
+#include <string>
+#include <thread>
+#include <utility>
+#include <vector>
+
+#include "../TaskTable.h"
+#include "../event/Event.h"
+#include "../event/FinishTaskEvent.h"
+#include "../event/LoadCompletedEvent.h"
+#include "../event/StartUpEvent.h"
+#include "../event/TaskTableUpdatedEvent.h"
+#include "../task/Task.h"
+#include "Connection.h"
+#include "Node.h"
+
+namespace milvus {
+namespace scheduler {
+
+// TODO(wxyu): Storage, Route, Executor
+enum class ResourceType {
+    DISK = 0,
+    CPU = 1,
+    GPU = 2,
+    TEST = 3,
+};
+
+class Resource : public Node, public std::enable_shared_from_this<Resource> {
+ public:
+    /*
+     * Start loader and executor if enable;
+     */
+    void
+    Start();
+
+    /*
+     * Stop loader and executor, join it, blocking util thread exited;
+     */
+    void
+    Stop();
+
+    /*
+     * wake up loader;
+     */
+    void
+    WakeupLoader();
+
+    /*
+     * wake up executor;
+     */
+    void
+    WakeupExecutor();
+
+    inline void
+    RegisterSubscriber(std::function<void(EventPtr)> subscriber) {
+        subscriber_ = std::move(subscriber);
+    }
+
+    inline virtual std::string
+    Dump() const {
+        return "<Resource>";
+    }
+
+ public:
+    inline std::string
+    name() const {
+        return name_;
+    }
+
+    inline ResourceType
+    type() const {
+        return type_;
+    }
+
+    inline uint64_t
+    device_id() const {
+        return device_id_;
+    }
+
+    TaskTable&
+    task_table() {
+        return task_table_;
+    }
+
+ public:
+    inline bool
+    HasLoader() const {
+        return enable_loader_;
+    }
+
+    inline bool
+    HasExecutor() const {
+        return enable_executor_;
+    }
+
+    // TODO(wxyu): const
+    uint64_t
+    NumOfTaskToExec();
+
+    // TODO(wxyu): need double ?
+    inline uint64_t
+    TaskAvgCost() const {
+        return total_cost_ / total_task_;
+    }
+
+    inline uint64_t
+    TotalTasks() const {
+        return total_task_;
+    }
+
+    friend std::ostream&
+    operator<<(std::ostream& out, const Resource& resource);
+
+ protected:
+    Resource(std::string name, ResourceType type, uint64_t device_id, bool enable_loader, bool enable_executor);
+
+    /*
+     * Implementation by inherit class;
+     * Blocking function;
+     */
+    virtual void
+    LoadFile(TaskPtr task) = 0;
+
+    /*
+     * Implementation by inherit class;
+     * Blocking function;
+     */
+    virtual void
+    Process(TaskPtr task) = 0;
+
+ private:
+    /*
+     * Pick one task to load;
+     * Order by start time;
+     */
+    TaskTableItemPtr
+    pick_task_load();
+
+    /*
+     * Pick one task to execute;
+     * Pick by start time and priority;
+     */
+    TaskTableItemPtr
+    pick_task_execute();
+
+ private:
+    /*
+     * Only called by load thread;
+     */
+    void
+    loader_function();
+
+    /*
+     * Only called by worker thread;
+     */
+    void
+    executor_function();
+
+ protected:
+    uint64_t device_id_;
+    std::string name_;
+
+ private:
+    ResourceType type_;
+
+    TaskTable task_table_;
+
+    uint64_t total_cost_ = 0;
+    uint64_t total_task_ = 0;
+
+    std::function<void(EventPtr)> subscriber_ = nullptr;
+
+    bool running_ = false;
+    bool enable_loader_ = true;
+    bool enable_executor_ = true;
+    std::thread loader_thread_;
+    std::thread executor_thread_;
+
+    bool load_flag_ = false;
+    bool exec_flag_ = false;
+    std::mutex load_mutex_;
+    std::mutex exec_mutex_;
+    std::condition_variable load_cv_;
+    std::condition_variable exec_cv_;
+};
+
+using ResourcePtr = std::shared_ptr<Resource>;
+using ResourceWPtr = std::weak_ptr<Resource>;
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/resource/TestResource.cpp b/core/src/scheduler/resource/TestResource.cpp
new file mode 100644
index 0000000000..c8c2fb7537
--- /dev/null
+++ b/core/src/scheduler/resource/TestResource.cpp
@@ -0,0 +1,46 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "scheduler/resource/TestResource.h"
+
+#include <string>
+
+namespace milvus {
+namespace scheduler {
+
+std::ostream&
+operator<<(std::ostream& out, const TestResource& resource) {
+    out << resource.Dump();
+    return out;
+}
+
+TestResource::TestResource(std::string name, uint64_t device_id, bool enable_loader, bool enable_executor)
+    : Resource(std::move(name), ResourceType::TEST, device_id, enable_loader, enable_executor) {
+}
+
+void
+TestResource::LoadFile(TaskPtr task) {
+    task->Load(LoadType::TEST, 0);
+}
+
+void
+TestResource::Process(TaskPtr task) {
+    task->Execute();
+}
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/resource/TestResource.h b/core/src/scheduler/resource/TestResource.h
new file mode 100644
index 0000000000..9bbc5a54d0
--- /dev/null
+++ b/core/src/scheduler/resource/TestResource.h
@@ -0,0 +1,49 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "Resource.h"
+
+#include <string>
+#include <utility>
+
+namespace milvus {
+namespace scheduler {
+
+class TestResource : public Resource {
+ public:
+    explicit TestResource(std::string name, uint64_t device_id, bool enable_loader, bool enable_executor);
+
+    inline std::string
+    Dump() const override {
+        return "<TestResource, name=" + name_ + ">";
+    }
+
+    friend std::ostream&
+    operator<<(std::ostream& out, const TestResource& resource);
+
+ protected:
+    void
+    LoadFile(TaskPtr task) override;
+
+    void
+    Process(TaskPtr task) override;
+};
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/task/BuildIndexTask.cpp b/core/src/scheduler/task/BuildIndexTask.cpp
new file mode 100644
index 0000000000..d8602c141e
--- /dev/null
+++ b/core/src/scheduler/task/BuildIndexTask.cpp
@@ -0,0 +1,229 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "scheduler/task/BuildIndexTask.h"
+#include "db/engine/EngineFactory.h"
+#include "metrics/Metrics.h"
+#include "scheduler/job/BuildIndexJob.h"
+#include "utils/Log.h"
+#include "utils/TimeRecorder.h"
+
+#include <memory>
+#include <string>
+#include <thread>
+#include <utility>
+
+namespace milvus {
+namespace scheduler {
+
+XBuildIndexTask::XBuildIndexTask(TableFileSchemaPtr file, TaskLabelPtr label)
+    : Task(TaskType::BuildIndexTask, std::move(label)), file_(file) {
+    if (file_) {
+        to_index_engine_ = EngineFactory::Build(file_->dimension_, file_->location_, (EngineType)file_->engine_type_,
+                                                (MetricType)file_->metric_type_, file_->nlist_);
+    }
+}
+
+void
+XBuildIndexTask::Load(milvus::scheduler::LoadType type, uint8_t device_id) {
+    TimeRecorder rc("");
+    Status stat = Status::OK();
+    std::string error_msg;
+    std::string type_str;
+
+    if (auto job = job_.lock()) {
+        auto build_index_job = std::static_pointer_cast<scheduler::BuildIndexJob>(job);
+        auto options = build_index_job->options();
+        try {
+            if (type == LoadType::DISK2CPU) {
+                stat = to_index_engine_->Load(options.insert_cache_immediately_);
+                type_str = "DISK2CPU";
+            } else if (type == LoadType::CPU2GPU) {
+                stat = to_index_engine_->CopyToIndexFileToGpu(device_id);
+                type_str = "CPU2GPU";
+            } else {
+                error_msg = "Wrong load type";
+                stat = Status(SERVER_UNEXPECTED_ERROR, error_msg);
+            }
+        } catch (std::exception& ex) {
+            // typical error: out of disk space or permition denied
+            error_msg = "Failed to load to_index file: " + std::string(ex.what());
+            stat = Status(SERVER_UNEXPECTED_ERROR, error_msg);
+        }
+
+        if (!stat.ok()) {
+            Status s;
+            if (stat.ToString().find("out of memory") != std::string::npos) {
+                error_msg = "out of memory: " + type_str;
+                s = Status(SERVER_UNEXPECTED_ERROR, error_msg);
+            } else {
+                error_msg = "Failed to load to_index file: " + type_str;
+                s = Status(SERVER_UNEXPECTED_ERROR, error_msg);
+            }
+
+            if (auto job = job_.lock()) {
+                auto build_index_job = std::static_pointer_cast<scheduler::BuildIndexJob>(job);
+                build_index_job->BuildIndexDone(file_->id_);
+            }
+
+            return;
+        }
+
+        size_t file_size = to_index_engine_->PhysicalSize();
+
+        std::string info = "Load file id:" + std::to_string(file_->id_) +
+                           " file type:" + std::to_string(file_->file_type_) + " size:" + std::to_string(file_size) +
+                           " bytes from location: " + file_->location_ + " totally cost";
+        double span = rc.ElapseFromBegin(info);
+
+        to_index_id_ = file_->id_;
+        to_index_type_ = file_->file_type_;
+    }
+}
+
+void
+XBuildIndexTask::Execute() {
+    if (to_index_engine_ == nullptr) {
+        return;
+    }
+
+    TimeRecorder rc("DoBuildIndex file id:" + std::to_string(to_index_id_));
+
+    if (auto job = job_.lock()) {
+        auto build_index_job = std::static_pointer_cast<scheduler::BuildIndexJob>(job);
+        std::string location = file_->location_;
+        EngineType engine_type = (EngineType)file_->engine_type_;
+        std::shared_ptr<engine::ExecutionEngine> index;
+
+        // step 2: create table file
+        engine::meta::TableFileSchema table_file;
+        table_file.table_id_ = file_->table_id_;
+        table_file.date_ = file_->date_;
+        table_file.file_type_ = engine::meta::TableFileSchema::NEW_INDEX;
+
+        engine::meta::MetaPtr meta_ptr = build_index_job->meta();
+        Status status = build_index_job->meta()->CreateTableFile(table_file);
+        if (!status.ok()) {
+            ENGINE_LOG_ERROR << "Failed to create table file: " << status.ToString();
+            build_index_job->BuildIndexDone(to_index_id_);
+            build_index_job->GetStatus() = status;
+            to_index_engine_ = nullptr;
+            return;
+        }
+
+        // step 3: build index
+        try {
+            index = to_index_engine_->BuildIndex(table_file.location_, (EngineType)table_file.engine_type_);
+            if (index == nullptr) {
+                table_file.file_type_ = engine::meta::TableFileSchema::TO_DELETE;
+                status = meta_ptr->UpdateTableFile(table_file);
+                ENGINE_LOG_DEBUG << "Failed to update file to index, mark file: " << table_file.file_id_
+                                 << " to to_delete";
+
+                build_index_job->BuildIndexDone(to_index_id_);
+                to_index_engine_ = nullptr;
+                return;
+            }
+        } catch (std::exception& ex) {
+            std::string msg = "BuildIndex encounter exception: " + std::string(ex.what());
+            ENGINE_LOG_ERROR << msg;
+
+            table_file.file_type_ = engine::meta::TableFileSchema::TO_DELETE;
+            status = meta_ptr->UpdateTableFile(table_file);
+            ENGINE_LOG_DEBUG << "Failed to update file to index, mark file: " << table_file.file_id_ << " to to_delete";
+
+            std::cout << "ERROR: failed to build index, index file is too large or gpu memory is not enough"
+                      << std::endl;
+
+            build_index_job->BuildIndexDone(to_index_id_);
+            build_index_job->GetStatus() = Status(DB_ERROR, msg);
+            to_index_engine_ = nullptr;
+            return;
+        }
+
+        // step 4: if table has been deleted, dont save index file
+        bool has_table = false;
+        meta_ptr->HasTable(file_->table_id_, has_table);
+        if (!has_table) {
+            meta_ptr->DeleteTableFiles(file_->table_id_);
+
+            build_index_job->BuildIndexDone(to_index_id_);
+            build_index_job->GetStatus() = Status(DB_ERROR, "Table has been deleted, discard index file.");
+            to_index_engine_ = nullptr;
+            return;
+        }
+
+        // step 5: save index file
+        try {
+            index->Serialize();
+        } catch (std::exception& ex) {
+            // typical error: out of disk space or permition denied
+            std::string msg = "Serialize index encounter exception: " + std::string(ex.what());
+            ENGINE_LOG_ERROR << msg;
+
+            table_file.file_type_ = engine::meta::TableFileSchema::TO_DELETE;
+            status = meta_ptr->UpdateTableFile(table_file);
+            ENGINE_LOG_DEBUG << "Failed to update file to index, mark file: " << table_file.file_id_ << " to to_delete";
+
+            std::cout << "ERROR: failed to persist index file: " << table_file.location_
+                      << ", possible out of disk space" << std::endl;
+
+            build_index_job->BuildIndexDone(to_index_id_);
+            build_index_job->GetStatus() = Status(DB_ERROR, msg);
+            to_index_engine_ = nullptr;
+            return;
+        }
+
+        // step 6: update meta
+        table_file.file_type_ = engine::meta::TableFileSchema::INDEX;
+        table_file.file_size_ = index->PhysicalSize();
+        table_file.row_count_ = index->Count();
+
+        auto origin_file = *file_;
+        origin_file.file_type_ = engine::meta::TableFileSchema::BACKUP;
+
+        engine::meta::TableFilesSchema update_files = {table_file, origin_file};
+        status = meta_ptr->UpdateTableFiles(update_files);
+        if (status.ok()) {
+            ENGINE_LOG_DEBUG << "New index file " << table_file.file_id_ << " of size " << index->PhysicalSize()
+                             << " bytes"
+                             << " from file " << origin_file.file_id_;
+            if (build_index_job->options().insert_cache_immediately_) {
+                index->Cache();
+            }
+        } else {
+            // failed to update meta, mark the new file as to_delete, don't delete old file
+            origin_file.file_type_ = engine::meta::TableFileSchema::TO_INDEX;
+            status = meta_ptr->UpdateTableFile(origin_file);
+            ENGINE_LOG_DEBUG << "Failed to update file to index, mark file: " << origin_file.file_id_ << " to to_index";
+
+            table_file.file_type_ = engine::meta::TableFileSchema::TO_DELETE;
+            status = meta_ptr->UpdateTableFile(table_file);
+            ENGINE_LOG_DEBUG << "Failed to up  date file to index, mark file: " << table_file.file_id_
+                             << " to to_delete";
+        }
+
+        build_index_job->BuildIndexDone(to_index_id_);
+    }
+
+    rc.ElapseFromBegin("totally cost");
+
+    to_index_engine_ = nullptr;
+}
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/task/BuildIndexTask.h b/core/src/scheduler/task/BuildIndexTask.h
new file mode 100644
index 0000000000..5c2aa69a00
--- /dev/null
+++ b/core/src/scheduler/task/BuildIndexTask.h
@@ -0,0 +1,46 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "Task.h"
+#include "scheduler/Definition.h"
+#include "scheduler/job/BuildIndexJob.h"
+
+namespace milvus {
+namespace scheduler {
+
+class XBuildIndexTask : public Task {
+ public:
+    explicit XBuildIndexTask(TableFileSchemaPtr file, TaskLabelPtr label);
+
+    void
+    Load(LoadType type, uint8_t device_id) override;
+
+    void
+    Execute() override;
+
+ public:
+    TableFileSchemaPtr file_;
+    TableFileSchema table_file_;
+    size_t to_index_id_ = 0;
+    int to_index_type_ = 0;
+    ExecutionEnginePtr to_index_engine_ = nullptr;
+};
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/task/DeleteTask.cpp b/core/src/scheduler/task/DeleteTask.cpp
new file mode 100644
index 0000000000..bffe78cf8f
--- /dev/null
+++ b/core/src/scheduler/task/DeleteTask.cpp
@@ -0,0 +1,39 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "scheduler/task/DeleteTask.h"
+
+#include <utility>
+
+namespace milvus {
+namespace scheduler {
+
+XDeleteTask::XDeleteTask(const scheduler::DeleteJobPtr& delete_job, TaskLabelPtr label)
+    : Task(TaskType::DeleteTask, std::move(label)), delete_job_(delete_job) {
+}
+
+void
+XDeleteTask::Load(LoadType type, uint8_t device_id) {
+}
+
+void
+XDeleteTask::Execute() {
+    delete_job_->ResourceDone();
+}
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/task/DeleteTask.h b/core/src/scheduler/task/DeleteTask.h
new file mode 100644
index 0000000000..fd5222ba4e
--- /dev/null
+++ b/core/src/scheduler/task/DeleteTask.h
@@ -0,0 +1,41 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "Task.h"
+#include "scheduler/job/DeleteJob.h"
+
+namespace milvus {
+namespace scheduler {
+
+class XDeleteTask : public Task {
+ public:
+    explicit XDeleteTask(const scheduler::DeleteJobPtr& delete_job, TaskLabelPtr label);
+
+    void
+    Load(LoadType type, uint8_t device_id) override;
+
+    void
+    Execute() override;
+
+ public:
+    scheduler::DeleteJobPtr delete_job_;
+};
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/task/Path.h b/core/src/scheduler/task/Path.h
new file mode 100644
index 0000000000..30e77a17b8
--- /dev/null
+++ b/core/src/scheduler/task/Path.h
@@ -0,0 +1,92 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <string>
+#include <vector>
+
+namespace milvus {
+namespace scheduler {
+
+class Path {
+ public:
+    Path() = default;
+
+    Path(std::vector<std::string>& path, uint64_t index) : path_(path), index_(index) {
+    }
+
+    void
+    push_back(const std::string& str) {
+        path_.push_back(str);
+    }
+
+    std::vector<std::string>
+    Dump() {
+        return path_;
+    }
+
+    std::string
+    Current() {
+        if (!path_.empty() && path_.size() > index_) {
+            return path_[index_];
+        } else {
+            return "";
+        }
+    }
+
+    std::string
+    Next() {
+        if (index_ > 0 && !path_.empty()) {
+            --index_;
+            return path_[index_];
+        } else {
+            return "";
+        }
+    }
+
+    std::string
+    Last() {
+        if (!path_.empty()) {
+            return path_[0];
+        } else {
+            return nullptr;
+        }
+    }
+
+ public:
+    std::string& operator[](uint64_t index) {
+        return path_[index];
+    }
+
+    std::vector<std::string>::iterator
+    begin() {
+        return path_.begin();
+    }
+
+    std::vector<std::string>::iterator
+    end() {
+        return path_.end();
+    }
+
+ public:
+    std::vector<std::string> path_;
+    uint64_t index_ = 0;
+};
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/task/SearchTask.cpp b/core/src/scheduler/task/SearchTask.cpp
new file mode 100644
index 0000000000..1bf1caff76
--- /dev/null
+++ b/core/src/scheduler/task/SearchTask.cpp
@@ -0,0 +1,377 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "scheduler/task/SearchTask.h"
+#include "db/engine/EngineFactory.h"
+#include "metrics/Metrics.h"
+#include "scheduler/job/SearchJob.h"
+#include "utils/Log.h"
+#include "utils/TimeRecorder.h"
+
+#include <src/scheduler/SchedInst.h>
+#include <algorithm>
+#include <string>
+#include <thread>
+#include <utility>
+
+namespace milvus {
+namespace scheduler {
+
+static constexpr size_t PARALLEL_REDUCE_THRESHOLD = 10000;
+static constexpr size_t PARALLEL_REDUCE_BATCH = 1000;
+
+// TODO(wxyu): remove unused code
+// bool
+// NeedParallelReduce(uint64_t nq, uint64_t topk) {
+//    server::ServerConfig &config = server::ServerConfig::GetInstance();
+//    server::ConfigNode &db_config = config.GetConfig(server::CONFIG_DB);
+//    bool need_parallel = db_config.GetBoolValue(server::CONFIG_DB_PARALLEL_REDUCE, false);
+//    if (!need_parallel) {
+//        return false;
+//    }
+//
+//    return nq * topk >= PARALLEL_REDUCE_THRESHOLD;
+//}
+//
+// void
+// ParallelReduce(std::function<void(size_t, size_t)> &reduce_function, size_t max_index) {
+//    size_t reduce_batch = PARALLEL_REDUCE_BATCH;
+//
+//    auto thread_count = std::thread::hardware_concurrency() - 1; //not all core do this work
+//    if (thread_count > 0) {
+//        reduce_batch = max_index / thread_count + 1;
+//    }
+//    ENGINE_LOG_DEBUG << "use " << thread_count <<
+//                     " thread parallelly do reduce, each thread process " << reduce_batch << " vectors";
+//
+//    std::vector<std::shared_ptr<std::thread> > thread_array;
+//    size_t from_index = 0;
+//    while (from_index < max_index) {
+//        size_t to_index = from_index + reduce_batch;
+//        if (to_index > max_index) {
+//            to_index = max_index;
+//        }
+//
+//        auto reduce_thread = std::make_shared<std::thread>(reduce_function, from_index, to_index);
+//        thread_array.push_back(reduce_thread);
+//
+//        from_index = to_index;
+//    }
+//
+//    for (auto &thread_ptr : thread_array) {
+//        thread_ptr->join();
+//    }
+//}
+
+void
+CollectFileMetrics(int file_type, size_t file_size) {
+    server::MetricsBase& inst = server::Metrics::GetInstance();
+    switch (file_type) {
+        case TableFileSchema::RAW:
+        case TableFileSchema::TO_INDEX: {
+            inst.RawFileSizeHistogramObserve(file_size);
+            inst.RawFileSizeTotalIncrement(file_size);
+            inst.RawFileSizeGaugeSet(file_size);
+            break;
+        }
+        default: {
+            inst.IndexFileSizeHistogramObserve(file_size);
+            inst.IndexFileSizeTotalIncrement(file_size);
+            inst.IndexFileSizeGaugeSet(file_size);
+            break;
+        }
+    }
+}
+
+XSearchTask::XSearchTask(TableFileSchemaPtr file, TaskLabelPtr label)
+    : Task(TaskType::SearchTask, std::move(label)), file_(file) {
+    if (file_) {
+        if (file_->metric_type_ != static_cast<int>(MetricType::L2)) {
+            metric_l2 = false;
+        }
+        index_engine_ = EngineFactory::Build(file_->dimension_, file_->location_, (EngineType)file_->engine_type_,
+                                             (MetricType)file_->metric_type_, file_->nlist_);
+    }
+}
+
+void
+XSearchTask::Load(LoadType type, uint8_t device_id) {
+    TimeRecorder rc("");
+    Status stat = Status::OK();
+    std::string error_msg;
+    std::string type_str;
+
+    try {
+        if (type == LoadType::DISK2CPU) {
+            stat = index_engine_->Load();
+            type_str = "DISK2CPU";
+        } else if (type == LoadType::CPU2GPU) {
+            bool hybrid = false;
+            if (index_engine_->IndexEngineType() == engine::EngineType::FAISS_IVFSQ8H) {
+                hybrid = true;
+            }
+            stat = index_engine_->CopyToGpu(device_id, hybrid);
+            type_str = "CPU2GPU";
+        } else if (type == LoadType::GPU2CPU) {
+            stat = index_engine_->CopyToCpu();
+            type_str = "GPU2CPU";
+        } else {
+            error_msg = "Wrong load type";
+            stat = Status(SERVER_UNEXPECTED_ERROR, error_msg);
+        }
+    } catch (std::exception& ex) {
+        // typical error: out of disk space or permition denied
+        error_msg = "Failed to load index file: " + std::string(ex.what());
+        stat = Status(SERVER_UNEXPECTED_ERROR, error_msg);
+    }
+
+    if (!stat.ok()) {
+        Status s;
+        if (stat.ToString().find("out of memory") != std::string::npos) {
+            error_msg = "out of memory: " + type_str;
+            s = Status(SERVER_OUT_OF_MEMORY, error_msg);
+        } else {
+            error_msg = "Failed to load index file: " + type_str;
+            s = Status(SERVER_UNEXPECTED_ERROR, error_msg);
+        }
+
+        if (auto job = job_.lock()) {
+            auto search_job = std::static_pointer_cast<scheduler::SearchJob>(job);
+            search_job->SearchDone(file_->id_);
+            search_job->GetStatus() = s;
+        }
+
+        return;
+    }
+
+    size_t file_size = index_engine_->PhysicalSize();
+
+    std::string info = "Load file id:" + std::to_string(file_->id_) +
+                       " file type:" + std::to_string(file_->file_type_) + " size:" + std::to_string(file_size) +
+                       " bytes from location: " + file_->location_ + " totally cost";
+    double span = rc.ElapseFromBegin(info);
+    //    for (auto &context : search_contexts_) {
+    //        context->AccumLoadCost(span);
+    //    }
+
+    CollectFileMetrics(file_->file_type_, file_size);
+
+    // step 2: return search task for later execution
+    index_id_ = file_->id_;
+    index_type_ = file_->file_type_;
+    //    search_contexts_.swap(search_contexts_);
+}
+
+void
+XSearchTask::Execute() {
+    if (index_engine_ == nullptr) {
+        return;
+    }
+
+    //    ENGINE_LOG_DEBUG << "Searching in file id:" << index_id_ << " with "
+    //                     << search_contexts_.size() << " tasks";
+
+    TimeRecorder rc("DoSearch file id:" + std::to_string(index_id_));
+
+    server::CollectDurationMetrics metrics(index_type_);
+
+    std::vector<int64_t> output_ids;
+    std::vector<float> output_distance;
+
+    if (auto job = job_.lock()) {
+        auto search_job = std::static_pointer_cast<scheduler::SearchJob>(job);
+        // step 1: allocate memory
+        uint64_t nq = search_job->nq();
+        uint64_t topk = search_job->topk();
+        uint64_t nprobe = search_job->nprobe();
+        const float* vectors = search_job->vectors();
+
+        output_ids.resize(topk * nq);
+        output_distance.resize(topk * nq);
+        std::string hdr =
+            "job " + std::to_string(search_job->id()) + " nq " + std::to_string(nq) + " topk " + std::to_string(topk);
+
+        try {
+            // step 2: search
+            bool hybrid = false;
+            if (index_engine_->IndexEngineType() == engine::EngineType::FAISS_IVFSQ8H &&
+                ResMgrInst::GetInstance()->GetResource(path().Last())->type() == ResourceType::CPU) {
+                hybrid = true;
+            }
+            index_engine_->Search(nq, vectors, topk, nprobe, output_distance.data(), output_ids.data(), hybrid);
+
+            double span = rc.RecordSection(hdr + ", do search");
+            //            search_job->AccumSearchCost(span);
+
+            // step 3: pick up topk result
+            auto spec_k = index_engine_->Count() < topk ? index_engine_->Count() : topk;
+            XSearchTask::MergeTopkToResultSet(output_ids, output_distance, spec_k, nq, topk, metric_l2,
+                                              search_job->GetResult());
+
+            span = rc.RecordSection(hdr + ", reduce topk");
+            //            search_job->AccumReduceCost(span);
+        } catch (std::exception& ex) {
+            ENGINE_LOG_ERROR << "SearchTask encounter exception: " << ex.what();
+            //            search_job->IndexSearchDone(index_id_);//mark as done avoid dead lock, even search failed
+        }
+
+        // step 4: notify to send result to client
+        search_job->SearchDone(index_id_);
+    }
+
+    rc.ElapseFromBegin("totally cost");
+
+    // release index in resource
+    index_engine_ = nullptr;
+}
+
+void
+XSearchTask::MergeTopkToResultSet(const std::vector<int64_t>& input_ids, const std::vector<float>& input_distance,
+                                  uint64_t input_k, uint64_t nq, uint64_t topk, bool ascending,
+                                  scheduler::ResultSet& result) {
+    if (result.empty()) {
+        result.resize(nq);
+    }
+
+    for (uint64_t i = 0; i < nq; i++) {
+        scheduler::Id2DistVec result_buf;
+        auto& result_i = result[i];
+
+        if (result[i].empty()) {
+            result_buf.resize(input_k, scheduler::IdDistPair(-1, 0.0));
+            uint64_t input_k_multi_i = topk * i;
+            for (auto k = 0; k < input_k; ++k) {
+                uint64_t idx = input_k_multi_i + k;
+                auto& result_buf_item = result_buf[k];
+                result_buf_item.first = input_ids[idx];
+                result_buf_item.second = input_distance[idx];
+            }
+        } else {
+            size_t tar_size = result_i.size();
+            uint64_t output_k = std::min(topk, input_k + tar_size);
+            result_buf.resize(output_k, scheduler::IdDistPair(-1, 0.0));
+            size_t buf_k = 0, src_k = 0, tar_k = 0;
+            uint64_t src_idx;
+            uint64_t input_k_multi_i = topk * i;
+            while (buf_k < output_k && src_k < input_k && tar_k < tar_size) {
+                src_idx = input_k_multi_i + src_k;
+                auto& result_buf_item = result_buf[buf_k];
+                auto& result_item = result_i[tar_k];
+                if ((ascending && input_distance[src_idx] < result_item.second) ||
+                    (!ascending && input_distance[src_idx] > result_item.second)) {
+                    result_buf_item.first = input_ids[src_idx];
+                    result_buf_item.second = input_distance[src_idx];
+                    src_k++;
+                } else {
+                    result_buf_item = result_item;
+                    tar_k++;
+                }
+                buf_k++;
+            }
+
+            if (buf_k < output_k) {
+                if (src_k < input_k) {
+                    while (buf_k < output_k && src_k < input_k) {
+                        src_idx = input_k_multi_i + src_k;
+                        auto& result_buf_item = result_buf[buf_k];
+                        result_buf_item.first = input_ids[src_idx];
+                        result_buf_item.second = input_distance[src_idx];
+                        src_k++;
+                        buf_k++;
+                    }
+                } else {
+                    while (buf_k < output_k && tar_k < tar_size) {
+                        result_buf[buf_k] = result_i[tar_k];
+                        tar_k++;
+                        buf_k++;
+                    }
+                }
+            }
+        }
+
+        result_i.swap(result_buf);
+    }
+}
+
+// void
+// XSearchTask::MergeTopkArray(std::vector<int64_t>& tar_ids, std::vector<float>& tar_distance, uint64_t& tar_input_k,
+//                            const std::vector<int64_t>& src_ids, const std::vector<float>& src_distance,
+//                            uint64_t src_input_k, uint64_t nq, uint64_t topk, bool ascending) {
+//    if (src_ids.empty() || src_distance.empty()) {
+//        return;
+//    }
+//
+//    uint64_t output_k = std::min(topk, tar_input_k + src_input_k);
+//    std::vector<int64_t> id_buf(nq * output_k, -1);
+//    std::vector<float> dist_buf(nq * output_k, 0.0);
+//
+//    uint64_t buf_k, src_k, tar_k;
+//    uint64_t src_idx, tar_idx, buf_idx;
+//    uint64_t src_input_k_multi_i, tar_input_k_multi_i, buf_k_multi_i;
+//
+//    for (uint64_t i = 0; i < nq; i++) {
+//        src_input_k_multi_i = src_input_k * i;
+//        tar_input_k_multi_i = tar_input_k * i;
+//        buf_k_multi_i = output_k * i;
+//        buf_k = src_k = tar_k = 0;
+//        while (buf_k < output_k && src_k < src_input_k && tar_k < tar_input_k) {
+//            src_idx = src_input_k_multi_i + src_k;
+//            tar_idx = tar_input_k_multi_i + tar_k;
+//            buf_idx = buf_k_multi_i + buf_k;
+//            if ((ascending && src_distance[src_idx] < tar_distance[tar_idx]) ||
+//                (!ascending && src_distance[src_idx] > tar_distance[tar_idx])) {
+//                id_buf[buf_idx] = src_ids[src_idx];
+//                dist_buf[buf_idx] = src_distance[src_idx];
+//                src_k++;
+//            } else {
+//                id_buf[buf_idx] = tar_ids[tar_idx];
+//                dist_buf[buf_idx] = tar_distance[tar_idx];
+//                tar_k++;
+//            }
+//            buf_k++;
+//        }
+//
+//        if (buf_k < output_k) {
+//            if (src_k < src_input_k) {
+//                while (buf_k < output_k && src_k < src_input_k) {
+//                    src_idx = src_input_k_multi_i + src_k;
+//                    buf_idx = buf_k_multi_i + buf_k;
+//                    id_buf[buf_idx] = src_ids[src_idx];
+//                    dist_buf[buf_idx] = src_distance[src_idx];
+//                    src_k++;
+//                    buf_k++;
+//                }
+//            } else {
+//                while (buf_k < output_k && tar_k < tar_input_k) {
+//                    tar_idx = tar_input_k_multi_i + tar_k;
+//                    buf_idx = buf_k_multi_i + buf_k;
+//                    id_buf[buf_idx] = tar_ids[tar_idx];
+//                    dist_buf[buf_idx] = tar_distance[tar_idx];
+//                    tar_k++;
+//                    buf_k++;
+//                }
+//            }
+//        }
+//    }
+//
+//    tar_ids.swap(id_buf);
+//    tar_distance.swap(dist_buf);
+//    tar_input_k = output_k;
+//}
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/task/SearchTask.h b/core/src/scheduler/task/SearchTask.h
new file mode 100644
index 0000000000..bbc8b5bd8f
--- /dev/null
+++ b/core/src/scheduler/task/SearchTask.h
@@ -0,0 +1,60 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "Task.h"
+#include "scheduler/Definition.h"
+#include "scheduler/job/SearchJob.h"
+
+#include <vector>
+
+namespace milvus {
+namespace scheduler {
+
+// TODO(wxyu): rewrite
+class XSearchTask : public Task {
+ public:
+    explicit XSearchTask(TableFileSchemaPtr file, TaskLabelPtr label);
+
+    void
+    Load(LoadType type, uint8_t device_id) override;
+
+    void
+    Execute() override;
+
+ public:
+    static void
+    MergeTopkToResultSet(const std::vector<int64_t>& input_ids, const std::vector<float>& input_distance,
+                         uint64_t input_k, uint64_t nq, uint64_t topk, bool ascending, scheduler::ResultSet& result);
+
+    //    static void
+    //    MergeTopkArray(std::vector<int64_t>& tar_ids, std::vector<float>& tar_distance, uint64_t& tar_input_k,
+    //                   const std::vector<int64_t>& src_ids, const std::vector<float>& src_distance, uint64_t
+    //                   src_input_k, uint64_t nq, uint64_t topk, bool ascending);
+
+ public:
+    TableFileSchemaPtr file_;
+
+    size_t index_id_ = 0;
+    int index_type_ = 0;
+    ExecutionEnginePtr index_engine_ = nullptr;
+    bool metric_l2 = true;
+};
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/task/Task.h b/core/src/scheduler/task/Task.h
new file mode 100644
index 0000000000..411c18cbde
--- /dev/null
+++ b/core/src/scheduler/task/Task.h
@@ -0,0 +1,95 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "Path.h"
+#include "scheduler/job/Job.h"
+#include "scheduler/tasklabel/TaskLabel.h"
+#include "utils/Status.h"
+
+#include <memory>
+#include <string>
+#include <utility>
+
+namespace milvus {
+namespace scheduler {
+
+enum class LoadType {
+    DISK2CPU,
+    CPU2GPU,
+    GPU2CPU,
+    TEST,
+};
+
+enum class TaskType {
+    SearchTask,
+    DeleteTask,
+    BuildIndexTask,
+    TestTask,
+};
+
+class Task;
+
+using TaskPtr = std::shared_ptr<Task>;
+
+// TODO: re-design
+class Task {
+ public:
+    explicit Task(TaskType type, TaskLabelPtr label) : type_(type), label_(std::move(label)) {
+    }
+
+    /*
+     * Just Getter;
+     */
+    inline TaskType
+    Type() const {
+        return type_;
+    }
+
+    /*
+     * Transport path;
+     */
+    inline Path&
+    path() {
+        return task_path_;
+    }
+
+    /*
+     * Getter and Setter;
+     */
+    inline TaskLabelPtr&
+    label() {
+        return label_;
+    }
+
+ public:
+    virtual void
+    Load(LoadType type, uint8_t device_id) = 0;
+
+    virtual void
+    Execute() = 0;
+
+ public:
+    Path task_path_;
+    scheduler::JobWPtr job_;
+    TaskType type_;
+    TaskLabelPtr label_ = nullptr;
+};
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/task/TestTask.cpp b/core/src/scheduler/task/TestTask.cpp
new file mode 100644
index 0000000000..3ec3a8ab19
--- /dev/null
+++ b/core/src/scheduler/task/TestTask.cpp
@@ -0,0 +1,51 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "scheduler/task/TestTask.h"
+#include "cache/GpuCacheMgr.h"
+
+#include <utility>
+
+namespace milvus {
+namespace scheduler {
+
+TestTask::TestTask(TableFileSchemaPtr& file, TaskLabelPtr label) : XSearchTask(file, std::move(label)) {
+}
+
+void
+TestTask::Load(LoadType type, uint8_t device_id) {
+    load_count_++;
+}
+
+void
+TestTask::Execute() {
+    {
+        std::lock_guard<std::mutex> lock(mutex_);
+        exec_count_++;
+        done_ = true;
+    }
+    cv_.notify_one();
+}
+
+void
+TestTask::Wait() {
+    std::unique_lock<std::mutex> lock(mutex_);
+    cv_.wait(lock, [&] { return done_; });
+}
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/task/TestTask.h b/core/src/scheduler/task/TestTask.h
new file mode 100644
index 0000000000..99b48a8afe
--- /dev/null
+++ b/core/src/scheduler/task/TestTask.h
@@ -0,0 +1,49 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "SearchTask.h"
+
+namespace milvus {
+namespace scheduler {
+
+class TestTask : public XSearchTask {
+ public:
+    explicit TestTask(TableFileSchemaPtr& file, TaskLabelPtr label);
+
+ public:
+    void
+    Load(LoadType type, uint8_t device_id) override;
+
+    void
+    Execute() override;
+
+    void
+    Wait();
+
+ public:
+    uint64_t load_count_ = 0;
+    uint64_t exec_count_ = 0;
+
+    bool done_ = false;
+    std::mutex mutex_;
+    std::condition_variable cv_;
+};
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/tasklabel/BroadcastLabel.h b/core/src/scheduler/tasklabel/BroadcastLabel.h
new file mode 100644
index 0000000000..f0b48afb23
--- /dev/null
+++ b/core/src/scheduler/tasklabel/BroadcastLabel.h
@@ -0,0 +1,36 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "TaskLabel.h"
+
+#include <memory>
+
+namespace milvus {
+namespace scheduler {
+
+class BroadcastLabel : public TaskLabel {
+ public:
+    BroadcastLabel() : TaskLabel(TaskLabelType::BROADCAST) {
+    }
+};
+
+using BroadcastLabelPtr = std::shared_ptr<BroadcastLabel>;
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/tasklabel/DefaultLabel.h b/core/src/scheduler/tasklabel/DefaultLabel.h
new file mode 100644
index 0000000000..c215743575
--- /dev/null
+++ b/core/src/scheduler/tasklabel/DefaultLabel.h
@@ -0,0 +1,36 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "TaskLabel.h"
+
+#include <memory>
+
+namespace milvus {
+namespace scheduler {
+
+class DefaultLabel : public TaskLabel {
+ public:
+    DefaultLabel() : TaskLabel(TaskLabelType::DEFAULT) {
+    }
+};
+
+using DefaultLabelPtr = std::shared_ptr<DefaultLabel>;
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/tasklabel/SpecResLabel.h b/core/src/scheduler/tasklabel/SpecResLabel.h
new file mode 100644
index 0000000000..db2989fbc2
--- /dev/null
+++ b/core/src/scheduler/tasklabel/SpecResLabel.h
@@ -0,0 +1,57 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "TaskLabel.h"
+#include "scheduler/ResourceMgr.h"
+
+#include <memory>
+#include <string>
+
+// class Resource;
+//
+// using ResourceWPtr = std::weak_ptr<Resource>;
+
+namespace milvus {
+namespace scheduler {
+
+class SpecResLabel : public TaskLabel {
+ public:
+    explicit SpecResLabel(const ResourceWPtr& resource)
+        : TaskLabel(TaskLabelType::SPECIFIED_RESOURCE), resource_(resource) {
+    }
+
+    inline ResourceWPtr&
+    resource() {
+        return resource_;
+    }
+
+    inline std::string&
+    resource_name() {
+        return resource_name_;
+    }
+
+ private:
+    ResourceWPtr resource_;
+    std::string resource_name_;
+};
+
+using SpecResLabelPtr = std::shared_ptr<SpecResLabel>();
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/scheduler/tasklabel/TaskLabel.h b/core/src/scheduler/tasklabel/TaskLabel.h
new file mode 100644
index 0000000000..d35ce409ff
--- /dev/null
+++ b/core/src/scheduler/tasklabel/TaskLabel.h
@@ -0,0 +1,49 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <memory>
+
+namespace milvus {
+namespace scheduler {
+
+enum class TaskLabelType {
+    DEFAULT,             // means can be executed in any resource
+    SPECIFIED_RESOURCE,  // means must executing in special resource
+    BROADCAST,           // means all enable-executor resource must execute task
+};
+
+class TaskLabel {
+ public:
+    inline TaskLabelType
+    Type() const {
+        return type_;
+    }
+
+ protected:
+    explicit TaskLabel(TaskLabelType type) : type_(type) {
+    }
+
+ private:
+    TaskLabelType type_;
+};
+
+using TaskLabelPtr = std::shared_ptr<TaskLabel>;
+
+}  // namespace scheduler
+}  // namespace milvus
diff --git a/core/src/sdk/CMakeLists.txt b/core/src/sdk/CMakeLists.txt
new file mode 100644
index 0000000000..a2991a49b4
--- /dev/null
+++ b/core/src/sdk/CMakeLists.txt
@@ -0,0 +1,41 @@
+#-------------------------------------------------------------------------------
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you 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_directories(include)
+
+aux_source_directory(interface interface_files)
+aux_source_directory(grpc grpc_client_files)
+
+add_library(milvus_sdk STATIC
+        ${interface_files}
+        ${grpc_client_files}
+        ${grpc_service_files}
+        )
+
+target_link_libraries(milvus_sdk
+        ${client_grpc_lib}
+        bzip2
+        lz4
+        snappy
+        zlib
+        )
+
+install(TARGETS milvus_sdk DESTINATION lib)
+
+add_subdirectory(examples)
diff --git a/core/src/sdk/examples/CMakeLists.txt b/core/src/sdk/examples/CMakeLists.txt
new file mode 100644
index 0000000000..aa15190178
--- /dev/null
+++ b/core/src/sdk/examples/CMakeLists.txt
@@ -0,0 +1,21 @@
+#-------------------------------------------------------------------------------
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you 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.
+#-------------------------------------------------------------------------------
+
+
+add_subdirectory(grpcsimple)
diff --git a/core/src/sdk/examples/grpcsimple/CMakeLists.txt b/core/src/sdk/examples/grpcsimple/CMakeLists.txt
new file mode 100644
index 0000000000..77542ed2a7
--- /dev/null
+++ b/core/src/sdk/examples/grpcsimple/CMakeLists.txt
@@ -0,0 +1,33 @@
+#-------------------------------------------------------------------------------
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you 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.
+#-------------------------------------------------------------------------------
+
+
+aux_source_directory(src src_files)
+
+add_executable(sdk_simple
+        main.cpp
+        ${src_files}
+        )
+
+target_link_libraries(sdk_simple
+        milvus_sdk
+        pthread
+        )
+
+install(TARGETS sdk_simple DESTINATION bin)
diff --git a/core/src/sdk/examples/grpcsimple/main.cpp b/core/src/sdk/examples/grpcsimple/main.cpp
new file mode 100644
index 0000000000..c31f491afb
--- /dev/null
+++ b/core/src/sdk/examples/grpcsimple/main.cpp
@@ -0,0 +1,79 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 <getopt.h>
+#include <libgen.h>
+#include <cstring>
+#include <string>
+
+#include "src/ClientTest.h"
+
+void
+print_help(const std::string& app_name);
+
+int
+main(int argc, char* argv[]) {
+    printf("Client start...\n");
+
+    std::string app_name = basename(argv[0]);
+    static struct option long_options[] = {{"server", optional_argument, nullptr, 's'},
+                                           {"port", optional_argument, nullptr, 'p'},
+                                           {"help", no_argument, nullptr, 'h'},
+                                           {nullptr, 0, nullptr, 0}};
+
+    int option_index = 0;
+    std::string address = "127.0.0.1", port = "19530";
+    app_name = argv[0];
+
+    int value;
+    while ((value = getopt_long(argc, argv, "s:p:h", long_options, &option_index)) != -1) {
+        switch (value) {
+            case 's': {
+                char* address_ptr = strdup(optarg);
+                address = address_ptr;
+                free(address_ptr);
+                break;
+            }
+            case 'p': {
+                char* port_ptr = strdup(optarg);
+                port = port_ptr;
+                free(port_ptr);
+                break;
+            }
+            case 'h':
+            default:
+                print_help(app_name);
+                return EXIT_SUCCESS;
+        }
+    }
+
+    ClientTest test;
+    test.Test(address, port);
+
+    printf("Client stop...\n");
+    return 0;
+}
+
+void
+print_help(const std::string& app_name) {
+    printf("\n Usage: %s [OPTIONS]\n\n", app_name.c_str());
+    printf("  Options:\n");
+    printf("   -s --server   Server address, default 127.0.0.1\n");
+    printf("   -p --port     Server port, default 19530\n");
+    printf("   -h --help     Print help information\n");
+    printf("\n");
+}
diff --git a/core/src/sdk/examples/grpcsimple/src/ClientTest.cpp b/core/src/sdk/examples/grpcsimple/src/ClientTest.cpp
new file mode 100644
index 0000000000..069283200f
--- /dev/null
+++ b/core/src/sdk/examples/grpcsimple/src/ClientTest.cpp
@@ -0,0 +1,371 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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/examples/grpcsimple/src/ClientTest.h"
+#include "MilvusApi.h"
+
+#include <time.h>
+#include <unistd.h>
+#include <chrono>
+#include <iostream>
+#include <memory>
+#include <thread>
+#include <utility>
+#include <vector>
+
+//#define SET_VECTOR_IDS;
+
+namespace {
+const std::string&
+GetTableName();
+
+const char* TABLE_NAME = GetTableName().c_str();
+constexpr int64_t TABLE_DIMENSION = 512;
+constexpr int64_t TABLE_INDEX_FILE_SIZE = 1024;
+constexpr int64_t BATCH_ROW_COUNT = 100000;
+constexpr int64_t NQ = 5;
+constexpr int64_t TOP_K = 10;
+constexpr int64_t SEARCH_TARGET = 5000;  // change this value, result is different
+constexpr int64_t ADD_VECTOR_LOOP = 5;
+constexpr int64_t SECONDS_EACH_HOUR = 3600;
+constexpr milvus::IndexType INDEX_TYPE = milvus::IndexType::gpu_ivfsq8;
+constexpr int32_t N_LIST = 15000;
+
+#define BLOCK_SPLITER std::cout << "===========================================" << std::endl;
+
+void
+PrintTableSchema(const milvus::TableSchema& tb_schema) {
+    BLOCK_SPLITER
+    std::cout << "Table name: " << tb_schema.table_name << std::endl;
+    std::cout << "Table dimension: " << tb_schema.dimension << std::endl;
+    BLOCK_SPLITER
+}
+
+void
+PrintSearchResult(const std::vector<std::pair<int64_t, milvus::RowRecord>>& search_record_array,
+                  const std::vector<milvus::TopKQueryResult>& topk_query_result_array) {
+    BLOCK_SPLITER
+    std::cout << "Returned result count: " << topk_query_result_array.size() << std::endl;
+
+    int32_t index = 0;
+    for (auto& result : topk_query_result_array) {
+        auto search_id = search_record_array[index].first;
+        index++;
+        std::cout << "No." << std::to_string(index) << " vector " << std::to_string(search_id) << " top "
+                  << std::to_string(result.query_result_arrays.size()) << " search result:" << std::endl;
+        for (auto& item : result.query_result_arrays) {
+            std::cout << "\t" << std::to_string(item.id) << "\tdistance:" << std::to_string(item.distance);
+            std::cout << std::endl;
+        }
+    }
+
+    BLOCK_SPLITER
+}
+
+std::string
+CurrentTime() {
+    time_t tt;
+    time(&tt);
+    tt = tt + 8 * SECONDS_EACH_HOUR;
+    tm t;
+    gmtime_r(&tt, &t);
+
+    std::string str = std::to_string(t.tm_year + 1900) + "_" + std::to_string(t.tm_mon + 1) + "_" +
+                      std::to_string(t.tm_mday) + "_" + std::to_string(t.tm_hour) + "_" + std::to_string(t.tm_min) +
+                      "_" + std::to_string(t.tm_sec);
+
+    return str;
+}
+
+std::string
+CurrentTmDate(int64_t offset_day = 0) {
+    time_t tt;
+    time(&tt);
+    tt = tt + 8 * SECONDS_EACH_HOUR;
+    tt = tt + 24 * SECONDS_EACH_HOUR * offset_day;
+    tm t;
+    gmtime_r(&tt, &t);
+
+    std::string str =
+        std::to_string(t.tm_year + 1900) + "-" + std::to_string(t.tm_mon + 1) + "-" + std::to_string(t.tm_mday);
+
+    return str;
+}
+
+const std::string&
+GetTableName() {
+    static std::string s_id("tbl_" + CurrentTime());
+    return s_id;
+}
+
+milvus::TableSchema
+BuildTableSchema() {
+    milvus::TableSchema tb_schema;
+    tb_schema.table_name = TABLE_NAME;
+    tb_schema.dimension = TABLE_DIMENSION;
+    tb_schema.index_file_size = TABLE_INDEX_FILE_SIZE;
+    tb_schema.metric_type = milvus::MetricType::L2;
+
+    return tb_schema;
+}
+
+void
+BuildVectors(int64_t from, int64_t to, std::vector<milvus::RowRecord>& vector_record_array) {
+    if (to <= from) {
+        return;
+    }
+
+    vector_record_array.clear();
+    for (int64_t k = from; k < to; k++) {
+        milvus::RowRecord record;
+        record.data.resize(TABLE_DIMENSION);
+        for (int64_t i = 0; i < TABLE_DIMENSION; i++) {
+            record.data[i] = (float)(k % (i + 1));
+        }
+
+        vector_record_array.emplace_back(record);
+    }
+}
+
+void
+Sleep(int seconds) {
+    std::cout << "Waiting " << seconds << " seconds ..." << std::endl;
+    sleep(seconds);
+}
+
+class TimeRecorder {
+ public:
+    explicit TimeRecorder(const std::string& title) : title_(title) {
+        start_ = std::chrono::system_clock::now();
+    }
+
+    ~TimeRecorder() {
+        std::chrono::system_clock::time_point end = std::chrono::system_clock::now();
+        int64_t span = (std::chrono::duration_cast<std::chrono::milliseconds>(end - start_)).count();
+        std::cout << title_ << " totally cost: " << span << " ms" << std::endl;
+    }
+
+ private:
+    std::string title_;
+    std::chrono::system_clock::time_point start_;
+};
+
+void
+CheckResult(const std::vector<std::pair<int64_t, milvus::RowRecord>>& search_record_array,
+            const std::vector<milvus::TopKQueryResult>& topk_query_result_array) {
+    BLOCK_SPLITER
+    int64_t index = 0;
+    for (auto& result : topk_query_result_array) {
+        auto result_id = result.query_result_arrays[0].id;
+        auto search_id = search_record_array[index++].first;
+        if (result_id != search_id) {
+            std::cout << "The top 1 result is wrong: " << result_id << " vs. " << search_id << std::endl;
+        } else {
+            std::cout << "Check result sucessfully" << std::endl;
+        }
+    }
+    BLOCK_SPLITER
+}
+
+void
+DoSearch(std::shared_ptr<milvus::Connection> conn,
+         const std::vector<std::pair<int64_t, milvus::RowRecord>>& search_record_array, const std::string& phase_name) {
+    std::vector<milvus::Range> query_range_array;
+    milvus::Range rg;
+    rg.start_value = CurrentTmDate();
+    rg.end_value = CurrentTmDate(1);
+    query_range_array.emplace_back(rg);
+
+    std::vector<milvus::RowRecord> record_array;
+    for (auto& pair : search_record_array) {
+        record_array.push_back(pair.second);
+    }
+
+    auto start = std::chrono::high_resolution_clock::now();
+    std::vector<milvus::TopKQueryResult> topk_query_result_array;
+    {
+        TimeRecorder rc(phase_name);
+        milvus::Status stat =
+            conn->Search(TABLE_NAME, record_array, query_range_array, TOP_K, 32, topk_query_result_array);
+        std::cout << "SearchVector function call status: " << stat.message() << std::endl;
+    }
+    auto finish = std::chrono::high_resolution_clock::now();
+    std::cout << "SEARCHVECTOR COST: "
+              << std::chrono::duration_cast<std::chrono::duration<double>>(finish - start).count() << "s\n";
+
+    PrintSearchResult(search_record_array, topk_query_result_array);
+    CheckResult(search_record_array, topk_query_result_array);
+}
+}  // namespace
+
+void
+ClientTest::Test(const std::string& address, const std::string& port) {
+    std::shared_ptr<milvus::Connection> conn = milvus::Connection::Create();
+
+    {  // connect server
+        milvus::ConnectParam param = {address, port};
+        milvus::Status stat = conn->Connect(param);
+        std::cout << "Connect function call status: " << stat.message() << std::endl;
+    }
+
+    {  // server version
+        std::string version = conn->ServerVersion();
+        std::cout << "Server version: " << version << std::endl;
+    }
+
+    {  // sdk version
+        std::string version = conn->ClientVersion();
+        std::cout << "SDK version: " << version << std::endl;
+    }
+
+    {
+        std::vector<std::string> tables;
+        milvus::Status stat = conn->ShowTables(tables);
+        std::cout << "ShowTables function call status: " << stat.message() << std::endl;
+        std::cout << "All tables: " << std::endl;
+        for (auto& table : tables) {
+            int64_t row_count = 0;
+            //            conn->DropTable(table);
+            stat = conn->CountTable(table, row_count);
+            std::cout << "\t" << table << "(" << row_count << " rows)" << std::endl;
+        }
+    }
+
+    {  // create table
+        milvus::TableSchema tb_schema = BuildTableSchema();
+        milvus::Status stat = conn->CreateTable(tb_schema);
+        std::cout << "CreateTable function call status: " << stat.message() << std::endl;
+        PrintTableSchema(tb_schema);
+
+        bool has_table = conn->HasTable(tb_schema.table_name);
+        if (has_table) {
+            std::cout << "Table is created" << std::endl;
+        }
+    }
+
+    {  // describe table
+        milvus::TableSchema tb_schema;
+        milvus::Status stat = conn->DescribeTable(TABLE_NAME, tb_schema);
+        std::cout << "DescribeTable function call status: " << stat.message() << std::endl;
+        PrintTableSchema(tb_schema);
+    }
+
+    std::vector<std::pair<int64_t, milvus::RowRecord>> search_record_array;
+    {                                                // insert vectors
+        for (int i = 0; i < ADD_VECTOR_LOOP; i++) {  // add vectors
+            std::vector<milvus::RowRecord> record_array;
+            int64_t begin_index = i * BATCH_ROW_COUNT;
+            BuildVectors(begin_index, begin_index + BATCH_ROW_COUNT, record_array);
+
+#ifdef SET_VECTOR_IDS
+            record_ids.resize(ADD_VECTOR_LOOP * BATCH_ROW_COUNT);
+            for (auto j = begin_index; j < begin_index + BATCH_ROW_COUNT; j++) {
+                record_ids[i * BATCH_ROW_COUNT + j] = i * BATCH_ROW_COUNT + j;
+            }
+#endif
+
+            std::vector<int64_t> record_ids;
+            // generate user defined ids
+            for (int k = 0; k < BATCH_ROW_COUNT; k++) {
+                record_ids.push_back(i * BATCH_ROW_COUNT + k);
+            }
+
+            auto start = std::chrono::high_resolution_clock::now();
+
+            milvus::Status stat = conn->Insert(TABLE_NAME, record_array, record_ids);
+            auto finish = std::chrono::high_resolution_clock::now();
+            std::cout << "InsertVector cost: "
+                      << std::chrono::duration_cast<std::chrono::duration<double>>(finish - start).count() << "s\n";
+
+            std::cout << "InsertVector function call status: " << stat.message() << std::endl;
+            std::cout << "Returned id array count: " << record_ids.size() << std::endl;
+
+            if (search_record_array.size() < NQ) {
+                search_record_array.push_back(std::make_pair(record_ids[SEARCH_TARGET], record_array[SEARCH_TARGET]));
+            }
+        }
+    }
+
+    {  // search vectors without index
+        Sleep(2);
+
+        int64_t row_count = 0;
+        milvus::Status stat = conn->CountTable(TABLE_NAME, row_count);
+        std::cout << TABLE_NAME << "(" << row_count << " rows)" << std::endl;
+        //        DoSearch(conn, search_record_array, "Search without index");
+    }
+
+    {  // wait unit build index finish
+        std::cout << "Wait until create all index done" << std::endl;
+        milvus::IndexParam index;
+        index.table_name = TABLE_NAME;
+        index.index_type = INDEX_TYPE;
+        index.nlist = N_LIST;
+        milvus::Status stat = conn->CreateIndex(index);
+        std::cout << "CreateIndex function call status: " << stat.message() << std::endl;
+
+        milvus::IndexParam index2;
+        stat = conn->DescribeIndex(TABLE_NAME, index2);
+        std::cout << "DescribeIndex function call status: " << stat.message() << std::endl;
+    }
+
+    {  // preload table
+        milvus::Status stat = conn->PreloadTable(TABLE_NAME);
+        std::cout << "PreloadTable function call status: " << stat.message() << std::endl;
+    }
+
+    {  // search vectors after build index finish
+        for (uint64_t i = 0; i < 5; ++i) {
+            DoSearch(conn, search_record_array, "Search after build index finish");
+        }
+        //        std::cout << conn->DumpTaskTables() << std::endl;
+    }
+
+    {  // delete index
+        milvus::Status stat = conn->DropIndex(TABLE_NAME);
+        std::cout << "DropIndex function call status: " << stat.message() << std::endl;
+
+        int64_t row_count = 0;
+        stat = conn->CountTable(TABLE_NAME, row_count);
+        std::cout << TABLE_NAME << "(" << row_count << " rows)" << std::endl;
+    }
+
+    {  // delete by range
+        milvus::Range rg;
+        rg.start_value = CurrentTmDate(-3);
+        rg.end_value = CurrentTmDate(-2);
+
+        milvus::Status stat = conn->DeleteByRange(rg, TABLE_NAME);
+        std::cout << "DeleteByRange function call status: " << stat.message() << std::endl;
+    }
+
+    {
+        // delete table
+        //        Status stat = conn->DropTable(TABLE_NAME);
+        //        std::cout << "DeleteTable function call status: " << stat.message() << std::endl;
+    }
+
+    {  // server status
+        std::string status = conn->ServerStatus();
+        std::cout << "Server status before disconnect: " << status << std::endl;
+    }
+    milvus::Connection::Destroy(conn);
+    {  // server status
+        std::string status = conn->ServerStatus();
+        std::cout << "Server status after disconnect: " << status << std::endl;
+    }
+}
diff --git a/core/src/sdk/examples/grpcsimple/src/ClientTest.h b/core/src/sdk/examples/grpcsimple/src/ClientTest.h
new file mode 100644
index 0000000000..b028b63f44
--- /dev/null
+++ b/core/src/sdk/examples/grpcsimple/src/ClientTest.h
@@ -0,0 +1,26 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <string>
+
+class ClientTest {
+ public:
+    void
+    Test(const std::string& address, const std::string& port);
+};
diff --git a/core/src/sdk/grpc/ClientProxy.cpp b/core/src/sdk/grpc/ClientProxy.cpp
new file mode 100644
index 0000000000..7e1955b04b
--- /dev/null
+++ b/core/src/sdk/grpc/ClientProxy.cpp
@@ -0,0 +1,404 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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/grpc/ClientProxy.h"
+#include "../../../version.h"
+#include "grpc/gen-milvus/milvus.grpc.pb.h"
+
+#include <memory>
+#include <string>
+#include <vector>
+
+//#define GRPC_MULTIPLE_THREAD;
+
+namespace milvus {
+bool
+UriCheck(const std::string& uri) {
+    size_t index = uri.find_first_of(':', 0);
+    return (index != std::string::npos);
+}
+
+Status
+ClientProxy::Connect(const ConnectParam& param) {
+    std::string uri = param.ip_address + ":" + param.port;
+
+    channel_ = ::grpc::CreateChannel(uri, ::grpc::InsecureChannelCredentials());
+    if (channel_ != nullptr) {
+        connected_ = true;
+        client_ptr_ = std::make_shared<GrpcClient>(channel_);
+        return Status::OK();
+    }
+
+    std::string reason = "connect failed!";
+    connected_ = false;
+    return Status(StatusCode::NotConnected, reason);
+}
+
+Status
+ClientProxy::Connect(const std::string& uri) {
+    if (!UriCheck(uri)) {
+        return Status(StatusCode::InvalidAgument, "Invalid uri");
+    }
+    size_t index = uri.find_first_of(':', 0);
+
+    ConnectParam param;
+    param.ip_address = uri.substr(0, index);
+    param.port = uri.substr(index + 1);
+
+    return Connect(param);
+}
+
+Status
+ClientProxy::Connected() const {
+    try {
+        std::string info;
+        return client_ptr_->Cmd(info, "");
+    } catch (std::exception& ex) {
+        return Status(StatusCode::NotConnected, "connection lost: " + std::string(ex.what()));
+    }
+}
+
+Status
+ClientProxy::Disconnect() {
+    try {
+        Status status = client_ptr_->Disconnect();
+        connected_ = false;
+        channel_.reset();
+        return status;
+    } catch (std::exception& ex) {
+        return Status(StatusCode::UnknownError, "failed to disconnect: " + std::string(ex.what()));
+    }
+}
+
+std::string
+ClientProxy::ClientVersion() const {
+    return MILVUS_VERSION;
+}
+
+Status
+ClientProxy::CreateTable(const TableSchema& param) {
+    try {
+        ::milvus::grpc::TableSchema schema;
+        schema.set_table_name(param.table_name);
+        schema.set_dimension(param.dimension);
+        schema.set_index_file_size(param.index_file_size);
+        schema.set_metric_type(static_cast<int32_t>(param.metric_type));
+
+        return client_ptr_->CreateTable(schema);
+    } catch (std::exception& ex) {
+        return Status(StatusCode::UnknownError, "failed to create table: " + std::string(ex.what()));
+    }
+}
+
+bool
+ClientProxy::HasTable(const std::string& table_name) {
+    Status status = Status::OK();
+    ::milvus::grpc::TableName grpc_table_name;
+    grpc_table_name.set_table_name(table_name);
+    bool result = client_ptr_->HasTable(grpc_table_name, status);
+    return result;
+}
+
+Status
+ClientProxy::DropTable(const std::string& table_name) {
+    try {
+        ::milvus::grpc::TableName grpc_table_name;
+        grpc_table_name.set_table_name(table_name);
+        return client_ptr_->DropTable(grpc_table_name);
+    } catch (std::exception& ex) {
+        return Status(StatusCode::UnknownError, "failed to drop table: " + std::string(ex.what()));
+    }
+}
+
+Status
+ClientProxy::CreateIndex(const IndexParam& index_param) {
+    try {
+        ::milvus::grpc::IndexParam grpc_index_param;
+        grpc_index_param.set_table_name(index_param.table_name);
+        grpc_index_param.mutable_index()->set_index_type(static_cast<int32_t>(index_param.index_type));
+        grpc_index_param.mutable_index()->set_nlist(index_param.nlist);
+        return client_ptr_->CreateIndex(grpc_index_param);
+    } catch (std::exception& ex) {
+        return Status(StatusCode::UnknownError, "failed to build index: " + std::string(ex.what()));
+    }
+}
+
+Status
+ClientProxy::Insert(const std::string& table_name, const std::vector<RowRecord>& record_array,
+                    std::vector<int64_t>& id_array) {
+    Status status = Status::OK();
+    try {
+////////////////////////////////////////////////////////////////////////////
+#ifdef GRPC_MULTIPLE_THREAD
+        std::vector<std::thread> threads;
+        int thread_count = 10;
+
+        std::shared_ptr<::milvus::grpc::InsertInfos> insert_info_array(
+            new ::milvus::grpc::InsertInfos[thread_count], std::default_delete<::milvus::grpc::InsertInfos[]>());
+
+        std::shared_ptr<::milvus::grpc::VectorIds> vector_ids_array(new ::milvus::grpc::VectorIds[thread_count],
+                                                                    std::default_delete<::milvus::grpc::VectorIds[]>());
+
+        int64_t record_count = record_array.size() / thread_count;
+
+        for (size_t i = 0; i < thread_count; i++) {
+            insert_info_array.get()[i].set_table_name(table_name);
+            for (size_t j = i * record_count; j < record_count * (i + 1); j++) {
+                ::milvus::grpc::RowRecord* grpc_record = insert_info_array.get()[i].add_row_record_array();
+                for (size_t k = 0; k < record_array[j].data.size(); k++) {
+                    grpc_record->add_vector_data(record_array[j].data[k]);
+                }
+            }
+        }
+
+        std::cout << "*****************************************************\n";
+        auto start = std::chrono::high_resolution_clock::now();
+        for (size_t j = 0; j < thread_count; j++) {
+            threads.push_back(std::thread(&GrpcClient::InsertVector, client_ptr_, std::ref(vector_ids_array.get()[j]),
+                                          std::ref(insert_info_array.get()[j]), std::ref(status)));
+        }
+        std::for_each(threads.begin(), threads.end(), std::mem_fn(&std::thread::join));
+        auto finish = std::chrono::high_resolution_clock::now();
+        std::cout << "InsertVector cost: "
+                  << std::chrono::duration_cast<std::chrono::duration<double>>(finish - start).count() << "s\n";
+        std::cout << "*****************************************************\n";
+
+        for (size_t i = 0; i < thread_count; i++) {
+            for (size_t j = 0; j < vector_ids_array.get()[i].vector_id_array_size(); j++) {
+                id_array.push_back(vector_ids_array.get()[i].vector_id_array(j));
+            }
+        }
+#else
+        ::milvus::grpc::InsertParam insert_param;
+        insert_param.set_table_name(table_name);
+
+        for (auto& record : record_array) {
+            ::milvus::grpc::RowRecord* grpc_record = insert_param.add_row_record_array();
+            for (size_t i = 0; i < record.data.size(); i++) {
+                grpc_record->add_vector_data(record.data[i]);
+            }
+        }
+
+        // Single thread
+        ::milvus::grpc::VectorIds vector_ids;
+        if (!id_array.empty()) {
+            for (auto i = 0; i < id_array.size(); i++) {
+                insert_param.add_row_id_array(id_array[i]);
+            }
+            client_ptr_->Insert(vector_ids, insert_param, status);
+        } else {
+            client_ptr_->Insert(vector_ids, insert_param, status);
+            for (size_t i = 0; i < vector_ids.vector_id_array_size(); i++) {
+                id_array.push_back(vector_ids.vector_id_array(i));
+            }
+        }
+#endif
+    } catch (std::exception& ex) {
+        return Status(StatusCode::UnknownError, "fail to add vector: " + std::string(ex.what()));
+    }
+
+    return status;
+}
+
+Status
+ClientProxy::Search(const std::string& table_name, const std::vector<RowRecord>& query_record_array,
+                    const std::vector<Range>& query_range_array, int64_t topk, int64_t nprobe,
+                    std::vector<TopKQueryResult>& topk_query_result_array) {
+    try {
+        // step 1: convert vectors data
+        ::milvus::grpc::SearchParam search_param;
+        search_param.set_table_name(table_name);
+        search_param.set_topk(topk);
+        search_param.set_nprobe(nprobe);
+        for (auto& record : query_record_array) {
+            ::milvus::grpc::RowRecord* row_record = search_param.add_query_record_array();
+            for (auto& rec : record.data) {
+                row_record->add_vector_data(rec);
+            }
+        }
+
+        // step 2: convert range array
+        for (auto& range : query_range_array) {
+            ::milvus::grpc::Range* grpc_range = search_param.add_query_range_array();
+            grpc_range->set_start_value(range.start_value);
+            grpc_range->set_end_value(range.end_value);
+        }
+
+        // step 3: search vectors
+        ::milvus::grpc::TopKQueryResultList topk_query_result_list;
+        Status status = client_ptr_->Search(topk_query_result_list, search_param);
+
+        // step 4: convert result array
+        for (uint64_t i = 0; i < topk_query_result_list.topk_query_result_size(); ++i) {
+            TopKQueryResult result;
+            for (uint64_t j = 0; j < topk_query_result_list.topk_query_result(i).query_result_arrays_size(); ++j) {
+                QueryResult query_result;
+                query_result.id = topk_query_result_list.topk_query_result(i).query_result_arrays(j).id();
+                query_result.distance = topk_query_result_list.topk_query_result(i).query_result_arrays(j).distance();
+                result.query_result_arrays.emplace_back(query_result);
+            }
+
+            topk_query_result_array.emplace_back(result);
+        }
+        return status;
+    } catch (std::exception& ex) {
+        return Status(StatusCode::UnknownError, "fail to search vectors: " + std::string(ex.what()));
+    }
+}
+
+Status
+ClientProxy::DescribeTable(const std::string& table_name, TableSchema& table_schema) {
+    try {
+        ::milvus::grpc::TableSchema grpc_schema;
+
+        Status status = client_ptr_->DescribeTable(grpc_schema, table_name);
+
+        table_schema.table_name = grpc_schema.table_name();
+        table_schema.dimension = grpc_schema.dimension();
+        table_schema.index_file_size = grpc_schema.index_file_size();
+        table_schema.metric_type = static_cast<MetricType>(grpc_schema.metric_type());
+
+        return status;
+    } catch (std::exception& ex) {
+        return Status(StatusCode::UnknownError, "fail to describe table: " + std::string(ex.what()));
+    }
+}
+
+Status
+ClientProxy::CountTable(const std::string& table_name, int64_t& row_count) {
+    try {
+        Status status;
+        row_count = client_ptr_->CountTable(table_name, status);
+        return status;
+    } catch (std::exception& ex) {
+        return Status(StatusCode::UnknownError, "fail to show tables: " + std::string(ex.what()));
+    }
+}
+
+Status
+ClientProxy::ShowTables(std::vector<std::string>& table_array) {
+    try {
+        Status status;
+        milvus::grpc::TableNameList table_name_list;
+        status = client_ptr_->ShowTables(table_name_list);
+
+        table_array.resize(table_name_list.table_names_size());
+        for (uint64_t i = 0; i < table_name_list.table_names_size(); ++i) {
+            table_array[i] = table_name_list.table_names(i);
+        }
+        return status;
+    } catch (std::exception& ex) {
+        return Status(StatusCode::UnknownError, "fail to show tables: " + std::string(ex.what()));
+    }
+}
+
+std::string
+ClientProxy::ServerVersion() const {
+    Status status = Status::OK();
+    try {
+        std::string version;
+        Status status = client_ptr_->Cmd(version, "version");
+        return version;
+    } catch (std::exception& ex) {
+        return "";
+    }
+}
+
+std::string
+ClientProxy::ServerStatus() const {
+    if (channel_ == nullptr) {
+        return "not connected to server";
+    }
+
+    try {
+        std::string dummy;
+        Status status = client_ptr_->Cmd(dummy, "");
+        return "server alive";
+    } catch (std::exception& ex) {
+        return "connection lost";
+    }
+}
+
+std::string
+ClientProxy::DumpTaskTables() const {
+    if (channel_ == nullptr) {
+        return "not connected to server";
+    }
+
+    try {
+        std::string dummy;
+        Status status = client_ptr_->Cmd(dummy, "tasktable");
+        return dummy;
+    } catch (std::exception& ex) {
+        return "connection lost";
+    }
+}
+
+Status
+ClientProxy::DeleteByRange(milvus::Range& range, const std::string& table_name) {
+    try {
+        ::milvus::grpc::DeleteByRangeParam delete_by_range_param;
+        delete_by_range_param.set_table_name(table_name);
+        delete_by_range_param.mutable_range()->set_start_value(range.start_value);
+        delete_by_range_param.mutable_range()->set_end_value(range.end_value);
+        return client_ptr_->DeleteByRange(delete_by_range_param);
+    } catch (std::exception& ex) {
+        return Status(StatusCode::UnknownError, "fail to delete by range: " + std::string(ex.what()));
+    }
+}
+
+Status
+ClientProxy::PreloadTable(const std::string& table_name) const {
+    try {
+        ::milvus::grpc::TableName grpc_table_name;
+        grpc_table_name.set_table_name(table_name);
+        Status status = client_ptr_->PreloadTable(grpc_table_name);
+        return status;
+    } catch (std::exception& ex) {
+        return Status(StatusCode::UnknownError, "fail to preload tables: " + std::string(ex.what()));
+    }
+}
+
+Status
+ClientProxy::DescribeIndex(const std::string& table_name, IndexParam& index_param) const {
+    try {
+        ::milvus::grpc::TableName grpc_table_name;
+        grpc_table_name.set_table_name(table_name);
+        ::milvus::grpc::IndexParam grpc_index_param;
+        Status status = client_ptr_->DescribeIndex(grpc_table_name, grpc_index_param);
+        index_param.index_type = static_cast<IndexType>(grpc_index_param.mutable_index()->index_type());
+        index_param.nlist = grpc_index_param.mutable_index()->nlist();
+
+        return status;
+    } catch (std::exception& ex) {
+        return Status(StatusCode::UnknownError, "fail to describe index: " + std::string(ex.what()));
+    }
+}
+
+Status
+ClientProxy::DropIndex(const std::string& table_name) const {
+    try {
+        ::milvus::grpc::TableName grpc_table_name;
+        grpc_table_name.set_table_name(table_name);
+        Status status = client_ptr_->DropIndex(grpc_table_name);
+        return status;
+    } catch (std::exception& ex) {
+        return Status(StatusCode::UnknownError, "fail to drop index: " + std::string(ex.what()));
+    }
+}
+
+}  // namespace milvus
diff --git a/core/src/sdk/grpc/ClientProxy.h b/core/src/sdk/grpc/ClientProxy.h
new file mode 100644
index 0000000000..dbeacc1380
--- /dev/null
+++ b/core/src/sdk/grpc/ClientProxy.h
@@ -0,0 +1,106 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "GrpcClient.h"
+#include "MilvusApi.h"
+
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace milvus {
+
+class ClientProxy : public Connection {
+ public:
+    // Implementations of the Connection interface
+    Status
+    Connect(const ConnectParam& param) override;
+
+    Status
+    Connect(const std::string& uri) override;
+
+    Status
+    Connected() const override;
+
+    Status
+    Disconnect() override;
+
+    Status
+    CreateTable(const TableSchema& param) override;
+
+    bool
+    HasTable(const std::string& table_name) override;
+
+    Status
+    DropTable(const std::string& table_name) override;
+
+    Status
+    CreateIndex(const IndexParam& index_param) override;
+
+    Status
+    Insert(const std::string& table_name, const std::vector<RowRecord>& record_array,
+           std::vector<int64_t>& id_array) override;
+
+    Status
+    Search(const std::string& table_name, const std::vector<RowRecord>& query_record_array,
+           const std::vector<Range>& query_range_array, int64_t topk, int64_t nprobe,
+           std::vector<TopKQueryResult>& topk_query_result_array) override;
+
+    Status
+    DescribeTable(const std::string& table_name, TableSchema& table_schema) override;
+
+    Status
+    CountTable(const std::string& table_name, int64_t& row_count) override;
+
+    Status
+    ShowTables(std::vector<std::string>& table_array) override;
+
+    std::string
+    ClientVersion() const override;
+
+    std::string
+    ServerVersion() const override;
+
+    std::string
+    ServerStatus() const override;
+
+    std::string
+    DumpTaskTables() const override;
+
+    Status
+    DeleteByRange(Range& range, const std::string& table_name) override;
+
+    Status
+    PreloadTable(const std::string& table_name) const override;
+
+    Status
+    DescribeIndex(const std::string& table_name, IndexParam& index_param) const override;
+
+    Status
+    DropIndex(const std::string& table_name) const override;
+
+ private:
+    std::shared_ptr<::grpc::Channel> channel_;
+
+ private:
+    std::shared_ptr<GrpcClient> client_ptr_;
+    bool connected_ = false;
+};
+
+}  // namespace milvus
diff --git a/core/src/sdk/grpc/GrpcClient.cpp b/core/src/sdk/grpc/GrpcClient.cpp
new file mode 100644
index 0000000000..5c27c3b73f
--- /dev/null
+++ b/core/src/sdk/grpc/GrpcClient.cpp
@@ -0,0 +1,320 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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/grpc/GrpcClient.h"
+
+#include <grpc/grpc.h>
+#include <grpcpp/channel.h>
+#include <grpcpp/client_context.h>
+#include <grpcpp/create_channel.h>
+#include <grpcpp/security/credentials.h>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+using grpc::Channel;
+using grpc::ClientContext;
+using grpc::ClientReader;
+using grpc::ClientReaderWriter;
+using grpc::ClientWriter;
+using grpc::Status;
+
+namespace milvus {
+GrpcClient::GrpcClient(std::shared_ptr<::grpc::Channel>& channel)
+    : stub_(::milvus::grpc::MilvusService::NewStub(channel)) {
+}
+
+GrpcClient::~GrpcClient() = default;
+
+Status
+GrpcClient::CreateTable(const ::milvus::grpc::TableSchema& table_schema) {
+    ClientContext context;
+    grpc::Status response;
+    ::grpc::Status grpc_status = stub_->CreateTable(&context, table_schema, &response);
+
+    if (!grpc_status.ok()) {
+        std::cerr << "CreateTable gRPC failed!" << std::endl;
+        return Status(StatusCode::RPCFailed, grpc_status.error_message());
+    }
+
+    if (response.error_code() != grpc::SUCCESS) {
+        std::cerr << response.reason() << std::endl;
+        return Status(StatusCode::ServerFailed, response.reason());
+    }
+    return Status::OK();
+}
+
+bool
+GrpcClient::HasTable(const ::milvus::grpc::TableName& table_name, Status& status) {
+    ClientContext context;
+    ::milvus::grpc::BoolReply response;
+    ::grpc::Status grpc_status = stub_->HasTable(&context, table_name, &response);
+
+    if (!grpc_status.ok()) {
+        std::cerr << "HasTable gRPC failed!" << std::endl;
+        status = Status(StatusCode::RPCFailed, grpc_status.error_message());
+    }
+    if (response.status().error_code() != grpc::SUCCESS) {
+        std::cerr << response.status().reason() << std::endl;
+        status = Status(StatusCode::ServerFailed, response.status().reason());
+    }
+    status = Status::OK();
+    return response.bool_reply();
+}
+
+Status
+GrpcClient::DropTable(const ::milvus::grpc::TableName& table_name) {
+    ClientContext context;
+    grpc::Status response;
+    ::grpc::Status grpc_status = stub_->DropTable(&context, table_name, &response);
+
+    if (!grpc_status.ok()) {
+        std::cerr << "DropTable gRPC failed!" << std::endl;
+        return Status(StatusCode::RPCFailed, grpc_status.error_message());
+    }
+    if (response.error_code() != grpc::SUCCESS) {
+        std::cerr << response.reason() << std::endl;
+        return Status(StatusCode::ServerFailed, response.reason());
+    }
+
+    return Status::OK();
+}
+
+Status
+GrpcClient::CreateIndex(const ::milvus::grpc::IndexParam& index_param) {
+    ClientContext context;
+    grpc::Status response;
+    ::grpc::Status grpc_status = stub_->CreateIndex(&context, index_param, &response);
+
+    if (!grpc_status.ok()) {
+        std::cerr << "BuildIndex rpc failed!" << std::endl;
+        return Status(StatusCode::RPCFailed, grpc_status.error_message());
+    }
+    if (response.error_code() != grpc::SUCCESS) {
+        std::cerr << response.reason() << std::endl;
+        return Status(StatusCode::ServerFailed, response.reason());
+    }
+
+    return Status::OK();
+}
+
+void
+GrpcClient::Insert(::milvus::grpc::VectorIds& vector_ids, const ::milvus::grpc::InsertParam& insert_param,
+                   Status& status) {
+    ClientContext context;
+    ::grpc::Status grpc_status = stub_->Insert(&context, insert_param, &vector_ids);
+
+    if (!grpc_status.ok()) {
+        std::cerr << "InsertVector rpc failed!" << std::endl;
+        status = Status(StatusCode::RPCFailed, grpc_status.error_message());
+        return;
+    }
+    if (vector_ids.status().error_code() != grpc::SUCCESS) {
+        std::cerr << vector_ids.status().reason() << std::endl;
+        status = Status(StatusCode::ServerFailed, vector_ids.status().reason());
+        return;
+    }
+
+    status = Status::OK();
+}
+
+Status
+GrpcClient::Search(::milvus::grpc::TopKQueryResultList& topk_query_result_list,
+                   const ::milvus::grpc::SearchParam& search_param) {
+    ::milvus::grpc::TopKQueryResult query_result;
+    ClientContext context;
+    ::grpc::Status grpc_status = stub_->Search(&context, search_param, &topk_query_result_list);
+
+    if (!grpc_status.ok()) {
+        std::cerr << "SearchVector rpc failed!" << std::endl;
+        std::cerr << grpc_status.error_message() << std::endl;
+        return Status(StatusCode::RPCFailed, grpc_status.error_message());
+    }
+    if (topk_query_result_list.status().error_code() != grpc::SUCCESS) {
+        std::cerr << topk_query_result_list.status().reason() << std::endl;
+        return Status(StatusCode::ServerFailed, topk_query_result_list.status().reason());
+    }
+
+    return Status::OK();
+}
+
+Status
+GrpcClient::DescribeTable(::milvus::grpc::TableSchema& grpc_schema, const std::string& table_name) {
+    ClientContext context;
+    ::milvus::grpc::TableName grpc_tablename;
+    grpc_tablename.set_table_name(table_name);
+    ::grpc::Status grpc_status = stub_->DescribeTable(&context, grpc_tablename, &grpc_schema);
+
+    if (!grpc_status.ok()) {
+        std::cerr << "DescribeTable rpc failed!" << std::endl;
+        std::cerr << grpc_status.error_message() << std::endl;
+        return Status(StatusCode::RPCFailed, grpc_status.error_message());
+    }
+
+    if (grpc_schema.status().error_code() != grpc::SUCCESS) {
+        std::cerr << grpc_schema.status().reason() << std::endl;
+        return Status(StatusCode::ServerFailed, grpc_schema.status().reason());
+    }
+
+    return Status::OK();
+}
+
+int64_t
+GrpcClient::CountTable(const std::string& table_name, Status& status) {
+    ClientContext context;
+    ::milvus::grpc::TableRowCount response;
+    ::milvus::grpc::TableName grpc_tablename;
+    grpc_tablename.set_table_name(table_name);
+    ::grpc::Status grpc_status = stub_->CountTable(&context, grpc_tablename, &response);
+
+    if (!grpc_status.ok()) {
+        std::cerr << "DescribeTable rpc failed!" << std::endl;
+        status = Status(StatusCode::RPCFailed, grpc_status.error_message());
+        return -1;
+    }
+
+    if (response.status().error_code() != grpc::SUCCESS) {
+        std::cerr << response.status().reason() << std::endl;
+        status = Status(StatusCode::ServerFailed, response.status().reason());
+        return -1;
+    }
+
+    status = Status::OK();
+    return response.table_row_count();
+}
+
+Status
+GrpcClient::ShowTables(milvus::grpc::TableNameList& table_name_list) {
+    ClientContext context;
+    ::milvus::grpc::Command command;
+    ::grpc::Status grpc_status = stub_->ShowTables(&context, command, &table_name_list);
+
+    if (!grpc_status.ok()) {
+        std::cerr << "ShowTables gRPC failed!" << std::endl;
+        std::cerr << grpc_status.error_message() << std::endl;
+        return Status(StatusCode::RPCFailed, grpc_status.error_message());
+    }
+
+    if (table_name_list.status().error_code() != grpc::SUCCESS) {
+        std::cerr << table_name_list.status().reason() << std::endl;
+        return Status(StatusCode::ServerFailed, table_name_list.status().reason());
+    }
+
+    return Status::OK();
+}
+
+Status
+GrpcClient::Cmd(std::string& result, const std::string& cmd) {
+    ClientContext context;
+    ::milvus::grpc::StringReply response;
+    ::milvus::grpc::Command command;
+    command.set_cmd(cmd);
+    ::grpc::Status grpc_status = stub_->Cmd(&context, command, &response);
+
+    result = response.string_reply();
+    if (!grpc_status.ok()) {
+        std::cerr << "Cmd gRPC failed!" << std::endl;
+        return Status(StatusCode::RPCFailed, grpc_status.error_message());
+    }
+
+    if (response.status().error_code() != grpc::SUCCESS) {
+        std::cerr << response.status().reason() << std::endl;
+        return Status(StatusCode::ServerFailed, response.status().reason());
+    }
+
+    return Status::OK();
+}
+
+Status
+GrpcClient::PreloadTable(milvus::grpc::TableName& table_name) {
+    ClientContext context;
+    ::milvus::grpc::Status response;
+    ::grpc::Status grpc_status = stub_->PreloadTable(&context, table_name, &response);
+
+    if (!grpc_status.ok()) {
+        std::cerr << "PreloadTable gRPC failed!" << std::endl;
+        return Status(StatusCode::RPCFailed, grpc_status.error_message());
+    }
+
+    if (response.error_code() != grpc::SUCCESS) {
+        std::cerr << response.reason() << std::endl;
+        return Status(StatusCode::ServerFailed, response.reason());
+    }
+    return Status::OK();
+}
+
+Status
+GrpcClient::DeleteByRange(grpc::DeleteByRangeParam& delete_by_range_param) {
+    ClientContext context;
+    ::milvus::grpc::Status response;
+    ::grpc::Status grpc_status = stub_->DeleteByRange(&context, delete_by_range_param, &response);
+
+    if (!grpc_status.ok()) {
+        std::cerr << "DeleteByRange gRPC failed!" << std::endl;
+        return Status(StatusCode::RPCFailed, grpc_status.error_message());
+    }
+
+    if (response.error_code() != grpc::SUCCESS) {
+        std::cerr << response.reason() << std::endl;
+        return Status(StatusCode::ServerFailed, response.reason());
+    }
+    return Status::OK();
+}
+
+Status
+GrpcClient::Disconnect() {
+    stub_.release();
+    return Status::OK();
+}
+
+Status
+GrpcClient::DescribeIndex(grpc::TableName& table_name, grpc::IndexParam& index_param) {
+    ClientContext context;
+    ::grpc::Status grpc_status = stub_->DescribeIndex(&context, table_name, &index_param);
+
+    if (!grpc_status.ok()) {
+        std::cerr << "DescribeIndex rpc failed!" << std::endl;
+        return Status(StatusCode::RPCFailed, grpc_status.error_message());
+    }
+    if (index_param.status().error_code() != grpc::SUCCESS) {
+        std::cerr << index_param.status().reason() << std::endl;
+        return Status(StatusCode::ServerFailed, index_param.status().reason());
+    }
+
+    return Status::OK();
+}
+
+Status
+GrpcClient::DropIndex(grpc::TableName& table_name) {
+    ClientContext context;
+    ::milvus::grpc::Status response;
+    ::grpc::Status grpc_status = stub_->DropIndex(&context, table_name, &response);
+
+    if (!grpc_status.ok()) {
+        std::cerr << "DropIndex gRPC failed!" << std::endl;
+        return Status(StatusCode::RPCFailed, grpc_status.error_message());
+    }
+
+    if (response.error_code() != grpc::SUCCESS) {
+        std::cerr << response.reason() << std::endl;
+        return Status(StatusCode::ServerFailed, response.reason());
+    }
+    return Status::OK();
+}
+
+}  // namespace milvus
diff --git a/core/src/sdk/grpc/GrpcClient.h b/core/src/sdk/grpc/GrpcClient.h
new file mode 100644
index 0000000000..d2e6ae5095
--- /dev/null
+++ b/core/src/sdk/grpc/GrpcClient.h
@@ -0,0 +1,93 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "MilvusApi.h"
+#include "grpc/gen-milvus/milvus.grpc.pb.h"
+//#include "grpc/gen-status/status.grpc.pb.h"
+
+#include <chrono>
+#include <iostream>
+#include <memory>
+#include <random>
+#include <string>
+#include <thread>
+
+#include <grpc/grpc.h>
+#include <grpcpp/channel.h>
+#include <grpcpp/client_context.h>
+#include <grpcpp/create_channel.h>
+#include <grpcpp/security/credentials.h>
+
+namespace milvus {
+class GrpcClient {
+ public:
+    explicit GrpcClient(std::shared_ptr<::grpc::Channel>& channel);
+
+    virtual ~GrpcClient();
+
+    Status
+    CreateTable(const grpc::TableSchema& table_schema);
+
+    bool
+    HasTable(const grpc::TableName& table_name, Status& status);
+
+    Status
+    DropTable(const grpc::TableName& table_name);
+
+    Status
+    CreateIndex(const grpc::IndexParam& index_param);
+
+    void
+    Insert(grpc::VectorIds& vector_ids, const grpc::InsertParam& insert_param, Status& status);
+
+    Status
+    Search(::milvus::grpc::TopKQueryResultList& topk_query_result_list, const grpc::SearchParam& search_param);
+
+    Status
+    DescribeTable(grpc::TableSchema& grpc_schema, const std::string& table_name);
+
+    int64_t
+    CountTable(const std::string& table_name, Status& status);
+
+    Status
+    ShowTables(milvus::grpc::TableNameList& table_name_list);
+
+    Status
+    Cmd(std::string& result, const std::string& cmd);
+
+    Status
+    DeleteByRange(grpc::DeleteByRangeParam& delete_by_range_param);
+
+    Status
+    PreloadTable(grpc::TableName& table_name);
+
+    Status
+    DescribeIndex(grpc::TableName& table_name, grpc::IndexParam& index_param);
+
+    Status
+    DropIndex(grpc::TableName& table_name);
+
+    Status
+    Disconnect();
+
+ private:
+    std::unique_ptr<grpc::MilvusService::Stub> stub_;
+};
+
+}  // namespace milvus
diff --git a/core/src/sdk/include/MilvusApi.h b/core/src/sdk/include/MilvusApi.h
new file mode 100644
index 0000000000..68fe0e9d5c
--- /dev/null
+++ b/core/src/sdk/include/MilvusApi.h
@@ -0,0 +1,387 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "Status.h"
+
+#include <memory>
+#include <string>
+#include <vector>
+
+/** \brief Milvus SDK namespace
+ */
+namespace milvus {
+
+/**
+ * @brief Index Type
+ */
+enum class IndexType {
+    invalid = 0,
+    cpu_idmap,
+    gpu_ivfflat,
+    gpu_ivfsq8,
+    mix_nsg,
+    ivfsq8h,
+};
+
+enum class MetricType {
+    L2 = 1,
+    IP = 2,
+};
+
+/**
+ * @brief Connect API parameter
+ */
+struct ConnectParam {
+    std::string ip_address;  ///< Server IP address
+    std::string port;        ///< Server PORT
+};
+
+/**
+ * @brief Table Schema
+ */
+struct TableSchema {
+    std::string table_name;                   ///< Table name
+    int64_t dimension = 0;                    ///< Vector dimension, must be a positive value
+    int64_t index_file_size = 0;              ///< Index file size, must be a positive value
+    MetricType metric_type = MetricType::L2;  ///< Index metric type
+};
+
+/**
+ * @brief Range information
+ * for DATE partition, the format is like: 'year-month-day'
+ */
+struct Range {
+    std::string start_value;  ///< Range start
+    std::string end_value;    ///< Range stop
+};
+
+/**
+ * @brief Record inserted
+ */
+struct RowRecord {
+    std::vector<float> data;  ///< Vector raw data
+};
+
+/**
+ * @brief Query result
+ */
+struct QueryResult {
+    int64_t id;       ///< Output result
+    double distance;  ///< Vector similarity distance
+};
+
+/**
+ * @brief TopK query result
+ */
+struct TopKQueryResult {
+    std::vector<QueryResult> query_result_arrays;  ///< TopK query result
+};
+
+/**
+ * @brief index parameters
+ */
+struct IndexParam {
+    std::string table_name;
+    IndexType index_type;
+    int32_t nlist;
+};
+
+/**
+ * @brief SDK main class
+ */
+class Connection {
+ public:
+    /**
+     * @brief CreateConnection
+     *
+     * Create a connection instance and return it's shared pointer
+     *
+     * @return Connection instance pointer
+     */
+
+    static std::shared_ptr<Connection>
+    Create();
+
+    /**
+     * @brief DestroyConnection
+     *
+     * Destroy the connection instance
+     *
+     * @param connection, the shared pointer to the instance to be destroyed
+     *
+     * @return if destroy is successful
+     */
+
+    static Status
+    Destroy(std::shared_ptr<Connection>& connection_ptr);
+
+    /**
+     * @brief Connect
+     *
+     * Connect function should be called before any operations
+     * Server will be connected after Connect return OK
+     *
+     * @param param, use to provide server information
+     *
+     * @return Indicate if connect is successful
+     */
+
+    virtual Status
+    Connect(const ConnectParam& param) = 0;
+
+    /**
+     * @brief Connect
+     *
+     * Connect function should be called before any operations
+     * Server will be connected after Connect return OK
+     *
+     * @param uri, use to provide server information, example: milvus://ipaddress:port
+     *
+     * @return Indicate if connect is successful
+     */
+    virtual Status
+    Connect(const std::string& uri) = 0;
+
+    /**
+     * @brief connected
+     *
+     * Connection status.
+     *
+     * @return Indicate if connection status
+     */
+    virtual Status
+    Connected() const = 0;
+
+    /**
+     * @brief Disconnect
+     *
+     * Server will be disconnected after Disconnect return OK
+     *
+     * @return Indicate if disconnect is successful
+     */
+    virtual Status
+    Disconnect() = 0;
+
+    /**
+     * @brief Create table method
+     *
+     * This method is used to create table
+     *
+     * @param param, use to provide table information to be created.
+     *
+     * @return Indicate if table is created successfully
+     */
+    virtual Status
+    CreateTable(const TableSchema& param) = 0;
+
+    /**
+     * @brief Test table existence method
+     *
+     * This method is used to create table
+     *
+     * @param table_name, table name is going to be tested.
+     *
+     * @return Indicate if table is cexist
+     */
+    virtual bool
+    HasTable(const std::string& table_name) = 0;
+
+    /**
+     * @brief Delete table method
+     *
+     * This method is used to delete table.
+     *
+     * @param table_name, table name is going to be deleted.
+     *
+     * @return Indicate if table is delete successfully.
+     */
+    virtual Status
+    DropTable(const std::string& table_name) = 0;
+
+    /**
+     * @brief Create index method
+     *
+     * This method is used to create index for whole table
+     *
+     * @param IndexParam
+     *  table_name, table name is going to be create index.
+     *  index type,
+     *  nlist,
+     *  index file size
+     *
+     * @return Indicate if build index successfully.
+     */
+    virtual Status
+    CreateIndex(const IndexParam& index_param) = 0;
+
+    /**
+     * @brief Add vector to table
+     *
+     * This method is used to add vector array to table.
+     *
+     * @param table_name, table_name is inserted.
+     * @param record_array, vector array is inserted.
+     * @param id_array, after inserted every vector is given a id.
+     *
+     * @return Indicate if vector array are inserted successfully
+     */
+    virtual Status
+    Insert(const std::string& table_name, const std::vector<RowRecord>& record_array,
+           std::vector<int64_t>& id_array) = 0;
+
+    /**
+     * @brief Search vector
+     *
+     * This method is used to query vector in table.
+     *
+     * @param table_name, table_name is queried.
+     * @param query_record_array, all vector are going to be queried.
+     * @param query_range_array, time ranges, if not specified, will search in whole table
+     * @param topk, how many similarity vectors will be searched.
+     * @param topk_query_result_array, result array.
+     *
+     * @return Indicate if query is successful.
+     */
+    virtual Status
+    Search(const std::string& table_name, const std::vector<RowRecord>& query_record_array,
+           const std::vector<Range>& query_range_array, int64_t topk, int64_t nprobe,
+           std::vector<TopKQueryResult>& topk_query_result_array) = 0;
+
+    /**
+     * @brief Show table description
+     *
+     * This method is used to show table information.
+     *
+     * @param table_name, which table is show.
+     * @param table_schema, table_schema is given when operation is successful.
+     *
+     * @return Indicate if this operation is successful.
+     */
+    virtual Status
+    DescribeTable(const std::string& table_name, TableSchema& table_schema) = 0;
+
+    /**
+     * @brief Get table row count
+     *
+     * This method is used to get table row count.
+     *
+     * @param table_name, table's name.
+     * @param row_count, table total row count.
+     *
+     * @return Indicate if this operation is successful.
+     */
+    virtual Status
+    CountTable(const std::string& table_name, int64_t& row_count) = 0;
+
+    /**
+     * @brief Show all tables in database
+     *
+     * This method is used to list all tables.
+     *
+     * @param table_array, all tables are push into the array.
+     *
+     * @return Indicate if this operation is successful.
+     */
+    virtual Status
+    ShowTables(std::vector<std::string>& table_array) = 0;
+
+    /**
+     * @brief Give the client version
+     *
+     * This method is used to give the client version.
+     *
+     * @return Client version.
+     */
+    virtual std::string
+    ClientVersion() const = 0;
+
+    /**
+     * @brief Give the server version
+     *
+     * This method is used to give the server version.
+     *
+     * @return Server version.
+     */
+    virtual std::string
+    ServerVersion() const = 0;
+
+    /**
+     * @brief Give the server status
+     *
+     * This method is used to give the server status.
+     *
+     * @return Server status.
+     */
+    virtual std::string
+    ServerStatus() const = 0;
+
+    virtual std::string
+    DumpTaskTables() const = 0;
+
+    /**
+     * @brief delete tables by range
+     *
+     * This method is used to delete tables by range.
+     *
+     * @param Range, table range to delete.
+     * @param table_name
+     *
+     * @return Indicate if this operation is successful.
+     */
+    virtual Status
+    DeleteByRange(Range& range, const std::string& table_name) = 0;
+
+    /**
+     * @brief preload table
+     *
+     * This method is used to preload table
+     *
+     * @param table_name
+     *
+     * @return Indicate if this operation is successful.
+     */
+    virtual Status
+    PreloadTable(const std::string& table_name) const = 0;
+
+    /**
+     * @brief describe index
+     *
+     * This method is used to describe index
+     *
+     * @param table_name
+     *
+     * @return index informations and indicate if this operation is successful.
+     */
+    virtual Status
+    DescribeIndex(const std::string& table_name, IndexParam& index_param) const = 0;
+
+    /**
+     * @brief drop index
+     *
+     * This method is used to drop index
+     *
+     * @param table_name
+     *
+     * @return Indicate if this operation is successful.
+     */
+    virtual Status
+    DropIndex(const std::string& table_name) const = 0;
+};
+
+}  // namespace milvus
diff --git a/core/src/sdk/include/Status.h b/core/src/sdk/include/Status.h
new file mode 100644
index 0000000000..008f9956d2
--- /dev/null
+++ b/core/src/sdk/include/Status.h
@@ -0,0 +1,91 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <string>
+
+/** \brief Milvus SDK namespace
+ */
+namespace milvus {
+
+/**
+ * @brief Status Code for SDK interface return
+ */
+enum class StatusCode {
+    OK = 0,
+
+    // system error section
+    UnknownError = 1,
+    NotSupported,
+    NotConnected,
+
+    // function error section
+    InvalidAgument = 1000,
+    RPCFailed,
+    ServerFailed,
+};
+
+/**
+ * @brief Status for SDK interface return
+ */
+class Status {
+ public:
+    Status(StatusCode code, const std::string& msg);
+    Status();
+    ~Status();
+
+    Status(const Status& s);
+
+    Status&
+    operator=(const Status& s);
+
+    Status(Status&& s);
+
+    Status&
+    operator=(Status&& s);
+
+    static Status
+    OK() {
+        return Status();
+    }
+
+    bool
+    ok() const {
+        return state_ == nullptr || code() == StatusCode::OK;
+    }
+
+    StatusCode
+    code() const {
+        return (state_ == nullptr) ? StatusCode::OK : *(StatusCode*)(state_);
+    }
+
+    std::string
+    message() const;
+
+ private:
+    inline void
+    CopyFrom(const Status& s);
+
+    inline void
+    MoveFrom(Status& s);
+
+ private:
+    char* state_ = nullptr;
+};  // Status
+
+}  // namespace milvus
diff --git a/core/src/sdk/interface/ConnectionImpl.cpp b/core/src/sdk/interface/ConnectionImpl.cpp
new file mode 100644
index 0000000000..7034ce4a4d
--- /dev/null
+++ b/core/src/sdk/interface/ConnectionImpl.cpp
@@ -0,0 +1,149 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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/interface/ConnectionImpl.h"
+
+namespace milvus {
+
+std::shared_ptr<Connection>
+Connection::Create() {
+    return std::shared_ptr<Connection>(new ConnectionImpl());
+}
+
+Status
+Connection::Destroy(std::shared_ptr<milvus::Connection>& connection_ptr) {
+    if (connection_ptr != nullptr) {
+        return connection_ptr->Disconnect();
+    }
+    return Status::OK();
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+ConnectionImpl::ConnectionImpl() {
+    client_proxy_ = std::make_shared<ClientProxy>();
+}
+
+Status
+ConnectionImpl::Connect(const ConnectParam& param) {
+    return client_proxy_->Connect(param);
+}
+
+Status
+ConnectionImpl::Connect(const std::string& uri) {
+    return client_proxy_->Connect(uri);
+}
+
+Status
+ConnectionImpl::Connected() const {
+    return client_proxy_->Connected();
+}
+
+Status
+ConnectionImpl::Disconnect() {
+    return client_proxy_->Disconnect();
+}
+
+std::string
+ConnectionImpl::ClientVersion() const {
+    return client_proxy_->ClientVersion();
+}
+
+Status
+ConnectionImpl::CreateTable(const TableSchema& param) {
+    return client_proxy_->CreateTable(param);
+}
+
+bool
+ConnectionImpl::HasTable(const std::string& table_name) {
+    return client_proxy_->HasTable(table_name);
+}
+
+Status
+ConnectionImpl::DropTable(const std::string& table_name) {
+    return client_proxy_->DropTable(table_name);
+}
+
+Status
+ConnectionImpl::CreateIndex(const IndexParam& index_param) {
+    return client_proxy_->CreateIndex(index_param);
+}
+
+Status
+ConnectionImpl::Insert(const std::string& table_name, const std::vector<RowRecord>& record_array,
+                       std::vector<int64_t>& id_array) {
+    return client_proxy_->Insert(table_name, record_array, id_array);
+}
+
+Status
+ConnectionImpl::Search(const std::string& table_name, const std::vector<RowRecord>& query_record_array,
+                       const std::vector<Range>& query_range_array, int64_t topk, int64_t nprobe,
+                       std::vector<TopKQueryResult>& topk_query_result_array) {
+    return client_proxy_->Search(table_name, query_record_array, query_range_array, topk, nprobe,
+                                 topk_query_result_array);
+}
+
+Status
+ConnectionImpl::DescribeTable(const std::string& table_name, TableSchema& table_schema) {
+    return client_proxy_->DescribeTable(table_name, table_schema);
+}
+
+Status
+ConnectionImpl::CountTable(const std::string& table_name, int64_t& row_count) {
+    return client_proxy_->CountTable(table_name, row_count);
+}
+
+Status
+ConnectionImpl::ShowTables(std::vector<std::string>& table_array) {
+    return client_proxy_->ShowTables(table_array);
+}
+
+std::string
+ConnectionImpl::ServerVersion() const {
+    return client_proxy_->ServerVersion();
+}
+
+std::string
+ConnectionImpl::ServerStatus() const {
+    return client_proxy_->ServerStatus();
+}
+
+std::string
+ConnectionImpl::DumpTaskTables() const {
+    return client_proxy_->DumpTaskTables();
+}
+
+Status
+ConnectionImpl::DeleteByRange(Range& range, const std::string& table_name) {
+    return client_proxy_->DeleteByRange(range, table_name);
+}
+
+Status
+ConnectionImpl::PreloadTable(const std::string& table_name) const {
+    return client_proxy_->PreloadTable(table_name);
+}
+
+Status
+ConnectionImpl::DescribeIndex(const std::string& table_name, IndexParam& index_param) const {
+    return client_proxy_->DescribeIndex(table_name, index_param);
+}
+
+Status
+ConnectionImpl::DropIndex(const std::string& table_name) const {
+    return client_proxy_->DropIndex(table_name);
+}
+
+}  // namespace milvus
diff --git a/core/src/sdk/interface/ConnectionImpl.h b/core/src/sdk/interface/ConnectionImpl.h
new file mode 100644
index 0000000000..6bc3432bc4
--- /dev/null
+++ b/core/src/sdk/interface/ConnectionImpl.h
@@ -0,0 +1,104 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "MilvusApi.h"
+#include "sdk/grpc/ClientProxy.h"
+
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace milvus {
+
+class ConnectionImpl : public Connection {
+ public:
+    ConnectionImpl();
+
+    // Implementations of the Connection interface
+    Status
+    Connect(const ConnectParam& param) override;
+
+    Status
+    Connect(const std::string& uri) override;
+
+    Status
+    Connected() const override;
+
+    Status
+    Disconnect() override;
+
+    Status
+    CreateTable(const TableSchema& param) override;
+
+    bool
+    HasTable(const std::string& table_name) override;
+
+    Status
+    DropTable(const std::string& table_name) override;
+
+    Status
+    CreateIndex(const IndexParam& index_param) override;
+
+    Status
+    Insert(const std::string& table_name, const std::vector<RowRecord>& record_array,
+           std::vector<int64_t>& id_array) override;
+
+    Status
+    Search(const std::string& table_name, const std::vector<RowRecord>& query_record_array,
+           const std::vector<Range>& query_range_array, int64_t topk, int64_t nprobe,
+           std::vector<TopKQueryResult>& topk_query_result_array) override;
+
+    Status
+    DescribeTable(const std::string& table_name, TableSchema& table_schema) override;
+
+    Status
+    CountTable(const std::string& table_name, int64_t& row_count) override;
+
+    Status
+    ShowTables(std::vector<std::string>& table_array) override;
+
+    std::string
+    ClientVersion() const override;
+
+    std::string
+    ServerVersion() const override;
+
+    std::string
+    ServerStatus() const override;
+
+    std::string
+    DumpTaskTables() const override;
+
+    Status
+    DeleteByRange(Range& range, const std::string& table_name) override;
+
+    Status
+    PreloadTable(const std::string& table_name) const override;
+
+    Status
+    DescribeIndex(const std::string& table_name, IndexParam& index_param) const override;
+
+    Status
+    DropIndex(const std::string& table_name) const override;
+
+ private:
+    std::shared_ptr<ClientProxy> client_proxy_;
+};
+
+}  // namespace milvus
diff --git a/core/src/sdk/interface/Status.cpp b/core/src/sdk/interface/Status.cpp
new file mode 100644
index 0000000000..9ccbabfd20
--- /dev/null
+++ b/core/src/sdk/interface/Status.cpp
@@ -0,0 +1,104 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "Status.h"
+
+#include <cstring>
+
+namespace milvus {
+
+constexpr int CODE_WIDTH = sizeof(StatusCode);
+
+Status::Status(StatusCode code, const std::string& msg) {
+    // 4 bytes store code
+    // 4 bytes store message length
+    // the left bytes store message string
+    const uint32_t length = (uint32_t)msg.size();
+    auto result = new char[length + sizeof(length) + CODE_WIDTH];
+    memcpy(result, &code, CODE_WIDTH);
+    memcpy(result + CODE_WIDTH, &length, sizeof(length));
+    memcpy(result + sizeof(length) + CODE_WIDTH, msg.data(), length);
+
+    state_ = result;
+}
+
+Status::Status() : state_(nullptr) {
+}
+
+Status::~Status() {
+    delete state_;
+}
+
+Status::Status(const Status& s) : state_(nullptr) {
+    CopyFrom(s);
+}
+
+Status&
+Status::operator=(const Status& s) {
+    CopyFrom(s);
+    return *this;
+}
+
+Status::Status(Status&& s) : state_(nullptr) {
+    MoveFrom(s);
+}
+
+Status&
+Status::operator=(Status&& s) {
+    MoveFrom(s);
+    return *this;
+}
+
+void
+Status::CopyFrom(const Status& s) {
+    delete state_;
+    state_ = nullptr;
+    if (s.state_ == nullptr) {
+        return;
+    }
+
+    uint32_t length = 0;
+    memcpy(&length, s.state_ + CODE_WIDTH, sizeof(length));
+    int buff_len = length + sizeof(length) + CODE_WIDTH;
+    state_ = new char[buff_len];
+    memcpy(state_, s.state_, buff_len);
+}
+
+void
+Status::MoveFrom(Status& s) {
+    delete state_;
+    state_ = s.state_;
+    s.state_ = nullptr;
+}
+
+std::string
+Status::message() const {
+    if (state_ == nullptr) {
+        return "OK";
+    }
+
+    std::string msg;
+    uint32_t length = 0;
+    memcpy(&length, state_ + CODE_WIDTH, sizeof(length));
+    if (length > 0) {
+        msg.append(state_ + sizeof(length) + CODE_WIDTH, length);
+    }
+
+    return msg;
+}
+
+}  // namespace milvus
diff --git a/core/src/server/Config.cpp b/core/src/server/Config.cpp
new file mode 100644
index 0000000000..7de84cbccc
--- /dev/null
+++ b/core/src/server/Config.cpp
@@ -0,0 +1,1157 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 <sys/stat.h>
+#include <algorithm>
+#include <iostream>
+#include <regex>
+#include <string>
+#include <vector>
+
+#include "config/YamlConfigMgr.h"
+#include "server/Config.h"
+#include "utils/CommonUtil.h"
+#include "utils/ValidationUtil.h"
+
+namespace milvus {
+namespace server {
+
+constexpr uint64_t GB = 1UL << 30;
+
+Config&
+Config::GetInstance() {
+    static Config config_inst;
+    return config_inst;
+}
+
+Status
+Config::LoadConfigFile(const std::string& filename) {
+    if (filename.empty()) {
+        return Status(SERVER_UNEXPECTED_ERROR, "No specified config file");
+    }
+
+    struct stat file_stat;
+    if (stat(filename.c_str(), &file_stat) != 0) {
+        std::string str = "Config file not exist: " + filename;
+        return Status(SERVER_FILE_NOT_FOUND, str);
+    }
+
+    try {
+        ConfigMgr* mgr = YamlConfigMgr::GetInstance();
+        Status s = mgr->LoadConfigFile(filename);
+        if (!s.ok()) {
+            return s;
+        }
+    } catch (YAML::Exception& e) {
+        std::string str = "Exception occurs when loading config file: " + filename;
+        return Status(SERVER_UNEXPECTED_ERROR, str);
+    }
+
+    return Status::OK();
+}
+
+Status
+Config::ValidateConfig() {
+    Status s;
+
+    /* server config */
+    std::string server_addr;
+    s = GetServerConfigAddress(server_addr);
+    if (!s.ok()) {
+        return s;
+    }
+
+    std::string server_port;
+    s = GetServerConfigPort(server_port);
+    if (!s.ok()) {
+        return s;
+    }
+
+    std::string server_mode;
+    s = GetServerConfigDeployMode(server_mode);
+    if (!s.ok()) {
+        return s;
+    }
+
+    std::string server_time_zone;
+    s = GetServerConfigTimeZone(server_time_zone);
+    if (!s.ok()) {
+        return s;
+    }
+
+    /* db config */
+    std::string db_primary_path;
+    s = GetDBConfigPrimaryPath(db_primary_path);
+    if (!s.ok()) {
+        return s;
+    }
+
+    std::string db_secondary_path;
+    s = GetDBConfigSecondaryPath(db_secondary_path);
+    if (!s.ok()) {
+        return s;
+    }
+
+    std::string db_backend_url;
+    s = GetDBConfigBackendUrl(db_backend_url);
+    if (!s.ok()) {
+        return s;
+    }
+
+    int32_t db_archive_disk_threshold;
+    s = GetDBConfigArchiveDiskThreshold(db_archive_disk_threshold);
+    if (!s.ok()) {
+        return s;
+    }
+
+    int32_t db_archive_days_threshold;
+    s = GetDBConfigArchiveDaysThreshold(db_archive_days_threshold);
+    if (!s.ok()) {
+        return s;
+    }
+
+    int32_t db_insert_buffer_size;
+    s = GetDBConfigInsertBufferSize(db_insert_buffer_size);
+    if (!s.ok()) {
+        return s;
+    }
+
+    /* metric config */
+    bool metric_enable_monitor;
+    s = GetMetricConfigEnableMonitor(metric_enable_monitor);
+    if (!s.ok()) {
+        return s;
+    }
+
+    std::string metric_collector;
+    s = GetMetricConfigCollector(metric_collector);
+    if (!s.ok()) {
+        return s;
+    }
+
+    std::string metric_prometheus_port;
+    s = GetMetricConfigPrometheusPort(metric_prometheus_port);
+    if (!s.ok()) {
+        return s;
+    }
+
+    /* cache config */
+    int64_t cache_cpu_cache_capacity;
+    s = GetCacheConfigCpuCacheCapacity(cache_cpu_cache_capacity);
+    if (!s.ok()) {
+        return s;
+    }
+
+    float cache_cpu_cache_threshold;
+    s = GetCacheConfigCpuCacheThreshold(cache_cpu_cache_threshold);
+    if (!s.ok()) {
+        return s;
+    }
+
+    int64_t cache_gpu_cache_capacity;
+    s = GetCacheConfigGpuCacheCapacity(cache_gpu_cache_capacity);
+    if (!s.ok()) {
+        return s;
+    }
+
+    float cache_gpu_cache_threshold;
+    s = GetCacheConfigGpuCacheThreshold(cache_gpu_cache_threshold);
+    if (!s.ok()) {
+        return s;
+    }
+
+    bool cache_insert_data;
+    s = GetCacheConfigCacheInsertData(cache_insert_data);
+    if (!s.ok()) {
+        return s;
+    }
+
+    /* engine config */
+    int32_t engine_use_blas_threshold;
+    s = GetEngineConfigUseBlasThreshold(engine_use_blas_threshold);
+    if (!s.ok()) {
+        return s;
+    }
+
+    int32_t engine_omp_thread_num;
+    s = GetEngineConfigOmpThreadNum(engine_omp_thread_num);
+    if (!s.ok()) {
+        return s;
+    }
+
+    /* resource config */
+    std::string resource_mode;
+    s = GetResourceConfigMode(resource_mode);
+    if (!s.ok()) {
+        return s;
+    }
+
+    std::vector<std::string> search_resources;
+    s = GetResourceConfigSearchResources(search_resources);
+    if (!s.ok()) {
+        return s;
+    }
+
+    int32_t resource_index_build_device;
+    s = GetResourceConfigIndexBuildDevice(resource_index_build_device);
+    if (!s.ok()) {
+        return s;
+    }
+
+    return Status::OK();
+}
+
+Status
+Config::ResetDefaultConfig() {
+    Status s;
+
+    /* server config */
+    s = SetServerConfigAddress(CONFIG_SERVER_ADDRESS_DEFAULT);
+    if (!s.ok()) {
+        return s;
+    }
+
+    s = SetServerConfigPort(CONFIG_SERVER_PORT_DEFAULT);
+    if (!s.ok()) {
+        return s;
+    }
+
+    s = SetServerConfigDeployMode(CONFIG_SERVER_DEPLOY_MODE_DEFAULT);
+    if (!s.ok()) {
+        return s;
+    }
+
+    s = SetServerConfigTimeZone(CONFIG_SERVER_TIME_ZONE_DEFAULT);
+    if (!s.ok()) {
+        return s;
+    }
+
+    /* db config */
+    s = SetDBConfigPrimaryPath(CONFIG_DB_PRIMARY_PATH_DEFAULT);
+    if (!s.ok()) {
+        return s;
+    }
+
+    s = SetDBConfigSecondaryPath(CONFIG_DB_SECONDARY_PATH_DEFAULT);
+    if (!s.ok()) {
+        return s;
+    }
+
+    s = SetDBConfigBackendUrl(CONFIG_DB_BACKEND_URL_DEFAULT);
+    if (!s.ok()) {
+        return s;
+    }
+
+    s = SetDBConfigArchiveDiskThreshold(CONFIG_DB_ARCHIVE_DISK_THRESHOLD_DEFAULT);
+    if (!s.ok()) {
+        return s;
+    }
+
+    s = SetDBConfigArchiveDaysThreshold(CONFIG_DB_ARCHIVE_DAYS_THRESHOLD_DEFAULT);
+    if (!s.ok()) {
+        return s;
+    }
+
+    s = SetDBConfigInsertBufferSize(CONFIG_DB_INSERT_BUFFER_SIZE_DEFAULT);
+    if (!s.ok()) {
+        return s;
+    }
+
+    /* metric config */
+    s = SetMetricConfigEnableMonitor(CONFIG_METRIC_ENABLE_MONITOR_DEFAULT);
+    if (!s.ok()) {
+        return s;
+    }
+
+    s = SetMetricConfigCollector(CONFIG_METRIC_COLLECTOR_DEFAULT);
+    if (!s.ok()) {
+        return s;
+    }
+
+    s = SetMetricConfigPrometheusPort(CONFIG_METRIC_PROMETHEUS_PORT_DEFAULT);
+    if (!s.ok()) {
+        return s;
+    }
+
+    /* cache config */
+    s = SetCacheConfigCpuCacheCapacity(CONFIG_CACHE_CPU_CACHE_CAPACITY_DEFAULT);
+    if (!s.ok()) {
+        return s;
+    }
+
+    s = SetCacheConfigCpuCacheThreshold(CONFIG_CACHE_CPU_CACHE_THRESHOLD_DEFAULT);
+    if (!s.ok()) {
+        return s;
+    }
+
+    s = SetCacheConfigGpuCacheCapacity(CONFIG_CACHE_GPU_CACHE_CAPACITY_DEFAULT);
+    if (!s.ok()) {
+        return s;
+    }
+
+    s = SetCacheConfigGpuCacheThreshold(CONFIG_CACHE_GPU_CACHE_THRESHOLD_DEFAULT);
+    if (!s.ok()) {
+        return s;
+    }
+
+    s = SetCacheConfigCacheInsertData(CONFIG_CACHE_CACHE_INSERT_DATA_DEFAULT);
+    if (!s.ok()) {
+        return s;
+    }
+
+    /* engine config */
+    s = SetEngineConfigUseBlasThreshold(CONFIG_ENGINE_USE_BLAS_THRESHOLD_DEFAULT);
+    if (!s.ok()) {
+        return s;
+    }
+
+    s = SetEngineConfigOmpThreadNum(CONFIG_ENGINE_OMP_THREAD_NUM_DEFAULT);
+    if (!s.ok()) {
+        return s;
+    }
+
+    /* resource config */
+    s = SetResourceConfigMode(CONFIG_RESOURCE_MODE_DEFAULT);
+    if (!s.ok()) {
+        return s;
+    }
+
+    s = SetResourceConfigIndexBuildDevice(CONFIG_RESOURCE_INDEX_BUILD_DEVICE_DEFAULT);
+    if (!s.ok()) {
+        return s;
+    }
+
+    return Status::OK();
+}
+
+void
+Config::PrintConfigSection(const std::string& config_node_name) {
+    std::cout << std::endl;
+    std::cout << config_node_name << ":" << std::endl;
+    if (config_map_.find(config_node_name) != config_map_.end()) {
+        for (auto item : config_map_[config_node_name]) {
+            std::cout << item.first << ": " << item.second << std::endl;
+        }
+    }
+}
+
+void
+Config::PrintAll() {
+    PrintConfigSection(CONFIG_SERVER);
+    PrintConfigSection(CONFIG_DB);
+    PrintConfigSection(CONFIG_CACHE);
+    PrintConfigSection(CONFIG_METRIC);
+    PrintConfigSection(CONFIG_ENGINE);
+    PrintConfigSection(CONFIG_RESOURCE);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+Status
+Config::CheckServerConfigAddress(const std::string& value) {
+    if (!ValidationUtil::ValidateIpAddress(value).ok()) {
+        return Status(SERVER_INVALID_ARGUMENT, "Invalid server config address: " + value);
+    }
+    return Status::OK();
+}
+
+Status
+Config::CheckServerConfigPort(const std::string& value) {
+    if (!ValidationUtil::ValidateStringIsNumber(value).ok()) {
+        return Status(SERVER_INVALID_ARGUMENT, "Invalid server config port: " + value);
+    } else {
+        int32_t port = std::stoi(value);
+        if (!(port > 1024 && port < 65535)) {
+            return Status(SERVER_INVALID_ARGUMENT, "Server config port out of range (1024, 65535): " + value);
+        }
+    }
+    return Status::OK();
+}
+
+Status
+Config::CheckServerConfigDeployMode(const std::string& value) {
+    if (value != "single" && value != "cluster_readonly" && value != "cluster_writable") {
+        return Status(SERVER_INVALID_ARGUMENT,
+                      "Invalid server config mode [single, cluster_readonly, cluster_writable]: " + value);
+    }
+    return Status::OK();
+}
+
+Status
+Config::CheckServerConfigTimeZone(const std::string& value) {
+    if (value.length() <= 3) {
+        return Status(SERVER_INVALID_ARGUMENT, "Invalid server config time_zone: " + value);
+    } else {
+        if (value.substr(0, 3) != "UTC") {
+            return Status(SERVER_INVALID_ARGUMENT, "Invalid server config time_zone: " + value);
+        } else {
+            try {
+                stoi(value.substr(3));
+            } catch (...) {
+                return Status(SERVER_INVALID_ARGUMENT, "Invalid server config time_zone: " + value);
+            }
+        }
+    }
+    return Status::OK();
+}
+
+Status
+Config::CheckDBConfigPrimaryPath(const std::string& value) {
+    if (value.empty()) {
+        return Status(SERVER_INVALID_ARGUMENT, "DB config primary_path empty");
+    }
+    return Status::OK();
+}
+
+Status
+Config::CheckDBConfigSecondaryPath(const std::string& value) {
+    return Status::OK();
+}
+
+Status
+Config::CheckDBConfigBackendUrl(const std::string& value) {
+    if (!ValidationUtil::ValidateDbURI(value).ok()) {
+        return Status(SERVER_INVALID_ARGUMENT, "Invalid DB config backend_url: " + value);
+    }
+    return Status::OK();
+}
+
+Status
+Config::CheckDBConfigArchiveDiskThreshold(const std::string& value) {
+    if (!ValidationUtil::ValidateStringIsNumber(value).ok()) {
+        return Status(SERVER_INVALID_ARGUMENT, "Invalid DB config archive_disk_threshold: " + value);
+    }
+    return Status::OK();
+}
+
+Status
+Config::CheckDBConfigArchiveDaysThreshold(const std::string& value) {
+    if (!ValidationUtil::ValidateStringIsNumber(value).ok()) {
+        return Status(SERVER_INVALID_ARGUMENT, "Invalid DB config archive_days_threshold: " + value);
+    }
+    return Status::OK();
+}
+
+Status
+Config::CheckDBConfigInsertBufferSize(const std::string& value) {
+    if (!ValidationUtil::ValidateStringIsNumber(value).ok()) {
+        return Status(SERVER_INVALID_ARGUMENT, "Invalid DB config insert_buffer_size: " + value);
+    } else {
+        int64_t buffer_size = std::stoi(value) * GB;
+        uint64_t total_mem = 0, free_mem = 0;
+        CommonUtil::GetSystemMemInfo(total_mem, free_mem);
+        if (buffer_size >= total_mem) {
+            return Status(SERVER_INVALID_ARGUMENT, "DB config insert_buffer_size exceed system memory: " + value);
+        }
+    }
+    return Status::OK();
+}
+
+Status
+Config::CheckMetricConfigEnableMonitor(const std::string& value) {
+    if (!ValidationUtil::ValidateStringIsBool(value).ok()) {
+        return Status(SERVER_INVALID_ARGUMENT, "Invalid metric config auto_bootup: " + value);
+    }
+    return Status::OK();
+}
+
+Status
+Config::CheckMetricConfigCollector(const std::string& value) {
+    if (value != "prometheus") {
+        return Status(SERVER_INVALID_ARGUMENT, "Invalid metric config collector: " + value);
+    }
+    return Status::OK();
+}
+
+Status
+Config::CheckMetricConfigPrometheusPort(const std::string& value) {
+    if (!ValidationUtil::ValidateStringIsNumber(value).ok()) {
+        return Status(SERVER_INVALID_ARGUMENT, "Invalid metric config prometheus_port: " + value);
+    }
+    return Status::OK();
+}
+
+Status
+Config::CheckCacheConfigCpuCacheCapacity(const std::string& value) {
+    if (!ValidationUtil::ValidateStringIsNumber(value).ok()) {
+        return Status(SERVER_INVALID_ARGUMENT, "Invalid cache config cpu_cache_capacity: " + value);
+    } else {
+        uint64_t cpu_cache_capacity = std::stoi(value) * GB;
+        uint64_t total_mem = 0, free_mem = 0;
+        CommonUtil::GetSystemMemInfo(total_mem, free_mem);
+        if (cpu_cache_capacity >= total_mem) {
+            return Status(SERVER_INVALID_ARGUMENT, "Cache config cpu_cache_capacity exceed system memory: " + value);
+        } else if (cpu_cache_capacity > static_cast<double>(total_mem * 0.9)) {
+            std::cerr << "Warning: cpu_cache_capacity value is too big" << std::endl;
+        }
+
+        int32_t buffer_value;
+        Status s = GetDBConfigInsertBufferSize(buffer_value);
+        if (!s.ok()) {
+            return s;
+        }
+
+        int64_t insert_buffer_size = buffer_value * GB;
+        if (insert_buffer_size + cpu_cache_capacity >= total_mem) {
+            return Status(SERVER_INVALID_ARGUMENT, "Sum of cpu_cache_capacity and buffer_size exceed system memory");
+        }
+    }
+    return Status::OK();
+}
+
+Status
+Config::CheckCacheConfigCpuCacheThreshold(const std::string& value) {
+    if (!ValidationUtil::ValidateStringIsFloat(value).ok()) {
+        return Status(SERVER_INVALID_ARGUMENT, "Invalid cache config cpu_cache_threshold: " + value);
+    } else {
+        float cpu_cache_threshold = std::stof(value);
+        if (cpu_cache_threshold <= 0.0 || cpu_cache_threshold >= 1.0) {
+            return Status(SERVER_INVALID_ARGUMENT, "Invalid cache config cpu_cache_threshold: " + value);
+        }
+    }
+    return Status::OK();
+}
+
+Status
+Config::CheckCacheConfigGpuCacheCapacity(const std::string& value) {
+    if (!ValidationUtil::ValidateStringIsNumber(value).ok()) {
+        return Status(SERVER_INVALID_ARGUMENT, "Invalid cache config gpu_cache_capacity: " + value);
+    } else {
+        uint64_t gpu_cache_capacity = std::stoi(value) * GB;
+        int gpu_index;
+        Status s = GetResourceConfigIndexBuildDevice(gpu_index);
+        if (!s.ok()) {
+            return s;
+        }
+
+        size_t gpu_memory;
+        if (!ValidationUtil::GetGpuMemory(gpu_index, gpu_memory).ok()) {
+            return Status(SERVER_UNEXPECTED_ERROR,
+                          "Fail to get GPU memory for GPU device: " + std::to_string(gpu_index));
+        } else if (gpu_cache_capacity >= gpu_memory) {
+            return Status(SERVER_INVALID_ARGUMENT,
+                          "Cache config gpu_cache_capacity exceed GPU memory: " + std::to_string(gpu_memory));
+        } else if (gpu_cache_capacity > (double)gpu_memory * 0.9) {
+            std::cerr << "Warning: gpu_cache_capacity value is too big" << std::endl;
+        }
+    }
+    return Status::OK();
+}
+
+Status
+Config::CheckCacheConfigGpuCacheThreshold(const std::string& value) {
+    if (!ValidationUtil::ValidateStringIsFloat(value).ok()) {
+        return Status(SERVER_INVALID_ARGUMENT, "Invalid cache config gpu_cache_threshold: " + value);
+    } else {
+        float gpu_cache_threshold = std::stof(value);
+        if (gpu_cache_threshold <= 0.0 || gpu_cache_threshold >= 1.0) {
+            return Status(SERVER_INVALID_ARGUMENT, "Invalid cache config gpu_cache_threshold: " + value);
+        }
+    }
+    return Status::OK();
+}
+
+Status
+Config::CheckCacheConfigCacheInsertData(const std::string& value) {
+    if (!ValidationUtil::ValidateStringIsBool(value).ok()) {
+        return Status(SERVER_INVALID_ARGUMENT, "Invalid cache config cache_insert_data: " + value);
+    }
+    return Status::OK();
+}
+
+Status
+Config::CheckEngineConfigUseBlasThreshold(const std::string& value) {
+    if (!ValidationUtil::ValidateStringIsNumber(value).ok()) {
+        return Status(SERVER_INVALID_ARGUMENT, "Invalid engine config use_blas_threshold: " + value);
+    }
+    return Status::OK();
+}
+
+Status
+Config::CheckEngineConfigOmpThreadNum(const std::string& value) {
+    if (!ValidationUtil::ValidateStringIsNumber(value).ok()) {
+        return Status(SERVER_INVALID_ARGUMENT, "Invalid engine config omp_thread_num: " + value);
+    }
+
+    int32_t omp_thread = std::stoi(value);
+    uint32_t sys_thread_cnt = 8;
+    CommonUtil::GetSystemAvailableThreads(sys_thread_cnt);
+    if (omp_thread > static_cast<int32_t>(sys_thread_cnt)) {
+        return Status(SERVER_INVALID_ARGUMENT, "Invalid engine config omp_thread_num: " + value);
+    }
+    return Status::OK();
+}
+
+Status
+Config::CheckResourceConfigMode(const std::string& value) {
+    if (value != "simple") {
+        return Status(SERVER_INVALID_ARGUMENT, "Invalid resource config mode: " + value);
+    }
+    return Status::OK();
+}
+
+Status
+CheckGpuDevice(const std::string& value) {
+    const std::regex pat("gpu(\\d+)");
+    std::cmatch m;
+    if (!std::regex_match(value.c_str(), m, pat)) {
+        return Status(SERVER_INVALID_ARGUMENT, "Invalid gpu device: " + value);
+    }
+
+    int32_t gpu_index = std::stoi(value.substr(3));
+    if (!ValidationUtil::ValidateGpuIndex(gpu_index).ok()) {
+        return Status(SERVER_INVALID_ARGUMENT, "Invalid gpu device: " + value);
+    }
+    return Status::OK();
+}
+
+Status
+Config::CheckResourceConfigSearchResources(const std::vector<std::string>& value) {
+    if (value.empty()) {
+        return Status(SERVER_INVALID_ARGUMENT, "Empty resource config search_resources");
+    }
+
+    for (auto& gpu_device : value) {
+        if (!CheckGpuDevice(gpu_device).ok()) {
+            return Status(SERVER_INVALID_ARGUMENT, "Invalid resource config search_resources: " + gpu_device);
+        }
+    }
+    return Status::OK();
+}
+
+Status
+Config::CheckResourceConfigIndexBuildDevice(const std::string& value) {
+    if (!CheckGpuDevice(value).ok()) {
+        return Status(SERVER_INVALID_ARGUMENT, "Invalid resource config index_build_device: " + value);
+    }
+    return Status::OK();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+ConfigNode&
+Config::GetConfigNode(const std::string& name) {
+    ConfigMgr* mgr = YamlConfigMgr::GetInstance();
+    ConfigNode& root_node = mgr->GetRootNode();
+    return root_node.GetChild(name);
+}
+
+Status
+Config::GetConfigValueInMem(const std::string& parent_key, const std::string& child_key, std::string& value) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    if (config_map_.find(parent_key) != config_map_.end() &&
+        config_map_[parent_key].find(child_key) != config_map_[parent_key].end()) {
+        value = config_map_[parent_key][child_key];
+        return Status::OK();
+    }
+    return Status(SERVER_UNEXPECTED_ERROR, "key not exist");
+}
+
+void
+Config::SetConfigValueInMem(const std::string& parent_key, const std::string& child_key, const std::string& value) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    config_map_[parent_key][child_key] = value;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+std::string
+Config::GetConfigStr(const std::string& parent_key, const std::string& child_key, const std::string& default_value) {
+    std::string value;
+    if (!GetConfigValueInMem(parent_key, child_key, value).ok()) {
+        value = GetConfigNode(parent_key).GetValue(child_key, default_value);
+        SetConfigValueInMem(parent_key, child_key, value);
+    }
+    return value;
+}
+
+Status
+Config::GetServerConfigAddress(std::string& value) {
+    value = GetConfigStr(CONFIG_SERVER, CONFIG_SERVER_ADDRESS, CONFIG_SERVER_ADDRESS_DEFAULT);
+    return CheckServerConfigAddress(value);
+}
+
+Status
+Config::GetServerConfigPort(std::string& value) {
+    value = GetConfigStr(CONFIG_SERVER, CONFIG_SERVER_PORT, CONFIG_SERVER_PORT_DEFAULT);
+    return CheckServerConfigPort(value);
+}
+
+Status
+Config::GetServerConfigDeployMode(std::string& value) {
+    value = GetConfigStr(CONFIG_SERVER, CONFIG_SERVER_DEPLOY_MODE, CONFIG_SERVER_DEPLOY_MODE_DEFAULT);
+    return CheckServerConfigDeployMode(value);
+}
+
+Status
+Config::GetServerConfigTimeZone(std::string& value) {
+    value = GetConfigStr(CONFIG_SERVER, CONFIG_SERVER_TIME_ZONE, CONFIG_SERVER_TIME_ZONE_DEFAULT);
+    return CheckServerConfigTimeZone(value);
+}
+
+Status
+Config::GetDBConfigPrimaryPath(std::string& value) {
+    value = GetConfigStr(CONFIG_DB, CONFIG_DB_PRIMARY_PATH, CONFIG_DB_PRIMARY_PATH_DEFAULT);
+    return CheckDBConfigPrimaryPath(value);
+}
+
+Status
+Config::GetDBConfigSecondaryPath(std::string& value) {
+    value = GetConfigStr(CONFIG_DB, CONFIG_DB_SECONDARY_PATH, CONFIG_DB_SECONDARY_PATH_DEFAULT);
+    return Status::OK();
+}
+
+Status
+Config::GetDBConfigBackendUrl(std::string& value) {
+    value = GetConfigStr(CONFIG_DB, CONFIG_DB_BACKEND_URL, CONFIG_DB_BACKEND_URL_DEFAULT);
+    return CheckDBConfigBackendUrl(value);
+}
+
+Status
+Config::GetDBConfigArchiveDiskThreshold(int32_t& value) {
+    std::string str =
+        GetConfigStr(CONFIG_DB, CONFIG_DB_ARCHIVE_DISK_THRESHOLD, CONFIG_DB_ARCHIVE_DISK_THRESHOLD_DEFAULT);
+    Status s = CheckDBConfigArchiveDiskThreshold(str);
+    if (!s.ok()) {
+        return s;
+    }
+
+    value = std::stoi(str);
+    return Status::OK();
+}
+
+Status
+Config::GetDBConfigArchiveDaysThreshold(int32_t& value) {
+    std::string str =
+        GetConfigStr(CONFIG_DB, CONFIG_DB_ARCHIVE_DAYS_THRESHOLD, CONFIG_DB_ARCHIVE_DAYS_THRESHOLD_DEFAULT);
+    Status s = CheckDBConfigArchiveDaysThreshold(str);
+    if (!s.ok()) {
+        return s;
+    }
+
+    value = std::stoi(str);
+    return Status::OK();
+}
+
+Status
+Config::GetDBConfigInsertBufferSize(int32_t& value) {
+    std::string str = GetConfigStr(CONFIG_DB, CONFIG_DB_INSERT_BUFFER_SIZE, CONFIG_DB_INSERT_BUFFER_SIZE_DEFAULT);
+    Status s = CheckDBConfigInsertBufferSize(str);
+    if (!s.ok()) {
+        return s;
+    }
+
+    value = std::stoi(str);
+    return Status::OK();
+}
+
+Status
+Config::GetDBConfigPreloadTable(std::string& value) {
+    value = GetConfigStr(CONFIG_DB, CONFIG_DB_PRELOAD_TABLE);
+    return Status::OK();
+}
+
+Status
+Config::GetMetricConfigEnableMonitor(bool& value) {
+    std::string str = GetConfigStr(CONFIG_METRIC, CONFIG_METRIC_ENABLE_MONITOR, CONFIG_METRIC_ENABLE_MONITOR_DEFAULT);
+    Status s = CheckMetricConfigEnableMonitor(str);
+    if (!s.ok()) {
+        return s;
+    }
+
+    std::transform(str.begin(), str.end(), str.begin(), ::tolower);
+    value = (str == "true" || str == "on" || str == "yes" || str == "1");
+    return Status::OK();
+}
+
+Status
+Config::GetMetricConfigCollector(std::string& value) {
+    value = GetConfigStr(CONFIG_METRIC, CONFIG_METRIC_COLLECTOR, CONFIG_METRIC_COLLECTOR_DEFAULT);
+    return Status::OK();
+}
+
+Status
+Config::GetMetricConfigPrometheusPort(std::string& value) {
+    value = GetConfigStr(CONFIG_METRIC, CONFIG_METRIC_PROMETHEUS_PORT, CONFIG_METRIC_PROMETHEUS_PORT_DEFAULT);
+    return CheckMetricConfigPrometheusPort(value);
+}
+
+Status
+Config::GetCacheConfigCpuCacheCapacity(int64_t& value) {
+    std::string str =
+        GetConfigStr(CONFIG_CACHE, CONFIG_CACHE_CPU_CACHE_CAPACITY, CONFIG_CACHE_CPU_CACHE_CAPACITY_DEFAULT);
+    Status s = CheckCacheConfigCpuCacheCapacity(str);
+    if (!s.ok()) {
+        return s;
+    }
+
+    value = std::stoi(str);
+    return Status::OK();
+}
+
+Status
+Config::GetCacheConfigCpuCacheThreshold(float& value) {
+    std::string str =
+        GetConfigStr(CONFIG_CACHE, CONFIG_CACHE_CPU_CACHE_THRESHOLD, CONFIG_CACHE_CPU_CACHE_THRESHOLD_DEFAULT);
+    Status s = CheckCacheConfigCpuCacheThreshold(str);
+    if (!s.ok()) {
+        return s;
+    }
+
+    value = std::stof(str);
+    return Status::OK();
+}
+
+Status
+Config::GetCacheConfigGpuCacheCapacity(int64_t& value) {
+    std::string str =
+        GetConfigStr(CONFIG_CACHE, CONFIG_CACHE_GPU_CACHE_CAPACITY, CONFIG_CACHE_GPU_CACHE_CAPACITY_DEFAULT);
+    Status s = CheckCacheConfigGpuCacheCapacity(str);
+    if (!s.ok()) {
+        return s;
+    }
+
+    value = std::stoi(str);
+    return Status::OK();
+}
+
+Status
+Config::GetCacheConfigGpuCacheThreshold(float& value) {
+    std::string str =
+        GetConfigStr(CONFIG_CACHE, CONFIG_CACHE_GPU_CACHE_THRESHOLD, CONFIG_CACHE_GPU_CACHE_THRESHOLD_DEFAULT);
+    Status s = CheckCacheConfigGpuCacheThreshold(str);
+    if (!s.ok()) {
+        return s;
+    }
+
+    value = std::stof(str);
+    return Status::OK();
+}
+
+Status
+Config::GetCacheConfigCacheInsertData(bool& value) {
+    std::string str =
+        GetConfigStr(CONFIG_CACHE, CONFIG_CACHE_CACHE_INSERT_DATA, CONFIG_CACHE_CACHE_INSERT_DATA_DEFAULT);
+    Status s = CheckCacheConfigCacheInsertData(str);
+    if (!s.ok()) {
+        return s;
+    }
+
+    std::transform(str.begin(), str.end(), str.begin(), ::tolower);
+    value = (str == "true" || str == "on" || str == "yes" || str == "1");
+    return Status::OK();
+}
+
+Status
+Config::GetEngineConfigUseBlasThreshold(int32_t& value) {
+    std::string str =
+        GetConfigStr(CONFIG_ENGINE, CONFIG_ENGINE_USE_BLAS_THRESHOLD, CONFIG_ENGINE_USE_BLAS_THRESHOLD_DEFAULT);
+    Status s = CheckEngineConfigUseBlasThreshold(str);
+    if (!s.ok()) {
+        return s;
+    }
+
+    value = std::stoi(str);
+    return Status::OK();
+}
+
+Status
+Config::GetEngineConfigOmpThreadNum(int32_t& value) {
+    std::string str = GetConfigStr(CONFIG_ENGINE, CONFIG_ENGINE_OMP_THREAD_NUM, CONFIG_ENGINE_OMP_THREAD_NUM_DEFAULT);
+    Status s = CheckEngineConfigOmpThreadNum(str);
+    if (!s.ok()) {
+        return s;
+    }
+
+    value = std::stoi(str);
+    return Status::OK();
+}
+
+Status
+Config::GetResourceConfigMode(std::string& value) {
+    value = GetConfigStr(CONFIG_RESOURCE, CONFIG_RESOURCE_MODE, CONFIG_RESOURCE_MODE_DEFAULT);
+    return CheckResourceConfigMode(value);
+}
+
+Status
+Config::GetResourceConfigSearchResources(std::vector<std::string>& value) {
+    ConfigNode resource_config = GetConfigNode(CONFIG_RESOURCE);
+    value = resource_config.GetSequence(CONFIG_RESOURCE_SEARCH_RESOURCES);
+    return CheckResourceConfigSearchResources(value);
+}
+
+Status
+Config::GetResourceConfigIndexBuildDevice(int32_t& value) {
+    std::string str =
+        GetConfigStr(CONFIG_RESOURCE, CONFIG_RESOURCE_INDEX_BUILD_DEVICE, CONFIG_RESOURCE_INDEX_BUILD_DEVICE_DEFAULT);
+    Status s = CheckResourceConfigIndexBuildDevice(str);
+    if (!s.ok()) {
+        return s;
+    }
+
+    value = std::stoi(str.substr(3));
+    return Status::OK();
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/* server config */
+Status
+Config::SetServerConfigAddress(const std::string& value) {
+    Status s = CheckServerConfigAddress(value);
+    if (!s.ok()) {
+        return s;
+    }
+
+    SetConfigValueInMem(CONFIG_SERVER, CONFIG_SERVER_ADDRESS, value);
+    return Status::OK();
+}
+
+Status
+Config::SetServerConfigPort(const std::string& value) {
+    Status s = CheckServerConfigPort(value);
+    if (!s.ok()) {
+        return s;
+    }
+
+    SetConfigValueInMem(CONFIG_SERVER, CONFIG_SERVER_PORT, value);
+    return Status::OK();
+}
+
+Status
+Config::SetServerConfigDeployMode(const std::string& value) {
+    Status s = CheckServerConfigDeployMode(value);
+    if (!s.ok()) {
+        return s;
+    }
+
+    SetConfigValueInMem(CONFIG_SERVER, CONFIG_SERVER_DEPLOY_MODE, value);
+    return Status::OK();
+}
+
+Status
+Config::SetServerConfigTimeZone(const std::string& value) {
+    Status s = CheckServerConfigTimeZone(value);
+    if (!s.ok()) {
+        return s;
+    }
+
+    SetConfigValueInMem(CONFIG_SERVER, CONFIG_SERVER_TIME_ZONE, value);
+    return Status::OK();
+}
+
+/* db config */
+Status
+Config::SetDBConfigPrimaryPath(const std::string& value) {
+    Status s = CheckDBConfigPrimaryPath(value);
+    if (!s.ok()) {
+        return s;
+    }
+
+    SetConfigValueInMem(CONFIG_DB, CONFIG_DB_PRIMARY_PATH, value);
+    return Status::OK();
+}
+
+Status
+Config::SetDBConfigSecondaryPath(const std::string& value) {
+    Status s = CheckDBConfigSecondaryPath(value);
+    if (!s.ok()) {
+        return s;
+    }
+
+    SetConfigValueInMem(CONFIG_DB, CONFIG_DB_SECONDARY_PATH, value);
+    return Status::OK();
+}
+
+Status
+Config::SetDBConfigBackendUrl(const std::string& value) {
+    Status s = CheckDBConfigBackendUrl(value);
+    if (!s.ok()) {
+        return s;
+    }
+
+    SetConfigValueInMem(CONFIG_DB, CONFIG_DB_BACKEND_URL, value);
+    return Status::OK();
+}
+
+Status
+Config::SetDBConfigArchiveDiskThreshold(const std::string& value) {
+    Status s = CheckDBConfigArchiveDiskThreshold(value);
+    if (!s.ok()) {
+        return s;
+    }
+
+    SetConfigValueInMem(CONFIG_DB, CONFIG_DB_ARCHIVE_DISK_THRESHOLD, value);
+    return Status::OK();
+}
+
+Status
+Config::SetDBConfigArchiveDaysThreshold(const std::string& value) {
+    Status s = CheckDBConfigArchiveDaysThreshold(value);
+    if (!s.ok()) {
+        return s;
+    }
+
+    SetConfigValueInMem(CONFIG_DB, CONFIG_DB_ARCHIVE_DAYS_THRESHOLD, value);
+    return Status::OK();
+}
+
+Status
+Config::SetDBConfigInsertBufferSize(const std::string& value) {
+    Status s = CheckDBConfigInsertBufferSize(value);
+    if (!s.ok()) {
+        return s;
+    }
+
+    SetConfigValueInMem(CONFIG_DB, CONFIG_DB_INSERT_BUFFER_SIZE, value);
+    return Status::OK();
+}
+
+/* metric config */
+Status
+Config::SetMetricConfigEnableMonitor(const std::string& value) {
+    Status s = CheckMetricConfigEnableMonitor(value);
+    if (!s.ok()) {
+        return s;
+    }
+
+    SetConfigValueInMem(CONFIG_DB, CONFIG_METRIC_ENABLE_MONITOR, value);
+    return Status::OK();
+}
+
+Status
+Config::SetMetricConfigCollector(const std::string& value) {
+    Status s = CheckMetricConfigCollector(value);
+    if (!s.ok()) {
+        return s;
+    }
+
+    SetConfigValueInMem(CONFIG_DB, CONFIG_METRIC_COLLECTOR, value);
+    return Status::OK();
+}
+
+Status
+Config::SetMetricConfigPrometheusPort(const std::string& value) {
+    Status s = CheckMetricConfigPrometheusPort(value);
+    if (!s.ok()) {
+        return s;
+    }
+
+    SetConfigValueInMem(CONFIG_DB, CONFIG_METRIC_PROMETHEUS_PORT, value);
+    return Status::OK();
+}
+
+/* cache config */
+Status
+Config::SetCacheConfigCpuCacheCapacity(const std::string& value) {
+    Status s = CheckCacheConfigCpuCacheCapacity(value);
+    if (!s.ok()) {
+        return s;
+    }
+
+    SetConfigValueInMem(CONFIG_DB, CONFIG_CACHE_CPU_CACHE_CAPACITY, value);
+    return Status::OK();
+}
+
+Status
+Config::SetCacheConfigCpuCacheThreshold(const std::string& value) {
+    Status s = CheckCacheConfigCpuCacheThreshold(value);
+    if (!s.ok()) {
+        return s;
+    }
+
+    SetConfigValueInMem(CONFIG_DB, CONFIG_CACHE_CPU_CACHE_THRESHOLD, value);
+    return Status::OK();
+}
+
+Status
+Config::SetCacheConfigGpuCacheCapacity(const std::string& value) {
+    Status s = CheckCacheConfigGpuCacheCapacity(value);
+    if (!s.ok()) {
+        return s;
+    }
+
+    SetConfigValueInMem(CONFIG_DB, CONFIG_CACHE_GPU_CACHE_CAPACITY, value);
+    return Status::OK();
+}
+
+Status
+Config::SetCacheConfigGpuCacheThreshold(const std::string& value) {
+    Status s = CheckCacheConfigGpuCacheThreshold(value);
+    if (!s.ok()) {
+        return s;
+    }
+
+    SetConfigValueInMem(CONFIG_DB, CONFIG_CACHE_GPU_CACHE_THRESHOLD, value);
+    return Status::OK();
+}
+
+Status
+Config::SetCacheConfigCacheInsertData(const std::string& value) {
+    Status s = CheckCacheConfigCacheInsertData(value);
+    if (!s.ok()) {
+        return s;
+    }
+
+    SetConfigValueInMem(CONFIG_DB, CONFIG_CACHE_CACHE_INSERT_DATA, value);
+    return Status::OK();
+}
+
+/* engine config */
+Status
+Config::SetEngineConfigUseBlasThreshold(const std::string& value) {
+    Status s = CheckEngineConfigUseBlasThreshold(value);
+    if (!s.ok()) {
+        return s;
+    }
+
+    SetConfigValueInMem(CONFIG_DB, CONFIG_ENGINE_USE_BLAS_THRESHOLD, value);
+    return Status::OK();
+}
+
+Status
+Config::SetEngineConfigOmpThreadNum(const std::string& value) {
+    Status s = CheckEngineConfigOmpThreadNum(value);
+    if (!s.ok()) {
+        return s;
+    }
+
+    SetConfigValueInMem(CONFIG_DB, CONFIG_ENGINE_OMP_THREAD_NUM, value);
+    return Status::OK();
+}
+
+/* resource config */
+Status
+Config::SetResourceConfigMode(const std::string& value) {
+    Status s = CheckResourceConfigMode(value);
+    if (!s.ok()) {
+        return s;
+    }
+
+    SetConfigValueInMem(CONFIG_DB, CONFIG_RESOURCE_MODE, value);
+    return Status::OK();
+}
+
+Status
+Config::SetResourceConfigIndexBuildDevice(const std::string& value) {
+    Status s = CheckResourceConfigIndexBuildDevice(value);
+    if (!s.ok()) {
+        return s;
+    }
+
+    SetConfigValueInMem(CONFIG_DB, CONFIG_RESOURCE_INDEX_BUILD_DEVICE, value);
+    return Status::OK();
+}
+
+}  // namespace server
+}  // namespace milvus
diff --git a/core/src/server/Config.h b/core/src/server/Config.h
new file mode 100644
index 0000000000..4cab25a1c6
--- /dev/null
+++ b/core/src/server/Config.h
@@ -0,0 +1,305 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <mutex>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include "config/ConfigNode.h"
+#include "utils/Status.h"
+
+namespace milvus {
+namespace server {
+
+/* server config */
+static const char* CONFIG_SERVER = "server_config";
+static const char* CONFIG_SERVER_ADDRESS = "address";
+static const char* CONFIG_SERVER_ADDRESS_DEFAULT = "127.0.0.1";
+static const char* CONFIG_SERVER_PORT = "port";
+static const char* CONFIG_SERVER_PORT_DEFAULT = "19530";
+static const char* CONFIG_SERVER_DEPLOY_MODE = "deploy_mode";
+static const char* CONFIG_SERVER_DEPLOY_MODE_DEFAULT = "single";
+static const char* CONFIG_SERVER_TIME_ZONE = "time_zone";
+static const char* CONFIG_SERVER_TIME_ZONE_DEFAULT = "UTC+8";
+
+/* db config */
+static const char* CONFIG_DB = "db_config";
+static const char* CONFIG_DB_PRIMARY_PATH = "primary_path";
+static const char* CONFIG_DB_PRIMARY_PATH_DEFAULT = "/tmp/milvus";
+static const char* CONFIG_DB_SECONDARY_PATH = "secondary_path";
+static const char* CONFIG_DB_SECONDARY_PATH_DEFAULT = "";
+static const char* CONFIG_DB_BACKEND_URL = "backend_url";
+static const char* CONFIG_DB_BACKEND_URL_DEFAULT = "sqlite://:@:/";
+static const char* CONFIG_DB_ARCHIVE_DISK_THRESHOLD = "archive_disk_threshold";
+static const char* CONFIG_DB_ARCHIVE_DISK_THRESHOLD_DEFAULT = "0";
+static const char* CONFIG_DB_ARCHIVE_DAYS_THRESHOLD = "archive_days_threshold";
+static const char* CONFIG_DB_ARCHIVE_DAYS_THRESHOLD_DEFAULT = "0";
+static const char* CONFIG_DB_INSERT_BUFFER_SIZE = "insert_buffer_size";
+static const char* CONFIG_DB_INSERT_BUFFER_SIZE_DEFAULT = "4";
+static const char* CONFIG_DB_PRELOAD_TABLE = "preload_table";
+
+/* cache config */
+static const char* CONFIG_CACHE = "cache_config";
+static const char* CONFIG_CACHE_CPU_CACHE_CAPACITY = "cpu_cache_capacity";
+static const char* CONFIG_CACHE_CPU_CACHE_CAPACITY_DEFAULT = "16";
+static const char* CONFIG_CACHE_GPU_CACHE_CAPACITY = "gpu_cache_capacity";
+static const char* CONFIG_CACHE_GPU_CACHE_CAPACITY_DEFAULT = "4";
+static const char* CONFIG_CACHE_CPU_CACHE_THRESHOLD = "cpu_mem_threshold";
+static const char* CONFIG_CACHE_CPU_CACHE_THRESHOLD_DEFAULT = "0.85";
+static const char* CONFIG_CACHE_GPU_CACHE_THRESHOLD = "gpu_mem_threshold";
+static const char* CONFIG_CACHE_GPU_CACHE_THRESHOLD_DEFAULT = "0.85";
+static const char* CONFIG_CACHE_CACHE_INSERT_DATA = "cache_insert_data";
+static const char* CONFIG_CACHE_CACHE_INSERT_DATA_DEFAULT = "false";
+
+/* metric config */
+static const char* CONFIG_METRIC = "metric_config";
+static const char* CONFIG_METRIC_ENABLE_MONITOR = "enable_monitor";
+static const char* CONFIG_METRIC_ENABLE_MONITOR_DEFAULT = "false";
+static const char* CONFIG_METRIC_COLLECTOR = "collector";
+static const char* CONFIG_METRIC_COLLECTOR_DEFAULT = "prometheus";
+static const char* CONFIG_METRIC_PROMETHEUS = "prometheus_config";
+static const char* CONFIG_METRIC_PROMETHEUS_PORT = "port";
+static const char* CONFIG_METRIC_PROMETHEUS_PORT_DEFAULT = "8080";
+
+/* engine config */
+static const char* CONFIG_ENGINE = "engine_config";
+static const char* CONFIG_ENGINE_USE_BLAS_THRESHOLD = "use_blas_threshold";
+static const char* CONFIG_ENGINE_USE_BLAS_THRESHOLD_DEFAULT = "20";
+static const char* CONFIG_ENGINE_OMP_THREAD_NUM = "omp_thread_num";
+static const char* CONFIG_ENGINE_OMP_THREAD_NUM_DEFAULT = "0";
+
+/* resource config */
+static const char* CONFIG_RESOURCE = "resource_config";
+static const char* CONFIG_RESOURCE_MODE = "mode";
+static const char* CONFIG_RESOURCE_MODE_DEFAULT = "simple";
+static const char* CONFIG_RESOURCE_SEARCH_RESOURCES = "search_resources";
+static const char* CONFIG_RESOURCE_INDEX_BUILD_DEVICE = "index_build_device";
+static const char* CONFIG_RESOURCE_INDEX_BUILD_DEVICE_DEFAULT = "gpu0";
+
+class Config {
+ public:
+    static Config&
+    GetInstance();
+    Status
+    LoadConfigFile(const std::string& filename);
+    Status
+    ValidateConfig();
+    Status
+    ResetDefaultConfig();
+    void
+    PrintAll();
+
+ private:
+    ConfigNode&
+    GetConfigNode(const std::string& name);
+    Status
+    GetConfigValueInMem(const std::string& parent_key, const std::string& child_key, std::string& value);
+    void
+    SetConfigValueInMem(const std::string& parent_key, const std::string& child_key, const std::string& value);
+    void
+    PrintConfigSection(const std::string& config_node_name);
+
+    ///////////////////////////////////////////////////////////////////////////
+    /* server config */
+    Status
+    CheckServerConfigAddress(const std::string& value);
+    Status
+    CheckServerConfigPort(const std::string& value);
+    Status
+    CheckServerConfigDeployMode(const std::string& value);
+    Status
+    CheckServerConfigTimeZone(const std::string& value);
+
+    /* db config */
+    Status
+    CheckDBConfigPrimaryPath(const std::string& value);
+    Status
+    CheckDBConfigSecondaryPath(const std::string& value);
+    Status
+    CheckDBConfigBackendUrl(const std::string& value);
+    Status
+    CheckDBConfigArchiveDiskThreshold(const std::string& value);
+    Status
+    CheckDBConfigArchiveDaysThreshold(const std::string& value);
+    Status
+    CheckDBConfigInsertBufferSize(const std::string& value);
+
+    /* metric config */
+    Status
+    CheckMetricConfigEnableMonitor(const std::string& value);
+    Status
+    CheckMetricConfigCollector(const std::string& value);
+    Status
+    CheckMetricConfigPrometheusPort(const std::string& value);
+
+    /* cache config */
+    Status
+    CheckCacheConfigCpuCacheCapacity(const std::string& value);
+    Status
+    CheckCacheConfigCpuCacheThreshold(const std::string& value);
+    Status
+    CheckCacheConfigGpuCacheCapacity(const std::string& value);
+    Status
+    CheckCacheConfigGpuCacheThreshold(const std::string& value);
+    Status
+    CheckCacheConfigCacheInsertData(const std::string& value);
+
+    /* engine config */
+    Status
+    CheckEngineConfigUseBlasThreshold(const std::string& value);
+    Status
+    CheckEngineConfigOmpThreadNum(const std::string& value);
+
+    /* resource config */
+    Status
+    CheckResourceConfigMode(const std::string& value);
+    Status
+    CheckResourceConfigSearchResources(const std::vector<std::string>& value);
+    Status
+    CheckResourceConfigIndexBuildDevice(const std::string& value);
+
+    std::string
+    GetConfigStr(const std::string& parent_key, const std::string& child_key, const std::string& default_value = "");
+
+ public:
+    /* server config */
+    Status
+    GetServerConfigAddress(std::string& value);
+    Status
+    GetServerConfigPort(std::string& value);
+    Status
+    GetServerConfigDeployMode(std::string& value);
+    Status
+    GetServerConfigTimeZone(std::string& value);
+
+    /* db config */
+    Status
+    GetDBConfigPrimaryPath(std::string& value);
+    Status
+    GetDBConfigSecondaryPath(std::string& value);
+    Status
+    GetDBConfigBackendUrl(std::string& value);
+    Status
+    GetDBConfigArchiveDiskThreshold(int32_t& value);
+    Status
+    GetDBConfigArchiveDaysThreshold(int32_t& value);
+    Status
+    GetDBConfigInsertBufferSize(int32_t& value);
+    Status
+    GetDBConfigPreloadTable(std::string& value);
+
+    /* metric config */
+    Status
+    GetMetricConfigEnableMonitor(bool& value);
+    Status
+    GetMetricConfigCollector(std::string& value);
+    Status
+    GetMetricConfigPrometheusPort(std::string& value);
+
+    /* cache config */
+    Status
+    GetCacheConfigCpuCacheCapacity(int64_t& value);
+    Status
+    GetCacheConfigCpuCacheThreshold(float& value);
+    Status
+    GetCacheConfigGpuCacheCapacity(int64_t& value);
+    Status
+    GetCacheConfigGpuCacheThreshold(float& value);
+    Status
+    GetCacheConfigCacheInsertData(bool& value);
+
+    /* engine config */
+    Status
+    GetEngineConfigUseBlasThreshold(int32_t& value);
+    Status
+    GetEngineConfigOmpThreadNum(int32_t& value);
+
+    /* resource config */
+    Status
+    GetResourceConfigMode(std::string& value);
+    Status
+    GetResourceConfigSearchResources(std::vector<std::string>& value);
+    Status
+    GetResourceConfigIndexBuildDevice(int32_t& value);
+
+ public:
+    /* server config */
+    Status
+    SetServerConfigAddress(const std::string& value);
+    Status
+    SetServerConfigPort(const std::string& value);
+    Status
+    SetServerConfigDeployMode(const std::string& value);
+    Status
+    SetServerConfigTimeZone(const std::string& value);
+
+    /* db config */
+    Status
+    SetDBConfigPrimaryPath(const std::string& value);
+    Status
+    SetDBConfigSecondaryPath(const std::string& value);
+    Status
+    SetDBConfigBackendUrl(const std::string& value);
+    Status
+    SetDBConfigArchiveDiskThreshold(const std::string& value);
+    Status
+    SetDBConfigArchiveDaysThreshold(const std::string& value);
+    Status
+    SetDBConfigInsertBufferSize(const std::string& value);
+
+    /* metric config */
+    Status
+    SetMetricConfigEnableMonitor(const std::string& value);
+    Status
+    SetMetricConfigCollector(const std::string& value);
+    Status
+    SetMetricConfigPrometheusPort(const std::string& value);
+
+    /* cache config */
+    Status
+    SetCacheConfigCpuCacheCapacity(const std::string& value);
+    Status
+    SetCacheConfigCpuCacheThreshold(const std::string& value);
+    Status
+    SetCacheConfigGpuCacheCapacity(const std::string& value);
+    Status
+    SetCacheConfigGpuCacheThreshold(const std::string& value);
+    Status
+    SetCacheConfigCacheInsertData(const std::string& value);
+
+    /* engine config */
+    Status
+    SetEngineConfigUseBlasThreshold(const std::string& value);
+    Status
+    SetEngineConfigOmpThreadNum(const std::string& value);
+
+    /* resource config */
+    Status
+    SetResourceConfigMode(const std::string& value);
+    Status
+    SetResourceConfigIndexBuildDevice(const std::string& value);
+
+ private:
+    std::unordered_map<std::string, std::unordered_map<std::string, std::string>> config_map_;
+    std::mutex mutex_;
+};
+
+}  // namespace server
+}  // namespace milvus
diff --git a/core/src/server/DBWrapper.cpp b/core/src/server/DBWrapper.cpp
new file mode 100644
index 0000000000..a5b892ad47
--- /dev/null
+++ b/core/src/server/DBWrapper.cpp
@@ -0,0 +1,216 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 <faiss/utils.h>
+#include <omp.h>
+#include <cmath>
+#include <string>
+#include <vector>
+
+#include "db/DBFactory.h"
+#include "server/Config.h"
+#include "server/DBWrapper.h"
+#include "utils/CommonUtil.h"
+#include "utils/Log.h"
+#include "utils/StringHelpFunctions.h"
+
+namespace milvus {
+namespace server {
+
+Status
+DBWrapper::StartService() {
+    Config& config = Config::GetInstance();
+    Status s;
+
+    // db config
+    engine::DBOptions opt;
+    s = config.GetDBConfigBackendUrl(opt.meta_.backend_uri_);
+    if (!s.ok()) {
+        return s;
+    }
+
+    std::string path;
+    s = config.GetDBConfigPrimaryPath(path);
+    if (!s.ok()) {
+        return s;
+    }
+
+    opt.meta_.path_ = path + "/db";
+
+    std::string db_slave_path;
+    s = config.GetDBConfigSecondaryPath(db_slave_path);
+    if (!s.ok()) {
+        return s;
+    }
+
+    StringHelpFunctions::SplitStringByDelimeter(db_slave_path, ";", opt.meta_.slave_paths_);
+
+    // cache config
+    s = config.GetCacheConfigCacheInsertData(opt.insert_cache_immediately_);
+    if (!s.ok()) {
+        return s;
+    }
+
+    std::string mode;
+    s = config.GetServerConfigDeployMode(mode);
+    if (!s.ok()) {
+        return s;
+    }
+
+    if (mode == "single") {
+        opt.mode_ = engine::DBOptions::MODE::SINGLE;
+    } else if (mode == "cluster_readonly") {
+        opt.mode_ = engine::DBOptions::MODE::CLUSTER_READONLY;
+    } else if (mode == "cluster_writable") {
+        opt.mode_ = engine::DBOptions::MODE::CLUSTER_WRITABLE;
+    } else {
+        std::cerr << "ERROR: mode specified in server_config must be ['single', 'cluster_readonly', 'cluster_writable']"
+                  << std::endl;
+        kill(0, SIGUSR1);
+    }
+
+    // engine config
+    int32_t omp_thread;
+    s = config.GetEngineConfigOmpThreadNum(omp_thread);
+    if (!s.ok()) {
+        return s;
+    }
+
+    if (omp_thread > 0) {
+        omp_set_num_threads(omp_thread);
+        SERVER_LOG_DEBUG << "Specify openmp thread number: " << omp_thread;
+    } else {
+        uint32_t sys_thread_cnt = 8;
+        if (CommonUtil::GetSystemAvailableThreads(sys_thread_cnt)) {
+            omp_thread = static_cast<int32_t>(ceil(sys_thread_cnt * 0.5));
+            omp_set_num_threads(omp_thread);
+        }
+    }
+
+    // init faiss global variable
+    int32_t use_blas_threshold;
+    s = config.GetEngineConfigUseBlasThreshold(use_blas_threshold);
+    if (!s.ok()) {
+        return s;
+    }
+
+    faiss::distance_compute_blas_threshold = use_blas_threshold;
+
+    // set archive config
+    engine::ArchiveConf::CriteriaT criterial;
+    int32_t disk, days;
+    s = config.GetDBConfigArchiveDiskThreshold(disk);
+    if (!s.ok()) {
+        return s;
+    }
+
+    if (disk > 0) {
+        criterial[engine::ARCHIVE_CONF_DISK] = disk;
+    }
+
+    s = config.GetDBConfigArchiveDaysThreshold(days);
+    if (!s.ok()) {
+        return s;
+    }
+
+    if (days > 0) {
+        criterial[engine::ARCHIVE_CONF_DAYS] = days;
+    }
+    opt.meta_.archive_conf_.SetCriterias(criterial);
+
+    // create db root folder
+    Status status = CommonUtil::CreateDirectory(opt.meta_.path_);
+    if (!status.ok()) {
+        std::cerr << "ERROR! Failed to create database root path: " << opt.meta_.path_ << std::endl;
+        kill(0, SIGUSR1);
+    }
+
+    for (auto& path : opt.meta_.slave_paths_) {
+        status = CommonUtil::CreateDirectory(path);
+        if (!status.ok()) {
+            std::cerr << "ERROR! Failed to create database slave path: " << path << std::endl;
+            kill(0, SIGUSR1);
+        }
+    }
+
+    // create db instance
+    try {
+        db_ = engine::DBFactory::Build(opt);
+    } catch (std::exception& ex) {
+        std::cerr << "ERROR! Failed to open database: " << ex.what() << std::endl;
+        kill(0, SIGUSR1);
+    }
+
+    db_->Start();
+
+    // preload table
+    std::string preload_tables;
+    s = config.GetDBConfigPreloadTable(preload_tables);
+    if (!s.ok()) {
+        return s;
+    }
+
+    s = PreloadTables(preload_tables);
+    if (!s.ok()) {
+        std::cerr << "ERROR! Failed to preload tables: " << preload_tables << std::endl;
+        std::cerr << s.ToString() << std::endl;
+        kill(0, SIGUSR1);
+    }
+
+    return Status::OK();
+}
+
+Status
+DBWrapper::StopService() {
+    if (db_) {
+        db_->Stop();
+    }
+
+    return Status::OK();
+}
+
+Status
+DBWrapper::PreloadTables(const std::string& preload_tables) {
+    if (preload_tables.empty()) {
+        // do nothing
+    } else if (preload_tables == "*") {
+        // load all tables
+        std::vector<engine::meta::TableSchema> table_schema_array;
+        db_->AllTables(table_schema_array);
+
+        for (auto& schema : table_schema_array) {
+            auto status = db_->PreloadTable(schema.table_id_);
+            if (!status.ok()) {
+                return status;
+            }
+        }
+    } else {
+        std::vector<std::string> table_names;
+        StringHelpFunctions::SplitStringByDelimeter(preload_tables, ",", table_names);
+        for (auto& name : table_names) {
+            auto status = db_->PreloadTable(name);
+            if (!status.ok()) {
+                return status;
+            }
+        }
+    }
+
+    return Status::OK();
+}
+
+}  // namespace server
+}  // namespace milvus
diff --git a/core/src/server/DBWrapper.h b/core/src/server/DBWrapper.h
new file mode 100644
index 0000000000..0c74b3b9cb
--- /dev/null
+++ b/core/src/server/DBWrapper.h
@@ -0,0 +1,64 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <string>
+
+#include "db/DB.h"
+#include "utils/Status.h"
+
+namespace milvus {
+namespace server {
+
+class DBWrapper {
+ private:
+    DBWrapper() = default;
+    ~DBWrapper() = default;
+
+ public:
+    static DBWrapper&
+    GetInstance() {
+        static DBWrapper wrapper;
+        return wrapper;
+    }
+
+    static engine::DBPtr
+    DB() {
+        return GetInstance().EngineDB();
+    }
+
+    Status
+    StartService();
+    Status
+    StopService();
+
+    engine::DBPtr
+    EngineDB() {
+        return db_;
+    }
+
+ private:
+    Status
+    PreloadTables(const std::string& preload_tables);
+
+ private:
+    engine::DBPtr db_;
+};
+
+}  // namespace server
+}  // namespace milvus
diff --git a/core/src/server/Server.cpp b/core/src/server/Server.cpp
new file mode 100644
index 0000000000..465ed62ddf
--- /dev/null
+++ b/core/src/server/Server.cpp
@@ -0,0 +1,260 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 <fcntl.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "metrics/Metrics.h"
+#include "scheduler/SchedInst.h"
+#include "server/Config.h"
+#include "server/DBWrapper.h"
+#include "server/Server.h"
+#include "server/grpc_impl/GrpcServer.h"
+#include "utils/Log.h"
+#include "utils/LogUtil.h"
+#include "utils/SignalUtil.h"
+#include "utils/TimeRecorder.h"
+#include "wrapper/KnowhereResource.h"
+
+namespace milvus {
+namespace server {
+
+Server&
+Server::GetInstance() {
+    static Server server;
+    return server;
+}
+
+void
+Server::Init(int64_t daemonized, const std::string& pid_filename, const std::string& config_filename,
+             const std::string& log_config_file) {
+    daemonized_ = daemonized;
+    pid_filename_ = pid_filename;
+    config_filename_ = config_filename;
+    log_config_file_ = log_config_file;
+}
+
+void
+Server::Daemonize() {
+    if (daemonized_ == 0) {
+        return;
+    }
+
+    std::cout << "Milvus server run in daemonize mode";
+
+    //    std::string log_path(GetLogDirFullPath());
+    //    log_path += "zdb_server.(INFO/WARNNING/ERROR/CRITICAL)";
+    //    SERVER_LOG_INFO << "Log will be exported to: " + log_path);
+
+    pid_t pid = 0;
+
+    // Fork off the parent process
+    pid = fork();
+
+    // An error occurred
+    if (pid < 0) {
+        exit(EXIT_FAILURE);
+    }
+
+    // Success: terminate parent
+    if (pid > 0) {
+        exit(EXIT_SUCCESS);
+    }
+
+    // On success: The child process becomes session leader
+    if (setsid() < 0) {
+        exit(EXIT_FAILURE);
+    }
+
+    // Ignore signal sent from child to parent process
+    signal(SIGCHLD, SIG_IGN);
+
+    // Fork off for the second time
+    pid = fork();
+
+    // An error occurred
+    if (pid < 0) {
+        exit(EXIT_FAILURE);
+    }
+
+    // Terminate the parent
+    if (pid > 0) {
+        exit(EXIT_SUCCESS);
+    }
+
+    // Set new file permissions
+    umask(0);
+
+    // Change the working directory to root
+    int ret = chdir("/");
+    if (ret != 0) {
+        return;
+    }
+
+    // Close all open fd
+    for (int64_t fd = sysconf(_SC_OPEN_MAX); fd > 0; fd--) {
+        close(fd);
+    }
+
+    std::cout << "Redirect stdin/stdout/stderr to /dev/null";
+
+    // Redirect stdin/stdout/stderr to /dev/null
+    stdin = fopen("/dev/null", "r");
+    stdout = fopen("/dev/null", "w+");
+    stderr = fopen("/dev/null", "w+");
+    // Try to write PID of daemon to lockfile
+    if (!pid_filename_.empty()) {
+        pid_fd_ = open(pid_filename_.c_str(), O_RDWR | O_CREAT, 0640);
+        if (pid_fd_ < 0) {
+            std::cerr << "Can't open filename: " + pid_filename_ + ", Error: " + strerror(errno);
+            exit(EXIT_FAILURE);
+        }
+        if (lockf(pid_fd_, F_TLOCK, 0) < 0) {
+            std::cerr << "Can't lock filename: " + pid_filename_ + ", Error: " + strerror(errno);
+            exit(EXIT_FAILURE);
+        }
+
+        std::string pid_file_context = std::to_string(getpid());
+        ssize_t res = write(pid_fd_, pid_file_context.c_str(), pid_file_context.size());
+        if (res != 0) {
+            return;
+        }
+    }
+}
+
+Status
+Server::Start() {
+    if (daemonized_ != 0) {
+        Daemonize();
+    }
+
+    try {
+        /* Read config file */
+        Status s = LoadConfig();
+        if (!s.ok()) {
+            std::cerr << "ERROR: Milvus server fail to load config file" << std::endl;
+            return s;
+        }
+
+        /* log path is defined in Config file, so InitLog must be called after LoadConfig */
+        Config& config = Config::GetInstance();
+        std::string time_zone;
+        s = config.GetServerConfigTimeZone(time_zone);
+        if (!s.ok()) {
+            std::cerr << "Fail to get server config timezone" << std::endl;
+            return s;
+        }
+
+        if (time_zone.length() == 3) {
+            time_zone = "CUT";
+        } else {
+            int time_bias = std::stoi(time_zone.substr(3, std::string::npos));
+            if (time_bias == 0) {
+                time_zone = "CUT";
+            } else if (time_bias > 0) {
+                time_zone = "CUT" + std::to_string(-time_bias);
+            } else {
+                time_zone = "CUT+" + std::to_string(-time_bias);
+            }
+        }
+
+        if (setenv("TZ", time_zone.c_str(), 1) != 0) {
+            return Status(SERVER_UNEXPECTED_ERROR, "Fail to setenv");
+        }
+        tzset();
+
+        InitLog(log_config_file_);
+
+        server::Metrics::GetInstance().Init();
+        server::SystemInfo::GetInstance().Init();
+
+        StartService();
+        return Status::OK();
+    } catch (std::exception& ex) {
+        std::string str = "Milvus server encounter exception: " + std::string(ex.what());
+        return Status(SERVER_UNEXPECTED_ERROR, str);
+    }
+}
+
+void
+Server::Stop() {
+    std::cerr << "Milvus server is going to shutdown ..." << std::endl;
+
+    /* Unlock and close lockfile */
+    if (pid_fd_ != -1) {
+        int ret = lockf(pid_fd_, F_ULOCK, 0);
+        if (ret != 0) {
+            std::cerr << "ERROR: Can't lock file: " << strerror(errno) << std::endl;
+            exit(0);
+        }
+        ret = close(pid_fd_);
+        if (ret != 0) {
+            std::cerr << "ERROR: Can't close file: " << strerror(errno) << std::endl;
+            exit(0);
+        }
+    }
+
+    /* delete lockfile */
+    if (!pid_filename_.empty()) {
+        int ret = unlink(pid_filename_.c_str());
+        if (ret != 0) {
+            std::cerr << "ERROR: Can't unlink file: " << strerror(errno) << std::endl;
+            exit(0);
+        }
+    }
+
+    StopService();
+
+    std::cerr << "Milvus server exit..." << std::endl;
+}
+
+Status
+Server::LoadConfig() {
+    Config& config = Config::GetInstance();
+    Status s = config.LoadConfigFile(config_filename_);
+    if (!s.ok()) {
+        std::cerr << s.message() << std::endl;
+        return s;
+    }
+
+    s = config.ValidateConfig();
+    if (!s.ok()) {
+        std::cerr << "Config check fail: " << s.message() << std::endl;
+        return s;
+    }
+    return milvus::Status::OK();
+}
+
+void
+Server::StartService() {
+    engine::KnowhereResource::Initialize();
+    scheduler::StartSchedulerService();
+    DBWrapper::GetInstance().StartService();
+    grpc::GrpcServer::GetInstance().Start();
+}
+
+void
+Server::StopService() {
+    grpc::GrpcServer::GetInstance().Stop();
+    DBWrapper::GetInstance().StopService();
+    scheduler::StopSchedulerService();
+    engine::KnowhereResource::Finalize();
+}
+
+}  // namespace server
+}  // namespace milvus
diff --git a/core/src/server/Server.h b/core/src/server/Server.h
new file mode 100644
index 0000000000..c0f2812f4c
--- /dev/null
+++ b/core/src/server/Server.h
@@ -0,0 +1,64 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <string>
+#include "utils/Status.h"
+
+namespace milvus {
+namespace server {
+
+class Server {
+ public:
+    static Server&
+    GetInstance();
+
+    void
+    Init(int64_t daemonized, const std::string& pid_filename, const std::string& config_filename,
+         const std::string& log_config_file);
+
+    Status
+    Start();
+    void
+    Stop();
+
+ private:
+    Server() = default;
+    ~Server() = default;
+
+    void
+    Daemonize();
+
+    Status
+    LoadConfig();
+
+    void
+    StartService();
+    void
+    StopService();
+
+ private:
+    int64_t daemonized_ = 0;
+    int pid_fd_ = -1;
+    std::string pid_filename_;
+    std::string config_filename_;
+    std::string log_config_file_;
+};  // Server
+
+}  // namespace server
+}  // namespace milvus
diff --git a/core/src/server/grpc_impl/GrpcRequestHandler.cpp b/core/src/server/grpc_impl/GrpcRequestHandler.cpp
new file mode 100644
index 0000000000..a9ee3d77d0
--- /dev/null
+++ b/core/src/server/grpc_impl/GrpcRequestHandler.cpp
@@ -0,0 +1,198 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "server/grpc_impl/GrpcRequestHandler.h"
+#include "server/grpc_impl/GrpcRequestTask.h"
+#include "utils/TimeRecorder.h"
+
+#include <vector>
+
+namespace milvus {
+namespace server {
+namespace grpc {
+
+::grpc::Status
+GrpcRequestHandler::CreateTable(::grpc::ServerContext* context, const ::milvus::grpc::TableSchema* request,
+                                ::milvus::grpc::Status* response) {
+    BaseTaskPtr task_ptr = CreateTableTask::Create(request);
+    GrpcRequestScheduler::ExecTask(task_ptr, response);
+    return ::grpc::Status::OK;
+}
+
+::grpc::Status
+GrpcRequestHandler::HasTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request,
+                             ::milvus::grpc::BoolReply* response) {
+    bool has_table = false;
+    BaseTaskPtr task_ptr = HasTableTask::Create(request->table_name(), has_table);
+    ::milvus::grpc::Status grpc_status;
+    GrpcRequestScheduler::ExecTask(task_ptr, &grpc_status);
+    response->set_bool_reply(has_table);
+    response->mutable_status()->set_reason(grpc_status.reason());
+    response->mutable_status()->set_error_code(grpc_status.error_code());
+    return ::grpc::Status::OK;
+}
+
+::grpc::Status
+GrpcRequestHandler::DropTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request,
+                              ::milvus::grpc::Status* response) {
+    BaseTaskPtr task_ptr = DropTableTask::Create(request->table_name());
+    GrpcRequestScheduler::ExecTask(task_ptr, response);
+    return ::grpc::Status::OK;
+}
+
+::grpc::Status
+GrpcRequestHandler::CreateIndex(::grpc::ServerContext* context, const ::milvus::grpc::IndexParam* request,
+                                ::milvus::grpc::Status* response) {
+    BaseTaskPtr task_ptr = CreateIndexTask::Create(request);
+    GrpcRequestScheduler::ExecTask(task_ptr, response);
+    return ::grpc::Status::OK;
+}
+
+::grpc::Status
+GrpcRequestHandler::Insert(::grpc::ServerContext* context, const ::milvus::grpc::InsertParam* request,
+                           ::milvus::grpc::VectorIds* response) {
+    BaseTaskPtr task_ptr = InsertTask::Create(request, response);
+    ::milvus::grpc::Status grpc_status;
+    GrpcRequestScheduler::ExecTask(task_ptr, &grpc_status);
+    response->mutable_status()->set_reason(grpc_status.reason());
+    response->mutable_status()->set_error_code(grpc_status.error_code());
+    return ::grpc::Status::OK;
+}
+
+::grpc::Status
+GrpcRequestHandler::Search(::grpc::ServerContext* context, const ::milvus::grpc::SearchParam* request,
+                           ::milvus::grpc::TopKQueryResultList* response) {
+    std::vector<std::string> file_id_array;
+    BaseTaskPtr task_ptr = SearchTask::Create(request, file_id_array, response);
+    ::milvus::grpc::Status grpc_status;
+    GrpcRequestScheduler::ExecTask(task_ptr, &grpc_status);
+    response->mutable_status()->set_error_code(grpc_status.error_code());
+    response->mutable_status()->set_reason(grpc_status.reason());
+    return ::grpc::Status::OK;
+}
+
+::grpc::Status
+GrpcRequestHandler::SearchInFiles(::grpc::ServerContext* context, const ::milvus::grpc::SearchInFilesParam* request,
+                                  ::milvus::grpc::TopKQueryResultList* response) {
+    std::vector<std::string> file_id_array;
+    for (int i = 0; i < request->file_id_array_size(); i++) {
+        file_id_array.push_back(request->file_id_array(i));
+    }
+    ::milvus::grpc::SearchInFilesParam* request_mutable = const_cast<::milvus::grpc::SearchInFilesParam*>(request);
+    BaseTaskPtr task_ptr = SearchTask::Create(request_mutable->mutable_search_param(), file_id_array, response);
+    ::milvus::grpc::Status grpc_status;
+    GrpcRequestScheduler::ExecTask(task_ptr, &grpc_status);
+    response->mutable_status()->set_error_code(grpc_status.error_code());
+    response->mutable_status()->set_reason(grpc_status.reason());
+    return ::grpc::Status::OK;
+}
+
+::grpc::Status
+GrpcRequestHandler::DescribeTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request,
+                                  ::milvus::grpc::TableSchema* response) {
+    BaseTaskPtr task_ptr = DescribeTableTask::Create(request->table_name(), response);
+    ::milvus::grpc::Status grpc_status;
+    GrpcRequestScheduler::ExecTask(task_ptr, &grpc_status);
+    response->mutable_status()->set_error_code(grpc_status.error_code());
+    response->mutable_status()->set_reason(grpc_status.reason());
+    return ::grpc::Status::OK;
+}
+
+::grpc::Status
+GrpcRequestHandler::CountTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request,
+                               ::milvus::grpc::TableRowCount* response) {
+    int64_t row_count = 0;
+    BaseTaskPtr task_ptr = CountTableTask::Create(request->table_name(), row_count);
+    ::milvus::grpc::Status grpc_status;
+    GrpcRequestScheduler::ExecTask(task_ptr, &grpc_status);
+    response->set_table_row_count(row_count);
+    response->mutable_status()->set_reason(grpc_status.reason());
+    response->mutable_status()->set_error_code(grpc_status.error_code());
+    return ::grpc::Status::OK;
+}
+
+::grpc::Status
+GrpcRequestHandler::ShowTables(::grpc::ServerContext* context, const ::milvus::grpc::Command* request,
+                               ::milvus::grpc::TableNameList* response) {
+    BaseTaskPtr task_ptr = ShowTablesTask::Create(response);
+    ::milvus::grpc::Status grpc_status;
+    GrpcRequestScheduler::ExecTask(task_ptr, &grpc_status);
+    response->mutable_status()->set_error_code(grpc_status.error_code());
+    response->mutable_status()->set_reason(grpc_status.reason());
+    return ::grpc::Status::OK;
+}
+
+::grpc::Status
+GrpcRequestHandler::Cmd(::grpc::ServerContext* context, const ::milvus::grpc::Command* request,
+                        ::milvus::grpc::StringReply* response) {
+    std::string result;
+    BaseTaskPtr task_ptr = CmdTask::Create(request->cmd(), result);
+    ::milvus::grpc::Status grpc_status;
+    GrpcRequestScheduler::ExecTask(task_ptr, &grpc_status);
+    response->set_string_reply(result);
+    response->mutable_status()->set_reason(grpc_status.reason());
+    response->mutable_status()->set_error_code(grpc_status.error_code());
+    return ::grpc::Status::OK;
+}
+
+::grpc::Status
+GrpcRequestHandler::DeleteByRange(::grpc::ServerContext* context, const ::milvus::grpc::DeleteByRangeParam* request,
+                                  ::milvus::grpc::Status* response) {
+    BaseTaskPtr task_ptr = DeleteByRangeTask::Create(request);
+    ::milvus::grpc::Status grpc_status;
+    GrpcRequestScheduler::ExecTask(task_ptr, &grpc_status);
+    response->set_error_code(grpc_status.error_code());
+    response->set_reason(grpc_status.reason());
+    return ::grpc::Status::OK;
+}
+
+::grpc::Status
+GrpcRequestHandler::PreloadTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request,
+                                 ::milvus::grpc::Status* response) {
+    BaseTaskPtr task_ptr = PreloadTableTask::Create(request->table_name());
+    ::milvus::grpc::Status grpc_status;
+    GrpcRequestScheduler::ExecTask(task_ptr, &grpc_status);
+    response->set_reason(grpc_status.reason());
+    response->set_error_code(grpc_status.error_code());
+    return ::grpc::Status::OK;
+}
+
+::grpc::Status
+GrpcRequestHandler::DescribeIndex(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request,
+                                  ::milvus::grpc::IndexParam* response) {
+    BaseTaskPtr task_ptr = DescribeIndexTask::Create(request->table_name(), response);
+    ::milvus::grpc::Status grpc_status;
+    GrpcRequestScheduler::ExecTask(task_ptr, &grpc_status);
+    response->mutable_status()->set_reason(grpc_status.reason());
+    response->mutable_status()->set_error_code(grpc_status.error_code());
+    return ::grpc::Status::OK;
+}
+
+::grpc::Status
+GrpcRequestHandler::DropIndex(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request,
+                              ::milvus::grpc::Status* response) {
+    BaseTaskPtr task_ptr = DropIndexTask::Create(request->table_name());
+    ::milvus::grpc::Status grpc_status;
+    GrpcRequestScheduler::ExecTask(task_ptr, &grpc_status);
+    response->set_reason(grpc_status.reason());
+    response->set_error_code(grpc_status.error_code());
+    return ::grpc::Status::OK;
+}
+
+}  // namespace grpc
+}  // namespace server
+}  // namespace milvus
diff --git a/core/src/server/grpc_impl/GrpcRequestHandler.h b/core/src/server/grpc_impl/GrpcRequestHandler.h
new file mode 100644
index 0000000000..1a9b591154
--- /dev/null
+++ b/core/src/server/grpc_impl/GrpcRequestHandler.h
@@ -0,0 +1,325 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <cstdint>
+#include <string>
+
+#include "grpc/gen-milvus/milvus.grpc.pb.h"
+#include "grpc/gen-status/status.pb.h"
+
+namespace milvus {
+namespace server {
+namespace grpc {
+class GrpcRequestHandler final : public ::milvus::grpc::MilvusService::Service {
+ public:
+    /**
+     * @brief Create table method
+     *
+     * This method is used to create table
+     *
+     * @param context, add context for every RPC
+     * @param request, used to provide table information to be created.
+     * @param response, used to get the status
+     *
+     * @return status
+     *
+     * @param request
+     * @param response
+     * @param context
+     */
+    ::grpc::Status
+    CreateTable(::grpc::ServerContext* context, const ::milvus::grpc::TableSchema* request,
+                ::milvus::grpc::Status* response) override;
+
+    /**
+     * @brief Test table existence method
+     *
+     * This method is used to test table existence.
+     *
+     * @param context, add context for every RPC
+     * @param request, table name is going to be tested.
+     * @param response, get the bool reply of hastable
+     *
+     * @return status
+     *
+     * @param request
+     * @param response
+     * @param context
+     */
+    ::grpc::Status
+    HasTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request,
+             ::milvus::grpc::BoolReply* response) override;
+
+    /**
+     * @brief Drop table method
+     *
+     * This method is used to drop table.
+     *
+     * @param context, add context for every RPC
+     * @param request, table name is going to be deleted.
+     * @param response, get the status of droptable
+     *
+     * @return status
+     *
+     * @param request
+     * @param response
+     * @param context
+     */
+    ::grpc::Status
+    DropTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request,
+              ::milvus::grpc::Status* response) override;
+
+    /**
+     * @brief build index by table method
+     *
+     * This method is used to build index by table in sync.
+     *
+     * @param context, add context for every RPC
+     * @param request, table name is going to be built index.
+     * @param response, get the status of buildindex
+     *
+     * @return status
+     *
+     * @param request
+     * @param response
+     * @param context
+     */
+    ::grpc::Status
+    CreateIndex(::grpc::ServerContext* context, const ::milvus::grpc::IndexParam* request,
+                ::milvus::grpc::Status* response) override;
+
+    /**
+     * @brief Insert vector array to table
+     *
+     * This method is used to insert vector array to table.
+     *
+     * @param context, add context for every RPC
+     * @param request, table_name is inserted.
+     * @param response, vector array is inserted.
+     *
+     * @return status
+     *
+     * @param context
+     * @param request
+     * @param response
+     */
+    ::grpc::Status
+    Insert(::grpc::ServerContext* context, const ::milvus::grpc::InsertParam* request,
+           ::milvus::grpc::VectorIds* response) override;
+
+    /**
+     * @brief Query vector
+     *
+     * This method is used to query vector in table.
+     *
+     * @param context, add context for every RPC
+     * @param request:
+     *               table_name, table_name is queried.
+     *               query_record_array, all vector are going to be queried.
+     *               query_range_array, optional ranges for conditional search. If not specified, search whole table
+     *               topk, how many similarity vectors will be searched.
+     *
+     * @param writer, write query result array.
+     *
+     * @return status
+     *
+     * @param context
+     * @param request
+     * @param writer
+     */
+    ::grpc::Status
+    Search(::grpc::ServerContext* context, const ::milvus::grpc::SearchParam* request,
+           ::milvus::grpc::TopKQueryResultList* response) override;
+
+    /**
+     * @brief Internal use query interface
+     *
+     * This method is used to query vector in specified files.
+     *
+     * @param context, add context for every RPC
+     * @param request:
+     *                file_id_array, specified files id array, queried.
+     *                query_record_array, all vector are going to be queried.
+     *                query_range_array, optional ranges for conditional search. If not specified, search whole table
+     *                topk, how many similarity vectors will be searched.
+     *
+     * @param writer, write query result array.
+     *
+     * @return status
+     *
+     * @param context
+     * @param request
+     * @param writer
+     */
+    ::grpc::Status
+    SearchInFiles(::grpc::ServerContext* context, const ::milvus::grpc::SearchInFilesParam* request,
+                  ::milvus::grpc::TopKQueryResultList* response) override;
+
+    /**
+     * @brief Get table schema
+     *
+     * This method is used to get table schema.
+     *
+     * @param context, add context for every RPC
+     * @param request, target table name.
+     * @param response, table schema
+     *
+     * @return status
+     *
+     * @param context
+     * @param request
+     * @param response
+     */
+    ::grpc::Status
+    DescribeTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request,
+                  ::milvus::grpc::TableSchema* response) override;
+
+    /**
+     * @brief Get table row count
+     *
+     * This method is used to get table row count.
+     *
+     * @param context, add context for every RPC
+     * @param request, target table name.
+     * @param response, table row count
+     *
+     * @return table row count
+     *
+     * @param request
+     * @param response
+     * @param context
+     */
+    ::grpc::Status
+    CountTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request,
+               ::milvus::grpc::TableRowCount* response) override;
+
+    /**
+     * @brief List all tables in database
+     *
+     * This method is used to list all tables.
+     *
+     * @param context, add context for every RPC
+     * @param request, show table command, usually not use
+     * @param writer, write tables to client
+     *
+     * @return status
+     *
+     * @param context
+     * @param request
+     * @param writer
+     */
+    ::grpc::Status
+    ShowTables(::grpc::ServerContext* context, const ::milvus::grpc::Command* request,
+               ::milvus::grpc::TableNameList* response) override;
+
+    /**
+     * @brief Give the server status
+     *
+     *
+     * This method is used to give the server status.
+     * @param context, add context for every RPC
+     * @param request, give server command
+     * @param response, server status
+     *
+     * @return status
+     *
+     * @param context
+     * @param request
+     * @param response
+     */
+    ::grpc::Status
+    Cmd(::grpc::ServerContext* context, const ::milvus::grpc::Command* request,
+        ::milvus::grpc::StringReply* response) override;
+
+    /**
+     * @brief delete table by range
+     *
+     * This method is used to delete table by range.
+     * @param context, add context for every RPC
+     * @param request, table name and range
+     * @param response, status
+     *
+     * @return status
+     *
+     * @param context
+     * @param request
+     * @param response
+     */
+    ::grpc::Status
+    DeleteByRange(::grpc::ServerContext* context, const ::milvus::grpc::DeleteByRangeParam* request,
+                  ::milvus::grpc::Status* response) override;
+
+    /**
+     * @brief preload table
+     *
+     * This method is used to preload table.
+     * @param context, add context for every RPC
+     * @param request, table name
+     * @param response, status
+     *
+     * @return status
+     *
+     * @param context
+     * @param request
+     * @param response
+     */
+    ::grpc::Status
+    PreloadTable(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request,
+                 ::milvus::grpc::Status* response) override;
+
+    /**
+     * @brief Describe index
+     *
+     * This method is used to describe index.
+     * @param context, add context for every RPC
+     * @param request, table name
+     * @param response, index informations
+     *
+     * @return status
+     *
+     * @param context
+     * @param request
+     * @param response
+     */
+    ::grpc::Status
+    DescribeIndex(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request,
+                  ::milvus::grpc::IndexParam* response) override;
+
+    /**
+     * @brief Drop index
+     *
+     * This method is used to drop index.
+     * @param context, add context for every RPC
+     * @param request, table name
+     * @param response, status
+     *
+     * @return status
+     *
+     * @param context
+     * @param request
+     * @param response
+     */
+    ::grpc::Status
+    DropIndex(::grpc::ServerContext* context, const ::milvus::grpc::TableName* request,
+              ::milvus::grpc::Status* response) override;
+};
+
+}  // namespace grpc
+}  // namespace server
+}  // namespace milvus
diff --git a/core/src/server/grpc_impl/GrpcRequestScheduler.cpp b/core/src/server/grpc_impl/GrpcRequestScheduler.cpp
new file mode 100644
index 0000000000..ac35f82947
--- /dev/null
+++ b/core/src/server/grpc_impl/GrpcRequestScheduler.cpp
@@ -0,0 +1,239 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "server/grpc_impl/GrpcRequestScheduler.h"
+#include "utils/Log.h"
+
+#include "grpc/gen-status/status.pb.h"
+
+#include <utility>
+
+namespace milvus {
+namespace server {
+namespace grpc {
+
+namespace {
+::milvus::grpc::ErrorCode
+ErrorMap(ErrorCode code) {
+    static const std::map<ErrorCode, ::milvus::grpc::ErrorCode> code_map = {
+        {SERVER_UNEXPECTED_ERROR, ::milvus::grpc::ErrorCode::UNEXPECTED_ERROR},
+        {SERVER_UNSUPPORTED_ERROR, ::milvus::grpc::ErrorCode::UNEXPECTED_ERROR},
+        {SERVER_NULL_POINTER, ::milvus::grpc::ErrorCode::UNEXPECTED_ERROR},
+        {SERVER_INVALID_ARGUMENT, ::milvus::grpc::ErrorCode::ILLEGAL_ARGUMENT},
+        {SERVER_FILE_NOT_FOUND, ::milvus::grpc::ErrorCode::FILE_NOT_FOUND},
+        {SERVER_NOT_IMPLEMENT, ::milvus::grpc::ErrorCode::UNEXPECTED_ERROR},
+        {SERVER_CANNOT_CREATE_FOLDER, ::milvus::grpc::ErrorCode::CANNOT_CREATE_FOLDER},
+        {SERVER_CANNOT_CREATE_FILE, ::milvus::grpc::ErrorCode::CANNOT_CREATE_FILE},
+        {SERVER_CANNOT_DELETE_FOLDER, ::milvus::grpc::ErrorCode::CANNOT_DELETE_FOLDER},
+        {SERVER_CANNOT_DELETE_FILE, ::milvus::grpc::ErrorCode::CANNOT_DELETE_FILE},
+        {SERVER_TABLE_NOT_EXIST, ::milvus::grpc::ErrorCode::TABLE_NOT_EXISTS},
+        {SERVER_INVALID_TABLE_NAME, ::milvus::grpc::ErrorCode::ILLEGAL_TABLE_NAME},
+        {SERVER_INVALID_TABLE_DIMENSION, ::milvus::grpc::ErrorCode::ILLEGAL_DIMENSION},
+        {SERVER_INVALID_TIME_RANGE, ::milvus::grpc::ErrorCode::ILLEGAL_RANGE},
+        {SERVER_INVALID_VECTOR_DIMENSION, ::milvus::grpc::ErrorCode::ILLEGAL_DIMENSION},
+
+        {SERVER_INVALID_INDEX_TYPE, ::milvus::grpc::ErrorCode::ILLEGAL_INDEX_TYPE},
+        {SERVER_INVALID_ROWRECORD, ::milvus::grpc::ErrorCode::ILLEGAL_ROWRECORD},
+        {SERVER_INVALID_ROWRECORD_ARRAY, ::milvus::grpc::ErrorCode::ILLEGAL_ROWRECORD},
+        {SERVER_INVALID_TOPK, ::milvus::grpc::ErrorCode::ILLEGAL_TOPK},
+        {SERVER_INVALID_NPROBE, ::milvus::grpc::ErrorCode::ILLEGAL_ARGUMENT},
+        {SERVER_INVALID_INDEX_NLIST, ::milvus::grpc::ErrorCode::ILLEGAL_NLIST},
+        {SERVER_INVALID_INDEX_METRIC_TYPE, ::milvus::grpc::ErrorCode::ILLEGAL_METRIC_TYPE},
+        {SERVER_INVALID_INDEX_FILE_SIZE, ::milvus::grpc::ErrorCode::ILLEGAL_ARGUMENT},
+        {SERVER_ILLEGAL_VECTOR_ID, ::milvus::grpc::ErrorCode::ILLEGAL_VECTOR_ID},
+        {SERVER_ILLEGAL_SEARCH_RESULT, ::milvus::grpc::ErrorCode::ILLEGAL_SEARCH_RESULT},
+        {SERVER_CACHE_FULL, ::milvus::grpc::ErrorCode::CACHE_FAILED},
+        {DB_META_TRANSACTION_FAILED, ::milvus::grpc::ErrorCode::META_FAILED},
+        {SERVER_BUILD_INDEX_ERROR, ::milvus::grpc::ErrorCode::BUILD_INDEX_ERROR},
+        {SERVER_OUT_OF_MEMORY, ::milvus::grpc::ErrorCode::OUT_OF_MEMORY},
+    };
+
+    if (code_map.find(code) != code_map.end()) {
+        return code_map.at(code);
+    } else {
+        return ::milvus::grpc::ErrorCode::UNEXPECTED_ERROR;
+    }
+}
+}  // namespace
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+GrpcBaseTask::GrpcBaseTask(const std::string& task_group, bool async)
+    : task_group_(task_group), async_(async), done_(false) {
+}
+
+GrpcBaseTask::~GrpcBaseTask() {
+    WaitToFinish();
+}
+
+Status
+GrpcBaseTask::Execute() {
+    status_ = OnExecute();
+    Done();
+    return status_;
+}
+
+void
+GrpcBaseTask::Done() {
+    done_ = true;
+    finish_cond_.notify_all();
+}
+
+Status
+GrpcBaseTask::SetStatus(ErrorCode error_code, const std::string& error_msg) {
+    status_ = Status(error_code, error_msg);
+    SERVER_LOG_ERROR << error_msg;
+    return status_;
+}
+
+Status
+GrpcBaseTask::WaitToFinish() {
+    std::unique_lock<std::mutex> lock(finish_mtx_);
+    finish_cond_.wait(lock, [this] { return done_; });
+
+    return status_;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+GrpcRequestScheduler::GrpcRequestScheduler() : stopped_(false) {
+    Start();
+}
+
+GrpcRequestScheduler::~GrpcRequestScheduler() {
+    Stop();
+}
+
+void
+GrpcRequestScheduler::ExecTask(BaseTaskPtr& task_ptr, ::milvus::grpc::Status* grpc_status) {
+    if (task_ptr == nullptr) {
+        return;
+    }
+
+    GrpcRequestScheduler& scheduler = GrpcRequestScheduler::GetInstance();
+    scheduler.ExecuteTask(task_ptr);
+
+    if (!task_ptr->IsAsync()) {
+        task_ptr->WaitToFinish();
+        const Status& status = task_ptr->status();
+        if (!status.ok()) {
+            grpc_status->set_reason(status.message());
+            grpc_status->set_error_code(ErrorMap(status.code()));
+        }
+    }
+}
+
+void
+GrpcRequestScheduler::Start() {
+    if (!stopped_) {
+        return;
+    }
+
+    stopped_ = false;
+}
+
+void
+GrpcRequestScheduler::Stop() {
+    if (stopped_) {
+        return;
+    }
+
+    SERVER_LOG_INFO << "Scheduler gonna stop...";
+    {
+        std::lock_guard<std::mutex> lock(queue_mtx_);
+        for (auto iter : task_groups_) {
+            if (iter.second != nullptr) {
+                iter.second->Put(nullptr);
+            }
+        }
+    }
+
+    for (auto iter : execute_threads_) {
+        if (iter == nullptr)
+            continue;
+
+        iter->join();
+    }
+    stopped_ = true;
+    SERVER_LOG_INFO << "Scheduler stopped";
+}
+
+Status
+GrpcRequestScheduler::ExecuteTask(const BaseTaskPtr& task_ptr) {
+    if (task_ptr == nullptr) {
+        return Status::OK();
+    }
+
+    auto status = PutTaskToQueue(task_ptr);
+    if (!status.ok()) {
+        SERVER_LOG_ERROR << "Put task to queue failed with code: " << status.ToString();
+        return status;
+    }
+
+    if (task_ptr->IsAsync()) {
+        return Status::OK();  // async execution, caller need to call WaitToFinish at somewhere
+    }
+
+    return task_ptr->WaitToFinish();  // sync execution
+}
+
+void
+GrpcRequestScheduler::TakeTaskToExecute(TaskQueuePtr task_queue) {
+    if (task_queue == nullptr) {
+        return;
+    }
+
+    while (true) {
+        BaseTaskPtr task = task_queue->Take();
+        if (task == nullptr) {
+            SERVER_LOG_ERROR << "Take null from task queue, stop thread";
+            break;  // stop the thread
+        }
+
+        try {
+            auto status = task->Execute();
+            if (!status.ok()) {
+                SERVER_LOG_ERROR << "Task failed with code: " << status.ToString();
+            }
+        } catch (std::exception& ex) {
+            SERVER_LOG_ERROR << "Task failed to execute: " << ex.what();
+        }
+    }
+}
+
+Status
+GrpcRequestScheduler::PutTaskToQueue(const BaseTaskPtr& task_ptr) {
+    std::lock_guard<std::mutex> lock(queue_mtx_);
+
+    std::string group_name = task_ptr->TaskGroup();
+    if (task_groups_.count(group_name) > 0) {
+        task_groups_[group_name]->Put(task_ptr);
+    } else {
+        TaskQueuePtr queue = std::make_shared<TaskQueue>();
+        queue->Put(task_ptr);
+        task_groups_.insert(std::make_pair(group_name, queue));
+
+        // start a thread
+        ThreadPtr thread = std::make_shared<std::thread>(&GrpcRequestScheduler::TakeTaskToExecute, this, queue);
+        execute_threads_.push_back(thread);
+        SERVER_LOG_INFO << "Create new thread for task group: " << group_name;
+    }
+
+    return Status::OK();
+}
+
+}  // namespace grpc
+}  // namespace server
+}  // namespace milvus
diff --git a/core/src/server/grpc_impl/GrpcRequestScheduler.h b/core/src/server/grpc_impl/GrpcRequestScheduler.h
new file mode 100644
index 0000000000..802d247fb5
--- /dev/null
+++ b/core/src/server/grpc_impl/GrpcRequestScheduler.h
@@ -0,0 +1,131 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "grpc/gen-status/status.grpc.pb.h"
+#include "grpc/gen-status/status.pb.h"
+#include "utils/BlockingQueue.h"
+#include "utils/Status.h"
+
+#include <map>
+#include <memory>
+#include <string>
+#include <thread>
+#include <vector>
+
+namespace milvus {
+namespace server {
+namespace grpc {
+
+class GrpcBaseTask {
+ protected:
+    explicit GrpcBaseTask(const std::string& task_group, bool async = false);
+
+    virtual ~GrpcBaseTask();
+
+ public:
+    Status
+    Execute();
+
+    void
+    Done();
+
+    Status
+    WaitToFinish();
+
+    std::string
+    TaskGroup() const {
+        return task_group_;
+    }
+
+    const Status&
+    status() const {
+        return status_;
+    }
+
+    bool
+    IsAsync() const {
+        return async_;
+    }
+
+ protected:
+    virtual Status
+    OnExecute() = 0;
+
+    Status
+    SetStatus(ErrorCode error_code, const std::string& error_msg);
+
+ protected:
+    mutable std::mutex finish_mtx_;
+    std::condition_variable finish_cond_;
+
+    std::string task_group_;
+    bool async_;
+    bool done_;
+    Status status_;
+};
+
+using BaseTaskPtr = std::shared_ptr<GrpcBaseTask>;
+using TaskQueue = BlockingQueue<BaseTaskPtr>;
+using TaskQueuePtr = std::shared_ptr<TaskQueue>;
+using ThreadPtr = std::shared_ptr<std::thread>;
+
+class GrpcRequestScheduler {
+ public:
+    static GrpcRequestScheduler&
+    GetInstance() {
+        static GrpcRequestScheduler scheduler;
+        return scheduler;
+    }
+
+    void
+    Start();
+
+    void
+    Stop();
+
+    Status
+    ExecuteTask(const BaseTaskPtr& task_ptr);
+
+    static void
+    ExecTask(BaseTaskPtr& task_ptr, ::milvus::grpc::Status* grpc_status);
+
+ protected:
+    GrpcRequestScheduler();
+
+    virtual ~GrpcRequestScheduler();
+
+    void
+    TakeTaskToExecute(TaskQueuePtr task_queue);
+
+    Status
+    PutTaskToQueue(const BaseTaskPtr& task_ptr);
+
+ private:
+    mutable std::mutex queue_mtx_;
+
+    std::map<std::string, TaskQueuePtr> task_groups_;
+
+    std::vector<ThreadPtr> execute_threads_;
+
+    bool stopped_;
+};
+
+}  // namespace grpc
+}  // namespace server
+}  // namespace milvus
diff --git a/core/src/server/grpc_impl/GrpcRequestTask.cpp b/core/src/server/grpc_impl/GrpcRequestTask.cpp
new file mode 100644
index 0000000000..86ff23b3d0
--- /dev/null
+++ b/core/src/server/grpc_impl/GrpcRequestTask.cpp
@@ -0,0 +1,951 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "server/grpc_impl/GrpcRequestTask.h"
+
+#include <string.h>
+#include <map>
+#include <string>
+#include <vector>
+//#include <gperftools/profiler.h>
+
+#include "../../../version.h"
+#include "GrpcServer.h"
+#include "db/Utils.h"
+#include "scheduler/SchedInst.h"
+#include "server/DBWrapper.h"
+#include "server/Server.h"
+#include "utils/CommonUtil.h"
+#include "utils/Log.h"
+#include "utils/TimeRecorder.h"
+#include "utils/ValidationUtil.h"
+
+namespace milvus {
+namespace server {
+namespace grpc {
+
+static const char* DQL_TASK_GROUP = "dql";
+static const char* DDL_DML_TASK_GROUP = "ddl_dml";
+static const char* INFO_TASK_GROUP = "info";
+
+constexpr int64_t DAY_SECONDS = 24 * 60 * 60;
+
+using DB_META = milvus::engine::meta::Meta;
+using DB_DATE = milvus::engine::meta::DateT;
+
+namespace {
+engine::EngineType
+EngineType(int type) {
+    static std::map<int, engine::EngineType> map_type = {
+        {0, engine::EngineType::INVALID},
+        {1, engine::EngineType::FAISS_IDMAP},
+        {2, engine::EngineType::FAISS_IVFFLAT},
+        {3, engine::EngineType::FAISS_IVFSQ8},
+    };
+
+    if (map_type.find(type) == map_type.end()) {
+        return engine::EngineType::INVALID;
+    }
+
+    return map_type[type];
+}
+
+int
+IndexType(engine::EngineType type) {
+    static std::map<engine::EngineType, int> map_type = {
+        {engine::EngineType::INVALID, 0},
+        {engine::EngineType::FAISS_IDMAP, 1},
+        {engine::EngineType::FAISS_IVFFLAT, 2},
+        {engine::EngineType::FAISS_IVFSQ8, 3},
+    };
+
+    if (map_type.find(type) == map_type.end()) {
+        return 0;
+    }
+
+    return map_type[type];
+}
+
+Status
+ConvertTimeRangeToDBDates(const std::vector<::milvus::grpc::Range>& range_array, std::vector<DB_DATE>& dates) {
+    dates.clear();
+    for (auto& range : range_array) {
+        time_t tt_start, tt_end;
+        tm tm_start, tm_end;
+        if (!CommonUtil::TimeStrToTime(range.start_value(), tt_start, tm_start)) {
+            return Status(SERVER_INVALID_TIME_RANGE, "Invalid time range: " + range.start_value());
+        }
+
+        if (!CommonUtil::TimeStrToTime(range.end_value(), tt_end, tm_end)) {
+            return Status(SERVER_INVALID_TIME_RANGE, "Invalid time range: " + range.start_value());
+        }
+
+        int64_t days = (tt_end - tt_start) / DAY_SECONDS;
+        if (days <= 0) {
+            return Status(SERVER_INVALID_TIME_RANGE,
+                          "Invalid time range: The start-date should be smaller than end-date!");
+        }
+
+        // range: [start_day, end_day)
+        for (int64_t i = 0; i < days; i++) {
+            time_t tt_day = tt_start + DAY_SECONDS * i;
+            tm tm_day;
+            CommonUtil::ConvertTime(tt_day, tm_day);
+
+            int64_t date = tm_day.tm_year * 10000 + tm_day.tm_mon * 100 + tm_day.tm_mday;  // according to db logic
+            dates.push_back(date);
+        }
+    }
+
+    return Status::OK();
+}
+
+std::string
+TableNotExistMsg(const std::string& table_name) {
+    return "Table " + table_name +
+           " not exist. Use milvus.has_table to verify whether the table exists. You also can check if the table name "
+           "exists.";
+}
+
+}  // namespace
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+CreateTableTask::CreateTableTask(const ::milvus::grpc::TableSchema* schema)
+    : GrpcBaseTask(DDL_DML_TASK_GROUP), schema_(schema) {
+}
+
+BaseTaskPtr
+CreateTableTask::Create(const ::milvus::grpc::TableSchema* schema) {
+    if (schema == nullptr) {
+        SERVER_LOG_ERROR << "grpc input is null!";
+        return nullptr;
+    }
+    return std::shared_ptr<GrpcBaseTask>(new CreateTableTask(schema));
+}
+
+Status
+CreateTableTask::OnExecute() {
+    TimeRecorder rc("CreateTableTask");
+
+    try {
+        // step 1: check arguments
+        auto status = ValidationUtil::ValidateTableName(schema_->table_name());
+        if (!status.ok()) {
+            return status;
+        }
+
+        status = ValidationUtil::ValidateTableDimension(schema_->dimension());
+        if (!status.ok()) {
+            return status;
+        }
+
+        status = ValidationUtil::ValidateTableIndexFileSize(schema_->index_file_size());
+        if (!status.ok()) {
+            return status;
+        }
+
+        status = ValidationUtil::ValidateTableIndexMetricType(schema_->metric_type());
+        if (!status.ok()) {
+            return status;
+        }
+
+        // step 2: construct table schema
+        engine::meta::TableSchema table_info;
+        table_info.table_id_ = schema_->table_name();
+        table_info.dimension_ = static_cast<uint16_t>(schema_->dimension());
+        table_info.index_file_size_ = schema_->index_file_size();
+        table_info.metric_type_ = schema_->metric_type();
+
+        // step 3: create table
+        status = DBWrapper::DB()->CreateTable(table_info);
+        if (!status.ok()) {
+            // table could exist
+            if (status.code() == DB_ALREADY_EXIST) {
+                return Status(SERVER_INVALID_TABLE_NAME, status.message());
+            }
+            return status;
+        }
+    } catch (std::exception& ex) {
+        return Status(SERVER_UNEXPECTED_ERROR, ex.what());
+    }
+
+    rc.ElapseFromBegin("totally cost");
+
+    return Status::OK();
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+DescribeTableTask::DescribeTableTask(const std::string& table_name, ::milvus::grpc::TableSchema* schema)
+    : GrpcBaseTask(INFO_TASK_GROUP), table_name_(table_name), schema_(schema) {
+}
+
+BaseTaskPtr
+DescribeTableTask::Create(const std::string& table_name, ::milvus::grpc::TableSchema* schema) {
+    return std::shared_ptr<GrpcBaseTask>(new DescribeTableTask(table_name, schema));
+}
+
+Status
+DescribeTableTask::OnExecute() {
+    TimeRecorder rc("DescribeTableTask");
+
+    try {
+        // step 1: check arguments
+        auto status = ValidationUtil::ValidateTableName(table_name_);
+        if (!status.ok()) {
+            return status;
+        }
+
+        // step 2: get table info
+        engine::meta::TableSchema table_info;
+        table_info.table_id_ = table_name_;
+        status = DBWrapper::DB()->DescribeTable(table_info);
+        if (!status.ok()) {
+            return status;
+        }
+
+        schema_->set_table_name(table_info.table_id_);
+        schema_->set_dimension(table_info.dimension_);
+        schema_->set_index_file_size(table_info.index_file_size_);
+        schema_->set_metric_type(table_info.metric_type_);
+    } catch (std::exception& ex) {
+        return Status(SERVER_UNEXPECTED_ERROR, ex.what());
+    }
+
+    rc.ElapseFromBegin("totally cost");
+
+    return Status::OK();
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+CreateIndexTask::CreateIndexTask(const ::milvus::grpc::IndexParam* index_param)
+    : GrpcBaseTask(DDL_DML_TASK_GROUP), index_param_(index_param) {
+}
+
+BaseTaskPtr
+CreateIndexTask::Create(const ::milvus::grpc::IndexParam* index_param) {
+    if (index_param == nullptr) {
+        SERVER_LOG_ERROR << "grpc input is null!";
+        return nullptr;
+    }
+    return std::shared_ptr<GrpcBaseTask>(new CreateIndexTask(index_param));
+}
+
+Status
+CreateIndexTask::OnExecute() {
+    try {
+        TimeRecorder rc("CreateIndexTask");
+
+        // step 1: check arguments
+        std::string table_name_ = index_param_->table_name();
+        auto status = ValidationUtil::ValidateTableName(table_name_);
+        if (!status.ok()) {
+            return status;
+        }
+
+        bool has_table = false;
+        status = DBWrapper::DB()->HasTable(table_name_, has_table);
+        if (!status.ok()) {
+            return status;
+        }
+
+        if (!has_table) {
+            return Status(SERVER_TABLE_NOT_EXIST, TableNotExistMsg(table_name_));
+        }
+
+        auto& grpc_index = index_param_->index();
+        status = ValidationUtil::ValidateTableIndexType(grpc_index.index_type());
+        if (!status.ok()) {
+            return status;
+        }
+
+        status = ValidationUtil::ValidateTableIndexNlist(grpc_index.nlist());
+        if (!status.ok()) {
+            return status;
+        }
+
+        // step 2: check table existence
+        engine::TableIndex index;
+        index.engine_type_ = grpc_index.index_type();
+        index.nlist_ = grpc_index.nlist();
+        status = DBWrapper::DB()->CreateIndex(table_name_, index);
+        if (!status.ok()) {
+            return status;
+        }
+
+        rc.ElapseFromBegin("totally cost");
+    } catch (std::exception& ex) {
+        return Status(SERVER_UNEXPECTED_ERROR, ex.what());
+    }
+
+    return Status::OK();
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+HasTableTask::HasTableTask(const std::string& table_name, bool& has_table)
+    : GrpcBaseTask(INFO_TASK_GROUP), table_name_(table_name), has_table_(has_table) {
+}
+
+BaseTaskPtr
+HasTableTask::Create(const std::string& table_name, bool& has_table) {
+    return std::shared_ptr<GrpcBaseTask>(new HasTableTask(table_name, has_table));
+}
+
+Status
+HasTableTask::OnExecute() {
+    try {
+        TimeRecorder rc("HasTableTask");
+
+        // step 1: check arguments
+        auto status = ValidationUtil::ValidateTableName(table_name_);
+        if (!status.ok()) {
+            return status;
+        }
+
+        // step 2: check table existence
+        status = DBWrapper::DB()->HasTable(table_name_, has_table_);
+        if (!status.ok()) {
+            return status;
+        }
+
+        rc.ElapseFromBegin("totally cost");
+    } catch (std::exception& ex) {
+        return Status(SERVER_UNEXPECTED_ERROR, ex.what());
+    }
+
+    return Status::OK();
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+DropTableTask::DropTableTask(const std::string& table_name)
+    : GrpcBaseTask(DDL_DML_TASK_GROUP), table_name_(table_name) {
+}
+
+BaseTaskPtr
+DropTableTask::Create(const std::string& table_name) {
+    return std::shared_ptr<GrpcBaseTask>(new DropTableTask(table_name));
+}
+
+Status
+DropTableTask::OnExecute() {
+    try {
+        TimeRecorder rc("DropTableTask");
+
+        // step 1: check arguments
+        auto status = ValidationUtil::ValidateTableName(table_name_);
+        if (!status.ok()) {
+            return status;
+        }
+
+        // step 2: check table existence
+        engine::meta::TableSchema table_info;
+        table_info.table_id_ = table_name_;
+        status = DBWrapper::DB()->DescribeTable(table_info);
+        if (!status.ok()) {
+            if (status.code() == DB_NOT_FOUND) {
+                return Status(SERVER_TABLE_NOT_EXIST, TableNotExistMsg(table_name_));
+            } else {
+                return status;
+            }
+        }
+
+        rc.ElapseFromBegin("check validation");
+
+        // step 3: Drop table
+        std::vector<DB_DATE> dates;
+        status = DBWrapper::DB()->DeleteTable(table_name_, dates);
+        if (!status.ok()) {
+            return status;
+        }
+
+        rc.ElapseFromBegin("total cost");
+    } catch (std::exception& ex) {
+        return Status(SERVER_UNEXPECTED_ERROR, ex.what());
+    }
+
+    return Status::OK();
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ShowTablesTask::ShowTablesTask(::milvus::grpc::TableNameList* table_name_list)
+    : GrpcBaseTask(INFO_TASK_GROUP), table_name_list_(table_name_list) {
+}
+
+BaseTaskPtr
+ShowTablesTask::Create(::milvus::grpc::TableNameList* table_name_list) {
+    return std::shared_ptr<GrpcBaseTask>(new ShowTablesTask(table_name_list));
+}
+
+Status
+ShowTablesTask::OnExecute() {
+    std::vector<engine::meta::TableSchema> schema_array;
+    auto statuts = DBWrapper::DB()->AllTables(schema_array);
+    if (!statuts.ok()) {
+        return statuts;
+    }
+
+    for (auto& schema : schema_array) {
+        table_name_list_->add_table_names(schema.table_id_);
+    }
+    return Status::OK();
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+InsertTask::InsertTask(const ::milvus::grpc::InsertParam* insert_param, ::milvus::grpc::VectorIds* record_ids)
+    : GrpcBaseTask(DDL_DML_TASK_GROUP), insert_param_(insert_param), record_ids_(record_ids) {
+}
+
+BaseTaskPtr
+InsertTask::Create(const ::milvus::grpc::InsertParam* insert_param, ::milvus::grpc::VectorIds* record_ids) {
+    if (insert_param == nullptr) {
+        SERVER_LOG_ERROR << "grpc input is null!";
+        return nullptr;
+    }
+    return std::shared_ptr<GrpcBaseTask>(new InsertTask(insert_param, record_ids));
+}
+
+Status
+InsertTask::OnExecute() {
+    try {
+        TimeRecorder rc("InsertVectorTask");
+
+        // step 1: check arguments
+        auto status = ValidationUtil::ValidateTableName(insert_param_->table_name());
+        if (!status.ok()) {
+            return status;
+        }
+        if (insert_param_->row_record_array().empty()) {
+            return Status(SERVER_INVALID_ROWRECORD_ARRAY,
+                          "The vector array is empty. Make sure you have entered vector records.");
+        }
+
+        if (!insert_param_->row_id_array().empty()) {
+            if (insert_param_->row_id_array().size() != insert_param_->row_record_array_size()) {
+                return Status(SERVER_ILLEGAL_VECTOR_ID,
+                              "The size of vector ID array must be equal to the size of the vector.");
+            }
+        }
+
+        // step 2: check table existence
+        engine::meta::TableSchema table_info;
+        table_info.table_id_ = insert_param_->table_name();
+        status = DBWrapper::DB()->DescribeTable(table_info);
+        if (!status.ok()) {
+            if (status.code() == DB_NOT_FOUND) {
+                return Status(SERVER_TABLE_NOT_EXIST, TableNotExistMsg(insert_param_->table_name()));
+            } else {
+                return status;
+            }
+        }
+
+        // step 3: check table flag
+        // all user provide id, or all internal id
+        bool user_provide_ids = !insert_param_->row_id_array().empty();
+        // user already provided id before, all insert action require user id
+        if ((table_info.flag_ & engine::meta::FLAG_MASK_HAS_USERID) != 0 && !user_provide_ids) {
+            return Status(SERVER_ILLEGAL_VECTOR_ID,
+                          "Table vector IDs are user-defined. Please provide IDs for all vectors of this table.");
+        }
+
+        // user didn't provided id before, no need to provide user id
+        if ((table_info.flag_ & engine::meta::FLAG_MASK_NO_USERID) != 0 && user_provide_ids) {
+            return Status(
+                SERVER_ILLEGAL_VECTOR_ID,
+                "Table vector IDs are auto-generated. All vectors of this table must use auto-generated IDs.");
+        }
+
+        rc.RecordSection("check validation");
+
+#ifdef MILVUS_ENABLE_PROFILING
+        std::string fname =
+            "/tmp/insert_" + std::to_string(this->insert_param_->row_record_array_size()) + ".profiling";
+        ProfilerStart(fname.c_str());
+#endif
+
+        // step 4: prepare float data
+        std::vector<float> vec_f(insert_param_->row_record_array_size() * table_info.dimension_, 0);
+
+        // TODO(yk): change to one dimension array or use multiple-thread to copy the data
+        for (size_t i = 0; i < insert_param_->row_record_array_size(); i++) {
+            if (insert_param_->row_record_array(i).vector_data().empty()) {
+                return Status(SERVER_INVALID_ROWRECORD_ARRAY,
+                              "The vector dimension must be equal to the table dimension.");
+            }
+            uint64_t vec_dim = insert_param_->row_record_array(i).vector_data().size();
+            if (vec_dim != table_info.dimension_) {
+                ErrorCode error_code = SERVER_INVALID_VECTOR_DIMENSION;
+                std::string error_msg = "The vector dimension must be equal to the table dimension.";
+                return Status(error_code, error_msg);
+            }
+            memcpy(&vec_f[i * table_info.dimension_], insert_param_->row_record_array(i).vector_data().data(),
+                   table_info.dimension_ * sizeof(float));
+        }
+
+        rc.ElapseFromBegin("prepare vectors data");
+
+        // step 5: insert vectors
+        auto vec_count = static_cast<uint64_t>(insert_param_->row_record_array_size());
+        std::vector<int64_t> vec_ids(insert_param_->row_id_array_size(), 0);
+        if (!insert_param_->row_id_array().empty()) {
+            const int64_t* src_data = insert_param_->row_id_array().data();
+            int64_t* target_data = vec_ids.data();
+            memcpy(target_data, src_data, static_cast<size_t>(sizeof(int64_t) * insert_param_->row_id_array_size()));
+        }
+
+        status = DBWrapper::DB()->InsertVectors(insert_param_->table_name(), vec_count, vec_f.data(), vec_ids);
+        rc.ElapseFromBegin("add vectors to engine");
+        if (!status.ok()) {
+            return status;
+        }
+        for (int64_t id : vec_ids) {
+            record_ids_->add_vector_id_array(id);
+        }
+
+        auto ids_size = record_ids_->vector_id_array_size();
+        if (ids_size != vec_count) {
+            std::string msg =
+                "Add " + std::to_string(vec_count) + " vectors but only return " + std::to_string(ids_size) + " id";
+            return Status(SERVER_ILLEGAL_VECTOR_ID, msg);
+        }
+
+        // step 6: update table flag
+        user_provide_ids ? table_info.flag_ |= engine::meta::FLAG_MASK_HAS_USERID
+                         : table_info.flag_ |= engine::meta::FLAG_MASK_NO_USERID;
+        status = DBWrapper::DB()->UpdateTableFlag(insert_param_->table_name(), table_info.flag_);
+
+#ifdef MILVUS_ENABLE_PROFILING
+        ProfilerStop();
+#endif
+
+        rc.RecordSection("add vectors to engine");
+        rc.ElapseFromBegin("total cost");
+    } catch (std::exception& ex) {
+        return Status(SERVER_UNEXPECTED_ERROR, ex.what());
+    }
+
+    return Status::OK();
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+SearchTask::SearchTask(const ::milvus::grpc::SearchParam* search_vector_infos,
+                       const std::vector<std::string>& file_id_array, ::milvus::grpc::TopKQueryResultList* response)
+    : GrpcBaseTask(DQL_TASK_GROUP),
+      search_param_(search_vector_infos),
+      file_id_array_(file_id_array),
+      topk_result_list(response) {
+}
+
+BaseTaskPtr
+SearchTask::Create(const ::milvus::grpc::SearchParam* search_vector_infos,
+                   const std::vector<std::string>& file_id_array, ::milvus::grpc::TopKQueryResultList* response) {
+    if (search_vector_infos == nullptr) {
+        SERVER_LOG_ERROR << "grpc input is null!";
+        return nullptr;
+    }
+    return std::shared_ptr<GrpcBaseTask>(new SearchTask(search_vector_infos, file_id_array, response));
+}
+
+Status
+SearchTask::OnExecute() {
+    try {
+        int64_t top_k = search_param_->topk();
+        int64_t nprobe = search_param_->nprobe();
+
+        std::string hdr = "SearchTask(k=" + std::to_string(top_k) + ", nprob=" + std::to_string(nprobe) + ")";
+        TimeRecorder rc(hdr);
+
+        // step 1: check table name
+        std::string table_name_ = search_param_->table_name();
+        auto status = ValidationUtil::ValidateTableName(table_name_);
+        if (!status.ok()) {
+            return status;
+        }
+
+        // step 2: check table existence
+        engine::meta::TableSchema table_info;
+        table_info.table_id_ = table_name_;
+        status = DBWrapper::DB()->DescribeTable(table_info);
+        if (!status.ok()) {
+            if (status.code() == DB_NOT_FOUND) {
+                return Status(SERVER_TABLE_NOT_EXIST, TableNotExistMsg(table_name_));
+            } else {
+                return status;
+            }
+        }
+
+        // step 3: check search parameter
+        status = ValidationUtil::ValidateSearchTopk(top_k, table_info);
+        if (!status.ok()) {
+            return status;
+        }
+
+        status = ValidationUtil::ValidateSearchNprobe(nprobe, table_info);
+        if (!status.ok()) {
+            return status;
+        }
+
+        if (search_param_->query_record_array().empty()) {
+            return Status(SERVER_INVALID_ROWRECORD_ARRAY,
+                          "The vector array is empty. Make sure you have entered vector records.");
+        }
+
+        // step 4: check date range, and convert to db dates
+        std::vector<DB_DATE> dates;
+        std::vector<::milvus::grpc::Range> range_array;
+        for (size_t i = 0; i < search_param_->query_range_array_size(); i++) {
+            range_array.emplace_back(search_param_->query_range_array(i));
+        }
+
+        status = ConvertTimeRangeToDBDates(range_array, dates);
+        if (!status.ok()) {
+            return status;
+        }
+
+        rc.RecordSection("check validation");
+
+        // step 5: prepare float data
+        auto record_array_size = search_param_->query_record_array_size();
+        std::vector<float> vec_f(record_array_size * table_info.dimension_, 0);
+        for (size_t i = 0; i < record_array_size; i++) {
+            if (search_param_->query_record_array(i).vector_data().empty()) {
+                return Status(SERVER_INVALID_ROWRECORD_ARRAY,
+                              "The vector dimension must be equal to the table dimension.");
+            }
+            uint64_t query_vec_dim = search_param_->query_record_array(i).vector_data().size();
+            if (query_vec_dim != table_info.dimension_) {
+                ErrorCode error_code = SERVER_INVALID_VECTOR_DIMENSION;
+                std::string error_msg = "The vector dimension must be equal to the table dimension.";
+                return Status(error_code, error_msg);
+            }
+
+            memcpy(&vec_f[i * table_info.dimension_], search_param_->query_record_array(i).vector_data().data(),
+                   table_info.dimension_ * sizeof(float));
+        }
+        rc.RecordSection("prepare vector data");
+
+        // step 6: search vectors
+        engine::QueryResults results;
+        auto record_count = (uint64_t)search_param_->query_record_array().size();
+
+#ifdef MILVUS_ENABLE_PROFILING
+        std::string fname =
+            "/tmp/search_nq_" + std::to_string(this->search_param_->query_record_array_size()) + ".profiling";
+        ProfilerStart(fname.c_str());
+#endif
+
+        if (file_id_array_.empty()) {
+            status =
+                DBWrapper::DB()->Query(table_name_, (size_t)top_k, record_count, nprobe, vec_f.data(), dates, results);
+        } else {
+            status = DBWrapper::DB()->Query(table_name_, file_id_array_, (size_t)top_k, record_count, nprobe,
+                                            vec_f.data(), dates, results);
+        }
+
+#ifdef MILVUS_ENABLE_PROFILING
+        ProfilerStop();
+#endif
+
+        rc.RecordSection("search vectors from engine");
+        if (!status.ok()) {
+            return status;
+        }
+
+        if (results.empty()) {
+            return Status::OK();  // empty table
+        }
+
+        if (results.size() != record_count) {
+            std::string msg = "Search " + std::to_string(record_count) + " vectors but only return " +
+                              std::to_string(results.size()) + " results";
+            return Status(SERVER_ILLEGAL_SEARCH_RESULT, msg);
+        }
+
+        // step 7: construct result array
+        for (auto& result : results) {
+            ::milvus::grpc::TopKQueryResult* topk_query_result = topk_result_list->add_topk_query_result();
+            for (auto& pair : result) {
+                ::milvus::grpc::QueryResult* grpc_result = topk_query_result->add_query_result_arrays();
+                grpc_result->set_id(pair.first);
+                grpc_result->set_distance(pair.second);
+            }
+        }
+
+        // step 8: print time cost percent
+        rc.RecordSection("construct result and send");
+        rc.ElapseFromBegin("totally cost");
+    } catch (std::exception& ex) {
+        return Status(SERVER_UNEXPECTED_ERROR, ex.what());
+    }
+
+    return Status::OK();
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+CountTableTask::CountTableTask(const std::string& table_name, int64_t& row_count)
+    : GrpcBaseTask(INFO_TASK_GROUP), table_name_(table_name), row_count_(row_count) {
+}
+
+BaseTaskPtr
+CountTableTask::Create(const std::string& table_name, int64_t& row_count) {
+    return std::shared_ptr<GrpcBaseTask>(new CountTableTask(table_name, row_count));
+}
+
+Status
+CountTableTask::OnExecute() {
+    try {
+        TimeRecorder rc("GetTableRowCountTask");
+
+        // step 1: check arguments
+        auto status = ValidationUtil::ValidateTableName(table_name_);
+        if (!status.ok()) {
+            return status;
+        }
+
+        // step 2: get row count
+        uint64_t row_count = 0;
+        status = DBWrapper::DB()->GetTableRowCount(table_name_, row_count);
+        if (!status.ok()) {
+            if (status.code(), DB_NOT_FOUND) {
+                return Status(SERVER_TABLE_NOT_EXIST, TableNotExistMsg(table_name_));
+            } else {
+                return status;
+            }
+        }
+
+        row_count_ = static_cast<int64_t>(row_count);
+
+        rc.ElapseFromBegin("total cost");
+    } catch (std::exception& ex) {
+        return Status(SERVER_UNEXPECTED_ERROR, ex.what());
+    }
+
+    return Status::OK();
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+CmdTask::CmdTask(const std::string& cmd, std::string& result)
+    : GrpcBaseTask(INFO_TASK_GROUP), cmd_(cmd), result_(result) {
+}
+
+BaseTaskPtr
+CmdTask::Create(const std::string& cmd, std::string& result) {
+    return std::shared_ptr<GrpcBaseTask>(new CmdTask(cmd, result));
+}
+
+Status
+CmdTask::OnExecute() {
+    if (cmd_ == "version") {
+        result_ = MILVUS_VERSION;
+    } else if (cmd_ == "tasktable") {
+        result_ = scheduler::ResMgrInst::GetInstance()->DumpTaskTables();
+    } else {
+        result_ = "OK";
+    }
+
+    return Status::OK();
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+DeleteByRangeTask::DeleteByRangeTask(const ::milvus::grpc::DeleteByRangeParam* delete_by_range_param)
+    : GrpcBaseTask(DDL_DML_TASK_GROUP), delete_by_range_param_(delete_by_range_param) {
+}
+
+BaseTaskPtr
+DeleteByRangeTask::Create(const ::milvus::grpc::DeleteByRangeParam* delete_by_range_param) {
+    if (delete_by_range_param == nullptr) {
+        SERVER_LOG_ERROR << "grpc input is null!";
+        return nullptr;
+    }
+
+    return std::shared_ptr<GrpcBaseTask>(new DeleteByRangeTask(delete_by_range_param));
+}
+
+Status
+DeleteByRangeTask::OnExecute() {
+    try {
+        TimeRecorder rc("DeleteByRangeTask");
+
+        // step 1: check arguments
+        std::string table_name = delete_by_range_param_->table_name();
+        auto status = ValidationUtil::ValidateTableName(table_name);
+        if (!status.ok()) {
+            return status;
+        }
+
+        // step 2: check table existence
+        engine::meta::TableSchema table_info;
+        table_info.table_id_ = table_name;
+        status = DBWrapper::DB()->DescribeTable(table_info);
+        if (!status.ok()) {
+            if (status.code(), DB_NOT_FOUND) {
+                return Status(SERVER_TABLE_NOT_EXIST, TableNotExistMsg(table_name));
+            } else {
+                return status;
+            }
+        }
+
+        rc.ElapseFromBegin("check validation");
+
+        // step 3: check date range, and convert to db dates
+        std::vector<DB_DATE> dates;
+        ErrorCode error_code = SERVER_SUCCESS;
+        std::string error_msg;
+
+        std::vector<::milvus::grpc::Range> range_array;
+        range_array.emplace_back(delete_by_range_param_->range());
+        status = ConvertTimeRangeToDBDates(range_array, dates);
+        if (!status.ok()) {
+            return status;
+        }
+
+#ifdef MILVUS_ENABLE_PROFILING
+        std::string fname = "/tmp/search_nq_" + this->delete_by_range_param_->table_name() + ".profiling";
+        ProfilerStart(fname.c_str());
+#endif
+        status = DBWrapper::DB()->DeleteTable(table_name, dates);
+        if (!status.ok()) {
+            return status;
+        }
+    } catch (std::exception& ex) {
+        return Status(SERVER_UNEXPECTED_ERROR, ex.what());
+    }
+
+    return Status::OK();
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+PreloadTableTask::PreloadTableTask(const std::string& table_name)
+    : GrpcBaseTask(DQL_TASK_GROUP), table_name_(table_name) {
+}
+
+BaseTaskPtr
+PreloadTableTask::Create(const std::string& table_name) {
+    return std::shared_ptr<GrpcBaseTask>(new PreloadTableTask(table_name));
+}
+
+Status
+PreloadTableTask::OnExecute() {
+    try {
+        TimeRecorder rc("PreloadTableTask");
+
+        // step 1: check arguments
+        auto status = ValidationUtil::ValidateTableName(table_name_);
+        if (!status.ok()) {
+            return status;
+        }
+
+        // step 2: check table existence
+        status = DBWrapper::DB()->PreloadTable(table_name_);
+        if (!status.ok()) {
+            return status;
+        }
+
+        rc.ElapseFromBegin("totally cost");
+    } catch (std::exception& ex) {
+        return Status(SERVER_UNEXPECTED_ERROR, ex.what());
+    }
+
+    return Status::OK();
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+DescribeIndexTask::DescribeIndexTask(const std::string& table_name, ::milvus::grpc::IndexParam* index_param)
+    : GrpcBaseTask(INFO_TASK_GROUP), table_name_(table_name), index_param_(index_param) {
+}
+
+BaseTaskPtr
+DescribeIndexTask::Create(const std::string& table_name, ::milvus::grpc::IndexParam* index_param) {
+    return std::shared_ptr<GrpcBaseTask>(new DescribeIndexTask(table_name, index_param));
+}
+
+Status
+DescribeIndexTask::OnExecute() {
+    try {
+        TimeRecorder rc("DescribeIndexTask");
+
+        // step 1: check arguments
+        auto status = ValidationUtil::ValidateTableName(table_name_);
+        if (!status.ok()) {
+            return status;
+        }
+
+        // step 2: check table existence
+        engine::TableIndex index;
+        status = DBWrapper::DB()->DescribeIndex(table_name_, index);
+        if (!status.ok()) {
+            return status;
+        }
+
+        index_param_->set_table_name(table_name_);
+        index_param_->mutable_index()->set_index_type(index.engine_type_);
+        index_param_->mutable_index()->set_nlist(index.nlist_);
+
+        rc.ElapseFromBegin("totally cost");
+    } catch (std::exception& ex) {
+        return Status(SERVER_UNEXPECTED_ERROR, ex.what());
+    }
+
+    return Status::OK();
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+DropIndexTask::DropIndexTask(const std::string& table_name)
+    : GrpcBaseTask(DDL_DML_TASK_GROUP), table_name_(table_name) {
+}
+
+BaseTaskPtr
+DropIndexTask::Create(const std::string& table_name) {
+    return std::shared_ptr<GrpcBaseTask>(new DropIndexTask(table_name));
+}
+
+Status
+DropIndexTask::OnExecute() {
+    try {
+        TimeRecorder rc("DropIndexTask");
+
+        // step 1: check arguments
+        auto status = ValidationUtil::ValidateTableName(table_name_);
+        if (!status.ok()) {
+            return status;
+        }
+
+        bool has_table = false;
+        status = DBWrapper::DB()->HasTable(table_name_, has_table);
+        if (!status.ok()) {
+            return status;
+        }
+
+        if (!has_table) {
+            return Status(SERVER_TABLE_NOT_EXIST, TableNotExistMsg(table_name_));
+        }
+
+        // step 2: check table existence
+        status = DBWrapper::DB()->DropIndex(table_name_);
+        if (!status.ok()) {
+            return status;
+        }
+
+        rc.ElapseFromBegin("totally cost");
+    } catch (std::exception& ex) {
+        return Status(SERVER_UNEXPECTED_ERROR, ex.what());
+    }
+
+    return Status::OK();
+}
+
+}  // namespace grpc
+}  // namespace server
+}  // namespace milvus
diff --git a/core/src/server/grpc_impl/GrpcRequestTask.h b/core/src/server/grpc_impl/GrpcRequestTask.h
new file mode 100644
index 0000000000..ad2828ebf3
--- /dev/null
+++ b/core/src/server/grpc_impl/GrpcRequestTask.h
@@ -0,0 +1,272 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "db/Types.h"
+#include "server/grpc_impl/GrpcRequestScheduler.h"
+#include "utils/Status.h"
+
+#include "grpc/gen-milvus/milvus.grpc.pb.h"
+#include "grpc/gen-status/status.pb.h"
+
+#include <condition_variable>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace milvus {
+namespace server {
+namespace grpc {
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class CreateTableTask : public GrpcBaseTask {
+ public:
+    static BaseTaskPtr
+    Create(const ::milvus::grpc::TableSchema* schema);
+
+ protected:
+    explicit CreateTableTask(const ::milvus::grpc::TableSchema* schema);
+
+    Status
+    OnExecute() override;
+
+ private:
+    const ::milvus::grpc::TableSchema* schema_;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class HasTableTask : public GrpcBaseTask {
+ public:
+    static BaseTaskPtr
+    Create(const std::string& table_name, bool& has_table);
+
+ protected:
+    HasTableTask(const std::string& table_name, bool& has_table);
+
+    Status
+    OnExecute() override;
+
+ private:
+    std::string table_name_;
+    bool& has_table_;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class DescribeTableTask : public GrpcBaseTask {
+ public:
+    static BaseTaskPtr
+    Create(const std::string& table_name, ::milvus::grpc::TableSchema* schema);
+
+ protected:
+    DescribeTableTask(const std::string& table_name, ::milvus::grpc::TableSchema* schema);
+
+    Status
+    OnExecute() override;
+
+ private:
+    std::string table_name_;
+    ::milvus::grpc::TableSchema* schema_;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class DropTableTask : public GrpcBaseTask {
+ public:
+    static BaseTaskPtr
+    Create(const std::string& table_name);
+
+ protected:
+    explicit DropTableTask(const std::string& table_name);
+
+    Status
+    OnExecute() override;
+
+ private:
+    std::string table_name_;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class CreateIndexTask : public GrpcBaseTask {
+ public:
+    static BaseTaskPtr
+    Create(const ::milvus::grpc::IndexParam* index_param);
+
+ protected:
+    explicit CreateIndexTask(const ::milvus::grpc::IndexParam* index_param);
+
+    Status
+    OnExecute() override;
+
+ private:
+    const ::milvus::grpc::IndexParam* index_param_;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class ShowTablesTask : public GrpcBaseTask {
+ public:
+    static BaseTaskPtr
+    Create(::milvus::grpc::TableNameList* table_name_list);
+
+ protected:
+    explicit ShowTablesTask(::milvus::grpc::TableNameList* table_name_list);
+
+    Status
+    OnExecute() override;
+
+ private:
+    ::milvus::grpc::TableNameList* table_name_list_;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class InsertTask : public GrpcBaseTask {
+ public:
+    static BaseTaskPtr
+    Create(const ::milvus::grpc::InsertParam* insert_param, ::milvus::grpc::VectorIds* record_ids);
+
+ protected:
+    InsertTask(const ::milvus::grpc::InsertParam* insert_param, ::milvus::grpc::VectorIds* record_ids);
+
+    Status
+    OnExecute() override;
+
+ private:
+    const ::milvus::grpc::InsertParam* insert_param_;
+    ::milvus::grpc::VectorIds* record_ids_;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class SearchTask : public GrpcBaseTask {
+ public:
+    static BaseTaskPtr
+    Create(const ::milvus::grpc::SearchParam* search_param, const std::vector<std::string>& file_id_array,
+           ::milvus::grpc::TopKQueryResultList* response);
+
+ protected:
+    SearchTask(const ::milvus::grpc::SearchParam* search_param, const std::vector<std::string>& file_id_array,
+               ::milvus::grpc::TopKQueryResultList* response);
+
+    Status
+    OnExecute() override;
+
+ private:
+    const ::milvus::grpc::SearchParam* search_param_;
+    std::vector<std::string> file_id_array_;
+    ::milvus::grpc::TopKQueryResultList* topk_result_list;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class CountTableTask : public GrpcBaseTask {
+ public:
+    static BaseTaskPtr
+    Create(const std::string& table_name, int64_t& row_count);
+
+ protected:
+    CountTableTask(const std::string& table_name, int64_t& row_count);
+
+    Status
+    OnExecute() override;
+
+ private:
+    std::string table_name_;
+    int64_t& row_count_;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class CmdTask : public GrpcBaseTask {
+ public:
+    static BaseTaskPtr
+    Create(const std::string& cmd, std::string& result);
+
+ protected:
+    CmdTask(const std::string& cmd, std::string& result);
+
+    Status
+    OnExecute() override;
+
+ private:
+    std::string cmd_;
+    std::string& result_;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class DeleteByRangeTask : public GrpcBaseTask {
+ public:
+    static BaseTaskPtr
+    Create(const ::milvus::grpc::DeleteByRangeParam* delete_by_range_param);
+
+ protected:
+    explicit DeleteByRangeTask(const ::milvus::grpc::DeleteByRangeParam* delete_by_range_param);
+
+    Status
+    OnExecute() override;
+
+ private:
+    const ::milvus::grpc::DeleteByRangeParam* delete_by_range_param_;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class PreloadTableTask : public GrpcBaseTask {
+ public:
+    static BaseTaskPtr
+    Create(const std::string& table_name);
+
+ protected:
+    explicit PreloadTableTask(const std::string& table_name);
+
+    Status
+    OnExecute() override;
+
+ private:
+    std::string table_name_;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class DescribeIndexTask : public GrpcBaseTask {
+ public:
+    static BaseTaskPtr
+    Create(const std::string& table_name, ::milvus::grpc::IndexParam* index_param);
+
+ protected:
+    DescribeIndexTask(const std::string& table_name, ::milvus::grpc::IndexParam* index_param);
+
+    Status
+    OnExecute() override;
+
+ private:
+    std::string table_name_;
+    ::milvus::grpc::IndexParam* index_param_;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class DropIndexTask : public GrpcBaseTask {
+ public:
+    static BaseTaskPtr
+    Create(const std::string& table_name);
+
+ protected:
+    explicit DropIndexTask(const std::string& table_name);
+
+    Status
+    OnExecute() override;
+
+ private:
+    std::string table_name_;
+};
+
+}  // namespace grpc
+}  // namespace server
+}  // namespace milvus
diff --git a/core/src/server/grpc_impl/GrpcServer.cpp b/core/src/server/grpc_impl/GrpcServer.cpp
new file mode 100644
index 0000000000..5e0c5f3169
--- /dev/null
+++ b/core/src/server/grpc_impl/GrpcServer.cpp
@@ -0,0 +1,120 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "server/grpc_impl/GrpcServer.h"
+#include "GrpcRequestHandler.h"
+#include "grpc/gen-milvus/milvus.grpc.pb.h"
+#include "server/Config.h"
+#include "server/DBWrapper.h"
+#include "utils/Log.h"
+
+#include <chrono>
+#include <iostream>
+#include <memory>
+#include <random>
+#include <string>
+#include <thread>
+#include <vector>
+
+#include <grpc/grpc.h>
+#include <grpcpp/channel.h>
+#include <grpcpp/client_context.h>
+#include <grpcpp/create_channel.h>
+#include <grpcpp/security/credentials.h>
+
+namespace milvus {
+namespace server {
+namespace grpc {
+
+constexpr int64_t MESSAGE_SIZE = -1;
+
+// this class is to check port occupation during server start
+class NoReusePortOption : public ::grpc::ServerBuilderOption {
+ public:
+    void
+    UpdateArguments(::grpc::ChannelArguments* args) override {
+        args->SetInt(GRPC_ARG_ALLOW_REUSEPORT, 0);
+    }
+
+    void
+    UpdatePlugins(std::vector<std::unique_ptr<::grpc::ServerBuilderPlugin>>* plugins) override {
+    }
+};
+
+void
+GrpcServer::Start() {
+    thread_ptr_ = std::make_shared<std::thread>(&GrpcServer::StartService, this);
+}
+
+void
+GrpcServer::Stop() {
+    StopService();
+    if (thread_ptr_) {
+        thread_ptr_->join();
+        thread_ptr_ = nullptr;
+    }
+}
+
+Status
+GrpcServer::StartService() {
+    Config& config = Config::GetInstance();
+    std::string address, port;
+    Status s;
+
+    s = config.GetServerConfigAddress(address);
+    if (!s.ok()) {
+        return s;
+    }
+    s = config.GetServerConfigPort(port);
+    if (!s.ok()) {
+        return s;
+    }
+
+    std::string server_address(address + ":" + port);
+
+    ::grpc::ServerBuilder builder;
+    builder.SetOption(std::unique_ptr<::grpc::ServerBuilderOption>(new NoReusePortOption));
+    builder.SetMaxReceiveMessageSize(MESSAGE_SIZE);  // default 4 * 1024 * 1024
+    builder.SetMaxSendMessageSize(MESSAGE_SIZE);
+
+    builder.SetCompressionAlgorithmSupportStatus(GRPC_COMPRESS_STREAM_GZIP, true);
+    builder.SetDefaultCompressionAlgorithm(GRPC_COMPRESS_STREAM_GZIP);
+    builder.SetDefaultCompressionLevel(GRPC_COMPRESS_LEVEL_HIGH);
+
+    GrpcRequestHandler service;
+
+    builder.AddListeningPort(server_address, ::grpc::InsecureServerCredentials());
+    builder.RegisterService(&service);
+
+    server_ptr_ = builder.BuildAndStart();
+    server_ptr_->Wait();
+
+    return Status::OK();
+}
+
+Status
+GrpcServer::StopService() {
+    if (server_ptr_ != nullptr) {
+        server_ptr_->Shutdown();
+    }
+
+    return Status::OK();
+}
+
+}  // namespace grpc
+}  // namespace server
+}  // namespace milvus
diff --git a/core/src/server/grpc_impl/GrpcServer.h b/core/src/server/grpc_impl/GrpcServer.h
new file mode 100644
index 0000000000..aeaf9f0dca
--- /dev/null
+++ b/core/src/server/grpc_impl/GrpcServer.h
@@ -0,0 +1,61 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "utils/Status.h"
+
+#include <grpcpp/grpcpp.h>
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <thread>
+
+namespace milvus {
+namespace server {
+namespace grpc {
+
+class GrpcServer {
+ public:
+    static GrpcServer&
+    GetInstance() {
+        static GrpcServer grpc_server;
+        return grpc_server;
+    }
+
+    void
+    Start();
+    void
+    Stop();
+
+ private:
+    GrpcServer() = default;
+    ~GrpcServer() = default;
+
+    Status
+    StartService();
+    Status
+    StopService();
+
+ private:
+    std::unique_ptr<::grpc::Server> server_ptr_;
+    std::shared_ptr<std::thread> thread_ptr_;
+};
+
+}  // namespace grpc
+}  // namespace server
+}  // namespace milvus
diff --git a/core/src/utils/BlockingQueue.h b/core/src/utils/BlockingQueue.h
new file mode 100644
index 0000000000..dc7968fcb6
--- /dev/null
+++ b/core/src/utils/BlockingQueue.h
@@ -0,0 +1,72 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <assert.h>
+#include <condition_variable>
+#include <iostream>
+#include <queue>
+#include <vector>
+
+namespace milvus {
+namespace server {
+
+template <typename T>
+class BlockingQueue {
+ public:
+    BlockingQueue() : mtx(), full_(), empty_() {
+    }
+
+    BlockingQueue(const BlockingQueue& rhs) = delete;
+
+    BlockingQueue&
+    operator=(const BlockingQueue& rhs) = delete;
+
+    void
+    Put(const T& task);
+
+    T
+    Take();
+
+    T
+    Front();
+
+    T
+    Back();
+
+    size_t
+    Size();
+
+    bool
+    Empty();
+
+    void
+    SetCapacity(const size_t capacity);
+
+ private:
+    mutable std::mutex mtx;
+    std::condition_variable full_;
+    std::condition_variable empty_;
+    std::queue<T> queue_;
+    size_t capacity_ = 32;
+};
+
+}  // namespace server
+}  // namespace milvus
+
+#include "./BlockingQueue.inl"
diff --git a/core/src/utils/BlockingQueue.inl b/core/src/utils/BlockingQueue.inl
new file mode 100644
index 0000000000..c4318c5fc6
--- /dev/null
+++ b/core/src/utils/BlockingQueue.inl
@@ -0,0 +1,98 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+
+#pragma once
+
+
+namespace milvus {
+namespace server {
+
+template<typename T>
+void
+BlockingQueue<T>::Put(const T &task) {
+    std::unique_lock<std::mutex> lock(mtx);
+    full_.wait(lock, [this] {
+        return (queue_.size() < capacity_);
+    });
+
+    queue_.push(task);
+    empty_.notify_all();
+}
+
+template<typename T>
+T
+BlockingQueue<T>::Take() {
+    std::unique_lock<std::mutex> lock(mtx);
+    empty_.wait(lock, [this] {
+        return !queue_.empty();
+    });
+
+    T front(queue_.front());
+    queue_.pop();
+    full_.notify_all();
+    return front;
+}
+
+template<typename T>
+size_t
+BlockingQueue<T>::Size() {
+    std::lock_guard<std::mutex> lock(mtx);
+    return queue_.size();
+}
+
+template<typename T>
+T
+BlockingQueue<T>::Front() {
+    std::unique_lock<std::mutex> lock(mtx);
+    empty_.wait(lock, [this] {
+        return !queue_.empty();
+    });
+
+    T front(queue_.front());
+    return front;
+}
+
+template<typename T>
+T
+BlockingQueue<T>::Back() {
+    std::unique_lock<std::mutex> lock(mtx);
+    empty_.wait(lock, [this] {
+        return !queue_.empty();
+    });
+
+    T back(queue_.back());
+    return back;
+}
+
+template<typename T>
+bool
+BlockingQueue<T>::Empty() {
+    std::unique_lock<std::mutex> lock(mtx);
+    return queue_.empty();
+}
+
+template<typename T>
+void
+BlockingQueue<T>::SetCapacity(const size_t capacity) {
+    capacity_ = (capacity > 0 ? capacity : capacity_);
+}
+
+} // namespace server
+} // namespace milvus
+
+
diff --git a/core/src/utils/CommonUtil.cpp b/core/src/utils/CommonUtil.cpp
new file mode 100644
index 0000000000..fbf3112aeb
--- /dev/null
+++ b/core/src/utils/CommonUtil.cpp
@@ -0,0 +1,226 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "utils/CommonUtil.h"
+#include "utils/Log.h"
+
+#include <dirent.h>
+#include <pwd.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/sysinfo.h>
+#include <time.h>
+#include <unistd.h>
+#include <iostream>
+#include <thread>
+
+#include "boost/filesystem.hpp"
+
+#if defined(__x86_64__)
+#define THREAD_MULTIPLY_CPU 1
+#elif defined(__powerpc64__)
+#define THREAD_MULTIPLY_CPU 4
+#else
+#define THREAD_MULTIPLY_CPU 1
+#endif
+
+namespace milvus {
+namespace server {
+
+namespace fs = boost::filesystem;
+
+bool
+CommonUtil::GetSystemMemInfo(uint64_t& total_mem, uint64_t& free_mem) {
+    struct sysinfo info;
+    int ret = sysinfo(&info);
+    total_mem = info.totalram;
+    free_mem = info.freeram;
+
+    return ret == 0;  // succeed 0, failed -1
+}
+
+bool
+CommonUtil::GetSystemAvailableThreads(uint32_t& thread_count) {
+    // threadCnt = std::thread::hardware_concurrency();
+    thread_count = sysconf(_SC_NPROCESSORS_CONF);
+    thread_count *= THREAD_MULTIPLY_CPU;
+    if (thread_count == 0) {
+        thread_count = 8;
+    }
+
+    return true;
+}
+
+bool
+CommonUtil::IsDirectoryExist(const std::string& path) {
+    DIR* dp = nullptr;
+    if ((dp = opendir(path.c_str())) == nullptr) {
+        return false;
+    }
+
+    closedir(dp);
+    return true;
+}
+
+Status
+CommonUtil::CreateDirectory(const std::string& path) {
+    if (path.empty()) {
+        return Status::OK();
+    }
+
+    struct stat directory_stat;
+    int status = stat(path.c_str(), &directory_stat);
+    if (status == 0) {
+        return Status::OK();  // already exist
+    }
+
+    fs::path fs_path(path);
+    fs::path parent_path = fs_path.parent_path();
+    Status err_status = CreateDirectory(parent_path.string());
+    if (!err_status.ok()) {
+        return err_status;
+    }
+
+    status = stat(path.c_str(), &directory_stat);
+    if (status == 0) {
+        return Status::OK();  // already exist
+    }
+
+    int makeOK = mkdir(path.c_str(), S_IRWXU | S_IRGRP | S_IROTH);
+    if (makeOK != 0) {
+        return Status(SERVER_UNEXPECTED_ERROR, "failed to create directory: " + path);
+    }
+
+    return Status::OK();
+}
+
+namespace {
+void
+RemoveDirectory(const std::string& path) {
+    DIR* dir = nullptr;
+    struct dirent* dmsg;
+    const int32_t buf_size = 256;
+    char file_name[buf_size];
+
+    std::string folder_name = path + "/%s";
+    if ((dir = opendir(path.c_str())) != nullptr) {
+        while ((dmsg = readdir(dir)) != nullptr) {
+            if (strcmp(dmsg->d_name, ".") != 0 && strcmp(dmsg->d_name, "..") != 0) {
+                snprintf(file_name, buf_size, folder_name.c_str(), dmsg->d_name);
+                std::string tmp = file_name;
+                if (tmp.find(".") == std::string::npos) {
+                    RemoveDirectory(file_name);
+                }
+                remove(file_name);
+            }
+        }
+    }
+
+    if (dir != nullptr) {
+        closedir(dir);
+    }
+    remove(path.c_str());
+}
+}  // namespace
+
+Status
+CommonUtil::DeleteDirectory(const std::string& path) {
+    if (path.empty()) {
+        return Status::OK();
+    }
+
+    struct stat directory_stat;
+    int statOK = stat(path.c_str(), &directory_stat);
+    if (statOK != 0) {
+        return Status::OK();
+    }
+
+    RemoveDirectory(path);
+    return Status::OK();
+}
+
+bool
+CommonUtil::IsFileExist(const std::string& path) {
+    return (access(path.c_str(), F_OK) == 0);
+}
+
+uint64_t
+CommonUtil::GetFileSize(const std::string& path) {
+    struct stat file_info;
+    if (stat(path.c_str(), &file_info) < 0) {
+        return 0;
+    }
+
+    return static_cast<uint64_t>(file_info.st_size);
+}
+
+std::string
+CommonUtil::GetFileName(std::string filename) {
+    int pos = filename.find_last_of('/');
+    return filename.substr(pos + 1);
+}
+
+std::string
+CommonUtil::GetExePath() {
+    const size_t buf_len = 1024;
+    char buf[buf_len];
+    size_t cnt = readlink("/proc/self/exe", buf, buf_len);
+    if (cnt < 0 || cnt >= buf_len) {
+        return "";
+    }
+
+    buf[cnt] = '\0';
+
+    std::string exe_path = buf;
+    if (exe_path.rfind('/') != exe_path.length()) {
+        std::string sub_str = exe_path.substr(0, exe_path.rfind('/'));
+        return sub_str + "/";
+    }
+    return exe_path;
+}
+
+bool
+CommonUtil::TimeStrToTime(const std::string& time_str, time_t& time_integer, tm& time_struct,
+                          const std::string& format) {
+    time_integer = 0;
+    memset(&time_struct, 0, sizeof(tm));
+
+    int ret = sscanf(time_str.c_str(), format.c_str(), &(time_struct.tm_year), &(time_struct.tm_mon),
+                     &(time_struct.tm_mday), &(time_struct.tm_hour), &(time_struct.tm_min), &(time_struct.tm_sec));
+    if (ret <= 0) {
+        return false;
+    }
+
+    time_struct.tm_year -= 1900;
+    time_struct.tm_mon--;
+    time_integer = mktime(&time_struct);
+
+    return true;
+}
+
+void
+CommonUtil::ConvertTime(time_t time_integer, tm& time_struct) {
+    localtime_r(&time_integer, &time_struct);
+}
+
+void
+CommonUtil::ConvertTime(tm time_struct, time_t& time_integer) {
+    time_integer = mktime(&time_struct);
+}
+
+}  // namespace server
+}  // namespace milvus
diff --git a/core/src/utils/CommonUtil.h b/core/src/utils/CommonUtil.h
new file mode 100644
index 0000000000..939bdd6d31
--- /dev/null
+++ b/core/src/utils/CommonUtil.h
@@ -0,0 +1,62 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "utils/Status.h"
+
+#include <time.h>
+#include <string>
+
+namespace milvus {
+namespace server {
+
+class CommonUtil {
+ public:
+    static bool
+    GetSystemMemInfo(uint64_t& total_mem, uint64_t& free_mem);
+    static bool
+    GetSystemAvailableThreads(uint32_t& thread_count);
+
+    static bool
+    IsFileExist(const std::string& path);
+    static uint64_t
+    GetFileSize(const std::string& path);
+    static bool
+    IsDirectoryExist(const std::string& path);
+    static Status
+    CreateDirectory(const std::string& path);
+    static Status
+    DeleteDirectory(const std::string& path);
+
+    static std::string
+    GetFileName(std::string filename);
+    static std::string
+    GetExePath();
+
+    static bool
+    TimeStrToTime(const std::string& time_str, time_t& time_integer, tm& time_struct,
+                  const std::string& format = "%d-%d-%d %d:%d:%d");
+
+    static void
+    ConvertTime(time_t time_integer, tm& time_struct);
+    static void
+    ConvertTime(tm time_struct, time_t& time_integer);
+};
+
+}  // namespace server
+}  // namespace milvus
diff --git a/core/src/utils/Error.h b/core/src/utils/Error.h
new file mode 100644
index 0000000000..dfc400ca9a
--- /dev/null
+++ b/core/src/utils/Error.h
@@ -0,0 +1,123 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <cstdint>
+#include <exception>
+#include <string>
+
+namespace milvus {
+
+using ErrorCode = int32_t;
+
+constexpr ErrorCode SERVER_SUCCESS = 0;
+constexpr ErrorCode SERVER_ERROR_CODE_BASE = 30000;
+
+constexpr ErrorCode
+ToServerErrorCode(const ErrorCode error_code) {
+    return SERVER_ERROR_CODE_BASE + error_code;
+}
+
+constexpr ErrorCode DB_SUCCESS = 0;
+constexpr ErrorCode DB_ERROR_CODE_BASE = 40000;
+
+constexpr ErrorCode
+ToDbErrorCode(const ErrorCode error_code) {
+    return DB_ERROR_CODE_BASE + error_code;
+}
+
+constexpr ErrorCode KNOWHERE_SUCCESS = 0;
+constexpr ErrorCode KNOWHERE_ERROR_CODE_BASE = 50000;
+
+constexpr ErrorCode
+ToKnowhereErrorCode(const ErrorCode error_code) {
+    return KNOWHERE_ERROR_CODE_BASE + error_code;
+}
+
+// server error code
+constexpr ErrorCode SERVER_UNEXPECTED_ERROR = ToServerErrorCode(1);
+constexpr ErrorCode SERVER_UNSUPPORTED_ERROR = ToServerErrorCode(2);
+constexpr ErrorCode SERVER_NULL_POINTER = ToServerErrorCode(3);
+constexpr ErrorCode SERVER_INVALID_ARGUMENT = ToServerErrorCode(4);
+constexpr ErrorCode SERVER_FILE_NOT_FOUND = ToServerErrorCode(5);
+constexpr ErrorCode SERVER_NOT_IMPLEMENT = ToServerErrorCode(6);
+constexpr ErrorCode SERVER_CANNOT_CREATE_FOLDER = ToServerErrorCode(8);
+constexpr ErrorCode SERVER_CANNOT_CREATE_FILE = ToServerErrorCode(9);
+constexpr ErrorCode SERVER_CANNOT_DELETE_FOLDER = ToServerErrorCode(10);
+constexpr ErrorCode SERVER_CANNOT_DELETE_FILE = ToServerErrorCode(11);
+constexpr ErrorCode SERVER_BUILD_INDEX_ERROR = ToServerErrorCode(12);
+
+constexpr ErrorCode SERVER_TABLE_NOT_EXIST = ToServerErrorCode(100);
+constexpr ErrorCode SERVER_INVALID_TABLE_NAME = ToServerErrorCode(101);
+constexpr ErrorCode SERVER_INVALID_TABLE_DIMENSION = ToServerErrorCode(102);
+constexpr ErrorCode SERVER_INVALID_TIME_RANGE = ToServerErrorCode(103);
+constexpr ErrorCode SERVER_INVALID_VECTOR_DIMENSION = ToServerErrorCode(104);
+constexpr ErrorCode SERVER_INVALID_INDEX_TYPE = ToServerErrorCode(105);
+constexpr ErrorCode SERVER_INVALID_ROWRECORD = ToServerErrorCode(106);
+constexpr ErrorCode SERVER_INVALID_ROWRECORD_ARRAY = ToServerErrorCode(107);
+constexpr ErrorCode SERVER_INVALID_TOPK = ToServerErrorCode(108);
+constexpr ErrorCode SERVER_ILLEGAL_VECTOR_ID = ToServerErrorCode(109);
+constexpr ErrorCode SERVER_ILLEGAL_SEARCH_RESULT = ToServerErrorCode(110);
+constexpr ErrorCode SERVER_CACHE_FULL = ToServerErrorCode(111);
+constexpr ErrorCode SERVER_WRITE_ERROR = ToServerErrorCode(112);
+constexpr ErrorCode SERVER_INVALID_NPROBE = ToServerErrorCode(113);
+constexpr ErrorCode SERVER_INVALID_INDEX_NLIST = ToServerErrorCode(114);
+constexpr ErrorCode SERVER_INVALID_INDEX_METRIC_TYPE = ToServerErrorCode(115);
+constexpr ErrorCode SERVER_INVALID_INDEX_FILE_SIZE = ToServerErrorCode(116);
+constexpr ErrorCode SERVER_OUT_OF_MEMORY = ToServerErrorCode(117);
+
+// db error code
+constexpr ErrorCode DB_META_TRANSACTION_FAILED = ToDbErrorCode(1);
+constexpr ErrorCode DB_ERROR = ToDbErrorCode(2);
+constexpr ErrorCode DB_NOT_FOUND = ToDbErrorCode(3);
+constexpr ErrorCode DB_ALREADY_EXIST = ToDbErrorCode(4);
+constexpr ErrorCode DB_INVALID_PATH = ToDbErrorCode(5);
+constexpr ErrorCode DB_INCOMPATIB_META = ToDbErrorCode(6);
+constexpr ErrorCode DB_INVALID_META_URI = ToDbErrorCode(7);
+
+// knowhere error code
+constexpr ErrorCode KNOWHERE_ERROR = ToKnowhereErrorCode(1);
+constexpr ErrorCode KNOWHERE_INVALID_ARGUMENT = ToKnowhereErrorCode(2);
+constexpr ErrorCode KNOWHERE_UNEXPECTED_ERROR = ToKnowhereErrorCode(3);
+constexpr ErrorCode KNOWHERE_NO_SPACE = ToKnowhereErrorCode(4);
+
+namespace server {
+class ServerException : public std::exception {
+ public:
+    explicit ServerException(ErrorCode error_code, const std::string& message = std::string())
+        : error_code_(error_code), message_(message) {
+    }
+
+ public:
+    ErrorCode
+    error_code() const {
+        return error_code_;
+    }
+
+    virtual const char*
+    what() const noexcept {
+        return message_.c_str();
+    }
+
+ private:
+    ErrorCode error_code_;
+    std::string message_;
+};
+}  // namespace server
+
+}  // namespace milvus
diff --git a/core/src/utils/Exception.h b/core/src/utils/Exception.h
new file mode 100644
index 0000000000..a2d8473fa3
--- /dev/null
+++ b/core/src/utils/Exception.h
@@ -0,0 +1,63 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "utils/Error.h"
+
+#include <exception>
+#include <string>
+
+namespace milvus {
+
+class Exception : public std::exception {
+ public:
+    Exception(ErrorCode code, const std::string& message) : code_(code), message_(message) {
+    }
+
+    ErrorCode
+    code() const throw() {
+        return code_;
+    }
+
+    virtual const char*
+    what() const throw() {
+        if (message_.empty()) {
+            return "Default Exception.";
+        } else {
+            return message_.c_str();
+        }
+    }
+
+    virtual ~Exception() throw() {
+    }
+
+ protected:
+    ErrorCode code_;
+    std::string message_;
+};
+
+class InvalidArgumentException : public Exception {
+ public:
+    InvalidArgumentException() : Exception(SERVER_INVALID_ARGUMENT, "Invalid Argument") {
+    }
+
+    explicit InvalidArgumentException(const std::string& message) : Exception(SERVER_INVALID_ARGUMENT, message) {
+    }
+};
+
+}  // namespace milvus
diff --git a/core/src/utils/Json.h b/core/src/utils/Json.h
new file mode 100644
index 0000000000..e5e74a3b67
--- /dev/null
+++ b/core/src/utils/Json.h
@@ -0,0 +1,23 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+#pragma once
+
+#include "external/nlohmann/json.hpp"
+
+namespace milvus {
+using json = nlohmann::json;
+}
diff --git a/core/src/utils/Log.h b/core/src/utils/Log.h
new file mode 100644
index 0000000000..1dd116367a
--- /dev/null
+++ b/core/src/utils/Log.h
@@ -0,0 +1,54 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "utils/easylogging++.h"
+
+namespace milvus {
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+#define SERVER_DOMAIN_NAME "[SERVER] "
+
+#define SERVER_LOG_TRACE LOG(TRACE) << SERVER_DOMAIN_NAME
+#define SERVER_LOG_DEBUG LOG(DEBUG) << SERVER_DOMAIN_NAME
+#define SERVER_LOG_INFO LOG(INFO) << SERVER_DOMAIN_NAME
+#define SERVER_LOG_WARNING LOG(WARNING) << SERVER_DOMAIN_NAME
+#define SERVER_LOG_ERROR LOG(ERROR) << SERVER_DOMAIN_NAME
+#define SERVER_LOG_FATAL LOG(FATAL) << SERVER_DOMAIN_NAME
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+#define ENGINE_DOMAIN_NAME "[ENGINE] "
+
+#define ENGINE_LOG_TRACE LOG(TRACE) << ENGINE_DOMAIN_NAME
+#define ENGINE_LOG_DEBUG LOG(DEBUG) << ENGINE_DOMAIN_NAME
+#define ENGINE_LOG_INFO LOG(INFO) << ENGINE_DOMAIN_NAME
+#define ENGINE_LOG_WARNING LOG(WARNING) << ENGINE_DOMAIN_NAME
+#define ENGINE_LOG_ERROR LOG(ERROR) << ENGINE_DOMAIN_NAME
+#define ENGINE_LOG_FATAL LOG(FATAL) << ENGINE_DOMAIN_NAME
+
+/////////////////////////////////////////////////////////////////////////////////////////////////
+#define WRAPPER_DOMAIN_NAME "[WRAPPER] "
+
+#define WRAPPER_LOG_TRACE LOG(TRACE) << WRAPPER_DOMAIN_NAME
+#define WRAPPER_LOG_DEBUG LOG(DEBUG) << WRAPPER_DOMAIN_NAME
+#define WRAPPER_LOG_INFO LOG(INFO) << WRAPPER_DOMAIN_NAME
+#define WRAPPER_LOG_WARNING LOG(WARNING) << WRAPPER_DOMAIN_NAME
+#define WRAPPER_LOG_ERROR LOG(ERROR) << WRAPPER_DOMAIN_NAME
+#define WRAPPER_LOG_FATAL LOG(FATAL) << WRAPPER_DOMAIN_NAME
+
+}  // namespace milvus
diff --git a/core/src/utils/LogUtil.cpp b/core/src/utils/LogUtil.cpp
new file mode 100644
index 0000000000..4a962f466c
--- /dev/null
+++ b/core/src/utils/LogUtil.cpp
@@ -0,0 +1,96 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "utils/LogUtil.h"
+
+#include <ctype.h>
+#include <libgen.h>
+#include <string>
+
+namespace milvus {
+namespace server {
+
+namespace {
+static int global_idx = 0;
+static int debug_idx = 0;
+static int warning_idx = 0;
+static int trace_idx = 0;
+static int error_idx = 0;
+static int fatal_idx = 0;
+}  // namespace
+
+// TODO(yzb) : change the easylogging library to get the log level from parameter rather than filename
+void
+RolloutHandler(const char* filename, std::size_t size, el::Level level) {
+    char* dirc = strdup(filename);
+    char* basec = strdup(filename);
+    char* dir = dirname(dirc);
+    char* base = basename(basec);
+
+    std::string s(base);
+    std::stringstream ss;
+    std::string list[] = {"\\", " ", "\'", "\"", "*", "\?", "{", "}", ";", "<",
+                          ">",  "|", "^",  "&",  "$", "#",  "!", "`", "~"};
+    std::string::size_type position;
+    for (auto substr : list) {
+        position = 0;
+        while ((position = s.find_first_of(substr, position)) != std::string::npos) {
+            s.insert(position, "\\");
+            position += 2;
+        }
+    }
+    int ret;
+    std::string m(std::string(dir) + "/" + s);
+    s = m;
+    if (level == el::Level::Global) {
+        s.append("." + std::to_string(++global_idx));
+        ret = rename(m.c_str(), s.c_str());
+    } else if (level == el::Level::Debug) {
+        s.append("." + std::to_string(++debug_idx));
+        ret = rename(m.c_str(), s.c_str());
+    } else if (level == el::Level::Warning) {
+        s.append("." + std::to_string(++warning_idx));
+        ret = rename(m.c_str(), s.c_str());
+    } else if (level == el::Level::Trace) {
+        s.append("." + std::to_string(++trace_idx));
+        ret = rename(m.c_str(), s.c_str());
+    } else if (level == el::Level::Error) {
+        s.append("." + std::to_string(++error_idx));
+        ret = rename(m.c_str(), s.c_str());
+    } else if (level == el::Level::Fatal) {
+        s.append("." + std::to_string(++fatal_idx));
+        ret = rename(m.c_str(), s.c_str());
+    } else {
+        s.append("." + std::to_string(++global_idx));
+        ret = rename(m.c_str(), s.c_str());
+    }
+}
+
+Status
+InitLog(const std::string& log_config_file) {
+    el::Configurations conf(log_config_file);
+    el::Loggers::reconfigureAllLoggers(conf);
+
+    el::Loggers::addFlag(el::LoggingFlag::StrictLogFileSizeCheck);
+    el::Helpers::installPreRollOutCallback(RolloutHandler);
+    el::Loggers::addFlag(el::LoggingFlag::DisableApplicationAbortOnFatalLog);
+
+    return Status::OK();
+}
+
+}  // namespace server
+}  // namespace milvus
diff --git a/core/src/utils/LogUtil.h b/core/src/utils/LogUtil.h
new file mode 100644
index 0000000000..9926939442
--- /dev/null
+++ b/core/src/utils/LogUtil.h
@@ -0,0 +1,43 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "utils/Status.h"
+#include "utils/easylogging++.h"
+
+#include <sstream>
+#include <string>
+
+namespace milvus {
+namespace server {
+
+Status
+InitLog(const std::string& log_config_file);
+
+void
+RolloutHandler(const char* filename, std::size_t size, el::Level level);
+
+#define SHOW_LOCATION
+#ifdef SHOW_LOCATION
+#define LOCATION_INFO "[" << sql::server::GetFileName(__FILE__) << ":" << __LINE__ << "] "
+#else
+#define LOCATION_INFO ""
+#endif
+
+}  // namespace server
+}  // namespace milvus
diff --git a/core/src/utils/SignalUtil.cpp b/core/src/utils/SignalUtil.cpp
new file mode 100644
index 0000000000..5531aaed27
--- /dev/null
+++ b/core/src/utils/SignalUtil.cpp
@@ -0,0 +1,69 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "utils/SignalUtil.h"
+#include "src/server/Server.h"
+#include "utils/Log.h"
+
+#include <execinfo.h>
+#include <signal.h>
+#include <string>
+
+namespace milvus {
+namespace server {
+
+void
+SignalUtil::HandleSignal(int signum) {
+    switch (signum) {
+        case SIGINT:
+        case SIGUSR2: {
+            SERVER_LOG_INFO << "Server received signal: " << signum;
+
+            server::Server& server = server::Server::GetInstance();
+            server.Stop();
+
+            exit(0);
+        }
+        default: {
+            SERVER_LOG_INFO << "Server received critical signal: " << signum;
+            SignalUtil::PrintStacktrace();
+
+            server::Server& server = server::Server::GetInstance();
+            server.Stop();
+
+            exit(1);
+        }
+    }
+}
+
+void
+SignalUtil::PrintStacktrace() {
+    SERVER_LOG_INFO << "Call stack:";
+
+    const int size = 32;
+    void* array[size];
+    int stack_num = backtrace(array, size);
+    char** stacktrace = backtrace_symbols(array, stack_num);
+    for (int i = 0; i < stack_num; ++i) {
+        std::string info = stacktrace[i];
+        SERVER_LOG_INFO << info;
+    }
+    free(stacktrace);
+}
+
+}  // namespace server
+}  // namespace milvus
diff --git a/core/src/utils/SignalUtil.h b/core/src/utils/SignalUtil.h
new file mode 100644
index 0000000000..2ecfdecfba
--- /dev/null
+++ b/core/src/utils/SignalUtil.h
@@ -0,0 +1,32 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+namespace milvus {
+namespace server {
+
+class SignalUtil {
+ public:
+    static void
+    HandleSignal(int signum);
+    static void
+    PrintStacktrace();
+};
+
+}  // namespace server
+}  // namespace milvus
diff --git a/core/src/utils/Status.cpp b/core/src/utils/Status.cpp
new file mode 100644
index 0000000000..9ac0279810
--- /dev/null
+++ b/core/src/utils/Status.cpp
@@ -0,0 +1,139 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "utils/Status.h"
+
+#include <cstring>
+
+namespace milvus {
+
+constexpr int CODE_WIDTH = sizeof(StatusCode);
+
+Status::Status(StatusCode code, const std::string& msg) {
+    // 4 bytes store code
+    // 4 bytes store message length
+    // the left bytes store message string
+    const uint32_t length = (uint32_t)msg.size();
+    auto result = new char[length + sizeof(length) + CODE_WIDTH];
+    std::memcpy(result, &code, CODE_WIDTH);
+    std::memcpy(result + CODE_WIDTH, &length, sizeof(length));
+    memcpy(result + sizeof(length) + CODE_WIDTH, msg.data(), length);
+
+    state_ = result;
+}
+
+Status::Status() : state_(nullptr) {
+}
+
+Status::~Status() {
+    delete state_;
+}
+
+Status::Status(const Status& s) : state_(nullptr) {
+    CopyFrom(s);
+}
+
+Status&
+Status::operator=(const Status& s) {
+    CopyFrom(s);
+    return *this;
+}
+
+Status::Status(Status&& s) : state_(nullptr) {
+    MoveFrom(s);
+}
+
+Status&
+Status::operator=(Status&& s) {
+    MoveFrom(s);
+    return *this;
+}
+
+void
+Status::CopyFrom(const Status& s) {
+    delete state_;
+    state_ = nullptr;
+    if (s.state_ == nullptr) {
+        return;
+    }
+
+    uint32_t length = 0;
+    memcpy(&length, s.state_ + CODE_WIDTH, sizeof(length));
+    int buff_len = length + sizeof(length) + CODE_WIDTH;
+    state_ = new char[buff_len];
+    memcpy(state_, s.state_, buff_len);
+}
+
+void
+Status::MoveFrom(Status& s) {
+    delete state_;
+    state_ = s.state_;
+    s.state_ = nullptr;
+}
+
+std::string
+Status::message() const {
+    if (state_ == nullptr) {
+        return "OK";
+    }
+
+    std::string msg;
+    uint32_t length = 0;
+    memcpy(&length, state_ + CODE_WIDTH, sizeof(length));
+    if (length > 0) {
+        msg.append(state_ + sizeof(length) + CODE_WIDTH, length);
+    }
+
+    return msg;
+}
+
+std::string
+Status::ToString() const {
+    if (state_ == nullptr) {
+        return "OK";
+    }
+
+    std::string result;
+    switch (code()) {
+        case DB_SUCCESS:
+            result = "OK ";
+            break;
+        case DB_ERROR:
+            result = "Error: ";
+            break;
+        case DB_META_TRANSACTION_FAILED:
+            result = "Database error: ";
+            break;
+        case DB_NOT_FOUND:
+            result = "Not found: ";
+            break;
+        case DB_ALREADY_EXIST:
+            result = "Already exist: ";
+            break;
+        case DB_INVALID_PATH:
+            result = "Invalid path: ";
+            break;
+        default:
+            result = "Error code(" + std::to_string(code()) + "): ";
+            break;
+    }
+
+    result += message();
+    return result;
+}
+
+}  // namespace milvus
diff --git a/core/src/utils/Status.h b/core/src/utils/Status.h
new file mode 100644
index 0000000000..07a12261bb
--- /dev/null
+++ b/core/src/utils/Status.h
@@ -0,0 +1,76 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "utils/Error.h"
+
+#include <string>
+
+namespace milvus {
+
+using StatusCode = ErrorCode;
+
+class Status {
+ public:
+    Status(StatusCode code, const std::string& msg);
+    Status();
+    ~Status();
+
+    Status(const Status& s);
+
+    Status&
+    operator=(const Status& s);
+
+    Status(Status&& s);
+
+    Status&
+    operator=(Status&& s);
+
+    static Status
+    OK() {
+        return Status();
+    }
+
+    bool
+    ok() const {
+        return state_ == nullptr || code() == 0;
+    }
+
+    StatusCode
+    code() const {
+        return (state_ == nullptr) ? 0 : *(StatusCode*)(state_);
+    }
+
+    std::string
+    message() const;
+
+    std::string
+    ToString() const;
+
+ private:
+    inline void
+    CopyFrom(const Status& s);
+
+    inline void
+    MoveFrom(Status& s);
+
+ private:
+    char* state_ = nullptr;
+};  // Status
+
+}  // namespace milvus
diff --git a/core/src/utils/StringHelpFunctions.cpp b/core/src/utils/StringHelpFunctions.cpp
new file mode 100644
index 0000000000..230cc1a0ff
--- /dev/null
+++ b/core/src/utils/StringHelpFunctions.cpp
@@ -0,0 +1,126 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "utils/StringHelpFunctions.h"
+
+#include <string>
+
+namespace milvus {
+namespace server {
+
+void
+StringHelpFunctions::TrimStringBlank(std::string& string) {
+    if (!string.empty()) {
+        static std::string s_format(" \n\r\t");
+        string.erase(0, string.find_first_not_of(s_format));
+        string.erase(string.find_last_not_of(s_format) + 1);
+    }
+}
+
+void
+StringHelpFunctions::TrimStringQuote(std::string& string, const std::string& qoute) {
+    if (!string.empty()) {
+        string.erase(0, string.find_first_not_of(qoute));
+        string.erase(string.find_last_not_of(qoute) + 1);
+    }
+}
+
+Status
+StringHelpFunctions::SplitStringByDelimeter(const std::string& str, const std::string& delimeter,
+                                            std::vector<std::string>& result) {
+    if (str.empty()) {
+        return Status::OK();
+    }
+
+    size_t last = 0;
+    size_t index = str.find_first_of(delimeter, last);
+    while (index != std::string::npos) {
+        result.emplace_back(str.substr(last, index - last));
+        last = index + 1;
+        index = str.find_first_of(delimeter, last);
+    }
+    if (index - last > 0) {
+        std::string temp = str.substr(last);
+        result.emplace_back(temp);
+    }
+
+    return Status::OK();
+}
+
+Status
+StringHelpFunctions::SplitStringByQuote(const std::string& str, const std::string& delimeter, const std::string& quote,
+                                        std::vector<std::string>& result) {
+    if (quote.empty()) {
+        return SplitStringByDelimeter(str, delimeter, result);
+    }
+
+    size_t last = 0;
+    size_t index = str.find_first_of(quote, last);
+    if (index == std::string::npos) {
+        return SplitStringByDelimeter(str, delimeter, result);
+    }
+
+    std::string process_str = str;
+    while (index != std::string::npos) {
+        std::string prefix = process_str.substr(last, index - last);
+        std::string append_prefix;
+        if (!prefix.empty()) {
+            std::vector<std::string> prefix_split;
+            SplitStringByDelimeter(prefix, delimeter, prefix_split);
+            for (size_t i = 0; i < prefix_split.size() - 1; i++) {
+                result.push_back(prefix_split[i]);
+            }
+            append_prefix = prefix_split[prefix_split.size() - 1];
+        }
+        last = index + 1;
+        std::string postfix = process_str.substr(last);
+        index = postfix.find_first_of(quote, 0);
+        if (index == std::string::npos) {
+            return Status(SERVER_UNEXPECTED_ERROR, "");
+        }
+        std::string quoted_text = postfix.substr(0, index);
+        append_prefix += quoted_text;
+
+        last = index + 1;
+        index = postfix.find_first_of(delimeter, last);
+        if (index != std::string::npos) {
+            if (index > last) {
+                append_prefix += postfix.substr(last, index - last);
+            }
+        } else {
+            append_prefix += postfix.substr(last);
+        }
+        result.emplace_back(append_prefix);
+
+        if (last == postfix.length()) {
+            return Status::OK();
+        }
+
+        process_str = postfix.substr(index + 1);
+        last = 0;
+        index = process_str.find_first_of(quote, last);
+    }
+
+    if (!process_str.empty()) {
+        return SplitStringByDelimeter(process_str, delimeter, result);
+    }
+
+    return Status::OK();
+}
+
+}  // namespace server
+}  // namespace milvus
diff --git a/core/src/utils/StringHelpFunctions.h b/core/src/utils/StringHelpFunctions.h
new file mode 100644
index 0000000000..cb355332f1
--- /dev/null
+++ b/core/src/utils/StringHelpFunctions.h
@@ -0,0 +1,62 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "utils/Status.h"
+
+#include <string>
+#include <vector>
+
+namespace milvus {
+namespace server {
+
+class StringHelpFunctions {
+ private:
+    StringHelpFunctions() = default;
+
+ public:
+    static void
+    TrimStringBlank(std::string& string);
+
+    static void
+    TrimStringQuote(std::string& string, const std::string& qoute);
+
+    // split string by delimeter ','
+    // a,b,c            a | b | c
+    // a,b,             a | b |
+    // ,b,c               | b | c
+    // ,b,                | b |
+    // ,,                 |   |
+    // a                    a
+    static Status
+    SplitStringByDelimeter(const std::string& str, const std::string& delimeter, std::vector<std::string>& result);
+
+    // assume the table has two columns, quote='\"', delimeter=','
+    //  a,b             a | b
+    //  "aa,gg,yy",b    aa,gg,yy | b
+    //  aa"dd,rr"kk,pp  aadd,rrkk | pp
+    //  "aa,bb"         aa,bb
+    //  55,1122\"aa,bb\",yyy,\"kkk\"    55 | 1122aa,bb | yyy | kkk
+    //  "55,1122"aa,bb",yyy,"kkk"   illegal
+    static Status
+    SplitStringByQuote(const std::string& str, const std::string& delimeter, const std::string& quote,
+                       std::vector<std::string>& result);
+};
+
+}  // namespace server
+}  // namespace milvus
diff --git a/core/src/utils/ThreadPool.h b/core/src/utils/ThreadPool.h
new file mode 100644
index 0000000000..d605d70018
--- /dev/null
+++ b/core/src/utils/ThreadPool.h
@@ -0,0 +1,119 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <condition_variable>
+#include <functional>
+#include <future>
+#include <memory>
+#include <mutex>
+#include <queue>
+#include <stdexcept>
+#include <thread>
+#include <utility>
+#include <vector>
+
+#define MAX_THREADS_NUM 32
+
+namespace milvus {
+
+class ThreadPool {
+ public:
+    explicit ThreadPool(size_t threads, size_t queue_size = 1000);
+
+    template <class F, class... Args>
+    auto
+    enqueue(F&& f, Args&&... args) -> std::future<typename std::result_of<F(Args...)>::type>;
+
+    ~ThreadPool();
+
+ private:
+    // need to keep track of threads so we can join them
+    std::vector<std::thread> workers_;
+
+    // the task queue
+    std::queue<std::function<void()> > tasks_;
+
+    size_t max_queue_size_;
+
+    // synchronization
+    std::mutex queue_mutex_;
+
+    std::condition_variable condition_;
+
+    bool stop;
+};
+
+// the constructor just launches some amount of workers
+inline ThreadPool::ThreadPool(size_t threads, size_t queue_size) : max_queue_size_(queue_size), stop(false) {
+    for (size_t i = 0; i < threads; ++i)
+        workers_.emplace_back([this] {
+            for (;;) {
+                std::function<void()> task;
+
+                {
+                    std::unique_lock<std::mutex> lock(this->queue_mutex_);
+                    this->condition_.wait(lock, [this] { return this->stop || !this->tasks_.empty(); });
+                    if (this->stop && this->tasks_.empty())
+                        return;
+                    task = std::move(this->tasks_.front());
+                    this->tasks_.pop();
+                }
+                this->condition_.notify_all();
+
+                task();
+            }
+        });
+}
+
+// add new work item to the pool
+template <class F, class... Args>
+auto
+ThreadPool::enqueue(F&& f, Args&&... args) -> std::future<typename std::result_of<F(Args...)>::type> {
+    using return_type = typename std::result_of<F(Args...)>::type;
+
+    auto task = std::make_shared<std::packaged_task<return_type()> >(
+        std::bind(std::forward<F>(f), std::forward<Args>(args)...));
+
+    std::future<return_type> res = task->get_future();
+    {
+        std::unique_lock<std::mutex> lock(queue_mutex_);
+        this->condition_.wait(lock, [this] { return this->tasks_.size() < max_queue_size_; });
+        // don't allow enqueueing after stopping the pool
+        if (stop)
+            throw std::runtime_error("enqueue on stopped ThreadPool");
+
+        tasks_.emplace([task]() { (*task)(); });
+    }
+    condition_.notify_all();
+    return res;
+}
+
+// the destructor joins all threads
+inline ThreadPool::~ThreadPool() {
+    {
+        std::unique_lock<std::mutex> lock(queue_mutex_);
+        stop = true;
+    }
+    condition_.notify_all();
+    for (std::thread& worker : workers_) {
+        worker.join();
+    }
+}
+
+}  // namespace milvus
diff --git a/core/src/utils/TimeRecorder.cpp b/core/src/utils/TimeRecorder.cpp
new file mode 100644
index 0000000000..f3061d9d2b
--- /dev/null
+++ b/core/src/utils/TimeRecorder.cpp
@@ -0,0 +1,99 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "utils/TimeRecorder.h"
+#include "utils/Log.h"
+
+namespace milvus {
+
+TimeRecorder::TimeRecorder(const std::string& header, int64_t log_level) : header_(header), log_level_(log_level) {
+    start_ = last_ = stdclock::now();
+}
+
+TimeRecorder::~TimeRecorder() {
+}
+
+std::string
+TimeRecorder::GetTimeSpanStr(double span) {
+    std::string str_sec = std::to_string(span * 0.000001) + ((span > 1000000) ? " seconds" : " second");
+    std::string str_ms = std::to_string(span * 0.001) + " ms";
+
+    return str_sec + " [" + str_ms + "]";
+}
+
+void
+TimeRecorder::PrintTimeRecord(const std::string& msg, double span) {
+    std::string str_log;
+    if (!header_.empty())
+        str_log += header_ + ": ";
+    str_log += msg;
+    str_log += " (";
+    str_log += TimeRecorder::GetTimeSpanStr(span);
+    str_log += ")";
+
+    switch (log_level_) {
+        case 0: {
+            SERVER_LOG_TRACE << str_log;
+            break;
+        }
+        case 1: {
+            SERVER_LOG_DEBUG << str_log;
+            break;
+        }
+        case 2: {
+            SERVER_LOG_INFO << str_log;
+            break;
+        }
+        case 3: {
+            SERVER_LOG_WARNING << str_log;
+            break;
+        }
+        case 4: {
+            SERVER_LOG_ERROR << str_log;
+            break;
+        }
+        case 5: {
+            SERVER_LOG_FATAL << str_log;
+            break;
+        }
+        default: {
+            SERVER_LOG_INFO << str_log;
+            break;
+        }
+    }
+}
+
+double
+TimeRecorder::RecordSection(const std::string& msg) {
+    stdclock::time_point curr = stdclock::now();
+    double span = (std::chrono::duration<double, std::micro>(curr - last_)).count();
+    last_ = curr;
+
+    PrintTimeRecord(msg, span);
+    return span;
+}
+
+double
+TimeRecorder::ElapseFromBegin(const std::string& msg) {
+    stdclock::time_point curr = stdclock::now();
+    double span = (std::chrono::duration<double, std::micro>(curr - start_)).count();
+
+    PrintTimeRecord(msg, span);
+    return span;
+}
+
+}  // namespace milvus
diff --git a/core/src/utils/TimeRecorder.h b/core/src/utils/TimeRecorder.h
new file mode 100644
index 0000000000..cc0a86fbe0
--- /dev/null
+++ b/core/src/utils/TimeRecorder.h
@@ -0,0 +1,53 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <chrono>
+#include <string>
+
+namespace milvus {
+
+class TimeRecorder {
+    using stdclock = std::chrono::high_resolution_clock;
+
+ public:
+    explicit TimeRecorder(const std::string& header, int64_t log_level = 1);
+
+    ~TimeRecorder();  // trace = 0, debug = 1, info = 2, warn = 3, error = 4, critical = 5
+
+    double
+    RecordSection(const std::string& msg);
+
+    double
+    ElapseFromBegin(const std::string& msg);
+
+    static std::string
+    GetTimeSpanStr(double span);
+
+ private:
+    void
+    PrintTimeRecord(const std::string& msg, double span);
+
+ private:
+    std::string header_;
+    stdclock::time_point start_;
+    stdclock::time_point last_;
+    int64_t log_level_;
+};
+
+}  // namespace milvus
diff --git a/core/src/utils/ValidationUtil.cpp b/core/src/utils/ValidationUtil.cpp
new file mode 100644
index 0000000000..68088d6c93
--- /dev/null
+++ b/core/src/utils/ValidationUtil.cpp
@@ -0,0 +1,310 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "utils/ValidationUtil.h"
+#include "Log.h"
+#include "db/engine/ExecutionEngine.h"
+
+#include <arpa/inet.h>
+#include <cuda_runtime.h>
+#include <algorithm>
+#include <cmath>
+#include <regex>
+#include <string>
+
+namespace milvus {
+namespace server {
+
+constexpr size_t TABLE_NAME_SIZE_LIMIT = 255;
+constexpr int64_t TABLE_DIMENSION_LIMIT = 16384;
+constexpr int32_t INDEX_FILE_SIZE_LIMIT = 4096;  // index trigger size max = 4096 MB
+
+Status
+ValidationUtil::ValidateTableName(const std::string& table_name) {
+    // Table name shouldn't be empty.
+    if (table_name.empty()) {
+        std::string msg = "Table name should not be empty.";
+        SERVER_LOG_ERROR << msg;
+        return Status(SERVER_INVALID_TABLE_NAME, msg);
+    }
+
+    std::string invalid_msg = "Invalid table name: " + table_name + ". ";
+    // Table name size shouldn't exceed 16384.
+    if (table_name.size() > TABLE_NAME_SIZE_LIMIT) {
+        std::string msg = invalid_msg + "The length of a table name must be less than 255 characters.";
+        SERVER_LOG_ERROR << msg;
+        return Status(SERVER_INVALID_TABLE_NAME, msg);
+    }
+
+    // Table name first character should be underscore or character.
+    char first_char = table_name[0];
+    if (first_char != '_' && std::isalpha(first_char) == 0) {
+        std::string msg = invalid_msg + "The first character of a table name must be an underscore or letter.";
+        SERVER_LOG_ERROR << msg;
+        return Status(SERVER_INVALID_TABLE_NAME, msg);
+    }
+
+    int64_t table_name_size = table_name.size();
+    for (int64_t i = 1; i < table_name_size; ++i) {
+        char name_char = table_name[i];
+        if (name_char != '_' && std::isalnum(name_char) == 0) {
+            std::string msg = invalid_msg + "Table name can only contain numbers, letters, and underscores.";
+            SERVER_LOG_ERROR << msg;
+            return Status(SERVER_INVALID_TABLE_NAME, msg);
+        }
+    }
+
+    return Status::OK();
+}
+
+Status
+ValidationUtil::ValidateTableDimension(int64_t dimension) {
+    if (dimension <= 0 || dimension > TABLE_DIMENSION_LIMIT) {
+        std::string msg = "Invalid table dimension: " + std::to_string(dimension) + ". " +
+                          "The table dimension must be within the range of 1 ~ 16384.";
+        SERVER_LOG_ERROR << msg;
+        return Status(SERVER_INVALID_VECTOR_DIMENSION, msg);
+    } else {
+        return Status::OK();
+    }
+}
+
+Status
+ValidationUtil::ValidateTableIndexType(int32_t index_type) {
+    int engine_type = static_cast<int>(engine::EngineType(index_type));
+    if (engine_type <= 0 || engine_type > static_cast<int>(engine::EngineType::MAX_VALUE)) {
+        std::string msg = "Invalid index type: " + std::to_string(index_type) + ". " +
+                          "Make sure the index type is in IndexType list.";
+        SERVER_LOG_ERROR << msg;
+        return Status(SERVER_INVALID_INDEX_TYPE, msg);
+    }
+
+#ifndef CUSTOMIZATION
+    // special case, hybird index only available in customize faiss library
+    if (engine_type == static_cast<int>(engine::EngineType::FAISS_IVFSQ8H)) {
+        std::string msg = "Unsupported index type: " + std::to_string(index_type);
+        SERVER_LOG_ERROR << msg;
+        return Status(SERVER_INVALID_INDEX_TYPE, msg);
+    }
+#endif
+
+    return Status::OK();
+}
+
+Status
+ValidationUtil::ValidateTableIndexNlist(int32_t nlist) {
+    if (nlist <= 0) {
+        std::string msg =
+            "Invalid index nlist: " + std::to_string(nlist) + ". " + "The index nlist must be greater than 0.";
+        SERVER_LOG_ERROR << msg;
+        return Status(SERVER_INVALID_INDEX_NLIST, msg);
+    }
+
+    return Status::OK();
+}
+
+Status
+ValidationUtil::ValidateTableIndexFileSize(int64_t index_file_size) {
+    if (index_file_size <= 0 || index_file_size > INDEX_FILE_SIZE_LIMIT) {
+        std::string msg = "Invalid index file size: " + std::to_string(index_file_size) + ". " +
+                          "The index file size must be within the range of 1 ~ " +
+                          std::to_string(INDEX_FILE_SIZE_LIMIT) + ".";
+        SERVER_LOG_ERROR << msg;
+        return Status(SERVER_INVALID_INDEX_FILE_SIZE, msg);
+    }
+
+    return Status::OK();
+}
+
+Status
+ValidationUtil::ValidateTableIndexMetricType(int32_t metric_type) {
+    if (metric_type != static_cast<int32_t>(engine::MetricType::L2) &&
+        metric_type != static_cast<int32_t>(engine::MetricType::IP)) {
+        std::string msg = "Invalid index metric type: " + std::to_string(metric_type) + ". " +
+                          "Make sure the metric type is either MetricType.L2 or MetricType.IP.";
+        SERVER_LOG_ERROR << msg;
+        return Status(SERVER_INVALID_INDEX_METRIC_TYPE, msg);
+    }
+    return Status::OK();
+}
+
+Status
+ValidationUtil::ValidateSearchTopk(int64_t top_k, const engine::meta::TableSchema& table_schema) {
+    if (top_k <= 0 || top_k > 2048) {
+        std::string msg =
+            "Invalid topk: " + std::to_string(top_k) + ". " + "The topk must be within the range of 1 ~ 2048.";
+        SERVER_LOG_ERROR << msg;
+        return Status(SERVER_INVALID_TOPK, msg);
+    }
+
+    return Status::OK();
+}
+
+Status
+ValidationUtil::ValidateSearchNprobe(int64_t nprobe, const engine::meta::TableSchema& table_schema) {
+    if (nprobe <= 0 || nprobe > table_schema.nlist_) {
+        std::string msg = "Invalid nprobe: " + std::to_string(nprobe) + ". " +
+                          "The nprobe must be within the range of 1 ~ index nlist.";
+        SERVER_LOG_ERROR << msg;
+        return Status(SERVER_INVALID_NPROBE, msg);
+    }
+
+    return Status::OK();
+}
+
+Status
+ValidationUtil::ValidateGpuIndex(uint32_t gpu_index) {
+    int num_devices = 0;
+    auto cuda_err = cudaGetDeviceCount(&num_devices);
+    if (cuda_err != cudaSuccess) {
+        std::string msg = "Failed to get gpu card number, cuda error:" + std::to_string(cuda_err);
+        SERVER_LOG_ERROR << msg;
+        return Status(SERVER_UNEXPECTED_ERROR, msg);
+    }
+
+    if (gpu_index >= num_devices) {
+        std::string msg = "Invalid gpu index: " + std::to_string(gpu_index);
+        SERVER_LOG_ERROR << msg;
+        return Status(SERVER_INVALID_ARGUMENT, msg);
+    }
+
+    return Status::OK();
+}
+
+Status
+ValidationUtil::GetGpuMemory(uint32_t gpu_index, size_t& memory) {
+    cudaDeviceProp deviceProp;
+    auto cuda_err = cudaGetDeviceProperties(&deviceProp, gpu_index);
+    if (cuda_err) {
+        std::string msg = "Failed to get gpu properties, cuda error:" + std::to_string(cuda_err);
+        SERVER_LOG_ERROR << msg;
+        return Status(SERVER_UNEXPECTED_ERROR, msg);
+    }
+
+    memory = deviceProp.totalGlobalMem;
+    return Status::OK();
+}
+
+Status
+ValidationUtil::ValidateIpAddress(const std::string& ip_address) {
+    struct in_addr address;
+
+    int result = inet_pton(AF_INET, ip_address.c_str(), &address);
+
+    switch (result) {
+        case 1:
+            return Status::OK();
+        case 0: {
+            std::string msg = "Invalid IP address: " + ip_address;
+            SERVER_LOG_ERROR << msg;
+            return Status(SERVER_INVALID_ARGUMENT, msg);
+        }
+        default: {
+            std::string msg = "IP address conversion error: " + ip_address;
+            SERVER_LOG_ERROR << msg;
+            return Status(SERVER_UNEXPECTED_ERROR, msg);
+        }
+    }
+}
+
+Status
+ValidationUtil::ValidateStringIsNumber(const std::string& str) {
+    if (str.empty() || !std::all_of(str.begin(), str.end(), ::isdigit)) {
+        return Status(SERVER_INVALID_ARGUMENT, "Invalid number");
+    }
+    try {
+        int32_t value = std::stoi(str);
+    } catch (...) {
+        return Status(SERVER_INVALID_ARGUMENT, "Invalid number");
+    }
+    return Status::OK();
+}
+
+Status
+ValidationUtil::ValidateStringIsBool(const std::string& str) {
+    std::string s = str;
+    std::transform(s.begin(), s.end(), s.begin(), ::tolower);
+    if (s == "true" || s == "on" || s == "yes" || s == "1" || s == "false" || s == "off" || s == "no" || s == "0" ||
+        s.empty()) {
+        return Status::OK();
+    }
+    return Status(SERVER_INVALID_ARGUMENT, "Invalid boolean: " + str);
+}
+
+Status
+ValidationUtil::ValidateStringIsFloat(const std::string& str) {
+    try {
+        float val = std::stof(str);
+    } catch (...) {
+        return Status(SERVER_INVALID_ARGUMENT, "Invalid float: " + str);
+    }
+    return Status::OK();
+}
+
+Status
+ValidationUtil::ValidateDbURI(const std::string& uri) {
+    std::string dialectRegex = "(.*)";
+    std::string usernameRegex = "(.*)";
+    std::string passwordRegex = "(.*)";
+    std::string hostRegex = "(.*)";
+    std::string portRegex = "(.*)";
+    std::string dbNameRegex = "(.*)";
+    std::string uriRegexStr = dialectRegex + "\\:\\/\\/" + usernameRegex + "\\:" + passwordRegex + "\\@" + hostRegex +
+                              "\\:" + portRegex + "\\/" + dbNameRegex;
+    std::regex uriRegex(uriRegexStr);
+    std::smatch pieces_match;
+
+    bool okay = true;
+
+    if (std::regex_match(uri, pieces_match, uriRegex)) {
+        std::string dialect = pieces_match[1].str();
+        std::transform(dialect.begin(), dialect.end(), dialect.begin(), ::tolower);
+        if (dialect.find("mysql") == std::string::npos && dialect.find("sqlite") == std::string::npos) {
+            SERVER_LOG_ERROR << "Invalid dialect in URI: dialect = " << dialect;
+            okay = false;
+        }
+
+        /*
+         *      Could be DNS, skip checking
+         *
+                std::string host = pieces_match[4].str();
+                if (!host.empty() && host != "localhost") {
+                    if (ValidateIpAddress(host) != SERVER_SUCCESS) {
+                        SERVER_LOG_ERROR << "Invalid host ip address in uri = " << host;
+                        okay = false;
+                    }
+                }
+        */
+
+        std::string port = pieces_match[5].str();
+        if (!port.empty()) {
+            auto status = ValidateStringIsNumber(port);
+            if (!status.ok()) {
+                SERVER_LOG_ERROR << "Invalid port in uri = " << port;
+                okay = false;
+            }
+        }
+    } else {
+        SERVER_LOG_ERROR << "Wrong URI format: URI = " << uri;
+        okay = false;
+    }
+
+    return (okay ? Status::OK() : Status(SERVER_INVALID_ARGUMENT, "Invalid db backend uri"));
+}
+
+}  // namespace server
+}  // namespace milvus
diff --git a/core/src/utils/ValidationUtil.h b/core/src/utils/ValidationUtil.h
new file mode 100644
index 0000000000..7b24c93fb5
--- /dev/null
+++ b/core/src/utils/ValidationUtil.h
@@ -0,0 +1,80 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "db/meta/MetaTypes.h"
+#include "utils/Status.h"
+
+#include <string>
+
+namespace milvus {
+namespace server {
+
+class ValidationUtil {
+ private:
+    ValidationUtil() = default;
+
+ public:
+    static Status
+    ValidateTableName(const std::string& table_name);
+
+    static Status
+    ValidateTableDimension(int64_t dimension);
+
+    static Status
+    ValidateTableIndexType(int32_t index_type);
+
+    static Status
+    ValidateTableIndexNlist(int32_t nlist);
+
+    static Status
+    ValidateTableIndexFileSize(int64_t index_file_size);
+
+    static Status
+    ValidateTableIndexMetricType(int32_t metric_type);
+
+    static Status
+    ValidateSearchTopk(int64_t top_k, const engine::meta::TableSchema& table_schema);
+
+    static Status
+    ValidateSearchNprobe(int64_t nprobe, const engine::meta::TableSchema& table_schema);
+
+    static Status
+    ValidateGpuIndex(uint32_t gpu_index);
+
+    static Status
+    GetGpuMemory(uint32_t gpu_index, size_t& memory);
+
+    static Status
+    ValidateIpAddress(const std::string& ip_address);
+
+    static Status
+    ValidateStringIsNumber(const std::string& str);
+
+    static Status
+    ValidateStringIsBool(const std::string& str);
+
+    static Status
+    ValidateStringIsFloat(const std::string& str);
+
+    static Status
+    ValidateDbURI(const std::string& uri);
+};
+
+}  // namespace server
+}  // namespace milvus
diff --git a/core/src/utils/easylogging++.cc b/core/src/utils/easylogging++.cc
new file mode 100644
index 0000000000..0c3bb0d375
--- /dev/null
+++ b/core/src/utils/easylogging++.cc
@@ -0,0 +1,3112 @@
+//
+//  Bismillah ar-Rahmaan ar-Raheem
+//
+//  Easylogging++ v9.96.7
+//  Cross-platform logging library for C++ applications
+//
+//  Copyright (c) 2012-2018 Zuhd Web Services
+//  Copyright (c) 2012-2018 @abumusamq
+//
+//  This library is released under the MIT Licence.
+//  https://github.com/zuhd-org/easyloggingpp/blob/master/LICENSE
+//
+//  https://zuhd.org
+//  http://muflihun.com
+//
+
+#include "easylogging++.h"
+
+#if defined(AUTO_INITIALIZE_EASYLOGGINGPP)
+INITIALIZE_EASYLOGGINGPP
+#endif
+
+namespace el {
+
+// el::base
+namespace base {
+// el::base::consts
+namespace consts {
+
+// Level log values - These are values that are replaced in place of %level format specifier
+// Extra spaces after format specifiers are only for readability purposes in log files
+static const base::type::char_t* kInfoLevelLogValue     =   ELPP_LITERAL("INFO");
+static const base::type::char_t* kDebugLevelLogValue    =   ELPP_LITERAL("DEBUG");
+static const base::type::char_t* kWarningLevelLogValue  =   ELPP_LITERAL("WARNING");
+static const base::type::char_t* kErrorLevelLogValue    =   ELPP_LITERAL("ERROR");
+static const base::type::char_t* kFatalLevelLogValue    =   ELPP_LITERAL("FATAL");
+static const base::type::char_t* kVerboseLevelLogValue  =
+  ELPP_LITERAL("VERBOSE"); // will become VERBOSE-x where x = verbose level
+static const base::type::char_t* kTraceLevelLogValue    =   ELPP_LITERAL("TRACE");
+static const base::type::char_t* kInfoLevelShortLogValue     =   ELPP_LITERAL("I");
+static const base::type::char_t* kDebugLevelShortLogValue    =   ELPP_LITERAL("D");
+static const base::type::char_t* kWarningLevelShortLogValue  =   ELPP_LITERAL("W");
+static const base::type::char_t* kErrorLevelShortLogValue    =   ELPP_LITERAL("E");
+static const base::type::char_t* kFatalLevelShortLogValue    =   ELPP_LITERAL("F");
+static const base::type::char_t* kVerboseLevelShortLogValue  =   ELPP_LITERAL("V");
+static const base::type::char_t* kTraceLevelShortLogValue    =   ELPP_LITERAL("T");
+// Format specifiers - These are used to define log format
+static const base::type::char_t* kAppNameFormatSpecifier          =      ELPP_LITERAL("%app");
+static const base::type::char_t* kLoggerIdFormatSpecifier         =      ELPP_LITERAL("%logger");
+static const base::type::char_t* kThreadIdFormatSpecifier         =      ELPP_LITERAL("%thread");
+static const base::type::char_t* kSeverityLevelFormatSpecifier    =      ELPP_LITERAL("%level");
+static const base::type::char_t* kSeverityLevelShortFormatSpecifier    =      ELPP_LITERAL("%levshort");
+static const base::type::char_t* kDateTimeFormatSpecifier         =      ELPP_LITERAL("%datetime");
+static const base::type::char_t* kLogFileFormatSpecifier          =      ELPP_LITERAL("%file");
+static const base::type::char_t* kLogFileBaseFormatSpecifier      =      ELPP_LITERAL("%fbase");
+static const base::type::char_t* kLogLineFormatSpecifier          =      ELPP_LITERAL("%line");
+static const base::type::char_t* kLogLocationFormatSpecifier      =      ELPP_LITERAL("%loc");
+static const base::type::char_t* kLogFunctionFormatSpecifier      =      ELPP_LITERAL("%func");
+static const base::type::char_t* kCurrentUserFormatSpecifier      =      ELPP_LITERAL("%user");
+static const base::type::char_t* kCurrentHostFormatSpecifier      =      ELPP_LITERAL("%host");
+static const base::type::char_t* kMessageFormatSpecifier          =      ELPP_LITERAL("%msg");
+static const base::type::char_t* kVerboseLevelFormatSpecifier     =      ELPP_LITERAL("%vlevel");
+static const char* kDateTimeFormatSpecifierForFilename            =      "%datetime";
+// Date/time
+static const char* kDays[7]                         =      { "Sundayaaa", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" };
+static const char* kDaysAbbrev[7]                   =      { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
+static const char* kMonths[12]                      =      { "January", "February", "March", "Apri", "May", "June", "July", "August",
+                                                             "September", "October", "November", "December"
+                                                           };
+static const char* kMonthsAbbrev[12]                =      { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
+static const char* kDefaultDateTimeFormat           =      "%Y-%M-%d %H:%m:%s,%g";
+static const char* kDefaultDateTimeFormatInFilename =      "%Y-%M-%d_%H-%m";
+static const int kYearBase                          =      1900;
+static const char* kAm                              =      "AM";
+static const char* kPm                              =      "PM";
+// Miscellaneous constants
+
+static const char* kNullPointer                            =      "nullptr";
+#if ELPP_VARIADIC_TEMPLATES_SUPPORTED
+#endif  // ELPP_VARIADIC_TEMPLATES_SUPPORTED
+static const base::type::VerboseLevel kMaxVerboseLevel     =      9;
+static const char* kUnknownUser                            =      "user";
+static const char* kUnknownHost                            =      "unknown-host";
+
+
+//---------------- DEFAULT LOG FILE -----------------------
+
+#if defined(ELPP_NO_DEFAULT_LOG_FILE)
+#  if ELPP_OS_UNIX
+static const char* kDefaultLogFile                         =      "/dev/null";
+#  elif ELPP_OS_WINDOWS
+static const char* kDefaultLogFile                         =      "nul";
+#  endif  // ELPP_OS_UNIX
+#elif defined(ELPP_DEFAULT_LOG_FILE)
+static const char* kDefaultLogFile                         =      ELPP_DEFAULT_LOG_FILE;
+#else
+static const char* kDefaultLogFile                         =      "myeasylog.log";
+#endif // defined(ELPP_NO_DEFAULT_LOG_FILE)
+
+
+#if !defined(ELPP_DISABLE_LOG_FILE_FROM_ARG)
+static const char* kDefaultLogFileParam                    =      "--default-log-file";
+#endif  // !defined(ELPP_DISABLE_LOG_FILE_FROM_ARG)
+#if defined(ELPP_LOGGING_FLAGS_FROM_ARG)
+static const char* kLoggingFlagsParam                      =      "--logging-flags";
+#endif  // defined(ELPP_LOGGING_FLAGS_FROM_ARG)
+static const char* kValidLoggerIdSymbols                   =
+  "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._";
+static const char* kConfigurationComment                   =      "##";
+static const char* kConfigurationLevel                     =      "*";
+static const char* kConfigurationLoggerId                  =      "--";
+}
+// el::base::utils
+namespace utils {
+
+/// @brief Aborts application due with user-defined status
+static void abort(int status, const std::string& reason) {
+  // Both status and reason params are there for debugging with tools like gdb etc
+  ELPP_UNUSED(status);
+  ELPP_UNUSED(reason);
+#if defined(ELPP_COMPILER_MSVC) && defined(_M_IX86) && defined(_DEBUG)
+  // Ignore msvc critical error dialog - break instead (on debug mode)
+  _asm int 3
+#else
+  ::abort();
+#endif  // defined(ELPP_COMPILER_MSVC) && defined(_M_IX86) && defined(_DEBUG)
+}
+
+} // namespace utils
+} // namespace base
+
+// el
+
+// LevelHelper
+
+const char* LevelHelper::convertToString(Level level) {
+  // Do not use switch over strongly typed enums because Intel C++ compilers dont support them yet.
+  if (level == Level::Global) return "GLOBAL";
+  if (level == Level::Debug) return "DEBUG";
+  if (level == Level::Info) return "INFO";
+  if (level == Level::Warning) return "WARNING";
+  if (level == Level::Error) return "ERROR";
+  if (level == Level::Fatal) return "FATAL";
+  if (level == Level::Verbose) return "VERBOSE";
+  if (level == Level::Trace) return "TRACE";
+  return "UNKNOWN";
+}
+
+struct StringToLevelItem {
+  const char* levelString;
+  Level level;
+};
+
+static struct StringToLevelItem stringToLevelMap[] = {
+  { "global", Level::Global },
+  { "debug", Level::Debug },
+  { "info", Level::Info },
+  { "warning", Level::Warning },
+  { "error", Level::Error },
+  { "fatal", Level::Fatal },
+  { "verbose", Level::Verbose },
+  { "trace", Level::Trace }
+};
+
+Level LevelHelper::convertFromString(const char* levelStr) {
+  for (auto& item : stringToLevelMap) {
+    if (base::utils::Str::cStringCaseEq(levelStr, item.levelString)) {
+      return item.level;
+    }
+  }
+  return Level::Unknown;
+}
+
+void LevelHelper::forEachLevel(base::type::EnumType* startIndex, const std::function<bool(void)>& fn) {
+  base::type::EnumType lIndexMax = LevelHelper::kMaxValid;
+  do {
+    if (fn()) {
+      break;
+    }
+    *startIndex = static_cast<base::type::EnumType>(*startIndex << 1);
+  } while (*startIndex <= lIndexMax);
+}
+
+// ConfigurationTypeHelper
+
+const char* ConfigurationTypeHelper::convertToString(ConfigurationType configurationType) {
+  // Do not use switch over strongly typed enums because Intel C++ compilers dont support them yet.
+  if (configurationType == ConfigurationType::Enabled) return "ENABLED";
+  if (configurationType == ConfigurationType::Filename) return "FILENAME";
+  if (configurationType == ConfigurationType::Format) return "FORMAT";
+  if (configurationType == ConfigurationType::ToFile) return "TO_FILE";
+  if (configurationType == ConfigurationType::ToStandardOutput) return "TO_STANDARD_OUTPUT";
+  if (configurationType == ConfigurationType::SubsecondPrecision) return "SUBSECOND_PRECISION";
+  if (configurationType == ConfigurationType::PerformanceTracking) return "PERFORMANCE_TRACKING";
+  if (configurationType == ConfigurationType::MaxLogFileSize) return "MAX_LOG_FILE_SIZE";
+  if (configurationType == ConfigurationType::LogFlushThreshold) return "LOG_FLUSH_THRESHOLD";
+  return "UNKNOWN";
+}
+
+struct ConfigurationStringToTypeItem {
+  const char* configString;
+  ConfigurationType configType;
+};
+
+static struct ConfigurationStringToTypeItem configStringToTypeMap[] = {
+  { "enabled", ConfigurationType::Enabled },
+  { "to_file", ConfigurationType::ToFile },
+  { "to_standard_output", ConfigurationType::ToStandardOutput },
+  { "format", ConfigurationType::Format },
+  { "filename", ConfigurationType::Filename },
+  { "subsecond_precision", ConfigurationType::SubsecondPrecision },
+  { "milliseconds_width", ConfigurationType::MillisecondsWidth },
+  { "performance_tracking", ConfigurationType::PerformanceTracking },
+  { "max_log_file_size", ConfigurationType::MaxLogFileSize },
+  { "log_flush_threshold", ConfigurationType::LogFlushThreshold },
+};
+
+ConfigurationType ConfigurationTypeHelper::convertFromString(const char* configStr) {
+  for (auto& item : configStringToTypeMap) {
+    if (base::utils::Str::cStringCaseEq(configStr, item.configString)) {
+      return item.configType;
+    }
+  }
+  return ConfigurationType::Unknown;
+}
+
+void ConfigurationTypeHelper::forEachConfigType(base::type::EnumType* startIndex, const std::function<bool(void)>& fn) {
+  base::type::EnumType cIndexMax = ConfigurationTypeHelper::kMaxValid;
+  do {
+    if (fn()) {
+      break;
+    }
+    *startIndex = static_cast<base::type::EnumType>(*startIndex << 1);
+  } while (*startIndex <= cIndexMax);
+}
+
+// Configuration
+
+Configuration::Configuration(const Configuration& c) :
+  m_level(c.m_level),
+  m_configurationType(c.m_configurationType),
+  m_value(c.m_value) {
+}
+
+Configuration& Configuration::operator=(const Configuration& c) {
+  if (&c != this) {
+    m_level = c.m_level;
+    m_configurationType = c.m_configurationType;
+    m_value = c.m_value;
+  }
+  return *this;
+}
+
+/// @brief Full constructor used to sets value of configuration
+Configuration::Configuration(Level level, ConfigurationType configurationType, const std::string& value) :
+  m_level(level),
+  m_configurationType(configurationType),
+  m_value(value) {
+}
+
+void Configuration::log(el::base::type::ostream_t& os) const {
+  os << LevelHelper::convertToString(m_level)
+     << ELPP_LITERAL(" ") << ConfigurationTypeHelper::convertToString(m_configurationType)
+     << ELPP_LITERAL(" = ") << m_value.c_str();
+}
+
+/// @brief Used to find configuration from configuration (pointers) repository. Avoid using it.
+Configuration::Predicate::Predicate(Level level, ConfigurationType configurationType) :
+  m_level(level),
+  m_configurationType(configurationType) {
+}
+
+bool Configuration::Predicate::operator()(const Configuration* conf) const {
+  return ((conf != nullptr) && (conf->level() == m_level) && (conf->configurationType() == m_configurationType));
+}
+
+// Configurations
+
+Configurations::Configurations(void) :
+  m_configurationFile(std::string()),
+  m_isFromFile(false) {
+}
+
+Configurations::Configurations(const std::string& configurationFile, bool useDefaultsForRemaining,
+                               Configurations* base) :
+  m_configurationFile(configurationFile),
+  m_isFromFile(false) {
+  parseFromFile(configurationFile, base);
+  if (useDefaultsForRemaining) {
+    setRemainingToDefault();
+  }
+}
+
+bool Configurations::parseFromFile(const std::string& configurationFile, Configurations* base) {
+  // We initial assertion with true because if we have assertion diabled, we want to pass this
+  // check and if assertion is enabled we will have values re-assigned any way.
+  bool assertionPassed = true;
+  ELPP_ASSERT((assertionPassed = base::utils::File::pathExists(configurationFile.c_str(), true)) == true,
+              "Configuration file [" << configurationFile << "] does not exist!");
+  if (!assertionPassed) {
+    return false;
+  }
+  bool success = Parser::parseFromFile(configurationFile, this, base);
+  m_isFromFile = success;
+  return success;
+}
+
+bool Configurations::parseFromText(const std::string& configurationsString, Configurations* base) {
+  bool success = Parser::parseFromText(configurationsString, this, base);
+  if (success) {
+    m_isFromFile = false;
+  }
+  return success;
+}
+
+void Configurations::setFromBase(Configurations* base) {
+  if (base == nullptr || base == this) {
+    return;
+  }
+  base::threading::ScopedLock scopedLock(base->lock());
+  for (Configuration*& conf : base->list()) {
+    set(conf);
+  }
+}
+
+bool Configurations::hasConfiguration(ConfigurationType configurationType) {
+  base::type::EnumType lIndex = LevelHelper::kMinValid;
+  bool result = false;
+  LevelHelper::forEachLevel(&lIndex, [&](void) -> bool {
+    if (hasConfiguration(LevelHelper::castFromInt(lIndex), configurationType)) {
+      result = true;
+    }
+    return result;
+  });
+  return result;
+}
+
+bool Configurations::hasConfiguration(Level level, ConfigurationType configurationType) {
+  base::threading::ScopedLock scopedLock(lock());
+#if ELPP_COMPILER_INTEL
+  // We cant specify template types here, Intel C++ throws compilation error
+  // "error: type name is not allowed"
+  return RegistryWithPred::get(level, configurationType) != nullptr;
+#else
+  return RegistryWithPred<Configuration, Configuration::Predicate>::get(level, configurationType) != nullptr;
+#endif  // ELPP_COMPILER_INTEL
+}
+
+void Configurations::set(Level level, ConfigurationType configurationType, const std::string& value) {
+  base::threading::ScopedLock scopedLock(lock());
+  unsafeSet(level, configurationType, value);  // This is not unsafe anymore as we have locked mutex
+  if (level == Level::Global) {
+    unsafeSetGlobally(configurationType, value, false);  // Again this is not unsafe either
+  }
+}
+
+void Configurations::set(Configuration* conf) {
+  if (conf == nullptr) {
+    return;
+  }
+  set(conf->level(), conf->configurationType(), conf->value());
+}
+
+void Configurations::setToDefault(void) {
+  setGlobally(ConfigurationType::Enabled, std::string("true"), true);
+  setGlobally(ConfigurationType::Filename, std::string(base::consts::kDefaultLogFile), true);
+#if defined(ELPP_NO_LOG_TO_FILE)
+  setGlobally(ConfigurationType::ToFile, std::string("false"), true);
+#else
+  setGlobally(ConfigurationType::ToFile, std::string("true"), true);
+#endif // defined(ELPP_NO_LOG_TO_FILE)
+  setGlobally(ConfigurationType::ToStandardOutput, std::string("true"), true);
+  setGlobally(ConfigurationType::SubsecondPrecision, std::string("3"), true);
+  setGlobally(ConfigurationType::PerformanceTracking, std::string("true"), true);
+  setGlobally(ConfigurationType::MaxLogFileSize, std::string("0"), true);
+  setGlobally(ConfigurationType::LogFlushThreshold, std::string("0"), true);
+
+  setGlobally(ConfigurationType::Format, std::string("%datetime %level [%logger] %msg"), true);
+  set(Level::Debug, ConfigurationType::Format,
+      std::string("%datetime %level [%logger] [%user@%host] [%func] [%loc] %msg"));
+  // INFO and WARNING are set to default by Level::Global
+  set(Level::Error, ConfigurationType::Format, std::string("%datetime %level [%logger] %msg"));
+  set(Level::Fatal, ConfigurationType::Format, std::string("%datetime %level [%logger] %msg"));
+  set(Level::Verbose, ConfigurationType::Format, std::string("%datetime %level-%vlevel [%logger] %msg"));
+  set(Level::Trace, ConfigurationType::Format, std::string("%datetime %level [%logger] [%func] [%loc] %msg"));
+}
+
+void Configurations::setRemainingToDefault(void) {
+  base::threading::ScopedLock scopedLock(lock());
+#if defined(ELPP_NO_LOG_TO_FILE)
+  unsafeSetIfNotExist(Level::Global, ConfigurationType::Enabled, std::string("false"));
+#else
+  unsafeSetIfNotExist(Level::Global, ConfigurationType::Enabled, std::string("true"));
+#endif // defined(ELPP_NO_LOG_TO_FILE)
+  unsafeSetIfNotExist(Level::Global, ConfigurationType::Filename, std::string(base::consts::kDefaultLogFile));
+  unsafeSetIfNotExist(Level::Global, ConfigurationType::ToStandardOutput, std::string("true"));
+  unsafeSetIfNotExist(Level::Global, ConfigurationType::SubsecondPrecision, std::string("3"));
+  unsafeSetIfNotExist(Level::Global, ConfigurationType::PerformanceTracking, std::string("true"));
+  unsafeSetIfNotExist(Level::Global, ConfigurationType::MaxLogFileSize, std::string("0"));
+  unsafeSetIfNotExist(Level::Global, ConfigurationType::Format, std::string("%datetime %level [%logger] %msg"));
+  unsafeSetIfNotExist(Level::Debug, ConfigurationType::Format,
+                      std::string("%datetime %level [%logger] [%user@%host] [%func] [%loc] %msg"));
+  // INFO and WARNING are set to default by Level::Global
+  unsafeSetIfNotExist(Level::Error, ConfigurationType::Format, std::string("%datetime %level [%logger] %msg"));
+  unsafeSetIfNotExist(Level::Fatal, ConfigurationType::Format, std::string("%datetime %level [%logger] %msg"));
+  unsafeSetIfNotExist(Level::Verbose, ConfigurationType::Format, std::string("%datetime %level-%vlevel [%logger] %msg"));
+  unsafeSetIfNotExist(Level::Trace, ConfigurationType::Format,
+                      std::string("%datetime %level [%logger] [%func] [%loc] %msg"));
+}
+
+bool Configurations::Parser::parseFromFile(const std::string& configurationFile, Configurations* sender,
+    Configurations* base) {
+  sender->setFromBase(base);
+  std::ifstream fileStream_(configurationFile.c_str(), std::ifstream::in);
+  ELPP_ASSERT(fileStream_.is_open(), "Unable to open configuration file [" << configurationFile << "] for parsing.");
+  bool parsedSuccessfully = false;
+  std::string line = std::string();
+  Level currLevel = Level::Unknown;
+  std::string currConfigStr = std::string();
+  std::string currLevelStr = std::string();
+  while (fileStream_.good()) {
+    std::getline(fileStream_, line);
+    parsedSuccessfully = parseLine(&line, &currConfigStr, &currLevelStr, &currLevel, sender);
+    ELPP_ASSERT(parsedSuccessfully, "Unable to parse configuration line: " << line);
+  }
+  return parsedSuccessfully;
+}
+
+bool Configurations::Parser::parseFromText(const std::string& configurationsString, Configurations* sender,
+    Configurations* base) {
+  sender->setFromBase(base);
+  bool parsedSuccessfully = false;
+  std::stringstream ss(configurationsString);
+  std::string line = std::string();
+  Level currLevel = Level::Unknown;
+  std::string currConfigStr = std::string();
+  std::string currLevelStr = std::string();
+  while (std::getline(ss, line)) {
+    parsedSuccessfully = parseLine(&line, &currConfigStr, &currLevelStr, &currLevel, sender);
+    ELPP_ASSERT(parsedSuccessfully, "Unable to parse configuration line: " << line);
+  }
+  return parsedSuccessfully;
+}
+
+void Configurations::Parser::ignoreComments(std::string* line) {
+  std::size_t foundAt = 0;
+  std::size_t quotesStart = line->find("\"");
+  std::size_t quotesEnd = std::string::npos;
+  if (quotesStart != std::string::npos) {
+    quotesEnd = line->find("\"", quotesStart + 1);
+    while (quotesEnd != std::string::npos && line->at(quotesEnd - 1) == '\\') {
+      // Do not erase slash yet - we will erase it in parseLine(..) while loop
+      quotesEnd = line->find("\"", quotesEnd + 2);
+    }
+  }
+  if ((foundAt = line->find(base::consts::kConfigurationComment)) != std::string::npos) {
+    if (foundAt < quotesEnd) {
+      foundAt = line->find(base::consts::kConfigurationComment, quotesEnd + 1);
+    }
+    *line = line->substr(0, foundAt);
+  }
+}
+
+bool Configurations::Parser::isLevel(const std::string& line) {
+  return base::utils::Str::startsWith(line, std::string(base::consts::kConfigurationLevel));
+}
+
+bool Configurations::Parser::isComment(const std::string& line) {
+  return base::utils::Str::startsWith(line, std::string(base::consts::kConfigurationComment));
+}
+
+bool Configurations::Parser::isConfig(const std::string& line) {
+  std::size_t assignment = line.find('=');
+  return line != "" &&
+         ((line[0] >= 'A' && line[0] <= 'Z') || (line[0] >= 'a' && line[0] <= 'z')) &&
+         (assignment != std::string::npos) &&
+         (line.size() > assignment);
+}
+
+bool Configurations::Parser::parseLine(std::string* line, std::string* currConfigStr, std::string* currLevelStr,
+                                       Level* currLevel,
+                                       Configurations* conf) {
+  ConfigurationType currConfig = ConfigurationType::Unknown;
+  std::string currValue = std::string();
+  *line = base::utils::Str::trim(*line);
+  if (isComment(*line)) return true;
+  ignoreComments(line);
+  *line = base::utils::Str::trim(*line);
+  if (line->empty()) {
+    // Comment ignored
+    return true;
+  }
+  if (isLevel(*line)) {
+    if (line->size() <= 2) {
+      return true;
+    }
+    *currLevelStr = line->substr(1, line->size() - 2);
+    *currLevelStr = base::utils::Str::toUpper(*currLevelStr);
+    *currLevelStr = base::utils::Str::trim(*currLevelStr);
+    *currLevel = LevelHelper::convertFromString(currLevelStr->c_str());
+    return true;
+  }
+  if (isConfig(*line)) {
+    std::size_t assignment = line->find('=');
+    *currConfigStr = line->substr(0, assignment);
+    *currConfigStr = base::utils::Str::toUpper(*currConfigStr);
+    *currConfigStr = base::utils::Str::trim(*currConfigStr);
+    currConfig = ConfigurationTypeHelper::convertFromString(currConfigStr->c_str());
+    currValue = line->substr(assignment + 1);
+    currValue = base::utils::Str::trim(currValue);
+    std::size_t quotesStart = currValue.find("\"", 0);
+    std::size_t quotesEnd = std::string::npos;
+    if (quotesStart != std::string::npos) {
+      quotesEnd = currValue.find("\"", quotesStart + 1);
+      while (quotesEnd != std::string::npos && currValue.at(quotesEnd - 1) == '\\') {
+        currValue = currValue.erase(quotesEnd - 1, 1);
+        quotesEnd = currValue.find("\"", quotesEnd + 2);
+      }
+    }
+    if (quotesStart != std::string::npos && quotesEnd != std::string::npos) {
+      // Quote provided - check and strip if valid
+      ELPP_ASSERT((quotesStart < quotesEnd), "Configuration error - No ending quote found in ["
+                  << currConfigStr << "]");
+      ELPP_ASSERT((quotesStart + 1 != quotesEnd), "Empty configuration value for [" << currConfigStr << "]");
+      if ((quotesStart != quotesEnd) && (quotesStart + 1 != quotesEnd)) {
+        // Explicit check in case if assertion is disabled
+        currValue = currValue.substr(quotesStart + 1, quotesEnd - 1);
+      }
+    }
+  }
+  ELPP_ASSERT(*currLevel != Level::Unknown, "Unrecognized severity level [" << *currLevelStr << "]");
+  ELPP_ASSERT(currConfig != ConfigurationType::Unknown, "Unrecognized configuration [" << *currConfigStr << "]");
+  if (*currLevel == Level::Unknown || currConfig == ConfigurationType::Unknown) {
+    return false;  // unrecognizable level or config
+  }
+  conf->set(*currLevel, currConfig, currValue);
+  return true;
+}
+
+void Configurations::unsafeSetIfNotExist(Level level, ConfigurationType configurationType, const std::string& value) {
+  Configuration* conf = RegistryWithPred<Configuration, Configuration::Predicate>::get(level, configurationType);
+  if (conf == nullptr) {
+    unsafeSet(level, configurationType, value);
+  }
+}
+
+void Configurations::unsafeSet(Level level, ConfigurationType configurationType, const std::string& value) {
+  Configuration* conf = RegistryWithPred<Configuration, Configuration::Predicate>::get(level, configurationType);
+  if (conf == nullptr) {
+    registerNew(new Configuration(level, configurationType, value));
+  } else {
+    conf->setValue(value);
+  }
+  if (level == Level::Global) {
+    unsafeSetGlobally(configurationType, value, false);
+  }
+}
+
+void Configurations::setGlobally(ConfigurationType configurationType, const std::string& value,
+                                 bool includeGlobalLevel) {
+  if (includeGlobalLevel) {
+    set(Level::Global, configurationType, value);
+  }
+  base::type::EnumType lIndex = LevelHelper::kMinValid;
+  LevelHelper::forEachLevel(&lIndex, [&](void) -> bool {
+    set(LevelHelper::castFromInt(lIndex), configurationType, value);
+    return false;  // Do not break lambda function yet as we need to set all levels regardless
+  });
+}
+
+void Configurations::unsafeSetGlobally(ConfigurationType configurationType, const std::string& value,
+                                       bool includeGlobalLevel) {
+  if (includeGlobalLevel) {
+    unsafeSet(Level::Global, configurationType, value);
+  }
+  base::type::EnumType lIndex = LevelHelper::kMinValid;
+  LevelHelper::forEachLevel(&lIndex, [&](void) -> bool  {
+    unsafeSet(LevelHelper::castFromInt(lIndex), configurationType, value);
+    return false;  // Do not break lambda function yet as we need to set all levels regardless
+  });
+}
+
+// LogBuilder
+
+void LogBuilder::convertToColoredOutput(base::type::string_t* logLine, Level level) {
+  if (!m_termSupportsColor) return;
+  const base::type::char_t* resetColor = ELPP_LITERAL("\x1b[0m");
+  if (level == Level::Error || level == Level::Fatal)
+    *logLine = ELPP_LITERAL("\x1b[31m") + *logLine + resetColor;
+  else if (level == Level::Warning)
+    *logLine = ELPP_LITERAL("\x1b[33m") + *logLine + resetColor;
+  else if (level == Level::Debug)
+    *logLine = ELPP_LITERAL("\x1b[32m") + *logLine + resetColor;
+  else if (level == Level::Info)
+    *logLine = ELPP_LITERAL("\x1b[36m") + *logLine + resetColor;
+  else if (level == Level::Trace)
+    *logLine = ELPP_LITERAL("\x1b[35m") + *logLine + resetColor;
+}
+
+// Logger
+
+Logger::Logger(const std::string& id, base::LogStreamsReferenceMap* logStreamsReference) :
+  m_id(id),
+  m_typedConfigurations(nullptr),
+  m_parentApplicationName(std::string()),
+  m_isConfigured(false),
+  m_logStreamsReference(logStreamsReference) {
+  initUnflushedCount();
+}
+
+Logger::Logger(const std::string& id, const Configurations& configurations,
+               base::LogStreamsReferenceMap* logStreamsReference) :
+  m_id(id),
+  m_typedConfigurations(nullptr),
+  m_parentApplicationName(std::string()),
+  m_isConfigured(false),
+  m_logStreamsReference(logStreamsReference) {
+  initUnflushedCount();
+  configure(configurations);
+}
+
+Logger::Logger(const Logger& logger) {
+  base::utils::safeDelete(m_typedConfigurations);
+  m_id = logger.m_id;
+  m_typedConfigurations = logger.m_typedConfigurations;
+  m_parentApplicationName = logger.m_parentApplicationName;
+  m_isConfigured = logger.m_isConfigured;
+  m_configurations = logger.m_configurations;
+  m_unflushedCount = logger.m_unflushedCount;
+  m_logStreamsReference = logger.m_logStreamsReference;
+}
+
+Logger& Logger::operator=(const Logger& logger) {
+  if (&logger != this) {
+    base::utils::safeDelete(m_typedConfigurations);
+    m_id = logger.m_id;
+    m_typedConfigurations = logger.m_typedConfigurations;
+    m_parentApplicationName = logger.m_parentApplicationName;
+    m_isConfigured = logger.m_isConfigured;
+    m_configurations = logger.m_configurations;
+    m_unflushedCount = logger.m_unflushedCount;
+    m_logStreamsReference = logger.m_logStreamsReference;
+  }
+  return *this;
+}
+
+void Logger::configure(const Configurations& configurations) {
+  m_isConfigured = false;  // we set it to false in case if we fail
+  initUnflushedCount();
+  if (m_typedConfigurations != nullptr) {
+    Configurations* c = const_cast<Configurations*>(m_typedConfigurations->configurations());
+    if (c->hasConfiguration(Level::Global, ConfigurationType::Filename)) {
+      flush();
+    }
+  }
+  base::threading::ScopedLock scopedLock(lock());
+  if (m_configurations != configurations) {
+    m_configurations.setFromBase(const_cast<Configurations*>(&configurations));
+  }
+  base::utils::safeDelete(m_typedConfigurations);
+  m_typedConfigurations = new base::TypedConfigurations(&m_configurations, m_logStreamsReference);
+  resolveLoggerFormatSpec();
+  m_isConfigured = true;
+}
+
+void Logger::reconfigure(void) {
+  ELPP_INTERNAL_INFO(1, "Reconfiguring logger [" << m_id << "]");
+  configure(m_configurations);
+}
+
+bool Logger::isValidId(const std::string& id) {
+  for (std::string::const_iterator it = id.begin(); it != id.end(); ++it) {
+    if (!base::utils::Str::contains(base::consts::kValidLoggerIdSymbols, *it)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+void Logger::flush(void) {
+  ELPP_INTERNAL_INFO(3, "Flushing logger [" << m_id << "] all levels");
+  base::threading::ScopedLock scopedLock(lock());
+  base::type::EnumType lIndex = LevelHelper::kMinValid;
+  LevelHelper::forEachLevel(&lIndex, [&](void) -> bool {
+    flush(LevelHelper::castFromInt(lIndex), nullptr);
+    return false;
+  });
+}
+
+void Logger::flush(Level level, base::type::fstream_t* fs) {
+  if (fs == nullptr && m_typedConfigurations->toFile(level)) {
+    fs = m_typedConfigurations->fileStream(level);
+  }
+  if (fs != nullptr) {
+    fs->flush();
+    std::unordered_map<Level, unsigned int>::iterator iter = m_unflushedCount.find(level);
+    if (iter != m_unflushedCount.end()) {
+      iter->second = 0;
+    }
+    Helpers::validateFileRolling(this, level);
+  }
+}
+
+void Logger::initUnflushedCount(void) {
+  m_unflushedCount.clear();
+  base::type::EnumType lIndex = LevelHelper::kMinValid;
+  LevelHelper::forEachLevel(&lIndex, [&](void) -> bool {
+    m_unflushedCount.insert(std::make_pair(LevelHelper::castFromInt(lIndex), 0));
+    return false;
+  });
+}
+
+void Logger::resolveLoggerFormatSpec(void) const {
+  base::type::EnumType lIndex = LevelHelper::kMinValid;
+  LevelHelper::forEachLevel(&lIndex, [&](void) -> bool {
+    base::LogFormat* logFormat =
+    const_cast<base::LogFormat*>(&m_typedConfigurations->logFormat(LevelHelper::castFromInt(lIndex)));
+    base::utils::Str::replaceFirstWithEscape(logFormat->m_format, base::consts::kLoggerIdFormatSpecifier, m_id);
+    return false;
+  });
+}
+
+// el::base
+namespace base {
+
+// el::base::utils
+namespace utils {
+
+// File
+
+base::type::fstream_t* File::newFileStream(const std::string& filename) {
+  base::type::fstream_t *fs = new base::type::fstream_t(filename.c_str(),
+      base::type::fstream_t::out
+#if !defined(ELPP_FRESH_LOG_FILE)
+      | base::type::fstream_t::app
+#endif
+                                                       );
+#if defined(ELPP_UNICODE)
+  std::locale elppUnicodeLocale("");
+#  if ELPP_OS_WINDOWS
+  std::locale elppUnicodeLocaleWindows(elppUnicodeLocale, new std::codecvt_utf8_utf16<wchar_t>);
+  elppUnicodeLocale = elppUnicodeLocaleWindows;
+#  endif // ELPP_OS_WINDOWS
+  fs->imbue(elppUnicodeLocale);
+#endif  // defined(ELPP_UNICODE)
+  if (fs->is_open()) {
+    fs->flush();
+  } else {
+    base::utils::safeDelete(fs);
+    ELPP_INTERNAL_ERROR("Bad file [" << filename << "]", true);
+  }
+  return fs;
+}
+
+std::size_t File::getSizeOfFile(base::type::fstream_t* fs) {
+  if (fs == nullptr) {
+    return 0;
+  }
+  // Since the file stream is appended to or truncated, the current
+  // offset is the file size.
+  std::size_t size = static_cast<std::size_t>(fs->tellg());
+  return size;
+}
+
+bool File::pathExists(const char* path, bool considerFile) {
+  if (path == nullptr) {
+    return false;
+  }
+#if ELPP_OS_UNIX
+  ELPP_UNUSED(considerFile);
+  struct stat st;
+  return (stat(path, &st) == 0);
+#elif ELPP_OS_WINDOWS
+  DWORD fileType = GetFileAttributesA(path);
+  if (fileType == INVALID_FILE_ATTRIBUTES) {
+    return false;
+  }
+  return considerFile ? true : ((fileType & FILE_ATTRIBUTE_DIRECTORY) == 0 ? false : true);
+#endif  // ELPP_OS_UNIX
+}
+
+bool File::createPath(const std::string& path) {
+  if (path.empty()) {
+    return false;
+  }
+  if (base::utils::File::pathExists(path.c_str())) {
+    return true;
+  }
+  int status = -1;
+
+  char* currPath = const_cast<char*>(path.c_str());
+  std::string builtPath = std::string();
+#if ELPP_OS_UNIX
+  if (path[0] == '/') {
+    builtPath = "/";
+  }
+  currPath = STRTOK(currPath, base::consts::kFilePathSeperator, 0);
+#elif ELPP_OS_WINDOWS
+  // Use secure functions API
+  char* nextTok_ = nullptr;
+  currPath = STRTOK(currPath, base::consts::kFilePathSeperator, &nextTok_);
+  ELPP_UNUSED(nextTok_);
+#endif  // ELPP_OS_UNIX
+  while (currPath != nullptr) {
+    builtPath.append(currPath);
+    builtPath.append(base::consts::kFilePathSeperator);
+#if ELPP_OS_UNIX
+    status = mkdir(builtPath.c_str(), ELPP_LOG_PERMS);
+    currPath = STRTOK(nullptr, base::consts::kFilePathSeperator, 0);
+#elif ELPP_OS_WINDOWS
+    status = _mkdir(builtPath.c_str());
+    currPath = STRTOK(nullptr, base::consts::kFilePathSeperator, &nextTok_);
+#endif  // ELPP_OS_UNIX
+  }
+  if (status == -1) {
+    ELPP_INTERNAL_ERROR("Error while creating path [" << path << "]", true);
+    return false;
+  }
+  return true;
+}
+
+std::string File::extractPathFromFilename(const std::string& fullPath, const char* separator) {
+  if ((fullPath == "") || (fullPath.find(separator) == std::string::npos)) {
+    return fullPath;
+  }
+  std::size_t lastSlashAt = fullPath.find_last_of(separator);
+  if (lastSlashAt == 0) {
+    return std::string(separator);
+  }
+  return fullPath.substr(0, lastSlashAt + 1);
+}
+
+void File::buildStrippedFilename(const char* filename, char buff[], std::size_t limit) {
+  std::size_t sizeOfFilename = strlen(filename);
+  if (sizeOfFilename >= limit) {
+    filename += (sizeOfFilename - limit);
+    if (filename[0] != '.' && filename[1] != '.') {  // prepend if not already
+      filename += 3;  // 3 = '..'
+      STRCAT(buff, "..", limit);
+    }
+  }
+  STRCAT(buff, filename, limit);
+}
+
+void File::buildBaseFilename(const std::string& fullPath, char buff[], std::size_t limit, const char* separator) {
+  const char *filename = fullPath.c_str();
+  std::size_t lastSlashAt = fullPath.find_last_of(separator);
+  filename += lastSlashAt ? lastSlashAt+1 : 0;
+  std::size_t sizeOfFilename = strlen(filename);
+  if (sizeOfFilename >= limit) {
+    filename += (sizeOfFilename - limit);
+    if (filename[0] != '.' && filename[1] != '.') {  // prepend if not already
+      filename += 3;  // 3 = '..'
+      STRCAT(buff, "..", limit);
+    }
+  }
+  STRCAT(buff, filename, limit);
+}
+
+// Str
+
+bool Str::wildCardMatch(const char* str, const char* pattern) {
+  while (*pattern) {
+    switch (*pattern) {
+    case '?':
+      if (!*str)
+        return false;
+      ++str;
+      ++pattern;
+      break;
+    case '*':
+      if (wildCardMatch(str, pattern + 1))
+        return true;
+      if (*str && wildCardMatch(str + 1, pattern))
+        return true;
+      return false;
+    default:
+      if (*str++ != *pattern++)
+        return false;
+      break;
+    }
+  }
+  return !*str && !*pattern;
+}
+
+std::string& Str::ltrim(std::string& str) {
+  str.erase(str.begin(), std::find_if(str.begin(), str.end(), [](char c) {
+    return !std::isspace(c);
+  } ));
+  return str;
+}
+
+std::string& Str::rtrim(std::string& str) {
+  str.erase(std::find_if(str.rbegin(), str.rend(), [](char c) {
+    return !std::isspace(c);
+  }).base(), str.end());
+  return str;
+}
+
+std::string& Str::trim(std::string& str) {
+  return ltrim(rtrim(str));
+}
+
+bool Str::startsWith(const std::string& str, const std::string& start) {
+  return (str.length() >= start.length()) && (str.compare(0, start.length(), start) == 0);
+}
+
+bool Str::endsWith(const std::string& str, const std::string& end) {
+  return (str.length() >= end.length()) && (str.compare(str.length() - end.length(), end.length(), end) == 0);
+}
+
+std::string& Str::replaceAll(std::string& str, char replaceWhat, char replaceWith) {
+  std::replace(str.begin(), str.end(), replaceWhat, replaceWith);
+  return str;
+}
+
+std::string& Str::replaceAll(std::string& str, const std::string& replaceWhat,
+                             const std::string& replaceWith) {
+  if (replaceWhat == replaceWith)
+    return str;
+  std::size_t foundAt = std::string::npos;
+  while ((foundAt = str.find(replaceWhat, foundAt + 1)) != std::string::npos) {
+    str.replace(foundAt, replaceWhat.length(), replaceWith);
+  }
+  return str;
+}
+
+void Str::replaceFirstWithEscape(base::type::string_t& str, const base::type::string_t& replaceWhat,
+                                 const base::type::string_t& replaceWith) {
+  std::size_t foundAt = base::type::string_t::npos;
+  while ((foundAt = str.find(replaceWhat, foundAt + 1)) != base::type::string_t::npos) {
+    if (foundAt > 0 && str[foundAt - 1] == base::consts::kFormatSpecifierChar) {
+      str.erase(foundAt - 1, 1);
+      ++foundAt;
+    } else {
+      str.replace(foundAt, replaceWhat.length(), replaceWith);
+      return;
+    }
+  }
+}
+#if defined(ELPP_UNICODE)
+void Str::replaceFirstWithEscape(base::type::string_t& str, const base::type::string_t& replaceWhat,
+                                 const std::string& replaceWith) {
+  replaceFirstWithEscape(str, replaceWhat, base::type::string_t(replaceWith.begin(), replaceWith.end()));
+}
+#endif  // defined(ELPP_UNICODE)
+
+std::string& Str::toUpper(std::string& str) {
+  std::transform(str.begin(), str.end(), str.begin(),
+  [](char c) {
+    return static_cast<char>(::toupper(c));
+  });
+  return str;
+}
+
+bool Str::cStringEq(const char* s1, const char* s2) {
+  if (s1 == nullptr && s2 == nullptr) return true;
+  if (s1 == nullptr || s2 == nullptr) return false;
+  return strcmp(s1, s2) == 0;
+}
+
+bool Str::cStringCaseEq(const char* s1, const char* s2) {
+  if (s1 == nullptr && s2 == nullptr) return true;
+  if (s1 == nullptr || s2 == nullptr) return false;
+
+  // With thanks to cygwin for this code
+  int d = 0;
+
+  while (true) {
+    const int c1 = toupper(*s1++);
+    const int c2 = toupper(*s2++);
+
+    if (((d = c1 - c2) != 0) || (c2 == '\0')) {
+      break;
+    }
+  }
+
+  return d == 0;
+}
+
+bool Str::contains(const char* str, char c) {
+  for (; *str; ++str) {
+    if (*str == c)
+      return true;
+  }
+  return false;
+}
+
+char* Str::convertAndAddToBuff(std::size_t n, int len, char* buf, const char* bufLim, bool zeroPadded) {
+  char localBuff[10] = "";
+  char* p = localBuff + sizeof(localBuff) - 2;
+  if (n > 0) {
+    for (; n > 0 && p > localBuff && len > 0; n /= 10, --len)
+      *--p = static_cast<char>(n % 10 + '0');
+  } else {
+    *--p = '0';
+    --len;
+  }
+  if (zeroPadded)
+    while (p > localBuff && len-- > 0) *--p = static_cast<char>('0');
+  return addToBuff(p, buf, bufLim);
+}
+
+char* Str::addToBuff(const char* str, char* buf, const char* bufLim) {
+  while ((buf < bufLim) && ((*buf = *str++) != '\0'))
+    ++buf;
+  return buf;
+}
+
+char* Str::clearBuff(char buff[], std::size_t lim) {
+  STRCPY(buff, "", lim);
+  ELPP_UNUSED(lim);  // For *nix we dont have anything using lim in above STRCPY macro
+  return buff;
+}
+
+/// @brief Converst wchar* to char*
+///        NOTE: Need to free return value after use!
+char* Str::wcharPtrToCharPtr(const wchar_t* line) {
+  std::size_t len_ = wcslen(line) + 1;
+  char* buff_ = static_cast<char*>(malloc(len_ + 1));
+#      if ELPP_OS_UNIX || (ELPP_OS_WINDOWS && !ELPP_CRT_DBG_WARNINGS)
+  std::wcstombs(buff_, line, len_);
+#      elif ELPP_OS_WINDOWS
+  std::size_t convCount_ = 0;
+  mbstate_t mbState_;
+  ::memset(static_cast<void*>(&mbState_), 0, sizeof(mbState_));
+  wcsrtombs_s(&convCount_, buff_, len_, &line, len_, &mbState_);
+#      endif  // ELPP_OS_UNIX || (ELPP_OS_WINDOWS && !ELPP_CRT_DBG_WARNINGS)
+  return buff_;
+}
+
+// OS
+
+#if ELPP_OS_WINDOWS
+/// @brief Gets environment variables for Windows based OS.
+///        We are not using <code>getenv(const char*)</code> because of CRT deprecation
+/// @param varname Variable name to get environment variable value for
+/// @return If variable exist the value of it otherwise nullptr
+const char* OS::getWindowsEnvironmentVariable(const char* varname) {
+  const DWORD bufferLen = 50;
+  static char buffer[bufferLen];
+  if (GetEnvironmentVariableA(varname, buffer, bufferLen)) {
+    return buffer;
+  }
+  return nullptr;
+}
+#endif  // ELPP_OS_WINDOWS
+#if ELPP_OS_ANDROID
+std::string OS::getProperty(const char* prop) {
+  char propVal[PROP_VALUE_MAX + 1];
+  int ret = __system_property_get(prop, propVal);
+  return ret == 0 ? std::string() : std::string(propVal);
+}
+
+std::string OS::getDeviceName(void) {
+  std::stringstream ss;
+  std::string manufacturer = getProperty("ro.product.manufacturer");
+  std::string model = getProperty("ro.product.model");
+  if (manufacturer.empty() || model.empty()) {
+    return std::string();
+  }
+  ss << manufacturer << "-" << model;
+  return ss.str();
+}
+#endif  // ELPP_OS_ANDROID
+
+const std::string OS::getBashOutput(const char* command) {
+#if (ELPP_OS_UNIX && !ELPP_OS_ANDROID && !ELPP_CYGWIN)
+  if (command == nullptr) {
+    return std::string();
+  }
+  FILE* proc = nullptr;
+  if ((proc = popen(command, "r")) == nullptr) {
+    ELPP_INTERNAL_ERROR("\nUnable to run command [" << command << "]", true);
+    return std::string();
+  }
+  char hBuff[4096];
+  if (fgets(hBuff, sizeof(hBuff), proc) != nullptr) {
+    pclose(proc);
+    const std::size_t buffLen = strlen(hBuff);
+    if (buffLen > 0 && hBuff[buffLen - 1] == '\n') {
+      hBuff[buffLen - 1] = '\0';
+    }
+    return std::string(hBuff);
+  } else {
+    pclose(proc);
+  }
+  return std::string();
+#else
+  ELPP_UNUSED(command);
+  return std::string();
+#endif  // (ELPP_OS_UNIX && !ELPP_OS_ANDROID && !ELPP_CYGWIN)
+}
+
+std::string OS::getEnvironmentVariable(const char* variableName, const char* defaultVal,
+                                       const char* alternativeBashCommand) {
+#if ELPP_OS_UNIX
+  const char* val = getenv(variableName);
+#elif ELPP_OS_WINDOWS
+  const char* val = getWindowsEnvironmentVariable(variableName);
+#endif  // ELPP_OS_UNIX
+  if ((val == nullptr) || ((strcmp(val, "") == 0))) {
+#if ELPP_OS_UNIX && defined(ELPP_FORCE_ENV_VAR_FROM_BASH)
+    // Try harder on unix-based systems
+    std::string valBash = base::utils::OS::getBashOutput(alternativeBashCommand);
+    if (valBash.empty()) {
+      return std::string(defaultVal);
+    } else {
+      return valBash;
+    }
+#elif ELPP_OS_WINDOWS || ELPP_OS_UNIX
+    ELPP_UNUSED(alternativeBashCommand);
+    return std::string(defaultVal);
+#endif  // ELPP_OS_UNIX && defined(ELPP_FORCE_ENV_VAR_FROM_BASH)
+  }
+  return std::string(val);
+}
+
+std::string OS::currentUser(void) {
+#if ELPP_OS_UNIX && !ELPP_OS_ANDROID
+  return getEnvironmentVariable("USER", base::consts::kUnknownUser, "whoami");
+#elif ELPP_OS_WINDOWS
+  return getEnvironmentVariable("USERNAME", base::consts::kUnknownUser);
+#elif ELPP_OS_ANDROID
+  ELPP_UNUSED(base::consts::kUnknownUser);
+  return std::string("android");
+#else
+  return std::string();
+#endif  // ELPP_OS_UNIX && !ELPP_OS_ANDROID
+}
+
+std::string OS::currentHost(void) {
+#if ELPP_OS_UNIX && !ELPP_OS_ANDROID
+  return getEnvironmentVariable("HOSTNAME", base::consts::kUnknownHost, "hostname");
+#elif ELPP_OS_WINDOWS
+  return getEnvironmentVariable("COMPUTERNAME", base::consts::kUnknownHost);
+#elif ELPP_OS_ANDROID
+  ELPP_UNUSED(base::consts::kUnknownHost);
+  return getDeviceName();
+#else
+  return std::string();
+#endif  // ELPP_OS_UNIX && !ELPP_OS_ANDROID
+}
+
+bool OS::termSupportsColor(void) {
+  std::string term = getEnvironmentVariable("TERM", "");
+  return term == "xterm" || term == "xterm-color" || term == "xterm-256color"
+         || term == "screen" || term == "linux" || term == "cygwin"
+         || term == "screen-256color";
+}
+
+// DateTime
+
+void DateTime::gettimeofday(struct timeval* tv) {
+#if ELPP_OS_WINDOWS
+  if (tv != nullptr) {
+#  if ELPP_COMPILER_MSVC || defined(_MSC_EXTENSIONS)
+    const unsigned __int64 delta_ = 11644473600000000Ui64;
+#  else
+    const unsigned __int64 delta_ = 11644473600000000ULL;
+#  endif  // ELPP_COMPILER_MSVC || defined(_MSC_EXTENSIONS)
+    const double secOffSet = 0.000001;
+    const unsigned long usecOffSet = 1000000;
+    FILETIME fileTime;
+    GetSystemTimeAsFileTime(&fileTime);
+    unsigned __int64 present = 0;
+    present |= fileTime.dwHighDateTime;
+    present = present << 32;
+    present |= fileTime.dwLowDateTime;
+    present /= 10;  // mic-sec
+    // Subtract the difference
+    present -= delta_;
+    tv->tv_sec = static_cast<long>(present * secOffSet);
+    tv->tv_usec = static_cast<long>(present % usecOffSet);
+  }
+#else
+  ::gettimeofday(tv, nullptr);
+#endif  // ELPP_OS_WINDOWS
+}
+
+std::string DateTime::getDateTime(const char* format, const base::SubsecondPrecision* ssPrec) {
+  struct timeval currTime;
+  gettimeofday(&currTime);
+  return timevalToString(currTime, format, ssPrec);
+}
+
+std::string DateTime::timevalToString(struct timeval tval, const char* format,
+                                      const el::base::SubsecondPrecision* ssPrec) {
+  struct ::tm timeInfo;
+  buildTimeInfo(&tval, &timeInfo);
+  const int kBuffSize = 30;
+  char buff_[kBuffSize] = "";
+  parseFormat(buff_, kBuffSize, format, &timeInfo, static_cast<std::size_t>(tval.tv_usec / ssPrec->m_offset),
+              ssPrec);
+  return std::string(buff_);
+}
+
+base::type::string_t DateTime::formatTime(unsigned long long time, base::TimestampUnit timestampUnit) {
+  base::type::EnumType start = static_cast<base::type::EnumType>(timestampUnit);
+  const base::type::char_t* unit = base::consts::kTimeFormats[start].unit;
+  for (base::type::EnumType i = start; i < base::consts::kTimeFormatsCount - 1; ++i) {
+    if (time <= base::consts::kTimeFormats[i].value) {
+      break;
+    }
+    if (base::consts::kTimeFormats[i].value == 1000.0f && time / 1000.0f < 1.9f) {
+      break;
+    }
+    time /= static_cast<decltype(time)>(base::consts::kTimeFormats[i].value);
+    unit = base::consts::kTimeFormats[i + 1].unit;
+  }
+  base::type::stringstream_t ss;
+  ss << time << " " << unit;
+  return ss.str();
+}
+
+unsigned long long DateTime::getTimeDifference(const struct timeval& endTime, const struct timeval& startTime,
+    base::TimestampUnit timestampUnit) {
+  if (timestampUnit == base::TimestampUnit::Microsecond) {
+    return static_cast<unsigned long long>(static_cast<unsigned long long>(1000000 * endTime.tv_sec + endTime.tv_usec) -
+                                           static_cast<unsigned long long>(1000000 * startTime.tv_sec + startTime.tv_usec));
+  }
+  // milliseconds
+  auto conv = [](const struct timeval& tim) {
+    return static_cast<unsigned long long>((tim.tv_sec * 1000) + (tim.tv_usec / 1000));
+  };
+  return static_cast<unsigned long long>(conv(endTime) - conv(startTime));
+}
+
+struct ::tm* DateTime::buildTimeInfo(struct timeval* currTime, struct ::tm* timeInfo) {
+#if ELPP_OS_UNIX
+  time_t rawTime = currTime->tv_sec;
+  ::elpptime_r(&rawTime, timeInfo);
+  return timeInfo;
+#else
+#  if ELPP_COMPILER_MSVC
+  ELPP_UNUSED(currTime);
+  time_t t;
+#    if defined(_USE_32BIT_TIME_T)
+  _time32(&t);
+#    else
+  _time64(&t);
+#    endif
+  elpptime_s(timeInfo, &t);
+  return timeInfo;
+#  else
+  // For any other compilers that don't have CRT warnings issue e.g, MinGW or TDM GCC- we use different method
+  time_t rawTime = currTime->tv_sec;
+  struct tm* tmInf = elpptime(&rawTime);
+  *timeInfo = *tmInf;
+  return timeInfo;
+#  endif  // ELPP_COMPILER_MSVC
+#endif  // ELPP_OS_UNIX
+}
+
+char* DateTime::parseFormat(char* buf, std::size_t bufSz, const char* format, const struct tm* tInfo,
+                            std::size_t msec, const base::SubsecondPrecision* ssPrec) {
+  const char* bufLim = buf + bufSz;
+  for (; *format; ++format) {
+    if (*format == base::consts::kFormatSpecifierChar) {
+      switch (*++format) {
+      case base::consts::kFormatSpecifierChar:  // Escape
+        break;
+      case '\0':  // End
+        --format;
+        break;
+      case 'd':  // Day
+        buf = base::utils::Str::convertAndAddToBuff(tInfo->tm_mday, 2, buf, bufLim);
+        continue;
+      case 'a':  // Day of week (short)
+        buf = base::utils::Str::addToBuff(base::consts::kDaysAbbrev[tInfo->tm_wday], buf, bufLim);
+        continue;
+      case 'A':  // Day of week (long)
+        buf = base::utils::Str::addToBuff(base::consts::kDays[tInfo->tm_wday], buf, bufLim);
+        continue;
+      case 'M':  // month
+        buf = base::utils::Str::convertAndAddToBuff(tInfo->tm_mon + 1, 2, buf, bufLim);
+        continue;
+      case 'b':  // month (short)
+        buf = base::utils::Str::addToBuff(base::consts::kMonthsAbbrev[tInfo->tm_mon], buf, bufLim);
+        continue;
+      case 'B':  // month (long)
+        buf = base::utils::Str::addToBuff(base::consts::kMonths[tInfo->tm_mon], buf, bufLim);
+        continue;
+      case 'y':  // year (two digits)
+        buf = base::utils::Str::convertAndAddToBuff(tInfo->tm_year + base::consts::kYearBase, 2, buf, bufLim);
+        continue;
+      case 'Y':  // year (four digits)
+        buf = base::utils::Str::convertAndAddToBuff(tInfo->tm_year + base::consts::kYearBase, 4, buf, bufLim);
+        continue;
+      case 'h':  // hour (12-hour)
+        buf = base::utils::Str::convertAndAddToBuff(tInfo->tm_hour % 12, 2, buf, bufLim);
+        continue;
+      case 'H':  // hour (24-hour)
+        buf = base::utils::Str::convertAndAddToBuff(tInfo->tm_hour, 2, buf, bufLim);
+        continue;
+      case 'm':  // minute
+        buf = base::utils::Str::convertAndAddToBuff(tInfo->tm_min, 2, buf, bufLim);
+        continue;
+      case 's':  // second
+        buf = base::utils::Str::convertAndAddToBuff(tInfo->tm_sec, 2, buf, bufLim);
+        continue;
+      case 'z':  // subsecond part
+      case 'g':
+        buf = base::utils::Str::convertAndAddToBuff(msec, ssPrec->m_width, buf, bufLim);
+        continue;
+      case 'F':  // AM/PM
+        buf = base::utils::Str::addToBuff((tInfo->tm_hour >= 12) ? base::consts::kPm : base::consts::kAm, buf, bufLim);
+        continue;
+      default:
+        continue;
+      }
+    }
+    if (buf == bufLim) break;
+    *buf++ = *format;
+  }
+  return buf;
+}
+
+// CommandLineArgs
+
+void CommandLineArgs::setArgs(int argc, char** argv) {
+  m_params.clear();
+  m_paramsWithValue.clear();
+  if (argc == 0 || argv == nullptr) {
+    return;
+  }
+  m_argc = argc;
+  m_argv = argv;
+  for (int i = 1; i < m_argc; ++i) {
+    const char* v = (strstr(m_argv[i], "="));
+    if (v != nullptr && strlen(v) > 0) {
+      std::string key = std::string(m_argv[i]);
+      key = key.substr(0, key.find_first_of('='));
+      if (hasParamWithValue(key.c_str())) {
+        ELPP_INTERNAL_INFO(1, "Skipping [" << key << "] arg since it already has value ["
+                           << getParamValue(key.c_str()) << "]");
+      } else {
+        m_paramsWithValue.insert(std::make_pair(key, std::string(v + 1)));
+      }
+    }
+    if (v == nullptr) {
+      if (hasParam(m_argv[i])) {
+        ELPP_INTERNAL_INFO(1, "Skipping [" << m_argv[i] << "] arg since it already exists");
+      } else {
+        m_params.push_back(std::string(m_argv[i]));
+      }
+    }
+  }
+}
+
+bool CommandLineArgs::hasParamWithValue(const char* paramKey) const {
+  return m_paramsWithValue.find(std::string(paramKey)) != m_paramsWithValue.end();
+}
+
+const char* CommandLineArgs::getParamValue(const char* paramKey) const {
+  std::unordered_map<std::string, std::string>::const_iterator iter = m_paramsWithValue.find(std::string(paramKey));
+  return iter != m_paramsWithValue.end() ? iter->second.c_str() : "";
+}
+
+bool CommandLineArgs::hasParam(const char* paramKey) const {
+  return std::find(m_params.begin(), m_params.end(), std::string(paramKey)) != m_params.end();
+}
+
+bool CommandLineArgs::empty(void) const {
+  return m_params.empty() && m_paramsWithValue.empty();
+}
+
+std::size_t CommandLineArgs::size(void) const {
+  return m_params.size() + m_paramsWithValue.size();
+}
+
+base::type::ostream_t& operator<<(base::type::ostream_t& os, const CommandLineArgs& c) {
+  for (int i = 1; i < c.m_argc; ++i) {
+    os << ELPP_LITERAL("[") << c.m_argv[i] << ELPP_LITERAL("]");
+    if (i < c.m_argc - 1) {
+      os << ELPP_LITERAL(" ");
+    }
+  }
+  return os;
+}
+
+} // namespace utils
+
+// el::base::threading
+namespace threading {
+
+#if ELPP_THREADING_ENABLED
+#  if ELPP_USE_STD_THREADING
+#      if ELPP_ASYNC_LOGGING
+static void msleep(int ms) {
+  // Only when async logging enabled - this is because async is strict on compiler
+#         if defined(ELPP_NO_SLEEP_FOR)
+  usleep(ms * 1000);
+#         else
+  std::this_thread::sleep_for(std::chrono::milliseconds(ms));
+#         endif  // defined(ELPP_NO_SLEEP_FOR)
+}
+#      endif  // ELPP_ASYNC_LOGGING
+#  endif  // !ELPP_USE_STD_THREADING
+#endif  // ELPP_THREADING_ENABLED
+
+} // namespace threading
+
+// el::base
+
+// SubsecondPrecision
+
+void SubsecondPrecision::init(int width) {
+  if (width < 1 || width > 6) {
+    width = base::consts::kDefaultSubsecondPrecision;
+  }
+  m_width = width;
+  switch (m_width) {
+  case 3:
+    m_offset = 1000;
+    break;
+  case 4:
+    m_offset = 100;
+    break;
+  case 5:
+    m_offset = 10;
+    break;
+  case 6:
+    m_offset = 1;
+    break;
+  default:
+    m_offset = 1000;
+    break;
+  }
+}
+
+// LogFormat
+
+LogFormat::LogFormat(void) :
+  m_level(Level::Unknown),
+  m_userFormat(base::type::string_t()),
+  m_format(base::type::string_t()),
+  m_dateTimeFormat(std::string()),
+  m_flags(0x0),
+  m_currentUser(base::utils::OS::currentUser()),
+  m_currentHost(base::utils::OS::currentHost()) {
+}
+
+LogFormat::LogFormat(Level level, const base::type::string_t& format)
+  : m_level(level), m_userFormat(format), m_currentUser(base::utils::OS::currentUser()),
+    m_currentHost(base::utils::OS::currentHost()) {
+  parseFromFormat(m_userFormat);
+}
+
+LogFormat::LogFormat(const LogFormat& logFormat):
+  m_level(logFormat.m_level),
+  m_userFormat(logFormat.m_userFormat),
+  m_format(logFormat.m_format),
+  m_dateTimeFormat(logFormat.m_dateTimeFormat),
+  m_flags(logFormat.m_flags),
+  m_currentUser(logFormat.m_currentUser),
+  m_currentHost(logFormat.m_currentHost) {
+}
+
+LogFormat::LogFormat(LogFormat&& logFormat) {
+  m_level = std::move(logFormat.m_level);
+  m_userFormat = std::move(logFormat.m_userFormat);
+  m_format = std::move(logFormat.m_format);
+  m_dateTimeFormat = std::move(logFormat.m_dateTimeFormat);
+  m_flags = std::move(logFormat.m_flags);
+  m_currentUser = std::move(logFormat.m_currentUser);
+  m_currentHost = std::move(logFormat.m_currentHost);
+}
+
+LogFormat& LogFormat::operator=(const LogFormat& logFormat) {
+  if (&logFormat != this) {
+    m_level = logFormat.m_level;
+    m_userFormat = logFormat.m_userFormat;
+    m_dateTimeFormat = logFormat.m_dateTimeFormat;
+    m_flags = logFormat.m_flags;
+    m_currentUser = logFormat.m_currentUser;
+    m_currentHost = logFormat.m_currentHost;
+  }
+  return *this;
+}
+
+bool LogFormat::operator==(const LogFormat& other) {
+  return m_level == other.m_level && m_userFormat == other.m_userFormat && m_format == other.m_format &&
+         m_dateTimeFormat == other.m_dateTimeFormat && m_flags == other.m_flags;
+}
+
+/// @brief Updates format to be used while logging.
+/// @param userFormat User provided format
+void LogFormat::parseFromFormat(const base::type::string_t& userFormat) {
+  // We make copy because we will be changing the format
+  // i.e, removing user provided date format from original format
+  // and then storing it.
+  base::type::string_t formatCopy = userFormat;
+  m_flags = 0x0;
+  auto conditionalAddFlag = [&](const base::type::char_t* specifier, base::FormatFlags flag) {
+    std::size_t foundAt = base::type::string_t::npos;
+    while ((foundAt = formatCopy.find(specifier, foundAt + 1)) != base::type::string_t::npos) {
+      if (foundAt > 0 && formatCopy[foundAt - 1] == base::consts::kFormatSpecifierChar) {
+        if (hasFlag(flag)) {
+          // If we already have flag we remove the escape chars so that '%%' is turned to '%'
+          // even after specifier resolution - this is because we only replaceFirst specifier
+          formatCopy.erase(foundAt - 1, 1);
+          ++foundAt;
+        }
+      } else {
+        if (!hasFlag(flag)) addFlag(flag);
+      }
+    }
+  };
+  conditionalAddFlag(base::consts::kAppNameFormatSpecifier, base::FormatFlags::AppName);
+  conditionalAddFlag(base::consts::kSeverityLevelFormatSpecifier, base::FormatFlags::Level);
+  conditionalAddFlag(base::consts::kSeverityLevelShortFormatSpecifier, base::FormatFlags::LevelShort);
+  conditionalAddFlag(base::consts::kLoggerIdFormatSpecifier, base::FormatFlags::LoggerId);
+  conditionalAddFlag(base::consts::kThreadIdFormatSpecifier, base::FormatFlags::ThreadId);
+  conditionalAddFlag(base::consts::kLogFileFormatSpecifier, base::FormatFlags::File);
+  conditionalAddFlag(base::consts::kLogFileBaseFormatSpecifier, base::FormatFlags::FileBase);
+  conditionalAddFlag(base::consts::kLogLineFormatSpecifier, base::FormatFlags::Line);
+  conditionalAddFlag(base::consts::kLogLocationFormatSpecifier, base::FormatFlags::Location);
+  conditionalAddFlag(base::consts::kLogFunctionFormatSpecifier, base::FormatFlags::Function);
+  conditionalAddFlag(base::consts::kCurrentUserFormatSpecifier, base::FormatFlags::User);
+  conditionalAddFlag(base::consts::kCurrentHostFormatSpecifier, base::FormatFlags::Host);
+  conditionalAddFlag(base::consts::kMessageFormatSpecifier, base::FormatFlags::LogMessage);
+  conditionalAddFlag(base::consts::kVerboseLevelFormatSpecifier, base::FormatFlags::VerboseLevel);
+  // For date/time we need to extract user's date format first
+  std::size_t dateIndex = std::string::npos;
+  if ((dateIndex = formatCopy.find(base::consts::kDateTimeFormatSpecifier)) != std::string::npos) {
+    while (dateIndex > 0 && formatCopy[dateIndex - 1] == base::consts::kFormatSpecifierChar) {
+      dateIndex = formatCopy.find(base::consts::kDateTimeFormatSpecifier, dateIndex + 1);
+    }
+    if (dateIndex != std::string::npos) {
+      addFlag(base::FormatFlags::DateTime);
+      updateDateFormat(dateIndex, formatCopy);
+    }
+  }
+  m_format = formatCopy;
+  updateFormatSpec();
+}
+
+void LogFormat::updateDateFormat(std::size_t index, base::type::string_t& currFormat) {
+  if (hasFlag(base::FormatFlags::DateTime)) {
+    index += ELPP_STRLEN(base::consts::kDateTimeFormatSpecifier);
+  }
+  const base::type::char_t* ptr = currFormat.c_str() + index;
+  if ((currFormat.size() > index) && (ptr[0] == '{')) {
+    // User has provided format for date/time
+    ++ptr;
+    int count = 1;  // Start by 1 in order to remove starting brace
+    std::stringstream ss;
+    for (; *ptr; ++ptr, ++count) {
+      if (*ptr == '}') {
+        ++count;  // In order to remove ending brace
+        break;
+      }
+      ss << static_cast<char>(*ptr);
+    }
+    currFormat.erase(index, count);
+    m_dateTimeFormat = ss.str();
+  } else {
+    // No format provided, use default
+    if (hasFlag(base::FormatFlags::DateTime)) {
+      m_dateTimeFormat = std::string(base::consts::kDefaultDateTimeFormat);
+    }
+  }
+}
+
+void LogFormat::updateFormatSpec(void) {
+  // Do not use switch over strongly typed enums because Intel C++ compilers dont support them yet.
+  if (m_level == Level::Debug) {
+    base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelFormatSpecifier,
+        base::consts::kDebugLevelLogValue);
+    base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelShortFormatSpecifier,
+        base::consts::kDebugLevelShortLogValue);
+  } else if (m_level == Level::Info) {
+    base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelFormatSpecifier,
+        base::consts::kInfoLevelLogValue);
+    base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelShortFormatSpecifier,
+        base::consts::kInfoLevelShortLogValue);
+  } else if (m_level == Level::Warning) {
+    base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelFormatSpecifier,
+        base::consts::kWarningLevelLogValue);
+    base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelShortFormatSpecifier,
+        base::consts::kWarningLevelShortLogValue);
+  } else if (m_level == Level::Error) {
+    base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelFormatSpecifier,
+        base::consts::kErrorLevelLogValue);
+    base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelShortFormatSpecifier,
+        base::consts::kErrorLevelShortLogValue);
+  } else if (m_level == Level::Fatal) {
+    base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelFormatSpecifier,
+        base::consts::kFatalLevelLogValue);
+    base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelShortFormatSpecifier,
+        base::consts::kFatalLevelShortLogValue);
+  } else if (m_level == Level::Verbose) {
+    base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelFormatSpecifier,
+        base::consts::kVerboseLevelLogValue);
+    base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelShortFormatSpecifier,
+        base::consts::kVerboseLevelShortLogValue);
+  } else if (m_level == Level::Trace) {
+    base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelFormatSpecifier,
+        base::consts::kTraceLevelLogValue);
+    base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kSeverityLevelShortFormatSpecifier,
+        base::consts::kTraceLevelShortLogValue);
+  }
+  if (hasFlag(base::FormatFlags::User)) {
+    base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kCurrentUserFormatSpecifier,
+        m_currentUser);
+  }
+  if (hasFlag(base::FormatFlags::Host)) {
+    base::utils::Str::replaceFirstWithEscape(m_format, base::consts::kCurrentHostFormatSpecifier,
+        m_currentHost);
+  }
+  // Ignore Level::Global and Level::Unknown
+}
+
+// TypedConfigurations
+
+TypedConfigurations::TypedConfigurations(Configurations* configurations,
+    base::LogStreamsReferenceMap* logStreamsReference) {
+  m_configurations = configurations;
+  m_logStreamsReference = logStreamsReference;
+  build(m_configurations);
+}
+
+TypedConfigurations::TypedConfigurations(const TypedConfigurations& other) {
+  this->m_configurations = other.m_configurations;
+  this->m_logStreamsReference = other.m_logStreamsReference;
+  build(m_configurations);
+}
+
+bool TypedConfigurations::enabled(Level level) {
+  return getConfigByVal<bool>(level, &m_enabledMap, "enabled");
+}
+
+bool TypedConfigurations::toFile(Level level) {
+  return getConfigByVal<bool>(level, &m_toFileMap, "toFile");
+}
+
+const std::string& TypedConfigurations::filename(Level level) {
+  return getConfigByRef<std::string>(level, &m_filenameMap, "filename");
+}
+
+bool TypedConfigurations::toStandardOutput(Level level) {
+  return getConfigByVal<bool>(level, &m_toStandardOutputMap, "toStandardOutput");
+}
+
+const base::LogFormat& TypedConfigurations::logFormat(Level level) {
+  return getConfigByRef<base::LogFormat>(level, &m_logFormatMap, "logFormat");
+}
+
+const base::SubsecondPrecision& TypedConfigurations::subsecondPrecision(Level level) {
+  return getConfigByRef<base::SubsecondPrecision>(level, &m_subsecondPrecisionMap, "subsecondPrecision");
+}
+
+const base::MillisecondsWidth& TypedConfigurations::millisecondsWidth(Level level) {
+  return getConfigByRef<base::MillisecondsWidth>(level, &m_subsecondPrecisionMap, "millisecondsWidth");
+}
+
+bool TypedConfigurations::performanceTracking(Level level) {
+  return getConfigByVal<bool>(level, &m_performanceTrackingMap, "performanceTracking");
+}
+
+base::type::fstream_t* TypedConfigurations::fileStream(Level level) {
+  return getConfigByRef<base::FileStreamPtr>(level, &m_fileStreamMap, "fileStream").get();
+}
+
+std::size_t TypedConfigurations::maxLogFileSize(Level level) {
+  return getConfigByVal<std::size_t>(level, &m_maxLogFileSizeMap, "maxLogFileSize");
+}
+
+std::size_t TypedConfigurations::logFlushThreshold(Level level) {
+  return getConfigByVal<std::size_t>(level, &m_logFlushThresholdMap, "logFlushThreshold");
+}
+
+void TypedConfigurations::build(Configurations* configurations) {
+  base::threading::ScopedLock scopedLock(lock());
+  auto getBool = [] (std::string boolStr) -> bool {  // Pass by value for trimming
+    base::utils::Str::trim(boolStr);
+    return (boolStr == "TRUE" || boolStr == "true" || boolStr == "1");
+  };
+  std::vector<Configuration*> withFileSizeLimit;
+  for (Configurations::const_iterator it = configurations->begin(); it != configurations->end(); ++it) {
+    Configuration* conf = *it;
+    // We cannot use switch on strong enums because Intel C++ dont support them yet
+    if (conf->configurationType() == ConfigurationType::Enabled) {
+      setValue(conf->level(), getBool(conf->value()), &m_enabledMap);
+    } else if (conf->configurationType() == ConfigurationType::ToFile) {
+      setValue(conf->level(), getBool(conf->value()), &m_toFileMap);
+    } else if (conf->configurationType() == ConfigurationType::ToStandardOutput) {
+      setValue(conf->level(), getBool(conf->value()), &m_toStandardOutputMap);
+    } else if (conf->configurationType() == ConfigurationType::Filename) {
+      // We do not yet configure filename but we will configure in another
+      // loop. This is because if file cannot be created, we will force ToFile
+      // to be false. Because configuring logger is not necessarily performance
+      // sensative operation, we can live with another loop; (by the way this loop
+      // is not very heavy either)
+    } else if (conf->configurationType() == ConfigurationType::Format) {
+      setValue(conf->level(), base::LogFormat(conf->level(),
+                                              base::type::string_t(conf->value().begin(), conf->value().end())), &m_logFormatMap);
+    } else if (conf->configurationType() == ConfigurationType::SubsecondPrecision) {
+      setValue(Level::Global,
+               base::SubsecondPrecision(static_cast<int>(getULong(conf->value()))), &m_subsecondPrecisionMap);
+    } else if (conf->configurationType() == ConfigurationType::PerformanceTracking) {
+      setValue(Level::Global, getBool(conf->value()), &m_performanceTrackingMap);
+    } else if (conf->configurationType() == ConfigurationType::MaxLogFileSize) {
+      auto v = getULong(conf->value());
+      setValue(conf->level(), static_cast<std::size_t>(v), &m_maxLogFileSizeMap);
+      if (v != 0) {
+        withFileSizeLimit.push_back(conf);
+      }
+    } else if (conf->configurationType() == ConfigurationType::LogFlushThreshold) {
+      setValue(conf->level(), static_cast<std::size_t>(getULong(conf->value())), &m_logFlushThresholdMap);
+    }
+  }
+  // As mentioned earlier, we will now set filename configuration in separate loop to deal with non-existent files
+  for (Configurations::const_iterator it = configurations->begin(); it != configurations->end(); ++it) {
+    Configuration* conf = *it;
+    if (conf->configurationType() == ConfigurationType::Filename) {
+      insertFile(conf->level(), conf->value());
+    }
+  }
+  for (std::vector<Configuration*>::iterator conf = withFileSizeLimit.begin();
+       conf != withFileSizeLimit.end(); ++conf) {
+    // This is not unsafe as mutex is locked in currect scope
+    unsafeValidateFileRolling((*conf)->level(), base::defaultPreRollOutCallback);
+  }
+}
+
+unsigned long TypedConfigurations::getULong(std::string confVal) {
+  bool valid = true;
+  base::utils::Str::trim(confVal);
+  valid = !confVal.empty() && std::find_if(confVal.begin(), confVal.end(),
+  [](char c) {
+    return !base::utils::Str::isDigit(c);
+  }) == confVal.end();
+  if (!valid) {
+    valid = false;
+    ELPP_ASSERT(valid, "Configuration value not a valid integer [" << confVal << "]");
+    return 0;
+  }
+  return atol(confVal.c_str());
+}
+
+std::string TypedConfigurations::resolveFilename(const std::string& filename) {
+  std::string resultingFilename = filename;
+  std::size_t dateIndex = std::string::npos;
+  std::string dateTimeFormatSpecifierStr = std::string(base::consts::kDateTimeFormatSpecifierForFilename);
+  if ((dateIndex = resultingFilename.find(dateTimeFormatSpecifierStr.c_str())) != std::string::npos) {
+    while (dateIndex > 0 && resultingFilename[dateIndex - 1] == base::consts::kFormatSpecifierChar) {
+      dateIndex = resultingFilename.find(dateTimeFormatSpecifierStr.c_str(), dateIndex + 1);
+    }
+    if (dateIndex != std::string::npos) {
+      const char* ptr = resultingFilename.c_str() + dateIndex;
+      // Goto end of specifier
+      ptr += dateTimeFormatSpecifierStr.size();
+      std::string fmt;
+      if ((resultingFilename.size() > dateIndex) && (ptr[0] == '{')) {
+        // User has provided format for date/time
+        ++ptr;
+        int count = 1;  // Start by 1 in order to remove starting brace
+        std::stringstream ss;
+        for (; *ptr; ++ptr, ++count) {
+          if (*ptr == '}') {
+            ++count;  // In order to remove ending brace
+            break;
+          }
+          ss << *ptr;
+        }
+        resultingFilename.erase(dateIndex + dateTimeFormatSpecifierStr.size(), count);
+        fmt = ss.str();
+      } else {
+        fmt = std::string(base::consts::kDefaultDateTimeFormatInFilename);
+      }
+      base::SubsecondPrecision ssPrec(3);
+      std::string now = base::utils::DateTime::getDateTime(fmt.c_str(), &ssPrec);
+      base::utils::Str::replaceAll(now, '/', '-'); // Replace path element since we are dealing with filename
+      base::utils::Str::replaceAll(resultingFilename, dateTimeFormatSpecifierStr, now);
+    }
+  }
+  return resultingFilename;
+}
+
+void TypedConfigurations::insertFile(Level level, const std::string& fullFilename) {
+  std::string resolvedFilename = resolveFilename(fullFilename);
+  if (resolvedFilename.empty()) {
+    std::cerr << "Could not load empty file for logging, please re-check your configurations for level ["
+              << LevelHelper::convertToString(level) << "]";
+  }
+  std::string filePath = base::utils::File::extractPathFromFilename(resolvedFilename, base::consts::kFilePathSeperator);
+  if (filePath.size() < resolvedFilename.size()) {
+    base::utils::File::createPath(filePath);
+  }
+  auto create = [&](Level level) {
+    base::LogStreamsReferenceMap::iterator filestreamIter = m_logStreamsReference->find(resolvedFilename);
+    base::type::fstream_t* fs = nullptr;
+    if (filestreamIter == m_logStreamsReference->end()) {
+      // We need a completely new stream, nothing to share with
+      fs = base::utils::File::newFileStream(resolvedFilename);
+      m_filenameMap.insert(std::make_pair(level, resolvedFilename));
+      m_fileStreamMap.insert(std::make_pair(level, base::FileStreamPtr(fs)));
+      m_logStreamsReference->insert(std::make_pair(resolvedFilename, base::FileStreamPtr(m_fileStreamMap.at(level))));
+    } else {
+      // Woops! we have an existing one, share it!
+      m_filenameMap.insert(std::make_pair(level, filestreamIter->first));
+      m_fileStreamMap.insert(std::make_pair(level, base::FileStreamPtr(filestreamIter->second)));
+      fs = filestreamIter->second.get();
+    }
+    if (fs == nullptr) {
+      // We display bad file error from newFileStream()
+      ELPP_INTERNAL_ERROR("Setting [TO_FILE] of ["
+                          << LevelHelper::convertToString(level) << "] to FALSE", false);
+      setValue(level, false, &m_toFileMap);
+    }
+  };
+  // If we dont have file conf for any level, create it for Level::Global first
+  // otherwise create for specified level
+  create(m_filenameMap.empty() && m_fileStreamMap.empty() ? Level::Global : level);
+}
+
+bool TypedConfigurations::unsafeValidateFileRolling(Level level, const PreRollOutCallback& preRollOutCallback) {
+  base::type::fstream_t* fs = unsafeGetConfigByRef(level, &m_fileStreamMap, "fileStream").get();
+  if (fs == nullptr) {
+    return true;
+  }
+  std::size_t maxLogFileSize = unsafeGetConfigByVal(level, &m_maxLogFileSizeMap, "maxLogFileSize");
+  std::size_t currFileSize = base::utils::File::getSizeOfFile(fs);
+  if (maxLogFileSize != 0 && currFileSize >= maxLogFileSize) {
+    std::string fname = unsafeGetConfigByRef(level, &m_filenameMap, "filename");
+    ELPP_INTERNAL_INFO(1, "Truncating log file [" << fname << "] as a result of configurations for level ["
+                       << LevelHelper::convertToString(level) << "]");
+    fs->close();
+    preRollOutCallback(fname.c_str(), currFileSize, level);
+    fs->open(fname, std::fstream::out | std::fstream::trunc);
+    return true;
+  }
+  return false;
+}
+
+// RegisteredHitCounters
+
+bool RegisteredHitCounters::validateEveryN(const char* filename, base::type::LineNumber lineNumber, std::size_t n) {
+  base::threading::ScopedLock scopedLock(lock());
+  base::HitCounter* counter = get(filename, lineNumber);
+  if (counter == nullptr) {
+    registerNew(counter = new base::HitCounter(filename, lineNumber));
+  }
+  counter->validateHitCounts(n);
+  bool result = (n >= 1 && counter->hitCounts() != 0 && counter->hitCounts() % n == 0);
+  return result;
+}
+
+/// @brief Validates counter for hits >= N, i.e, registers new if does not exist otherwise updates original one
+/// @return True if validation resulted in triggering hit. Meaning logs should be written everytime true is returned
+bool RegisteredHitCounters::validateAfterN(const char* filename, base::type::LineNumber lineNumber, std::size_t n) {
+  base::threading::ScopedLock scopedLock(lock());
+  base::HitCounter* counter = get(filename, lineNumber);
+  if (counter == nullptr) {
+    registerNew(counter = new base::HitCounter(filename, lineNumber));
+  }
+  // Do not use validateHitCounts here since we do not want to reset counter here
+  // Note the >= instead of > because we are incrementing
+  // after this check
+  if (counter->hitCounts() >= n)
+    return true;
+  counter->increment();
+  return false;
+}
+
+/// @brief Validates counter for hits are <= n, i.e, registers new if does not exist otherwise updates original one
+/// @return True if validation resulted in triggering hit. Meaning logs should be written everytime true is returned
+bool RegisteredHitCounters::validateNTimes(const char* filename, base::type::LineNumber lineNumber, std::size_t n) {
+  base::threading::ScopedLock scopedLock(lock());
+  base::HitCounter* counter = get(filename, lineNumber);
+  if (counter == nullptr) {
+    registerNew(counter = new base::HitCounter(filename, lineNumber));
+  }
+  counter->increment();
+  // Do not use validateHitCounts here since we do not want to reset counter here
+  if (counter->hitCounts() <= n)
+    return true;
+  return false;
+}
+
+// RegisteredLoggers
+
+RegisteredLoggers::RegisteredLoggers(const LogBuilderPtr& defaultLogBuilder) :
+  m_defaultLogBuilder(defaultLogBuilder) {
+  m_defaultConfigurations.setToDefault();
+}
+
+Logger* RegisteredLoggers::get(const std::string& id, bool forceCreation) {
+  base::threading::ScopedLock scopedLock(lock());
+  Logger* logger_ = base::utils::Registry<Logger, std::string>::get(id);
+  if (logger_ == nullptr && forceCreation) {
+    bool validId = Logger::isValidId(id);
+    if (!validId) {
+      ELPP_ASSERT(validId, "Invalid logger ID [" << id << "]. Not registering this logger.");
+      return nullptr;
+    }
+    logger_ = new Logger(id, m_defaultConfigurations, &m_logStreamsReference);
+    logger_->m_logBuilder = m_defaultLogBuilder;
+    registerNew(id, logger_);
+    LoggerRegistrationCallback* callback = nullptr;
+    for (const std::pair<std::string, base::type::LoggerRegistrationCallbackPtr>& h
+         : m_loggerRegistrationCallbacks) {
+      callback = h.second.get();
+      if (callback != nullptr && callback->enabled()) {
+        callback->handle(logger_);
+      }
+    }
+  }
+  return logger_;
+}
+
+bool RegisteredLoggers::remove(const std::string& id) {
+  if (id == base::consts::kDefaultLoggerId) {
+    return false;
+  }
+  // get has internal lock
+  Logger* logger = base::utils::Registry<Logger, std::string>::get(id);
+  if (logger != nullptr) {
+    // unregister has internal lock
+    unregister(logger);
+  }
+  return true;
+}
+
+void RegisteredLoggers::unsafeFlushAll(void) {
+  ELPP_INTERNAL_INFO(1, "Flushing all log files");
+  for (base::LogStreamsReferenceMap::iterator it = m_logStreamsReference.begin();
+       it != m_logStreamsReference.end(); ++it) {
+    if (it->second.get() == nullptr) continue;
+    it->second->flush();
+  }
+}
+
+// VRegistry
+
+VRegistry::VRegistry(base::type::VerboseLevel level, base::type::EnumType* pFlags) : m_level(level), m_pFlags(pFlags) {
+}
+
+/// @brief Sets verbose level. Accepted range is 0-9
+void VRegistry::setLevel(base::type::VerboseLevel level) {
+  base::threading::ScopedLock scopedLock(lock());
+  if (level > 9)
+    m_level = base::consts::kMaxVerboseLevel;
+  else
+    m_level = level;
+}
+
+void VRegistry::setModules(const char* modules) {
+  base::threading::ScopedLock scopedLock(lock());
+  auto addSuffix = [](std::stringstream& ss, const char* sfx, const char* prev) {
+    if (prev != nullptr && base::utils::Str::endsWith(ss.str(), std::string(prev))) {
+      std::string chr(ss.str().substr(0, ss.str().size() - strlen(prev)));
+      ss.str(std::string(""));
+      ss << chr;
+    }
+    if (base::utils::Str::endsWith(ss.str(), std::string(sfx))) {
+      std::string chr(ss.str().substr(0, ss.str().size() - strlen(sfx)));
+      ss.str(std::string(""));
+      ss << chr;
+    }
+    ss << sfx;
+  };
+  auto insert = [&](std::stringstream& ss, base::type::VerboseLevel level) {
+    if (!base::utils::hasFlag(LoggingFlag::DisableVModulesExtensions, *m_pFlags)) {
+      addSuffix(ss, ".h", nullptr);
+      m_modules.insert(std::make_pair(ss.str(), level));
+      addSuffix(ss, ".c", ".h");
+      m_modules.insert(std::make_pair(ss.str(), level));
+      addSuffix(ss, ".cpp", ".c");
+      m_modules.insert(std::make_pair(ss.str(), level));
+      addSuffix(ss, ".cc", ".cpp");
+      m_modules.insert(std::make_pair(ss.str(), level));
+      addSuffix(ss, ".cxx", ".cc");
+      m_modules.insert(std::make_pair(ss.str(), level));
+      addSuffix(ss, ".-inl.h", ".cxx");
+      m_modules.insert(std::make_pair(ss.str(), level));
+      addSuffix(ss, ".hxx", ".-inl.h");
+      m_modules.insert(std::make_pair(ss.str(), level));
+      addSuffix(ss, ".hpp", ".hxx");
+      m_modules.insert(std::make_pair(ss.str(), level));
+      addSuffix(ss, ".hh", ".hpp");
+    }
+    m_modules.insert(std::make_pair(ss.str(), level));
+  };
+  bool isMod = true;
+  bool isLevel = false;
+  std::stringstream ss;
+  int level = -1;
+  for (; *modules; ++modules) {
+    switch (*modules) {
+    case '=':
+      isLevel = true;
+      isMod = false;
+      break;
+    case ',':
+      isLevel = false;
+      isMod = true;
+      if (!ss.str().empty() && level != -1) {
+        insert(ss, static_cast<base::type::VerboseLevel>(level));
+        ss.str(std::string(""));
+        level = -1;
+      }
+      break;
+    default:
+      if (isMod) {
+        ss << *modules;
+      } else if (isLevel) {
+        if (isdigit(*modules)) {
+          level = static_cast<base::type::VerboseLevel>(*modules) - 48;
+        }
+      }
+      break;
+    }
+  }
+  if (!ss.str().empty() && level != -1) {
+    insert(ss, static_cast<base::type::VerboseLevel>(level));
+  }
+}
+
+bool VRegistry::allowed(base::type::VerboseLevel vlevel, const char* file) {
+  base::threading::ScopedLock scopedLock(lock());
+  if (m_modules.empty() || file == nullptr) {
+    return vlevel <= m_level;
+  } else {
+    char baseFilename[base::consts::kSourceFilenameMaxLength] = "";
+    base::utils::File::buildBaseFilename(file, baseFilename);
+    std::unordered_map<std::string, base::type::VerboseLevel>::iterator it = m_modules.begin();
+    for (; it != m_modules.end(); ++it) {
+      if (base::utils::Str::wildCardMatch(baseFilename, it->first.c_str())) {
+        return vlevel <= it->second;
+      }
+    }
+    if (base::utils::hasFlag(LoggingFlag::AllowVerboseIfModuleNotSpecified, *m_pFlags)) {
+      return true;
+    }
+    return false;
+  }
+}
+
+void VRegistry::setFromArgs(const base::utils::CommandLineArgs* commandLineArgs) {
+  if (commandLineArgs->hasParam("-v") || commandLineArgs->hasParam("--verbose") ||
+      commandLineArgs->hasParam("-V") || commandLineArgs->hasParam("--VERBOSE")) {
+    setLevel(base::consts::kMaxVerboseLevel);
+  } else if (commandLineArgs->hasParamWithValue("--v")) {
+    setLevel(static_cast<base::type::VerboseLevel>(atoi(commandLineArgs->getParamValue("--v"))));
+  } else if (commandLineArgs->hasParamWithValue("--V")) {
+    setLevel(static_cast<base::type::VerboseLevel>(atoi(commandLineArgs->getParamValue("--V"))));
+  } else if ((commandLineArgs->hasParamWithValue("-vmodule")) && vModulesEnabled()) {
+    setModules(commandLineArgs->getParamValue("-vmodule"));
+  } else if (commandLineArgs->hasParamWithValue("-VMODULE") && vModulesEnabled()) {
+    setModules(commandLineArgs->getParamValue("-VMODULE"));
+  }
+}
+
+#if !defined(ELPP_DEFAULT_LOGGING_FLAGS)
+#   define ELPP_DEFAULT_LOGGING_FLAGS 0x0
+#endif // !defined(ELPP_DEFAULT_LOGGING_FLAGS)
+// Storage
+#if ELPP_ASYNC_LOGGING
+Storage::Storage(const LogBuilderPtr& defaultLogBuilder, base::IWorker* asyncDispatchWorker) :
+#else
+Storage::Storage(const LogBuilderPtr& defaultLogBuilder) :
+#endif  // ELPP_ASYNC_LOGGING
+  m_registeredHitCounters(new base::RegisteredHitCounters()),
+  m_registeredLoggers(new base::RegisteredLoggers(defaultLogBuilder)),
+  m_flags(ELPP_DEFAULT_LOGGING_FLAGS),
+  m_vRegistry(new base::VRegistry(0, &m_flags)),
+
+#if ELPP_ASYNC_LOGGING
+  m_asyncLogQueue(new base::AsyncLogQueue()),
+  m_asyncDispatchWorker(asyncDispatchWorker),
+#endif  // ELPP_ASYNC_LOGGING
+
+  m_preRollOutCallback(base::defaultPreRollOutCallback) {
+  // Register default logger
+  m_registeredLoggers->get(std::string(base::consts::kDefaultLoggerId));
+  // We register default logger anyway (worse case it's not going to register) just in case
+  m_registeredLoggers->get("default");
+
+#if defined(ELPP_FEATURE_ALL) || defined(ELPP_FEATURE_PERFORMANCE_TRACKING)
+  // Register performance logger and reconfigure format
+  Logger* performanceLogger = m_registeredLoggers->get(std::string(base::consts::kPerformanceLoggerId));
+  m_registeredLoggers->get("performance");
+  performanceLogger->configurations()->setGlobally(ConfigurationType::Format, std::string("%datetime %level %msg"));
+  performanceLogger->reconfigure();
+#endif // defined(ELPP_FEATURE_ALL) || defined(ELPP_FEATURE_PERFORMANCE_TRACKING)
+
+#if defined(ELPP_SYSLOG)
+  // Register syslog logger and reconfigure format
+  Logger* sysLogLogger = m_registeredLoggers->get(std::string(base::consts::kSysLogLoggerId));
+  sysLogLogger->configurations()->setGlobally(ConfigurationType::Format, std::string("%level: %msg"));
+  sysLogLogger->reconfigure();
+#endif //  defined(ELPP_SYSLOG)
+  addFlag(LoggingFlag::AllowVerboseIfModuleNotSpecified);
+#if ELPP_ASYNC_LOGGING
+  installLogDispatchCallback<base::AsyncLogDispatchCallback>(std::string("AsyncLogDispatchCallback"));
+#else
+  installLogDispatchCallback<base::DefaultLogDispatchCallback>(std::string("DefaultLogDispatchCallback"));
+#endif  // ELPP_ASYNC_LOGGING
+#if defined(ELPP_FEATURE_ALL) || defined(ELPP_FEATURE_PERFORMANCE_TRACKING)
+  installPerformanceTrackingCallback<base::DefaultPerformanceTrackingCallback>
+  (std::string("DefaultPerformanceTrackingCallback"));
+#endif // defined(ELPP_FEATURE_ALL) || defined(ELPP_FEATURE_PERFORMANCE_TRACKING)
+  ELPP_INTERNAL_INFO(1, "Easylogging++ has been initialized");
+#if ELPP_ASYNC_LOGGING
+  m_asyncDispatchWorker->start();
+#endif  // ELPP_ASYNC_LOGGING
+}
+
+Storage::~Storage(void) {
+  ELPP_INTERNAL_INFO(4, "Destroying storage");
+#if ELPP_ASYNC_LOGGING
+  ELPP_INTERNAL_INFO(5, "Replacing log dispatch callback to synchronous");
+  uninstallLogDispatchCallback<base::AsyncLogDispatchCallback>(std::string("AsyncLogDispatchCallback"));
+  installLogDispatchCallback<base::DefaultLogDispatchCallback>(std::string("DefaultLogDispatchCallback"));
+  ELPP_INTERNAL_INFO(5, "Destroying asyncDispatchWorker");
+  base::utils::safeDelete(m_asyncDispatchWorker);
+  ELPP_INTERNAL_INFO(5, "Destroying asyncLogQueue");
+  base::utils::safeDelete(m_asyncLogQueue);
+#endif  // ELPP_ASYNC_LOGGING
+  ELPP_INTERNAL_INFO(5, "Destroying registeredHitCounters");
+  base::utils::safeDelete(m_registeredHitCounters);
+  ELPP_INTERNAL_INFO(5, "Destroying registeredLoggers");
+  base::utils::safeDelete(m_registeredLoggers);
+  ELPP_INTERNAL_INFO(5, "Destroying vRegistry");
+  base::utils::safeDelete(m_vRegistry);
+}
+
+bool Storage::hasCustomFormatSpecifier(const char* formatSpecifier) {
+  base::threading::ScopedLock scopedLock(customFormatSpecifiersLock());
+  return std::find(m_customFormatSpecifiers.begin(), m_customFormatSpecifiers.end(),
+                   formatSpecifier) != m_customFormatSpecifiers.end();
+}
+
+void Storage::installCustomFormatSpecifier(const CustomFormatSpecifier& customFormatSpecifier) {
+  if (hasCustomFormatSpecifier(customFormatSpecifier.formatSpecifier())) {
+    return;
+  }
+  base::threading::ScopedLock scopedLock(customFormatSpecifiersLock());
+  m_customFormatSpecifiers.push_back(customFormatSpecifier);
+}
+
+bool Storage::uninstallCustomFormatSpecifier(const char* formatSpecifier) {
+  base::threading::ScopedLock scopedLock(customFormatSpecifiersLock());
+  std::vector<CustomFormatSpecifier>::iterator it = std::find(m_customFormatSpecifiers.begin(),
+      m_customFormatSpecifiers.end(), formatSpecifier);
+  if (it != m_customFormatSpecifiers.end() && strcmp(formatSpecifier, it->formatSpecifier()) == 0) {
+    m_customFormatSpecifiers.erase(it);
+    return true;
+  }
+  return false;
+}
+
+void Storage::setApplicationArguments(int argc, char** argv) {
+  m_commandLineArgs.setArgs(argc, argv);
+  m_vRegistry->setFromArgs(commandLineArgs());
+  // default log file
+#if !defined(ELPP_DISABLE_LOG_FILE_FROM_ARG)
+  if (m_commandLineArgs.hasParamWithValue(base::consts::kDefaultLogFileParam)) {
+    Configurations c;
+    c.setGlobally(ConfigurationType::Filename,
+                  std::string(m_commandLineArgs.getParamValue(base::consts::kDefaultLogFileParam)));
+    registeredLoggers()->setDefaultConfigurations(c);
+    for (base::RegisteredLoggers::iterator it = registeredLoggers()->begin();
+         it != registeredLoggers()->end(); ++it) {
+      it->second->configure(c);
+    }
+  }
+#endif  // !defined(ELPP_DISABLE_LOG_FILE_FROM_ARG)
+#if defined(ELPP_LOGGING_FLAGS_FROM_ARG)
+  if (m_commandLineArgs.hasParamWithValue(base::consts::kLoggingFlagsParam)) {
+    int userInput = atoi(m_commandLineArgs.getParamValue(base::consts::kLoggingFlagsParam));
+    if (ELPP_DEFAULT_LOGGING_FLAGS == 0x0) {
+      m_flags = userInput;
+    } else {
+      base::utils::addFlag<base::type::EnumType>(userInput, &m_flags);
+    }
+  }
+#endif  // defined(ELPP_LOGGING_FLAGS_FROM_ARG)
+}
+
+} // namespace base
+
+// LogDispatchCallback
+void LogDispatchCallback::handle(const LogDispatchData* data) {
+#if defined(ELPP_THREAD_SAFE)
+  base::threading::ScopedLock scopedLock(m_fileLocksMapLock);
+  std::string filename = data->logMessage()->logger()->typedConfigurations()->filename(data->logMessage()->level());
+  auto lock = m_fileLocks.find(filename);
+  if (lock == m_fileLocks.end()) {
+    m_fileLocks.emplace(std::make_pair(filename, std::unique_ptr<base::threading::Mutex>(new base::threading::Mutex)));
+  }
+#endif
+}
+
+base::threading::Mutex& LogDispatchCallback::fileHandle(const LogDispatchData* data) {
+  auto it = m_fileLocks.find(data->logMessage()->logger()->typedConfigurations()->filename(data->logMessage()->level()));
+  return *(it->second.get());
+}
+
+namespace base {
+// DefaultLogDispatchCallback
+
+void DefaultLogDispatchCallback::handle(const LogDispatchData* data) {
+#if defined(ELPP_THREAD_SAFE)
+  LogDispatchCallback::handle(data);
+  base::threading::ScopedLock scopedLock(fileHandle(data));
+#endif
+  m_data = data;
+  dispatch(m_data->logMessage()->logger()->logBuilder()->build(m_data->logMessage(),
+           m_data->dispatchAction() == base::DispatchAction::NormalLog));
+}
+
+void DefaultLogDispatchCallback::dispatch(base::type::string_t&& logLine) {
+  if (m_data->dispatchAction() == base::DispatchAction::NormalLog) {
+    if (m_data->logMessage()->logger()->m_typedConfigurations->toFile(m_data->logMessage()->level())) {
+      base::type::fstream_t* fs = m_data->logMessage()->logger()->m_typedConfigurations->fileStream(
+                                    m_data->logMessage()->level());
+      if (fs != nullptr) {
+        fs->write(logLine.c_str(), logLine.size());
+        if (fs->fail()) {
+          ELPP_INTERNAL_ERROR("Unable to write log to file ["
+                              << m_data->logMessage()->logger()->m_typedConfigurations->filename(m_data->logMessage()->level()) << "].\n"
+                              << "Few possible reasons (could be something else):\n" << "      * Permission denied\n"
+                              << "      * Disk full\n" << "      * Disk is not writable", true);
+        } else {
+          if (ELPP->hasFlag(LoggingFlag::ImmediateFlush)
+              || (m_data->logMessage()->logger()->isFlushNeeded(m_data->logMessage()->level()))) {
+            m_data->logMessage()->logger()->flush(m_data->logMessage()->level(), fs);
+          }
+        }
+      } else {
+        ELPP_INTERNAL_ERROR("Log file for [" << LevelHelper::convertToString(m_data->logMessage()->level()) << "] "
+                            << "has not been configured but [TO_FILE] is configured to TRUE. [Logger ID: "
+                            << m_data->logMessage()->logger()->id() << "]", false);
+      }
+    }
+    if (m_data->logMessage()->logger()->m_typedConfigurations->toStandardOutput(m_data->logMessage()->level())) {
+      if (ELPP->hasFlag(LoggingFlag::ColoredTerminalOutput))
+        m_data->logMessage()->logger()->logBuilder()->convertToColoredOutput(&logLine, m_data->logMessage()->level());
+      ELPP_COUT << ELPP_COUT_LINE(logLine);
+    }
+  }
+#if defined(ELPP_SYSLOG)
+  else if (m_data->dispatchAction() == base::DispatchAction::SysLog) {
+    // Determine syslog priority
+    int sysLogPriority = 0;
+    if (m_data->logMessage()->level() == Level::Fatal)
+      sysLogPriority = LOG_EMERG;
+    else if (m_data->logMessage()->level() == Level::Error)
+      sysLogPriority = LOG_ERR;
+    else if (m_data->logMessage()->level() == Level::Warning)
+      sysLogPriority = LOG_WARNING;
+    else if (m_data->logMessage()->level() == Level::Info)
+      sysLogPriority = LOG_INFO;
+    else if (m_data->logMessage()->level() == Level::Debug)
+      sysLogPriority = LOG_DEBUG;
+    else
+      sysLogPriority = LOG_NOTICE;
+#  if defined(ELPP_UNICODE)
+    char* line = base::utils::Str::wcharPtrToCharPtr(logLine.c_str());
+    syslog(sysLogPriority, "%s", line);
+    free(line);
+#  else
+    syslog(sysLogPriority, "%s", logLine.c_str());
+#  endif
+  }
+#endif  // defined(ELPP_SYSLOG)
+}
+
+#if ELPP_ASYNC_LOGGING
+
+// AsyncLogDispatchCallback
+
+void AsyncLogDispatchCallback::handle(const LogDispatchData* data) {
+  base::type::string_t logLine = data->logMessage()->logger()->logBuilder()->build(data->logMessage(),
+                                 data->dispatchAction() == base::DispatchAction::NormalLog);
+  if (data->dispatchAction() == base::DispatchAction::NormalLog
+      && data->logMessage()->logger()->typedConfigurations()->toStandardOutput(data->logMessage()->level())) {
+    if (ELPP->hasFlag(LoggingFlag::ColoredTerminalOutput))
+      data->logMessage()->logger()->logBuilder()->convertToColoredOutput(&logLine, data->logMessage()->level());
+    ELPP_COUT << ELPP_COUT_LINE(logLine);
+  }
+  // Save resources and only queue if we want to write to file otherwise just ignore handler
+  if (data->logMessage()->logger()->typedConfigurations()->toFile(data->logMessage()->level())) {
+    ELPP->asyncLogQueue()->push(AsyncLogItem(*(data->logMessage()), *data, logLine));
+  }
+}
+
+// AsyncDispatchWorker
+AsyncDispatchWorker::AsyncDispatchWorker() {
+  setContinueRunning(false);
+}
+
+AsyncDispatchWorker::~AsyncDispatchWorker() {
+  setContinueRunning(false);
+  ELPP_INTERNAL_INFO(6, "Stopping dispatch worker - Cleaning log queue");
+  clean();
+  ELPP_INTERNAL_INFO(6, "Log queue cleaned");
+}
+
+bool AsyncDispatchWorker::clean(void) {
+  std::mutex m;
+  std::unique_lock<std::mutex> lk(m);
+  cv.wait(lk, [] { return !ELPP->asyncLogQueue()->empty(); });
+  emptyQueue();
+  lk.unlock();
+  cv.notify_one();
+  return ELPP->asyncLogQueue()->empty();
+}
+
+void AsyncDispatchWorker::emptyQueue(void) {
+  while (!ELPP->asyncLogQueue()->empty()) {
+    AsyncLogItem data = ELPP->asyncLogQueue()->next();
+    handle(&data);
+    base::threading::msleep(100);
+  }
+}
+
+void AsyncDispatchWorker::start(void) {
+  base::threading::msleep(5000); // 5s (why?)
+  setContinueRunning(true);
+  std::thread t1(&AsyncDispatchWorker::run, this);
+  t1.join();
+}
+
+void AsyncDispatchWorker::handle(AsyncLogItem* logItem) {
+  LogDispatchData* data = logItem->data();
+  LogMessage* logMessage = logItem->logMessage();
+  Logger* logger = logMessage->logger();
+  base::TypedConfigurations* conf = logger->typedConfigurations();
+  base::type::string_t logLine = logItem->logLine();
+  if (data->dispatchAction() == base::DispatchAction::NormalLog) {
+    if (conf->toFile(logMessage->level())) {
+      base::type::fstream_t* fs = conf->fileStream(logMessage->level());
+      if (fs != nullptr) {
+        fs->write(logLine.c_str(), logLine.size());
+        if (fs->fail()) {
+          ELPP_INTERNAL_ERROR("Unable to write log to file ["
+                              << conf->filename(logMessage->level()) << "].\n"
+                              << "Few possible reasons (could be something else):\n" << "      * Permission denied\n"
+                              << "      * Disk full\n" << "      * Disk is not writable", true);
+        } else {
+          if (ELPP->hasFlag(LoggingFlag::ImmediateFlush) || (logger->isFlushNeeded(logMessage->level()))) {
+            logger->flush(logMessage->level(), fs);
+          }
+        }
+      } else {
+        ELPP_INTERNAL_ERROR("Log file for [" << LevelHelper::convertToString(logMessage->level()) << "] "
+                            << "has not been configured but [TO_FILE] is configured to TRUE. [Logger ID: " << logger->id() << "]", false);
+      }
+    }
+  }
+#  if defined(ELPP_SYSLOG)
+  else if (data->dispatchAction() == base::DispatchAction::SysLog) {
+    // Determine syslog priority
+    int sysLogPriority = 0;
+    if (logMessage->level() == Level::Fatal)
+      sysLogPriority = LOG_EMERG;
+    else if (logMessage->level() == Level::Error)
+      sysLogPriority = LOG_ERR;
+    else if (logMessage->level() == Level::Warning)
+      sysLogPriority = LOG_WARNING;
+    else if (logMessage->level() == Level::Info)
+      sysLogPriority = LOG_INFO;
+    else if (logMessage->level() == Level::Debug)
+      sysLogPriority = LOG_DEBUG;
+    else
+      sysLogPriority = LOG_NOTICE;
+#      if defined(ELPP_UNICODE)
+    char* line = base::utils::Str::wcharPtrToCharPtr(logLine.c_str());
+    syslog(sysLogPriority, "%s", line);
+    free(line);
+#      else
+    syslog(sysLogPriority, "%s", logLine.c_str());
+#      endif
+  }
+#  endif  // defined(ELPP_SYSLOG)
+}
+
+void AsyncDispatchWorker::run(void) {
+  while (continueRunning()) {
+    emptyQueue();
+    base::threading::msleep(10); // 10ms
+  }
+}
+#endif  // ELPP_ASYNC_LOGGING
+
+// DefaultLogBuilder
+
+base::type::string_t DefaultLogBuilder::build(const LogMessage* logMessage, bool appendNewLine) const {
+  base::TypedConfigurations* tc = logMessage->logger()->typedConfigurations();
+  const base::LogFormat* logFormat = &tc->logFormat(logMessage->level());
+  base::type::string_t logLine = logFormat->format();
+  char buff[base::consts::kSourceFilenameMaxLength + base::consts::kSourceLineMaxLength] = "";
+  const char* bufLim = buff + sizeof(buff);
+  if (logFormat->hasFlag(base::FormatFlags::AppName)) {
+    // App name
+    base::utils::Str::replaceFirstWithEscape(logLine, base::consts::kAppNameFormatSpecifier,
+        logMessage->logger()->parentApplicationName());
+  }
+  if (logFormat->hasFlag(base::FormatFlags::ThreadId)) {
+    // Thread ID
+    base::utils::Str::replaceFirstWithEscape(logLine, base::consts::kThreadIdFormatSpecifier,
+        ELPP->getThreadName(base::threading::getCurrentThreadId()));
+  }
+  if (logFormat->hasFlag(base::FormatFlags::DateTime)) {
+    // DateTime
+    base::utils::Str::replaceFirstWithEscape(logLine, base::consts::kDateTimeFormatSpecifier,
+        base::utils::DateTime::getDateTime(logFormat->dateTimeFormat().c_str(),
+                                           &tc->subsecondPrecision(logMessage->level())));
+  }
+  if (logFormat->hasFlag(base::FormatFlags::Function)) {
+    // Function
+    base::utils::Str::replaceFirstWithEscape(logLine, base::consts::kLogFunctionFormatSpecifier, logMessage->func());
+  }
+  if (logFormat->hasFlag(base::FormatFlags::File)) {
+    // File
+    base::utils::Str::clearBuff(buff, base::consts::kSourceFilenameMaxLength);
+    base::utils::File::buildStrippedFilename(logMessage->file().c_str(), buff);
+    base::utils::Str::replaceFirstWithEscape(logLine, base::consts::kLogFileFormatSpecifier, std::string(buff));
+  }
+  if (logFormat->hasFlag(base::FormatFlags::FileBase)) {
+    // FileBase
+    base::utils::Str::clearBuff(buff, base::consts::kSourceFilenameMaxLength);
+    base::utils::File::buildBaseFilename(logMessage->file(), buff);
+    base::utils::Str::replaceFirstWithEscape(logLine, base::consts::kLogFileBaseFormatSpecifier, std::string(buff));
+  }
+  if (logFormat->hasFlag(base::FormatFlags::Line)) {
+    // Line
+    char* buf = base::utils::Str::clearBuff(buff, base::consts::kSourceLineMaxLength);
+    buf = base::utils::Str::convertAndAddToBuff(logMessage->line(), base::consts::kSourceLineMaxLength, buf, bufLim, false);
+    base::utils::Str::replaceFirstWithEscape(logLine, base::consts::kLogLineFormatSpecifier, std::string(buff));
+  }
+  if (logFormat->hasFlag(base::FormatFlags::Location)) {
+    // Location
+    char* buf = base::utils::Str::clearBuff(buff,
+                                            base::consts::kSourceFilenameMaxLength + base::consts::kSourceLineMaxLength);
+    base::utils::File::buildStrippedFilename(logMessage->file().c_str(), buff);
+    buf = base::utils::Str::addToBuff(buff, buf, bufLim);
+    buf = base::utils::Str::addToBuff(":", buf, bufLim);
+    buf = base::utils::Str::convertAndAddToBuff(logMessage->line(),  base::consts::kSourceLineMaxLength, buf, bufLim,
+          false);
+    base::utils::Str::replaceFirstWithEscape(logLine, base::consts::kLogLocationFormatSpecifier, std::string(buff));
+  }
+  if (logMessage->level() == Level::Verbose && logFormat->hasFlag(base::FormatFlags::VerboseLevel)) {
+    // Verbose level
+    char* buf = base::utils::Str::clearBuff(buff, 1);
+    buf = base::utils::Str::convertAndAddToBuff(logMessage->verboseLevel(), 1, buf, bufLim, false);
+    base::utils::Str::replaceFirstWithEscape(logLine, base::consts::kVerboseLevelFormatSpecifier, std::string(buff));
+  }
+  if (logFormat->hasFlag(base::FormatFlags::LogMessage)) {
+    // Log message
+    base::utils::Str::replaceFirstWithEscape(logLine, base::consts::kMessageFormatSpecifier, logMessage->message());
+  }
+#if !defined(ELPP_DISABLE_CUSTOM_FORMAT_SPECIFIERS)
+  el::base::threading::ScopedLock lock_(ELPP->customFormatSpecifiersLock());
+  ELPP_UNUSED(lock_);
+  for (std::vector<CustomFormatSpecifier>::const_iterator it = ELPP->customFormatSpecifiers()->begin();
+       it != ELPP->customFormatSpecifiers()->end(); ++it) {
+    std::string fs(it->formatSpecifier());
+    base::type::string_t wcsFormatSpecifier(fs.begin(), fs.end());
+    base::utils::Str::replaceFirstWithEscape(logLine, wcsFormatSpecifier, it->resolver()(logMessage));
+  }
+#endif  // !defined(ELPP_DISABLE_CUSTOM_FORMAT_SPECIFIERS)
+  if (appendNewLine) logLine += ELPP_LITERAL("\n");
+  return logLine;
+}
+
+// LogDispatcher
+
+void LogDispatcher::dispatch(void) {
+  if (m_proceed && m_dispatchAction == base::DispatchAction::None) {
+    m_proceed = false;
+  }
+  if (!m_proceed) {
+    return;
+  }
+#ifndef ELPP_NO_GLOBAL_LOCK
+  // see https://github.com/muflihun/easyloggingpp/issues/580
+  // global lock is turned off by default unless
+  // ELPP_NO_GLOBAL_LOCK is defined
+  base::threading::ScopedLock scopedLock(ELPP->lock());
+#endif
+  base::TypedConfigurations* tc = m_logMessage->logger()->m_typedConfigurations;
+  if (ELPP->hasFlag(LoggingFlag::StrictLogFileSizeCheck)) {
+    tc->validateFileRolling(m_logMessage->level(), ELPP->preRollOutCallback());
+  }
+  LogDispatchCallback* callback = nullptr;
+  LogDispatchData data;
+  for (const std::pair<std::string, base::type::LogDispatchCallbackPtr>& h
+       : ELPP->m_logDispatchCallbacks) {
+    callback = h.second.get();
+    if (callback != nullptr && callback->enabled()) {
+      data.setLogMessage(m_logMessage);
+      data.setDispatchAction(m_dispatchAction);
+      callback->handle(&data);
+    }
+  }
+}
+
+// MessageBuilder
+
+void MessageBuilder::initialize(Logger* logger) {
+  m_logger = logger;
+  m_containerLogSeperator = ELPP->hasFlag(LoggingFlag::NewLineForContainer) ?
+                            ELPP_LITERAL("\n    ") : ELPP_LITERAL(", ");
+}
+
+MessageBuilder& MessageBuilder::operator<<(const wchar_t* msg) {
+  if (msg == nullptr) {
+    m_logger->stream() << base::consts::kNullPointer;
+    return *this;
+  }
+#  if defined(ELPP_UNICODE)
+  m_logger->stream() << msg;
+#  else
+  char* buff_ = base::utils::Str::wcharPtrToCharPtr(msg);
+  m_logger->stream() << buff_;
+  free(buff_);
+#  endif
+  if (ELPP->hasFlag(LoggingFlag::AutoSpacing)) {
+    m_logger->stream() << " ";
+  }
+  return *this;
+}
+
+// Writer
+
+Writer& Writer::construct(Logger* logger, bool needLock) {
+  m_logger = logger;
+  initializeLogger(logger->id(), false, needLock);
+  m_messageBuilder.initialize(m_logger);
+  return *this;
+}
+
+Writer& Writer::construct(int count, const char* loggerIds, ...) {
+  if (ELPP->hasFlag(LoggingFlag::MultiLoggerSupport)) {
+    va_list loggersList;
+    va_start(loggersList, loggerIds);
+    const char* id = loggerIds;
+    m_loggerIds.reserve(count);
+    for (int i = 0; i < count; ++i) {
+      m_loggerIds.push_back(std::string(id));
+      id = va_arg(loggersList, const char*);
+    }
+    va_end(loggersList);
+    initializeLogger(m_loggerIds.at(0));
+  } else {
+    initializeLogger(std::string(loggerIds));
+  }
+  m_messageBuilder.initialize(m_logger);
+  return *this;
+}
+
+void Writer::initializeLogger(const std::string& loggerId, bool lookup, bool needLock) {
+  if (lookup) {
+    m_logger = ELPP->registeredLoggers()->get(loggerId, ELPP->hasFlag(LoggingFlag::CreateLoggerAutomatically));
+  }
+  if (m_logger == nullptr) {
+    {
+      if (!ELPP->registeredLoggers()->has(std::string(base::consts::kDefaultLoggerId))) {
+        // Somehow default logger has been unregistered. Not good! Register again
+        ELPP->registeredLoggers()->get(std::string(base::consts::kDefaultLoggerId));
+      }
+    }
+    Writer(Level::Debug, m_file, m_line, m_func).construct(1, base::consts::kDefaultLoggerId)
+        << "Logger [" << loggerId << "] is not registered yet!";
+    m_proceed = false;
+  } else {
+    if (needLock) {
+      m_logger->acquireLock();  // This should not be unlocked by checking m_proceed because
+      // m_proceed can be changed by lines below
+    }
+    if (ELPP->hasFlag(LoggingFlag::HierarchicalLogging)) {
+      m_proceed = m_level == Level::Verbose ? m_logger->enabled(m_level) :
+                  LevelHelper::castToInt(m_level) >= LevelHelper::castToInt(ELPP->m_loggingLevel);
+    } else {
+      m_proceed = m_logger->enabled(m_level);
+    }
+  }
+}
+
+void Writer::processDispatch() {
+#if ELPP_LOGGING_ENABLED
+  if (ELPP->hasFlag(LoggingFlag::MultiLoggerSupport)) {
+    bool firstDispatched = false;
+    base::type::string_t logMessage;
+    std::size_t i = 0;
+    do {
+      if (m_proceed) {
+        if (firstDispatched) {
+          m_logger->stream() << logMessage;
+        } else {
+          firstDispatched = true;
+          if (m_loggerIds.size() > 1) {
+            logMessage = m_logger->stream().str();
+          }
+        }
+        triggerDispatch();
+      } else if (m_logger != nullptr) {
+        m_logger->stream().str(ELPP_LITERAL(""));
+        m_logger->releaseLock();
+      }
+      if (i + 1 < m_loggerIds.size()) {
+        initializeLogger(m_loggerIds.at(i + 1));
+      }
+    } while (++i < m_loggerIds.size());
+  } else {
+    if (m_proceed) {
+      triggerDispatch();
+    } else if (m_logger != nullptr) {
+      m_logger->stream().str(ELPP_LITERAL(""));
+      m_logger->releaseLock();
+    }
+  }
+#else
+  if (m_logger != nullptr) {
+    m_logger->stream().str(ELPP_LITERAL(""));
+    m_logger->releaseLock();
+  }
+#endif // ELPP_LOGGING_ENABLED
+}
+
+void Writer::triggerDispatch(void) {
+  if (m_proceed) {
+    if (m_msg == nullptr) {
+      LogMessage msg(m_level, m_file, m_line, m_func, m_verboseLevel,
+                     m_logger);
+      base::LogDispatcher(m_proceed, &msg, m_dispatchAction).dispatch();
+    } else {
+      base::LogDispatcher(m_proceed, m_msg, m_dispatchAction).dispatch();
+    }
+  }
+  if (m_logger != nullptr) {
+    m_logger->stream().str(ELPP_LITERAL(""));
+    m_logger->releaseLock();
+  }
+  if (m_proceed && m_level == Level::Fatal
+      && !ELPP->hasFlag(LoggingFlag::DisableApplicationAbortOnFatalLog)) {
+    base::Writer(Level::Warning, m_file, m_line, m_func).construct(1, base::consts::kDefaultLoggerId)
+        << "Aborting application. Reason: Fatal log at [" << m_file << ":" << m_line << "]";
+    std::stringstream reasonStream;
+    reasonStream << "Fatal log at [" << m_file << ":" << m_line << "]"
+                 << " If you wish to disable 'abort on fatal log' please use "
+                 << "el::Loggers::addFlag(el::LoggingFlag::DisableApplicationAbortOnFatalLog)";
+    base::utils::abort(1, reasonStream.str());
+  }
+  m_proceed = false;
+}
+
+// PErrorWriter
+
+PErrorWriter::~PErrorWriter(void) {
+  if (m_proceed) {
+#if ELPP_COMPILER_MSVC
+    char buff[256];
+    strerror_s(buff, 256, errno);
+    m_logger->stream() << ": " << buff << " [" << errno << "]";
+#else
+    m_logger->stream() << ": " << strerror(errno) << " [" << errno << "]";
+#endif
+  }
+}
+
+// PerformanceTracker
+
+#if defined(ELPP_FEATURE_ALL) || defined(ELPP_FEATURE_PERFORMANCE_TRACKING)
+
+PerformanceTracker::PerformanceTracker(const std::string& blockName,
+                                       base::TimestampUnit timestampUnit,
+                                       const std::string& loggerId,
+                                       bool scopedLog, Level level) :
+  m_blockName(blockName), m_timestampUnit(timestampUnit), m_loggerId(loggerId), m_scopedLog(scopedLog),
+  m_level(level), m_hasChecked(false), m_lastCheckpointId(std::string()), m_enabled(false) {
+#if !defined(ELPP_DISABLE_PERFORMANCE_TRACKING) && ELPP_LOGGING_ENABLED
+  // We store it locally so that if user happen to change configuration by the end of scope
+  // or before calling checkpoint, we still depend on state of configuraton at time of construction
+  el::Logger* loggerPtr = ELPP->registeredLoggers()->get(loggerId, false);
+  m_enabled = loggerPtr != nullptr && loggerPtr->m_typedConfigurations->performanceTracking(m_level);
+  if (m_enabled) {
+    base::utils::DateTime::gettimeofday(&m_startTime);
+  }
+#endif  // !defined(ELPP_DISABLE_PERFORMANCE_TRACKING) && ELPP_LOGGING_ENABLED
+}
+
+PerformanceTracker::~PerformanceTracker(void) {
+#if !defined(ELPP_DISABLE_PERFORMANCE_TRACKING) && ELPP_LOGGING_ENABLED
+  if (m_enabled) {
+    base::threading::ScopedLock scopedLock(lock());
+    if (m_scopedLog) {
+      base::utils::DateTime::gettimeofday(&m_endTime);
+      base::type::string_t formattedTime = getFormattedTimeTaken();
+      PerformanceTrackingData data(PerformanceTrackingData::DataType::Complete);
+      data.init(this);
+      data.m_formattedTimeTaken = formattedTime;
+      PerformanceTrackingCallback* callback = nullptr;
+      for (const std::pair<std::string, base::type::PerformanceTrackingCallbackPtr>& h
+           : ELPP->m_performanceTrackingCallbacks) {
+        callback = h.second.get();
+        if (callback != nullptr && callback->enabled()) {
+          callback->handle(&data);
+        }
+      }
+    }
+  }
+#endif  // !defined(ELPP_DISABLE_PERFORMANCE_TRACKING)
+}
+
+void PerformanceTracker::checkpoint(const std::string& id, const char* file, base::type::LineNumber line,
+                                    const char* func) {
+#if !defined(ELPP_DISABLE_PERFORMANCE_TRACKING) && ELPP_LOGGING_ENABLED
+  if (m_enabled) {
+    base::threading::ScopedLock scopedLock(lock());
+    base::utils::DateTime::gettimeofday(&m_endTime);
+    base::type::string_t formattedTime = m_hasChecked ? getFormattedTimeTaken(m_lastCheckpointTime) : ELPP_LITERAL("");
+    PerformanceTrackingData data(PerformanceTrackingData::DataType::Checkpoint);
+    data.init(this);
+    data.m_checkpointId = id;
+    data.m_file = file;
+    data.m_line = line;
+    data.m_func = func;
+    data.m_formattedTimeTaken = formattedTime;
+    PerformanceTrackingCallback* callback = nullptr;
+    for (const std::pair<std::string, base::type::PerformanceTrackingCallbackPtr>& h
+         : ELPP->m_performanceTrackingCallbacks) {
+      callback = h.second.get();
+      if (callback != nullptr && callback->enabled()) {
+        callback->handle(&data);
+      }
+    }
+    base::utils::DateTime::gettimeofday(&m_lastCheckpointTime);
+    m_hasChecked = true;
+    m_lastCheckpointId = id;
+  }
+#endif  // !defined(ELPP_DISABLE_PERFORMANCE_TRACKING) && ELPP_LOGGING_ENABLED
+  ELPP_UNUSED(id);
+  ELPP_UNUSED(file);
+  ELPP_UNUSED(line);
+  ELPP_UNUSED(func);
+}
+
+const base::type::string_t PerformanceTracker::getFormattedTimeTaken(struct timeval startTime) const {
+  if (ELPP->hasFlag(LoggingFlag::FixedTimeFormat)) {
+    base::type::stringstream_t ss;
+    ss << base::utils::DateTime::getTimeDifference(m_endTime,
+        startTime, m_timestampUnit) << " " << base::consts::kTimeFormats[static_cast<base::type::EnumType>
+            (m_timestampUnit)].unit;
+    return ss.str();
+  }
+  return base::utils::DateTime::formatTime(base::utils::DateTime::getTimeDifference(m_endTime,
+         startTime, m_timestampUnit), m_timestampUnit);
+}
+
+#endif // defined(ELPP_FEATURE_ALL) || defined(ELPP_FEATURE_PERFORMANCE_TRACKING)
+
+namespace debug {
+#if defined(ELPP_FEATURE_ALL) || defined(ELPP_FEATURE_CRASH_LOG)
+
+// StackTrace
+
+StackTrace::StackTraceEntry::StackTraceEntry(std::size_t index, const std::string& loc, const std::string& demang,
+    const std::string& hex,
+    const std::string& addr) :
+  m_index(index),
+  m_location(loc),
+  m_demangled(demang),
+  m_hex(hex),
+  m_addr(addr) {
+}
+
+std::ostream& operator<<(std::ostream& ss, const StackTrace::StackTraceEntry& si) {
+  ss << "[" << si.m_index << "] " << si.m_location << (si.m_hex.empty() ? "" : "+") << si.m_hex << " " << si.m_addr <<
+     (si.m_demangled.empty() ? "" : ":") << si.m_demangled;
+  return ss;
+}
+
+std::ostream& operator<<(std::ostream& os, const StackTrace& st) {
+  std::vector<StackTrace::StackTraceEntry>::const_iterator it = st.m_stack.begin();
+  while (it != st.m_stack.end()) {
+    os << "    " << *it++ << "\n";
+  }
+  return os;
+}
+
+void StackTrace::generateNew(void) {
+#if ELPP_STACKTRACE
+  m_stack.clear();
+  void* stack[kMaxStack];
+  unsigned int size = backtrace(stack, kMaxStack);
+  char** strings = backtrace_symbols(stack, size);
+  if (size > kStackStart) {  // Skip StackTrace c'tor and generateNew
+    for (std::size_t i = kStackStart; i < size; ++i) {
+      std::string mangName;
+      std::string location;
+      std::string hex;
+      std::string addr;
+
+      // entry: 2   crash.cpp.bin                       0x0000000101552be5 _ZN2el4base5debug10StackTraceC1Ev + 21
+      const std::string line(strings[i]);
+      auto p = line.find("_");
+      if (p != std::string::npos) {
+        mangName = line.substr(p);
+        mangName = mangName.substr(0, mangName.find(" +"));
+      }
+      p = line.find("0x");
+      if (p != std::string::npos) {
+        addr = line.substr(p);
+        addr = addr.substr(0, addr.find("_"));
+      }
+      // Perform demangling if parsed properly
+      if (!mangName.empty()) {
+        int status = 0;
+        char* demangName = abi::__cxa_demangle(mangName.data(), 0, 0, &status);
+        // if demangling is successful, output the demangled function name
+        if (status == 0) {
+          // Success (see http://gcc.gnu.org/onlinedocs/libstdc++/libstdc++-html-USERS-4.3/a01696.html)
+          StackTraceEntry entry(i - 1, location, demangName, hex, addr);
+          m_stack.push_back(entry);
+        } else {
+          // Not successful - we will use mangled name
+          StackTraceEntry entry(i - 1, location, mangName, hex, addr);
+          m_stack.push_back(entry);
+        }
+        free(demangName);
+      } else {
+        StackTraceEntry entry(i - 1, line);
+        m_stack.push_back(entry);
+      }
+    }
+  }
+  free(strings);
+#else
+  ELPP_INTERNAL_INFO(1, "Stacktrace generation not supported for selected compiler");
+#endif  // ELPP_STACKTRACE
+}
+
+// Static helper functions
+
+static std::string crashReason(int sig) {
+  std::stringstream ss;
+  bool foundReason = false;
+  for (int i = 0; i < base::consts::kCrashSignalsCount; ++i) {
+    if (base::consts::kCrashSignals[i].numb == sig) {
+      ss << "Application has crashed due to [" << base::consts::kCrashSignals[i].name << "] signal";
+      if (ELPP->hasFlag(el::LoggingFlag::LogDetailedCrashReason)) {
+        ss << std::endl <<
+           "    " << base::consts::kCrashSignals[i].brief << std::endl <<
+           "    " << base::consts::kCrashSignals[i].detail;
+      }
+      foundReason = true;
+    }
+  }
+  if (!foundReason) {
+    ss << "Application has crashed due to unknown signal [" << sig << "]";
+  }
+  return ss.str();
+}
+/// @brief Logs reason of crash from sig
+static void logCrashReason(int sig, bool stackTraceIfAvailable, Level level, const char* logger) {
+  if (sig == SIGINT && ELPP->hasFlag(el::LoggingFlag::IgnoreSigInt)) {
+    return;
+  }
+  std::stringstream ss;
+  ss << "CRASH HANDLED; ";
+  ss << crashReason(sig);
+#if ELPP_STACKTRACE
+  if (stackTraceIfAvailable) {
+    ss << std::endl << "    ======= Backtrace: =========" << std::endl << base::debug::StackTrace();
+  }
+#else
+  ELPP_UNUSED(stackTraceIfAvailable);
+#endif  // ELPP_STACKTRACE
+  ELPP_WRITE_LOG(el::base::Writer, level, base::DispatchAction::NormalLog, logger) << ss.str();
+}
+
+static inline void crashAbort(int sig) {
+  base::utils::abort(sig, std::string());
+}
+
+/// @brief Default application crash handler
+///
+/// @detail This function writes log using 'default' logger, prints stack trace for GCC based compilers and aborts program.
+static inline void defaultCrashHandler(int sig) {
+  base::debug::logCrashReason(sig, true, Level::Fatal, base::consts::kDefaultLoggerId);
+  base::debug::crashAbort(sig);
+}
+
+// CrashHandler
+
+CrashHandler::CrashHandler(bool useDefault) {
+  if (useDefault) {
+    setHandler(defaultCrashHandler);
+  }
+}
+
+void CrashHandler::setHandler(const Handler& cHandler) {
+  m_handler = cHandler;
+#if defined(ELPP_HANDLE_SIGABRT)
+  int i = 0;  // SIGABRT is at base::consts::kCrashSignals[0]
+#else
+  int i = 1;
+#endif  // defined(ELPP_HANDLE_SIGABRT)
+  for (; i < base::consts::kCrashSignalsCount; ++i) {
+    m_handler = signal(base::consts::kCrashSignals[i].numb, cHandler);
+  }
+}
+
+#endif // defined(ELPP_FEATURE_ALL) || defined(ELPP_FEATURE_CRASH_LOG)
+}  // namespace debug
+} // namespace base
+
+// el
+
+// Helpers
+
+#if defined(ELPP_FEATURE_ALL) || defined(ELPP_FEATURE_CRASH_LOG)
+
+void Helpers::crashAbort(int sig, const char* sourceFile, unsigned int long line) {
+  std::stringstream ss;
+  ss << base::debug::crashReason(sig).c_str();
+  ss << " - [Called el::Helpers::crashAbort(" << sig << ")]";
+  if (sourceFile != nullptr && strlen(sourceFile) > 0) {
+    ss << " - Source: " << sourceFile;
+    if (line > 0)
+      ss << ":" << line;
+    else
+      ss << " (line number not specified)";
+  }
+  base::utils::abort(sig, ss.str());
+}
+
+void Helpers::logCrashReason(int sig, bool stackTraceIfAvailable, Level level, const char* logger) {
+  el::base::debug::logCrashReason(sig, stackTraceIfAvailable, level, logger);
+}
+
+#endif // defined(ELPP_FEATURE_ALL) || defined(ELPP_FEATURE_CRASH_LOG)
+
+// Loggers
+
+Logger* Loggers::getLogger(const std::string& identity, bool registerIfNotAvailable) {
+  return ELPP->registeredLoggers()->get(identity, registerIfNotAvailable);
+}
+
+void Loggers::setDefaultLogBuilder(el::LogBuilderPtr& logBuilderPtr) {
+  ELPP->registeredLoggers()->setDefaultLogBuilder(logBuilderPtr);
+}
+
+bool Loggers::unregisterLogger(const std::string& identity) {
+  return ELPP->registeredLoggers()->remove(identity);
+}
+
+bool Loggers::hasLogger(const std::string& identity) {
+  return ELPP->registeredLoggers()->has(identity);
+}
+
+Logger* Loggers::reconfigureLogger(Logger* logger, const Configurations& configurations) {
+  if (!logger) return nullptr;
+  logger->configure(configurations);
+  return logger;
+}
+
+Logger* Loggers::reconfigureLogger(const std::string& identity, const Configurations& configurations) {
+  return Loggers::reconfigureLogger(Loggers::getLogger(identity), configurations);
+}
+
+Logger* Loggers::reconfigureLogger(const std::string& identity, ConfigurationType configurationType,
+                                   const std::string& value) {
+  Logger* logger = Loggers::getLogger(identity);
+  if (logger == nullptr) {
+    return nullptr;
+  }
+  logger->configurations()->set(Level::Global, configurationType, value);
+  logger->reconfigure();
+  return logger;
+}
+
+void Loggers::reconfigureAllLoggers(const Configurations& configurations) {
+  for (base::RegisteredLoggers::iterator it = ELPP->registeredLoggers()->begin();
+       it != ELPP->registeredLoggers()->end(); ++it) {
+    Loggers::reconfigureLogger(it->second, configurations);
+  }
+}
+
+void Loggers::reconfigureAllLoggers(Level level, ConfigurationType configurationType,
+                                    const std::string& value) {
+  for (base::RegisteredLoggers::iterator it = ELPP->registeredLoggers()->begin();
+       it != ELPP->registeredLoggers()->end(); ++it) {
+    Logger* logger = it->second;
+    logger->configurations()->set(level, configurationType, value);
+    logger->reconfigure();
+  }
+}
+
+void Loggers::setDefaultConfigurations(const Configurations& configurations, bool reconfigureExistingLoggers) {
+  ELPP->registeredLoggers()->setDefaultConfigurations(configurations);
+  if (reconfigureExistingLoggers) {
+    Loggers::reconfigureAllLoggers(configurations);
+  }
+}
+
+const Configurations* Loggers::defaultConfigurations(void) {
+  return ELPP->registeredLoggers()->defaultConfigurations();
+}
+
+const base::LogStreamsReferenceMap* Loggers::logStreamsReference(void) {
+  return ELPP->registeredLoggers()->logStreamsReference();
+}
+
+base::TypedConfigurations Loggers::defaultTypedConfigurations(void) {
+  return base::TypedConfigurations(
+           ELPP->registeredLoggers()->defaultConfigurations(),
+           ELPP->registeredLoggers()->logStreamsReference());
+}
+
+std::vector<std::string>* Loggers::populateAllLoggerIds(std::vector<std::string>* targetList) {
+  targetList->clear();
+  for (base::RegisteredLoggers::iterator it = ELPP->registeredLoggers()->list().begin();
+       it != ELPP->registeredLoggers()->list().end(); ++it) {
+    targetList->push_back(it->first);
+  }
+  return targetList;
+}
+
+void Loggers::configureFromGlobal(const char* globalConfigurationFilePath) {
+  std::ifstream gcfStream(globalConfigurationFilePath, std::ifstream::in);
+  ELPP_ASSERT(gcfStream.is_open(), "Unable to open global configuration file [" << globalConfigurationFilePath
+              << "] for parsing.");
+  std::string line = std::string();
+  std::stringstream ss;
+  Logger* logger = nullptr;
+  auto configure = [&](void) {
+    ELPP_INTERNAL_INFO(8, "Configuring logger: '" << logger->id() << "' with configurations \n" << ss.str()
+                       << "\n--------------");
+    Configurations c;
+    c.parseFromText(ss.str());
+    logger->configure(c);
+  };
+  while (gcfStream.good()) {
+    std::getline(gcfStream, line);
+    ELPP_INTERNAL_INFO(1, "Parsing line: " << line);
+    base::utils::Str::trim(line);
+    if (Configurations::Parser::isComment(line)) continue;
+    Configurations::Parser::ignoreComments(&line);
+    base::utils::Str::trim(line);
+    if (line.size() > 2 && base::utils::Str::startsWith(line, std::string(base::consts::kConfigurationLoggerId))) {
+      if (!ss.str().empty() && logger != nullptr) {
+        configure();
+      }
+      ss.str(std::string(""));
+      line = line.substr(2);
+      base::utils::Str::trim(line);
+      if (line.size() > 1) {
+        ELPP_INTERNAL_INFO(1, "Getting logger: '" << line << "'");
+        logger = getLogger(line);
+      }
+    } else {
+      ss << line << "\n";
+    }
+  }
+  if (!ss.str().empty() && logger != nullptr) {
+    configure();
+  }
+}
+
+bool Loggers::configureFromArg(const char* argKey) {
+#if defined(ELPP_DISABLE_CONFIGURATION_FROM_PROGRAM_ARGS)
+  ELPP_UNUSED(argKey);
+#else
+  if (!Helpers::commandLineArgs()->hasParamWithValue(argKey)) {
+    return false;
+  }
+  configureFromGlobal(Helpers::commandLineArgs()->getParamValue(argKey));
+#endif  // defined(ELPP_DISABLE_CONFIGURATION_FROM_PROGRAM_ARGS)
+  return true;
+}
+
+void Loggers::flushAll(void) {
+  ELPP->registeredLoggers()->flushAll();
+}
+
+void Loggers::setVerboseLevel(base::type::VerboseLevel level) {
+  ELPP->vRegistry()->setLevel(level);
+}
+
+base::type::VerboseLevel Loggers::verboseLevel(void) {
+  return ELPP->vRegistry()->level();
+}
+
+void Loggers::setVModules(const char* modules) {
+  if (ELPP->vRegistry()->vModulesEnabled()) {
+    ELPP->vRegistry()->setModules(modules);
+  }
+}
+
+void Loggers::clearVModules(void) {
+  ELPP->vRegistry()->clearModules();
+}
+
+// VersionInfo
+
+const std::string VersionInfo::version(void) {
+  return std::string("9.96.7");
+}
+/// @brief Release date of current version
+const std::string VersionInfo::releaseDate(void) {
+  return std::string("24-11-2018 0728hrs");
+}
+
+} // namespace el
diff --git a/core/src/utils/easylogging++.h b/core/src/utils/easylogging++.h
new file mode 100644
index 0000000000..62a7c5a423
--- /dev/null
+++ b/core/src/utils/easylogging++.h
@@ -0,0 +1,4569 @@
+//
+//  Bismillah ar-Rahmaan ar-Raheem
+//
+//  Easylogging++ v9.96.7
+//  Single-header only, cross-platform logging library for C++ applications
+//
+//  Copyright (c) 2012-2018 Zuhd Web Services
+//  Copyright (c) 2012-2018 @abumusamq
+//
+//  This library is released under the MIT Licence.
+//  https://github.com/zuhd-org/easyloggingpp/blob/master/LICENSE
+//
+//  https://zuhd.org
+//  http://muflihun.com
+//
+
+#ifndef EASYLOGGINGPP_H
+#define EASYLOGGINGPP_H
+// Compilers and C++0x/C++11 Evaluation
+#if __cplusplus >= 201103L
+#  define ELPP_CXX11 1
+#endif  // __cplusplus >= 201103L
+#if (defined(__GNUC__))
+#  define ELPP_COMPILER_GCC 1
+#else
+#  define ELPP_COMPILER_GCC 0
+#endif
+#if ELPP_COMPILER_GCC
+#    define ELPP_GCC_VERSION (__GNUC__ * 10000 \
++ __GNUC_MINOR__ * 100 \
++ __GNUC_PATCHLEVEL__)
+#  if defined(__GXX_EXPERIMENTAL_CXX0X__)
+#    define ELPP_CXX0X 1
+#  endif
+#endif
+// Visual C++
+#if defined(_MSC_VER)
+#  define ELPP_COMPILER_MSVC 1
+#else
+#  define ELPP_COMPILER_MSVC 0
+#endif
+#define ELPP_CRT_DBG_WARNINGS ELPP_COMPILER_MSVC
+#if ELPP_COMPILER_MSVC
+#  if (_MSC_VER == 1600)
+#    define ELPP_CXX0X 1
+#  elif(_MSC_VER >= 1700)
+#    define ELPP_CXX11 1
+#  endif
+#endif
+// Clang++
+#if (defined(__clang__) && (__clang__ == 1))
+#  define ELPP_COMPILER_CLANG 1
+#else
+#  define ELPP_COMPILER_CLANG 0
+#endif
+#if ELPP_COMPILER_CLANG
+#  if __has_include(<thread>)
+#    include <cstddef> // Make __GLIBCXX__ defined when using libstdc++
+#    if !defined(__GLIBCXX__) || __GLIBCXX__ >= 20150426
+#      define ELPP_CLANG_SUPPORTS_THREAD
+#    endif // !defined(__GLIBCXX__) || __GLIBCXX__ >= 20150426
+#  endif // __has_include(<thread>)
+#endif
+#if (defined(__MINGW32__) || defined(__MINGW64__))
+#  define ELPP_MINGW 1
+#else
+#  define ELPP_MINGW 0
+#endif
+#if (defined(__CYGWIN__) && (__CYGWIN__ == 1))
+#  define ELPP_CYGWIN 1
+#else
+#  define ELPP_CYGWIN 0
+#endif
+#if (defined(__INTEL_COMPILER))
+#  define ELPP_COMPILER_INTEL 1
+#else
+#  define ELPP_COMPILER_INTEL 0
+#endif
+// Operating System Evaluation
+// Windows
+#if (defined(_WIN32) || defined(_WIN64))
+#  define ELPP_OS_WINDOWS 1
+#else
+#  define ELPP_OS_WINDOWS 0
+#endif
+// Linux
+#if (defined(__linux) || defined(__linux__))
+#  define ELPP_OS_LINUX 1
+#else
+#  define ELPP_OS_LINUX 0
+#endif
+#if (defined(__APPLE__))
+#  define ELPP_OS_MAC 1
+#else
+#  define ELPP_OS_MAC 0
+#endif
+#if (defined(__FreeBSD__) || defined(__FreeBSD_kernel__))
+#  define ELPP_OS_FREEBSD 1
+#else
+#  define ELPP_OS_FREEBSD 0
+#endif
+#if (defined(__sun))
+#  define ELPP_OS_SOLARIS 1
+#else
+#  define ELPP_OS_SOLARIS 0
+#endif
+#if (defined(_AIX))
+#  define ELPP_OS_AIX 1
+#else
+#  define ELPP_OS_AIX 0
+#endif
+#if (defined(__NetBSD__))
+#  define ELPP_OS_NETBSD 1
+#else
+#  define ELPP_OS_NETBSD 0
+#endif
+#if defined(__EMSCRIPTEN__)
+#  define ELPP_OS_EMSCRIPTEN 1
+#else
+#  define ELPP_OS_EMSCRIPTEN 0
+#endif
+// Unix
+#if ((ELPP_OS_LINUX || ELPP_OS_MAC || ELPP_OS_FREEBSD || ELPP_OS_NETBSD || ELPP_OS_SOLARIS || ELPP_OS_AIX || ELPP_OS_EMSCRIPTEN) && (!ELPP_OS_WINDOWS))
+#  define ELPP_OS_UNIX 1
+#else
+#  define ELPP_OS_UNIX 0
+#endif
+#if (defined(__ANDROID__))
+#  define ELPP_OS_ANDROID 1
+#else
+#  define ELPP_OS_ANDROID 0
+#endif
+// Evaluating Cygwin as *nix OS
+#if !ELPP_OS_UNIX && !ELPP_OS_WINDOWS && ELPP_CYGWIN
+#  undef ELPP_OS_UNIX
+#  undef ELPP_OS_LINUX
+#  define ELPP_OS_UNIX 1
+#  define ELPP_OS_LINUX 1
+#endif //  !ELPP_OS_UNIX && !ELPP_OS_WINDOWS && ELPP_CYGWIN
+#if !defined(ELPP_INTERNAL_DEBUGGING_OUT_INFO)
+#  define ELPP_INTERNAL_DEBUGGING_OUT_INFO std::cout
+#endif // !defined(ELPP_INTERNAL_DEBUGGING_OUT)
+#if !defined(ELPP_INTERNAL_DEBUGGING_OUT_ERROR)
+#  define ELPP_INTERNAL_DEBUGGING_OUT_ERROR std::cerr
+#endif // !defined(ELPP_INTERNAL_DEBUGGING_OUT)
+#if !defined(ELPP_INTERNAL_DEBUGGING_ENDL)
+#  define ELPP_INTERNAL_DEBUGGING_ENDL std::endl
+#endif // !defined(ELPP_INTERNAL_DEBUGGING_OUT)
+#if !defined(ELPP_INTERNAL_DEBUGGING_MSG)
+#  define ELPP_INTERNAL_DEBUGGING_MSG(msg) msg
+#endif // !defined(ELPP_INTERNAL_DEBUGGING_OUT)
+// Internal Assertions and errors
+#if !defined(ELPP_DISABLE_ASSERT)
+#  if (defined(ELPP_DEBUG_ASSERT_FAILURE))
+#    define ELPP_ASSERT(expr, msg) if (!(expr)) { \
+std::stringstream internalInfoStream; internalInfoStream << msg; \
+ELPP_INTERNAL_DEBUGGING_OUT_ERROR \
+<< "EASYLOGGING++ ASSERTION FAILED (LINE: " << __LINE__ << ") [" #expr << "] WITH MESSAGE \"" \
+<< ELPP_INTERNAL_DEBUGGING_MSG(internalInfoStream.str()) << "\"" << ELPP_INTERNAL_DEBUGGING_ENDL; base::utils::abort(1, \
+"ELPP Assertion failure, please define ELPP_DEBUG_ASSERT_FAILURE"); }
+#  else
+#    define ELPP_ASSERT(expr, msg) if (!(expr)) { \
+std::stringstream internalInfoStream; internalInfoStream << msg; \
+ELPP_INTERNAL_DEBUGGING_OUT_ERROR\
+<< "ASSERTION FAILURE FROM EASYLOGGING++ (LINE: " \
+<< __LINE__ << ") [" #expr << "] WITH MESSAGE \"" << ELPP_INTERNAL_DEBUGGING_MSG(internalInfoStream.str()) << "\"" \
+<< ELPP_INTERNAL_DEBUGGING_ENDL; }
+#  endif  // (defined(ELPP_DEBUG_ASSERT_FAILURE))
+#else
+#  define ELPP_ASSERT(x, y)
+#endif  //(!defined(ELPP_DISABLE_ASSERT)
+#if ELPP_COMPILER_MSVC
+#  define ELPP_INTERNAL_DEBUGGING_WRITE_PERROR \
+{ char buff[256]; strerror_s(buff, 256, errno); \
+ELPP_INTERNAL_DEBUGGING_OUT_ERROR << ": " << buff << " [" << errno << "]";} (void)0
+#else
+#  define ELPP_INTERNAL_DEBUGGING_WRITE_PERROR \
+ELPP_INTERNAL_DEBUGGING_OUT_ERROR << ": " << strerror(errno) << " [" << errno << "]"; (void)0
+#endif  // ELPP_COMPILER_MSVC
+#if defined(ELPP_DEBUG_ERRORS)
+#  if !defined(ELPP_INTERNAL_ERROR)
+#    define ELPP_INTERNAL_ERROR(msg, pe) { \
+std::stringstream internalInfoStream; internalInfoStream << "<ERROR> " << msg; \
+ELPP_INTERNAL_DEBUGGING_OUT_ERROR \
+<< "ERROR FROM EASYLOGGING++ (LINE: " << __LINE__ << ") " \
+<< ELPP_INTERNAL_DEBUGGING_MSG(internalInfoStream.str()) << ELPP_INTERNAL_DEBUGGING_ENDL; \
+if (pe) { ELPP_INTERNAL_DEBUGGING_OUT_ERROR << "    "; ELPP_INTERNAL_DEBUGGING_WRITE_PERROR; }} (void)0
+#  endif
+#else
+#  undef ELPP_INTERNAL_INFO
+#  define ELPP_INTERNAL_ERROR(msg, pe)
+#endif  // defined(ELPP_DEBUG_ERRORS)
+#if (defined(ELPP_DEBUG_INFO))
+#  if !(defined(ELPP_INTERNAL_INFO_LEVEL))
+#    define ELPP_INTERNAL_INFO_LEVEL 9
+#  endif  // !(defined(ELPP_INTERNAL_INFO_LEVEL))
+#  if !defined(ELPP_INTERNAL_INFO)
+#    define ELPP_INTERNAL_INFO(lvl, msg) { if (lvl <= ELPP_INTERNAL_INFO_LEVEL) { \
+std::stringstream internalInfoStream; internalInfoStream << "<INFO> " << msg; \
+ELPP_INTERNAL_DEBUGGING_OUT_INFO << ELPP_INTERNAL_DEBUGGING_MSG(internalInfoStream.str()) \
+<< ELPP_INTERNAL_DEBUGGING_ENDL; }}
+#  endif
+#else
+#  undef ELPP_INTERNAL_INFO
+#  define ELPP_INTERNAL_INFO(lvl, msg)
+#endif  // (defined(ELPP_DEBUG_INFO))
+#if (defined(ELPP_FEATURE_ALL)) || (defined(ELPP_FEATURE_CRASH_LOG))
+#  if (ELPP_COMPILER_GCC && !ELPP_MINGW && !ELPP_OS_ANDROID && !ELPP_OS_EMSCRIPTEN)
+#    define ELPP_STACKTRACE 1
+#  else
+#      if ELPP_COMPILER_MSVC
+#         pragma message("Stack trace not available for this compiler")
+#      else
+#         warning "Stack trace not available for this compiler";
+#      endif  // ELPP_COMPILER_MSVC
+#    define ELPP_STACKTRACE 0
+#  endif  // ELPP_COMPILER_GCC
+#else
+#    define ELPP_STACKTRACE 0
+#endif  // (defined(ELPP_FEATURE_ALL)) || (defined(ELPP_FEATURE_CRASH_LOG))
+// Miscellaneous macros
+#define ELPP_UNUSED(x) (void)x
+#if ELPP_OS_UNIX
+// Log file permissions for unix-based systems
+#  define ELPP_LOG_PERMS S_IRUSR | S_IWUSR | S_IXUSR | S_IWGRP | S_IRGRP | S_IXGRP | S_IWOTH | S_IXOTH
+#endif  // ELPP_OS_UNIX
+#if defined(ELPP_AS_DLL) && ELPP_COMPILER_MSVC
+#  if defined(ELPP_EXPORT_SYMBOLS)
+#    define ELPP_EXPORT __declspec(dllexport)
+#  else
+#    define ELPP_EXPORT __declspec(dllimport)
+#  endif  // defined(ELPP_EXPORT_SYMBOLS)
+#else
+#  define ELPP_EXPORT
+#endif  // defined(ELPP_AS_DLL) && ELPP_COMPILER_MSVC
+// Some special functions that are VC++ specific
+#undef STRTOK
+#undef STRERROR
+#undef STRCAT
+#undef STRCPY
+#if ELPP_CRT_DBG_WARNINGS
+#  define STRTOK(a, b, c) strtok_s(a, b, c)
+#  define STRERROR(a, b, c) strerror_s(a, b, c)
+#  define STRCAT(a, b, len) strcat_s(a, len, b)
+#  define STRCPY(a, b, len) strcpy_s(a, len, b)
+#else
+#  define STRTOK(a, b, c) strtok(a, b)
+#  define STRERROR(a, b, c) strerror(c)
+#  define STRCAT(a, b, len) strcat(a, b)
+#  define STRCPY(a, b, len) strcpy(a, b)
+#endif
+// Compiler specific support evaluations
+#if (ELPP_MINGW && !defined(ELPP_FORCE_USE_STD_THREAD))
+#  define ELPP_USE_STD_THREADING 0
+#else
+#  if ((ELPP_COMPILER_CLANG && defined(ELPP_CLANG_SUPPORTS_THREAD)) || \
+       (!ELPP_COMPILER_CLANG && defined(ELPP_CXX11)) || \
+       defined(ELPP_FORCE_USE_STD_THREAD))
+#    define ELPP_USE_STD_THREADING 1
+#  else
+#    define ELPP_USE_STD_THREADING 0
+#  endif
+#endif
+#undef ELPP_FINAL
+#if ELPP_COMPILER_INTEL || (ELPP_GCC_VERSION < 40702)
+#  define ELPP_FINAL
+#else
+#  define ELPP_FINAL final
+#endif  // ELPP_COMPILER_INTEL || (ELPP_GCC_VERSION < 40702)
+#if defined(ELPP_EXPERIMENTAL_ASYNC)
+#  define ELPP_ASYNC_LOGGING 1
+#else
+#  define ELPP_ASYNC_LOGGING 0
+#endif // defined(ELPP_EXPERIMENTAL_ASYNC)
+#if defined(ELPP_THREAD_SAFE) || ELPP_ASYNC_LOGGING
+#  define ELPP_THREADING_ENABLED 1
+#else
+#  define ELPP_THREADING_ENABLED 0
+#endif  // defined(ELPP_THREAD_SAFE) || ELPP_ASYNC_LOGGING
+// Function macro ELPP_FUNC
+#undef ELPP_FUNC
+#if ELPP_COMPILER_MSVC  // Visual C++
+#  define ELPP_FUNC __FUNCSIG__
+#elif ELPP_COMPILER_GCC  // GCC
+#  define ELPP_FUNC __PRETTY_FUNCTION__
+#elif ELPP_COMPILER_INTEL  // Intel C++
+#  define ELPP_FUNC __PRETTY_FUNCTION__
+#elif ELPP_COMPILER_CLANG  // Clang++
+#  define ELPP_FUNC __PRETTY_FUNCTION__
+#else
+#  if defined(__func__)
+#    define ELPP_FUNC __func__
+#  else
+#    define ELPP_FUNC ""
+#  endif  // defined(__func__)
+#endif  // defined(_MSC_VER)
+#undef ELPP_VARIADIC_TEMPLATES_SUPPORTED
+// Keep following line commented until features are fixed
+#define ELPP_VARIADIC_TEMPLATES_SUPPORTED \
+(ELPP_COMPILER_GCC || ELPP_COMPILER_CLANG || ELPP_COMPILER_INTEL || (ELPP_COMPILER_MSVC && _MSC_VER >= 1800))
+// Logging Enable/Disable macros
+#if defined(ELPP_DISABLE_LOGS)
+#define ELPP_LOGGING_ENABLED 0
+#else
+#define ELPP_LOGGING_ENABLED 1
+#endif
+#if (!defined(ELPP_DISABLE_DEBUG_LOGS) && (ELPP_LOGGING_ENABLED))
+#  define ELPP_DEBUG_LOG 1
+#else
+#  define ELPP_DEBUG_LOG 0
+#endif  // (!defined(ELPP_DISABLE_DEBUG_LOGS) && (ELPP_LOGGING_ENABLED))
+#if (!defined(ELPP_DISABLE_INFO_LOGS) && (ELPP_LOGGING_ENABLED))
+#  define ELPP_INFO_LOG 1
+#else
+#  define ELPP_INFO_LOG 0
+#endif  // (!defined(ELPP_DISABLE_INFO_LOGS) && (ELPP_LOGGING_ENABLED))
+#if (!defined(ELPP_DISABLE_WARNING_LOGS) && (ELPP_LOGGING_ENABLED))
+#  define ELPP_WARNING_LOG 1
+#else
+#  define ELPP_WARNING_LOG 0
+#endif  // (!defined(ELPP_DISABLE_WARNING_LOGS) && (ELPP_LOGGING_ENABLED))
+#if (!defined(ELPP_DISABLE_ERROR_LOGS) && (ELPP_LOGGING_ENABLED))
+#  define ELPP_ERROR_LOG 1
+#else
+#  define ELPP_ERROR_LOG 0
+#endif  // (!defined(ELPP_DISABLE_ERROR_LOGS) && (ELPP_LOGGING_ENABLED))
+#if (!defined(ELPP_DISABLE_FATAL_LOGS) && (ELPP_LOGGING_ENABLED))
+#  define ELPP_FATAL_LOG 1
+#else
+#  define ELPP_FATAL_LOG 0
+#endif  // (!defined(ELPP_DISABLE_FATAL_LOGS) && (ELPP_LOGGING_ENABLED))
+#if (!defined(ELPP_DISABLE_TRACE_LOGS) && (ELPP_LOGGING_ENABLED))
+#  define ELPP_TRACE_LOG 1
+#else
+#  define ELPP_TRACE_LOG 0
+#endif  // (!defined(ELPP_DISABLE_TRACE_LOGS) && (ELPP_LOGGING_ENABLED))
+#if (!defined(ELPP_DISABLE_VERBOSE_LOGS) && (ELPP_LOGGING_ENABLED))
+#  define ELPP_VERBOSE_LOG 1
+#else
+#  define ELPP_VERBOSE_LOG 0
+#endif  // (!defined(ELPP_DISABLE_VERBOSE_LOGS) && (ELPP_LOGGING_ENABLED))
+#if (!(ELPP_CXX0X || ELPP_CXX11))
+#   error "C++0x (or higher) support not detected! (Is `-std=c++11' missing?)"
+#endif  // (!(ELPP_CXX0X || ELPP_CXX11))
+// Headers
+#if defined(ELPP_SYSLOG)
+#   include <syslog.h>
+#endif  // defined(ELPP_SYSLOG)
+#include <ctime>
+#include <cstring>
+#include <cstdlib>
+#include <cctype>
+#include <cwchar>
+#include <csignal>
+#include <cerrno>
+#include <cstdarg>
+#if defined(ELPP_UNICODE)
+#   include <locale>
+#  if ELPP_OS_WINDOWS
+#      include <codecvt>
+#  endif // ELPP_OS_WINDOWS
+#endif  // defined(ELPP_UNICODE)
+#if ELPP_STACKTRACE
+#   include <cxxabi.h>
+#   include <execinfo.h>
+#endif  // ELPP_STACKTRACE
+#if ELPP_OS_ANDROID
+#   include <sys/system_properties.h>
+#endif  // ELPP_OS_ANDROID
+#if ELPP_OS_UNIX
+#   include <sys/stat.h>
+#   include <sys/time.h>
+#elif ELPP_OS_WINDOWS
+#   include <direct.h>
+#   include <windows.h>
+#  if defined(WIN32_LEAN_AND_MEAN)
+#      if defined(ELPP_WINSOCK2)
+#         include <winsock2.h>
+#      else
+#         include <winsock.h>
+#      endif // defined(ELPP_WINSOCK2)
+#  endif // defined(WIN32_LEAN_AND_MEAN)
+#endif  // ELPP_OS_UNIX
+#include <string>
+#include <vector>
+#include <map>
+#include <unordered_map>
+#include <utility>
+#include <functional>
+#include <algorithm>
+#include <fstream>
+#include <iostream>
+#include <sstream>
+#include <memory>
+#include <type_traits>
+#if ELPP_THREADING_ENABLED
+#  if ELPP_USE_STD_THREADING
+#      include <mutex>
+#      include <thread>
+#  else
+#      if ELPP_OS_UNIX
+#         include <pthread.h>
+#      endif  // ELPP_OS_UNIX
+#  endif  // ELPP_USE_STD_THREADING
+#endif  // ELPP_THREADING_ENABLED
+#if ELPP_ASYNC_LOGGING
+#  if defined(ELPP_NO_SLEEP_FOR)
+#      include <unistd.h>
+#  endif  // defined(ELPP_NO_SLEEP_FOR)
+#   include <thread>
+#   include <queue>
+#   include <condition_variable>
+#endif  // ELPP_ASYNC_LOGGING
+#if defined(ELPP_STL_LOGGING)
+// For logging STL based templates
+#   include <list>
+#   include <queue>
+#   include <deque>
+#   include <set>
+#   include <bitset>
+#   include <stack>
+#  if defined(ELPP_LOG_STD_ARRAY)
+#      include <array>
+#  endif  // defined(ELPP_LOG_STD_ARRAY)
+#  if defined(ELPP_LOG_UNORDERED_SET)
+#      include <unordered_set>
+#  endif  // defined(ELPP_UNORDERED_SET)
+#endif  // defined(ELPP_STL_LOGGING)
+#if defined(ELPP_QT_LOGGING)
+// For logging Qt based classes & templates
+#   include <QString>
+#   include <QByteArray>
+#   include <QVector>
+#   include <QList>
+#   include <QPair>
+#   include <QMap>
+#   include <QQueue>
+#   include <QSet>
+#   include <QLinkedList>
+#   include <QHash>
+#   include <QMultiHash>
+#   include <QStack>
+#endif  // defined(ELPP_QT_LOGGING)
+#if defined(ELPP_BOOST_LOGGING)
+// For logging boost based classes & templates
+#   include <boost/container/vector.hpp>
+#   include <boost/container/stable_vector.hpp>
+#   include <boost/container/list.hpp>
+#   include <boost/container/deque.hpp>
+#   include <boost/container/map.hpp>
+#   include <boost/container/flat_map.hpp>
+#   include <boost/container/set.hpp>
+#   include <boost/container/flat_set.hpp>
+#endif  // defined(ELPP_BOOST_LOGGING)
+#if defined(ELPP_WXWIDGETS_LOGGING)
+// For logging wxWidgets based classes & templates
+#   include <wx/vector.h>
+#endif  // defined(ELPP_WXWIDGETS_LOGGING)
+#if defined(ELPP_UTC_DATETIME)
+#   define elpptime_r gmtime_r
+#   define elpptime_s gmtime_s
+#   define elpptime   gmtime
+#else
+#   define elpptime_r localtime_r
+#   define elpptime_s localtime_s
+#   define elpptime   localtime
+#endif  // defined(ELPP_UTC_DATETIME)
+// Forward declarations
+namespace el {
+class Logger;
+class LogMessage;
+class PerformanceTrackingData;
+class Loggers;
+class Helpers;
+template <typename T> class Callback;
+class LogDispatchCallback;
+class PerformanceTrackingCallback;
+class LoggerRegistrationCallback;
+class LogDispatchData;
+namespace base {
+class Storage;
+class RegisteredLoggers;
+class PerformanceTracker;
+class MessageBuilder;
+class Writer;
+class PErrorWriter;
+class LogDispatcher;
+class DefaultLogBuilder;
+class DefaultLogDispatchCallback;
+#if ELPP_ASYNC_LOGGING
+class AsyncLogDispatchCallback;
+class AsyncDispatchWorker;
+#endif // ELPP_ASYNC_LOGGING
+class DefaultPerformanceTrackingCallback;
+}  // namespace base
+}  // namespace el
+/// @brief Easylogging++ entry namespace
+namespace el {
+/// @brief Namespace containing base/internal functionality used by Easylogging++
+namespace base {
+/// @brief Data types used by Easylogging++
+namespace type {
+#undef ELPP_LITERAL
+#undef ELPP_STRLEN
+#undef ELPP_COUT
+#if defined(ELPP_UNICODE)
+#  define ELPP_LITERAL(txt) L##txt
+#  define ELPP_STRLEN wcslen
+#  if defined ELPP_CUSTOM_COUT
+#    define ELPP_COUT ELPP_CUSTOM_COUT
+#  else
+#    define ELPP_COUT std::wcout
+#  endif  // defined ELPP_CUSTOM_COUT
+typedef wchar_t char_t;
+typedef std::wstring string_t;
+typedef std::wstringstream stringstream_t;
+typedef std::wfstream fstream_t;
+typedef std::wostream ostream_t;
+#else
+#  define ELPP_LITERAL(txt) txt
+#  define ELPP_STRLEN strlen
+#  if defined ELPP_CUSTOM_COUT
+#    define ELPP_COUT ELPP_CUSTOM_COUT
+#  else
+#    define ELPP_COUT std::cout
+#  endif  // defined ELPP_CUSTOM_COUT
+typedef char char_t;
+typedef std::string string_t;
+typedef std::stringstream stringstream_t;
+typedef std::fstream fstream_t;
+typedef std::ostream ostream_t;
+#endif  // defined(ELPP_UNICODE)
+#if defined(ELPP_CUSTOM_COUT_LINE)
+#  define ELPP_COUT_LINE(logLine) ELPP_CUSTOM_COUT_LINE(logLine)
+#else
+#  define ELPP_COUT_LINE(logLine) logLine << std::flush
+#endif // defined(ELPP_CUSTOM_COUT_LINE)
+typedef unsigned int EnumType;
+typedef unsigned short VerboseLevel;
+typedef unsigned long int LineNumber;
+typedef std::shared_ptr<base::Storage> StoragePointer;
+typedef std::shared_ptr<LogDispatchCallback> LogDispatchCallbackPtr;
+typedef std::shared_ptr<PerformanceTrackingCallback> PerformanceTrackingCallbackPtr;
+typedef std::shared_ptr<LoggerRegistrationCallback> LoggerRegistrationCallbackPtr;
+typedef std::unique_ptr<el::base::PerformanceTracker> PerformanceTrackerPtr;
+}  // namespace type
+/// @brief Internal helper class that prevent copy constructor for class
+///
+/// @detail When using this class simply inherit it privately
+class NoCopy {
+ protected:
+  NoCopy(void) {}
+ private:
+  NoCopy(const NoCopy&);
+  NoCopy& operator=(const NoCopy&);
+};
+/// @brief Internal helper class that makes all default constructors private.
+///
+/// @detail This prevents initializing class making it static unless an explicit constructor is declared.
+/// When using this class simply inherit it privately
+class StaticClass {
+ private:
+  StaticClass(void);
+  StaticClass(const StaticClass&);
+  StaticClass& operator=(const StaticClass&);
+};
+}  // namespace base
+/// @brief Represents enumeration for severity level used to determine level of logging
+///
+/// @detail With Easylogging++, developers may disable or enable any level regardless of
+/// what the severity is. Or they can choose to log using hierarchical logging flag
+enum class Level : base::type::EnumType {
+  /// @brief Generic level that represents all the levels. Useful when setting global configuration for all levels
+  Global = 1,
+  /// @brief Information that can be useful to back-trace certain events - mostly useful than debug logs.
+  Trace = 2,
+  /// @brief Informational events most useful for developers to debug application
+  Debug = 4,
+  /// @brief Severe error information that will presumably abort application
+  Fatal = 8,
+  /// @brief Information representing errors in application but application will keep running
+  Error = 16,
+  /// @brief Useful when application has potentially harmful situtaions
+  Warning = 32,
+  /// @brief Information that can be highly useful and vary with verbose logging level.
+  Verbose = 64,
+  /// @brief Mainly useful to represent current progress of application
+  Info = 128,
+  /// @brief Represents unknown level
+  Unknown = 1010
+};
+} // namespace el
+namespace std {
+template<> struct hash<el::Level> {
+ public:
+  std::size_t operator()(const el::Level& l) const {
+    return hash<el::base::type::EnumType> {}(static_cast<el::base::type::EnumType>(l));
+  }
+};
+}
+namespace el {
+/// @brief Static class that contains helper functions for el::Level
+class LevelHelper : base::StaticClass {
+ public:
+  /// @brief Represents minimum valid level. Useful when iterating through enum.
+  static const base::type::EnumType kMinValid = static_cast<base::type::EnumType>(Level::Trace);
+  /// @brief Represents maximum valid level. This is used internally and you should not need it.
+  static const base::type::EnumType kMaxValid = static_cast<base::type::EnumType>(Level::Info);
+  /// @brief Casts level to int, useful for iterating through enum.
+  static base::type::EnumType castToInt(Level level) {
+    return static_cast<base::type::EnumType>(level);
+  }
+  /// @brief Casts int(ushort) to level, useful for iterating through enum.
+  static Level castFromInt(base::type::EnumType l) {
+    return static_cast<Level>(l);
+  }
+  /// @brief Converts level to associated const char*
+  /// @return Upper case string based level.
+  static const char* convertToString(Level level);
+  /// @brief Converts from levelStr to Level
+  /// @param levelStr Upper case string based level.
+  ///        Lower case is also valid but providing upper case is recommended.
+  static Level convertFromString(const char* levelStr);
+  /// @brief Applies specified function to each level starting from startIndex
+  /// @param startIndex initial value to start the iteration from. This is passed as pointer and
+  ///        is left-shifted so this can be used inside function (fn) to represent current level.
+  /// @param fn function to apply with each level. This bool represent whether or not to stop iterating through levels.
+  static void forEachLevel(base::type::EnumType* startIndex, const std::function<bool(void)>& fn);
+};
+/// @brief Represents enumeration of ConfigurationType used to configure or access certain aspect
+/// of logging
+enum class ConfigurationType : base::type::EnumType {
+  /// @brief Determines whether or not corresponding level and logger of logging is enabled
+  /// You may disable all logs by using el::Level::Global
+  Enabled = 1,
+  /// @brief Whether or not to write corresponding log to log file
+  ToFile = 2,
+  /// @brief Whether or not to write corresponding level and logger log to standard output.
+  /// By standard output meaning termnal, command prompt etc
+  ToStandardOutput = 4,
+  /// @brief Determines format of logging corresponding level and logger.
+  Format = 8,
+  /// @brief Determines log file (full path) to write logs to for correponding level and logger
+  Filename = 16,
+  /// @brief Specifies precision of the subsecond part. It should be within range (1-6).
+  SubsecondPrecision = 32,
+  /// @brief Alias of SubsecondPrecision (for backward compatibility)
+  MillisecondsWidth = SubsecondPrecision,
+  /// @brief Determines whether or not performance tracking is enabled.
+  ///
+  /// @detail This does not depend on logger or level. Performance tracking always uses 'performance' logger
+  PerformanceTracking = 64,
+  /// @brief Specifies log file max size.
+  ///
+  /// @detail If file size of corresponding log file (for corresponding level) is >= specified size, log file will
+  /// be truncated and re-initiated.
+  MaxLogFileSize = 128,
+  /// @brief Specifies number of log entries to hold until we flush pending log data
+  LogFlushThreshold = 256,
+  /// @brief Represents unknown configuration
+  Unknown = 1010
+};
+/// @brief Static class that contains helper functions for el::ConfigurationType
+class ConfigurationTypeHelper : base::StaticClass {
+ public:
+  /// @brief Represents minimum valid configuration type. Useful when iterating through enum.
+  static const base::type::EnumType kMinValid = static_cast<base::type::EnumType>(ConfigurationType::Enabled);
+  /// @brief Represents maximum valid configuration type. This is used internally and you should not need it.
+  static const base::type::EnumType kMaxValid = static_cast<base::type::EnumType>(ConfigurationType::MaxLogFileSize);
+  /// @brief Casts configuration type to int, useful for iterating through enum.
+  static base::type::EnumType castToInt(ConfigurationType configurationType) {
+    return static_cast<base::type::EnumType>(configurationType);
+  }
+  /// @brief Casts int(ushort) to configurationt type, useful for iterating through enum.
+  static ConfigurationType castFromInt(base::type::EnumType c) {
+    return static_cast<ConfigurationType>(c);
+  }
+  /// @brief Converts configuration type to associated const char*
+  /// @returns Upper case string based configuration type.
+  static const char* convertToString(ConfigurationType configurationType);
+  /// @brief Converts from configStr to ConfigurationType
+  /// @param configStr Upper case string based configuration type.
+  ///        Lower case is also valid but providing upper case is recommended.
+  static ConfigurationType convertFromString(const char* configStr);
+  /// @brief Applies specified function to each configuration type starting from startIndex
+  /// @param startIndex initial value to start the iteration from. This is passed by pointer and is left-shifted
+  ///        so this can be used inside function (fn) to represent current configuration type.
+  /// @param fn function to apply with each configuration type.
+  ///        This bool represent whether or not to stop iterating through configurations.
+  static inline void forEachConfigType(base::type::EnumType* startIndex, const std::function<bool(void)>& fn);
+};
+/// @brief Flags used while writing logs. This flags are set by user
+enum class LoggingFlag : base::type::EnumType {
+  /// @brief Makes sure we have new line for each container log entry
+  NewLineForContainer = 1,
+  /// @brief Makes sure if -vmodule is used and does not specifies a module, then verbose
+  /// logging is allowed via that module.
+  AllowVerboseIfModuleNotSpecified = 2,
+  /// @brief When handling crashes by default, detailed crash reason will be logged as well
+  LogDetailedCrashReason = 4,
+  /// @brief Allows to disable application abortion when logged using FATAL level
+  DisableApplicationAbortOnFatalLog = 8,
+  /// @brief Flushes log with every log-entry (performance sensative) - Disabled by default
+  ImmediateFlush = 16,
+  /// @brief Enables strict file rolling
+  StrictLogFileSizeCheck = 32,
+  /// @brief Make terminal output colorful for supported terminals
+  ColoredTerminalOutput = 64,
+  /// @brief Supports use of multiple logging in same macro, e.g, CLOG(INFO, "default", "network")
+  MultiLoggerSupport = 128,
+  /// @brief Disables comparing performance tracker's checkpoints
+  DisablePerformanceTrackingCheckpointComparison = 256,
+  /// @brief Disable VModules
+  DisableVModules = 512,
+  /// @brief Disable VModules extensions
+  DisableVModulesExtensions = 1024,
+  /// @brief Enables hierarchical logging
+  HierarchicalLogging = 2048,
+  /// @brief Creates logger automatically when not available
+  CreateLoggerAutomatically = 4096,
+  /// @brief Adds spaces b/w logs that separated by left-shift operator
+  AutoSpacing = 8192,
+  /// @brief Preserves time format and does not convert it to sec, hour etc (performance tracking only)
+  FixedTimeFormat = 16384,
+  // @brief Ignore SIGINT or crash
+  IgnoreSigInt = 32768,
+};
+namespace base {
+/// @brief Namespace containing constants used internally.
+namespace consts {
+static const char  kFormatSpecifierCharValue               =      'v';
+static const char  kFormatSpecifierChar                    =      '%';
+static const unsigned int kMaxLogPerCounter                =      100000;
+static const unsigned int kMaxLogPerContainer              =      100;
+static const unsigned int kDefaultSubsecondPrecision       =      3;
+
+#ifdef ELPP_DEFAULT_LOGGER
+static const char* kDefaultLoggerId                        =      ELPP_DEFAULT_LOGGER;
+#else
+static const char* kDefaultLoggerId                        =      "default";
+#endif
+
+#if defined(ELPP_FEATURE_ALL) || defined(ELPP_FEATURE_PERFORMANCE_TRACKING)
+#ifdef ELPP_DEFAULT_PERFORMANCE_LOGGER
+static const char* kPerformanceLoggerId                    =      ELPP_DEFAULT_PERFORMANCE_LOGGER;
+#else
+static const char* kPerformanceLoggerId                    =      "performance";
+#endif // ELPP_DEFAULT_PERFORMANCE_LOGGER
+#endif
+
+#if defined(ELPP_SYSLOG)
+static const char* kSysLogLoggerId                         =      "syslog";
+#endif  // defined(ELPP_SYSLOG)
+
+#if ELPP_OS_WINDOWS
+static const char* kFilePathSeperator                      =      "\\";
+#else
+static const char* kFilePathSeperator                      =      "/";
+#endif  // ELPP_OS_WINDOWS
+
+static const std::size_t kSourceFilenameMaxLength          =      100;
+static const std::size_t kSourceLineMaxLength              =      10;
+static const Level kPerformanceTrackerDefaultLevel         =      Level::Info;
+const struct {
+  double value;
+  const base::type::char_t* unit;
+} kTimeFormats[] = {
+  { 1000.0f, ELPP_LITERAL("us") },
+  { 1000.0f, ELPP_LITERAL("ms") },
+  { 60.0f, ELPP_LITERAL("seconds") },
+  { 60.0f, ELPP_LITERAL("minutes") },
+  { 24.0f, ELPP_LITERAL("hours") },
+  { 7.0f, ELPP_LITERAL("days") }
+};
+static const int kTimeFormatsCount                           =      sizeof(kTimeFormats) / sizeof(kTimeFormats[0]);
+const struct {
+  int numb;
+  const char* name;
+  const char* brief;
+  const char* detail;
+} kCrashSignals[] = {
+  // NOTE: Do not re-order, if you do please check CrashHandler(bool) constructor and CrashHandler::setHandler(..)
+  {
+    SIGABRT, "SIGABRT", "Abnormal termination",
+    "Program was abnormally terminated."
+  },
+  {
+    SIGFPE, "SIGFPE", "Erroneous arithmetic operation",
+    "Arithemetic operation issue such as division by zero or operation resulting in overflow."
+  },
+  {
+    SIGILL, "SIGILL", "Illegal instruction",
+    "Generally due to a corruption in the code or to an attempt to execute data."
+  },
+  {
+    SIGSEGV, "SIGSEGV", "Invalid access to memory",
+    "Program is trying to read an invalid (unallocated, deleted or corrupted) or inaccessible memory."
+  },
+  {
+    SIGINT, "SIGINT", "Interactive attention signal",
+    "Interruption generated (generally) by user or operating system."
+  },
+};
+static const int kCrashSignalsCount                          =      sizeof(kCrashSignals) / sizeof(kCrashSignals[0]);
+}  // namespace consts
+}  // namespace base
+typedef std::function<void(const char*, std::size_t, Level level)> PreRollOutCallback;
+namespace base {
+static inline void defaultPreRollOutCallback(const char*, std::size_t, Level level) {}
+/// @brief Enum to represent timestamp unit
+enum class TimestampUnit : base::type::EnumType {
+  Microsecond = 0, Millisecond = 1, Second = 2, Minute = 3, Hour = 4, Day = 5
+};
+/// @brief Format flags used to determine specifiers that are active for performance improvements.
+enum class FormatFlags : base::type::EnumType {
+  DateTime = 1 << 1,
+  LoggerId = 1 << 2,
+  File = 1 << 3,
+  Line = 1 << 4,
+  Location = 1 << 5,
+  Function = 1 << 6,
+  User = 1 << 7,
+  Host = 1 << 8,
+  LogMessage = 1 << 9,
+  VerboseLevel = 1 << 10,
+  AppName = 1 << 11,
+  ThreadId = 1 << 12,
+  Level = 1 << 13,
+  FileBase = 1 << 14,
+  LevelShort = 1 << 15
+};
+/// @brief A subsecond precision class containing actual width and offset of the subsecond part
+class SubsecondPrecision {
+ public:
+  SubsecondPrecision(void) {
+    init(base::consts::kDefaultSubsecondPrecision);
+  }
+  explicit SubsecondPrecision(int width) {
+    init(width);
+  }
+  bool operator==(const SubsecondPrecision& ssPrec) {
+    return m_width == ssPrec.m_width && m_offset == ssPrec.m_offset;
+  }
+  int m_width;
+  unsigned int m_offset;
+ private:
+  void init(int width);
+};
+/// @brief Type alias of SubsecondPrecision
+typedef SubsecondPrecision MillisecondsWidth;
+/// @brief Namespace containing utility functions/static classes used internally
+namespace utils {
+/// @brief Deletes memory safely and points to null
+template <typename T>
+static
+typename std::enable_if<std::is_pointer<T*>::value, void>::type
+safeDelete(T*& pointer) {
+  if (pointer == nullptr)
+    return;
+  delete pointer;
+  pointer = nullptr;
+}
+/// @brief Bitwise operations for C++11 strong enum class. This casts e into Flag_T and returns value after bitwise operation
+/// Use these function as <pre>flag = bitwise::Or<MyEnum>(MyEnum::val1, flag);</pre>
+namespace bitwise {
+template <typename Enum>
+static inline base::type::EnumType And(Enum e, base::type::EnumType flag) {
+  return static_cast<base::type::EnumType>(flag) & static_cast<base::type::EnumType>(e);
+}
+template <typename Enum>
+static inline base::type::EnumType Not(Enum e, base::type::EnumType flag) {
+  return static_cast<base::type::EnumType>(flag) & ~(static_cast<base::type::EnumType>(e));
+}
+template <typename Enum>
+static inline base::type::EnumType Or(Enum e, base::type::EnumType flag) {
+  return static_cast<base::type::EnumType>(flag) | static_cast<base::type::EnumType>(e);
+}
+}  // namespace bitwise
+template <typename Enum>
+static inline void addFlag(Enum e, base::type::EnumType* flag) {
+  *flag = base::utils::bitwise::Or<Enum>(e, *flag);
+}
+template <typename Enum>
+static inline void removeFlag(Enum e, base::type::EnumType* flag) {
+  *flag = base::utils::bitwise::Not<Enum>(e, *flag);
+}
+template <typename Enum>
+static inline bool hasFlag(Enum e, base::type::EnumType flag) {
+  return base::utils::bitwise::And<Enum>(e, flag) > 0x0;
+}
+}  // namespace utils
+namespace threading {
+#if ELPP_THREADING_ENABLED
+#  if !ELPP_USE_STD_THREADING
+namespace internal {
+/// @brief A mutex wrapper for compiler that dont yet support std::recursive_mutex
+class Mutex : base::NoCopy {
+ public:
+  Mutex(void) {
+#  if ELPP_OS_UNIX
+    pthread_mutexattr_t attr;
+    pthread_mutexattr_init(&attr);
+    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
+    pthread_mutex_init(&m_underlyingMutex, &attr);
+    pthread_mutexattr_destroy(&attr);
+#  elif ELPP_OS_WINDOWS
+    InitializeCriticalSection(&m_underlyingMutex);
+#  endif  // ELPP_OS_UNIX
+  }
+
+  virtual ~Mutex(void) {
+#  if ELPP_OS_UNIX
+    pthread_mutex_destroy(&m_underlyingMutex);
+#  elif ELPP_OS_WINDOWS
+    DeleteCriticalSection(&m_underlyingMutex);
+#  endif  // ELPP_OS_UNIX
+  }
+
+  inline void lock(void) {
+#  if ELPP_OS_UNIX
+    pthread_mutex_lock(&m_underlyingMutex);
+#  elif ELPP_OS_WINDOWS
+    EnterCriticalSection(&m_underlyingMutex);
+#  endif  // ELPP_OS_UNIX
+  }
+
+  inline bool try_lock(void) {
+#  if ELPP_OS_UNIX
+    return (pthread_mutex_trylock(&m_underlyingMutex) == 0);
+#  elif ELPP_OS_WINDOWS
+    return TryEnterCriticalSection(&m_underlyingMutex);
+#  endif  // ELPP_OS_UNIX
+  }
+
+  inline void unlock(void) {
+#  if ELPP_OS_UNIX
+    pthread_mutex_unlock(&m_underlyingMutex);
+#  elif ELPP_OS_WINDOWS
+    LeaveCriticalSection(&m_underlyingMutex);
+#  endif  // ELPP_OS_UNIX
+  }
+
+ private:
+#  if ELPP_OS_UNIX
+  pthread_mutex_t m_underlyingMutex;
+#  elif ELPP_OS_WINDOWS
+  CRITICAL_SECTION m_underlyingMutex;
+#  endif  // ELPP_OS_UNIX
+};
+/// @brief Scoped lock for compiler that dont yet support std::lock_guard
+template <typename M>
+class ScopedLock : base::NoCopy {
+ public:
+  explicit ScopedLock(M& mutex) {
+    m_mutex = &mutex;
+    m_mutex->lock();
+  }
+
+  virtual ~ScopedLock(void) {
+    m_mutex->unlock();
+  }
+ private:
+  M* m_mutex;
+  ScopedLock(void);
+};
+} // namespace internal
+typedef base::threading::internal::Mutex Mutex;
+typedef base::threading::internal::ScopedLock<base::threading::Mutex> ScopedLock;
+#  else
+typedef std::recursive_mutex Mutex;
+typedef std::lock_guard<base::threading::Mutex> ScopedLock;
+#  endif  // !ELPP_USE_STD_THREADING
+#else
+namespace internal {
+/// @brief Mutex wrapper used when multi-threading is disabled.
+class NoMutex : base::NoCopy {
+ public:
+  NoMutex(void) {}
+  inline void lock(void) {}
+  inline bool try_lock(void) {
+    return true;
+  }
+  inline void unlock(void) {}
+};
+/// @brief Lock guard wrapper used when multi-threading is disabled.
+template <typename Mutex>
+class NoScopedLock : base::NoCopy {
+ public:
+  explicit NoScopedLock(Mutex&) {
+  }
+  virtual ~NoScopedLock(void) {
+  }
+ private:
+  NoScopedLock(void);
+};
+}  // namespace internal
+typedef base::threading::internal::NoMutex Mutex;
+typedef base::threading::internal::NoScopedLock<base::threading::Mutex> ScopedLock;
+#endif  // ELPP_THREADING_ENABLED
+/// @brief Base of thread safe class, this class is inheritable-only
+class ThreadSafe {
+ public:
+  virtual inline void acquireLock(void) ELPP_FINAL { m_mutex.lock(); }
+  virtual inline void releaseLock(void) ELPP_FINAL { m_mutex.unlock(); }
+  virtual inline base::threading::Mutex& lock(void) ELPP_FINAL { return m_mutex; }
+ protected:
+  ThreadSafe(void) {}
+  virtual ~ThreadSafe(void) {}
+ private:
+  base::threading::Mutex m_mutex;
+};
+
+#if ELPP_THREADING_ENABLED
+#  if !ELPP_USE_STD_THREADING
+/// @brief Gets ID of currently running threading in windows systems. On unix, nothing is returned.
+static std::string getCurrentThreadId(void) {
+  std::stringstream ss;
+#      if (ELPP_OS_WINDOWS)
+  ss << GetCurrentThreadId();
+#      endif  // (ELPP_OS_WINDOWS)
+  return ss.str();
+}
+#  else
+/// @brief Gets ID of currently running threading using std::this_thread::get_id()
+static std::string getCurrentThreadId(void) {
+  std::stringstream ss;
+  ss << std::this_thread::get_id();
+  return ss.str();
+}
+#  endif  // !ELPP_USE_STD_THREADING
+#else
+static inline std::string getCurrentThreadId(void) {
+  return std::string();
+}
+#endif  // ELPP_THREADING_ENABLED
+}  // namespace threading
+namespace utils {
+class File : base::StaticClass {
+ public:
+  /// @brief Creates new out file stream for specified filename.
+  /// @return Pointer to newly created fstream or nullptr
+  static base::type::fstream_t* newFileStream(const std::string& filename);
+
+  /// @brief Gets size of file provided in stream
+  static std::size_t getSizeOfFile(base::type::fstream_t* fs);
+
+  /// @brief Determines whether or not provided path exist in current file system
+  static bool pathExists(const char* path, bool considerFile = false);
+
+  /// @brief Creates specified path on file system
+  /// @param path Path to create.
+  static bool createPath(const std::string& path);
+  /// @brief Extracts path of filename with leading slash
+  static std::string extractPathFromFilename(const std::string& fullPath,
+      const char* seperator = base::consts::kFilePathSeperator);
+  /// @brief builds stripped filename and puts it in buff
+  static void buildStrippedFilename(const char* filename, char buff[],
+                                    std::size_t limit = base::consts::kSourceFilenameMaxLength);
+  /// @brief builds base filename and puts it in buff
+  static void buildBaseFilename(const std::string& fullPath, char buff[],
+                                std::size_t limit = base::consts::kSourceFilenameMaxLength,
+                                const char* seperator = base::consts::kFilePathSeperator);
+};
+/// @brief String utilities helper class used internally. You should not use it.
+class Str : base::StaticClass {
+ public:
+  /// @brief Checks if character is digit. Dont use libc implementation of it to prevent locale issues.
+  static inline bool isDigit(char c) {
+    return c >= '0' && c <= '9';
+  }
+
+  /// @brief Matches wildcards, '*' and '?' only supported.
+  static bool wildCardMatch(const char* str, const char* pattern);
+
+  static std::string& ltrim(std::string& str);
+  static std::string& rtrim(std::string& str);
+  static std::string& trim(std::string& str);
+
+  /// @brief Determines whether or not str starts with specified string
+  /// @param str String to check
+  /// @param start String to check against
+  /// @return Returns true if starts with specified string, false otherwise
+  static bool startsWith(const std::string& str, const std::string& start);
+
+  /// @brief Determines whether or not str ends with specified string
+  /// @param str String to check
+  /// @param end String to check against
+  /// @return Returns true if ends with specified string, false otherwise
+  static bool endsWith(const std::string& str, const std::string& end);
+
+  /// @brief Replaces all instances of replaceWhat with 'replaceWith'. Original variable is changed for performance.
+  /// @param [in,out] str String to replace from
+  /// @param replaceWhat Character to replace
+  /// @param replaceWith Character to replace with
+  /// @return Modified version of str
+  static std::string& replaceAll(std::string& str, char replaceWhat, char replaceWith);
+
+  /// @brief Replaces all instances of 'replaceWhat' with 'replaceWith'. (String version) Replaces in place
+  /// @param str String to replace from
+  /// @param replaceWhat Character to replace
+  /// @param replaceWith Character to replace with
+  /// @return Modified (original) str
+  static std::string& replaceAll(std::string& str, const std::string& replaceWhat,
+                                 const std::string& replaceWith);
+
+  static void replaceFirstWithEscape(base::type::string_t& str, const base::type::string_t& replaceWhat,
+                                     const base::type::string_t& replaceWith);
+#if defined(ELPP_UNICODE)
+  static void replaceFirstWithEscape(base::type::string_t& str, const base::type::string_t& replaceWhat,
+                                     const std::string& replaceWith);
+#endif  // defined(ELPP_UNICODE)
+  /// @brief Converts string to uppercase
+  /// @param str String to convert
+  /// @return Uppercase string
+  static std::string& toUpper(std::string& str);
+
+  /// @brief Compares cstring equality - uses strcmp
+  static bool cStringEq(const char* s1, const char* s2);
+
+  /// @brief Compares cstring equality (case-insensitive) - uses toupper(char)
+  /// Dont use strcasecmp because of CRT (VC++)
+  static bool cStringCaseEq(const char* s1, const char* s2);
+
+  /// @brief Returns true if c exist in str
+  static bool contains(const char* str, char c);
+
+  static char* convertAndAddToBuff(std::size_t n, int len, char* buf, const char* bufLim, bool zeroPadded = true);
+  static char* addToBuff(const char* str, char* buf, const char* bufLim);
+  static char* clearBuff(char buff[], std::size_t lim);
+
+  /// @brief Converst wchar* to char*
+  ///        NOTE: Need to free return value after use!
+  static char* wcharPtrToCharPtr(const wchar_t* line);
+};
+/// @brief Operating System helper static class used internally. You should not use it.
+class OS : base::StaticClass {
+ public:
+#if ELPP_OS_WINDOWS
+  /// @brief Gets environment variables for Windows based OS.
+  ///        We are not using <code>getenv(const char*)</code> because of CRT deprecation
+  /// @param varname Variable name to get environment variable value for
+  /// @return If variable exist the value of it otherwise nullptr
+  static const char* getWindowsEnvironmentVariable(const char* varname);
+#endif  // ELPP_OS_WINDOWS
+#if ELPP_OS_ANDROID
+  /// @brief Reads android property value
+  static std::string getProperty(const char* prop);
+
+  /// @brief Reads android device name
+  static std::string getDeviceName(void);
+#endif  // ELPP_OS_ANDROID
+
+  /// @brief Runs command on terminal and returns the output.
+  ///
+  /// @detail This is applicable only on unix based systems, for all other OS, an empty string is returned.
+  /// @param command Bash command
+  /// @return Result of bash output or empty string if no result found.
+  static const std::string getBashOutput(const char* command);
+
+  /// @brief Gets environment variable. This is cross-platform and CRT safe (for VC++)
+  /// @param variableName Environment variable name
+  /// @param defaultVal If no environment variable or value found the value to return by default
+  /// @param alternativeBashCommand If environment variable not found what would be alternative bash command
+  ///        in order to look for value user is looking for. E.g, for 'user' alternative command will 'whoami'
+  static std::string getEnvironmentVariable(const char* variableName, const char* defaultVal,
+      const char* alternativeBashCommand = nullptr);
+  /// @brief Gets current username.
+  static std::string currentUser(void);
+
+  /// @brief Gets current host name or computer name.
+  ///
+  /// @detail For android systems this is device name with its manufacturer and model seperated by hyphen
+  static std::string currentHost(void);
+  /// @brief Whether or not terminal supports colors
+  static bool termSupportsColor(void);
+};
+/// @brief Contains utilities for cross-platform date/time. This class make use of el::base::utils::Str
+class DateTime : base::StaticClass {
+ public:
+  /// @brief Cross platform gettimeofday for Windows and unix platform. This can be used to determine current microsecond.
+  ///
+  /// @detail For unix system it uses gettimeofday(timeval*, timezone*) and for Windows, a seperate implementation is provided
+  /// @param [in,out] tv Pointer that gets updated
+  static void gettimeofday(struct timeval* tv);
+
+  /// @brief Gets current date and time with a subsecond part.
+  /// @param format User provided date/time format
+  /// @param ssPrec A pointer to base::SubsecondPrecision from configuration (non-null)
+  /// @returns string based date time in specified format.
+  static std::string getDateTime(const char* format, const base::SubsecondPrecision* ssPrec);
+
+  /// @brief Converts timeval (struct from ctime) to string using specified format and subsecond precision
+  static std::string timevalToString(struct timeval tval, const char* format,
+                                     const el::base::SubsecondPrecision* ssPrec);
+
+  /// @brief Formats time to get unit accordingly, units like second if > 1000 or minutes if > 60000 etc
+  static base::type::string_t formatTime(unsigned long long time, base::TimestampUnit timestampUnit);
+
+  /// @brief Gets time difference in milli/micro second depending on timestampUnit
+  static unsigned long long getTimeDifference(const struct timeval& endTime, const struct timeval& startTime,
+      base::TimestampUnit timestampUnit);
+
+
+  static struct ::tm* buildTimeInfo(struct timeval* currTime, struct ::tm* timeInfo);
+ private:
+  static char* parseFormat(char* buf, std::size_t bufSz, const char* format, const struct tm* tInfo,
+                           std::size_t msec, const base::SubsecondPrecision* ssPrec);
+};
+/// @brief Command line arguments for application if specified using el::Helpers::setArgs(..) or START_EASYLOGGINGPP(..)
+class CommandLineArgs {
+ public:
+  CommandLineArgs(void) {
+    setArgs(0, static_cast<char**>(nullptr));
+  }
+  CommandLineArgs(int argc, const char** argv) {
+    setArgs(argc, argv);
+  }
+  CommandLineArgs(int argc, char** argv) {
+    setArgs(argc, argv);
+  }
+  virtual ~CommandLineArgs(void) {}
+  /// @brief Sets arguments and parses them
+  inline void setArgs(int argc, const char** argv) {
+    setArgs(argc, const_cast<char**>(argv));
+  }
+  /// @brief Sets arguments and parses them
+  void setArgs(int argc, char** argv);
+  /// @brief Returns true if arguments contain paramKey with a value (seperated by '=')
+  bool hasParamWithValue(const char* paramKey) const;
+  /// @brief Returns value of arguments
+  /// @see hasParamWithValue(const char*)
+  const char* getParamValue(const char* paramKey) const;
+  /// @brief Return true if arguments has a param (not having a value) i,e without '='
+  bool hasParam(const char* paramKey) const;
+  /// @brief Returns true if no params available. This exclude argv[0]
+  bool empty(void) const;
+  /// @brief Returns total number of arguments. This exclude argv[0]
+  std::size_t size(void) const;
+  friend base::type::ostream_t& operator<<(base::type::ostream_t& os, const CommandLineArgs& c);
+
+ private:
+  int m_argc;
+  char** m_argv;
+  std::unordered_map<std::string, std::string> m_paramsWithValue;
+  std::vector<std::string> m_params;
+};
+/// @brief Abstract registry (aka repository) that provides basic interface for pointer repository specified by T_Ptr type.
+///
+/// @detail Most of the functions are virtual final methods but anything implementing this abstract class should implement
+/// unregisterAll() and deepCopy(const AbstractRegistry<T_Ptr, Container>&) and write registerNew() method according to container
+/// and few more methods; get() to find element, unregister() to unregister single entry.
+/// Please note that this is thread-unsafe and should also implement thread-safety mechanisms in implementation.
+template <typename T_Ptr, typename Container>
+class AbstractRegistry : public base::threading::ThreadSafe {
+ public:
+  typedef typename Container::iterator iterator;
+  typedef typename Container::const_iterator const_iterator;
+
+  /// @brief Default constructor
+  AbstractRegistry(void) {}
+
+  /// @brief Move constructor that is useful for base classes
+  AbstractRegistry(AbstractRegistry&& sr) {
+    if (this == &sr) {
+      return;
+    }
+    unregisterAll();
+    m_list = std::move(sr.m_list);
+  }
+
+  bool operator==(const AbstractRegistry<T_Ptr, Container>& other) {
+    if (size() != other.size()) {
+      return false;
+    }
+    for (std::size_t i = 0; i < m_list.size(); ++i) {
+      if (m_list.at(i) != other.m_list.at(i)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  bool operator!=(const AbstractRegistry<T_Ptr, Container>& other) {
+    if (size() != other.size()) {
+      return true;
+    }
+    for (std::size_t i = 0; i < m_list.size(); ++i) {
+      if (m_list.at(i) != other.m_list.at(i)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /// @brief Assignment move operator
+  AbstractRegistry& operator=(AbstractRegistry&& sr) {
+    if (this == &sr) {
+      return *this;
+    }
+    unregisterAll();
+    m_list = std::move(sr.m_list);
+    return *this;
+  }
+
+  virtual ~AbstractRegistry(void) {
+  }
+
+  /// @return Iterator pointer from start of repository
+  virtual inline iterator begin(void) ELPP_FINAL {
+    return m_list.begin();
+  }
+
+  /// @return Iterator pointer from end of repository
+  virtual inline iterator end(void) ELPP_FINAL {
+    return m_list.end();
+  }
+
+
+  /// @return Constant iterator pointer from start of repository
+  virtual inline const_iterator cbegin(void) const ELPP_FINAL {
+    return m_list.cbegin();
+  }
+
+  /// @return End of repository
+  virtual inline const_iterator cend(void) const ELPP_FINAL {
+    return m_list.cend();
+  }
+
+  /// @return Whether or not repository is empty
+  virtual inline bool empty(void) const ELPP_FINAL {
+    return m_list.empty();
+  }
+
+  /// @return Size of repository
+  virtual inline std::size_t size(void) const ELPP_FINAL {
+    return m_list.size();
+  }
+
+  /// @brief Returns underlying container by reference
+  virtual inline Container& list(void) ELPP_FINAL {
+    return m_list;
+  }
+
+  /// @brief Returns underlying container by constant reference.
+  virtual inline const Container& list(void) const ELPP_FINAL {
+    return m_list;
+  }
+
+  /// @brief Unregisters all the pointers from current repository.
+  virtual void unregisterAll(void) = 0;
+
+ protected:
+  virtual void deepCopy(const AbstractRegistry<T_Ptr, Container>&) = 0;
+  void reinitDeepCopy(const AbstractRegistry<T_Ptr, Container>& sr) {
+    unregisterAll();
+    deepCopy(sr);
+  }
+
+ private:
+  Container m_list;
+};
+
+/// @brief A pointer registry mechanism to manage memory and provide search functionalities. (non-predicate version)
+///
+/// @detail NOTE: This is thread-unsafe implementation (although it contains lock function, it does not use these functions)
+///         of AbstractRegistry<T_Ptr, Container>. Any implementation of this class should be
+///         explicitly (by using lock functions)
+template <typename T_Ptr, typename T_Key = const char*>
+class Registry : public AbstractRegistry<T_Ptr, std::unordered_map<T_Key, T_Ptr*>> {
+ public:
+  typedef typename Registry<T_Ptr, T_Key>::iterator iterator;
+  typedef typename Registry<T_Ptr, T_Key>::const_iterator const_iterator;
+
+  Registry(void) {}
+
+  /// @brief Copy constructor that is useful for base classes. Try to avoid this constructor, use move constructor.
+  Registry(const Registry& sr) : AbstractRegistry<T_Ptr, std::vector<T_Ptr*>>() {
+    if (this == &sr) {
+      return;
+    }
+    this->reinitDeepCopy(sr);
+  }
+
+  /// @brief Assignment operator that unregisters all the existing registeries and deeply copies each of repo element
+  /// @see unregisterAll()
+  /// @see deepCopy(const AbstractRegistry&)
+  Registry& operator=(const Registry& sr) {
+    if (this == &sr) {
+      return *this;
+    }
+    this->reinitDeepCopy(sr);
+    return *this;
+  }
+
+  virtual ~Registry(void) {
+    unregisterAll();
+  }
+
+ protected:
+  virtual void unregisterAll(void) ELPP_FINAL {
+    if (!this->empty()) {
+      for (auto&& curr : this->list()) {
+        base::utils::safeDelete(curr.second);
+      }
+      this->list().clear();
+    }
+  }
+
+/// @brief Registers new registry to repository.
+  virtual void registerNew(const T_Key& uniqKey, T_Ptr* ptr) ELPP_FINAL {
+    unregister(uniqKey);
+    this->list().insert(std::make_pair(uniqKey, ptr));
+  }
+
+/// @brief Unregisters single entry mapped to specified unique key
+  void unregister(const T_Key& uniqKey) {
+    T_Ptr* existing = get(uniqKey);
+    if (existing != nullptr) {
+      this->list().erase(uniqKey);
+      base::utils::safeDelete(existing);
+    }
+  }
+
+/// @brief Gets pointer from repository. If none found, nullptr is returned.
+  T_Ptr* get(const T_Key& uniqKey) {
+    iterator it = this->list().find(uniqKey);
+    return it == this->list().end()
+           ? nullptr
+           : it->second;
+  }
+
+ private:
+  virtual void deepCopy(const AbstractRegistry<T_Ptr, std::unordered_map<T_Key, T_Ptr*>>& sr) ELPP_FINAL {
+    for (const_iterator it = sr.cbegin(); it != sr.cend(); ++it) {
+      registerNew(it->first, new T_Ptr(*it->second));
+    }
+  }
+};
+
+/// @brief A pointer registry mechanism to manage memory and provide search functionalities. (predicate version)
+///
+/// @detail NOTE: This is thread-unsafe implementation of AbstractRegistry<T_Ptr, Container>. Any implementation of this class
+/// should be made thread-safe explicitly
+template <typename T_Ptr, typename Pred>
+class RegistryWithPred : public AbstractRegistry<T_Ptr, std::vector<T_Ptr*>> {
+ public:
+  typedef typename RegistryWithPred<T_Ptr, Pred>::iterator iterator;
+  typedef typename RegistryWithPred<T_Ptr, Pred>::const_iterator const_iterator;
+
+  RegistryWithPred(void) {
+  }
+
+  virtual ~RegistryWithPred(void) {
+    unregisterAll();
+  }
+
+  /// @brief Copy constructor that is useful for base classes. Try to avoid this constructor, use move constructor.
+  RegistryWithPred(const RegistryWithPred& sr) : AbstractRegistry<T_Ptr, std::vector<T_Ptr*>>() {
+    if (this == &sr) {
+      return;
+    }
+    this->reinitDeepCopy(sr);
+  }
+
+  /// @brief Assignment operator that unregisters all the existing registeries and deeply copies each of repo element
+  /// @see unregisterAll()
+  /// @see deepCopy(const AbstractRegistry&)
+  RegistryWithPred& operator=(const RegistryWithPred& sr) {
+    if (this == &sr) {
+      return *this;
+    }
+    this->reinitDeepCopy(sr);
+    return *this;
+  }
+
+  friend base::type::ostream_t& operator<<(base::type::ostream_t& os, const RegistryWithPred& sr) {
+    for (const_iterator it = sr.list().begin(); it != sr.list().end(); ++it) {
+      os << ELPP_LITERAL("    ") << **it << ELPP_LITERAL("\n");
+    }
+    return os;
+  }
+
+ protected:
+  virtual void unregisterAll(void) ELPP_FINAL {
+    if (!this->empty()) {
+      for (auto&& curr : this->list()) {
+        base::utils::safeDelete(curr);
+      }
+      this->list().clear();
+    }
+  }
+
+  virtual void unregister(T_Ptr*& ptr) ELPP_FINAL {
+    if (ptr) {
+      iterator iter = this->begin();
+      for (; iter != this->end(); ++iter) {
+        if (ptr == *iter) {
+          break;
+        }
+      }
+      if (iter != this->end() && *iter != nullptr) {
+        this->list().erase(iter);
+        base::utils::safeDelete(*iter);
+      }
+    }
+  }
+
+  virtual inline void registerNew(T_Ptr* ptr) ELPP_FINAL {
+    this->list().push_back(ptr);
+  }
+
+/// @brief Gets pointer from repository with speicifed arguments. Arguments are passed to predicate
+/// in order to validate pointer.
+  template <typename T, typename T2>
+  T_Ptr* get(const T& arg1, const T2 arg2) {
+    iterator iter = std::find_if(this->list().begin(), this->list().end(), Pred(arg1, arg2));
+    if (iter != this->list().end() && *iter != nullptr) {
+      return *iter;
+    }
+    return nullptr;
+  }
+
+ private:
+  virtual void deepCopy(const AbstractRegistry<T_Ptr, std::vector<T_Ptr*>>& sr) {
+    for (const_iterator it = sr.list().begin(); it != sr.list().end(); ++it) {
+      registerNew(new T_Ptr(**it));
+    }
+  }
+};
+class Utils {
+ public:
+  template <typename T, typename TPtr>
+  static bool installCallback(const std::string& id, std::unordered_map<std::string, TPtr>* mapT) {
+    if (mapT->find(id) == mapT->end()) {
+      mapT->insert(std::make_pair(id, TPtr(new T())));
+      return true;
+    }
+    return false;
+  }
+
+  template <typename T, typename TPtr>
+  static void uninstallCallback(const std::string& id, std::unordered_map<std::string, TPtr>* mapT) {
+    if (mapT->find(id) != mapT->end()) {
+      mapT->erase(id);
+    }
+  }
+
+  template <typename T, typename TPtr>
+  static T* callback(const std::string& id, std::unordered_map<std::string, TPtr>* mapT) {
+    typename std::unordered_map<std::string, TPtr>::iterator iter = mapT->find(id);
+    if (iter != mapT->end()) {
+      return static_cast<T*>(iter->second.get());
+    }
+    return nullptr;
+  }
+};
+}  // namespace utils
+} // namespace base
+/// @brief Base of Easylogging++ friendly class
+///
+/// @detail After inheriting this class publicly, implement pure-virtual function `void log(std::ostream&) const`
+class Loggable {
+ public:
+  virtual ~Loggable(void) {}
+  virtual void log(el::base::type::ostream_t&) const = 0;
+ private:
+  friend inline el::base::type::ostream_t& operator<<(el::base::type::ostream_t& os, const Loggable& loggable) {
+    loggable.log(os);
+    return os;
+  }
+};
+namespace base {
+/// @brief Represents log format containing flags and date format. This is used internally to start initial log
+class LogFormat : public Loggable {
+ public:
+  LogFormat(void);
+  LogFormat(Level level, const base::type::string_t& format);
+  LogFormat(const LogFormat& logFormat);
+  LogFormat(LogFormat&& logFormat);
+  LogFormat& operator=(const LogFormat& logFormat);
+  virtual ~LogFormat(void) {}
+  bool operator==(const LogFormat& other);
+
+  /// @brief Updates format to be used while logging.
+  /// @param userFormat User provided format
+  void parseFromFormat(const base::type::string_t& userFormat);
+
+  inline Level level(void) const {
+    return m_level;
+  }
+
+  inline const base::type::string_t& userFormat(void) const {
+    return m_userFormat;
+  }
+
+  inline const base::type::string_t& format(void) const {
+    return m_format;
+  }
+
+  inline const std::string& dateTimeFormat(void) const {
+    return m_dateTimeFormat;
+  }
+
+  inline base::type::EnumType flags(void) const {
+    return m_flags;
+  }
+
+  inline bool hasFlag(base::FormatFlags flag) const {
+    return base::utils::hasFlag(flag, m_flags);
+  }
+
+  virtual void log(el::base::type::ostream_t& os) const {
+    os << m_format;
+  }
+
+ protected:
+  /// @brief Updates date time format if available in currFormat.
+  /// @param index Index where %datetime, %date or %time was found
+  /// @param [in,out] currFormat current format that is being used to format
+  virtual void updateDateFormat(std::size_t index, base::type::string_t& currFormat) ELPP_FINAL;
+
+  /// @brief Updates %level from format. This is so that we dont have to do it at log-writing-time. It uses m_format and m_level
+  virtual void updateFormatSpec(void) ELPP_FINAL;
+
+  inline void addFlag(base::FormatFlags flag) {
+    base::utils::addFlag(flag, &m_flags);
+  }
+
+ private:
+  Level m_level;
+  base::type::string_t m_userFormat;
+  base::type::string_t m_format;
+  std::string m_dateTimeFormat;
+  base::type::EnumType m_flags;
+  std::string m_currentUser;
+  std::string m_currentHost;
+  friend class el::Logger;  // To resolve loggerId format specifier easily
+};
+}  // namespace base
+/// @brief Resolving function for format specifier
+typedef std::function<std::string(const LogMessage*)> FormatSpecifierValueResolver;
+/// @brief User-provided custom format specifier
+/// @see el::Helpers::installCustomFormatSpecifier
+/// @see FormatSpecifierValueResolver
+class CustomFormatSpecifier {
+ public:
+  CustomFormatSpecifier(const char* formatSpecifier, const FormatSpecifierValueResolver& resolver) :
+    m_formatSpecifier(formatSpecifier), m_resolver(resolver) {}
+  inline const char* formatSpecifier(void) const {
+    return m_formatSpecifier;
+  }
+  inline const FormatSpecifierValueResolver& resolver(void) const {
+    return m_resolver;
+  }
+  inline bool operator==(const char* formatSpecifier) {
+    return strcmp(m_formatSpecifier, formatSpecifier) == 0;
+  }
+
+ private:
+  const char* m_formatSpecifier;
+  FormatSpecifierValueResolver m_resolver;
+};
+/// @brief Represents single configuration that has representing level, configuration type and a string based value.
+///
+/// @detail String based value means any value either its boolean, integer or string itself, it will be embedded inside quotes
+/// and will be parsed later.
+///
+/// Consider some examples below:
+///   * el::Configuration confEnabledInfo(el::Level::Info, el::ConfigurationType::Enabled, "true");
+///   * el::Configuration confMaxLogFileSizeInfo(el::Level::Info, el::ConfigurationType::MaxLogFileSize, "2048");
+///   * el::Configuration confFilenameInfo(el::Level::Info, el::ConfigurationType::Filename, "/var/log/my.log");
+class Configuration : public Loggable {
+ public:
+  Configuration(const Configuration& c);
+  Configuration& operator=(const Configuration& c);
+
+  virtual ~Configuration(void) {
+  }
+
+  /// @brief Full constructor used to sets value of configuration
+  Configuration(Level level, ConfigurationType configurationType, const std::string& value);
+
+  /// @brief Gets level of current configuration
+  inline Level level(void) const {
+    return m_level;
+  }
+
+  /// @brief Gets configuration type of current configuration
+  inline ConfigurationType configurationType(void) const {
+    return m_configurationType;
+  }
+
+  /// @brief Gets string based configuration value
+  inline const std::string& value(void) const {
+    return m_value;
+  }
+
+  /// @brief Set string based configuration value
+  /// @param value Value to set. Values have to be std::string; For boolean values use "true", "false", for any integral values
+  ///        use them in quotes. They will be parsed when configuring
+  inline void setValue(const std::string& value) {
+    m_value = value;
+  }
+
+  virtual void log(el::base::type::ostream_t& os) const;
+
+  /// @brief Used to find configuration from configuration (pointers) repository. Avoid using it.
+  class Predicate {
+   public:
+    Predicate(Level level, ConfigurationType configurationType);
+
+    bool operator()(const Configuration* conf) const;
+
+   private:
+    Level m_level;
+    ConfigurationType m_configurationType;
+  };
+
+ private:
+  Level m_level;
+  ConfigurationType m_configurationType;
+  std::string m_value;
+};
+
+/// @brief Thread-safe Configuration repository
+///
+/// @detail This repository represents configurations for all the levels and configuration type mapped to a value.
+class Configurations : public base::utils::RegistryWithPred<Configuration, Configuration::Predicate> {
+ public:
+  /// @brief Default constructor with empty repository
+  Configurations(void);
+
+  /// @brief Constructor used to set configurations using configuration file.
+  /// @param configurationFile Full path to configuration file
+  /// @param useDefaultsForRemaining Lets you set the remaining configurations to default.
+  /// @param base If provided, this configuration will be based off existing repository that this argument is pointing to.
+  /// @see parseFromFile(const std::string&, Configurations* base)
+  /// @see setRemainingToDefault()
+  Configurations(const std::string& configurationFile, bool useDefaultsForRemaining = true,
+                 Configurations* base = nullptr);
+
+  virtual ~Configurations(void) {
+  }
+
+  /// @brief Parses configuration from file.
+  /// @param configurationFile Full path to configuration file
+  /// @param base Configurations to base new configuration repository off. This value is used when you want to use
+  ///        existing Configurations to base all the values and then set rest of configuration via configuration file.
+  /// @return True if successfully parsed, false otherwise. You may define 'ELPP_DEBUG_ASSERT_FAILURE' to make sure you
+  ///         do not proceed without successful parse.
+  bool parseFromFile(const std::string& configurationFile, Configurations* base = nullptr);
+
+  /// @brief Parse configurations from configuration string.
+  ///
+  /// @detail This configuration string has same syntax as configuration file contents. Make sure all the necessary
+  /// new line characters are provided.
+  /// @param base Configurations to base new configuration repository off. This value is used when you want to use
+  ///        existing Configurations to base all the values and then set rest of configuration via configuration text.
+  /// @return True if successfully parsed, false otherwise. You may define 'ELPP_DEBUG_ASSERT_FAILURE' to make sure you
+  ///         do not proceed without successful parse.
+  bool parseFromText(const std::string& configurationsString, Configurations* base = nullptr);
+
+  /// @brief Sets configuration based-off an existing configurations.
+  /// @param base Pointer to existing configurations.
+  void setFromBase(Configurations* base);
+
+  /// @brief Determines whether or not specified configuration type exists in the repository.
+  ///
+  /// @detail Returns as soon as first level is found.
+  /// @param configurationType Type of configuration to check existence for.
+  bool hasConfiguration(ConfigurationType configurationType);
+
+  /// @brief Determines whether or not specified configuration type exists for specified level
+  /// @param level Level to check
+  /// @param configurationType Type of configuration to check existence for.
+  bool hasConfiguration(Level level, ConfigurationType configurationType);
+
+  /// @brief Sets value of configuration for specified level.
+  ///
+  /// @detail Any existing configuration for specified level will be replaced. Also note that configuration types
+  /// ConfigurationType::SubsecondPrecision and ConfigurationType::PerformanceTracking will be ignored if not set for
+  /// Level::Global because these configurations are not dependant on level.
+  /// @param level Level to set configuration for (el::Level).
+  /// @param configurationType Type of configuration (el::ConfigurationType)
+  /// @param value A string based value. Regardless of what the data type of configuration is, it will always be string
+  /// from users' point of view. This is then parsed later to be used internally.
+  /// @see Configuration::setValue(const std::string& value)
+  /// @see el::Level
+  /// @see el::ConfigurationType
+  void set(Level level, ConfigurationType configurationType, const std::string& value);
+
+  /// @brief Sets single configuration based on other single configuration.
+  /// @see set(Level level, ConfigurationType configurationType, const std::string& value)
+  void set(Configuration* conf);
+
+  inline Configuration* get(Level level, ConfigurationType configurationType) {
+    base::threading::ScopedLock scopedLock(lock());
+    return RegistryWithPred<Configuration, Configuration::Predicate>::get(level, configurationType);
+  }
+
+  /// @brief Sets configuration for all levels.
+  /// @param configurationType Type of configuration
+  /// @param value String based value
+  /// @see Configurations::set(Level level, ConfigurationType configurationType, const std::string& value)
+  inline void setGlobally(ConfigurationType configurationType, const std::string& value) {
+    setGlobally(configurationType, value, false);
+  }
+
+  /// @brief Clears repository so that all the configurations are unset
+  inline void clear(void) {
+    base::threading::ScopedLock scopedLock(lock());
+    unregisterAll();
+  }
+
+  /// @brief Gets configuration file used in parsing this configurations.
+  ///
+  /// @detail If this repository was set manually or by text this returns empty string.
+  inline const std::string& configurationFile(void) const {
+    return m_configurationFile;
+  }
+
+  /// @brief Sets configurations to "factory based" configurations.
+  void setToDefault(void);
+
+  /// @brief Lets you set the remaining configurations to default.
+  ///
+  /// @detail By remaining, it means that the level/type a configuration does not exist for.
+  /// This function is useful when you want to minimize chances of failures, e.g, if you have a configuration file that sets
+  /// configuration for all the configurations except for Enabled or not, we use this so that ENABLED is set to default i.e,
+  /// true. If you dont do this explicitly (either by calling this function or by using second param in Constructor
+  /// and try to access a value, an error is thrown
+  void setRemainingToDefault(void);
+
+  /// @brief Parser used internally to parse configurations from file or text.
+  ///
+  /// @detail This class makes use of base::utils::Str.
+  /// You should not need this unless you are working on some tool for Easylogging++
+  class Parser : base::StaticClass {
+   public:
+    /// @brief Parses configuration from file.
+    /// @param configurationFile Full path to configuration file
+    /// @param sender Sender configurations pointer. Usually 'this' is used from calling class
+    /// @param base Configurations to base new configuration repository off. This value is used when you want to use
+    ///        existing Configurations to base all the values and then set rest of configuration via configuration file.
+    /// @return True if successfully parsed, false otherwise. You may define '_STOP_ON_FIRSTELPP_ASSERTION' to make sure you
+    ///         do not proceed without successful parse.
+    static bool parseFromFile(const std::string& configurationFile, Configurations* sender,
+                              Configurations* base = nullptr);
+
+    /// @brief Parse configurations from configuration string.
+    ///
+    /// @detail This configuration string has same syntax as configuration file contents. Make sure all the necessary
+    /// new line characters are provided. You may define '_STOP_ON_FIRSTELPP_ASSERTION' to make sure you
+    /// do not proceed without successful parse (This is recommended)
+    /// @param configurationsString the configuration in plain text format
+    /// @param sender Sender configurations pointer. Usually 'this' is used from calling class
+    /// @param base Configurations to base new configuration repository off. This value is used when you want to use
+    ///        existing Configurations to base all the values and then set rest of configuration via configuration text.
+    /// @return True if successfully parsed, false otherwise.
+    static bool parseFromText(const std::string& configurationsString, Configurations* sender,
+                              Configurations* base = nullptr);
+
+   private:
+    friend class el::Loggers;
+    static void ignoreComments(std::string* line);
+    static bool isLevel(const std::string& line);
+    static bool isComment(const std::string& line);
+    static inline bool isConfig(const std::string& line);
+    static bool parseLine(std::string* line, std::string* currConfigStr, std::string* currLevelStr, Level* currLevel,
+                          Configurations* conf);
+  };
+
+ private:
+  std::string m_configurationFile;
+  bool m_isFromFile;
+  friend class el::Loggers;
+
+  /// @brief Unsafely sets configuration if does not already exist
+  void unsafeSetIfNotExist(Level level, ConfigurationType configurationType, const std::string& value);
+
+  /// @brief Thread unsafe set
+  void unsafeSet(Level level, ConfigurationType configurationType, const std::string& value);
+
+  /// @brief Sets configurations for all levels including Level::Global if includeGlobalLevel is true
+  /// @see Configurations::setGlobally(ConfigurationType configurationType, const std::string& value)
+  void setGlobally(ConfigurationType configurationType, const std::string& value, bool includeGlobalLevel);
+
+  /// @brief Sets configurations (Unsafely) for all levels including Level::Global if includeGlobalLevel is true
+  /// @see Configurations::setGlobally(ConfigurationType configurationType, const std::string& value)
+  void unsafeSetGlobally(ConfigurationType configurationType, const std::string& value, bool includeGlobalLevel);
+};
+
+namespace base {
+typedef std::shared_ptr<base::type::fstream_t> FileStreamPtr;
+typedef std::unordered_map<std::string, FileStreamPtr> LogStreamsReferenceMap;
+/// @brief Configurations with data types.
+///
+/// @detail el::Configurations have string based values. This is whats used internally in order to read correct configurations.
+/// This is to perform faster while writing logs using correct configurations.
+///
+/// This is thread safe and final class containing non-virtual destructor (means nothing should inherit this class)
+class TypedConfigurations : public base::threading::ThreadSafe {
+ public:
+  /// @brief Constructor to initialize (construct) the object off el::Configurations
+  /// @param configurations Configurations pointer/reference to base this typed configurations off.
+  /// @param logStreamsReference Use ELPP->registeredLoggers()->logStreamsReference()
+  TypedConfigurations(Configurations* configurations, base::LogStreamsReferenceMap* logStreamsReference);
+
+  TypedConfigurations(const TypedConfigurations& other);
+
+  virtual ~TypedConfigurations(void) {
+  }
+
+  const Configurations* configurations(void) const {
+    return m_configurations;
+  }
+
+  bool enabled(Level level);
+  bool toFile(Level level);
+  const std::string& filename(Level level);
+  bool toStandardOutput(Level level);
+  const base::LogFormat& logFormat(Level level);
+  const base::SubsecondPrecision& subsecondPrecision(Level level = Level::Global);
+  const base::MillisecondsWidth& millisecondsWidth(Level level = Level::Global);
+  bool performanceTracking(Level level = Level::Global);
+  base::type::fstream_t* fileStream(Level level);
+  std::size_t maxLogFileSize(Level level);
+  std::size_t logFlushThreshold(Level level);
+
+ private:
+  Configurations* m_configurations;
+  std::unordered_map<Level, bool> m_enabledMap;
+  std::unordered_map<Level, bool> m_toFileMap;
+  std::unordered_map<Level, std::string> m_filenameMap;
+  std::unordered_map<Level, bool> m_toStandardOutputMap;
+  std::unordered_map<Level, base::LogFormat> m_logFormatMap;
+  std::unordered_map<Level, base::SubsecondPrecision> m_subsecondPrecisionMap;
+  std::unordered_map<Level, bool> m_performanceTrackingMap;
+  std::unordered_map<Level, base::FileStreamPtr> m_fileStreamMap;
+  std::unordered_map<Level, std::size_t> m_maxLogFileSizeMap;
+  std::unordered_map<Level, std::size_t> m_logFlushThresholdMap;
+  base::LogStreamsReferenceMap* m_logStreamsReference;
+
+  friend class el::Helpers;
+  friend class el::base::MessageBuilder;
+  friend class el::base::Writer;
+  friend class el::base::DefaultLogDispatchCallback;
+  friend class el::base::LogDispatcher;
+
+  template <typename Conf_T>
+  inline Conf_T getConfigByVal(Level level, const std::unordered_map<Level, Conf_T>* confMap, const char* confName) {
+    base::threading::ScopedLock scopedLock(lock());
+    return unsafeGetConfigByVal(level, confMap, confName);  // This is not unsafe anymore - mutex locked in scope
+  }
+
+  template <typename Conf_T>
+  inline Conf_T& getConfigByRef(Level level, std::unordered_map<Level, Conf_T>* confMap, const char* confName) {
+    base::threading::ScopedLock scopedLock(lock());
+    return unsafeGetConfigByRef(level, confMap, confName);  // This is not unsafe anymore - mutex locked in scope
+  }
+
+  template <typename Conf_T>
+  Conf_T unsafeGetConfigByVal(Level level, const std::unordered_map<Level, Conf_T>* confMap, const char* confName) {
+    ELPP_UNUSED(confName);
+    typename std::unordered_map<Level, Conf_T>::const_iterator it = confMap->find(level);
+    if (it == confMap->end()) {
+      try {
+        return confMap->at(Level::Global);
+      } catch (...) {
+        ELPP_INTERNAL_ERROR("Unable to get configuration [" << confName << "] for level ["
+                            << LevelHelper::convertToString(level) << "]"
+                            << std::endl << "Please ensure you have properly configured logger.", false);
+        return Conf_T();
+      }
+    }
+    return it->second;
+  }
+
+  template <typename Conf_T>
+  Conf_T& unsafeGetConfigByRef(Level level, std::unordered_map<Level, Conf_T>* confMap, const char* confName) {
+    ELPP_UNUSED(confName);
+    typename std::unordered_map<Level, Conf_T>::iterator it = confMap->find(level);
+    if (it == confMap->end()) {
+      try {
+        return confMap->at(Level::Global);
+      } catch (...) {
+        ELPP_INTERNAL_ERROR("Unable to get configuration [" << confName << "] for level ["
+                            << LevelHelper::convertToString(level) << "]"
+                            << std::endl << "Please ensure you have properly configured logger.", false);
+      }
+    }
+    return it->second;
+  }
+
+  template <typename Conf_T>
+  void setValue(Level level, const Conf_T& value, std::unordered_map<Level, Conf_T>* confMap,
+                bool includeGlobalLevel = true) {
+    // If map is empty and we are allowed to add into generic level (Level::Global), do it!
+    if (confMap->empty() && includeGlobalLevel) {
+      confMap->insert(std::make_pair(Level::Global, value));
+      return;
+    }
+    // If same value exist in generic level already, dont add it to explicit level
+    typename std::unordered_map<Level, Conf_T>::iterator it = confMap->find(Level::Global);
+    if (it != confMap->end() && it->second == value) {
+      return;
+    }
+    // Now make sure we dont double up values if we really need to add it to explicit level
+    it = confMap->find(level);
+    if (it == confMap->end()) {
+      // Value not found for level, add new
+      confMap->insert(std::make_pair(level, value));
+    } else {
+      // Value found, just update value
+      confMap->at(level) = value;
+    }
+  }
+
+  void build(Configurations* configurations);
+  unsigned long getULong(std::string confVal);
+  std::string resolveFilename(const std::string& filename);
+  void insertFile(Level level, const std::string& fullFilename);
+  bool unsafeValidateFileRolling(Level level, const PreRollOutCallback& preRollOutCallback);
+
+  inline bool validateFileRolling(Level level, const PreRollOutCallback& preRollOutCallback) {
+    base::threading::ScopedLock scopedLock(lock());
+    return unsafeValidateFileRolling(level, preRollOutCallback);
+  }
+};
+/// @brief Class that keeps record of current line hit for occasional logging
+class HitCounter {
+ public:
+  HitCounter(void) :
+    m_filename(""),
+    m_lineNumber(0),
+    m_hitCounts(0) {
+  }
+
+  HitCounter(const char* filename, base::type::LineNumber lineNumber) :
+    m_filename(filename),
+    m_lineNumber(lineNumber),
+    m_hitCounts(0) {
+  }
+
+  HitCounter(const HitCounter& hitCounter) :
+    m_filename(hitCounter.m_filename),
+    m_lineNumber(hitCounter.m_lineNumber),
+    m_hitCounts(hitCounter.m_hitCounts) {
+  }
+
+  HitCounter& operator=(const HitCounter& hitCounter) {
+    if (&hitCounter != this) {
+      m_filename = hitCounter.m_filename;
+      m_lineNumber = hitCounter.m_lineNumber;
+      m_hitCounts = hitCounter.m_hitCounts;
+    }
+    return *this;
+  }
+
+  virtual ~HitCounter(void) {
+  }
+
+  /// @brief Resets location of current hit counter
+  inline void resetLocation(const char* filename, base::type::LineNumber lineNumber) {
+    m_filename = filename;
+    m_lineNumber = lineNumber;
+  }
+
+  /// @brief Validates hit counts and resets it if necessary
+  inline void validateHitCounts(std::size_t n) {
+    if (m_hitCounts >= base::consts::kMaxLogPerCounter) {
+      m_hitCounts = (n >= 1 ? base::consts::kMaxLogPerCounter % n : 0);
+    }
+    ++m_hitCounts;
+  }
+
+  inline const char* filename(void) const {
+    return m_filename;
+  }
+
+  inline base::type::LineNumber lineNumber(void) const {
+    return m_lineNumber;
+  }
+
+  inline std::size_t hitCounts(void) const {
+    return m_hitCounts;
+  }
+
+  inline void increment(void) {
+    ++m_hitCounts;
+  }
+
+  class Predicate {
+   public:
+    Predicate(const char* filename, base::type::LineNumber lineNumber)
+      : m_filename(filename),
+        m_lineNumber(lineNumber) {
+    }
+    inline bool operator()(const HitCounter* counter) {
+      return ((counter != nullptr) &&
+              (strcmp(counter->m_filename, m_filename) == 0) &&
+              (counter->m_lineNumber == m_lineNumber));
+    }
+
+   private:
+    const char* m_filename;
+    base::type::LineNumber m_lineNumber;
+  };
+
+ private:
+  const char* m_filename;
+  base::type::LineNumber m_lineNumber;
+  std::size_t m_hitCounts;
+};
+/// @brief Repository for hit counters used across the application
+class RegisteredHitCounters : public base::utils::RegistryWithPred<base::HitCounter, base::HitCounter::Predicate> {
+ public:
+  /// @brief Validates counter for every N, i.e, registers new if does not exist otherwise updates original one
+  /// @return True if validation resulted in triggering hit. Meaning logs should be written everytime true is returned
+  bool validateEveryN(const char* filename, base::type::LineNumber lineNumber, std::size_t n);
+
+  /// @brief Validates counter for hits >= N, i.e, registers new if does not exist otherwise updates original one
+  /// @return True if validation resulted in triggering hit. Meaning logs should be written everytime true is returned
+  bool validateAfterN(const char* filename, base::type::LineNumber lineNumber, std::size_t n);
+
+  /// @brief Validates counter for hits are <= n, i.e, registers new if does not exist otherwise updates original one
+  /// @return True if validation resulted in triggering hit. Meaning logs should be written everytime true is returned
+  bool validateNTimes(const char* filename, base::type::LineNumber lineNumber, std::size_t n);
+
+  /// @brief Gets hit counter registered at specified position
+  inline const base::HitCounter* getCounter(const char* filename, base::type::LineNumber lineNumber) {
+    base::threading::ScopedLock scopedLock(lock());
+    return get(filename, lineNumber);
+  }
+};
+/// @brief Action to be taken for dispatching
+enum class DispatchAction : base::type::EnumType {
+  None = 1, NormalLog = 2, SysLog = 4
+};
+}  // namespace base
+template <typename T>
+class Callback : protected base::threading::ThreadSafe {
+ public:
+  Callback(void) : m_enabled(true) {}
+  inline bool enabled(void) const {
+    return m_enabled;
+  }
+  inline void setEnabled(bool enabled) {
+    base::threading::ScopedLock scopedLock(lock());
+    m_enabled = enabled;
+  }
+ protected:
+  virtual void handle(const T* handlePtr) = 0;
+ private:
+  bool m_enabled;
+};
+class LogDispatchData {
+ public:
+  LogDispatchData() : m_logMessage(nullptr), m_dispatchAction(base::DispatchAction::None) {}
+  inline const LogMessage* logMessage(void) const {
+    return m_logMessage;
+  }
+  inline base::DispatchAction dispatchAction(void) const {
+    return m_dispatchAction;
+  }
+  inline void setLogMessage(LogMessage* logMessage) {
+    m_logMessage = logMessage;
+  }
+  inline void setDispatchAction(base::DispatchAction dispatchAction) {
+    m_dispatchAction = dispatchAction;
+  }
+ private:
+  LogMessage* m_logMessage;
+  base::DispatchAction m_dispatchAction;
+  friend class base::LogDispatcher;
+
+};
+class LogDispatchCallback : public Callback<LogDispatchData> {
+ protected:
+  virtual void handle(const LogDispatchData* data);
+  base::threading::Mutex& fileHandle(const LogDispatchData* data);
+ private:
+  friend class base::LogDispatcher;
+  std::unordered_map<std::string, std::unique_ptr<base::threading::Mutex>> m_fileLocks;
+  base::threading::Mutex m_fileLocksMapLock;
+};
+class PerformanceTrackingCallback : public Callback<PerformanceTrackingData> {
+ private:
+  friend class base::PerformanceTracker;
+};
+class LoggerRegistrationCallback : public Callback<Logger> {
+ private:
+  friend class base::RegisteredLoggers;
+};
+class LogBuilder : base::NoCopy {
+ public:
+  LogBuilder() : m_termSupportsColor(base::utils::OS::termSupportsColor()) {}
+  virtual ~LogBuilder(void) {
+    ELPP_INTERNAL_INFO(3, "Destroying log builder...")
+  }
+  virtual base::type::string_t build(const LogMessage* logMessage, bool appendNewLine) const = 0;
+  void convertToColoredOutput(base::type::string_t* logLine, Level level);
+ private:
+  bool m_termSupportsColor;
+  friend class el::base::DefaultLogDispatchCallback;
+};
+typedef std::shared_ptr<LogBuilder> LogBuilderPtr;
+/// @brief Represents a logger holding ID and configurations we need to write logs
+///
+/// @detail This class does not write logs itself instead its used by writer to read configuations from.
+class Logger : public base::threading::ThreadSafe, public Loggable {
+ public:
+  Logger(const std::string& id, base::LogStreamsReferenceMap* logStreamsReference);
+  Logger(const std::string& id, const Configurations& configurations, base::LogStreamsReferenceMap* logStreamsReference);
+  Logger(const Logger& logger);
+  Logger& operator=(const Logger& logger);
+
+  virtual ~Logger(void) {
+    base::utils::safeDelete(m_typedConfigurations);
+  }
+
+  virtual inline void log(el::base::type::ostream_t& os) const {
+    os << m_id.c_str();
+  }
+
+  /// @brief Configures the logger using specified configurations.
+  void configure(const Configurations& configurations);
+
+  /// @brief Reconfigures logger using existing configurations
+  void reconfigure(void);
+
+  inline const std::string& id(void) const {
+    return m_id;
+  }
+
+  inline const std::string& parentApplicationName(void) const {
+    return m_parentApplicationName;
+  }
+
+  inline void setParentApplicationName(const std::string& parentApplicationName) {
+    m_parentApplicationName = parentApplicationName;
+  }
+
+  inline Configurations* configurations(void) {
+    return &m_configurations;
+  }
+
+  inline base::TypedConfigurations* typedConfigurations(void) {
+    return m_typedConfigurations;
+  }
+
+  static bool isValidId(const std::string& id);
+
+  /// @brief Flushes logger to sync all log files for all levels
+  void flush(void);
+
+  void flush(Level level, base::type::fstream_t* fs);
+
+  inline bool isFlushNeeded(Level level) {
+    return ++m_unflushedCount.find(level)->second >= m_typedConfigurations->logFlushThreshold(level);
+  }
+
+  inline LogBuilder* logBuilder(void) const {
+    return m_logBuilder.get();
+  }
+
+  inline void setLogBuilder(const LogBuilderPtr& logBuilder) {
+    m_logBuilder = logBuilder;
+  }
+
+  inline bool enabled(Level level) const {
+    return m_typedConfigurations->enabled(level);
+  }
+
+#if ELPP_VARIADIC_TEMPLATES_SUPPORTED
+#  define LOGGER_LEVEL_WRITERS_SIGNATURES(FUNCTION_NAME)\
+template <typename T, typename... Args>\
+inline void FUNCTION_NAME(const char*, const T&, const Args&...);\
+template <typename T>\
+inline void FUNCTION_NAME(const T&);
+
+  template <typename T, typename... Args>
+  inline void verbose(int, const char*, const T&, const Args&...);
+
+  template <typename T>
+  inline void verbose(int, const T&);
+
+  LOGGER_LEVEL_WRITERS_SIGNATURES(info)
+  LOGGER_LEVEL_WRITERS_SIGNATURES(debug)
+  LOGGER_LEVEL_WRITERS_SIGNATURES(warn)
+  LOGGER_LEVEL_WRITERS_SIGNATURES(error)
+  LOGGER_LEVEL_WRITERS_SIGNATURES(fatal)
+  LOGGER_LEVEL_WRITERS_SIGNATURES(trace)
+#  undef LOGGER_LEVEL_WRITERS_SIGNATURES
+#endif // ELPP_VARIADIC_TEMPLATES_SUPPORTED
+ private:
+  std::string m_id;
+  base::TypedConfigurations* m_typedConfigurations;
+  base::type::stringstream_t m_stream;
+  std::string m_parentApplicationName;
+  bool m_isConfigured;
+  Configurations m_configurations;
+  std::unordered_map<Level, unsigned int> m_unflushedCount;
+  base::LogStreamsReferenceMap* m_logStreamsReference;
+  LogBuilderPtr m_logBuilder;
+
+  friend class el::LogMessage;
+  friend class el::Loggers;
+  friend class el::Helpers;
+  friend class el::base::RegisteredLoggers;
+  friend class el::base::DefaultLogDispatchCallback;
+  friend class el::base::MessageBuilder;
+  friend class el::base::Writer;
+  friend class el::base::PErrorWriter;
+  friend class el::base::Storage;
+  friend class el::base::PerformanceTracker;
+  friend class el::base::LogDispatcher;
+
+  Logger(void);
+
+#if ELPP_VARIADIC_TEMPLATES_SUPPORTED
+  template <typename T, typename... Args>
+  void log_(Level, int, const char*, const T&, const Args&...);
+
+  template <typename T>
+  inline void log_(Level, int, const T&);
+
+  template <typename T, typename... Args>
+  void log(Level, const char*, const T&, const Args&...);
+
+  template <typename T>
+  inline void log(Level, const T&);
+#endif // ELPP_VARIADIC_TEMPLATES_SUPPORTED
+
+  void initUnflushedCount(void);
+
+  inline base::type::stringstream_t& stream(void) {
+    return m_stream;
+  }
+
+  void resolveLoggerFormatSpec(void) const;
+};
+namespace base {
+/// @brief Loggers repository
+class RegisteredLoggers : public base::utils::Registry<Logger, std::string> {
+ public:
+  explicit RegisteredLoggers(const LogBuilderPtr& defaultLogBuilder);
+
+  virtual ~RegisteredLoggers(void) {
+    unsafeFlushAll();
+  }
+
+  inline void setDefaultConfigurations(const Configurations& configurations) {
+    base::threading::ScopedLock scopedLock(lock());
+    m_defaultConfigurations.setFromBase(const_cast<Configurations*>(&configurations));
+  }
+
+  inline Configurations* defaultConfigurations(void) {
+    return &m_defaultConfigurations;
+  }
+
+  Logger* get(const std::string& id, bool forceCreation = true);
+
+  template <typename T>
+  inline bool installLoggerRegistrationCallback(const std::string& id) {
+    return base::utils::Utils::installCallback<T, base::type::LoggerRegistrationCallbackPtr>(id,
+           &m_loggerRegistrationCallbacks);
+  }
+
+  template <typename T>
+  inline void uninstallLoggerRegistrationCallback(const std::string& id) {
+    base::utils::Utils::uninstallCallback<T, base::type::LoggerRegistrationCallbackPtr>(id, &m_loggerRegistrationCallbacks);
+  }
+
+  template <typename T>
+  inline T* loggerRegistrationCallback(const std::string& id) {
+    return base::utils::Utils::callback<T, base::type::LoggerRegistrationCallbackPtr>(id, &m_loggerRegistrationCallbacks);
+  }
+
+  bool remove(const std::string& id);
+
+  inline bool has(const std::string& id) {
+    return get(id, false) != nullptr;
+  }
+
+  inline void unregister(Logger*& logger) {
+    base::threading::ScopedLock scopedLock(lock());
+    base::utils::Registry<Logger, std::string>::unregister(logger->id());
+  }
+
+  inline base::LogStreamsReferenceMap* logStreamsReference(void) {
+    return &m_logStreamsReference;
+  }
+
+  inline void flushAll(void) {
+    base::threading::ScopedLock scopedLock(lock());
+    unsafeFlushAll();
+  }
+
+  inline void setDefaultLogBuilder(LogBuilderPtr& logBuilderPtr) {
+    base::threading::ScopedLock scopedLock(lock());
+    m_defaultLogBuilder = logBuilderPtr;
+  }
+
+ private:
+  LogBuilderPtr m_defaultLogBuilder;
+  Configurations m_defaultConfigurations;
+  base::LogStreamsReferenceMap m_logStreamsReference;
+  std::unordered_map<std::string, base::type::LoggerRegistrationCallbackPtr> m_loggerRegistrationCallbacks;
+  friend class el::base::Storage;
+
+  void unsafeFlushAll(void);
+};
+/// @brief Represents registries for verbose logging
+class VRegistry : base::NoCopy, public base::threading::ThreadSafe {
+ public:
+  explicit VRegistry(base::type::VerboseLevel level, base::type::EnumType* pFlags);
+
+  /// @brief Sets verbose level. Accepted range is 0-9
+  void setLevel(base::type::VerboseLevel level);
+
+  inline base::type::VerboseLevel level(void) const {
+    return m_level;
+  }
+
+  inline void clearModules(void) {
+    base::threading::ScopedLock scopedLock(lock());
+    m_modules.clear();
+  }
+
+  void setModules(const char* modules);
+
+  bool allowed(base::type::VerboseLevel vlevel, const char* file);
+
+  inline const std::unordered_map<std::string, base::type::VerboseLevel>& modules(void) const {
+    return m_modules;
+  }
+
+  void setFromArgs(const base::utils::CommandLineArgs* commandLineArgs);
+
+  /// @brief Whether or not vModules enabled
+  inline bool vModulesEnabled(void) {
+    return !base::utils::hasFlag(LoggingFlag::DisableVModules, *m_pFlags);
+  }
+
+ private:
+  base::type::VerboseLevel m_level;
+  base::type::EnumType* m_pFlags;
+  std::unordered_map<std::string, base::type::VerboseLevel> m_modules;
+};
+}  // namespace base
+class LogMessage {
+ public:
+  LogMessage(Level level, const std::string& file, base::type::LineNumber line, const std::string& func,
+             base::type::VerboseLevel verboseLevel, Logger* logger) :
+    m_level(level), m_file(file), m_line(line), m_func(func),
+    m_verboseLevel(verboseLevel), m_logger(logger), m_message(logger->stream().str()) {
+  }
+  inline Level level(void) const {
+    return m_level;
+  }
+  inline const std::string& file(void) const {
+    return m_file;
+  }
+  inline base::type::LineNumber line(void) const {
+    return m_line;
+  }
+  inline const std::string& func(void) const {
+    return m_func;
+  }
+  inline base::type::VerboseLevel verboseLevel(void) const {
+    return m_verboseLevel;
+  }
+  inline Logger* logger(void) const {
+    return m_logger;
+  }
+  inline const base::type::string_t& message(void) const {
+    return m_message;
+  }
+ private:
+  Level m_level;
+  std::string m_file;
+  base::type::LineNumber m_line;
+  std::string m_func;
+  base::type::VerboseLevel m_verboseLevel;
+  Logger* m_logger;
+  base::type::string_t m_message;
+};
+namespace base {
+#if ELPP_ASYNC_LOGGING
+class AsyncLogItem {
+ public:
+  explicit AsyncLogItem(const LogMessage& logMessage, const LogDispatchData& data, const base::type::string_t& logLine)
+    : m_logMessage(logMessage), m_dispatchData(data), m_logLine(logLine) {}
+  virtual ~AsyncLogItem() {}
+  inline LogMessage* logMessage(void) {
+    return &m_logMessage;
+  }
+  inline LogDispatchData* data(void) {
+    return &m_dispatchData;
+  }
+  inline base::type::string_t logLine(void) {
+    return m_logLine;
+  }
+ private:
+  LogMessage m_logMessage;
+  LogDispatchData m_dispatchData;
+  base::type::string_t m_logLine;
+};
+class AsyncLogQueue : public base::threading::ThreadSafe {
+ public:
+  virtual ~AsyncLogQueue() {
+    ELPP_INTERNAL_INFO(6, "~AsyncLogQueue");
+  }
+
+  inline AsyncLogItem next(void) {
+    base::threading::ScopedLock scopedLock(lock());
+    AsyncLogItem result = m_queue.front();
+    m_queue.pop();
+    return result;
+  }
+
+  inline void push(const AsyncLogItem& item) {
+    base::threading::ScopedLock scopedLock(lock());
+    m_queue.push(item);
+  }
+  inline void pop(void) {
+    base::threading::ScopedLock scopedLock(lock());
+    m_queue.pop();
+  }
+  inline AsyncLogItem front(void) {
+    base::threading::ScopedLock scopedLock(lock());
+    return m_queue.front();
+  }
+  inline bool empty(void) {
+    base::threading::ScopedLock scopedLock(lock());
+    return m_queue.empty();
+  }
+ private:
+  std::queue<AsyncLogItem> m_queue;
+};
+class IWorker {
+ public:
+  virtual ~IWorker() {}
+  virtual void start() = 0;
+};
+#endif // ELPP_ASYNC_LOGGING
+/// @brief Easylogging++ management storage
+class Storage : base::NoCopy, public base::threading::ThreadSafe {
+ public:
+#if ELPP_ASYNC_LOGGING
+  Storage(const LogBuilderPtr& defaultLogBuilder, base::IWorker* asyncDispatchWorker);
+#else
+  explicit Storage(const LogBuilderPtr& defaultLogBuilder);
+#endif  // ELPP_ASYNC_LOGGING
+
+  virtual ~Storage(void);
+
+  inline bool validateEveryNCounter(const char* filename, base::type::LineNumber lineNumber, std::size_t occasion) {
+    return hitCounters()->validateEveryN(filename, lineNumber, occasion);
+  }
+
+  inline bool validateAfterNCounter(const char* filename, base::type::LineNumber lineNumber, std::size_t n) {
+    return hitCounters()->validateAfterN(filename, lineNumber, n);
+  }
+
+  inline bool validateNTimesCounter(const char* filename, base::type::LineNumber lineNumber, std::size_t n) {
+    return hitCounters()->validateNTimes(filename, lineNumber, n);
+  }
+
+  inline base::RegisteredHitCounters* hitCounters(void) const {
+    return m_registeredHitCounters;
+  }
+
+  inline base::RegisteredLoggers* registeredLoggers(void) const {
+    return m_registeredLoggers;
+  }
+
+  inline base::VRegistry* vRegistry(void) const {
+    return m_vRegistry;
+  }
+
+#if ELPP_ASYNC_LOGGING
+  inline base::AsyncLogQueue* asyncLogQueue(void) const {
+    return m_asyncLogQueue;
+  }
+#endif  // ELPP_ASYNC_LOGGING
+
+  inline const base::utils::CommandLineArgs* commandLineArgs(void) const {
+    return &m_commandLineArgs;
+  }
+
+  inline void addFlag(LoggingFlag flag) {
+    base::utils::addFlag(flag, &m_flags);
+  }
+
+  inline void removeFlag(LoggingFlag flag) {
+    base::utils::removeFlag(flag, &m_flags);
+  }
+
+  inline bool hasFlag(LoggingFlag flag) const {
+    return base::utils::hasFlag(flag, m_flags);
+  }
+
+  inline base::type::EnumType flags(void) const {
+    return m_flags;
+  }
+
+  inline void setFlags(base::type::EnumType flags) {
+    m_flags = flags;
+  }
+
+  inline void setPreRollOutCallback(const PreRollOutCallback& callback) {
+    m_preRollOutCallback = callback;
+  }
+
+  inline void unsetPreRollOutCallback(void) {
+    m_preRollOutCallback = base::defaultPreRollOutCallback;
+  }
+
+  inline PreRollOutCallback& preRollOutCallback(void) {
+    return m_preRollOutCallback;
+  }
+
+  bool hasCustomFormatSpecifier(const char* formatSpecifier);
+  void installCustomFormatSpecifier(const CustomFormatSpecifier& customFormatSpecifier);
+  bool uninstallCustomFormatSpecifier(const char* formatSpecifier);
+
+  const std::vector<CustomFormatSpecifier>* customFormatSpecifiers(void) const {
+    return &m_customFormatSpecifiers;
+  }
+
+  base::threading::Mutex& customFormatSpecifiersLock() {
+    return m_customFormatSpecifiersLock;
+  }
+
+  inline void setLoggingLevel(Level level) {
+    m_loggingLevel = level;
+  }
+
+  template <typename T>
+  inline bool installLogDispatchCallback(const std::string& id) {
+    return base::utils::Utils::installCallback<T, base::type::LogDispatchCallbackPtr>(id, &m_logDispatchCallbacks);
+  }
+
+  template <typename T>
+  inline void uninstallLogDispatchCallback(const std::string& id) {
+    base::utils::Utils::uninstallCallback<T, base::type::LogDispatchCallbackPtr>(id, &m_logDispatchCallbacks);
+  }
+  template <typename T>
+  inline T* logDispatchCallback(const std::string& id) {
+    return base::utils::Utils::callback<T, base::type::LogDispatchCallbackPtr>(id, &m_logDispatchCallbacks);
+  }
+
+#if defined(ELPP_FEATURE_ALL) || defined(ELPP_FEATURE_PERFORMANCE_TRACKING)
+  template <typename T>
+  inline bool installPerformanceTrackingCallback(const std::string& id) {
+    return base::utils::Utils::installCallback<T, base::type::PerformanceTrackingCallbackPtr>(id,
+           &m_performanceTrackingCallbacks);
+  }
+
+  template <typename T>
+  inline void uninstallPerformanceTrackingCallback(const std::string& id) {
+    base::utils::Utils::uninstallCallback<T, base::type::PerformanceTrackingCallbackPtr>(id,
+        &m_performanceTrackingCallbacks);
+  }
+
+  template <typename T>
+  inline T* performanceTrackingCallback(const std::string& id) {
+    return base::utils::Utils::callback<T, base::type::PerformanceTrackingCallbackPtr>(id, &m_performanceTrackingCallbacks);
+  }
+#endif // defined(ELPP_FEATURE_ALL) || defined(ELPP_FEATURE_PERFORMANCE_TRACKING)
+
+  /// @brief Sets thread name for current thread. Requires std::thread
+  inline void setThreadName(const std::string& name) {
+    if (name.empty()) return;
+    base::threading::ScopedLock scopedLock(m_threadNamesLock);
+    m_threadNames[base::threading::getCurrentThreadId()] = name;
+  }
+
+  inline std::string getThreadName(const std::string& threadId) {
+    base::threading::ScopedLock scopedLock(m_threadNamesLock);
+    std::unordered_map<std::string, std::string>::const_iterator it = m_threadNames.find(threadId);
+    if (it == m_threadNames.end()) {
+      return threadId;
+    }
+    return it->second;
+  }
+ private:
+  base::RegisteredHitCounters* m_registeredHitCounters;
+  base::RegisteredLoggers* m_registeredLoggers;
+  base::type::EnumType m_flags;
+  base::VRegistry* m_vRegistry;
+#if ELPP_ASYNC_LOGGING
+  base::AsyncLogQueue* m_asyncLogQueue;
+  base::IWorker* m_asyncDispatchWorker;
+#endif  // ELPP_ASYNC_LOGGING
+  base::utils::CommandLineArgs m_commandLineArgs;
+  PreRollOutCallback m_preRollOutCallback;
+  std::unordered_map<std::string, base::type::LogDispatchCallbackPtr> m_logDispatchCallbacks;
+  std::unordered_map<std::string, base::type::PerformanceTrackingCallbackPtr> m_performanceTrackingCallbacks;
+  std::unordered_map<std::string, std::string> m_threadNames;
+  std::vector<CustomFormatSpecifier> m_customFormatSpecifiers;
+  base::threading::Mutex m_customFormatSpecifiersLock;
+  base::threading::Mutex m_threadNamesLock;
+  Level m_loggingLevel;
+
+  friend class el::Helpers;
+  friend class el::base::DefaultLogDispatchCallback;
+  friend class el::LogBuilder;
+  friend class el::base::MessageBuilder;
+  friend class el::base::Writer;
+  friend class el::base::PerformanceTracker;
+  friend class el::base::LogDispatcher;
+
+  void setApplicationArguments(int argc, char** argv);
+
+  inline void setApplicationArguments(int argc, const char** argv) {
+    setApplicationArguments(argc, const_cast<char**>(argv));
+  }
+};
+extern ELPP_EXPORT base::type::StoragePointer elStorage;
+#define ELPP el::base::elStorage
+class DefaultLogDispatchCallback : public LogDispatchCallback {
+ protected:
+  void handle(const LogDispatchData* data);
+ private:
+  const LogDispatchData* m_data;
+  void dispatch(base::type::string_t&& logLine);
+};
+#if ELPP_ASYNC_LOGGING
+class AsyncLogDispatchCallback : public LogDispatchCallback {
+ protected:
+  void handle(const LogDispatchData* data);
+};
+class AsyncDispatchWorker : public base::IWorker, public base::threading::ThreadSafe {
+ public:
+  AsyncDispatchWorker();
+  virtual ~AsyncDispatchWorker();
+
+  bool clean(void);
+  void emptyQueue(void);
+  virtual void start(void);
+  void handle(AsyncLogItem* logItem);
+  void run(void);
+
+  void setContinueRunning(bool value) {
+    base::threading::ScopedLock scopedLock(m_continueRunningLock);
+    m_continueRunning = value;
+  }
+
+  bool continueRunning(void) const {
+    return m_continueRunning;
+  }
+ private:
+  std::condition_variable cv;
+  bool m_continueRunning;
+  base::threading::Mutex m_continueRunningLock;
+};
+#endif  // ELPP_ASYNC_LOGGING
+}  // namespace base
+namespace base {
+class DefaultLogBuilder : public LogBuilder {
+ public:
+  base::type::string_t build(const LogMessage* logMessage, bool appendNewLine) const;
+};
+/// @brief Dispatches log messages
+class LogDispatcher : base::NoCopy {
+ public:
+  LogDispatcher(bool proceed, LogMessage* logMessage, base::DispatchAction dispatchAction) :
+    m_proceed(proceed),
+    m_logMessage(logMessage),
+    m_dispatchAction(std::move(dispatchAction)) {
+  }
+
+  void dispatch(void);
+
+ private:
+  bool m_proceed;
+  LogMessage* m_logMessage;
+  base::DispatchAction m_dispatchAction;
+};
+#if defined(ELPP_STL_LOGGING)
+/// @brief Workarounds to write some STL logs
+///
+/// @detail There is workaround needed to loop through some stl containers. In order to do that, we need iterable containers
+/// of same type and provide iterator interface and pass it on to writeIterator().
+/// Remember, this is passed by value in constructor so that we dont change original containers.
+/// This operation is as expensive as Big-O(std::min(class_.size(), base::consts::kMaxLogPerContainer))
+namespace workarounds {
+/// @brief Abstract IterableContainer template that provides interface for iterable classes of type T
+template <typename T, typename Container>
+class IterableContainer {
+ public:
+  typedef typename Container::iterator iterator;
+  typedef typename Container::const_iterator const_iterator;
+  IterableContainer(void) {}
+  virtual ~IterableContainer(void) {}
+  iterator begin(void) {
+    return getContainer().begin();
+  }
+  iterator end(void) {
+    return getContainer().end();
+  }
+ private:
+  virtual Container& getContainer(void) = 0;
+};
+/// @brief Implements IterableContainer and provides iterable std::priority_queue class
+template<typename T, typename Container = std::vector<T>, typename Comparator = std::less<typename Container::value_type>>
+class IterablePriorityQueue : public IterableContainer<T, Container>,
+  public std::priority_queue<T, Container, Comparator> {
+ public:
+  IterablePriorityQueue(std::priority_queue<T, Container, Comparator> queue_) {
+    std::size_t count_ = 0;
+    while (++count_ < base::consts::kMaxLogPerContainer && !queue_.empty()) {
+      this->push(queue_.top());
+      queue_.pop();
+    }
+  }
+ private:
+  inline Container& getContainer(void) {
+    return this->c;
+  }
+};
+/// @brief Implements IterableContainer and provides iterable std::queue class
+template<typename T, typename Container = std::deque<T>>
+class IterableQueue : public IterableContainer<T, Container>, public std::queue<T, Container> {
+ public:
+  IterableQueue(std::queue<T, Container> queue_) {
+    std::size_t count_ = 0;
+    while (++count_ < base::consts::kMaxLogPerContainer && !queue_.empty()) {
+      this->push(queue_.front());
+      queue_.pop();
+    }
+  }
+ private:
+  inline Container& getContainer(void) {
+    return this->c;
+  }
+};
+/// @brief Implements IterableContainer and provides iterable std::stack class
+template<typename T, typename Container = std::deque<T>>
+class IterableStack : public IterableContainer<T, Container>, public std::stack<T, Container> {
+ public:
+  IterableStack(std::stack<T, Container> stack_) {
+    std::size_t count_ = 0;
+    while (++count_ < base::consts::kMaxLogPerContainer && !stack_.empty()) {
+      this->push(stack_.top());
+      stack_.pop();
+    }
+  }
+ private:
+  inline Container& getContainer(void) {
+    return this->c;
+  }
+};
+}  // namespace workarounds
+#endif  // defined(ELPP_STL_LOGGING)
+// Log message builder
+class MessageBuilder {
+ public:
+  MessageBuilder(void) : m_logger(nullptr), m_containerLogSeperator(ELPP_LITERAL("")) {}
+  void initialize(Logger* logger);
+
+#  define ELPP_SIMPLE_LOG(LOG_TYPE)\
+MessageBuilder& operator<<(LOG_TYPE msg) {\
+m_logger->stream() << msg;\
+if (ELPP->hasFlag(LoggingFlag::AutoSpacing)) {\
+m_logger->stream() << " ";\
+}\
+return *this;\
+}
+
+  inline MessageBuilder& operator<<(const std::string& msg) {
+    return operator<<(msg.c_str());
+  }
+  ELPP_SIMPLE_LOG(char)
+  ELPP_SIMPLE_LOG(bool)
+  ELPP_SIMPLE_LOG(signed short)
+  ELPP_SIMPLE_LOG(unsigned short)
+  ELPP_SIMPLE_LOG(signed int)
+  ELPP_SIMPLE_LOG(unsigned int)
+  ELPP_SIMPLE_LOG(signed long)
+  ELPP_SIMPLE_LOG(unsigned long)
+  ELPP_SIMPLE_LOG(float)
+  ELPP_SIMPLE_LOG(double)
+  ELPP_SIMPLE_LOG(char*)
+  ELPP_SIMPLE_LOG(const char*)
+  ELPP_SIMPLE_LOG(const void*)
+  ELPP_SIMPLE_LOG(long double)
+  inline MessageBuilder& operator<<(const std::wstring& msg) {
+    return operator<<(msg.c_str());
+  }
+  MessageBuilder& operator<<(const wchar_t* msg);
+  // ostream manipulators
+  inline MessageBuilder& operator<<(std::ostream& (*OStreamMani)(std::ostream&)) {
+    m_logger->stream() << OStreamMani;
+    return *this;
+  }
+#define ELPP_ITERATOR_CONTAINER_LOG_ONE_ARG(temp)                                                    \
+template <typename T>                                                                            \
+inline MessageBuilder& operator<<(const temp<T>& template_inst) {                                \
+return writeIterator(template_inst.begin(), template_inst.end(), template_inst.size());      \
+}
+#define ELPP_ITERATOR_CONTAINER_LOG_TWO_ARG(temp)                                                    \
+template <typename T1, typename T2>                                                              \
+inline MessageBuilder& operator<<(const temp<T1, T2>& template_inst) {                           \
+return writeIterator(template_inst.begin(), template_inst.end(), template_inst.size());      \
+}
+#define ELPP_ITERATOR_CONTAINER_LOG_THREE_ARG(temp)                                                  \
+template <typename T1, typename T2, typename T3>                                                 \
+inline MessageBuilder& operator<<(const temp<T1, T2, T3>& template_inst) {                       \
+return writeIterator(template_inst.begin(), template_inst.end(), template_inst.size());      \
+}
+#define ELPP_ITERATOR_CONTAINER_LOG_FOUR_ARG(temp)                                                   \
+template <typename T1, typename T2, typename T3, typename T4>                                    \
+inline MessageBuilder& operator<<(const temp<T1, T2, T3, T4>& template_inst) {                   \
+return writeIterator(template_inst.begin(), template_inst.end(), template_inst.size());      \
+}
+#define ELPP_ITERATOR_CONTAINER_LOG_FIVE_ARG(temp)                                                   \
+template <typename T1, typename T2, typename T3, typename T4, typename T5>                       \
+inline MessageBuilder& operator<<(const temp<T1, T2, T3, T4, T5>& template_inst) {               \
+return writeIterator(template_inst.begin(), template_inst.end(), template_inst.size());      \
+}
+
+#if defined(ELPP_STL_LOGGING)
+  ELPP_ITERATOR_CONTAINER_LOG_TWO_ARG(std::vector)
+  ELPP_ITERATOR_CONTAINER_LOG_TWO_ARG(std::list)
+  ELPP_ITERATOR_CONTAINER_LOG_TWO_ARG(std::deque)
+  ELPP_ITERATOR_CONTAINER_LOG_THREE_ARG(std::set)
+  ELPP_ITERATOR_CONTAINER_LOG_THREE_ARG(std::multiset)
+  ELPP_ITERATOR_CONTAINER_LOG_FOUR_ARG(std::map)
+  ELPP_ITERATOR_CONTAINER_LOG_FOUR_ARG(std::multimap)
+  template <class T, class Container>
+  inline MessageBuilder& operator<<(const std::queue<T, Container>& queue_) {
+    base::workarounds::IterableQueue<T, Container> iterableQueue_ =
+      static_cast<base::workarounds::IterableQueue<T, Container> >(queue_);
+    return writeIterator(iterableQueue_.begin(), iterableQueue_.end(), iterableQueue_.size());
+  }
+  template <class T, class Container>
+  inline MessageBuilder& operator<<(const std::stack<T, Container>& stack_) {
+    base::workarounds::IterableStack<T, Container> iterableStack_ =
+      static_cast<base::workarounds::IterableStack<T, Container> >(stack_);
+    return writeIterator(iterableStack_.begin(), iterableStack_.end(), iterableStack_.size());
+  }
+  template <class T, class Container, class Comparator>
+  inline MessageBuilder& operator<<(const std::priority_queue<T, Container, Comparator>& priorityQueue_) {
+    base::workarounds::IterablePriorityQueue<T, Container, Comparator> iterablePriorityQueue_ =
+      static_cast<base::workarounds::IterablePriorityQueue<T, Container, Comparator> >(priorityQueue_);
+    return writeIterator(iterablePriorityQueue_.begin(), iterablePriorityQueue_.end(), iterablePriorityQueue_.size());
+  }
+  template <class First, class Second>
+  MessageBuilder& operator<<(const std::pair<First, Second>& pair_) {
+    m_logger->stream() << ELPP_LITERAL("(");
+    operator << (static_cast<First>(pair_.first));
+    m_logger->stream() << ELPP_LITERAL(", ");
+    operator << (static_cast<Second>(pair_.second));
+    m_logger->stream() << ELPP_LITERAL(")");
+    return *this;
+  }
+  template <std::size_t Size>
+  MessageBuilder& operator<<(const std::bitset<Size>& bitset_) {
+    m_logger->stream() << ELPP_LITERAL("[");
+    operator << (bitset_.to_string());
+    m_logger->stream() << ELPP_LITERAL("]");
+    return *this;
+  }
+#  if defined(ELPP_LOG_STD_ARRAY)
+  template <class T, std::size_t Size>
+  inline MessageBuilder& operator<<(const std::array<T, Size>& array) {
+    return writeIterator(array.begin(), array.end(), array.size());
+  }
+#  endif  // defined(ELPP_LOG_STD_ARRAY)
+#  if defined(ELPP_LOG_UNORDERED_MAP)
+  ELPP_ITERATOR_CONTAINER_LOG_FIVE_ARG(std::unordered_map)
+  ELPP_ITERATOR_CONTAINER_LOG_FIVE_ARG(std::unordered_multimap)
+#  endif  // defined(ELPP_LOG_UNORDERED_MAP)
+#  if defined(ELPP_LOG_UNORDERED_SET)
+  ELPP_ITERATOR_CONTAINER_LOG_FOUR_ARG(std::unordered_set)
+  ELPP_ITERATOR_CONTAINER_LOG_FOUR_ARG(std::unordered_multiset)
+#  endif  // defined(ELPP_LOG_UNORDERED_SET)
+#endif  // defined(ELPP_STL_LOGGING)
+#if defined(ELPP_QT_LOGGING)
+  inline MessageBuilder& operator<<(const QString& msg) {
+#  if defined(ELPP_UNICODE)
+    m_logger->stream() << msg.toStdWString();
+#  else
+    m_logger->stream() << msg.toStdString();
+#  endif  // defined(ELPP_UNICODE)
+    return *this;
+  }
+  inline MessageBuilder& operator<<(const QByteArray& msg) {
+    return operator << (QString(msg));
+  }
+  inline MessageBuilder& operator<<(const QStringRef& msg) {
+    return operator<<(msg.toString());
+  }
+  inline MessageBuilder& operator<<(qint64 msg) {
+#  if defined(ELPP_UNICODE)
+    m_logger->stream() << QString::number(msg).toStdWString();
+#  else
+    m_logger->stream() << QString::number(msg).toStdString();
+#  endif  // defined(ELPP_UNICODE)
+    return *this;
+  }
+  inline MessageBuilder& operator<<(quint64 msg) {
+#  if defined(ELPP_UNICODE)
+    m_logger->stream() << QString::number(msg).toStdWString();
+#  else
+    m_logger->stream() << QString::number(msg).toStdString();
+#  endif  // defined(ELPP_UNICODE)
+    return *this;
+  }
+  inline MessageBuilder& operator<<(QChar msg) {
+    m_logger->stream() << msg.toLatin1();
+    return *this;
+  }
+  inline MessageBuilder& operator<<(const QLatin1String& msg) {
+    m_logger->stream() << msg.latin1();
+    return *this;
+  }
+  ELPP_ITERATOR_CONTAINER_LOG_ONE_ARG(QList)
+  ELPP_ITERATOR_CONTAINER_LOG_ONE_ARG(QVector)
+  ELPP_ITERATOR_CONTAINER_LOG_ONE_ARG(QQueue)
+  ELPP_ITERATOR_CONTAINER_LOG_ONE_ARG(QSet)
+  ELPP_ITERATOR_CONTAINER_LOG_ONE_ARG(QLinkedList)
+  ELPP_ITERATOR_CONTAINER_LOG_ONE_ARG(QStack)
+  template <typename First, typename Second>
+  MessageBuilder& operator<<(const QPair<First, Second>& pair_) {
+    m_logger->stream() << ELPP_LITERAL("(");
+    operator << (static_cast<First>(pair_.first));
+    m_logger->stream() << ELPP_LITERAL(", ");
+    operator << (static_cast<Second>(pair_.second));
+    m_logger->stream() << ELPP_LITERAL(")");
+    return *this;
+  }
+  template <typename K, typename V>
+  MessageBuilder& operator<<(const QMap<K, V>& map_) {
+    m_logger->stream() << ELPP_LITERAL("[");
+    QList<K> keys = map_.keys();
+    typename QList<K>::const_iterator begin = keys.begin();
+    typename QList<K>::const_iterator end = keys.end();
+    int max_ = static_cast<int>(base::consts::kMaxLogPerContainer);  // to prevent warning
+    for (int index_ = 0; begin != end && index_ < max_; ++index_, ++begin) {
+      m_logger->stream() << ELPP_LITERAL("(");
+      operator << (static_cast<K>(*begin));
+      m_logger->stream() << ELPP_LITERAL(", ");
+      operator << (static_cast<V>(map_.value(*begin)));
+      m_logger->stream() << ELPP_LITERAL(")");
+      m_logger->stream() << ((index_ < keys.size() -1) ? m_containerLogSeperator : ELPP_LITERAL(""));
+    }
+    if (begin != end) {
+      m_logger->stream() << ELPP_LITERAL("...");
+    }
+    m_logger->stream() << ELPP_LITERAL("]");
+    return *this;
+  }
+  template <typename K, typename V>
+  inline MessageBuilder& operator<<(const QMultiMap<K, V>& map_) {
+    operator << (static_cast<QMap<K, V>>(map_));
+    return *this;
+  }
+  template <typename K, typename V>
+  MessageBuilder& operator<<(const QHash<K, V>& hash_) {
+    m_logger->stream() << ELPP_LITERAL("[");
+    QList<K> keys = hash_.keys();
+    typename QList<K>::const_iterator begin = keys.begin();
+    typename QList<K>::const_iterator end = keys.end();
+    int max_ = static_cast<int>(base::consts::kMaxLogPerContainer);  // prevent type warning
+    for (int index_ = 0; begin != end && index_ < max_; ++index_, ++begin) {
+      m_logger->stream() << ELPP_LITERAL("(");
+      operator << (static_cast<K>(*begin));
+      m_logger->stream() << ELPP_LITERAL(", ");
+      operator << (static_cast<V>(hash_.value(*begin)));
+      m_logger->stream() << ELPP_LITERAL(")");
+      m_logger->stream() << ((index_ < keys.size() -1) ? m_containerLogSeperator : ELPP_LITERAL(""));
+    }
+    if (begin != end) {
+      m_logger->stream() << ELPP_LITERAL("...");
+    }
+    m_logger->stream() << ELPP_LITERAL("]");
+    return *this;
+  }
+  template <typename K, typename V>
+  inline MessageBuilder& operator<<(const QMultiHash<K, V>& multiHash_) {
+    operator << (static_cast<QHash<K, V>>(multiHash_));
+    return *this;
+  }
+#endif  // defined(ELPP_QT_LOGGING)
+#if defined(ELPP_BOOST_LOGGING)
+  ELPP_ITERATOR_CONTAINER_LOG_TWO_ARG(boost::container::vector)
+  ELPP_ITERATOR_CONTAINER_LOG_TWO_ARG(boost::container::stable_vector)
+  ELPP_ITERATOR_CONTAINER_LOG_TWO_ARG(boost::container::list)
+  ELPP_ITERATOR_CONTAINER_LOG_TWO_ARG(boost::container::deque)
+  ELPP_ITERATOR_CONTAINER_LOG_FOUR_ARG(boost::container::map)
+  ELPP_ITERATOR_CONTAINER_LOG_FOUR_ARG(boost::container::flat_map)
+  ELPP_ITERATOR_CONTAINER_LOG_THREE_ARG(boost::container::set)
+  ELPP_ITERATOR_CONTAINER_LOG_THREE_ARG(boost::container::flat_set)
+#endif  // defined(ELPP_BOOST_LOGGING)
+
+  /// @brief Macro used internally that can be used externally to make containers easylogging++ friendly
+  ///
+  /// @detail This macro expands to write an ostream& operator<< for container. This container is expected to
+  ///         have begin() and end() methods that return respective iterators
+  /// @param ContainerType Type of container e.g, MyList from WX_DECLARE_LIST(int, MyList); in wxwidgets
+  /// @param SizeMethod Method used to get size of container.
+  /// @param ElementInstance Instance of element to be fed out. Insance name is "elem". See WXELPP_ENABLED macro
+  ///        for an example usage
+#define MAKE_CONTAINERELPP_FRIENDLY(ContainerType, SizeMethod, ElementInstance) \
+el::base::type::ostream_t& operator<<(el::base::type::ostream_t& ss, const ContainerType& container) {\
+const el::base::type::char_t* sep = ELPP->hasFlag(el::LoggingFlag::NewLineForContainer) ? \
+ELPP_LITERAL("\n    ") : ELPP_LITERAL(", ");\
+ContainerType::const_iterator elem = container.begin();\
+ContainerType::const_iterator endElem = container.end();\
+std::size_t size_ = container.SizeMethod; \
+ss << ELPP_LITERAL("[");\
+for (std::size_t i = 0; elem != endElem && i < el::base::consts::kMaxLogPerContainer; ++i, ++elem) { \
+ss << ElementInstance;\
+ss << ((i < size_ - 1) ? sep : ELPP_LITERAL(""));\
+}\
+if (elem != endElem) {\
+ss << ELPP_LITERAL("...");\
+}\
+ss << ELPP_LITERAL("]");\
+return ss;\
+}
+#if defined(ELPP_WXWIDGETS_LOGGING)
+  ELPP_ITERATOR_CONTAINER_LOG_ONE_ARG(wxVector)
+#  define ELPP_WX_PTR_ENABLED(ContainerType) MAKE_CONTAINERELPP_FRIENDLY(ContainerType, size(), *(*elem))
+#  define ELPP_WX_ENABLED(ContainerType) MAKE_CONTAINERELPP_FRIENDLY(ContainerType, size(), (*elem))
+#  define ELPP_WX_HASH_MAP_ENABLED(ContainerType) MAKE_CONTAINERELPP_FRIENDLY(ContainerType, size(), \
+ELPP_LITERAL("(") << elem->first << ELPP_LITERAL(", ") << elem->second << ELPP_LITERAL(")")
+#else
+#  define ELPP_WX_PTR_ENABLED(ContainerType)
+#  define ELPP_WX_ENABLED(ContainerType)
+#  define ELPP_WX_HASH_MAP_ENABLED(ContainerType)
+#endif  // defined(ELPP_WXWIDGETS_LOGGING)
+  // Other classes
+  template <class Class>
+  ELPP_SIMPLE_LOG(const Class&)
+#undef ELPP_SIMPLE_LOG
+#undef ELPP_ITERATOR_CONTAINER_LOG_ONE_ARG
+#undef ELPP_ITERATOR_CONTAINER_LOG_TWO_ARG
+#undef ELPP_ITERATOR_CONTAINER_LOG_THREE_ARG
+#undef ELPP_ITERATOR_CONTAINER_LOG_FOUR_ARG
+#undef ELPP_ITERATOR_CONTAINER_LOG_FIVE_ARG
+ private:
+  Logger* m_logger;
+  const base::type::char_t* m_containerLogSeperator;
+
+  template<class Iterator>
+  MessageBuilder& writeIterator(Iterator begin_, Iterator end_, std::size_t size_) {
+    m_logger->stream() << ELPP_LITERAL("[");
+    for (std::size_t i = 0; begin_ != end_ && i < base::consts::kMaxLogPerContainer; ++i, ++begin_) {
+      operator << (*begin_);
+      m_logger->stream() << ((i < size_ - 1) ? m_containerLogSeperator : ELPP_LITERAL(""));
+    }
+    if (begin_ != end_) {
+      m_logger->stream() << ELPP_LITERAL("...");
+    }
+    m_logger->stream() << ELPP_LITERAL("]");
+    if (ELPP->hasFlag(LoggingFlag::AutoSpacing)) {
+      m_logger->stream() << " ";
+    }
+    return *this;
+  }
+};
+/// @brief Writes nothing - Used when certain log is disabled
+class NullWriter : base::NoCopy {
+ public:
+  NullWriter(void) {}
+
+  // Null manipulator
+  inline NullWriter& operator<<(std::ostream& (*)(std::ostream&)) {
+    return *this;
+  }
+
+  template <typename T>
+  inline NullWriter& operator<<(const T&) {
+    return *this;
+  }
+
+  inline operator bool() {
+    return true;
+  }
+};
+/// @brief Main entry point of each logging
+class Writer : base::NoCopy {
+ public:
+  Writer(Level level, const char* file, base::type::LineNumber line,
+         const char* func, base::DispatchAction dispatchAction = base::DispatchAction::NormalLog,
+         base::type::VerboseLevel verboseLevel = 0) :
+    m_msg(nullptr), m_level(level), m_file(file), m_line(line), m_func(func), m_verboseLevel(verboseLevel),
+    m_logger(nullptr), m_proceed(false), m_dispatchAction(dispatchAction) {
+  }
+
+  Writer(LogMessage* msg, base::DispatchAction dispatchAction = base::DispatchAction::NormalLog) :
+    m_msg(msg), m_level(msg != nullptr ? msg->level() : Level::Unknown),
+    m_line(0), m_logger(nullptr), m_proceed(false), m_dispatchAction(dispatchAction) {
+  }
+
+  virtual ~Writer(void) {
+    processDispatch();
+  }
+
+  template <typename T>
+  inline Writer& operator<<(const T& log) {
+#if ELPP_LOGGING_ENABLED
+    if (m_proceed) {
+      m_messageBuilder << log;
+    }
+#endif  // ELPP_LOGGING_ENABLED
+    return *this;
+  }
+
+  inline Writer& operator<<(std::ostream& (*log)(std::ostream&)) {
+#if ELPP_LOGGING_ENABLED
+    if (m_proceed) {
+      m_messageBuilder << log;
+    }
+#endif  // ELPP_LOGGING_ENABLED
+    return *this;
+  }
+
+  inline operator bool() {
+    return true;
+  }
+
+  Writer& construct(Logger* logger, bool needLock = true);
+  Writer& construct(int count, const char* loggerIds, ...);
+ protected:
+  LogMessage* m_msg;
+  Level m_level;
+  const char* m_file;
+  const base::type::LineNumber m_line;
+  const char* m_func;
+  base::type::VerboseLevel m_verboseLevel;
+  Logger* m_logger;
+  bool m_proceed;
+  base::MessageBuilder m_messageBuilder;
+  base::DispatchAction m_dispatchAction;
+  std::vector<std::string> m_loggerIds;
+  friend class el::Helpers;
+
+  void initializeLogger(const std::string& loggerId, bool lookup = true, bool needLock = true);
+  void processDispatch();
+  void triggerDispatch(void);
+};
+class PErrorWriter : public base::Writer {
+ public:
+  PErrorWriter(Level level, const char* file, base::type::LineNumber line,
+               const char* func, base::DispatchAction dispatchAction = base::DispatchAction::NormalLog,
+               base::type::VerboseLevel verboseLevel = 0) :
+    base::Writer(level, file, line, func, dispatchAction, verboseLevel) {
+  }
+
+  virtual ~PErrorWriter(void);
+};
+}  // namespace base
+// Logging from Logger class. Why this is here? Because we have Storage and Writer class available
+#if ELPP_VARIADIC_TEMPLATES_SUPPORTED
+template <typename T, typename... Args>
+void Logger::log_(Level level, int vlevel, const char* s, const T& value, const Args&... args) {
+  base::MessageBuilder b;
+  b.initialize(this);
+  while (*s) {
+    if (*s == base::consts::kFormatSpecifierChar) {
+      if (*(s + 1) == base::consts::kFormatSpecifierChar) {
+        ++s;
+      } else {
+        if (*(s + 1) == base::consts::kFormatSpecifierCharValue) {
+          ++s;
+          b << value;
+          log_(level, vlevel, ++s, args...);
+          return;
+        }
+      }
+    }
+    b << *s++;
+  }
+  ELPP_INTERNAL_ERROR("Too many arguments provided. Unable to handle. Please provide more format specifiers", false);
+}
+template <typename T>
+void Logger::log_(Level level, int vlevel, const T& log) {
+  if (level == Level::Verbose) {
+    if (ELPP->vRegistry()->allowed(vlevel, __FILE__)) {
+      base::Writer(Level::Verbose, "FILE", 0, "FUNCTION",
+                   base::DispatchAction::NormalLog, vlevel).construct(this, false) << log;
+    } else {
+      stream().str(ELPP_LITERAL(""));
+      releaseLock();
+    }
+  } else {
+    base::Writer(level, "FILE", 0, "FUNCTION").construct(this, false) << log;
+  }
+}
+template <typename T, typename... Args>
+inline void Logger::log(Level level, const char* s, const T& value, const Args&... args) {
+  acquireLock(); // released in Writer!
+  log_(level, 0, s, value, args...);
+}
+template <typename T>
+inline void Logger::log(Level level, const T& log) {
+  acquireLock(); // released in Writer!
+  log_(level, 0, log);
+}
+#  if ELPP_VERBOSE_LOG
+template <typename T, typename... Args>
+inline void Logger::verbose(int vlevel, const char* s, const T& value, const Args&... args) {
+  acquireLock(); // released in Writer!
+  log_(el::Level::Verbose, vlevel, s, value, args...);
+}
+template <typename T>
+inline void Logger::verbose(int vlevel, const T& log) {
+  acquireLock(); // released in Writer!
+  log_(el::Level::Verbose, vlevel, log);
+}
+#  else
+template <typename T, typename... Args>
+inline void Logger::verbose(int, const char*, const T&, const Args&...) {
+  return;
+}
+template <typename T>
+inline void Logger::verbose(int, const T&) {
+  return;
+}
+#  endif  // ELPP_VERBOSE_LOG
+#  define LOGGER_LEVEL_WRITERS(FUNCTION_NAME, LOG_LEVEL)\
+template <typename T, typename... Args>\
+inline void Logger::FUNCTION_NAME(const char* s, const T& value, const Args&... args) {\
+log(LOG_LEVEL, s, value, args...);\
+}\
+template <typename T>\
+inline void Logger::FUNCTION_NAME(const T& value) {\
+log(LOG_LEVEL, value);\
+}
+#  define LOGGER_LEVEL_WRITERS_DISABLED(FUNCTION_NAME, LOG_LEVEL)\
+template <typename T, typename... Args>\
+inline void Logger::FUNCTION_NAME(const char*, const T&, const Args&...) {\
+return;\
+}\
+template <typename T>\
+inline void Logger::FUNCTION_NAME(const T&) {\
+return;\
+}
+
+#  if ELPP_INFO_LOG
+LOGGER_LEVEL_WRITERS(info, Level::Info)
+#  else
+LOGGER_LEVEL_WRITERS_DISABLED(info, Level::Info)
+#  endif // ELPP_INFO_LOG
+#  if ELPP_DEBUG_LOG
+LOGGER_LEVEL_WRITERS(debug, Level::Debug)
+#  else
+LOGGER_LEVEL_WRITERS_DISABLED(debug, Level::Debug)
+#  endif // ELPP_DEBUG_LOG
+#  if ELPP_WARNING_LOG
+LOGGER_LEVEL_WRITERS(warn, Level::Warning)
+#  else
+LOGGER_LEVEL_WRITERS_DISABLED(warn, Level::Warning)
+#  endif // ELPP_WARNING_LOG
+#  if ELPP_ERROR_LOG
+LOGGER_LEVEL_WRITERS(error, Level::Error)
+#  else
+LOGGER_LEVEL_WRITERS_DISABLED(error, Level::Error)
+#  endif // ELPP_ERROR_LOG
+#  if ELPP_FATAL_LOG
+LOGGER_LEVEL_WRITERS(fatal, Level::Fatal)
+#  else
+LOGGER_LEVEL_WRITERS_DISABLED(fatal, Level::Fatal)
+#  endif // ELPP_FATAL_LOG
+#  if ELPP_TRACE_LOG
+LOGGER_LEVEL_WRITERS(trace, Level::Trace)
+#  else
+LOGGER_LEVEL_WRITERS_DISABLED(trace, Level::Trace)
+#  endif // ELPP_TRACE_LOG
+#  undef LOGGER_LEVEL_WRITERS
+#  undef LOGGER_LEVEL_WRITERS_DISABLED
+#endif // ELPP_VARIADIC_TEMPLATES_SUPPORTED
+#if ELPP_COMPILER_MSVC
+#  define ELPP_VARIADIC_FUNC_MSVC(variadicFunction, variadicArgs) variadicFunction variadicArgs
+#  define ELPP_VARIADIC_FUNC_MSVC_RUN(variadicFunction, ...) ELPP_VARIADIC_FUNC_MSVC(variadicFunction, (__VA_ARGS__))
+#  define el_getVALength(...) ELPP_VARIADIC_FUNC_MSVC_RUN(el_resolveVALength, 0, ## __VA_ARGS__,\
+10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
+#else
+#  if ELPP_COMPILER_CLANG
+#    define el_getVALength(...) el_resolveVALength(0, __VA_ARGS__, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
+#  else
+#    define el_getVALength(...) el_resolveVALength(0, ## __VA_ARGS__, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
+#  endif // ELPP_COMPILER_CLANG
+#endif // ELPP_COMPILER_MSVC
+#define el_resolveVALength(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N
+#define ELPP_WRITE_LOG(writer, level, dispatchAction, ...) \
+writer(level, __FILE__, __LINE__, ELPP_FUNC, dispatchAction).construct(el_getVALength(__VA_ARGS__), __VA_ARGS__)
+#define ELPP_WRITE_LOG_IF(writer, condition, level, dispatchAction, ...) if (condition) \
+writer(level, __FILE__, __LINE__, ELPP_FUNC, dispatchAction).construct(el_getVALength(__VA_ARGS__), __VA_ARGS__)
+#define ELPP_WRITE_LOG_EVERY_N(writer, occasion, level, dispatchAction, ...) \
+ELPP->validateEveryNCounter(__FILE__, __LINE__, occasion) && \
+writer(level, __FILE__, __LINE__, ELPP_FUNC, dispatchAction).construct(el_getVALength(__VA_ARGS__), __VA_ARGS__)
+#define ELPP_WRITE_LOG_AFTER_N(writer, n, level, dispatchAction, ...) \
+ELPP->validateAfterNCounter(__FILE__, __LINE__, n) && \
+writer(level, __FILE__, __LINE__, ELPP_FUNC, dispatchAction).construct(el_getVALength(__VA_ARGS__), __VA_ARGS__)
+#define ELPP_WRITE_LOG_N_TIMES(writer, n, level, dispatchAction, ...) \
+ELPP->validateNTimesCounter(__FILE__, __LINE__, n) && \
+writer(level, __FILE__, __LINE__, ELPP_FUNC, dispatchAction).construct(el_getVALength(__VA_ARGS__), __VA_ARGS__)
+#if defined(ELPP_FEATURE_ALL) || defined(ELPP_FEATURE_PERFORMANCE_TRACKING)
+class PerformanceTrackingData {
+ public:
+  enum class DataType : base::type::EnumType {
+    Checkpoint = 1, Complete = 2
+  };
+  // Do not use constructor, will run into multiple definition error, use init(PerformanceTracker*)
+  explicit PerformanceTrackingData(DataType dataType) : m_performanceTracker(nullptr),
+    m_dataType(dataType), m_firstCheckpoint(false), m_file(""), m_line(0), m_func("") {}
+  inline const std::string* blockName(void) const;
+  inline const struct timeval* startTime(void) const;
+  inline const struct timeval* endTime(void) const;
+  inline const struct timeval* lastCheckpointTime(void) const;
+  inline const base::PerformanceTracker* performanceTracker(void) const {
+    return m_performanceTracker;
+  }
+  inline PerformanceTrackingData::DataType dataType(void) const {
+    return m_dataType;
+  }
+  inline bool firstCheckpoint(void) const {
+    return m_firstCheckpoint;
+  }
+  inline std::string checkpointId(void) const {
+    return m_checkpointId;
+  }
+  inline const char* file(void) const {
+    return m_file;
+  }
+  inline base::type::LineNumber line(void) const {
+    return m_line;
+  }
+  inline const char* func(void) const {
+    return m_func;
+  }
+  inline const base::type::string_t* formattedTimeTaken() const {
+    return &m_formattedTimeTaken;
+  }
+  inline const std::string& loggerId(void) const;
+ private:
+  base::PerformanceTracker* m_performanceTracker;
+  base::type::string_t m_formattedTimeTaken;
+  PerformanceTrackingData::DataType m_dataType;
+  bool m_firstCheckpoint;
+  std::string m_checkpointId;
+  const char* m_file;
+  base::type::LineNumber m_line;
+  const char* m_func;
+  inline void init(base::PerformanceTracker* performanceTracker, bool firstCheckpoint = false) {
+    m_performanceTracker = performanceTracker;
+    m_firstCheckpoint = firstCheckpoint;
+  }
+
+  friend class el::base::PerformanceTracker;
+};
+namespace base {
+/// @brief Represents performanceTracker block of code that conditionally adds performance status to log
+///        either when goes outside the scope of when checkpoint() is called
+class PerformanceTracker : public base::threading::ThreadSafe, public Loggable {
+ public:
+  PerformanceTracker(const std::string& blockName,
+                     base::TimestampUnit timestampUnit = base::TimestampUnit::Millisecond,
+                     const std::string& loggerId = std::string(el::base::consts::kPerformanceLoggerId),
+                     bool scopedLog = true, Level level = base::consts::kPerformanceTrackerDefaultLevel);
+  /// @brief Copy constructor
+  PerformanceTracker(const PerformanceTracker& t) :
+    m_blockName(t.m_blockName), m_timestampUnit(t.m_timestampUnit), m_loggerId(t.m_loggerId), m_scopedLog(t.m_scopedLog),
+    m_level(t.m_level), m_hasChecked(t.m_hasChecked), m_lastCheckpointId(t.m_lastCheckpointId), m_enabled(t.m_enabled),
+    m_startTime(t.m_startTime), m_endTime(t.m_endTime), m_lastCheckpointTime(t.m_lastCheckpointTime) {
+  }
+  virtual ~PerformanceTracker(void);
+  /// @brief A checkpoint for current performanceTracker block.
+  void checkpoint(const std::string& id = std::string(), const char* file = __FILE__,
+                  base::type::LineNumber line = __LINE__,
+                  const char* func = "");
+  inline Level level(void) const {
+    return m_level;
+  }
+ private:
+  std::string m_blockName;
+  base::TimestampUnit m_timestampUnit;
+  std::string m_loggerId;
+  bool m_scopedLog;
+  Level m_level;
+  bool m_hasChecked;
+  std::string m_lastCheckpointId;
+  bool m_enabled;
+  struct timeval m_startTime, m_endTime, m_lastCheckpointTime;
+
+  PerformanceTracker(void);
+
+  friend class el::PerformanceTrackingData;
+  friend class base::DefaultPerformanceTrackingCallback;
+
+  const inline base::type::string_t getFormattedTimeTaken() const {
+    return getFormattedTimeTaken(m_startTime);
+  }
+
+  const base::type::string_t getFormattedTimeTaken(struct timeval startTime) const;
+
+  virtual inline void log(el::base::type::ostream_t& os) const {
+    os << getFormattedTimeTaken();
+  }
+};
+class DefaultPerformanceTrackingCallback : public PerformanceTrackingCallback {
+ protected:
+  void handle(const PerformanceTrackingData* data) {
+    m_data = data;
+    base::type::stringstream_t ss;
+    if (m_data->dataType() == PerformanceTrackingData::DataType::Complete) {
+      ss << ELPP_LITERAL("Executed [") << m_data->blockName()->c_str() << ELPP_LITERAL("] in [") <<
+         *m_data->formattedTimeTaken() << ELPP_LITERAL("]");
+    } else {
+      ss << ELPP_LITERAL("Performance checkpoint");
+      if (!m_data->checkpointId().empty()) {
+        ss << ELPP_LITERAL(" [") << m_data->checkpointId().c_str() << ELPP_LITERAL("]");
+      }
+      ss << ELPP_LITERAL(" for block [") << m_data->blockName()->c_str() << ELPP_LITERAL("] : [") <<
+         *m_data->performanceTracker();
+      if (!ELPP->hasFlag(LoggingFlag::DisablePerformanceTrackingCheckpointComparison)
+          && m_data->performanceTracker()->m_hasChecked) {
+        ss << ELPP_LITERAL(" ([") << *m_data->formattedTimeTaken() << ELPP_LITERAL("] from ");
+        if (m_data->performanceTracker()->m_lastCheckpointId.empty()) {
+          ss << ELPP_LITERAL("last checkpoint");
+        } else {
+          ss << ELPP_LITERAL("checkpoint '") << m_data->performanceTracker()->m_lastCheckpointId.c_str() << ELPP_LITERAL("'");
+        }
+        ss << ELPP_LITERAL(")]");
+      } else {
+        ss << ELPP_LITERAL("]");
+      }
+    }
+    el::base::Writer(m_data->performanceTracker()->level(), m_data->file(), m_data->line(), m_data->func()).construct(1,
+        m_data->loggerId().c_str()) << ss.str();
+  }
+ private:
+  const PerformanceTrackingData* m_data;
+};
+}  // namespace base
+inline const std::string* PerformanceTrackingData::blockName() const {
+  return const_cast<const std::string*>(&m_performanceTracker->m_blockName);
+}
+inline const struct timeval* PerformanceTrackingData::startTime() const {
+  return const_cast<const struct timeval*>(&m_performanceTracker->m_startTime);
+}
+inline const struct timeval* PerformanceTrackingData::endTime() const {
+  return const_cast<const struct timeval*>(&m_performanceTracker->m_endTime);
+}
+inline const struct timeval* PerformanceTrackingData::lastCheckpointTime() const {
+  return const_cast<const struct timeval*>(&m_performanceTracker->m_lastCheckpointTime);
+}
+inline const std::string& PerformanceTrackingData::loggerId(void) const {
+  return m_performanceTracker->m_loggerId;
+}
+#endif // defined(ELPP_FEATURE_ALL) || defined(ELPP_FEATURE_PERFORMANCE_TRACKING)
+namespace base {
+/// @brief Contains some internal debugging tools like crash handler and stack tracer
+namespace debug {
+#if defined(ELPP_FEATURE_ALL) || defined(ELPP_FEATURE_CRASH_LOG)
+class StackTrace : base::NoCopy {
+ public:
+  static const unsigned int kMaxStack = 64;
+  static const unsigned int kStackStart = 2;  // We want to skip c'tor and StackTrace::generateNew()
+  class StackTraceEntry {
+   public:
+    StackTraceEntry(std::size_t index, const std::string& loc, const std::string& demang, const std::string& hex,
+                    const std::string& addr);
+    StackTraceEntry(std::size_t index, const std::string& loc) :
+      m_index(index),
+      m_location(loc) {
+    }
+    std::size_t m_index;
+    std::string m_location;
+    std::string m_demangled;
+    std::string m_hex;
+    std::string m_addr;
+    friend std::ostream& operator<<(std::ostream& ss, const StackTraceEntry& si);
+
+   private:
+    StackTraceEntry(void);
+  };
+
+  StackTrace(void) {
+    generateNew();
+  }
+
+  virtual ~StackTrace(void) {
+  }
+
+  inline std::vector<StackTraceEntry>& getLatestStack(void) {
+    return m_stack;
+  }
+
+  friend std::ostream& operator<<(std::ostream& os, const StackTrace& st);
+
+ private:
+  std::vector<StackTraceEntry> m_stack;
+
+  void generateNew(void);
+};
+/// @brief Handles unexpected crashes
+class CrashHandler : base::NoCopy {
+ public:
+  typedef void (*Handler)(int);
+
+  explicit CrashHandler(bool useDefault);
+  explicit CrashHandler(const Handler& cHandler) {
+    setHandler(cHandler);
+  }
+  void setHandler(const Handler& cHandler);
+
+ private:
+  Handler m_handler;
+};
+#else
+class CrashHandler {
+ public:
+  explicit CrashHandler(bool) {}
+};
+#endif // defined(ELPP_FEATURE_ALL) || defined(ELPP_FEATURE_CRASH_LOG)
+}  // namespace debug
+}  // namespace base
+extern base::debug::CrashHandler elCrashHandler;
+#define MAKE_LOGGABLE(ClassType, ClassInstance, OutputStreamInstance) \
+el::base::type::ostream_t& operator<<(el::base::type::ostream_t& OutputStreamInstance, const ClassType& ClassInstance)
+/// @brief Initializes syslog with process ID, options and facility. calls closelog() on d'tor
+class SysLogInitializer {
+ public:
+  SysLogInitializer(const char* processIdent, int options = 0, int facility = 0) {
+#if defined(ELPP_SYSLOG)
+    openlog(processIdent, options, facility);
+#else
+    ELPP_UNUSED(processIdent);
+    ELPP_UNUSED(options);
+    ELPP_UNUSED(facility);
+#endif  // defined(ELPP_SYSLOG)
+  }
+  virtual ~SysLogInitializer(void) {
+#if defined(ELPP_SYSLOG)
+    closelog();
+#endif  // defined(ELPP_SYSLOG)
+  }
+};
+#define ELPP_INITIALIZE_SYSLOG(id, opt, fac) el::SysLogInitializer elSyslogInit(id, opt, fac)
+/// @brief Static helpers for developers
+class Helpers : base::StaticClass {
+ public:
+  /// @brief Shares logging repository (base::Storage)
+  static inline void setStorage(base::type::StoragePointer storage) {
+    ELPP = storage;
+  }
+  /// @return Main storage repository
+  static inline base::type::StoragePointer storage() {
+    return ELPP;
+  }
+  /// @brief Sets application arguments and figures out whats active for logging and whats not.
+  static inline void setArgs(int argc, char** argv) {
+    ELPP->setApplicationArguments(argc, argv);
+  }
+  /// @copydoc setArgs(int argc, char** argv)
+  static inline void setArgs(int argc, const char** argv) {
+    ELPP->setApplicationArguments(argc, const_cast<char**>(argv));
+  }
+  /// @brief Sets thread name for current thread. Requires std::thread
+  static inline void setThreadName(const std::string& name) {
+    ELPP->setThreadName(name);
+  }
+  static inline std::string getThreadName() {
+    return ELPP->getThreadName(base::threading::getCurrentThreadId());
+  }
+#if defined(ELPP_FEATURE_ALL) || defined(ELPP_FEATURE_CRASH_LOG)
+  /// @brief Overrides default crash handler and installs custom handler.
+  /// @param crashHandler A functor with no return type that takes single int argument.
+  ///        Handler is a typedef with specification: void (*Handler)(int)
+  static inline void setCrashHandler(const el::base::debug::CrashHandler::Handler& crashHandler) {
+    el::elCrashHandler.setHandler(crashHandler);
+  }
+  /// @brief Abort due to crash with signal in parameter
+  /// @param sig Crash signal
+  static void crashAbort(int sig, const char* sourceFile = "", unsigned int long line = 0);
+  /// @brief Logs reason of crash as per sig
+  /// @param sig Crash signal
+  /// @param stackTraceIfAvailable Includes stack trace if available
+  /// @param level Logging level
+  /// @param logger Logger to use for logging
+  static void logCrashReason(int sig, bool stackTraceIfAvailable = false,
+                             Level level = Level::Fatal, const char* logger = base::consts::kDefaultLoggerId);
+#endif // defined(ELPP_FEATURE_ALL) || defined(ELPP_FEATURE_CRASH_LOG)
+  /// @brief Installs pre rollout callback, this callback is triggered when log file is about to be rolled out
+  ///        (can be useful for backing up)
+  static inline void installPreRollOutCallback(const PreRollOutCallback& callback) {
+    ELPP->setPreRollOutCallback(callback);
+  }
+  /// @brief Uninstalls pre rollout callback
+  static inline void uninstallPreRollOutCallback(void) {
+    ELPP->unsetPreRollOutCallback();
+  }
+  /// @brief Installs post log dispatch callback, this callback is triggered when log is dispatched
+  template <typename T>
+  static inline bool installLogDispatchCallback(const std::string& id) {
+    return ELPP->installLogDispatchCallback<T>(id);
+  }
+  /// @brief Uninstalls log dispatch callback
+  template <typename T>
+  static inline void uninstallLogDispatchCallback(const std::string& id) {
+    ELPP->uninstallLogDispatchCallback<T>(id);
+  }
+  template <typename T>
+  static inline T* logDispatchCallback(const std::string& id) {
+    return ELPP->logDispatchCallback<T>(id);
+  }
+#if defined(ELPP_FEATURE_ALL) || defined(ELPP_FEATURE_PERFORMANCE_TRACKING)
+  /// @brief Installs post performance tracking callback, this callback is triggered when performance tracking is finished
+  template <typename T>
+  static inline bool installPerformanceTrackingCallback(const std::string& id) {
+    return ELPP->installPerformanceTrackingCallback<T>(id);
+  }
+  /// @brief Uninstalls post performance tracking handler
+  template <typename T>
+  static inline void uninstallPerformanceTrackingCallback(const std::string& id) {
+    ELPP->uninstallPerformanceTrackingCallback<T>(id);
+  }
+  template <typename T>
+  static inline T* performanceTrackingCallback(const std::string& id) {
+    return ELPP->performanceTrackingCallback<T>(id);
+  }
+#endif // defined(ELPP_FEATURE_ALL) || defined(ELPP_FEATURE_PERFORMANCE_TRACKING)
+  /// @brief Converts template to std::string - useful for loggable classes to log containers within log(std::ostream&) const
+  template <typename T>
+  static std::string convertTemplateToStdString(const T& templ) {
+    el::Logger* logger =
+      ELPP->registeredLoggers()->get(el::base::consts::kDefaultLoggerId);
+    if (logger == nullptr) {
+      return std::string();
+    }
+    base::MessageBuilder b;
+    b.initialize(logger);
+    logger->acquireLock();
+    b << templ;
+#if defined(ELPP_UNICODE)
+    std::string s = std::string(logger->stream().str().begin(), logger->stream().str().end());
+#else
+    std::string s = logger->stream().str();
+#endif  // defined(ELPP_UNICODE)
+    logger->stream().str(ELPP_LITERAL(""));
+    logger->releaseLock();
+    return s;
+  }
+  /// @brief Returns command line arguments (pointer) provided to easylogging++
+  static inline const el::base::utils::CommandLineArgs* commandLineArgs(void) {
+    return ELPP->commandLineArgs();
+  }
+  /// @brief Reserve space for custom format specifiers for performance
+  /// @see std::vector::reserve
+  static inline void reserveCustomFormatSpecifiers(std::size_t size) {
+    ELPP->m_customFormatSpecifiers.reserve(size);
+  }
+  /// @brief Installs user defined format specifier and handler
+  static inline void installCustomFormatSpecifier(const CustomFormatSpecifier& customFormatSpecifier) {
+    ELPP->installCustomFormatSpecifier(customFormatSpecifier);
+  }
+  /// @brief Uninstalls user defined format specifier and handler
+  static inline bool uninstallCustomFormatSpecifier(const char* formatSpecifier) {
+    return ELPP->uninstallCustomFormatSpecifier(formatSpecifier);
+  }
+  /// @brief Returns true if custom format specifier is installed
+  static inline bool hasCustomFormatSpecifier(const char* formatSpecifier) {
+    return ELPP->hasCustomFormatSpecifier(formatSpecifier);
+  }
+  static inline void validateFileRolling(Logger* logger, Level level) {
+    if (ELPP == nullptr || logger == nullptr) return;
+    logger->m_typedConfigurations->validateFileRolling(level, ELPP->preRollOutCallback());
+  }
+};
+/// @brief Static helpers to deal with loggers and their configurations
+class Loggers : base::StaticClass {
+ public:
+  /// @brief Gets existing or registers new logger
+  static Logger* getLogger(const std::string& identity, bool registerIfNotAvailable = true);
+  /// @brief Changes default log builder for future loggers
+  static void setDefaultLogBuilder(el::LogBuilderPtr& logBuilderPtr);
+  /// @brief Installs logger registration callback, this callback is triggered when new logger is registered
+  template <typename T>
+  static inline bool installLoggerRegistrationCallback(const std::string& id) {
+    return ELPP->registeredLoggers()->installLoggerRegistrationCallback<T>(id);
+  }
+  /// @brief Uninstalls log dispatch callback
+  template <typename T>
+  static inline void uninstallLoggerRegistrationCallback(const std::string& id) {
+    ELPP->registeredLoggers()->uninstallLoggerRegistrationCallback<T>(id);
+  }
+  template <typename T>
+  static inline T* loggerRegistrationCallback(const std::string& id) {
+    return ELPP->registeredLoggers()->loggerRegistrationCallback<T>(id);
+  }
+  /// @brief Unregisters logger - use it only when you know what you are doing, you may unregister
+  ///        loggers initialized / used by third-party libs.
+  static bool unregisterLogger(const std::string& identity);
+  /// @brief Whether or not logger with id is registered
+  static bool hasLogger(const std::string& identity);
+  /// @brief Reconfigures specified logger with new configurations
+  static Logger* reconfigureLogger(Logger* logger, const Configurations& configurations);
+  /// @brief Reconfigures logger with new configurations after looking it up using identity
+  static Logger* reconfigureLogger(const std::string& identity, const Configurations& configurations);
+  /// @brief Reconfigures logger's single configuration
+  static Logger* reconfigureLogger(const std::string& identity, ConfigurationType configurationType,
+                                   const std::string& value);
+  /// @brief Reconfigures all the existing loggers with new configurations
+  static void reconfigureAllLoggers(const Configurations& configurations);
+  /// @brief Reconfigures single configuration for all the loggers
+  static inline void reconfigureAllLoggers(ConfigurationType configurationType, const std::string& value) {
+    reconfigureAllLoggers(Level::Global, configurationType, value);
+  }
+  /// @brief Reconfigures single configuration for all the loggers for specified level
+  static void reconfigureAllLoggers(Level level, ConfigurationType configurationType,
+                                    const std::string& value);
+  /// @brief Sets default configurations. This configuration is used for future (and conditionally for existing) loggers
+  static void setDefaultConfigurations(const Configurations& configurations,
+                                       bool reconfigureExistingLoggers = false);
+  /// @brief Returns current default
+  static const Configurations* defaultConfigurations(void);
+  /// @brief Returns log stream reference pointer if needed by user
+  static const base::LogStreamsReferenceMap* logStreamsReference(void);
+  /// @brief Default typed configuration based on existing defaultConf
+  static base::TypedConfigurations defaultTypedConfigurations(void);
+  /// @brief Populates all logger IDs in current repository.
+  /// @param [out] targetList List of fill up.
+  static std::vector<std::string>* populateAllLoggerIds(std::vector<std::string>* targetList);
+  /// @brief Sets configurations from global configuration file.
+  static void configureFromGlobal(const char* globalConfigurationFilePath);
+  /// @brief Configures loggers using command line arg. Ensure you have already set command line args,
+  /// @return False if invalid argument or argument with no value provided, true if attempted to configure logger.
+  ///         If true is returned that does not mean it has been configured successfully, it only means that it
+  ///         has attempeted to configure logger using configuration file provided in argument
+  static bool configureFromArg(const char* argKey);
+  /// @brief Flushes all loggers for all levels - Be careful if you dont know how many loggers are registered
+  static void flushAll(void);
+  /// @brief Adds logging flag used internally.
+  static inline void addFlag(LoggingFlag flag) {
+    ELPP->addFlag(flag);
+  }
+  /// @brief Removes logging flag used internally.
+  static inline void removeFlag(LoggingFlag flag) {
+    ELPP->removeFlag(flag);
+  }
+  /// @brief Determines whether or not certain flag is active
+  static inline bool hasFlag(LoggingFlag flag) {
+    return ELPP->hasFlag(flag);
+  }
+  /// @brief Adds flag and removes it when scope goes out
+  class ScopedAddFlag {
+   public:
+    ScopedAddFlag(LoggingFlag flag) : m_flag(flag) {
+      Loggers::addFlag(m_flag);
+    }
+    ~ScopedAddFlag(void) {
+      Loggers::removeFlag(m_flag);
+    }
+   private:
+    LoggingFlag m_flag;
+  };
+  /// @brief Removes flag and add it when scope goes out
+  class ScopedRemoveFlag {
+   public:
+    ScopedRemoveFlag(LoggingFlag flag) : m_flag(flag) {
+      Loggers::removeFlag(m_flag);
+    }
+    ~ScopedRemoveFlag(void) {
+      Loggers::addFlag(m_flag);
+    }
+   private:
+    LoggingFlag m_flag;
+  };
+  /// @brief Sets hierarchy for logging. Needs to enable logging flag (HierarchicalLogging)
+  static void setLoggingLevel(Level level) {
+    ELPP->setLoggingLevel(level);
+  }
+  /// @brief Sets verbose level on the fly
+  static void setVerboseLevel(base::type::VerboseLevel level);
+  /// @brief Gets current verbose level
+  static base::type::VerboseLevel verboseLevel(void);
+  /// @brief Sets vmodules as specified (on the fly)
+  static void setVModules(const char* modules);
+  /// @brief Clears vmodules
+  static void clearVModules(void);
+};
+class VersionInfo : base::StaticClass {
+ public:
+  /// @brief Current version number
+  static const std::string version(void);
+
+  /// @brief Release date of current version
+  static const std::string releaseDate(void);
+};
+}  // namespace el
+#undef VLOG_IS_ON
+/// @brief Determines whether verbose logging is on for specified level current file.
+#define VLOG_IS_ON(verboseLevel) (ELPP->vRegistry()->allowed(verboseLevel, __FILE__))
+#undef TIMED_BLOCK
+#undef TIMED_SCOPE
+#undef TIMED_SCOPE_IF
+#undef TIMED_FUNC
+#undef TIMED_FUNC_IF
+#undef ELPP_MIN_UNIT
+#if defined(ELPP_PERFORMANCE_MICROSECONDS)
+#  define ELPP_MIN_UNIT el::base::TimestampUnit::Microsecond
+#else
+#  define ELPP_MIN_UNIT el::base::TimestampUnit::Millisecond
+#endif  // (defined(ELPP_PERFORMANCE_MICROSECONDS))
+/// @brief Performance tracked scope. Performance gets written when goes out of scope using
+///        'performance' logger.
+///
+/// @detail Please note in order to check the performance at a certain time you can use obj->checkpoint();
+/// @see el::base::PerformanceTracker
+/// @see el::base::PerformanceTracker::checkpoint
+// Note: Do not surround this definition with null macro because of obj instance
+#define TIMED_SCOPE_IF(obj, blockname, condition) el::base::type::PerformanceTrackerPtr obj( condition ? \
+  new el::base::PerformanceTracker(blockname, ELPP_MIN_UNIT) : nullptr )
+#define TIMED_SCOPE(obj, blockname) TIMED_SCOPE_IF(obj, blockname, true)
+#define TIMED_BLOCK(obj, blockName) for (struct { int i; el::base::type::PerformanceTrackerPtr timer; } obj = { 0, \
+  el::base::type::PerformanceTrackerPtr(new el::base::PerformanceTracker(blockName, ELPP_MIN_UNIT)) }; obj.i < 1; ++obj.i)
+/// @brief Performance tracked function. Performance gets written when goes out of scope using
+///        'performance' logger.
+///
+/// @detail Please note in order to check the performance at a certain time you can use obj->checkpoint();
+/// @see el::base::PerformanceTracker
+/// @see el::base::PerformanceTracker::checkpoint
+#define TIMED_FUNC_IF(obj,condition) TIMED_SCOPE_IF(obj, ELPP_FUNC, condition)
+#define TIMED_FUNC(obj) TIMED_SCOPE(obj, ELPP_FUNC)
+#undef PERFORMANCE_CHECKPOINT
+#undef PERFORMANCE_CHECKPOINT_WITH_ID
+#define PERFORMANCE_CHECKPOINT(obj) obj->checkpoint(std::string(), __FILE__, __LINE__, ELPP_FUNC)
+#define PERFORMANCE_CHECKPOINT_WITH_ID(obj, id) obj->checkpoint(id, __FILE__, __LINE__, ELPP_FUNC)
+#undef ELPP_COUNTER
+#undef ELPP_COUNTER_POS
+/// @brief Gets hit counter for file/line
+#define ELPP_COUNTER (ELPP->hitCounters()->getCounter(__FILE__, __LINE__))
+/// @brief Gets hit counter position for file/line, -1 if not registered yet
+#define ELPP_COUNTER_POS (ELPP_COUNTER == nullptr ? -1 : ELPP_COUNTER->hitCounts())
+// Undef levels to support LOG(LEVEL)
+#undef INFO
+#undef WARNING
+#undef DEBUG
+#undef ERROR
+#undef FATAL
+#undef TRACE
+#undef VERBOSE
+// Undef existing
+#undef CINFO
+#undef CWARNING
+#undef CDEBUG
+#undef CFATAL
+#undef CERROR
+#undef CTRACE
+#undef CVERBOSE
+#undef CINFO_IF
+#undef CWARNING_IF
+#undef CDEBUG_IF
+#undef CERROR_IF
+#undef CFATAL_IF
+#undef CTRACE_IF
+#undef CVERBOSE_IF
+#undef CINFO_EVERY_N
+#undef CWARNING_EVERY_N
+#undef CDEBUG_EVERY_N
+#undef CERROR_EVERY_N
+#undef CFATAL_EVERY_N
+#undef CTRACE_EVERY_N
+#undef CVERBOSE_EVERY_N
+#undef CINFO_AFTER_N
+#undef CWARNING_AFTER_N
+#undef CDEBUG_AFTER_N
+#undef CERROR_AFTER_N
+#undef CFATAL_AFTER_N
+#undef CTRACE_AFTER_N
+#undef CVERBOSE_AFTER_N
+#undef CINFO_N_TIMES
+#undef CWARNING_N_TIMES
+#undef CDEBUG_N_TIMES
+#undef CERROR_N_TIMES
+#undef CFATAL_N_TIMES
+#undef CTRACE_N_TIMES
+#undef CVERBOSE_N_TIMES
+// Normal logs
+#if ELPP_INFO_LOG
+#  define CINFO(writer, dispatchAction, ...) ELPP_WRITE_LOG(writer, el::Level::Info, dispatchAction, __VA_ARGS__)
+#else
+#  define CINFO(writer, dispatchAction, ...) el::base::NullWriter()
+#endif  // ELPP_INFO_LOG
+#if ELPP_WARNING_LOG
+#  define CWARNING(writer, dispatchAction, ...) ELPP_WRITE_LOG(writer, el::Level::Warning, dispatchAction, __VA_ARGS__)
+#else
+#  define CWARNING(writer, dispatchAction, ...) el::base::NullWriter()
+#endif  // ELPP_WARNING_LOG
+#if ELPP_DEBUG_LOG
+#  define CDEBUG(writer, dispatchAction, ...) ELPP_WRITE_LOG(writer, el::Level::Debug, dispatchAction, __VA_ARGS__)
+#else
+#  define CDEBUG(writer, dispatchAction, ...) el::base::NullWriter()
+#endif  // ELPP_DEBUG_LOG
+#if ELPP_ERROR_LOG
+#  define CERROR(writer, dispatchAction, ...) ELPP_WRITE_LOG(writer, el::Level::Error, dispatchAction, __VA_ARGS__)
+#else
+#  define CERROR(writer, dispatchAction, ...) el::base::NullWriter()
+#endif  // ELPP_ERROR_LOG
+#if ELPP_FATAL_LOG
+#  define CFATAL(writer, dispatchAction, ...) ELPP_WRITE_LOG(writer, el::Level::Fatal, dispatchAction, __VA_ARGS__)
+#else
+#  define CFATAL(writer, dispatchAction, ...) el::base::NullWriter()
+#endif  // ELPP_FATAL_LOG
+#if ELPP_TRACE_LOG
+#  define CTRACE(writer, dispatchAction, ...) ELPP_WRITE_LOG(writer, el::Level::Trace, dispatchAction, __VA_ARGS__)
+#else
+#  define CTRACE(writer, dispatchAction, ...) el::base::NullWriter()
+#endif  // ELPP_TRACE_LOG
+#if ELPP_VERBOSE_LOG
+#  define CVERBOSE(writer, vlevel, dispatchAction, ...) if (VLOG_IS_ON(vlevel)) writer(\
+el::Level::Verbose, __FILE__, __LINE__, ELPP_FUNC, dispatchAction, vlevel).construct(el_getVALength(__VA_ARGS__), __VA_ARGS__)
+#else
+#  define CVERBOSE(writer, vlevel, dispatchAction, ...) el::base::NullWriter()
+#endif  // ELPP_VERBOSE_LOG
+// Conditional logs
+#if ELPP_INFO_LOG
+#  define CINFO_IF(writer, condition_, dispatchAction, ...) \
+ELPP_WRITE_LOG_IF(writer, (condition_), el::Level::Info, dispatchAction, __VA_ARGS__)
+#else
+#  define CINFO_IF(writer, condition_, dispatchAction, ...) el::base::NullWriter()
+#endif  // ELPP_INFO_LOG
+#if ELPP_WARNING_LOG
+#  define CWARNING_IF(writer, condition_, dispatchAction, ...)\
+ELPP_WRITE_LOG_IF(writer, (condition_), el::Level::Warning, dispatchAction, __VA_ARGS__)
+#else
+#  define CWARNING_IF(writer, condition_, dispatchAction, ...) el::base::NullWriter()
+#endif  // ELPP_WARNING_LOG
+#if ELPP_DEBUG_LOG
+#  define CDEBUG_IF(writer, condition_, dispatchAction, ...)\
+ELPP_WRITE_LOG_IF(writer, (condition_), el::Level::Debug, dispatchAction, __VA_ARGS__)
+#else
+#  define CDEBUG_IF(writer, condition_, dispatchAction, ...) el::base::NullWriter()
+#endif  // ELPP_DEBUG_LOG
+#if ELPP_ERROR_LOG
+#  define CERROR_IF(writer, condition_, dispatchAction, ...)\
+ELPP_WRITE_LOG_IF(writer, (condition_), el::Level::Error, dispatchAction, __VA_ARGS__)
+#else
+#  define CERROR_IF(writer, condition_, dispatchAction, ...) el::base::NullWriter()
+#endif  // ELPP_ERROR_LOG
+#if ELPP_FATAL_LOG
+#  define CFATAL_IF(writer, condition_, dispatchAction, ...)\
+ELPP_WRITE_LOG_IF(writer, (condition_), el::Level::Fatal, dispatchAction, __VA_ARGS__)
+#else
+#  define CFATAL_IF(writer, condition_, dispatchAction, ...) el::base::NullWriter()
+#endif  // ELPP_FATAL_LOG
+#if ELPP_TRACE_LOG
+#  define CTRACE_IF(writer, condition_, dispatchAction, ...)\
+ELPP_WRITE_LOG_IF(writer, (condition_), el::Level::Trace, dispatchAction, __VA_ARGS__)
+#else
+#  define CTRACE_IF(writer, condition_, dispatchAction, ...) el::base::NullWriter()
+#endif  // ELPP_TRACE_LOG
+#if ELPP_VERBOSE_LOG
+#  define CVERBOSE_IF(writer, condition_, vlevel, dispatchAction, ...) if (VLOG_IS_ON(vlevel) && (condition_)) writer( \
+el::Level::Verbose, __FILE__, __LINE__, ELPP_FUNC, dispatchAction, vlevel).construct(el_getVALength(__VA_ARGS__), __VA_ARGS__)
+#else
+#  define CVERBOSE_IF(writer, condition_, vlevel, dispatchAction, ...) el::base::NullWriter()
+#endif  // ELPP_VERBOSE_LOG
+// Occasional logs
+#if ELPP_INFO_LOG
+#  define CINFO_EVERY_N(writer, occasion, dispatchAction, ...)\
+ELPP_WRITE_LOG_EVERY_N(writer, occasion, el::Level::Info, dispatchAction, __VA_ARGS__)
+#else
+#  define CINFO_EVERY_N(writer, occasion, dispatchAction, ...) el::base::NullWriter()
+#endif  // ELPP_INFO_LOG
+#if ELPP_WARNING_LOG
+#  define CWARNING_EVERY_N(writer, occasion, dispatchAction, ...)\
+ELPP_WRITE_LOG_EVERY_N(writer, occasion, el::Level::Warning, dispatchAction, __VA_ARGS__)
+#else
+#  define CWARNING_EVERY_N(writer, occasion, dispatchAction, ...) el::base::NullWriter()
+#endif  // ELPP_WARNING_LOG
+#if ELPP_DEBUG_LOG
+#  define CDEBUG_EVERY_N(writer, occasion, dispatchAction, ...)\
+ELPP_WRITE_LOG_EVERY_N(writer, occasion, el::Level::Debug, dispatchAction, __VA_ARGS__)
+#else
+#  define CDEBUG_EVERY_N(writer, occasion, dispatchAction, ...) el::base::NullWriter()
+#endif  // ELPP_DEBUG_LOG
+#if ELPP_ERROR_LOG
+#  define CERROR_EVERY_N(writer, occasion, dispatchAction, ...)\
+ELPP_WRITE_LOG_EVERY_N(writer, occasion, el::Level::Error, dispatchAction, __VA_ARGS__)
+#else
+#  define CERROR_EVERY_N(writer, occasion, dispatchAction, ...) el::base::NullWriter()
+#endif  // ELPP_ERROR_LOG
+#if ELPP_FATAL_LOG
+#  define CFATAL_EVERY_N(writer, occasion, dispatchAction, ...)\
+ELPP_WRITE_LOG_EVERY_N(writer, occasion, el::Level::Fatal, dispatchAction, __VA_ARGS__)
+#else
+#  define CFATAL_EVERY_N(writer, occasion, dispatchAction, ...) el::base::NullWriter()
+#endif  // ELPP_FATAL_LOG
+#if ELPP_TRACE_LOG
+#  define CTRACE_EVERY_N(writer, occasion, dispatchAction, ...)\
+ELPP_WRITE_LOG_EVERY_N(writer, occasion, el::Level::Trace, dispatchAction, __VA_ARGS__)
+#else
+#  define CTRACE_EVERY_N(writer, occasion, dispatchAction, ...) el::base::NullWriter()
+#endif  // ELPP_TRACE_LOG
+#if ELPP_VERBOSE_LOG
+#  define CVERBOSE_EVERY_N(writer, occasion, vlevel, dispatchAction, ...)\
+CVERBOSE_IF(writer, ELPP->validateEveryNCounter(__FILE__, __LINE__, occasion), vlevel, dispatchAction, __VA_ARGS__)
+#else
+#  define CVERBOSE_EVERY_N(writer, occasion, vlevel, dispatchAction, ...) el::base::NullWriter()
+#endif  // ELPP_VERBOSE_LOG
+// After N logs
+#if ELPP_INFO_LOG
+#  define CINFO_AFTER_N(writer, n, dispatchAction, ...)\
+ELPP_WRITE_LOG_AFTER_N(writer, n, el::Level::Info, dispatchAction, __VA_ARGS__)
+#else
+#  define CINFO_AFTER_N(writer, n, dispatchAction, ...) el::base::NullWriter()
+#endif  // ELPP_INFO_LOG
+#if ELPP_WARNING_LOG
+#  define CWARNING_AFTER_N(writer, n, dispatchAction, ...)\
+ELPP_WRITE_LOG_AFTER_N(writer, n, el::Level::Warning, dispatchAction, __VA_ARGS__)
+#else
+#  define CWARNING_AFTER_N(writer, n, dispatchAction, ...) el::base::NullWriter()
+#endif  // ELPP_WARNING_LOG
+#if ELPP_DEBUG_LOG
+#  define CDEBUG_AFTER_N(writer, n, dispatchAction, ...)\
+ELPP_WRITE_LOG_AFTER_N(writer, n, el::Level::Debug, dispatchAction, __VA_ARGS__)
+#else
+#  define CDEBUG_AFTER_N(writer, n, dispatchAction, ...) el::base::NullWriter()
+#endif  // ELPP_DEBUG_LOG
+#if ELPP_ERROR_LOG
+#  define CERROR_AFTER_N(writer, n, dispatchAction, ...)\
+ELPP_WRITE_LOG_AFTER_N(writer, n, el::Level::Error, dispatchAction, __VA_ARGS__)
+#else
+#  define CERROR_AFTER_N(writer, n, dispatchAction, ...) el::base::NullWriter()
+#endif  // ELPP_ERROR_LOG
+#if ELPP_FATAL_LOG
+#  define CFATAL_AFTER_N(writer, n, dispatchAction, ...)\
+ELPP_WRITE_LOG_AFTER_N(writer, n, el::Level::Fatal, dispatchAction, __VA_ARGS__)
+#else
+#  define CFATAL_AFTER_N(writer, n, dispatchAction, ...) el::base::NullWriter()
+#endif  // ELPP_FATAL_LOG
+#if ELPP_TRACE_LOG
+#  define CTRACE_AFTER_N(writer, n, dispatchAction, ...)\
+ELPP_WRITE_LOG_AFTER_N(writer, n, el::Level::Trace, dispatchAction, __VA_ARGS__)
+#else
+#  define CTRACE_AFTER_N(writer, n, dispatchAction, ...) el::base::NullWriter()
+#endif  // ELPP_TRACE_LOG
+#if ELPP_VERBOSE_LOG
+#  define CVERBOSE_AFTER_N(writer, n, vlevel, dispatchAction, ...)\
+CVERBOSE_IF(writer, ELPP->validateAfterNCounter(__FILE__, __LINE__, n), vlevel, dispatchAction, __VA_ARGS__)
+#else
+#  define CVERBOSE_AFTER_N(writer, n, vlevel, dispatchAction, ...) el::base::NullWriter()
+#endif  // ELPP_VERBOSE_LOG
+// N Times logs
+#if ELPP_INFO_LOG
+#  define CINFO_N_TIMES(writer, n, dispatchAction, ...)\
+ELPP_WRITE_LOG_N_TIMES(writer, n, el::Level::Info, dispatchAction, __VA_ARGS__)
+#else
+#  define CINFO_N_TIMES(writer, n, dispatchAction, ...) el::base::NullWriter()
+#endif  // ELPP_INFO_LOG
+#if ELPP_WARNING_LOG
+#  define CWARNING_N_TIMES(writer, n, dispatchAction, ...)\
+ELPP_WRITE_LOG_N_TIMES(writer, n, el::Level::Warning, dispatchAction, __VA_ARGS__)
+#else
+#  define CWARNING_N_TIMES(writer, n, dispatchAction, ...) el::base::NullWriter()
+#endif  // ELPP_WARNING_LOG
+#if ELPP_DEBUG_LOG
+#  define CDEBUG_N_TIMES(writer, n, dispatchAction, ...)\
+ELPP_WRITE_LOG_N_TIMES(writer, n, el::Level::Debug, dispatchAction, __VA_ARGS__)
+#else
+#  define CDEBUG_N_TIMES(writer, n, dispatchAction, ...) el::base::NullWriter()
+#endif  // ELPP_DEBUG_LOG
+#if ELPP_ERROR_LOG
+#  define CERROR_N_TIMES(writer, n, dispatchAction, ...)\
+ELPP_WRITE_LOG_N_TIMES(writer, n, el::Level::Error, dispatchAction, __VA_ARGS__)
+#else
+#  define CERROR_N_TIMES(writer, n, dispatchAction, ...) el::base::NullWriter()
+#endif  // ELPP_ERROR_LOG
+#if ELPP_FATAL_LOG
+#  define CFATAL_N_TIMES(writer, n, dispatchAction, ...)\
+ELPP_WRITE_LOG_N_TIMES(writer, n, el::Level::Fatal, dispatchAction, __VA_ARGS__)
+#else
+#  define CFATAL_N_TIMES(writer, n, dispatchAction, ...) el::base::NullWriter()
+#endif  // ELPP_FATAL_LOG
+#if ELPP_TRACE_LOG
+#  define CTRACE_N_TIMES(writer, n, dispatchAction, ...)\
+ELPP_WRITE_LOG_N_TIMES(writer, n, el::Level::Trace, dispatchAction, __VA_ARGS__)
+#else
+#  define CTRACE_N_TIMES(writer, n, dispatchAction, ...) el::base::NullWriter()
+#endif  // ELPP_TRACE_LOG
+#if ELPP_VERBOSE_LOG
+#  define CVERBOSE_N_TIMES(writer, n, vlevel, dispatchAction, ...)\
+CVERBOSE_IF(writer, ELPP->validateNTimesCounter(__FILE__, __LINE__, n), vlevel, dispatchAction, __VA_ARGS__)
+#else
+#  define CVERBOSE_N_TIMES(writer, n, vlevel, dispatchAction, ...) el::base::NullWriter()
+#endif  // ELPP_VERBOSE_LOG
+//
+// Custom Loggers - Requires (level, dispatchAction, loggerId/s)
+//
+// undef existing
+#undef CLOG
+#undef CLOG_VERBOSE
+#undef CVLOG
+#undef CLOG_IF
+#undef CLOG_VERBOSE_IF
+#undef CVLOG_IF
+#undef CLOG_EVERY_N
+#undef CVLOG_EVERY_N
+#undef CLOG_AFTER_N
+#undef CVLOG_AFTER_N
+#undef CLOG_N_TIMES
+#undef CVLOG_N_TIMES
+// Normal logs
+#define CLOG(LEVEL, ...)\
+C##LEVEL(el::base::Writer, el::base::DispatchAction::NormalLog, __VA_ARGS__)
+#define CVLOG(vlevel, ...) CVERBOSE(el::base::Writer, vlevel, el::base::DispatchAction::NormalLog, __VA_ARGS__)
+// Conditional logs
+#define CLOG_IF(condition, LEVEL, ...)\
+C##LEVEL##_IF(el::base::Writer, condition, el::base::DispatchAction::NormalLog, __VA_ARGS__)
+#define CVLOG_IF(condition, vlevel, ...)\
+CVERBOSE_IF(el::base::Writer, condition, vlevel, el::base::DispatchAction::NormalLog, __VA_ARGS__)
+// Hit counts based logs
+#define CLOG_EVERY_N(n, LEVEL, ...)\
+C##LEVEL##_EVERY_N(el::base::Writer, n, el::base::DispatchAction::NormalLog, __VA_ARGS__)
+#define CVLOG_EVERY_N(n, vlevel, ...)\
+CVERBOSE_EVERY_N(el::base::Writer, n, vlevel, el::base::DispatchAction::NormalLog, __VA_ARGS__)
+#define CLOG_AFTER_N(n, LEVEL, ...)\
+C##LEVEL##_AFTER_N(el::base::Writer, n, el::base::DispatchAction::NormalLog, __VA_ARGS__)
+#define CVLOG_AFTER_N(n, vlevel, ...)\
+CVERBOSE_AFTER_N(el::base::Writer, n, vlevel, el::base::DispatchAction::NormalLog, __VA_ARGS__)
+#define CLOG_N_TIMES(n, LEVEL, ...)\
+C##LEVEL##_N_TIMES(el::base::Writer, n, el::base::DispatchAction::NormalLog, __VA_ARGS__)
+#define CVLOG_N_TIMES(n, vlevel, ...)\
+CVERBOSE_N_TIMES(el::base::Writer, n, vlevel, el::base::DispatchAction::NormalLog, __VA_ARGS__)
+//
+// Default Loggers macro using CLOG(), CLOG_VERBOSE() and CVLOG() macros
+//
+// undef existing
+#undef LOG
+#undef VLOG
+#undef LOG_IF
+#undef VLOG_IF
+#undef LOG_EVERY_N
+#undef VLOG_EVERY_N
+#undef LOG_AFTER_N
+#undef VLOG_AFTER_N
+#undef LOG_N_TIMES
+#undef VLOG_N_TIMES
+#undef ELPP_CURR_FILE_LOGGER_ID
+#if defined(ELPP_DEFAULT_LOGGER)
+#  define ELPP_CURR_FILE_LOGGER_ID ELPP_DEFAULT_LOGGER
+#else
+#  define ELPP_CURR_FILE_LOGGER_ID el::base::consts::kDefaultLoggerId
+#endif
+#undef ELPP_TRACE
+#define ELPP_TRACE CLOG(TRACE, ELPP_CURR_FILE_LOGGER_ID)
+// Normal logs
+#define LOG(LEVEL) CLOG(LEVEL, ELPP_CURR_FILE_LOGGER_ID)
+#define VLOG(vlevel) CVLOG(vlevel, ELPP_CURR_FILE_LOGGER_ID)
+// Conditional logs
+#define LOG_IF(condition, LEVEL) CLOG_IF(condition, LEVEL, ELPP_CURR_FILE_LOGGER_ID)
+#define VLOG_IF(condition, vlevel) CVLOG_IF(condition, vlevel, ELPP_CURR_FILE_LOGGER_ID)
+// Hit counts based logs
+#define LOG_EVERY_N(n, LEVEL) CLOG_EVERY_N(n, LEVEL, ELPP_CURR_FILE_LOGGER_ID)
+#define VLOG_EVERY_N(n, vlevel) CVLOG_EVERY_N(n, vlevel, ELPP_CURR_FILE_LOGGER_ID)
+#define LOG_AFTER_N(n, LEVEL) CLOG_AFTER_N(n, LEVEL, ELPP_CURR_FILE_LOGGER_ID)
+#define VLOG_AFTER_N(n, vlevel) CVLOG_AFTER_N(n, vlevel, ELPP_CURR_FILE_LOGGER_ID)
+#define LOG_N_TIMES(n, LEVEL) CLOG_N_TIMES(n, LEVEL, ELPP_CURR_FILE_LOGGER_ID)
+#define VLOG_N_TIMES(n, vlevel) CVLOG_N_TIMES(n, vlevel, ELPP_CURR_FILE_LOGGER_ID)
+// Generic PLOG()
+#undef CPLOG
+#undef CPLOG_IF
+#undef PLOG
+#undef PLOG_IF
+#undef DCPLOG
+#undef DCPLOG_IF
+#undef DPLOG
+#undef DPLOG_IF
+#define CPLOG(LEVEL, ...)\
+C##LEVEL(el::base::PErrorWriter, el::base::DispatchAction::NormalLog, __VA_ARGS__)
+#define CPLOG_IF(condition, LEVEL, ...)\
+C##LEVEL##_IF(el::base::PErrorWriter, condition, el::base::DispatchAction::NormalLog, __VA_ARGS__)
+#define DCPLOG(LEVEL, ...)\
+if (ELPP_DEBUG_LOG) C##LEVEL(el::base::PErrorWriter, el::base::DispatchAction::NormalLog, __VA_ARGS__)
+#define DCPLOG_IF(condition, LEVEL, ...)\
+C##LEVEL##_IF(el::base::PErrorWriter, (ELPP_DEBUG_LOG) && (condition), el::base::DispatchAction::NormalLog, __VA_ARGS__)
+#define PLOG(LEVEL) CPLOG(LEVEL, ELPP_CURR_FILE_LOGGER_ID)
+#define PLOG_IF(condition, LEVEL) CPLOG_IF(condition, LEVEL, ELPP_CURR_FILE_LOGGER_ID)
+#define DPLOG(LEVEL) DCPLOG(LEVEL, ELPP_CURR_FILE_LOGGER_ID)
+#define DPLOG_IF(condition, LEVEL) DCPLOG_IF(condition, LEVEL, ELPP_CURR_FILE_LOGGER_ID)
+// Generic SYSLOG()
+#undef CSYSLOG
+#undef CSYSLOG_IF
+#undef CSYSLOG_EVERY_N
+#undef CSYSLOG_AFTER_N
+#undef CSYSLOG_N_TIMES
+#undef SYSLOG
+#undef SYSLOG_IF
+#undef SYSLOG_EVERY_N
+#undef SYSLOG_AFTER_N
+#undef SYSLOG_N_TIMES
+#undef DCSYSLOG
+#undef DCSYSLOG_IF
+#undef DCSYSLOG_EVERY_N
+#undef DCSYSLOG_AFTER_N
+#undef DCSYSLOG_N_TIMES
+#undef DSYSLOG
+#undef DSYSLOG_IF
+#undef DSYSLOG_EVERY_N
+#undef DSYSLOG_AFTER_N
+#undef DSYSLOG_N_TIMES
+#if defined(ELPP_SYSLOG)
+#  define CSYSLOG(LEVEL, ...)\
+C##LEVEL(el::base::Writer, el::base::DispatchAction::SysLog, __VA_ARGS__)
+#  define CSYSLOG_IF(condition, LEVEL, ...)\
+C##LEVEL##_IF(el::base::Writer, condition, el::base::DispatchAction::SysLog, __VA_ARGS__)
+#  define CSYSLOG_EVERY_N(n, LEVEL, ...) C##LEVEL##_EVERY_N(el::base::Writer, n, el::base::DispatchAction::SysLog, __VA_ARGS__)
+#  define CSYSLOG_AFTER_N(n, LEVEL, ...) C##LEVEL##_AFTER_N(el::base::Writer, n, el::base::DispatchAction::SysLog, __VA_ARGS__)
+#  define CSYSLOG_N_TIMES(n, LEVEL, ...) C##LEVEL##_N_TIMES(el::base::Writer, n, el::base::DispatchAction::SysLog, __VA_ARGS__)
+#  define SYSLOG(LEVEL) CSYSLOG(LEVEL, el::base::consts::kSysLogLoggerId)
+#  define SYSLOG_IF(condition, LEVEL) CSYSLOG_IF(condition, LEVEL, el::base::consts::kSysLogLoggerId)
+#  define SYSLOG_EVERY_N(n, LEVEL) CSYSLOG_EVERY_N(n, LEVEL, el::base::consts::kSysLogLoggerId)
+#  define SYSLOG_AFTER_N(n, LEVEL) CSYSLOG_AFTER_N(n, LEVEL, el::base::consts::kSysLogLoggerId)
+#  define SYSLOG_N_TIMES(n, LEVEL) CSYSLOG_N_TIMES(n, LEVEL, el::base::consts::kSysLogLoggerId)
+#  define DCSYSLOG(LEVEL, ...) if (ELPP_DEBUG_LOG) C##LEVEL(el::base::Writer, el::base::DispatchAction::SysLog, __VA_ARGS__)
+#  define DCSYSLOG_IF(condition, LEVEL, ...)\
+C##LEVEL##_IF(el::base::Writer, (ELPP_DEBUG_LOG) && (condition), el::base::DispatchAction::SysLog, __VA_ARGS__)
+#  define DCSYSLOG_EVERY_N(n, LEVEL, ...)\
+if (ELPP_DEBUG_LOG) C##LEVEL##_EVERY_N(el::base::Writer, n, el::base::DispatchAction::SysLog, __VA_ARGS__)
+#  define DCSYSLOG_AFTER_N(n, LEVEL, ...)\
+if (ELPP_DEBUG_LOG) C##LEVEL##_AFTER_N(el::base::Writer, n, el::base::DispatchAction::SysLog, __VA_ARGS__)
+#  define DCSYSLOG_N_TIMES(n, LEVEL, ...)\
+if (ELPP_DEBUG_LOG) C##LEVEL##_EVERY_N(el::base::Writer, n, el::base::DispatchAction::SysLog, __VA_ARGS__)
+#  define DSYSLOG(LEVEL) DCSYSLOG(LEVEL, el::base::consts::kSysLogLoggerId)
+#  define DSYSLOG_IF(condition, LEVEL) DCSYSLOG_IF(condition, LEVEL, el::base::consts::kSysLogLoggerId)
+#  define DSYSLOG_EVERY_N(n, LEVEL) DCSYSLOG_EVERY_N(n, LEVEL, el::base::consts::kSysLogLoggerId)
+#  define DSYSLOG_AFTER_N(n, LEVEL) DCSYSLOG_AFTER_N(n, LEVEL, el::base::consts::kSysLogLoggerId)
+#  define DSYSLOG_N_TIMES(n, LEVEL) DCSYSLOG_N_TIMES(n, LEVEL, el::base::consts::kSysLogLoggerId)
+#else
+#  define CSYSLOG(LEVEL, ...) el::base::NullWriter()
+#  define CSYSLOG_IF(condition, LEVEL, ...) el::base::NullWriter()
+#  define CSYSLOG_EVERY_N(n, LEVEL, ...) el::base::NullWriter()
+#  define CSYSLOG_AFTER_N(n, LEVEL, ...) el::base::NullWriter()
+#  define CSYSLOG_N_TIMES(n, LEVEL, ...) el::base::NullWriter()
+#  define SYSLOG(LEVEL) el::base::NullWriter()
+#  define SYSLOG_IF(condition, LEVEL) el::base::NullWriter()
+#  define SYSLOG_EVERY_N(n, LEVEL) el::base::NullWriter()
+#  define SYSLOG_AFTER_N(n, LEVEL) el::base::NullWriter()
+#  define SYSLOG_N_TIMES(n, LEVEL) el::base::NullWriter()
+#  define DCSYSLOG(LEVEL, ...) el::base::NullWriter()
+#  define DCSYSLOG_IF(condition, LEVEL, ...) el::base::NullWriter()
+#  define DCSYSLOG_EVERY_N(n, LEVEL, ...) el::base::NullWriter()
+#  define DCSYSLOG_AFTER_N(n, LEVEL, ...) el::base::NullWriter()
+#  define DCSYSLOG_N_TIMES(n, LEVEL, ...) el::base::NullWriter()
+#  define DSYSLOG(LEVEL) el::base::NullWriter()
+#  define DSYSLOG_IF(condition, LEVEL) el::base::NullWriter()
+#  define DSYSLOG_EVERY_N(n, LEVEL) el::base::NullWriter()
+#  define DSYSLOG_AFTER_N(n, LEVEL) el::base::NullWriter()
+#  define DSYSLOG_N_TIMES(n, LEVEL) el::base::NullWriter()
+#endif  // defined(ELPP_SYSLOG)
+//
+// Custom Debug Only Loggers - Requires (level, loggerId/s)
+//
+// undef existing
+#undef DCLOG
+#undef DCVLOG
+#undef DCLOG_IF
+#undef DCVLOG_IF
+#undef DCLOG_EVERY_N
+#undef DCVLOG_EVERY_N
+#undef DCLOG_AFTER_N
+#undef DCVLOG_AFTER_N
+#undef DCLOG_N_TIMES
+#undef DCVLOG_N_TIMES
+// Normal logs
+#define DCLOG(LEVEL, ...) if (ELPP_DEBUG_LOG) CLOG(LEVEL, __VA_ARGS__)
+#define DCLOG_VERBOSE(vlevel, ...) if (ELPP_DEBUG_LOG) CLOG_VERBOSE(vlevel, __VA_ARGS__)
+#define DCVLOG(vlevel, ...) if (ELPP_DEBUG_LOG) CVLOG(vlevel, __VA_ARGS__)
+// Conditional logs
+#define DCLOG_IF(condition, LEVEL, ...) if (ELPP_DEBUG_LOG) CLOG_IF(condition, LEVEL, __VA_ARGS__)
+#define DCVLOG_IF(condition, vlevel, ...) if (ELPP_DEBUG_LOG) CVLOG_IF(condition, vlevel, __VA_ARGS__)
+// Hit counts based logs
+#define DCLOG_EVERY_N(n, LEVEL, ...) if (ELPP_DEBUG_LOG) CLOG_EVERY_N(n, LEVEL, __VA_ARGS__)
+#define DCVLOG_EVERY_N(n, vlevel, ...) if (ELPP_DEBUG_LOG) CVLOG_EVERY_N(n, vlevel, __VA_ARGS__)
+#define DCLOG_AFTER_N(n, LEVEL, ...) if (ELPP_DEBUG_LOG) CLOG_AFTER_N(n, LEVEL, __VA_ARGS__)
+#define DCVLOG_AFTER_N(n, vlevel, ...) if (ELPP_DEBUG_LOG) CVLOG_AFTER_N(n, vlevel, __VA_ARGS__)
+#define DCLOG_N_TIMES(n, LEVEL, ...) if (ELPP_DEBUG_LOG) CLOG_N_TIMES(n, LEVEL, __VA_ARGS__)
+#define DCVLOG_N_TIMES(n, vlevel, ...) if (ELPP_DEBUG_LOG) CVLOG_N_TIMES(n, vlevel, __VA_ARGS__)
+//
+// Default Debug Only Loggers macro using CLOG(), CLOG_VERBOSE() and CVLOG() macros
+//
+#if !defined(ELPP_NO_DEBUG_MACROS)
+// undef existing
+#undef DLOG
+#undef DVLOG
+#undef DLOG_IF
+#undef DVLOG_IF
+#undef DLOG_EVERY_N
+#undef DVLOG_EVERY_N
+#undef DLOG_AFTER_N
+#undef DVLOG_AFTER_N
+#undef DLOG_N_TIMES
+#undef DVLOG_N_TIMES
+// Normal logs
+#define DLOG(LEVEL) DCLOG(LEVEL, ELPP_CURR_FILE_LOGGER_ID)
+#define DVLOG(vlevel) DCVLOG(vlevel, ELPP_CURR_FILE_LOGGER_ID)
+// Conditional logs
+#define DLOG_IF(condition, LEVEL) DCLOG_IF(condition, LEVEL, ELPP_CURR_FILE_LOGGER_ID)
+#define DVLOG_IF(condition, vlevel) DCVLOG_IF(condition, vlevel, ELPP_CURR_FILE_LOGGER_ID)
+// Hit counts based logs
+#define DLOG_EVERY_N(n, LEVEL) DCLOG_EVERY_N(n, LEVEL, ELPP_CURR_FILE_LOGGER_ID)
+#define DVLOG_EVERY_N(n, vlevel) DCVLOG_EVERY_N(n, vlevel, ELPP_CURR_FILE_LOGGER_ID)
+#define DLOG_AFTER_N(n, LEVEL) DCLOG_AFTER_N(n, LEVEL, ELPP_CURR_FILE_LOGGER_ID)
+#define DVLOG_AFTER_N(n, vlevel) DCVLOG_AFTER_N(n, vlevel, ELPP_CURR_FILE_LOGGER_ID)
+#define DLOG_N_TIMES(n, LEVEL) DCLOG_N_TIMES(n, LEVEL, ELPP_CURR_FILE_LOGGER_ID)
+#define DVLOG_N_TIMES(n, vlevel) DCVLOG_N_TIMES(n, vlevel, ELPP_CURR_FILE_LOGGER_ID)
+#endif // defined(ELPP_NO_DEBUG_MACROS)
+#if !defined(ELPP_NO_CHECK_MACROS)
+// Check macros
+#undef CCHECK
+#undef CPCHECK
+#undef CCHECK_EQ
+#undef CCHECK_NE
+#undef CCHECK_LT
+#undef CCHECK_GT
+#undef CCHECK_LE
+#undef CCHECK_GE
+#undef CCHECK_BOUNDS
+#undef CCHECK_NOTNULL
+#undef CCHECK_STRCASEEQ
+#undef CCHECK_STRCASENE
+#undef CHECK
+#undef PCHECK
+#undef CHECK_EQ
+#undef CHECK_NE
+#undef CHECK_LT
+#undef CHECK_GT
+#undef CHECK_LE
+#undef CHECK_GE
+#undef CHECK_BOUNDS
+#undef CHECK_NOTNULL
+#undef CHECK_STRCASEEQ
+#undef CHECK_STRCASENE
+#define CCHECK(condition, ...) CLOG_IF(!(condition), FATAL, __VA_ARGS__) << "Check failed: [" << #condition << "] "
+#define CPCHECK(condition, ...) CPLOG_IF(!(condition), FATAL, __VA_ARGS__) << "Check failed: [" << #condition << "] "
+#define CHECK(condition) CCHECK(condition, ELPP_CURR_FILE_LOGGER_ID)
+#define PCHECK(condition) CPCHECK(condition, ELPP_CURR_FILE_LOGGER_ID)
+#define CCHECK_EQ(a, b, ...) CCHECK(a == b, __VA_ARGS__)
+#define CCHECK_NE(a, b, ...) CCHECK(a != b, __VA_ARGS__)
+#define CCHECK_LT(a, b, ...) CCHECK(a < b, __VA_ARGS__)
+#define CCHECK_GT(a, b, ...) CCHECK(a > b, __VA_ARGS__)
+#define CCHECK_LE(a, b, ...) CCHECK(a <= b, __VA_ARGS__)
+#define CCHECK_GE(a, b, ...) CCHECK(a >= b, __VA_ARGS__)
+#define CCHECK_BOUNDS(val, min, max, ...) CCHECK(val >= min && val <= max, __VA_ARGS__)
+#define CHECK_EQ(a, b) CCHECK_EQ(a, b, ELPP_CURR_FILE_LOGGER_ID)
+#define CHECK_NE(a, b) CCHECK_NE(a, b, ELPP_CURR_FILE_LOGGER_ID)
+#define CHECK_LT(a, b) CCHECK_LT(a, b, ELPP_CURR_FILE_LOGGER_ID)
+#define CHECK_GT(a, b) CCHECK_GT(a, b, ELPP_CURR_FILE_LOGGER_ID)
+#define CHECK_LE(a, b) CCHECK_LE(a, b, ELPP_CURR_FILE_LOGGER_ID)
+#define CHECK_GE(a, b) CCHECK_GE(a, b, ELPP_CURR_FILE_LOGGER_ID)
+#define CHECK_BOUNDS(val, min, max) CCHECK_BOUNDS(val, min, max, ELPP_CURR_FILE_LOGGER_ID)
+#define CCHECK_NOTNULL(ptr, ...) CCHECK((ptr) != nullptr, __VA_ARGS__)
+#define CCHECK_STREQ(str1, str2, ...) CLOG_IF(!el::base::utils::Str::cStringEq(str1, str2), FATAL, __VA_ARGS__) \
+<< "Check failed: [" << #str1 << " == " << #str2 << "] "
+#define CCHECK_STRNE(str1, str2, ...) CLOG_IF(el::base::utils::Str::cStringEq(str1, str2), FATAL, __VA_ARGS__) \
+<< "Check failed: [" << #str1 << " != " << #str2 << "] "
+#define CCHECK_STRCASEEQ(str1, str2, ...) CLOG_IF(!el::base::utils::Str::cStringCaseEq(str1, str2), FATAL, __VA_ARGS__) \
+<< "Check failed: [" << #str1 << " == " << #str2 << "] "
+#define CCHECK_STRCASENE(str1, str2, ...) CLOG_IF(el::base::utils::Str::cStringCaseEq(str1, str2), FATAL, __VA_ARGS__) \
+<< "Check failed: [" << #str1 << " != " << #str2 << "] "
+#define CHECK_NOTNULL(ptr) CCHECK_NOTNULL((ptr), ELPP_CURR_FILE_LOGGER_ID)
+#define CHECK_STREQ(str1, str2) CCHECK_STREQ(str1, str2, ELPP_CURR_FILE_LOGGER_ID)
+#define CHECK_STRNE(str1, str2) CCHECK_STRNE(str1, str2, ELPP_CURR_FILE_LOGGER_ID)
+#define CHECK_STRCASEEQ(str1, str2) CCHECK_STRCASEEQ(str1, str2, ELPP_CURR_FILE_LOGGER_ID)
+#define CHECK_STRCASENE(str1, str2) CCHECK_STRCASENE(str1, str2, ELPP_CURR_FILE_LOGGER_ID)
+#undef DCCHECK
+#undef DCCHECK_EQ
+#undef DCCHECK_NE
+#undef DCCHECK_LT
+#undef DCCHECK_GT
+#undef DCCHECK_LE
+#undef DCCHECK_GE
+#undef DCCHECK_BOUNDS
+#undef DCCHECK_NOTNULL
+#undef DCCHECK_STRCASEEQ
+#undef DCCHECK_STRCASENE
+#undef DCPCHECK
+#undef DCHECK
+#undef DCHECK_EQ
+#undef DCHECK_NE
+#undef DCHECK_LT
+#undef DCHECK_GT
+#undef DCHECK_LE
+#undef DCHECK_GE
+#undef DCHECK_BOUNDS_
+#undef DCHECK_NOTNULL
+#undef DCHECK_STRCASEEQ
+#undef DCHECK_STRCASENE
+#undef DPCHECK
+#define DCCHECK(condition, ...) if (ELPP_DEBUG_LOG) CCHECK(condition, __VA_ARGS__)
+#define DCCHECK_EQ(a, b, ...) if (ELPP_DEBUG_LOG) CCHECK_EQ(a, b, __VA_ARGS__)
+#define DCCHECK_NE(a, b, ...) if (ELPP_DEBUG_LOG) CCHECK_NE(a, b, __VA_ARGS__)
+#define DCCHECK_LT(a, b, ...) if (ELPP_DEBUG_LOG) CCHECK_LT(a, b, __VA_ARGS__)
+#define DCCHECK_GT(a, b, ...) if (ELPP_DEBUG_LOG) CCHECK_GT(a, b, __VA_ARGS__)
+#define DCCHECK_LE(a, b, ...) if (ELPP_DEBUG_LOG) CCHECK_LE(a, b, __VA_ARGS__)
+#define DCCHECK_GE(a, b, ...) if (ELPP_DEBUG_LOG) CCHECK_GE(a, b, __VA_ARGS__)
+#define DCCHECK_BOUNDS(val, min, max, ...) if (ELPP_DEBUG_LOG) CCHECK_BOUNDS(val, min, max, __VA_ARGS__)
+#define DCCHECK_NOTNULL(ptr, ...) if (ELPP_DEBUG_LOG) CCHECK_NOTNULL((ptr), __VA_ARGS__)
+#define DCCHECK_STREQ(str1, str2, ...) if (ELPP_DEBUG_LOG) CCHECK_STREQ(str1, str2, __VA_ARGS__)
+#define DCCHECK_STRNE(str1, str2, ...) if (ELPP_DEBUG_LOG) CCHECK_STRNE(str1, str2, __VA_ARGS__)
+#define DCCHECK_STRCASEEQ(str1, str2, ...) if (ELPP_DEBUG_LOG) CCHECK_STRCASEEQ(str1, str2, __VA_ARGS__)
+#define DCCHECK_STRCASENE(str1, str2, ...) if (ELPP_DEBUG_LOG) CCHECK_STRCASENE(str1, str2, __VA_ARGS__)
+#define DCPCHECK(condition, ...) if (ELPP_DEBUG_LOG) CPCHECK(condition, __VA_ARGS__)
+#define DCHECK(condition) DCCHECK(condition, ELPP_CURR_FILE_LOGGER_ID)
+#define DCHECK_EQ(a, b) DCCHECK_EQ(a, b, ELPP_CURR_FILE_LOGGER_ID)
+#define DCHECK_NE(a, b) DCCHECK_NE(a, b, ELPP_CURR_FILE_LOGGER_ID)
+#define DCHECK_LT(a, b) DCCHECK_LT(a, b, ELPP_CURR_FILE_LOGGER_ID)
+#define DCHECK_GT(a, b) DCCHECK_GT(a, b, ELPP_CURR_FILE_LOGGER_ID)
+#define DCHECK_LE(a, b) DCCHECK_LE(a, b, ELPP_CURR_FILE_LOGGER_ID)
+#define DCHECK_GE(a, b) DCCHECK_GE(a, b, ELPP_CURR_FILE_LOGGER_ID)
+#define DCHECK_BOUNDS(val, min, max) DCCHECK_BOUNDS(val, min, max, ELPP_CURR_FILE_LOGGER_ID)
+#define DCHECK_NOTNULL(ptr) DCCHECK_NOTNULL((ptr), ELPP_CURR_FILE_LOGGER_ID)
+#define DCHECK_STREQ(str1, str2) DCCHECK_STREQ(str1, str2, ELPP_CURR_FILE_LOGGER_ID)
+#define DCHECK_STRNE(str1, str2) DCCHECK_STRNE(str1, str2, ELPP_CURR_FILE_LOGGER_ID)
+#define DCHECK_STRCASEEQ(str1, str2) DCCHECK_STRCASEEQ(str1, str2, ELPP_CURR_FILE_LOGGER_ID)
+#define DCHECK_STRCASENE(str1, str2) DCCHECK_STRCASENE(str1, str2, ELPP_CURR_FILE_LOGGER_ID)
+#define DPCHECK(condition) DCPCHECK(condition, ELPP_CURR_FILE_LOGGER_ID)
+#endif // defined(ELPP_NO_CHECK_MACROS)
+#if defined(ELPP_DISABLE_DEFAULT_CRASH_HANDLING)
+#  define ELPP_USE_DEF_CRASH_HANDLER false
+#else
+#  define ELPP_USE_DEF_CRASH_HANDLER true
+#endif  // defined(ELPP_DISABLE_DEFAULT_CRASH_HANDLING)
+#define ELPP_CRASH_HANDLER_INIT
+#define ELPP_INIT_EASYLOGGINGPP(val) \
+namespace el { \
+namespace base { \
+el::base::type::StoragePointer elStorage(val); \
+} \
+el::base::debug::CrashHandler elCrashHandler(ELPP_USE_DEF_CRASH_HANDLER); \
+}
+
+#if ELPP_ASYNC_LOGGING
+#  define INITIALIZE_EASYLOGGINGPP ELPP_INIT_EASYLOGGINGPP(new el::base::Storage(el::LogBuilderPtr(new el::base::DefaultLogBuilder()),\
+new el::base::AsyncDispatchWorker()))
+#else
+#  define INITIALIZE_EASYLOGGINGPP ELPP_INIT_EASYLOGGINGPP(new el::base::Storage(el::LogBuilderPtr(new el::base::DefaultLogBuilder())))
+#endif  // ELPP_ASYNC_LOGGING
+#define INITIALIZE_NULL_EASYLOGGINGPP \
+namespace el {\
+namespace base {\
+el::base::type::StoragePointer elStorage;\
+}\
+el::base::debug::CrashHandler elCrashHandler(ELPP_USE_DEF_CRASH_HANDLER);\
+}
+#define SHARE_EASYLOGGINGPP(initializedStorage)\
+namespace el {\
+namespace base {\
+el::base::type::StoragePointer elStorage(initializedStorage);\
+}\
+el::base::debug::CrashHandler elCrashHandler(ELPP_USE_DEF_CRASH_HANDLER);\
+}
+
+#if defined(ELPP_UNICODE)
+#  define START_EASYLOGGINGPP(argc, argv) el::Helpers::setArgs(argc, argv); std::locale::global(std::locale(""))
+#else
+#  define START_EASYLOGGINGPP(argc, argv) el::Helpers::setArgs(argc, argv)
+#endif  // defined(ELPP_UNICODE)
+#endif // EASYLOGGINGPP_H
diff --git a/core/src/wrapper/ConfAdapter.cpp b/core/src/wrapper/ConfAdapter.cpp
new file mode 100644
index 0000000000..2dcf6bab7e
--- /dev/null
+++ b/core/src/wrapper/ConfAdapter.cpp
@@ -0,0 +1,163 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "wrapper/ConfAdapter.h"
+#include "knowhere/index/vector_index/helpers/IndexParameter.h"
+#include "utils/Log.h"
+
+#include <cmath>
+#include <memory>
+
+// TODO(lxj): add conf checker
+
+namespace milvus {
+namespace engine {
+
+#if CUDA_VERSION > 9000
+#define GPU_MAX_NRPOBE 2048
+#else
+#define GPU_MAX_NRPOBE 1024
+#endif
+
+void
+ConfAdapter::MatchBase(knowhere::Config conf) {
+    if (conf->metric_type == knowhere::DEFAULT_TYPE)
+        conf->metric_type = knowhere::METRICTYPE::L2;
+    if (conf->gpu_id == knowhere::INVALID_VALUE)
+        conf->gpu_id = 0;
+}
+
+knowhere::Config
+ConfAdapter::Match(const TempMetaConf& metaconf) {
+    auto conf = std::make_shared<knowhere::Cfg>();
+    conf->d = metaconf.dim;
+    conf->metric_type = metaconf.metric_type;
+    conf->gpu_id = conf->gpu_id;
+    MatchBase(conf);
+    return conf;
+}
+
+knowhere::Config
+ConfAdapter::MatchSearch(const TempMetaConf& metaconf, const IndexType& type) {
+    auto conf = std::make_shared<knowhere::Cfg>();
+    conf->k = metaconf.k;
+    return conf;
+}
+
+knowhere::Config
+IVFConfAdapter::Match(const TempMetaConf& metaconf) {
+    auto conf = std::make_shared<knowhere::IVFCfg>();
+    conf->nlist = MatchNlist(metaconf.size, metaconf.nlist);
+    conf->d = metaconf.dim;
+    conf->metric_type = metaconf.metric_type;
+    conf->gpu_id = conf->gpu_id;
+    MatchBase(conf);
+    return conf;
+}
+
+static constexpr float TYPICAL_COUNT = 1000000.0;
+
+int64_t
+IVFConfAdapter::MatchNlist(const int64_t& size, const int64_t& nlist) {
+    if (size <= TYPICAL_COUNT / 16384 + 1) {
+        // handle less row count, avoid nlist set to 0
+        return 1;
+    } else if (int(size / TYPICAL_COUNT) * nlist == 0) {
+        // calculate a proper nlist if nlist not specified or size less than TYPICAL_COUNT
+        return int(size / TYPICAL_COUNT * 16384);
+    }
+    return nlist;
+}
+
+knowhere::Config
+IVFConfAdapter::MatchSearch(const TempMetaConf& metaconf, const IndexType& type) {
+    auto conf = std::make_shared<knowhere::IVFCfg>();
+    conf->k = metaconf.k;
+    conf->nprobe = metaconf.nprobe;
+
+    switch (type) {
+        case IndexType::FAISS_IVFFLAT_GPU:
+        case IndexType::FAISS_IVFSQ8_GPU:
+        case IndexType::FAISS_IVFPQ_GPU:
+            if (conf->nprobe > GPU_MAX_NRPOBE) {
+                WRAPPER_LOG_WARNING << "When search with GPU, nprobe shoud be no more than " << GPU_MAX_NRPOBE
+                                    << ", but you passed " << conf->nprobe << ". Search with " << GPU_MAX_NRPOBE
+                                    << " instead";
+                conf->nprobe = GPU_MAX_NRPOBE;
+            }
+    }
+    return conf;
+}
+
+knowhere::Config
+IVFSQConfAdapter::Match(const TempMetaConf& metaconf) {
+    auto conf = std::make_shared<knowhere::IVFSQCfg>();
+    conf->nlist = MatchNlist(metaconf.size, metaconf.nlist);
+    conf->d = metaconf.dim;
+    conf->metric_type = metaconf.metric_type;
+    conf->gpu_id = conf->gpu_id;
+    conf->nbits = 8;
+    MatchBase(conf);
+    return conf;
+}
+
+knowhere::Config
+IVFPQConfAdapter::Match(const TempMetaConf& metaconf) {
+    auto conf = std::make_shared<knowhere::IVFPQCfg>();
+    conf->nlist = MatchNlist(metaconf.size, metaconf.nlist);
+    conf->d = metaconf.dim;
+    conf->metric_type = metaconf.metric_type;
+    conf->gpu_id = conf->gpu_id;
+    conf->nbits = 8;
+    conf->m = 8;
+    MatchBase(conf);
+    return conf;
+}
+
+knowhere::Config
+NSGConfAdapter::Match(const TempMetaConf& metaconf) {
+    auto conf = std::make_shared<knowhere::NSGCfg>();
+    conf->nlist = MatchNlist(metaconf.size, metaconf.nlist);
+    conf->d = metaconf.dim;
+    conf->metric_type = metaconf.metric_type;
+    conf->gpu_id = conf->gpu_id;
+
+    auto scale_factor = round(metaconf.dim / 128.0);
+    scale_factor = scale_factor >= 4 ? 4 : scale_factor;
+    conf->nprobe = 6 + 10 * scale_factor;
+    conf->knng = 100 + 100 * scale_factor;
+    conf->search_length = 40 + 5 * scale_factor;
+    conf->out_degree = 50 + 5 * scale_factor;
+    conf->candidate_pool_size = 200 + 100 * scale_factor;
+    MatchBase(conf);
+
+    //    WRAPPER_LOG_DEBUG << "nlist: " << conf->nlist
+    //    << ", gpu_id: " << conf->gpu_id << ", d: " << conf->d
+    //    << ", nprobe: " << conf->nprobe << ", knng: " << conf->knng;
+    return conf;
+}
+
+knowhere::Config
+NSGConfAdapter::MatchSearch(const TempMetaConf& metaconf, const IndexType& type) {
+    auto conf = std::make_shared<knowhere::NSGCfg>();
+    conf->k = metaconf.k;
+    conf->search_length = metaconf.search_length;
+    return conf;
+}
+
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/wrapper/ConfAdapter.h b/core/src/wrapper/ConfAdapter.h
new file mode 100644
index 0000000000..4c8e528a2d
--- /dev/null
+++ b/core/src/wrapper/ConfAdapter.h
@@ -0,0 +1,94 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "VecIndex.h"
+#include "knowhere/common/Config.h"
+
+#include <memory>
+
+namespace milvus {
+namespace engine {
+
+// TODO(linxj): remove later, replace with real metaconf
+constexpr int64_t TEMPMETA_DEFAULT_VALUE = -1;
+struct TempMetaConf {
+    int64_t size = TEMPMETA_DEFAULT_VALUE;
+    int64_t nlist = TEMPMETA_DEFAULT_VALUE;
+    int64_t dim = TEMPMETA_DEFAULT_VALUE;
+    int64_t gpu_id = TEMPMETA_DEFAULT_VALUE;
+    int64_t k = TEMPMETA_DEFAULT_VALUE;
+    int64_t nprobe = TEMPMETA_DEFAULT_VALUE;
+    int64_t search_length = TEMPMETA_DEFAULT_VALUE;
+    knowhere::METRICTYPE metric_type = knowhere::DEFAULT_TYPE;
+};
+
+class ConfAdapter {
+ public:
+    virtual knowhere::Config
+    Match(const TempMetaConf& metaconf);
+
+    virtual knowhere::Config
+    MatchSearch(const TempMetaConf& metaconf, const IndexType& type);
+
+    //    virtual void
+    //    Dump(){}
+
+ protected:
+    static void
+    MatchBase(knowhere::Config conf);
+};
+
+using ConfAdapterPtr = std::shared_ptr<ConfAdapter>;
+
+class IVFConfAdapter : public ConfAdapter {
+ public:
+    knowhere::Config
+    Match(const TempMetaConf& metaconf) override;
+
+    knowhere::Config
+    MatchSearch(const TempMetaConf& metaconf, const IndexType& type) override;
+
+ protected:
+    static int64_t
+    MatchNlist(const int64_t& size, const int64_t& nlist);
+};
+
+class IVFSQConfAdapter : public IVFConfAdapter {
+ public:
+    knowhere::Config
+    Match(const TempMetaConf& metaconf) override;
+};
+
+class IVFPQConfAdapter : public IVFConfAdapter {
+ public:
+    knowhere::Config
+    Match(const TempMetaConf& metaconf) override;
+};
+
+class NSGConfAdapter : public IVFConfAdapter {
+ public:
+    knowhere::Config
+    Match(const TempMetaConf& metaconf) override;
+
+    knowhere::Config
+    MatchSearch(const TempMetaConf& metaconf, const IndexType& type) final;
+};
+
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/wrapper/ConfAdapterMgr.cpp b/core/src/wrapper/ConfAdapterMgr.cpp
new file mode 100644
index 0000000000..b329588cf2
--- /dev/null
+++ b/core/src/wrapper/ConfAdapterMgr.cpp
@@ -0,0 +1,61 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "wrapper/ConfAdapterMgr.h"
+#include "utils/Exception.h"
+
+namespace milvus {
+namespace engine {
+
+ConfAdapterPtr
+AdapterMgr::GetAdapter(const IndexType& indexType) {
+    if (!init_)
+        RegisterAdapter();
+
+    auto it = table_.find(indexType);
+    if (it != table_.end()) {
+        return it->second();
+    } else {
+        throw Exception(KNOWHERE_INVALID_ARGUMENT, "Can not find this type of confadapter");
+    }
+}
+
+#define REGISTER_CONF_ADAPTER(T, KEY, NAME) static AdapterMgr::register_t<T> reg_##NAME##_(KEY)
+
+void
+AdapterMgr::RegisterAdapter() {
+    init_ = true;
+
+    REGISTER_CONF_ADAPTER(ConfAdapter, IndexType::FAISS_IDMAP, idmap);
+
+    REGISTER_CONF_ADAPTER(IVFConfAdapter, IndexType::FAISS_IVFFLAT_CPU, ivf_cpu);
+    REGISTER_CONF_ADAPTER(IVFConfAdapter, IndexType::FAISS_IVFFLAT_GPU, ivf_gpu);
+    REGISTER_CONF_ADAPTER(IVFConfAdapter, IndexType::FAISS_IVFFLAT_MIX, ivf_mix);
+
+    REGISTER_CONF_ADAPTER(IVFSQConfAdapter, IndexType::FAISS_IVFSQ8_CPU, ivfsq8_cpu);
+    REGISTER_CONF_ADAPTER(IVFSQConfAdapter, IndexType::FAISS_IVFSQ8_GPU, ivfsq8_gpu);
+    REGISTER_CONF_ADAPTER(IVFSQConfAdapter, IndexType::FAISS_IVFSQ8_MIX, ivfsq8_mix);
+    REGISTER_CONF_ADAPTER(IVFSQConfAdapter, IndexType::FAISS_IVFSQ8_HYBRID, ivfsq8_h);
+
+    REGISTER_CONF_ADAPTER(IVFPQConfAdapter, IndexType::FAISS_IVFPQ_CPU, ivfpq_cpu);
+    REGISTER_CONF_ADAPTER(IVFPQConfAdapter, IndexType::FAISS_IVFPQ_GPU, ivfpq_gpu);
+
+    REGISTER_CONF_ADAPTER(NSGConfAdapter, IndexType::NSG_MIX, nsg_mix);
+}
+
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/wrapper/ConfAdapterMgr.h b/core/src/wrapper/ConfAdapterMgr.h
new file mode 100644
index 0000000000..8d5fa22877
--- /dev/null
+++ b/core/src/wrapper/ConfAdapterMgr.h
@@ -0,0 +1,57 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "ConfAdapter.h"
+#include "VecIndex.h"
+
+#include <functional>
+#include <map>
+#include <memory>
+
+namespace milvus {
+namespace engine {
+
+class AdapterMgr {
+ public:
+    template <typename T>
+    struct register_t {
+        explicit register_t(const IndexType& key) {
+            AdapterMgr::GetInstance().table_.emplace(key, [] { return std::make_shared<T>(); });
+        }
+    };
+
+    static AdapterMgr&
+    GetInstance() {
+        static AdapterMgr instance;
+        return instance;
+    }
+
+    ConfAdapterPtr
+    GetAdapter(const IndexType& indexType);
+
+    void
+    RegisterAdapter();
+
+ protected:
+    bool init_ = false;
+    std::map<IndexType, std::function<ConfAdapterPtr()> > table_;
+};
+
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/wrapper/DataTransfer.cpp b/core/src/wrapper/DataTransfer.cpp
new file mode 100644
index 0000000000..5eb83290d1
--- /dev/null
+++ b/core/src/wrapper/DataTransfer.cpp
@@ -0,0 +1,58 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "wrapper/DataTransfer.h"
+
+#include <memory>
+#include <utility>
+#include <vector>
+
+namespace milvus {
+namespace engine {
+
+knowhere::DatasetPtr
+GenDatasetWithIds(const int64_t& nb, const int64_t& dim, const float* xb, const int64_t* ids) {
+    std::vector<int64_t> shape{nb, dim};
+    auto tensor = knowhere::ConstructFloatTensor((uint8_t*)xb, nb * dim * sizeof(float), shape);
+    std::vector<knowhere::TensorPtr> tensors{tensor};
+    std::vector<knowhere::FieldPtr> tensor_fields{knowhere::ConstructFloatField("data")};
+    auto tensor_schema = std::make_shared<knowhere::Schema>(tensor_fields);
+
+    auto id_array = knowhere::ConstructInt64Array((uint8_t*)ids, nb * sizeof(int64_t));
+    std::vector<knowhere::ArrayPtr> arrays{id_array};
+    std::vector<knowhere::FieldPtr> array_fields{knowhere::ConstructInt64Field("id")};
+    auto array_schema = std::make_shared<knowhere::Schema>(tensor_fields);
+
+    auto dataset =
+        std::make_shared<knowhere::Dataset>(std::move(arrays), array_schema, std::move(tensors), tensor_schema);
+    return dataset;
+}
+
+knowhere::DatasetPtr
+GenDataset(const int64_t& nb, const int64_t& dim, const float* xb) {
+    std::vector<int64_t> shape{nb, dim};
+    auto tensor = knowhere::ConstructFloatTensor((uint8_t*)xb, nb * dim * sizeof(float), shape);
+    std::vector<knowhere::TensorPtr> tensors{tensor};
+    std::vector<knowhere::FieldPtr> tensor_fields{knowhere::ConstructFloatField("data")};
+    auto tensor_schema = std::make_shared<knowhere::Schema>(tensor_fields);
+
+    auto dataset = std::make_shared<knowhere::Dataset>(std::move(tensors), tensor_schema);
+    return dataset;
+}
+
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/wrapper/DataTransfer.h b/core/src/wrapper/DataTransfer.h
new file mode 100644
index 0000000000..e945eaa6db
--- /dev/null
+++ b/core/src/wrapper/DataTransfer.h
@@ -0,0 +1,32 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "knowhere/adapter/Structure.h"
+
+namespace milvus {
+namespace engine {
+
+extern knowhere::DatasetPtr
+GenDatasetWithIds(const int64_t& nb, const int64_t& dim, const float* xb, const int64_t* ids);
+
+extern knowhere::DatasetPtr
+GenDataset(const int64_t& nb, const int64_t& dim, const float* xb);
+
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/wrapper/KnowhereResource.cpp b/core/src/wrapper/KnowhereResource.cpp
new file mode 100644
index 0000000000..650ae727c1
--- /dev/null
+++ b/core/src/wrapper/KnowhereResource.cpp
@@ -0,0 +1,86 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "wrapper/KnowhereResource.h"
+#include "knowhere/index/vector_index/helpers/FaissGpuResourceMgr.h"
+#include "server/Config.h"
+
+#include <map>
+#include <set>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace milvus {
+namespace engine {
+
+constexpr int64_t M_BYTE = 1024 * 1024;
+
+Status
+KnowhereResource::Initialize() {
+    struct GpuResourceSetting {
+        int64_t pinned_memory = 300 * M_BYTE;
+        int64_t temp_memory = 300 * M_BYTE;
+        int64_t resource_num = 2;
+    };
+    using GpuResourcesArray = std::map<int64_t, GpuResourceSetting>;
+    GpuResourcesArray gpu_resources;
+    Status s;
+
+    // get build index gpu resource
+    server::Config& config = server::Config::GetInstance();
+
+    int32_t build_index_gpu;
+    s = config.GetResourceConfigIndexBuildDevice(build_index_gpu);
+    if (!s.ok())
+        return s;
+
+    gpu_resources.insert(std::make_pair(build_index_gpu, GpuResourceSetting()));
+
+    // get search gpu resource
+    std::vector<std::string> pool;
+    s = config.GetResourceConfigSearchResources(pool);
+    if (!s.ok())
+        return s;
+
+    std::set<uint64_t> gpu_ids;
+    for (auto& resource : pool) {
+        if (resource.length() < 4 || resource.substr(0, 3) != "gpu") {
+            // invalid
+            continue;
+        }
+        auto gpu_id = std::stoi(resource.substr(3));
+        gpu_resources.insert(std::make_pair(gpu_id, GpuResourceSetting()));
+    }
+
+    // init gpu resources
+    for (auto iter = gpu_resources.begin(); iter != gpu_resources.end(); ++iter) {
+        knowhere::FaissGpuResourceMgr::GetInstance().InitDevice(iter->first, iter->second.pinned_memory,
+                                                                iter->second.temp_memory, iter->second.resource_num);
+    }
+
+    return Status::OK();
+}
+
+Status
+KnowhereResource::Finalize() {
+    knowhere::FaissGpuResourceMgr::GetInstance().Free();  // free gpu resource.
+    return Status::OK();
+}
+
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/wrapper/KnowhereResource.h b/core/src/wrapper/KnowhereResource.h
new file mode 100644
index 0000000000..dff8b32c0b
--- /dev/null
+++ b/core/src/wrapper/KnowhereResource.h
@@ -0,0 +1,35 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include "utils/Status.h"
+
+namespace milvus {
+namespace engine {
+
+class KnowhereResource {
+ public:
+    static Status
+    Initialize();
+
+    static Status
+    Finalize();
+};
+
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/wrapper/VecImpl.cpp b/core/src/wrapper/VecImpl.cpp
new file mode 100644
index 0000000000..c97900f839
--- /dev/null
+++ b/core/src/wrapper/VecImpl.cpp
@@ -0,0 +1,355 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "wrapper/VecImpl.h"
+#include "DataTransfer.h"
+#include "knowhere/common/Exception.h"
+#include "knowhere/index/vector_index/IndexGPUIVF.h"
+#include "knowhere/index/vector_index/IndexIDMAP.h"
+#include "knowhere/index/vector_index/IndexIVFSQHybrid.h"
+#include "knowhere/index/vector_index/helpers/Cloner.h"
+#include "utils/Log.h"
+
+/*
+ * no parameter check in this layer.
+ * only responible for index combination
+ */
+
+namespace milvus {
+namespace engine {
+
+Status
+VecIndexImpl::BuildAll(const int64_t& nb, const float* xb, const int64_t* ids, const Config& cfg, const int64_t& nt,
+                       const float* xt) {
+    try {
+        dim = cfg->d;
+        auto dataset = GenDatasetWithIds(nb, dim, xb, ids);
+
+        auto preprocessor = index_->BuildPreprocessor(dataset, cfg);
+        index_->set_preprocessor(preprocessor);
+        auto model = index_->Train(dataset, cfg);
+        index_->set_index_model(model);
+        index_->Add(dataset, cfg);
+    } catch (knowhere::KnowhereException& e) {
+        WRAPPER_LOG_ERROR << e.what();
+        return Status(KNOWHERE_UNEXPECTED_ERROR, e.what());
+    } catch (std::exception& e) {
+        WRAPPER_LOG_ERROR << e.what();
+        return Status(KNOWHERE_ERROR, e.what());
+    }
+    return Status::OK();
+}
+
+Status
+VecIndexImpl::Add(const int64_t& nb, const float* xb, const int64_t* ids, const Config& cfg) {
+    try {
+        auto dataset = GenDatasetWithIds(nb, dim, xb, ids);
+
+        index_->Add(dataset, cfg);
+    } catch (knowhere::KnowhereException& e) {
+        WRAPPER_LOG_ERROR << e.what();
+        return Status(KNOWHERE_UNEXPECTED_ERROR, e.what());
+    } catch (std::exception& e) {
+        WRAPPER_LOG_ERROR << e.what();
+        return Status(KNOWHERE_ERROR, e.what());
+    }
+    return Status::OK();
+}
+
+Status
+VecIndexImpl::Search(const int64_t& nq, const float* xq, float* dist, int64_t* ids, const Config& cfg) {
+    try {
+        auto k = cfg->k;
+        auto dataset = GenDataset(nq, dim, xq);
+
+        Config search_cfg = cfg;
+
+        auto res = index_->Search(dataset, search_cfg);
+        auto ids_array = res->array()[0];
+        auto dis_array = res->array()[1];
+
+        //{
+        //    auto& ids = ids_array;
+        //    auto& dists = dis_array;
+        //    std::stringstream ss_id;
+        //    std::stringstream ss_dist;
+        //    for (auto i = 0; i < 10; i++) {
+        //        for (auto j = 0; j < k; ++j) {
+        //            ss_id << *(ids->data()->GetValues<int64_t>(1, i * k + j)) << " ";
+        //            ss_dist << *(dists->data()->GetValues<float>(1, i * k + j)) << " ";
+        //        }
+        //        ss_id << std::endl;
+        //        ss_dist << std::endl;
+        //    }
+        //    std::cout << "id\n" << ss_id.str() << std::endl;
+        //    std::cout << "dist\n" << ss_dist.str() << std::endl;
+        //}
+
+        auto p_ids = ids_array->data()->GetValues<int64_t>(1, 0);
+        auto p_dist = dis_array->data()->GetValues<float>(1, 0);
+
+        // TODO(linxj): avoid copy here.
+        memcpy(ids, p_ids, sizeof(int64_t) * nq * k);
+        memcpy(dist, p_dist, sizeof(float) * nq * k);
+    } catch (knowhere::KnowhereException& e) {
+        WRAPPER_LOG_ERROR << e.what();
+        return Status(KNOWHERE_UNEXPECTED_ERROR, e.what());
+    } catch (std::exception& e) {
+        WRAPPER_LOG_ERROR << e.what();
+        return Status(KNOWHERE_ERROR, e.what());
+    }
+    return Status::OK();
+}
+
+knowhere::BinarySet
+VecIndexImpl::Serialize() {
+    type = ConvertToCpuIndexType(type);
+    return index_->Serialize();
+}
+
+Status
+VecIndexImpl::Load(const knowhere::BinarySet& index_binary) {
+    index_->Load(index_binary);
+    dim = Dimension();
+    return Status::OK();
+}
+
+int64_t
+VecIndexImpl::Dimension() {
+    return index_->Dimension();
+}
+
+int64_t
+VecIndexImpl::Count() {
+    return index_->Count();
+}
+
+IndexType
+VecIndexImpl::GetType() {
+    return type;
+}
+
+VecIndexPtr
+VecIndexImpl::CopyToGpu(const int64_t& device_id, const Config& cfg) {
+    // TODO(linxj): exception handle
+    auto gpu_index = knowhere::cloner::CopyCpuToGpu(index_, device_id, cfg);
+    auto new_index = std::make_shared<VecIndexImpl>(gpu_index, ConvertToGpuIndexType(type));
+    new_index->dim = dim;
+    return new_index;
+}
+
+VecIndexPtr
+VecIndexImpl::CopyToCpu(const Config& cfg) {
+    // TODO(linxj): exception handle
+    auto cpu_index = knowhere::cloner::CopyGpuToCpu(index_, cfg);
+    auto new_index = std::make_shared<VecIndexImpl>(cpu_index, ConvertToCpuIndexType(type));
+    new_index->dim = dim;
+    return new_index;
+}
+
+VecIndexPtr
+VecIndexImpl::Clone() {
+    // TODO(linxj): exception handle
+    auto clone_index = std::make_shared<VecIndexImpl>(index_->Clone(), type);
+    clone_index->dim = dim;
+    return clone_index;
+}
+
+int64_t
+VecIndexImpl::GetDeviceId() {
+    if (auto device_idx = std::dynamic_pointer_cast<knowhere::GPUIndex>(index_)) {
+        return device_idx->GetGpuDevice();
+    }
+    // else
+    return -1;  // -1 == cpu
+}
+
+float*
+BFIndex::GetRawVectors() {
+    auto raw_index = std::dynamic_pointer_cast<knowhere::IDMAP>(index_);
+    if (raw_index) {
+        return raw_index->GetRawVectors();
+    }
+    return nullptr;
+}
+
+int64_t*
+BFIndex::GetRawIds() {
+    return std::static_pointer_cast<knowhere::IDMAP>(index_)->GetRawIds();
+}
+
+ErrorCode
+BFIndex::Build(const Config& cfg) {
+    try {
+        dim = cfg->d;
+        std::static_pointer_cast<knowhere::IDMAP>(index_)->Train(cfg);
+    } catch (knowhere::KnowhereException& e) {
+        WRAPPER_LOG_ERROR << e.what();
+        return KNOWHERE_UNEXPECTED_ERROR;
+    } catch (std::exception& e) {
+        WRAPPER_LOG_ERROR << e.what();
+        return KNOWHERE_ERROR;
+    }
+    return KNOWHERE_SUCCESS;
+}
+
+Status
+BFIndex::BuildAll(const int64_t& nb, const float* xb, const int64_t* ids, const Config& cfg, const int64_t& nt,
+                  const float* xt) {
+    try {
+        dim = cfg->d;
+        auto dataset = GenDatasetWithIds(nb, dim, xb, ids);
+
+        std::static_pointer_cast<knowhere::IDMAP>(index_)->Train(cfg);
+        index_->Add(dataset, cfg);
+    } catch (knowhere::KnowhereException& e) {
+        WRAPPER_LOG_ERROR << e.what();
+        return Status(KNOWHERE_UNEXPECTED_ERROR, e.what());
+    } catch (std::exception& e) {
+        WRAPPER_LOG_ERROR << e.what();
+        return Status(KNOWHERE_ERROR, e.what());
+    }
+    return Status::OK();
+}
+
+// TODO(linxj): add lock here.
+Status
+IVFMixIndex::BuildAll(const int64_t& nb, const float* xb, const int64_t* ids, const Config& cfg, const int64_t& nt,
+                      const float* xt) {
+    try {
+        dim = cfg->d;
+        auto dataset = GenDatasetWithIds(nb, dim, xb, ids);
+
+        auto preprocessor = index_->BuildPreprocessor(dataset, cfg);
+        index_->set_preprocessor(preprocessor);
+        auto model = index_->Train(dataset, cfg);
+        index_->set_index_model(model);
+        index_->Add(dataset, cfg);
+
+        if (auto device_index = std::dynamic_pointer_cast<knowhere::GPUIndex>(index_)) {
+            auto host_index = device_index->CopyGpuToCpu(Config());
+            index_ = host_index;
+            type = ConvertToCpuIndexType(type);
+        } else {
+            WRAPPER_LOG_ERROR << "Build IVFMIXIndex Failed";
+            return Status(KNOWHERE_ERROR, "Build IVFMIXIndex Failed");
+        }
+    } catch (knowhere::KnowhereException& e) {
+        WRAPPER_LOG_ERROR << e.what();
+        return Status(KNOWHERE_UNEXPECTED_ERROR, e.what());
+    } catch (std::exception& e) {
+        WRAPPER_LOG_ERROR << e.what();
+        return Status(KNOWHERE_ERROR, e.what());
+    }
+    return Status::OK();
+}
+
+Status
+IVFMixIndex::Load(const knowhere::BinarySet& index_binary) {
+    index_->Load(index_binary);
+    dim = Dimension();
+    return Status::OK();
+}
+
+knowhere::QuantizerPtr
+IVFHybridIndex::LoadQuantizer(const Config& conf) {
+    // TODO(linxj): Hardcode here
+    if (auto new_idx = std::dynamic_pointer_cast<knowhere::IVFSQHybrid>(index_)) {
+        return new_idx->LoadQuantizer(conf);
+    } else {
+        WRAPPER_LOG_ERROR << "Hybrid mode not support for index type: " << int(type);
+    }
+}
+
+Status
+IVFHybridIndex::SetQuantizer(const knowhere::QuantizerPtr& q) {
+    try {
+        // TODO(linxj): Hardcode here
+        if (auto new_idx = std::dynamic_pointer_cast<knowhere::IVFSQHybrid>(index_)) {
+            new_idx->SetQuantizer(q);
+        } else {
+            WRAPPER_LOG_ERROR << "Hybrid mode not support for index type: " << int(type);
+            return Status(KNOWHERE_ERROR, "not support");
+        }
+    } catch (knowhere::KnowhereException& e) {
+        WRAPPER_LOG_ERROR << e.what();
+        return Status(KNOWHERE_UNEXPECTED_ERROR, e.what());
+    } catch (std::exception& e) {
+        WRAPPER_LOG_ERROR << e.what();
+        return Status(KNOWHERE_ERROR, e.what());
+    }
+    return Status::OK();
+}
+
+Status
+IVFHybridIndex::UnsetQuantizer() {
+    try {
+        // TODO(linxj): Hardcode here
+        if (auto new_idx = std::dynamic_pointer_cast<knowhere::IVFSQHybrid>(index_)) {
+            new_idx->UnsetQuantizer();
+        } else {
+            WRAPPER_LOG_ERROR << "Hybrid mode not support for index type: " << int(type);
+            return Status(KNOWHERE_ERROR, "not support");
+        }
+    } catch (knowhere::KnowhereException& e) {
+        WRAPPER_LOG_ERROR << e.what();
+        return Status(KNOWHERE_UNEXPECTED_ERROR, e.what());
+    } catch (std::exception& e) {
+        WRAPPER_LOG_ERROR << e.what();
+        return Status(KNOWHERE_ERROR, e.what());
+    }
+    return Status::OK();
+}
+
+VecIndexPtr
+IVFHybridIndex::LoadData(const knowhere::QuantizerPtr& q, const Config& conf) {
+    try {
+        // TODO(linxj): Hardcode here
+        if (auto new_idx = std::dynamic_pointer_cast<knowhere::IVFSQHybrid>(index_)) {
+            return std::make_shared<IVFHybridIndex>(new_idx->LoadData(q, conf), type);
+        } else {
+            WRAPPER_LOG_ERROR << "Hybrid mode not support for index type: " << int(type);
+        }
+    } catch (knowhere::KnowhereException& e) {
+        WRAPPER_LOG_ERROR << e.what();
+    } catch (std::exception& e) {
+        WRAPPER_LOG_ERROR << e.what();
+    }
+    return nullptr;
+}
+
+std::pair<VecIndexPtr, knowhere::QuantizerPtr>
+IVFHybridIndex::CopyToGpuWithQuantizer(const int64_t& device_id, const Config& cfg) {
+    try {
+        // TODO(linxj): Hardcode here
+        if (auto hybrid_idx = std::dynamic_pointer_cast<knowhere::IVFSQHybrid>(index_)) {
+            auto pair = hybrid_idx->CopyCpuToGpuWithQuantizer(device_id, cfg);
+            auto new_idx = std::make_shared<IVFHybridIndex>(pair.first, type);
+            return std::make_pair(new_idx, pair.second);
+        } else {
+            WRAPPER_LOG_ERROR << "Hybrid mode not support for index type: " << int(type);
+        }
+    } catch (knowhere::KnowhereException& e) {
+        WRAPPER_LOG_ERROR << e.what();
+    } catch (std::exception& e) {
+        WRAPPER_LOG_ERROR << e.what();
+    }
+    return std::make_pair(nullptr, nullptr);
+}
+
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/wrapper/VecImpl.h b/core/src/wrapper/VecImpl.h
new file mode 100644
index 0000000000..22d734cf92
--- /dev/null
+++ b/core/src/wrapper/VecImpl.h
@@ -0,0 +1,150 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include "VecIndex.h"
+#include "knowhere/index/vector_index/VectorIndex.h"
+
+namespace milvus {
+namespace engine {
+
+class VecIndexImpl : public VecIndex {
+ public:
+    explicit VecIndexImpl(std::shared_ptr<knowhere::VectorIndex> index, const IndexType& type)
+        : index_(std::move(index)), type(type) {
+    }
+
+    Status
+    BuildAll(const int64_t& nb, const float* xb, const int64_t* ids, const Config& cfg, const int64_t& nt,
+             const float* xt) override;
+
+    VecIndexPtr
+    CopyToGpu(const int64_t& device_id, const Config& cfg) override;
+
+    VecIndexPtr
+    CopyToCpu(const Config& cfg) override;
+
+    IndexType
+    GetType() override;
+
+    int64_t
+    Dimension() override;
+
+    int64_t
+    Count() override;
+
+    Status
+    Add(const int64_t& nb, const float* xb, const int64_t* ids, const Config& cfg) override;
+
+    knowhere::BinarySet
+    Serialize() override;
+
+    Status
+    Load(const knowhere::BinarySet& index_binary) override;
+
+    VecIndexPtr
+    Clone() override;
+
+    int64_t
+    GetDeviceId() override;
+
+    Status
+    Search(const int64_t& nq, const float* xq, float* dist, int64_t* ids, const Config& cfg) override;
+
+ protected:
+    int64_t dim = 0;
+
+    IndexType type = IndexType::INVALID;
+
+    std::shared_ptr<knowhere::VectorIndex> index_ = nullptr;
+};
+
+class IVFMixIndex : public VecIndexImpl {
+ public:
+    explicit IVFMixIndex(std::shared_ptr<knowhere::VectorIndex> index, const IndexType& type)
+        : VecIndexImpl(std::move(index), type) {
+    }
+
+    Status
+    BuildAll(const int64_t& nb, const float* xb, const int64_t* ids, const Config& cfg, const int64_t& nt,
+             const float* xt) override;
+
+    Status
+    Load(const knowhere::BinarySet& index_binary) override;
+};
+
+class IVFHybridIndex : public IVFMixIndex {
+ public:
+    explicit IVFHybridIndex(std::shared_ptr<knowhere::VectorIndex> index, const IndexType& type)
+        : IVFMixIndex(std::move(index), type) {
+    }
+
+    knowhere::QuantizerPtr
+    LoadQuantizer(const Config& conf) override;
+
+    Status
+    SetQuantizer(const knowhere::QuantizerPtr& q) override;
+
+    Status
+    UnsetQuantizer() override;
+    std::pair<VecIndexPtr, knowhere::QuantizerPtr>
+    CopyToGpuWithQuantizer(const int64_t& device_id, const Config& cfg) override;
+
+    VecIndexPtr
+    LoadData(const knowhere::QuantizerPtr& q, const Config& conf) override;
+};
+
+class BFIndex : public VecIndexImpl {
+ public:
+    explicit BFIndex(std::shared_ptr<knowhere::VectorIndex> index)
+        : VecIndexImpl(std::move(index), IndexType::FAISS_IDMAP) {
+    }
+
+    ErrorCode
+    Build(const Config& cfg);
+
+    float*
+    GetRawVectors();
+
+    Status
+    BuildAll(const int64_t& nb, const float* xb, const int64_t* ids, const Config& cfg, const int64_t& nt,
+             const float* xt) override;
+
+    int64_t*
+    GetRawIds();
+};
+
+class ToIndexData : public cache::DataObj {
+ public:
+    explicit ToIndexData(int64_t size) : size_(size) {
+    }
+
+    int64_t
+    Size() override {
+        return size_;
+    }
+
+ private:
+    int64_t size_;
+};
+
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/wrapper/VecIndex.cpp b/core/src/wrapper/VecIndex.cpp
new file mode 100644
index 0000000000..abf97e69e5
--- /dev/null
+++ b/core/src/wrapper/VecIndex.cpp
@@ -0,0 +1,292 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "wrapper/VecIndex.h"
+#include "VecImpl.h"
+#include "knowhere/common/Exception.h"
+#include "knowhere/index/vector_index/IndexGPUIVF.h"
+#include "knowhere/index/vector_index/IndexGPUIVFPQ.h"
+#include "knowhere/index/vector_index/IndexGPUIVFSQ.h"
+#include "knowhere/index/vector_index/IndexIDMAP.h"
+#include "knowhere/index/vector_index/IndexIVF.h"
+#include "knowhere/index/vector_index/IndexIVFPQ.h"
+#include "knowhere/index/vector_index/IndexIVFSQ.h"
+#include "knowhere/index/vector_index/IndexIVFSQHybrid.h"
+#include "knowhere/index/vector_index/IndexKDT.h"
+#include "knowhere/index/vector_index/IndexNSG.h"
+#include "utils/Log.h"
+
+#include <cuda.h>
+
+namespace milvus {
+namespace engine {
+
+int64_t
+VecIndex::Size() {
+    if (size_ != 0) {
+        return size_;
+    }
+    return Count() * Dimension() * sizeof(float);
+}
+
+void
+VecIndex::set_size(int64_t size) {
+    size_ = size;
+}
+
+struct FileIOReader {
+    std::fstream fs;
+    std::string name;
+
+    explicit FileIOReader(const std::string& fname);
+
+    ~FileIOReader();
+
+    size_t
+    operator()(void* ptr, size_t size);
+
+    size_t
+    operator()(void* ptr, size_t size, size_t pos);
+};
+
+FileIOReader::FileIOReader(const std::string& fname) {
+    name = fname;
+    fs = std::fstream(name, std::ios::in | std::ios::binary);
+}
+
+FileIOReader::~FileIOReader() {
+    fs.close();
+}
+
+size_t
+FileIOReader::operator()(void* ptr, size_t size) {
+    fs.read(reinterpret_cast<char*>(ptr), size);
+}
+
+size_t
+FileIOReader::operator()(void* ptr, size_t size, size_t pos) {
+    return 0;
+}
+
+struct FileIOWriter {
+    std::fstream fs;
+    std::string name;
+
+    explicit FileIOWriter(const std::string& fname);
+    ~FileIOWriter();
+    size_t
+    operator()(void* ptr, size_t size);
+};
+
+FileIOWriter::FileIOWriter(const std::string& fname) {
+    name = fname;
+    fs = std::fstream(name, std::ios::out | std::ios::binary);
+}
+
+FileIOWriter::~FileIOWriter() {
+    fs.close();
+}
+
+size_t
+FileIOWriter::operator()(void* ptr, size_t size) {
+    fs.write(reinterpret_cast<char*>(ptr), size);
+}
+
+VecIndexPtr
+GetVecIndexFactory(const IndexType& type, const Config& cfg) {
+    std::shared_ptr<knowhere::VectorIndex> index;
+    auto gpu_device = -1;  // TODO(linxj): remove hardcode here
+    switch (type) {
+        case IndexType::FAISS_IDMAP: {
+            index = std::make_shared<knowhere::IDMAP>();
+            return std::make_shared<BFIndex>(index);
+        }
+        case IndexType::FAISS_IVFFLAT_CPU: {
+            index = std::make_shared<knowhere::IVF>();
+            break;
+        }
+        case IndexType::FAISS_IVFFLAT_GPU: {
+            index = std::make_shared<knowhere::GPUIVF>(gpu_device);
+            break;
+        }
+        case IndexType::FAISS_IVFFLAT_MIX: {
+            index = std::make_shared<knowhere::GPUIVF>(gpu_device);
+            return std::make_shared<IVFMixIndex>(index, IndexType::FAISS_IVFFLAT_MIX);
+        }
+        case IndexType::FAISS_IVFPQ_CPU: {
+            index = std::make_shared<knowhere::IVFPQ>();
+            break;
+        }
+        case IndexType::FAISS_IVFPQ_GPU: {
+            index = std::make_shared<knowhere::GPUIVFPQ>(gpu_device);
+            break;
+        }
+        case IndexType::SPTAG_KDT_RNT_CPU: {
+            index = std::make_shared<knowhere::CPUKDTRNG>();
+            break;
+        }
+        case IndexType::FAISS_IVFSQ8_MIX: {
+            index = std::make_shared<knowhere::GPUIVFSQ>(gpu_device);
+            return std::make_shared<IVFMixIndex>(index, IndexType::FAISS_IVFSQ8_MIX);
+        }
+        case IndexType::FAISS_IVFSQ8_CPU: {
+            index = std::make_shared<knowhere::IVFSQ>();
+            break;
+        }
+        case IndexType::FAISS_IVFSQ8_GPU: {
+            index = std::make_shared<knowhere::GPUIVFSQ>(gpu_device);
+            break;
+        }
+#ifdef CUSTOMIZATION
+        case IndexType::FAISS_IVFSQ8_HYBRID: {
+            index = std::make_shared<knowhere::IVFSQHybrid>(gpu_device);
+            return std::make_shared<IVFHybridIndex>(index, IndexType::FAISS_IVFSQ8_HYBRID);
+        }
+#endif
+        case IndexType::NSG_MIX: {  // TODO(linxj): bug.
+            index = std::make_shared<knowhere::NSG>(gpu_device);
+            break;
+        }
+        default: { return nullptr; }
+    }
+    return std::make_shared<VecIndexImpl>(index, type);
+}
+
+VecIndexPtr
+LoadVecIndex(const IndexType& index_type, const knowhere::BinarySet& index_binary, int64_t size) {
+    auto index = GetVecIndexFactory(index_type);
+    if (index == nullptr)
+        return nullptr;
+    // else
+    index->Load(index_binary);
+    index->set_size(size);
+    return index;
+}
+
+VecIndexPtr
+read_index(const std::string& location) {
+    knowhere::BinarySet load_data_list;
+    FileIOReader reader(location);
+    reader.fs.seekg(0, reader.fs.end);
+    int64_t length = reader.fs.tellg();
+    if (length <= 0) {
+        return nullptr;
+    }
+
+    reader.fs.seekg(0);
+
+    size_t rp = 0;
+    auto current_type = IndexType::INVALID;
+    reader(&current_type, sizeof(current_type));
+    rp += sizeof(current_type);
+    while (rp < length) {
+        size_t meta_length;
+        reader(&meta_length, sizeof(meta_length));
+        rp += sizeof(meta_length);
+        reader.fs.seekg(rp);
+
+        auto meta = new char[meta_length];
+        reader(meta, meta_length);
+        rp += meta_length;
+        reader.fs.seekg(rp);
+
+        size_t bin_length;
+        reader(&bin_length, sizeof(bin_length));
+        rp += sizeof(bin_length);
+        reader.fs.seekg(rp);
+
+        auto bin = new uint8_t[bin_length];
+        reader(bin, bin_length);
+        rp += bin_length;
+
+        auto binptr = std::make_shared<uint8_t>();
+        binptr.reset(bin);
+        load_data_list.Append(std::string(meta, meta_length), binptr, bin_length);
+        delete[] meta;
+    }
+
+    return LoadVecIndex(current_type, load_data_list, length);
+}
+
+Status
+write_index(VecIndexPtr index, const std::string& location) {
+    try {
+        auto binaryset = index->Serialize();
+        auto index_type = index->GetType();
+
+        FileIOWriter writer(location);
+        writer(&index_type, sizeof(IndexType));
+        for (auto& iter : binaryset.binary_map_) {
+            auto meta = iter.first.c_str();
+            size_t meta_length = iter.first.length();
+            writer(&meta_length, sizeof(meta_length));
+            writer((void*)meta, meta_length);
+
+            auto binary = iter.second;
+            int64_t binary_length = binary->size;
+            writer(&binary_length, sizeof(binary_length));
+            writer((void*)binary->data.get(), binary_length);
+        }
+    } catch (knowhere::KnowhereException& e) {
+        WRAPPER_LOG_ERROR << e.what();
+        return Status(KNOWHERE_UNEXPECTED_ERROR, e.what());
+    } catch (std::exception& e) {
+        WRAPPER_LOG_ERROR << e.what();
+        std::string estring(e.what());
+        if (estring.find("No space left on device") != estring.npos) {
+            WRAPPER_LOG_ERROR << "No space left on the device";
+            return Status(KNOWHERE_NO_SPACE, "No space left on the device");
+        } else {
+            return Status(KNOWHERE_ERROR, e.what());
+        }
+    }
+    return Status::OK();
+}
+
+IndexType
+ConvertToCpuIndexType(const IndexType& type) {
+    // TODO(linxj): add IDMAP
+    switch (type) {
+        case IndexType::FAISS_IVFFLAT_GPU:
+        case IndexType::FAISS_IVFFLAT_MIX: {
+            return IndexType::FAISS_IVFFLAT_CPU;
+        }
+        case IndexType::FAISS_IVFSQ8_GPU:
+        case IndexType::FAISS_IVFSQ8_MIX: {
+            return IndexType::FAISS_IVFSQ8_CPU;
+        }
+        default: { return type; }
+    }
+}
+
+IndexType
+ConvertToGpuIndexType(const IndexType& type) {
+    switch (type) {
+        case IndexType::FAISS_IVFFLAT_MIX:
+        case IndexType::FAISS_IVFFLAT_CPU: {
+            return IndexType::FAISS_IVFFLAT_GPU;
+        }
+        case IndexType::FAISS_IVFSQ8_MIX:
+        case IndexType::FAISS_IVFSQ8_CPU: {
+            return IndexType::FAISS_IVFSQ8_GPU;
+        }
+        default: { return type; }
+    }
+}
+
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/src/wrapper/VecIndex.h b/core/src/wrapper/VecIndex.h
new file mode 100644
index 0000000000..36104b2107
--- /dev/null
+++ b/core/src/wrapper/VecIndex.h
@@ -0,0 +1,152 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "cache/DataObj.h"
+#include "knowhere/common/BinarySet.h"
+#include "knowhere/common/Config.h"
+#include "knowhere/index/vector_index/Quantizer.h"
+#include "utils/Log.h"
+#include "utils/Status.h"
+
+namespace milvus {
+namespace engine {
+
+using Config = knowhere::Config;
+
+enum class IndexType {
+    INVALID = 0,
+    FAISS_IDMAP = 1,
+    FAISS_IVFFLAT_CPU,
+    FAISS_IVFFLAT_GPU,
+    FAISS_IVFFLAT_MIX,  // build on gpu and search on cpu
+    FAISS_IVFPQ_CPU,
+    FAISS_IVFPQ_GPU,
+    SPTAG_KDT_RNT_CPU,
+    FAISS_IVFSQ8_MIX,
+    FAISS_IVFSQ8_CPU,
+    FAISS_IVFSQ8_GPU,
+    FAISS_IVFSQ8_HYBRID,  // only support build on gpu.
+    NSG_MIX,
+};
+
+class VecIndex;
+
+using VecIndexPtr = std::shared_ptr<VecIndex>;
+
+class VecIndex : public cache::DataObj {
+ public:
+    virtual Status
+    BuildAll(const int64_t& nb, const float* xb, const int64_t* ids, const Config& cfg, const int64_t& nt = 0,
+             const float* xt = nullptr) = 0;
+
+    virtual Status
+    Add(const int64_t& nb, const float* xb, const int64_t* ids, const Config& cfg = Config()) = 0;
+
+    virtual Status
+    Search(const int64_t& nq, const float* xq, float* dist, int64_t* ids, const Config& cfg = Config()) = 0;
+
+    virtual VecIndexPtr
+    CopyToGpu(const int64_t& device_id, const Config& cfg = Config()) = 0;
+
+    virtual VecIndexPtr
+    CopyToCpu(const Config& cfg = Config()) = 0;
+
+    virtual VecIndexPtr
+    Clone() = 0;
+
+    virtual int64_t
+    GetDeviceId() = 0;
+
+    virtual IndexType
+    GetType() = 0;
+
+    virtual int64_t
+    Dimension() = 0;
+
+    virtual int64_t
+    Count() = 0;
+
+    int64_t
+    Size() override;
+
+    void
+    set_size(int64_t size);
+
+    virtual knowhere::BinarySet
+    Serialize() = 0;
+
+    virtual Status
+    Load(const knowhere::BinarySet& index_binary) = 0;
+
+    // TODO(linxj): refactor later
+    ////////////////
+    virtual knowhere::QuantizerPtr
+    LoadQuantizer(const Config& conf) {
+        ENGINE_LOG_ERROR << "LoadQuantizer virtual funciton called.";
+        return nullptr;
+    }
+
+    virtual VecIndexPtr
+    LoadData(const knowhere::QuantizerPtr& q, const Config& conf) {
+        return nullptr;
+    }
+
+    virtual Status
+    SetQuantizer(const knowhere::QuantizerPtr& q) {
+        return Status::OK();
+    }
+
+    virtual Status
+    UnsetQuantizer() {
+        return Status::OK();
+    }
+
+    virtual std::pair<VecIndexPtr, knowhere::QuantizerPtr>
+    CopyToGpuWithQuantizer(const int64_t& device_id, const Config& cfg = Config()) {
+        return std::make_pair(nullptr, nullptr);
+    }
+    ////////////////
+ private:
+    int64_t size_ = 0;
+};
+
+extern Status
+write_index(VecIndexPtr index, const std::string& location);
+
+extern VecIndexPtr
+read_index(const std::string& location);
+
+extern VecIndexPtr
+GetVecIndexFactory(const IndexType& type, const Config& cfg = Config());
+
+extern VecIndexPtr
+LoadVecIndex(const IndexType& index_type, const knowhere::BinarySet& index_binary, int64_t size);
+
+extern IndexType
+ConvertToCpuIndexType(const IndexType& type);
+
+extern IndexType
+ConvertToGpuIndexType(const IndexType& type);
+
+}  // namespace engine
+}  // namespace milvus
diff --git a/core/start_server.sh b/core/start_server.sh
new file mode 100755
index 0000000000..50bf8b84a8
--- /dev/null
+++ b/core/start_server.sh
@@ -0,0 +1,4 @@
+#!/bin/bash
+
+./cmake_build/src/milvus_server -c ./conf/server_config.yaml -l ./conf/log_config.conf &
+
diff --git a/core/stop_server.sh b/core/stop_server.sh
new file mode 100755
index 0000000000..f15e48a954
--- /dev/null
+++ b/core/stop_server.sh
@@ -0,0 +1,16 @@
+#!/bin/bash
+
+function kill_progress()
+{
+  kill -s SIGUSR2 $(pgrep $1)
+
+  sleep 2
+}
+
+STATUS=$(kill_progress "milvus_server" )
+
+if [[ ${STATUS} == "false" ]];then
+  echo "Milvus server closed abnormally!"
+else
+  echo "Milvus server closed successfully!"
+fi
diff --git a/core/thirdparty/versions.txt b/core/thirdparty/versions.txt
new file mode 100644
index 0000000000..ec270c0670
--- /dev/null
+++ b/core/thirdparty/versions.txt
@@ -0,0 +1,18 @@
+BOOST_VERSION=1.70.0
+BZIP2_VERSION=1.0.6
+EASYLOGGINGPP_VERSION=v9.96.7
+GTEST_VERSION=1.8.1
+LZ4_VERSION=v1.9.1
+MYSQLPP_VERSION=3.2.4
+PROMETHEUS_VERSION=v0.7.0
+SNAPPY_VERSION=1.1.7
+SQLITE_VERSION=3280000
+SQLITE_ORM_VERSION=master
+YAMLCPP_VERSION=0.6.2
+ZLIB_VERSION=v1.2.11
+ZSTD_VERSION=v1.4.0
+LIBUNWIND_VERSION=1.3.1
+GPERFTOOLS_VERSION=2.7
+GRPC_VERSION=master
+
+# vim: set filetype=sh:
diff --git a/core/ubuntu_build_deps.sh b/core/ubuntu_build_deps.sh
new file mode 100755
index 0000000000..ed9eb9dee5
--- /dev/null
+++ b/core/ubuntu_build_deps.sh
@@ -0,0 +1,5 @@
+#!/bin/bash
+
+sudo apt-get install -y gfortran libmysqlclient-dev mysql-client libcurl4-openssl-dev libboost-system-dev libboost-filesystem-dev libboost-serialization-dev
+
+sudo ln -s /usr/lib/x86_64-linux-gnu/libmysqlclient.so /usr/lib/x86_64-linux-gnu/libmysqlclient_r.so
diff --git a/core/unittest/CMakeLists.txt b/core/unittest/CMakeLists.txt
new file mode 100644
index 0000000000..258fd76a8e
--- /dev/null
+++ b/core/unittest/CMakeLists.txt
@@ -0,0 +1,121 @@
+#-------------------------------------------------------------------------------
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you 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_directories("${CUDA_TOOLKIT_ROOT_DIR}/include")
+
+foreach(dir ${INDEX_INCLUDE_DIRS})
+    include_directories(${dir})
+endforeach()
+
+include_directories(${MILVUS_SOURCE_DIR})
+include_directories(${MILVUS_ENGINE_SRC})
+include_directories(${CMAKE_CURRENT_SOURCE_DIR})
+
+link_directories("${CUDA_TOOLKIT_ROOT_DIR}/lib64")
+
+aux_source_directory(${MILVUS_ENGINE_SRC}/cache cache_files)
+aux_source_directory(${MILVUS_ENGINE_SRC}/config config_files)
+aux_source_directory(${MILVUS_ENGINE_SRC}/metrics metrics_files)
+aux_source_directory(${MILVUS_ENGINE_SRC}/db db_main_files)
+aux_source_directory(${MILVUS_ENGINE_SRC}/db/engine db_engine_files)
+aux_source_directory(${MILVUS_ENGINE_SRC}/db/insert db_insert_files)
+aux_source_directory(${MILVUS_ENGINE_SRC}/db/meta db_meta_files)
+
+set(grpc_service_files
+        ${MILVUS_ENGINE_SRC}/grpc/gen-milvus/milvus.grpc.pb.cc
+        ${MILVUS_ENGINE_SRC}/grpc/gen-milvus/milvus.pb.cc
+        ${MILVUS_ENGINE_SRC}/grpc/gen-status/status.grpc.pb.cc
+        ${MILVUS_ENGINE_SRC}/grpc/gen-status/status.pb.cc
+        )
+
+aux_source_directory(${MILVUS_ENGINE_SRC}/scheduler scheduler_main_files)
+aux_source_directory(${MILVUS_ENGINE_SRC}/scheduler/action scheduler_action_files)
+aux_source_directory(${MILVUS_ENGINE_SRC}/scheduler/event scheduler_event_files)
+aux_source_directory(${MILVUS_ENGINE_SRC}/scheduler/job scheduler_job_files)
+aux_source_directory(${MILVUS_ENGINE_SRC}/scheduler/resource scheduler_resource_files)
+aux_source_directory(${MILVUS_ENGINE_SRC}/scheduler/task scheduler_task_files)
+aux_source_directory(${MILVUS_ENGINE_SRC}/scheduler/optimizer scheduler_optimizer_files)
+set(scheduler_files
+        ${scheduler_main_files}
+        ${scheduler_action_files}
+        ${scheduler_event_files}
+        ${scheduler_job_files}
+        ${scheduler_resource_files}
+        ${scheduler_task_files}
+        ${scheduler_optimizer_files}
+        )
+
+aux_source_directory(${MILVUS_ENGINE_SRC}/server server_files)
+aux_source_directory(${MILVUS_ENGINE_SRC}/server/grpc_impl grpc_server_files)
+aux_source_directory(${MILVUS_ENGINE_SRC}/utils utils_files)
+aux_source_directory(${MILVUS_ENGINE_SRC}/wrapper wrapper_files)
+
+set(entry_file
+        ${CMAKE_CURRENT_SOURCE_DIR}/main.cpp)
+
+set(helper_files
+        ${MILVUS_ENGINE_SRC}/server/Config.cpp
+        ${MILVUS_ENGINE_SRC}/utils/CommonUtil.cpp
+        ${MILVUS_ENGINE_SRC}/utils/TimeRecorder.cpp
+        ${MILVUS_ENGINE_SRC}/utils/Status.cpp
+        ${MILVUS_ENGINE_SRC}/utils/ValidationUtil.cpp
+        ${MILVUS_ENGINE_SRC}/utils/easylogging++.cc
+        )
+
+set(common_files
+        ${cache_files}
+        ${config_files}
+        ${db_main_files}
+        ${db_engine_files}
+        ${db_insert_files}
+        ${db_meta_files}
+        ${metrics_files}
+        ${scheduler_files}
+        ${wrapper_files}
+        ${helper_files}
+        )
+
+set(unittest_libs
+        sqlite
+        libboost_system.a
+        libboost_filesystem.a
+        lz4
+        mysqlpp
+        yaml-cpp
+        gtest
+        gmock
+        gtest_main
+        gmock_main
+        pthread
+        metrics
+        gfortran
+        prometheus-cpp-pull
+        prometheus-cpp-push
+        prometheus-cpp-core
+        dl
+        z
+        ${CUDA_TOOLKIT_ROOT_DIR}/lib64/stubs/libnvidia-ml.so
+        cudart
+        cublas
+        )
+
+add_subdirectory(db)
+add_subdirectory(wrapper)
+add_subdirectory(metrics)
+add_subdirectory(scheduler)
+add_subdirectory(server)
\ No newline at end of file
diff --git a/core/unittest/db/CMakeLists.txt b/core/unittest/db/CMakeLists.txt
new file mode 100644
index 0000000000..4bce9f35b3
--- /dev/null
+++ b/core/unittest/db/CMakeLists.txt
@@ -0,0 +1,42 @@
+#-------------------------------------------------------------------------------
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you 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.
+#-------------------------------------------------------------------------------
+
+
+aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR} test_files)
+
+cuda_add_executable(test_db
+        ${common_files}
+        ${test_files}
+        )
+
+target_link_libraries(test_db
+        knowhere
+        ${unittest_libs})
+
+install(TARGETS test_db DESTINATION unittest)
+
+configure_file(appendix/server_config.yaml
+        "${CMAKE_CURRENT_BINARY_DIR}/milvus/conf/server_config.yaml"
+        COPYONLY)
+
+configure_file(appendix/log_config.conf
+        "${CMAKE_CURRENT_BINARY_DIR}/milvus/conf/log_config.conf"
+        COPYONLY)
+
+
diff --git a/core/unittest/db/appendix/log_config.conf b/core/unittest/db/appendix/log_config.conf
new file mode 100644
index 0000000000..0a3e0d21af
--- /dev/null
+++ b/core/unittest/db/appendix/log_config.conf
@@ -0,0 +1,27 @@
+* GLOBAL:
+    FORMAT                  =   "%datetime | %level | %logger | %msg"
+    FILENAME                =   "/tmp/milvus/logs/milvus-%datetime{%y-%M-%d-%H:%m}-global.log"
+    ENABLED                 =   true
+    TO_FILE                 =   true
+    TO_STANDARD_OUTPUT      =   false
+    SUBSECOND_PRECISION     =   3
+    PERFORMANCE_TRACKING    =   false
+    MAX_LOG_FILE_SIZE       =   209715200 ## Throw log files away after 200MB
+* DEBUG:
+    FILENAME                =   "/tmp/milvus/logs/milvus-%datetime{%y-%M-%d-%H:%m}-debug.log"
+    ENABLED                 =   true
+* WARNING:
+    FILENAME                =   "/tmp/milvus/logs/milvus-%datetime{%y-%M-%d-%H:%m}-warning.log"
+* TRACE:
+    FILENAME                =   "/tmp/milvus/logs/milvus-%datetime{%y-%M-%d-%H:%m}-trace.log"
+* VERBOSE:
+    FORMAT                  =   "%datetime{%d/%M/%y} | %level-%vlevel | %msg"
+    TO_FILE                 =   false
+    TO_STANDARD_OUTPUT      =   false
+## Error logs
+* ERROR:
+    ENABLED                 =   true
+    FILENAME                =   "/tmp/milvus/logs/milvus-%datetime{%y-%M-%d-%H:%m}-error.log"
+* FATAL:
+    ENABLED                 =   true
+    FILENAME                =   "/tmp/milvus/logs/milvus-%datetime{%y-%M-%d-%H:%m}-fatal.log"
diff --git a/core/unittest/db/appendix/server_config.yaml b/core/unittest/db/appendix/server_config.yaml
new file mode 100644
index 0000000000..f92b2f1a18
--- /dev/null
+++ b/core/unittest/db/appendix/server_config.yaml
@@ -0,0 +1,37 @@
+# All the following configurations are default values.
+
+server_config:
+  address: 0.0.0.0                  # milvus server ip address (IPv4)
+  port: 19530                       # port range: 1025 ~ 65534
+  deploy_mode: single               # deployment type: single, cluster_readonly, cluster_writable
+  time_zone: UTC+8
+
+db_config:
+  primary_path: /tmp/milvus    # path used to store data and meta
+  secondary_path:                   # path used to store data only, split by semicolon
+
+  backend_url: sqlite://:@:/        # URI format: dialect://username:password@host:port/database
+                                    # Keep 'dialect://:@:/', and replace other texts with real values.
+                                    # Replace 'dialect' with 'mysql' or 'sqlite'
+
+  insert_buffer_size: 4             # GB, maximum insert buffer size allowed
+  build_index_gpu: 0                # gpu id used for building index
+
+metric_config:
+  enable_monitor: false             # enable monitoring or not
+  collector: prometheus             # prometheus
+  prometheus_config:
+    port: 8080                      # port prometheus used to fetch metrics
+
+cache_config:
+  cpu_mem_capacity: 16              # GB, CPU memory used for cache
+  cpu_mem_threshold: 0.85           # percentage of data kept when cache cleanup triggered
+  cache_insert_data: false          # whether load inserted data into cache
+
+engine_config:
+  blas_threshold: 20
+
+resource_config:
+  resource_pool:
+    - cpu
+    - gpu0
diff --git a/core/unittest/db/test_db.cpp b/core/unittest/db/test_db.cpp
new file mode 100644
index 0000000000..5e6ecc2ac4
--- /dev/null
+++ b/core/unittest/db/test_db.cpp
@@ -0,0 +1,561 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "db/utils.h"
+#include "db/DB.h"
+#include "db/DBImpl.h"
+#include "db/Constants.h"
+#include "db/meta/MetaConsts.h"
+#include "db/DBFactory.h"
+#include "cache/CpuCacheMgr.h"
+#include "utils/CommonUtil.h"
+#include "server/Config.h"
+
+#include <gtest/gtest.h>
+#include <boost/filesystem.hpp>
+#include <thread>
+#include <random>
+
+
+namespace {
+
+static const char *CONFIG_FILE_PATH = "./milvus/conf/server_config.yaml";
+
+static const char *TABLE_NAME = "test_group";
+static constexpr int64_t TABLE_DIM = 256;
+static constexpr int64_t VECTOR_COUNT = 25000;
+static constexpr int64_t INSERT_LOOP = 1000;
+static constexpr int64_t SECONDS_EACH_HOUR = 3600;
+static constexpr int64_t DAY_SECONDS = 24 * 60 * 60;
+
+milvus::engine::meta::TableSchema
+BuildTableSchema() {
+    milvus::engine::meta::TableSchema table_info;
+    table_info.dimension_ = TABLE_DIM;
+    table_info.table_id_ = TABLE_NAME;
+    return table_info;
+}
+
+void
+BuildVectors(int64_t n, std::vector<float> &vectors) {
+    vectors.clear();
+    vectors.resize(n * TABLE_DIM);
+    float *data = vectors.data();
+    for (int i = 0; i < n; i++) {
+        for (int j = 0; j < TABLE_DIM; j++) data[TABLE_DIM * i + j] = drand48();
+        data[TABLE_DIM * i] += i / 2000.;
+    }
+}
+
+std::string
+CurrentTmDate(int64_t offset_day = 0) {
+    time_t tt;
+    time(&tt);
+    tt = tt + 8 * SECONDS_EACH_HOUR;
+    tt = tt + 24 * SECONDS_EACH_HOUR * offset_day;
+    tm t;
+    gmtime_r(&tt, &t);
+
+    std::string str = std::to_string(t.tm_year + 1900) + "-" + std::to_string(t.tm_mon + 1)
+        + "-" + std::to_string(t.tm_mday);
+
+    return str;
+}
+
+void
+ConvertTimeRangeToDBDates(const std::string &start_value,
+                          const std::string &end_value,
+                          std::vector<milvus::engine::meta::DateT> &dates) {
+    dates.clear();
+
+    time_t tt_start, tt_end;
+    tm tm_start, tm_end;
+    if (!milvus::server::CommonUtil::TimeStrToTime(start_value, tt_start, tm_start)) {
+        return;
+    }
+
+    if (!milvus::server::CommonUtil::TimeStrToTime(end_value, tt_end, tm_end)) {
+        return;
+    }
+
+    int64_t days = (tt_end > tt_start) ? (tt_end - tt_start) / DAY_SECONDS : (tt_start - tt_end) /
+        DAY_SECONDS;
+    if (days == 0) {
+        return;
+    }
+
+    for (int64_t i = 0; i < days; i++) {
+        time_t tt_day = tt_start + DAY_SECONDS * i;
+        tm tm_day;
+        milvus::server::CommonUtil::ConvertTime(tt_day, tm_day);
+
+        int64_t date = tm_day.tm_year * 10000 + tm_day.tm_mon * 100 +
+            tm_day.tm_mday;//according to db logic
+        dates.push_back(date);
+    }
+}
+
+} // namespace
+
+TEST_F(DBTest, CONFIG_TEST) {
+    {
+        ASSERT_ANY_THROW(milvus::engine::ArchiveConf conf("wrong"));
+        /* EXPECT_DEATH(engine::ArchiveConf conf("wrong"), ""); */
+    }
+    {
+        milvus::engine::ArchiveConf conf("delete");
+        ASSERT_EQ(conf.GetType(), "delete");
+        auto criterias = conf.GetCriterias();
+        ASSERT_EQ(criterias.size(), 0);
+    }
+    {
+        milvus::engine::ArchiveConf conf("swap");
+        ASSERT_EQ(conf.GetType(), "swap");
+        auto criterias = conf.GetCriterias();
+        ASSERT_EQ(criterias.size(), 0);
+    }
+    {
+        ASSERT_ANY_THROW(milvus::engine::ArchiveConf conf1("swap", "disk:"));
+        ASSERT_ANY_THROW(milvus::engine::ArchiveConf conf2("swap", "disk:a"));
+        milvus::engine::ArchiveConf conf("swap", "disk:1024");
+        auto criterias = conf.GetCriterias();
+        ASSERT_EQ(criterias.size(), 1);
+        ASSERT_EQ(criterias["disk"], 1024);
+    }
+    {
+        ASSERT_ANY_THROW(milvus::engine::ArchiveConf conf1("swap", "days:"));
+        ASSERT_ANY_THROW(milvus::engine::ArchiveConf conf2("swap", "days:a"));
+        milvus::engine::ArchiveConf conf("swap", "days:100");
+        auto criterias = conf.GetCriterias();
+        ASSERT_EQ(criterias.size(), 1);
+        ASSERT_EQ(criterias["days"], 100);
+    }
+    {
+        ASSERT_ANY_THROW(milvus::engine::ArchiveConf conf1("swap", "days:"));
+        ASSERT_ANY_THROW(milvus::engine::ArchiveConf conf2("swap", "days:a"));
+        milvus::engine::ArchiveConf conf("swap", "days:100;disk:200");
+        auto criterias = conf.GetCriterias();
+        ASSERT_EQ(criterias.size(), 2);
+        ASSERT_EQ(criterias["days"], 100);
+        ASSERT_EQ(criterias["disk"], 200);
+    }
+}
+
+TEST_F(DBTest, DB_TEST) {
+    milvus::engine::meta::TableSchema table_info = BuildTableSchema();
+    auto stat = db_->CreateTable(table_info);
+
+    milvus::engine::meta::TableSchema table_info_get;
+    table_info_get.table_id_ = TABLE_NAME;
+    stat = db_->DescribeTable(table_info_get);
+    ASSERT_TRUE(stat.ok());
+    ASSERT_EQ(table_info_get.dimension_, TABLE_DIM);
+
+    milvus::engine::IDNumbers vector_ids;
+    milvus::engine::IDNumbers target_ids;
+
+    int64_t nb = 50;
+    std::vector<float> xb;
+    BuildVectors(nb, xb);
+
+    int64_t qb = 5;
+    std::vector<float> qxb;
+    BuildVectors(qb, qxb);
+
+    std::thread search([&]() {
+        milvus::engine::QueryResults results;
+        int k = 10;
+        std::this_thread::sleep_for(std::chrono::seconds(2));
+
+        INIT_TIMER;
+        std::stringstream ss;
+        uint64_t count = 0;
+        uint64_t prev_count = 0;
+
+        for (auto j = 0; j < 10; ++j) {
+            ss.str("");
+            db_->Size(count);
+            prev_count = count;
+
+            START_TIMER;
+            stat = db_->Query(TABLE_NAME, k, qb, 10, qxb.data(), results);
+            ss << "Search " << j << " With Size " << count / milvus::engine::M << " M";
+            STOP_TIMER(ss.str());
+
+            ASSERT_TRUE(stat.ok());
+            for (auto k = 0; k < qb; ++k) {
+                ASSERT_EQ(results[k][0].first, target_ids[k]);
+                ss.str("");
+                ss << "Result [" << k << "]:";
+                for (auto result : results[k]) {
+                    ss << result.first << " ";
+                }
+                /* LOG(DEBUG) << ss.str(); */
+            }
+            ASSERT_TRUE(count >= prev_count);
+            std::this_thread::sleep_for(std::chrono::seconds(1));
+        }
+    });
+
+    int loop = INSERT_LOOP;
+
+    for (auto i = 0; i < loop; ++i) {
+        if (i == 40) {
+            db_->InsertVectors(TABLE_NAME, qb, qxb.data(), target_ids);
+            ASSERT_EQ(target_ids.size(), qb);
+        } else {
+            db_->InsertVectors(TABLE_NAME, nb, xb.data(), vector_ids);
+        }
+        std::this_thread::sleep_for(std::chrono::microseconds(1));
+    }
+
+    search.join();
+
+    uint64_t count;
+    stat = db_->GetTableRowCount(TABLE_NAME, count);
+    ASSERT_TRUE(stat.ok());
+    ASSERT_GT(count, 0);
+}
+
+TEST_F(DBTest, SEARCH_TEST) {
+    milvus::server::Config &config = milvus::server::Config::GetInstance();
+    milvus::Status s = config.LoadConfigFile(CONFIG_FILE_PATH);
+
+    milvus::engine::meta::TableSchema table_info = BuildTableSchema();
+    auto stat = db_->CreateTable(table_info);
+
+    milvus::engine::meta::TableSchema table_info_get;
+    table_info_get.table_id_ = TABLE_NAME;
+    stat = db_->DescribeTable(table_info_get);
+    ASSERT_TRUE(stat.ok());
+    ASSERT_EQ(table_info_get.dimension_, TABLE_DIM);
+
+    // prepare raw data
+    size_t nb = VECTOR_COUNT;
+    size_t nq = 10;
+    size_t k = 5;
+    std::vector<float> xb(nb * TABLE_DIM);
+    std::vector<float> xq(nq * TABLE_DIM);
+    std::vector<int64_t> ids(nb);
+
+    std::random_device rd;
+    std::mt19937 gen(rd());
+    std::uniform_real_distribution<> dis_xt(-1.0, 1.0);
+    for (size_t i = 0; i < nb * TABLE_DIM; i++) {
+        xb[i] = dis_xt(gen);
+        if (i < nb) {
+            ids[i] = i;
+        }
+    }
+    for (size_t i = 0; i < nq * TABLE_DIM; i++) {
+        xq[i] = dis_xt(gen);
+    }
+
+    // result data
+    //std::vector<long> nns_gt(k*nq);
+    std::vector<int64_t> nns(k * nq);  // nns = nearst neg search
+    //std::vector<float> dis_gt(k*nq);
+    std::vector<float> dis(k * nq);
+
+    // insert data
+    const int batch_size = 100;
+    for (int j = 0; j < nb / batch_size; ++j) {
+        stat = db_->InsertVectors(TABLE_NAME, batch_size, xb.data() + batch_size * j * TABLE_DIM, ids);
+        if (j == 200) { sleep(1); }
+        ASSERT_TRUE(stat.ok());
+    }
+
+    milvus::engine::TableIndex index;
+    index.engine_type_ = (int) milvus::engine::EngineType::FAISS_IDMAP;
+    db_->CreateIndex(TABLE_NAME, index); // wait until build index finish
+
+    {
+        milvus::engine::QueryResults results;
+        stat = db_->Query(TABLE_NAME, k, nq, 10, xq.data(), results);
+        ASSERT_TRUE(stat.ok());
+    }
+
+    {//search by specify index file
+        milvus::engine::meta::DatesT dates;
+        std::vector<std::string> file_ids = {"1", "2", "3", "4", "5", "6"};
+        milvus::engine::QueryResults results;
+        stat = db_->Query(TABLE_NAME, file_ids, k, nq, 10, xq.data(), dates, results);
+        ASSERT_TRUE(stat.ok());
+    }
+
+#ifdef CUSTOMIZATION
+    //test FAISS_IVFSQ8H optimizer
+    index.engine_type_ = (int)milvus::engine::EngineType::FAISS_IVFSQ8H;
+    db_->CreateIndex(TABLE_NAME, index); // wait until build index finish
+
+    {
+        milvus::engine::QueryResults results;
+        stat = db_->Query(TABLE_NAME, k, nq, 10, xq.data(), results);
+        ASSERT_TRUE(stat.ok());
+    }
+
+    {
+        milvus::engine::QueryResults large_nq_results;
+        stat = db_->Query(TABLE_NAME, k, 200, 10, xq.data(), large_nq_results);
+        ASSERT_TRUE(stat.ok());
+    }
+
+    {//search by specify index file
+        milvus::engine::meta::DatesT dates;
+        std::vector<std::string> file_ids = {"1", "2", "3", "4", "5", "6"};
+        milvus::engine::QueryResults results;
+        stat = db_->Query(TABLE_NAME, file_ids, k, nq, 10, xq.data(), dates, results);
+        ASSERT_TRUE(stat.ok());
+    }
+
+
+#endif
+}
+
+TEST_F(DBTest, PRELOADTABLE_TEST) {
+    milvus::engine::meta::TableSchema table_info = BuildTableSchema();
+    auto stat = db_->CreateTable(table_info);
+
+    milvus::engine::meta::TableSchema table_info_get;
+    table_info_get.table_id_ = TABLE_NAME;
+    stat = db_->DescribeTable(table_info_get);
+    ASSERT_TRUE(stat.ok());
+    ASSERT_EQ(table_info_get.dimension_, TABLE_DIM);
+
+    int64_t nb = VECTOR_COUNT;
+    std::vector<float> xb;
+    BuildVectors(nb, xb);
+
+    int loop = 5;
+    for (auto i = 0; i < loop; ++i) {
+        milvus::engine::IDNumbers vector_ids;
+        db_->InsertVectors(TABLE_NAME, nb, xb.data(), vector_ids);
+        ASSERT_EQ(vector_ids.size(), nb);
+    }
+
+    milvus::engine::TableIndex index;
+    index.engine_type_ = (int) milvus::engine::EngineType::FAISS_IDMAP;
+    db_->CreateIndex(TABLE_NAME, index); // wait until build index finish
+
+    int64_t prev_cache_usage = milvus::cache::CpuCacheMgr::GetInstance()->CacheUsage();
+    stat = db_->PreloadTable(TABLE_NAME);
+    ASSERT_TRUE(stat.ok());
+    int64_t cur_cache_usage = milvus::cache::CpuCacheMgr::GetInstance()->CacheUsage();
+    ASSERT_TRUE(prev_cache_usage < cur_cache_usage);
+}
+
+TEST_F(DBTest, SHUTDOWN_TEST) {
+    db_->Stop();
+
+    milvus::engine::meta::TableSchema table_info = BuildTableSchema();
+    auto stat = db_->CreateTable(table_info);
+    ASSERT_FALSE(stat.ok());
+
+    stat = db_->DescribeTable(table_info);
+    ASSERT_FALSE(stat.ok());
+
+    bool has_table = false;
+    stat = db_->HasTable(table_info.table_id_, has_table);
+    ASSERT_FALSE(stat.ok());
+
+    milvus::engine::IDNumbers ids;
+    stat = db_->InsertVectors(table_info.table_id_, 0, nullptr, ids);
+    ASSERT_FALSE(stat.ok());
+
+    stat = db_->PreloadTable(table_info.table_id_);
+    ASSERT_FALSE(stat.ok());
+
+    uint64_t row_count = 0;
+    stat = db_->GetTableRowCount(table_info.table_id_, row_count);
+    ASSERT_FALSE(stat.ok());
+
+    milvus::engine::TableIndex index;
+    stat = db_->CreateIndex(table_info.table_id_, index);
+    ASSERT_FALSE(stat.ok());
+
+    stat = db_->DescribeIndex(table_info.table_id_, index);
+    ASSERT_FALSE(stat.ok());
+
+    milvus::engine::meta::DatesT dates;
+    milvus::engine::QueryResults results;
+    stat = db_->Query(table_info.table_id_, 1, 1, 1, nullptr, dates, results);
+    ASSERT_FALSE(stat.ok());
+    std::vector<std::string> file_ids;
+    stat = db_->Query(table_info.table_id_, file_ids, 1, 1, 1, nullptr, dates, results);
+    ASSERT_FALSE(stat.ok());
+
+    stat = db_->DeleteTable(table_info.table_id_, dates);
+    ASSERT_FALSE(stat.ok());
+}
+
+TEST_F(DBTest, INDEX_TEST) {
+    milvus::engine::meta::TableSchema table_info = BuildTableSchema();
+    auto stat = db_->CreateTable(table_info);
+
+    int64_t nb = VECTOR_COUNT;
+    std::vector<float> xb;
+    BuildVectors(nb, xb);
+
+    milvus::engine::IDNumbers vector_ids;
+    db_->InsertVectors(TABLE_NAME, nb, xb.data(), vector_ids);
+    ASSERT_EQ(vector_ids.size(), nb);
+
+    milvus::engine::TableIndex index;
+    index.engine_type_ = (int) milvus::engine::EngineType::FAISS_IVFSQ8;
+    index.metric_type_ = (int) milvus::engine::MetricType::IP;
+    stat = db_->CreateIndex(table_info.table_id_, index);
+    ASSERT_TRUE(stat.ok());
+
+    index.engine_type_ = (int) milvus::engine::EngineType::FAISS_IVFFLAT;
+    stat = db_->CreateIndex(table_info.table_id_, index);
+    ASSERT_TRUE(stat.ok());
+
+#ifdef CUSTOMIZATION
+    index.engine_type_ = (int)milvus::engine::EngineType::FAISS_IVFSQ8H;
+    stat = db_->CreateIndex(table_info.table_id_, index);
+    ASSERT_TRUE(stat.ok());
+#endif
+
+    milvus::engine::TableIndex index_out;
+    stat = db_->DescribeIndex(table_info.table_id_, index_out);
+    ASSERT_TRUE(stat.ok());
+    ASSERT_EQ(index.engine_type_, index_out.engine_type_);
+    ASSERT_EQ(index.nlist_, index_out.nlist_);
+    ASSERT_EQ(table_info.metric_type_, index_out.metric_type_);
+
+    stat = db_->DropIndex(table_info.table_id_);
+    ASSERT_TRUE(stat.ok());
+}
+
+TEST_F(DBTest2, ARHIVE_DISK_CHECK) {
+    milvus::engine::meta::TableSchema table_info = BuildTableSchema();
+    auto stat = db_->CreateTable(table_info);
+
+    std::vector<milvus::engine::meta::TableSchema> table_schema_array;
+    stat = db_->AllTables(table_schema_array);
+    ASSERT_TRUE(stat.ok());
+    bool bfound = false;
+    for (auto &schema : table_schema_array) {
+        if (schema.table_id_ == TABLE_NAME) {
+            bfound = true;
+            break;
+        }
+    }
+    ASSERT_TRUE(bfound);
+
+    milvus::engine::meta::TableSchema table_info_get;
+    table_info_get.table_id_ = TABLE_NAME;
+    stat = db_->DescribeTable(table_info_get);
+    ASSERT_TRUE(stat.ok());
+    ASSERT_EQ(table_info_get.dimension_, TABLE_DIM);
+
+    uint64_t size;
+    db_->Size(size);
+
+    int64_t nb = 10;
+    std::vector<float> xb;
+    BuildVectors(nb, xb);
+
+    int loop = INSERT_LOOP;
+    for (auto i = 0; i < loop; ++i) {
+        milvus::engine::IDNumbers vector_ids;
+        db_->InsertVectors(TABLE_NAME, nb, xb.data(), vector_ids);
+        std::this_thread::sleep_for(std::chrono::microseconds(1));
+    }
+
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+
+    db_->Size(size);
+    LOG(DEBUG) << "size=" << size;
+    ASSERT_LE(size, 1 * milvus::engine::G);
+}
+
+TEST_F(DBTest2, DELETE_TEST) {
+    milvus::engine::meta::TableSchema table_info = BuildTableSchema();
+    auto stat = db_->CreateTable(table_info);
+
+    milvus::engine::meta::TableSchema table_info_get;
+    table_info_get.table_id_ = TABLE_NAME;
+    stat = db_->DescribeTable(table_info_get);
+    ASSERT_TRUE(stat.ok());
+
+    bool has_table = false;
+    db_->HasTable(TABLE_NAME, has_table);
+    ASSERT_TRUE(has_table);
+
+    uint64_t size;
+    db_->Size(size);
+
+    int64_t nb = VECTOR_COUNT;
+    std::vector<float> xb;
+    BuildVectors(nb, xb);
+
+    milvus::engine::IDNumbers vector_ids;
+    stat = db_->InsertVectors(TABLE_NAME, nb, xb.data(), vector_ids);
+    milvus::engine::TableIndex index;
+    stat = db_->CreateIndex(TABLE_NAME, index);
+
+    std::vector<milvus::engine::meta::DateT> dates;
+    stat = db_->DeleteTable(TABLE_NAME, dates);
+    std::this_thread::sleep_for(std::chrono::seconds(2));
+    ASSERT_TRUE(stat.ok());
+
+    db_->HasTable(TABLE_NAME, has_table);
+    ASSERT_FALSE(has_table);
+}
+
+TEST_F(DBTest2, DELETE_BY_RANGE_TEST) {
+    milvus::engine::meta::TableSchema table_info = BuildTableSchema();
+    auto stat = db_->CreateTable(table_info);
+
+    milvus::engine::meta::TableSchema table_info_get;
+    table_info_get.table_id_ = TABLE_NAME;
+    stat = db_->DescribeTable(table_info_get);
+    ASSERT_TRUE(stat.ok());
+
+    bool has_table = false;
+    db_->HasTable(TABLE_NAME, has_table);
+    ASSERT_TRUE(has_table);
+
+    uint64_t size;
+    db_->Size(size);
+    ASSERT_EQ(size, 0UL);
+
+    int64_t nb = VECTOR_COUNT;
+    std::vector<float> xb;
+    BuildVectors(nb, xb);
+
+    milvus::engine::IDNumbers vector_ids;
+    stat = db_->InsertVectors(TABLE_NAME, nb, xb.data(), vector_ids);
+    milvus::engine::TableIndex index;
+    stat = db_->CreateIndex(TABLE_NAME, index);
+
+    db_->Size(size);
+    ASSERT_NE(size, 0UL);
+
+    std::vector<milvus::engine::meta::DateT> dates;
+    std::string start_value = CurrentTmDate();
+    std::string end_value = CurrentTmDate(1);
+    ConvertTimeRangeToDBDates(start_value, end_value, dates);
+
+    stat = db_->DeleteTable(TABLE_NAME, dates);
+    ASSERT_TRUE(stat.ok());
+
+    uint64_t row_count = 0;
+    db_->GetTableRowCount(TABLE_NAME, row_count);
+    ASSERT_EQ(row_count, 0UL);
+}
diff --git a/core/unittest/db/test_db_mysql.cpp b/core/unittest/db/test_db_mysql.cpp
new file mode 100644
index 0000000000..ae1da8012a
--- /dev/null
+++ b/core/unittest/db/test_db_mysql.cpp
@@ -0,0 +1,280 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "db/utils.h"
+#include "db/DB.h"
+#include "db/DBImpl.h"
+#include "db/Constants.h"
+#include "db/meta/MetaConsts.h"
+
+#include <gtest/gtest.h>
+#include <boost/filesystem.hpp>
+
+#include <thread>
+#include <random>
+
+namespace {
+
+static const char *TABLE_NAME = "test_group";
+static constexpr int64_t TABLE_DIM = 256;
+static constexpr int64_t VECTOR_COUNT = 25000;
+static constexpr int64_t INSERT_LOOP = 1000;
+
+milvus::engine::meta::TableSchema
+BuildTableSchema() {
+    milvus::engine::meta::TableSchema table_info;
+    table_info.dimension_ = TABLE_DIM;
+    table_info.table_id_ = TABLE_NAME;
+    table_info.engine_type_ = (int) milvus::engine::EngineType::FAISS_IDMAP;
+    return table_info;
+}
+
+void
+BuildVectors(int64_t n, std::vector<float> &vectors) {
+    vectors.clear();
+    vectors.resize(n * TABLE_DIM);
+    float *data = vectors.data();
+    for (int i = 0; i < n; i++) {
+        for (int j = 0; j < TABLE_DIM; j++) data[TABLE_DIM * i + j] = drand48();
+        data[TABLE_DIM * i] += i / 2000.;
+    }
+}
+
+} // namespace
+
+TEST_F(MySqlDBTest, DB_TEST) {
+    milvus::engine::meta::TableSchema table_info = BuildTableSchema();
+    auto stat = db_->CreateTable(table_info);
+
+    milvus::engine::meta::TableSchema table_info_get;
+    table_info_get.table_id_ = TABLE_NAME;
+    stat = db_->DescribeTable(table_info_get);
+    ASSERT_TRUE(stat.ok());
+    ASSERT_EQ(table_info_get.dimension_, TABLE_DIM);
+
+    milvus::engine::IDNumbers vector_ids;
+    milvus::engine::IDNumbers target_ids;
+
+    int64_t nb = 50;
+    std::vector<float> xb;
+    BuildVectors(nb, xb);
+
+    int64_t qb = 5;
+    std::vector<float> qxb;
+    BuildVectors(qb, qxb);
+
+    db_->InsertVectors(TABLE_NAME, qb, qxb.data(), target_ids);
+    ASSERT_EQ(target_ids.size(), qb);
+
+    std::thread search([&]() {
+        milvus::engine::QueryResults results;
+        int k = 10;
+        std::this_thread::sleep_for(std::chrono::seconds(5));
+
+        INIT_TIMER;
+        std::stringstream ss;
+        uint64_t count = 0;
+        uint64_t prev_count = 0;
+
+        for (auto j = 0; j < 10; ++j) {
+            ss.str("");
+            db_->Size(count);
+            prev_count = count;
+
+            START_TIMER;
+            stat = db_->Query(TABLE_NAME, k, qb, 10, qxb.data(), results);
+            ss << "Search " << j << " With Size " << count / milvus::engine::M << " M";
+            STOP_TIMER(ss.str());
+
+            ASSERT_TRUE(stat.ok());
+            for (auto k = 0; k < qb; ++k) {
+//                std::cout << results[k][0].first << " " << target_ids[k] << std::endl;
+//                ASSERT_EQ(results[k][0].first, target_ids[k]);
+                bool exists = false;
+                for (auto &result : results[k]) {
+                    if (result.first == target_ids[k]) {
+                        exists = true;
+                    }
+                }
+                ASSERT_TRUE(exists);
+                ss.str("");
+                ss << "Result [" << k << "]:";
+                for (auto result : results[k]) {
+                    ss << result.first << " ";
+                }
+                /* LOG(DEBUG) << ss.str(); */
+            }
+            ASSERT_TRUE(count >= prev_count);
+            std::this_thread::sleep_for(std::chrono::seconds(3));
+        }
+
+        std::cout << "All search done!" << std::endl;
+    });
+
+    int loop = INSERT_LOOP;
+
+    for (auto i = 0; i < loop; ++i) {
+//        if (i==10) {
+//            db_->InsertVectors(TABLE_NAME, qb, qxb.data(), target_ids);
+//            ASSERT_EQ(target_ids.size(), qb);
+//        } else {
+//            db_->InsertVectors(TABLE_NAME, nb, xb.data(), vector_ids);
+//        }
+        db_->InsertVectors(TABLE_NAME, nb, xb.data(), vector_ids);
+        std::this_thread::sleep_for(std::chrono::microseconds(1));
+    }
+
+    search.join();
+}
+
+TEST_F(MySqlDBTest, SEARCH_TEST) {
+    milvus::engine::meta::TableSchema table_info = BuildTableSchema();
+    auto stat = db_->CreateTable(table_info);
+
+    milvus::engine::meta::TableSchema table_info_get;
+    table_info_get.table_id_ = TABLE_NAME;
+    stat = db_->DescribeTable(table_info_get);
+    ASSERT_TRUE(stat.ok());
+    ASSERT_EQ(table_info_get.dimension_, TABLE_DIM);
+
+    // prepare raw data
+    size_t nb = VECTOR_COUNT;
+    size_t nq = 10;
+    size_t k = 5;
+    std::vector<float> xb(nb * TABLE_DIM);
+    std::vector<float> xq(nq * TABLE_DIM);
+    std::vector<int64_t> ids(nb);
+
+    std::random_device rd;
+    std::mt19937 gen(rd());
+    std::uniform_real_distribution<> dis_xt(-1.0, 1.0);
+    for (size_t i = 0; i < nb * TABLE_DIM; i++) {
+        xb[i] = dis_xt(gen);
+        if (i < nb) {
+            ids[i] = i;
+        }
+    }
+    for (size_t i = 0; i < nq * TABLE_DIM; i++) {
+        xq[i] = dis_xt(gen);
+    }
+
+    // result data
+    //std::vector<long> nns_gt(k*nq);
+    std::vector<int64_t> nns(k * nq);  // nns = nearst neg search
+    //std::vector<float> dis_gt(k*nq);
+    std::vector<float> dis(k * nq);
+
+    // insert data
+    const int batch_size = 100;
+    for (int j = 0; j < nb / batch_size; ++j) {
+        stat = db_->InsertVectors(TABLE_NAME, batch_size, xb.data() + batch_size * j * TABLE_DIM, ids);
+        if (j == 200) { sleep(1); }
+        ASSERT_TRUE(stat.ok());
+    }
+
+    sleep(2); // wait until build index finish
+
+    milvus::engine::QueryResults results;
+    stat = db_->Query(TABLE_NAME, k, nq, 10, xq.data(), results);
+    ASSERT_TRUE(stat.ok());
+}
+
+TEST_F(MySqlDBTest, ARHIVE_DISK_CHECK) {
+    milvus::engine::meta::TableSchema table_info = BuildTableSchema();
+    auto stat = db_->CreateTable(table_info);
+
+    std::vector<milvus::engine::meta::TableSchema> table_schema_array;
+    stat = db_->AllTables(table_schema_array);
+    ASSERT_TRUE(stat.ok());
+    bool bfound = false;
+    for (auto &schema : table_schema_array) {
+        if (schema.table_id_ == TABLE_NAME) {
+            bfound = true;
+            break;
+        }
+    }
+    ASSERT_TRUE(bfound);
+
+    milvus::engine::meta::TableSchema table_info_get;
+    table_info_get.table_id_ = TABLE_NAME;
+    stat = db_->DescribeTable(table_info_get);
+    ASSERT_TRUE(stat.ok());
+    ASSERT_EQ(table_info_get.dimension_, TABLE_DIM);
+
+    milvus::engine::IDNumbers vector_ids;
+    milvus::engine::IDNumbers target_ids;
+
+    uint64_t size;
+    db_->Size(size);
+
+    int64_t nb = 10;
+    std::vector<float> xb;
+    BuildVectors(nb, xb);
+
+    int loop = INSERT_LOOP;
+    for (auto i = 0; i < loop; ++i) {
+        db_->InsertVectors(TABLE_NAME, nb, xb.data(), vector_ids);
+        std::this_thread::sleep_for(std::chrono::microseconds(1));
+    }
+
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+
+    db_->Size(size);
+    LOG(DEBUG) << "size=" << size;
+    ASSERT_LE(size, 1 * milvus::engine::G);
+}
+
+TEST_F(MySqlDBTest, DELETE_TEST) {
+    milvus::engine::meta::TableSchema table_info = BuildTableSchema();
+    auto stat = db_->CreateTable(table_info);
+//    std::cout << stat.ToString() << std::endl;
+
+    milvus::engine::meta::TableSchema table_info_get;
+    table_info_get.table_id_ = TABLE_NAME;
+    stat = db_->DescribeTable(table_info_get);
+    ASSERT_TRUE(stat.ok());
+
+    bool has_table = false;
+    db_->HasTable(TABLE_NAME, has_table);
+    ASSERT_TRUE(has_table);
+
+    milvus::engine::IDNumbers vector_ids;
+
+    uint64_t size;
+    db_->Size(size);
+
+    int64_t nb = INSERT_LOOP;
+    std::vector<float> xb;
+    BuildVectors(nb, xb);
+
+    int loop = 20;
+    for (auto i = 0; i < loop; ++i) {
+        db_->InsertVectors(TABLE_NAME, nb, xb.data(), vector_ids);
+        std::this_thread::sleep_for(std::chrono::microseconds(1));
+    }
+
+//    std::vector<engine::meta::DateT> dates;
+//    stat = db_->DeleteTable(TABLE_NAME, dates);
+////    std::cout << "5 sec start" << std::endl;
+//    std::this_thread::sleep_for(std::chrono::seconds(5));
+////    std::cout << "5 sec finish" << std::endl;
+//    ASSERT_TRUE(stat.ok());
+//
+//    db_->HasTable(TABLE_NAME, has_table);
+//    ASSERT_FALSE(has_table);
+}
+
diff --git a/core/unittest/db/test_engine.cpp b/core/unittest/db/test_engine.cpp
new file mode 100644
index 0000000000..147de5399c
--- /dev/null
+++ b/core/unittest/db/test_engine.cpp
@@ -0,0 +1,123 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 <gtest/gtest.h>
+#include <boost/filesystem.hpp>
+#include <vector>
+
+#include "db/engine/EngineFactory.h"
+#include "db/engine/ExecutionEngineImpl.h"
+#include "db/utils.h"
+
+TEST_F(EngineTest, FACTORY_TEST) {
+    {
+        auto engine_ptr = milvus::engine::EngineFactory::Build(
+                512,
+                "/tmp/milvus_index_1",
+                milvus::engine::EngineType::INVALID,
+                milvus::engine::MetricType::IP,
+                1024);
+
+        ASSERT_TRUE(engine_ptr == nullptr);
+    }
+
+    {
+        auto engine_ptr = milvus::engine::EngineFactory::Build(
+                512,
+                "/tmp/milvus_index_1",
+                milvus::engine::EngineType::FAISS_IDMAP,
+                milvus::engine::MetricType::IP,
+                1024);
+
+        ASSERT_TRUE(engine_ptr != nullptr);
+    }
+
+    {
+        auto engine_ptr = milvus::engine::EngineFactory::Build(
+                512,
+                "/tmp/milvus_index_1",
+                milvus::engine::EngineType::FAISS_IVFFLAT,
+                milvus::engine::MetricType::IP,
+                1024);
+
+        ASSERT_TRUE(engine_ptr != nullptr);
+    }
+
+    {
+        auto engine_ptr = milvus::engine::EngineFactory::Build(
+                512,
+                "/tmp/milvus_index_1",
+                milvus::engine::EngineType::FAISS_IVFSQ8,
+                milvus::engine::MetricType::IP,
+                1024);
+
+        ASSERT_TRUE(engine_ptr != nullptr);
+    }
+
+    {
+        auto engine_ptr = milvus::engine::EngineFactory::Build(
+                512,
+                "/tmp/milvus_index_1",
+                milvus::engine::EngineType::NSG_MIX,
+                milvus::engine::MetricType::IP,
+                1024);
+
+        ASSERT_TRUE(engine_ptr != nullptr);
+    }
+}
+
+TEST_F(EngineTest, ENGINE_IMPL_TEST) {
+    uint16_t dimension = 64;
+    std::string file_path = "/tmp/milvus_index_1";
+    auto engine_ptr = milvus::engine::EngineFactory::Build(
+            dimension,
+            file_path,
+            milvus::engine::EngineType::FAISS_IVFFLAT,
+            milvus::engine::MetricType::IP,
+            1024);
+
+    std::vector<float> data;
+    std::vector<int64_t> ids;
+    const int row_count = 10000;
+    data.reserve(row_count*dimension);
+    ids.reserve(row_count);
+    for (int64_t i = 0; i < row_count; i++) {
+        ids.push_back(i);
+        for (uint16_t k = 0; k < dimension; k++) {
+            data.push_back(i*dimension + k);
+        }
+    }
+
+    auto status = engine_ptr->AddWithIds((int64_t)ids.size(), data.data(), ids.data());
+    ASSERT_TRUE(status.ok());
+
+    ASSERT_EQ(engine_ptr->Dimension(), dimension);
+    ASSERT_EQ(engine_ptr->Count(), ids.size());
+
+    status = engine_ptr->CopyToGpu(0, true);
+    status = engine_ptr->CopyToGpu(0, false);
+    //ASSERT_TRUE(status.ok());
+
+    auto new_engine = engine_ptr->Clone();
+    ASSERT_EQ(new_engine->Dimension(), dimension);
+    ASSERT_EQ(new_engine->Count(), ids.size());
+    status = new_engine->CopyToCpu();
+    //ASSERT_TRUE(status.ok());
+
+    auto engine_build = new_engine->BuildIndex("/tmp/milvus_index_2", milvus::engine::EngineType::FAISS_IVFSQ8);
+    //ASSERT_TRUE(status.ok());
+}
diff --git a/core/unittest/db/test_mem.cpp b/core/unittest/db/test_mem.cpp
new file mode 100644
index 0000000000..e05811ff9e
--- /dev/null
+++ b/core/unittest/db/test_mem.cpp
@@ -0,0 +1,435 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "gtest/gtest.h"
+
+#include "db/insert/VectorSource.h"
+#include "db/insert/MemTableFile.h"
+#include "db/insert/MemTable.h"
+#include "db/Constants.h"
+#include "db/engine/EngineFactory.h"
+#include "db/meta/MetaConsts.h"
+#include "metrics/Metrics.h"
+#include "db/utils.h"
+
+#include <boost/filesystem.hpp>
+#include <thread>
+#include <fstream>
+#include <iostream>
+#include <cmath>
+#include <random>
+#include <chrono>
+
+namespace {
+
+static constexpr int64_t TABLE_DIM = 256;
+
+std::string
+GetTableName() {
+    auto now = std::chrono::system_clock::now();
+    auto micros = std::chrono::duration_cast<std::chrono::microseconds>(
+        now.time_since_epoch()).count();
+    static std::string table_name = std::to_string(micros);
+    return table_name;
+}
+
+milvus::engine::meta::TableSchema
+BuildTableSchema() {
+    milvus::engine::meta::TableSchema table_info;
+    table_info.dimension_ = TABLE_DIM;
+    table_info.table_id_ = GetTableName();
+    table_info.engine_type_ = (int)milvus::engine::EngineType::FAISS_IDMAP;
+    return table_info;
+}
+
+void
+BuildVectors(int64_t n, std::vector<float>& vectors) {
+    vectors.clear();
+    vectors.resize(n * TABLE_DIM);
+    float* data = vectors.data();
+    for (int i = 0; i < n; i++) {
+        for (int j = 0; j < TABLE_DIM; j++)
+            data[TABLE_DIM * i + j] = drand48();
+    }
+}
+} // namespace
+
+TEST_F(MemManagerTest, VECTOR_SOURCE_TEST) {
+    milvus::engine::meta::TableSchema table_schema = BuildTableSchema();
+    auto status = impl_->CreateTable(table_schema);
+    ASSERT_TRUE(status.ok());
+
+    milvus::engine::meta::TableFileSchema table_file_schema;
+    table_file_schema.table_id_ = GetTableName();
+    status = impl_->CreateTableFile(table_file_schema);
+    ASSERT_TRUE(status.ok());
+
+    int64_t n = 100;
+    std::vector<float> vectors;
+    BuildVectors(n, vectors);
+
+    milvus::engine::VectorSource source(n, vectors.data());
+
+    size_t num_vectors_added;
+    milvus::engine::ExecutionEnginePtr execution_engine_ =
+        milvus::engine::EngineFactory::Build(table_file_schema.dimension_,
+                                             table_file_schema.location_,
+                                             (milvus::engine::EngineType)table_file_schema.engine_type_,
+                                             (milvus::engine::MetricType)table_file_schema.metric_type_,
+                                             table_schema.nlist_);
+
+    milvus::engine::IDNumbers vector_ids;
+    status = source.Add(execution_engine_, table_file_schema, 50, num_vectors_added, vector_ids);
+    ASSERT_TRUE(status.ok());
+    vector_ids = source.GetVectorIds();
+    ASSERT_EQ(vector_ids.size(), 50);
+    ASSERT_EQ(num_vectors_added, 50);
+
+    vector_ids.clear();
+    status = source.Add(execution_engine_, table_file_schema, 60, num_vectors_added, vector_ids);
+    ASSERT_TRUE(status.ok());
+
+    ASSERT_EQ(num_vectors_added, 50);
+
+    vector_ids = source.GetVectorIds();
+    ASSERT_EQ(vector_ids.size(), 100);
+}
+
+TEST_F(MemManagerTest, MEM_TABLE_FILE_TEST) {
+    auto options = GetOptions();
+
+    milvus::engine::meta::TableSchema table_schema = BuildTableSchema();
+    auto status = impl_->CreateTable(table_schema);
+    ASSERT_TRUE(status.ok());
+
+    milvus::engine::MemTableFile mem_table_file(GetTableName(), impl_, options);
+
+    int64_t n_100 = 100;
+    std::vector<float> vectors_100;
+    BuildVectors(n_100, vectors_100);
+
+    milvus::engine::VectorSourcePtr source = std::make_shared<milvus::engine::VectorSource>(n_100, vectors_100.data());
+
+    milvus::engine::IDNumbers vector_ids;
+    status = mem_table_file.Add(source, vector_ids);
+    ASSERT_TRUE(status.ok());
+
+//    std::cout << mem_table_file.GetCurrentMem() << " " << mem_table_file.GetMemLeft() << std::endl;
+
+    vector_ids = source->GetVectorIds();
+    ASSERT_EQ(vector_ids.size(), 100);
+
+    size_t singleVectorMem = sizeof(float) * TABLE_DIM;
+    ASSERT_EQ(mem_table_file.GetCurrentMem(), n_100 * singleVectorMem);
+
+    int64_t n_max = milvus::engine::MAX_TABLE_FILE_MEM / singleVectorMem;
+    std::vector<float> vectors_128M;
+    BuildVectors(n_max, vectors_128M);
+
+    milvus::engine::VectorSourcePtr
+        source_128M = std::make_shared<milvus::engine::VectorSource>(n_max, vectors_128M.data());
+    vector_ids.clear();
+    status = mem_table_file.Add(source_128M, vector_ids);
+
+    vector_ids = source_128M->GetVectorIds();
+    ASSERT_EQ(vector_ids.size(), n_max - n_100);
+
+    ASSERT_TRUE(mem_table_file.IsFull());
+}
+
+TEST_F(MemManagerTest, MEM_TABLE_TEST) {
+    auto options = GetOptions();
+
+    milvus::engine::meta::TableSchema table_schema = BuildTableSchema();
+    auto status = impl_->CreateTable(table_schema);
+    ASSERT_TRUE(status.ok());
+
+    int64_t n_100 = 100;
+    std::vector<float> vectors_100;
+    BuildVectors(n_100, vectors_100);
+
+    milvus::engine::VectorSourcePtr
+        source_100 = std::make_shared<milvus::engine::VectorSource>(n_100, vectors_100.data());
+
+    milvus::engine::MemTable mem_table(GetTableName(), impl_, options);
+
+    milvus::engine::IDNumbers vector_ids;
+    status = mem_table.Add(source_100, vector_ids);
+    ASSERT_TRUE(status.ok());
+    vector_ids = source_100->GetVectorIds();
+    ASSERT_EQ(vector_ids.size(), 100);
+
+    milvus::engine::MemTableFilePtr mem_table_file;
+    mem_table.GetCurrentMemTableFile(mem_table_file);
+    size_t singleVectorMem = sizeof(float) * TABLE_DIM;
+    ASSERT_EQ(mem_table_file->GetCurrentMem(), n_100 * singleVectorMem);
+
+    int64_t n_max = milvus::engine::MAX_TABLE_FILE_MEM / singleVectorMem;
+    std::vector<float> vectors_128M;
+    BuildVectors(n_max, vectors_128M);
+
+    vector_ids.clear();
+    milvus::engine::VectorSourcePtr
+        source_128M = std::make_shared<milvus::engine::VectorSource>(n_max, vectors_128M.data());
+    status = mem_table.Add(source_128M, vector_ids);
+    ASSERT_TRUE(status.ok());
+
+    vector_ids = source_128M->GetVectorIds();
+    ASSERT_EQ(vector_ids.size(), n_max);
+
+    mem_table.GetCurrentMemTableFile(mem_table_file);
+    ASSERT_EQ(mem_table_file->GetCurrentMem(), n_100 * singleVectorMem);
+
+    ASSERT_EQ(mem_table.GetTableFileCount(), 2);
+
+    int64_t n_1G = 1024000;
+    std::vector<float> vectors_1G;
+    BuildVectors(n_1G, vectors_1G);
+
+    milvus::engine::VectorSourcePtr source_1G = std::make_shared<milvus::engine::VectorSource>(n_1G, vectors_1G.data());
+
+    vector_ids.clear();
+    status = mem_table.Add(source_1G, vector_ids);
+    ASSERT_TRUE(status.ok());
+
+    vector_ids = source_1G->GetVectorIds();
+    ASSERT_EQ(vector_ids.size(), n_1G);
+
+    int expectedTableFileCount = 2 + std::ceil((n_1G - n_100) * singleVectorMem / milvus::engine::MAX_TABLE_FILE_MEM);
+    ASSERT_EQ(mem_table.GetTableFileCount(), expectedTableFileCount);
+
+    status = mem_table.Serialize();
+    ASSERT_TRUE(status.ok());
+}
+
+TEST_F(MemManagerTest2, SERIAL_INSERT_SEARCH_TEST) {
+    milvus::engine::meta::TableSchema table_info = BuildTableSchema();
+    auto stat = db_->CreateTable(table_info);
+
+    milvus::engine::meta::TableSchema table_info_get;
+    table_info_get.table_id_ = GetTableName();
+    stat = db_->DescribeTable(table_info_get);
+    ASSERT_TRUE(stat.ok());
+    ASSERT_EQ(table_info_get.dimension_, TABLE_DIM);
+
+    int64_t nb = 100000;
+    std::vector<float> xb;
+    BuildVectors(nb, xb);
+
+    milvus::engine::IDNumbers vector_ids;
+    for (int64_t i = 0; i < nb; i++) {
+        vector_ids.push_back(i);
+    }
+
+    stat = db_->InsertVectors(GetTableName(), nb, xb.data(), vector_ids);
+    ASSERT_TRUE(stat.ok());
+
+    std::this_thread::sleep_for(std::chrono::seconds(3));//ensure raw data write to disk
+
+    std::random_device rd;
+    std::mt19937 gen(rd());
+    std::uniform_int_distribution<int64_t> dis(0, nb - 1);
+
+    int64_t num_query = 10;
+    std::map<int64_t, std::vector<float>> search_vectors;
+    for (int64_t i = 0; i < num_query; ++i) {
+        int64_t index = dis(gen);
+        std::vector<float> search;
+        for (int64_t j = 0; j < TABLE_DIM; j++) {
+            search.push_back(xb[index * TABLE_DIM + j]);
+        }
+        search_vectors.insert(std::make_pair(vector_ids[index], search));
+    }
+
+    int topk = 10, nprobe = 10;
+    for (auto& pair : search_vectors) {
+        auto& search = pair.second;
+        milvus::engine::QueryResults results;
+        stat = db_->Query(GetTableName(), topk, 1, nprobe, search.data(), results);
+        ASSERT_EQ(results[0][0].first, pair.first);
+        ASSERT_LT(results[0][0].second, 1e-4);
+    }
+}
+
+TEST_F(MemManagerTest2, INSERT_TEST) {
+    milvus::engine::meta::TableSchema table_info = BuildTableSchema();
+    auto stat = db_->CreateTable(table_info);
+
+    milvus::engine::meta::TableSchema table_info_get;
+    table_info_get.table_id_ = GetTableName();
+    stat = db_->DescribeTable(table_info_get);
+    ASSERT_TRUE(stat.ok());
+    ASSERT_EQ(table_info_get.dimension_, TABLE_DIM);
+
+    auto start_time = METRICS_NOW_TIME;
+
+    int insert_loop = 20;
+    for (int i = 0; i < insert_loop; ++i) {
+        int64_t nb = 40960;
+        std::vector<float> xb;
+        BuildVectors(nb, xb);
+        milvus::engine::IDNumbers vector_ids;
+        stat = db_->InsertVectors(GetTableName(), nb, xb.data(), vector_ids);
+        ASSERT_TRUE(stat.ok());
+    }
+    auto end_time = METRICS_NOW_TIME;
+    auto total_time = METRICS_MICROSECONDS(start_time, end_time);
+    LOG(DEBUG) << "total_time spent in INSERT_TEST (ms) : " << total_time;
+}
+
+TEST_F(MemManagerTest2, CONCURRENT_INSERT_SEARCH_TEST) {
+    milvus::engine::meta::TableSchema table_info = BuildTableSchema();
+    auto stat = db_->CreateTable(table_info);
+
+    milvus::engine::meta::TableSchema table_info_get;
+    table_info_get.table_id_ = GetTableName();
+    stat = db_->DescribeTable(table_info_get);
+    ASSERT_TRUE(stat.ok());
+    ASSERT_EQ(table_info_get.dimension_, TABLE_DIM);
+
+    milvus::engine::IDNumbers vector_ids;
+    milvus::engine::IDNumbers target_ids;
+
+    int64_t nb = 40960;
+    std::vector<float> xb;
+    BuildVectors(nb, xb);
+
+    int64_t qb = 5;
+    std::vector<float> qxb;
+    BuildVectors(qb, qxb);
+
+    std::thread search([&]() {
+        milvus::engine::QueryResults results;
+        int k = 10;
+        std::this_thread::sleep_for(std::chrono::seconds(2));
+
+        INIT_TIMER;
+        std::stringstream ss;
+        uint64_t count = 0;
+        uint64_t prev_count = 0;
+
+        for (auto j = 0; j < 10; ++j) {
+            ss.str("");
+            db_->Size(count);
+            prev_count = count;
+
+            START_TIMER;
+            stat = db_->Query(GetTableName(), k, qb, 10, qxb.data(), results);
+            ss << "Search " << j << " With Size " << count / milvus::engine::M << " M";
+            STOP_TIMER(ss.str());
+
+            ASSERT_TRUE(stat.ok());
+            for (auto k = 0; k < qb; ++k) {
+                ASSERT_EQ(results[k][0].first, target_ids[k]);
+                ss.str("");
+                ss << "Result [" << k << "]:";
+                for (auto result : results[k]) {
+                    ss << result.first << " ";
+                }
+                /* LOG(DEBUG) << ss.str(); */
+            }
+            ASSERT_TRUE(count >= prev_count);
+            std::this_thread::sleep_for(std::chrono::seconds(1));
+        }
+    });
+
+    int loop = 20;
+
+    for (auto i = 0; i < loop; ++i) {
+        if (i == 0) {
+            db_->InsertVectors(GetTableName(), qb, qxb.data(), target_ids);
+            ASSERT_EQ(target_ids.size(), qb);
+        } else {
+            db_->InsertVectors(GetTableName(), nb, xb.data(), vector_ids);
+        }
+        std::this_thread::sleep_for(std::chrono::microseconds(1));
+    }
+
+    search.join();
+}
+
+TEST_F(MemManagerTest2, VECTOR_IDS_TEST) {
+    milvus::engine::meta::TableSchema table_info = BuildTableSchema();
+    auto stat = db_->CreateTable(table_info);
+
+    milvus::engine::meta::TableSchema table_info_get;
+    table_info_get.table_id_ = GetTableName();
+    stat = db_->DescribeTable(table_info_get);
+    ASSERT_TRUE(stat.ok());
+    ASSERT_EQ(table_info_get.dimension_, TABLE_DIM);
+
+    milvus::engine::IDNumbers vector_ids;
+
+    int64_t nb = 100000;
+    std::vector<float> xb;
+    BuildVectors(nb, xb);
+
+    vector_ids.resize(nb);
+    for (auto i = 0; i < nb; i++) {
+        vector_ids[i] = i;
+    }
+
+    stat = db_->InsertVectors(GetTableName(), nb, xb.data(), vector_ids);
+    ASSERT_EQ(vector_ids[0], 0);
+    ASSERT_TRUE(stat.ok());
+
+    nb = 25000;
+    xb.clear();
+    BuildVectors(nb, xb);
+    vector_ids.clear();
+    vector_ids.resize(nb);
+    for (auto i = 0; i < nb; i++) {
+        vector_ids[i] = i + nb;
+    }
+    stat = db_->InsertVectors(GetTableName(), nb, xb.data(), vector_ids);
+    ASSERT_EQ(vector_ids[0], nb);
+    ASSERT_TRUE(stat.ok());
+
+    nb = 262144; //512M
+    xb.clear();
+    BuildVectors(nb, xb);
+    vector_ids.clear();
+    vector_ids.resize(nb);
+    for (auto i = 0; i < nb; i++) {
+        vector_ids[i] = i + nb / 2;
+    }
+    stat = db_->InsertVectors(GetTableName(), nb, xb.data(), vector_ids);
+    ASSERT_EQ(vector_ids[0], nb / 2);
+    ASSERT_TRUE(stat.ok());
+
+    nb = 65536; //128M
+    xb.clear();
+    BuildVectors(nb, xb);
+    vector_ids.clear();
+    stat = db_->InsertVectors(GetTableName(), nb, xb.data(), vector_ids);
+    ASSERT_TRUE(stat.ok());
+
+    nb = 100;
+    xb.clear();
+    BuildVectors(nb, xb);
+    vector_ids.clear();
+    vector_ids.resize(nb);
+    for (auto i = 0; i < nb; i++) {
+        vector_ids[i] = i + nb;
+    }
+    stat = db_->InsertVectors(GetTableName(), nb, xb.data(), vector_ids);
+    for (auto i = 0; i < nb; i++) {
+        ASSERT_EQ(vector_ids[i], i + nb);
+    }
+}
+
diff --git a/core/unittest/db/test_meta.cpp b/core/unittest/db/test_meta.cpp
new file mode 100644
index 0000000000..e2a9c98089
--- /dev/null
+++ b/core/unittest/db/test_meta.cpp
@@ -0,0 +1,387 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "db/utils.h"
+#include "db/meta/SqliteMetaImpl.h"
+#include "db/Utils.h"
+#include "db/Constants.h"
+#include "db/meta/MetaConsts.h"
+
+#include <gtest/gtest.h>
+#include <thread>
+#include <stdlib.h>
+#include <time.h>
+
+TEST_F(MetaTest, TABLE_TEST) {
+    auto table_id = "meta_test_table";
+
+    milvus::engine::meta::TableSchema table;
+    table.table_id_ = table_id;
+    auto status = impl_->CreateTable(table);
+    ASSERT_TRUE(status.ok());
+
+    auto gid = table.id_;
+    table.id_ = -1;
+    status = impl_->DescribeTable(table);
+    ASSERT_TRUE(status.ok());
+    ASSERT_EQ(table.id_, gid);
+    ASSERT_EQ(table.table_id_, table_id);
+
+    table.table_id_ = "not_found";
+    status = impl_->DescribeTable(table);
+    ASSERT_TRUE(!status.ok());
+
+    table.table_id_ = table_id;
+    status = impl_->CreateTable(table);
+    ASSERT_EQ(status.code(), milvus::DB_ALREADY_EXIST);
+
+    table.table_id_ = "";
+    status = impl_->CreateTable(table);
+    ASSERT_TRUE(status.ok());
+}
+
+TEST_F(MetaTest, TABLE_FILE_TEST) {
+    auto table_id = "meta_test_table";
+
+    milvus::engine::meta::TableSchema table;
+    table.table_id_ = table_id;
+    table.dimension_ = 256;
+    auto status = impl_->CreateTable(table);
+
+    milvus::engine::meta::TableFileSchema table_file;
+    table_file.table_id_ = table.table_id_;
+    status = impl_->CreateTableFile(table_file);
+    ASSERT_TRUE(status.ok());
+    ASSERT_EQ(table_file.file_type_, milvus::engine::meta::TableFileSchema::NEW);
+
+    uint64_t cnt = 0;
+    status = impl_->Count(table_id, cnt);
+    ASSERT_TRUE(status.ok());
+    ASSERT_EQ(cnt, 0UL);
+
+    auto file_id = table_file.file_id_;
+
+    auto new_file_type = milvus::engine::meta::TableFileSchema::INDEX;
+    table_file.file_type_ = new_file_type;
+
+    status = impl_->UpdateTableFile(table_file);
+    ASSERT_TRUE(status.ok());
+    ASSERT_EQ(table_file.file_type_, new_file_type);
+
+    milvus::engine::meta::DatesT dates;
+    dates.push_back(milvus::engine::utils::GetDate());
+    status = impl_->DropPartitionsByDates(table_file.table_id_, dates);
+    ASSERT_TRUE(status.ok());
+
+    dates.clear();
+    for (auto i = 2; i < 10; ++i) {
+        dates.push_back(milvus::engine::utils::GetDateWithDelta(-1 * i));
+    }
+    status = impl_->DropPartitionsByDates(table_file.table_id_, dates);
+    ASSERT_TRUE(status.ok());
+
+    table_file.date_ = milvus::engine::utils::GetDateWithDelta(-2);
+    status = impl_->UpdateTableFile(table_file);
+    ASSERT_TRUE(status.ok());
+    ASSERT_EQ(table_file.date_, milvus::engine::utils::GetDateWithDelta(-2));
+    ASSERT_FALSE(table_file.file_type_ == milvus::engine::meta::TableFileSchema::TO_DELETE);
+
+    dates.clear();
+    dates.push_back(table_file.date_);
+    status = impl_->DropPartitionsByDates(table_file.table_id_, dates);
+    ASSERT_TRUE(status.ok());
+
+    std::vector<size_t> ids = {table_file.id_};
+    milvus::engine::meta::TableFilesSchema files;
+    status = impl_->GetTableFiles(table_file.table_id_, ids, files);
+    ASSERT_TRUE(status.ok());
+    ASSERT_EQ(files.size(), 0UL);
+}
+
+TEST_F(MetaTest, ARCHIVE_TEST_DAYS) {
+    srand(time(0));
+    milvus::engine::DBMetaOptions options;
+    options.path_ = "/tmp/milvus_test";
+    unsigned int seed = 1;
+    int days_num = rand_r(&seed) % 100;
+    std::stringstream ss;
+    ss << "days:" << days_num;
+    options.archive_conf_ = milvus::engine::ArchiveConf("delete", ss.str());
+
+    milvus::engine::meta::SqliteMetaImpl impl(options);
+    auto table_id = "meta_test_table";
+
+    milvus::engine::meta::TableSchema table;
+    table.table_id_ = table_id;
+    auto status = impl.CreateTable(table);
+
+    milvus::engine::meta::TableFilesSchema files;
+    milvus::engine::meta::TableFileSchema table_file;
+    table_file.table_id_ = table.table_id_;
+
+    auto cnt = 100;
+    int64_t ts = milvus::engine::utils::GetMicroSecTimeStamp();
+    std::vector<int> days;
+    std::vector<size_t> ids;
+    for (auto i = 0; i < cnt; ++i) {
+        status = impl.CreateTableFile(table_file);
+        table_file.file_type_ = milvus::engine::meta::TableFileSchema::NEW;
+        int day = rand_r(&seed) % (days_num * 2);
+        table_file.created_on_ = ts - day * milvus::engine::meta::D_SEC * milvus::engine::meta::US_PS - 10000;
+        status = impl.UpdateTableFile(table_file);
+        files.push_back(table_file);
+        days.push_back(day);
+        ids.push_back(table_file.id_);
+    }
+
+    impl.Archive();
+    int i = 0;
+
+    milvus::engine::meta::TableFilesSchema files_get;
+    status = impl.GetTableFiles(table_file.table_id_, ids, files_get);
+    ASSERT_TRUE(status.ok());
+
+    for (auto &file : files_get) {
+        if (days[i] < days_num) {
+            ASSERT_EQ(file.file_type_, milvus::engine::meta::TableFileSchema::NEW);
+        }
+        i++;
+    }
+
+    impl.DropAll();
+}
+
+TEST_F(MetaTest, ARCHIVE_TEST_DISK) {
+    milvus::engine::DBMetaOptions options;
+    options.path_ = "/tmp/milvus_test";
+    options.archive_conf_ = milvus::engine::ArchiveConf("delete", "disk:11");
+
+    milvus::engine::meta::SqliteMetaImpl impl(options);
+    auto table_id = "meta_test_group";
+
+    milvus::engine::meta::TableSchema table;
+    table.table_id_ = table_id;
+    auto status = impl.CreateTable(table);
+
+    milvus::engine::meta::TableFilesSchema files;
+    milvus::engine::meta::TableFileSchema table_file;
+    table_file.table_id_ = table.table_id_;
+
+    auto cnt = 10;
+    auto each_size = 2UL;
+    std::vector<size_t> ids;
+    for (auto i = 0; i < cnt; ++i) {
+        status = impl.CreateTableFile(table_file);
+        table_file.file_type_ = milvus::engine::meta::TableFileSchema::NEW;
+        table_file.file_size_ = each_size * milvus::engine::G;
+        status = impl.UpdateTableFile(table_file);
+        files.push_back(table_file);
+        ids.push_back(table_file.id_);
+    }
+
+    impl.Archive();
+    int i = 0;
+
+    milvus::engine::meta::TableFilesSchema files_get;
+    status = impl.GetTableFiles(table_file.table_id_, ids, files_get);
+    ASSERT_TRUE(status.ok());
+
+    for (auto &file : files_get) {
+        if (i >= 5) {
+            ASSERT_EQ(file.file_type_, milvus::engine::meta::TableFileSchema::NEW);
+        }
+        ++i;
+    }
+
+    impl.DropAll();
+}
+
+TEST_F(MetaTest, TABLE_FILES_TEST) {
+    auto table_id = "meta_test_group";
+
+    milvus::engine::meta::TableSchema table;
+    table.table_id_ = table_id;
+    auto status = impl_->CreateTable(table);
+
+    uint64_t new_merge_files_cnt = 1;
+    uint64_t new_index_files_cnt = 2;
+    uint64_t backup_files_cnt = 3;
+    uint64_t new_files_cnt = 4;
+    uint64_t raw_files_cnt = 5;
+    uint64_t to_index_files_cnt = 6;
+    uint64_t index_files_cnt = 7;
+
+    milvus::engine::meta::TableFileSchema table_file;
+    table_file.table_id_ = table.table_id_;
+
+    for (auto i = 0; i < new_merge_files_cnt; ++i) {
+        status = impl_->CreateTableFile(table_file);
+        table_file.file_type_ = milvus::engine::meta::TableFileSchema::NEW_MERGE;
+        status = impl_->UpdateTableFile(table_file);
+    }
+
+    for (auto i = 0; i < new_index_files_cnt; ++i) {
+        status = impl_->CreateTableFile(table_file);
+        table_file.file_type_ = milvus::engine::meta::TableFileSchema::NEW_INDEX;
+        status = impl_->UpdateTableFile(table_file);
+    }
+
+    for (auto i = 0; i < backup_files_cnt; ++i) {
+        status = impl_->CreateTableFile(table_file);
+        table_file.file_type_ = milvus::engine::meta::TableFileSchema::BACKUP;
+        table_file.row_count_ = 1;
+        status = impl_->UpdateTableFile(table_file);
+    }
+
+    for (auto i = 0; i < new_files_cnt; ++i) {
+        status = impl_->CreateTableFile(table_file);
+        table_file.file_type_ = milvus::engine::meta::TableFileSchema::NEW;
+        status = impl_->UpdateTableFile(table_file);
+    }
+
+    for (auto i = 0; i < raw_files_cnt; ++i) {
+        status = impl_->CreateTableFile(table_file);
+        table_file.file_type_ = milvus::engine::meta::TableFileSchema::RAW;
+        table_file.row_count_ = 1;
+        status = impl_->UpdateTableFile(table_file);
+    }
+
+    for (auto i = 0; i < to_index_files_cnt; ++i) {
+        status = impl_->CreateTableFile(table_file);
+        table_file.file_type_ = milvus::engine::meta::TableFileSchema::TO_INDEX;
+        table_file.row_count_ = 1;
+        status = impl_->UpdateTableFile(table_file);
+    }
+
+    for (auto i = 0; i < index_files_cnt; ++i) {
+        status = impl_->CreateTableFile(table_file);
+        table_file.file_type_ = milvus::engine::meta::TableFileSchema::INDEX;
+        table_file.row_count_ = 1;
+        status = impl_->UpdateTableFile(table_file);
+    }
+
+    uint64_t total_row_count = 0;
+    status = impl_->Count(table_id, total_row_count);
+    ASSERT_TRUE(status.ok());
+    ASSERT_EQ(total_row_count, raw_files_cnt + to_index_files_cnt + index_files_cnt);
+
+    milvus::engine::meta::TableFilesSchema files;
+    status = impl_->FilesToIndex(files);
+    ASSERT_EQ(files.size(), to_index_files_cnt);
+
+    milvus::engine::meta::DatePartionedTableFilesSchema dated_files;
+    status = impl_->FilesToMerge(table.table_id_, dated_files);
+    ASSERT_EQ(dated_files[table_file.date_].size(), raw_files_cnt);
+
+    status = impl_->FilesToIndex(files);
+    ASSERT_EQ(files.size(), to_index_files_cnt);
+
+    milvus::engine::meta::DatesT dates = {table_file.date_};
+    std::vector<size_t> ids;
+    status = impl_->FilesToSearch(table_id, ids, dates, dated_files);
+    ASSERT_EQ(dated_files[table_file.date_].size(),
+              to_index_files_cnt + raw_files_cnt + index_files_cnt);
+
+    status = impl_->FilesToSearch(table_id, ids, milvus::engine::meta::DatesT(), dated_files);
+    ASSERT_EQ(dated_files[table_file.date_].size(),
+              to_index_files_cnt + raw_files_cnt + index_files_cnt);
+
+    status = impl_->FilesToSearch(table_id, ids, milvus::engine::meta::DatesT(), dated_files);
+    ASSERT_EQ(dated_files[table_file.date_].size(),
+              to_index_files_cnt + raw_files_cnt + index_files_cnt);
+
+    ids.push_back(size_t(9999999999));
+    status = impl_->FilesToSearch(table_id, ids, dates, dated_files);
+    ASSERT_EQ(dated_files[table_file.date_].size(), 0);
+
+    std::vector<int> file_types;
+    std::vector<std::string> file_ids;
+    status = impl_->FilesByType(table.table_id_, file_types, file_ids);
+    ASSERT_TRUE(file_ids.empty());
+    ASSERT_FALSE(status.ok());
+
+    file_types = {
+        milvus::engine::meta::TableFileSchema::NEW,
+        milvus::engine::meta::TableFileSchema::NEW_MERGE,
+        milvus::engine::meta::TableFileSchema::NEW_INDEX,
+        milvus::engine::meta::TableFileSchema::TO_INDEX,
+        milvus::engine::meta::TableFileSchema::INDEX,
+        milvus::engine::meta::TableFileSchema::RAW,
+        milvus::engine::meta::TableFileSchema::BACKUP,
+    };
+    status = impl_->FilesByType(table.table_id_, file_types, file_ids);
+    ASSERT_TRUE(status.ok());
+    uint64_t total_cnt = new_index_files_cnt + new_merge_files_cnt +
+        backup_files_cnt + new_files_cnt + raw_files_cnt +
+        to_index_files_cnt + index_files_cnt;
+    ASSERT_EQ(file_ids.size(), total_cnt);
+
+    status = impl_->DeleteTableFiles(table_id);
+    ASSERT_TRUE(status.ok());
+
+    status = impl_->CreateTableFile(table_file);
+    table_file.file_type_ = milvus::engine::meta::TableFileSchema::NEW;
+    status = impl_->UpdateTableFile(table_file);
+    status = impl_->CleanUp();
+    ASSERT_TRUE(status.ok());
+
+    status = impl_->DeleteTable(table_id);
+    ASSERT_TRUE(status.ok());
+
+    status = impl_->CleanUpFilesWithTTL(1UL);
+    ASSERT_TRUE(status.ok());
+}
+
+TEST_F(MetaTest, INDEX_TEST) {
+    auto table_id = "index_test";
+
+    milvus::engine::meta::TableSchema table;
+    table.table_id_ = table_id;
+    auto status = impl_->CreateTable(table);
+
+    milvus::engine::TableIndex index;
+    index.metric_type_ = 2;
+    index.nlist_ = 1234;
+    index.engine_type_ = 3;
+    status = impl_->UpdateTableIndex(table_id, index);
+    ASSERT_TRUE(status.ok());
+
+    int64_t flag = 65536;
+    status = impl_->UpdateTableFlag(table_id, flag);
+    ASSERT_TRUE(status.ok());
+
+    milvus::engine::meta::TableSchema table_info;
+    table_info.table_id_ = table_id;
+    status = impl_->DescribeTable(table_info);
+    ASSERT_EQ(table_info.flag_, flag);
+
+    milvus::engine::TableIndex index_out;
+    status = impl_->DescribeTableIndex(table_id, index_out);
+    ASSERT_EQ(index_out.metric_type_, index.metric_type_);
+    ASSERT_EQ(index_out.nlist_, index.nlist_);
+    ASSERT_EQ(index_out.engine_type_, index.engine_type_);
+
+    status = impl_->DropTableIndex(table_id);
+    ASSERT_TRUE(status.ok());
+    status = impl_->DescribeTableIndex(table_id, index_out);
+    ASSERT_NE(index_out.metric_type_, index.metric_type_);
+    ASSERT_NE(index_out.nlist_, index.nlist_);
+    ASSERT_NE(index_out.engine_type_, index.engine_type_);
+
+    status = impl_->UpdateTableFilesToIndex(table_id);
+    ASSERT_TRUE(status.ok());
+}
diff --git a/core/unittest/db/test_meta_mysql.cpp b/core/unittest/db/test_meta_mysql.cpp
new file mode 100644
index 0000000000..a3259e5645
--- /dev/null
+++ b/core/unittest/db/test_meta_mysql.cpp
@@ -0,0 +1,401 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "db/utils.h"
+#include "db/meta/MySQLMetaImpl.h"
+#include "db/Utils.h"
+#include "db/meta/MetaConsts.h"
+
+#include <iostream>
+#include <thread>
+#include <stdlib.h>
+#include <time.h>
+#include <gtest/gtest.h>
+#include <mysql++/mysql++.h>
+
+TEST_F(MySqlMetaTest, TABLE_TEST) {
+    auto table_id = "meta_test_table";
+
+    milvus::engine::meta::TableSchema table;
+    table.table_id_ = table_id;
+    auto status = impl_->CreateTable(table);
+    ASSERT_TRUE(status.ok());
+
+    auto gid = table.id_;
+    table.id_ = -1;
+    status = impl_->DescribeTable(table);
+    ASSERT_TRUE(status.ok());
+    ASSERT_EQ(table.id_, gid);
+    ASSERT_EQ(table.table_id_, table_id);
+
+    table.table_id_ = "not_found";
+    status = impl_->DescribeTable(table);
+    ASSERT_TRUE(!status.ok());
+
+    table.table_id_ = table_id;
+    status = impl_->CreateTable(table);
+    ASSERT_EQ(status.code(), milvus::DB_ALREADY_EXIST);
+
+    table.table_id_ = "";
+    status = impl_->CreateTable(table);
+//    ASSERT_TRUE(status.ok());
+
+    status = impl_->DropAll();
+    ASSERT_TRUE(status.ok());
+}
+
+TEST_F(MySqlMetaTest, TABLE_FILE_TEST) {
+    auto table_id = "meta_test_table";
+
+    milvus::engine::meta::TableSchema table;
+    table.table_id_ = table_id;
+    table.dimension_ = 256;
+    auto status = impl_->CreateTable(table);
+
+    milvus::engine::meta::TableFileSchema table_file;
+    table_file.table_id_ = table.table_id_;
+    status = impl_->CreateTableFile(table_file);
+    ASSERT_TRUE(status.ok());
+    ASSERT_EQ(table_file.file_type_, milvus::engine::meta::TableFileSchema::NEW);
+
+    milvus::engine::meta::DatesT dates;
+    dates.push_back(milvus::engine::utils::GetDate());
+    status = impl_->DropPartitionsByDates(table_file.table_id_, dates);
+    ASSERT_TRUE(status.ok());
+
+    uint64_t cnt = 0;
+    status = impl_->Count(table_id, cnt);
+//    ASSERT_TRUE(status.ok());
+//    ASSERT_EQ(cnt, 0UL);
+
+    auto file_id = table_file.file_id_;
+
+    auto new_file_type = milvus::engine::meta::TableFileSchema::INDEX;
+    table_file.file_type_ = new_file_type;
+
+    status = impl_->UpdateTableFile(table_file);
+    ASSERT_TRUE(status.ok());
+    ASSERT_EQ(table_file.file_type_, new_file_type);
+
+    dates.clear();
+    for (auto i = 2; i < 10; ++i) {
+        dates.push_back(milvus::engine::utils::GetDateWithDelta(-1 * i));
+    }
+    status = impl_->DropPartitionsByDates(table_file.table_id_, dates);
+    ASSERT_TRUE(status.ok());
+
+    table_file.date_ = milvus::engine::utils::GetDateWithDelta(-2);
+    status = impl_->UpdateTableFile(table_file);
+    ASSERT_TRUE(status.ok());
+    ASSERT_EQ(table_file.date_, milvus::engine::utils::GetDateWithDelta(-2));
+    ASSERT_FALSE(table_file.file_type_ == milvus::engine::meta::TableFileSchema::TO_DELETE);
+
+    dates.clear();
+    dates.push_back(table_file.date_);
+    status = impl_->DropPartitionsByDates(table_file.table_id_, dates);
+    ASSERT_TRUE(status.ok());
+
+    std::vector<size_t> ids = {table_file.id_};
+    milvus::engine::meta::TableFilesSchema files;
+    status = impl_->GetTableFiles(table_file.table_id_, ids, files);
+    ASSERT_EQ(files.size(), 0UL);
+}
+
+TEST_F(MySqlMetaTest, ARCHIVE_TEST_DAYS) {
+    srand(time(0));
+    milvus::engine::DBMetaOptions options = GetOptions().meta_;
+
+    unsigned int seed = 1;
+    int days_num = rand_r(&seed) % 100;
+    std::stringstream ss;
+    ss << "days:" << days_num;
+    options.archive_conf_ = milvus::engine::ArchiveConf("delete", ss.str());
+    int mode = milvus::engine::DBOptions::MODE::SINGLE;
+    milvus::engine::meta::MySQLMetaImpl impl(options, mode);
+
+    auto table_id = "meta_test_table";
+
+    milvus::engine::meta::TableSchema table;
+    table.table_id_ = table_id;
+    auto status = impl.CreateTable(table);
+
+    milvus::engine::meta::TableFilesSchema files;
+    milvus::engine::meta::TableFileSchema table_file;
+    table_file.table_id_ = table.table_id_;
+
+    auto cnt = 100;
+    int64_t ts = milvus::engine::utils::GetMicroSecTimeStamp();
+    std::vector<int> days;
+    std::vector<size_t> ids;
+    for (auto i = 0; i < cnt; ++i) {
+        status = impl.CreateTableFile(table_file);
+        table_file.file_type_ = milvus::engine::meta::TableFileSchema::NEW;
+        int day = rand_r(&seed) % (days_num * 2);
+        table_file.created_on_ = ts - day * milvus::engine::meta::D_SEC * milvus::engine::meta::US_PS - 10000;
+        status = impl.UpdateTableFile(table_file);
+        files.push_back(table_file);
+        days.push_back(day);
+        ids.push_back(table_file.id_);
+    }
+
+    impl.Archive();
+    int i = 0;
+
+    milvus::engine::meta::TableFilesSchema files_get;
+    status = impl.GetTableFiles(table_file.table_id_, ids, files_get);
+    ASSERT_TRUE(status.ok());
+
+    for (auto &file : files_get) {
+        if (days[i] < days_num) {
+            ASSERT_EQ(file.file_type_, milvus::engine::meta::TableFileSchema::NEW);
+        }
+        i++;
+    }
+
+    std::vector<int> file_types = {
+        (int) milvus::engine::meta::TableFileSchema::NEW,
+    };
+    std::vector<std::string> file_ids;
+    status = impl.FilesByType(table_id, file_types, file_ids);
+    ASSERT_FALSE(file_ids.empty());
+
+    status = impl.UpdateTableFilesToIndex(table_id);
+    ASSERT_TRUE(status.ok());
+
+    status = impl.DropAll();
+    ASSERT_TRUE(status.ok());
+}
+
+TEST_F(MySqlMetaTest, ARCHIVE_TEST_DISK) {
+    milvus::engine::DBMetaOptions options = GetOptions().meta_;
+
+    options.archive_conf_ = milvus::engine::ArchiveConf("delete", "disk:11");
+    int mode = milvus::engine::DBOptions::MODE::SINGLE;
+    auto impl = milvus::engine::meta::MySQLMetaImpl(options, mode);
+    auto table_id = "meta_test_group";
+
+    milvus::engine::meta::TableSchema table;
+    table.table_id_ = table_id;
+    auto status = impl.CreateTable(table);
+
+    milvus::engine::meta::TableSchema table_schema;
+    table_schema.table_id_ = "";
+    status = impl.CreateTable(table_schema);
+
+    milvus::engine::meta::TableFilesSchema files;
+    milvus::engine::meta::TableFileSchema table_file;
+    table_file.table_id_ = table.table_id_;
+
+    auto cnt = 10;
+    auto each_size = 2UL;
+    std::vector<size_t> ids;
+    for (auto i = 0; i < cnt; ++i) {
+        status = impl.CreateTableFile(table_file);
+        table_file.file_type_ = milvus::engine::meta::TableFileSchema::NEW;
+        table_file.file_size_ = each_size * milvus::engine::G;
+        status = impl.UpdateTableFile(table_file);
+        files.push_back(table_file);
+        ids.push_back(table_file.id_);
+    }
+
+    impl.Archive();
+    int i = 0;
+
+    milvus::engine::meta::TableFilesSchema files_get;
+    status = impl.GetTableFiles(table_file.table_id_, ids, files_get);
+    ASSERT_TRUE(status.ok());
+
+    for (auto &file : files_get) {
+        if (i >= 5) {
+            ASSERT_EQ(file.file_type_, milvus::engine::meta::TableFileSchema::NEW);
+        }
+        ++i;
+    }
+
+    status = impl.DropAll();
+    ASSERT_TRUE(status.ok());
+}
+
+TEST_F(MySqlMetaTest, TABLE_FILES_TEST) {
+    auto table_id = "meta_test_group";
+
+    milvus::engine::meta::TableSchema table;
+    table.table_id_ = table_id;
+    auto status = impl_->CreateTable(table);
+
+    uint64_t new_merge_files_cnt = 1;
+    uint64_t new_index_files_cnt = 2;
+    uint64_t backup_files_cnt = 3;
+    uint64_t new_files_cnt = 4;
+    uint64_t raw_files_cnt = 5;
+    uint64_t to_index_files_cnt = 6;
+    uint64_t index_files_cnt = 7;
+
+    milvus::engine::meta::TableFileSchema table_file;
+    table_file.table_id_ = table.table_id_;
+
+    for (auto i = 0; i < new_merge_files_cnt; ++i) {
+        status = impl_->CreateTableFile(table_file);
+        table_file.file_type_ = milvus::engine::meta::TableFileSchema::NEW_MERGE;
+        status = impl_->UpdateTableFile(table_file);
+    }
+
+    for (auto i = 0; i < new_index_files_cnt; ++i) {
+        status = impl_->CreateTableFile(table_file);
+        table_file.file_type_ = milvus::engine::meta::TableFileSchema::NEW_INDEX;
+        status = impl_->UpdateTableFile(table_file);
+    }
+
+    for (auto i = 0; i < backup_files_cnt; ++i) {
+        status = impl_->CreateTableFile(table_file);
+        table_file.file_type_ = milvus::engine::meta::TableFileSchema::BACKUP;
+        table_file.row_count_ = 1;
+        status = impl_->UpdateTableFile(table_file);
+    }
+
+    for (auto i = 0; i < new_files_cnt; ++i) {
+        status = impl_->CreateTableFile(table_file);
+        table_file.file_type_ = milvus::engine::meta::TableFileSchema::NEW;
+        status = impl_->UpdateTableFile(table_file);
+    }
+
+    for (auto i = 0; i < raw_files_cnt; ++i) {
+        status = impl_->CreateTableFile(table_file);
+        table_file.file_type_ = milvus::engine::meta::TableFileSchema::RAW;
+        table_file.row_count_ = 1;
+        status = impl_->UpdateTableFile(table_file);
+    }
+
+    for (auto i = 0; i < to_index_files_cnt; ++i) {
+        status = impl_->CreateTableFile(table_file);
+        table_file.file_type_ = milvus::engine::meta::TableFileSchema::TO_INDEX;
+        table_file.row_count_ = 1;
+        status = impl_->UpdateTableFile(table_file);
+    }
+
+    for (auto i = 0; i < index_files_cnt; ++i) {
+        status = impl_->CreateTableFile(table_file);
+        table_file.file_type_ = milvus::engine::meta::TableFileSchema::INDEX;
+        table_file.row_count_ = 1;
+        status = impl_->UpdateTableFile(table_file);
+    }
+
+    uint64_t total_row_count = 0;
+    status = impl_->Count(table_id, total_row_count);
+    ASSERT_TRUE(status.ok());
+    ASSERT_EQ(total_row_count, raw_files_cnt + to_index_files_cnt + index_files_cnt);
+
+    milvus::engine::meta::TableFilesSchema files;
+    status = impl_->FilesToIndex(files);
+    ASSERT_EQ(files.size(), to_index_files_cnt);
+
+    milvus::engine::meta::DatePartionedTableFilesSchema dated_files;
+    status = impl_->FilesToMerge(table.table_id_, dated_files);
+    ASSERT_EQ(dated_files[table_file.date_].size(), raw_files_cnt);
+
+    status = impl_->FilesToIndex(files);
+    ASSERT_EQ(files.size(), to_index_files_cnt);
+
+    milvus::engine::meta::DatesT dates = {table_file.date_};
+    std::vector<size_t> ids;
+    status = impl_->FilesToSearch(table_id, ids, dates, dated_files);
+    ASSERT_EQ(dated_files[table_file.date_].size(),
+              to_index_files_cnt + raw_files_cnt + index_files_cnt);
+
+    status = impl_->FilesToSearch(table_id, ids, milvus::engine::meta::DatesT(), dated_files);
+    ASSERT_EQ(dated_files[table_file.date_].size(),
+              to_index_files_cnt + raw_files_cnt + index_files_cnt);
+
+    status = impl_->FilesToSearch(table_id, ids, milvus::engine::meta::DatesT(), dated_files);
+    ASSERT_EQ(dated_files[table_file.date_].size(),
+              to_index_files_cnt + raw_files_cnt + index_files_cnt);
+
+    ids.push_back(size_t(9999999999));
+    status = impl_->FilesToSearch(table_id, ids, dates, dated_files);
+    ASSERT_EQ(dated_files[table_file.date_].size(), 0);
+
+    std::vector<int> file_types;
+    std::vector<std::string> file_ids;
+    status = impl_->FilesByType(table.table_id_, file_types, file_ids);
+    ASSERT_TRUE(file_ids.empty());
+    ASSERT_FALSE(status.ok());
+
+    file_types = {
+        milvus::engine::meta::TableFileSchema::NEW,
+        milvus::engine::meta::TableFileSchema::NEW_MERGE,
+        milvus::engine::meta::TableFileSchema::NEW_INDEX,
+        milvus::engine::meta::TableFileSchema::TO_INDEX,
+        milvus::engine::meta::TableFileSchema::INDEX,
+        milvus::engine::meta::TableFileSchema::RAW,
+        milvus::engine::meta::TableFileSchema::BACKUP,
+    };
+    status = impl_->FilesByType(table.table_id_, file_types, file_ids);
+    ASSERT_TRUE(status.ok());
+    uint64_t total_cnt = new_index_files_cnt + new_merge_files_cnt +
+        backup_files_cnt + new_files_cnt + raw_files_cnt +
+        to_index_files_cnt + index_files_cnt;
+    ASSERT_EQ(file_ids.size(), total_cnt);
+
+    status = impl_->DeleteTableFiles(table_id);
+    ASSERT_TRUE(status.ok());
+
+    status = impl_->DeleteTable(table_id);
+    ASSERT_TRUE(status.ok());
+
+    status = impl_->CleanUpFilesWithTTL(0UL);
+    ASSERT_TRUE(status.ok());
+}
+
+TEST_F(MySqlMetaTest, INDEX_TEST) {
+    auto table_id = "index_test";
+
+    milvus::engine::meta::TableSchema table;
+    table.table_id_ = table_id;
+    auto status = impl_->CreateTable(table);
+
+    milvus::engine::TableIndex index;
+    index.metric_type_ = 2;
+    index.nlist_ = 1234;
+    index.engine_type_ = 3;
+    status = impl_->UpdateTableIndex(table_id, index);
+    ASSERT_TRUE(status.ok());
+
+    int64_t flag = 65536;
+    status = impl_->UpdateTableFlag(table_id, flag);
+    ASSERT_TRUE(status.ok());
+
+    milvus::engine::meta::TableSchema table_info;
+    table_info.table_id_ = table_id;
+    status = impl_->DescribeTable(table_info);
+    ASSERT_EQ(table_info.flag_, flag);
+
+    milvus::engine::TableIndex index_out;
+    status = impl_->DescribeTableIndex(table_id, index_out);
+    ASSERT_EQ(index_out.metric_type_, index.metric_type_);
+    ASSERT_EQ(index_out.nlist_, index.nlist_);
+    ASSERT_EQ(index_out.engine_type_, index.engine_type_);
+
+    status = impl_->DropTableIndex(table_id);
+    ASSERT_TRUE(status.ok());
+    status = impl_->DescribeTableIndex(table_id, index_out);
+    ASSERT_NE(index_out.metric_type_, index.metric_type_);
+    ASSERT_NE(index_out.nlist_, index.nlist_);
+    ASSERT_NE(index_out.engine_type_, index.engine_type_);
+
+    status = impl_->UpdateTableFilesToIndex(table_id);
+    ASSERT_TRUE(status.ok());
+}
diff --git a/core/unittest/db/test_misc.cpp b/core/unittest/db/test_misc.cpp
new file mode 100644
index 0000000000..f63afc1b27
--- /dev/null
+++ b/core/unittest/db/test_misc.cpp
@@ -0,0 +1,124 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "db/Options.h"
+#include "db/meta/SqliteMetaImpl.h"
+#include "db/engine/EngineFactory.h"
+#include "db/Utils.h"
+#include "utils/Status.h"
+#include "utils/Exception.h"
+
+#include <gtest/gtest.h>
+#include <thread>
+#include <boost/filesystem.hpp>
+#include <vector>
+
+TEST(DBMiscTest, EXCEPTION_TEST) {
+    milvus::Exception ex1(100, "error");
+    std::string what = ex1.what();
+    ASSERT_EQ(what, "error");
+    ASSERT_EQ(ex1.code(), 100);
+
+    milvus::InvalidArgumentException ex2;
+    ASSERT_EQ(ex2.code(), milvus::SERVER_INVALID_ARGUMENT);
+}
+
+TEST(DBMiscTest, OPTIONS_TEST) {
+    try {
+        milvus::engine::ArchiveConf archive("$$##");
+    } catch (std::exception &ex) {
+        ASSERT_TRUE(true);
+    }
+
+    {
+        milvus::engine::ArchiveConf archive("delete", "no");
+        ASSERT_TRUE(archive.GetCriterias().empty());
+    }
+
+    {
+        milvus::engine::ArchiveConf archive("delete", "1:2");
+        ASSERT_TRUE(archive.GetCriterias().empty());
+    }
+
+    {
+        milvus::engine::ArchiveConf archive("delete", "1:2:3");
+        ASSERT_TRUE(archive.GetCriterias().empty());
+    }
+
+    {
+        milvus::engine::ArchiveConf archive("delete");
+        milvus::engine::ArchiveConf::CriteriaT criterial = {
+            {"disk", 1024},
+            {"days", 100}
+        };
+        archive.SetCriterias(criterial);
+
+        auto crit = archive.GetCriterias();
+        ASSERT_EQ(criterial["disk"], 1024);
+        ASSERT_EQ(criterial["days"], 100);
+    }
+}
+
+TEST(DBMiscTest, META_TEST) {
+    milvus::engine::DBMetaOptions options;
+    options.path_ = "/tmp/milvus_test";
+    milvus::engine::meta::SqliteMetaImpl impl(options);
+
+    time_t tt;
+    time(&tt);
+    int delta = 10;
+    milvus::engine::meta::DateT dt = milvus::engine::utils::GetDate(tt, delta);
+    ASSERT_GT(dt, 0);
+}
+
+TEST(DBMiscTest, UTILS_TEST) {
+    milvus::engine::DBMetaOptions options;
+    options.path_ = "/tmp/milvus_test/main";
+    options.slave_paths_.push_back("/tmp/milvus_test/slave_1");
+    options.slave_paths_.push_back("/tmp/milvus_test/slave_2");
+
+    const std::string TABLE_NAME = "test_tbl";
+    auto status = milvus::engine::utils::CreateTablePath(options, TABLE_NAME);
+    ASSERT_TRUE(status.ok());
+    ASSERT_TRUE(boost::filesystem::exists(options.path_));
+    for (auto &path : options.slave_paths_) {
+        ASSERT_TRUE(boost::filesystem::exists(path));
+    }
+
+//    options.slave_paths.push_back("/");
+//    status =  engine::utils::CreateTablePath(options, TABLE_NAME);
+//    ASSERT_FALSE(status.ok());
+//
+//    options.path = "/";
+//    status =  engine::utils::CreateTablePath(options, TABLE_NAME);
+//    ASSERT_FALSE(status.ok());
+
+    milvus::engine::meta::TableFileSchema file;
+    file.id_ = 50;
+    file.table_id_ = TABLE_NAME;
+    file.file_type_ = 3;
+    file.date_ = 155000;
+    status = milvus::engine::utils::GetTableFilePath(options, file);
+    ASSERT_FALSE(status.ok());
+    ASSERT_TRUE(file.location_.empty());
+
+    status = milvus::engine::utils::DeleteTablePath(options, TABLE_NAME);
+    ASSERT_TRUE(status.ok());
+
+    status = milvus::engine::utils::DeleteTableFilePath(options, file);
+    ASSERT_TRUE(status.ok());
+}
diff --git a/core/unittest/db/test_search.cpp b/core/unittest/db/test_search.cpp
new file mode 100644
index 0000000000..b8cf08b3e2
--- /dev/null
+++ b/core/unittest/db/test_search.cpp
@@ -0,0 +1,388 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 <gtest/gtest.h>
+#include <cmath>
+#include <vector>
+
+#include "scheduler/task/SearchTask.h"
+#include "utils/TimeRecorder.h"
+#include "utils/ThreadPool.h"
+
+namespace {
+
+namespace ms = milvus::scheduler;
+
+void
+BuildResult(std::vector<int64_t>& output_ids,
+            std::vector<float>& output_distance,
+            uint64_t input_k,
+            uint64_t topk,
+            uint64_t nq,
+            bool ascending) {
+    output_ids.clear();
+    output_ids.resize(nq * topk);
+    output_distance.clear();
+    output_distance.resize(nq * topk);
+
+    for (uint64_t i = 0; i < nq; i++) {
+        //insert valid items
+        for (uint64_t j = 0; j < input_k; j++) {
+            output_ids[i * topk + j] = (int64_t)(drand48() * 100000);
+            output_distance[i * topk + j] = ascending ? (j + drand48()) : ((input_k - j) + drand48());
+        }
+        //insert invalid items
+        for (uint64_t j = input_k; j < topk; j++) {
+            output_ids[i * topk + j] = -1;
+            output_distance[i * topk + j] = -1.0;
+        }
+    }
+}
+
+void
+CopyResult(std::vector<int64_t>& output_ids,
+           std::vector<float>& output_distance,
+           uint64_t output_topk,
+           std::vector<int64_t>& input_ids,
+           std::vector<float>& input_distance,
+           uint64_t input_topk,
+           uint64_t nq) {
+    ASSERT_TRUE(input_ids.size() >= nq * input_topk);
+    ASSERT_TRUE(input_distance.size() >= nq * input_topk);
+    ASSERT_TRUE(output_topk <= input_topk);
+    output_ids.clear();
+    output_ids.resize(nq * output_topk);
+    output_distance.clear();
+    output_distance.resize(nq * output_topk);
+
+    for (uint64_t i = 0; i < nq; i++) {
+        for (uint64_t j = 0; j < output_topk; j++) {
+            output_ids[i * output_topk + j] = input_ids[i * input_topk + j];
+            output_distance[i * output_topk + j] = input_distance[i * input_topk + j];
+        }
+    }
+}
+
+void
+CheckTopkResult(const std::vector<int64_t>& input_ids_1,
+                const std::vector<float>& input_distance_1,
+                const std::vector<int64_t>& input_ids_2,
+                const std::vector<float>& input_distance_2,
+                uint64_t topk,
+                uint64_t nq,
+                bool ascending,
+                const milvus::scheduler::ResultSet& result) {
+    ASSERT_EQ(result.size(), nq);
+    ASSERT_EQ(input_ids_1.size(), input_distance_1.size());
+    ASSERT_EQ(input_ids_2.size(), input_distance_2.size());
+
+    for (int64_t i = 0; i < nq; i++) {
+        std::vector<float>
+            src_vec(input_distance_1.begin() + i * topk, input_distance_1.begin() + (i + 1) * topk);
+        src_vec.insert(src_vec.end(),
+                       input_distance_2.begin() + i * topk,
+                       input_distance_2.begin() + (i + 1) * topk);
+        if (ascending) {
+            std::sort(src_vec.begin(), src_vec.end());
+        } else {
+            std::sort(src_vec.begin(), src_vec.end(), std::greater<float>());
+        }
+
+        //erase invalid items
+        std::vector<float>::iterator iter;
+        for (iter = src_vec.begin(); iter != src_vec.end();) {
+            if (*iter < 0.0)
+                iter = src_vec.erase(iter);
+            else
+                ++iter;
+        }
+
+        uint64_t n = std::min(topk, result[i].size());
+        for (uint64_t j = 0; j < n; j++) {
+            if (result[i][j].first < 0) {
+                continue;
+            }
+            if (src_vec[j] != result[i][j].second) {
+                std::cout << src_vec[j] << " " << result[i][j].second << std::endl;
+            }
+            ASSERT_TRUE(src_vec[j] == result[i][j].second);
+        }
+    }
+}
+
+} // namespace
+
+void
+MergeTopkToResultSetTest(uint64_t topk_1, uint64_t topk_2, uint64_t nq, uint64_t topk, bool ascending) {
+    std::vector<int64_t> ids1, ids2;
+    std::vector<float> dist1, dist2;
+    ms::ResultSet result;
+    BuildResult(ids1, dist1, topk_1, topk, nq, ascending);
+    BuildResult(ids2, dist2, topk_2, topk, nq, ascending);
+    ms::XSearchTask::MergeTopkToResultSet(ids1, dist1, topk_1, nq, topk, ascending, result);
+    ms::XSearchTask::MergeTopkToResultSet(ids2, dist2, topk_2, nq, topk, ascending, result);
+    CheckTopkResult(ids1, dist1, ids2, dist2, topk, nq, ascending, result);
+}
+
+TEST(DBSearchTest, MERGE_RESULT_SET_TEST) {
+    uint64_t NQ = 15;
+    uint64_t TOP_K = 64;
+
+    /* test1, id1/dist1 valid, id2/dist2 empty */
+    MergeTopkToResultSetTest(TOP_K, 0, NQ, TOP_K, true);
+    MergeTopkToResultSetTest(TOP_K, 0, NQ, TOP_K, false);
+
+    /* test2, id1/dist1 valid, id2/dist2 valid */
+    MergeTopkToResultSetTest(TOP_K, TOP_K, NQ, TOP_K, true);
+    MergeTopkToResultSetTest(TOP_K, TOP_K, NQ, TOP_K, false);
+
+    /* test3, id1/dist1 small topk */
+    MergeTopkToResultSetTest(TOP_K / 2, TOP_K, NQ, TOP_K, true);
+    MergeTopkToResultSetTest(TOP_K / 2, TOP_K, NQ, TOP_K, false);
+
+    /* test4, id1/dist1 small topk, id2/dist2 small topk */
+    MergeTopkToResultSetTest(TOP_K / 2, TOP_K / 3, NQ, TOP_K, true);
+    MergeTopkToResultSetTest(TOP_K / 2, TOP_K / 3, NQ, TOP_K, false);
+}
+
+//void MergeTopkArrayTest(uint64_t topk_1, uint64_t topk_2, uint64_t nq, uint64_t topk, bool ascending) {
+//    std::vector<int64_t> ids1, ids2;
+//    std::vector<float> dist1, dist2;
+//    ms::ResultSet result;
+//    BuildResult(ids1, dist1, topk_1, topk, nq, ascending);
+//    BuildResult(ids2, dist2, topk_2, topk, nq, ascending);
+//    uint64_t result_topk = std::min(topk, topk_1 + topk_2);
+//    ms::XSearchTask::MergeTopkArray(ids1, dist1, topk_1, ids2, dist2, topk_2, nq, topk, ascending);
+//    if (ids1.size() != result_topk * nq) {
+//        std::cout << ids1.size() << " " << result_topk * nq << std::endl;
+//    }
+//    ASSERT_TRUE(ids1.size() == result_topk * nq);
+//    ASSERT_TRUE(dist1.size() == result_topk * nq);
+//    for (uint64_t i = 0; i < nq; i++) {
+//        for (uint64_t k = 1; k < result_topk; k++) {
+//            float f0 = dist1[i * topk + k - 1];
+//            float f1 = dist1[i * topk + k];
+//            if (ascending) {
+//                if (f1 < f0) {
+//                    std::cout << f0 << " " << f1 << std::endl;
+//                }
+//                ASSERT_TRUE(f1 >= f0);
+//            } else {
+//                if (f1 > f0) {
+//                    std::cout << f0 << " " << f1 << std::endl;
+//                }
+//                ASSERT_TRUE(f1 <= f0);
+//            }
+//        }
+//    }
+//}
+
+//TEST(DBSearchTest, MERGE_ARRAY_TEST) {
+//    uint64_t NQ = 15;
+//    uint64_t TOP_K = 64;
+//
+//    /* test1, id1/dist1 valid, id2/dist2 empty */
+//    MergeTopkArrayTest(TOP_K, 0, NQ, TOP_K, true);
+//    MergeTopkArrayTest(TOP_K, 0, NQ, TOP_K, false);
+//    MergeTopkArrayTest(0, TOP_K, NQ, TOP_K, true);
+//    MergeTopkArrayTest(0, TOP_K, NQ, TOP_K, false);
+
+//    /* test2, id1/dist1 valid, id2/dist2 valid */
+//    MergeTopkArrayTest(TOP_K, TOP_K, NQ, TOP_K, true);
+//    MergeTopkArrayTest(TOP_K, TOP_K, NQ, TOP_K, false);
+//
+//    /* test3, id1/dist1 small topk */
+//    MergeTopkArrayTest(TOP_K/2, TOP_K, NQ, TOP_K, true);
+//    MergeTopkArrayTest(TOP_K/2, TOP_K, NQ, TOP_K, false);
+//    MergeTopkArrayTest(TOP_K, TOP_K/2, NQ, TOP_K, true);
+//    MergeTopkArrayTest(TOP_K, TOP_K/2, NQ, TOP_K, false);
+//
+//    /* test4, id1/dist1 small topk, id2/dist2 small topk */
+//    MergeTopkArrayTest(TOP_K/2, TOP_K/3, NQ, TOP_K, true);
+//    MergeTopkArrayTest(TOP_K/2, TOP_K/3, NQ, TOP_K, false);
+//    MergeTopkArrayTest(TOP_K/3, TOP_K/2, NQ, TOP_K, true);
+//    MergeTopkArrayTest(TOP_K/3, TOP_K/2, NQ, TOP_K, false);
+//}
+
+TEST(DBSearchTest, REDUCE_PERF_TEST) {
+    int32_t index_file_num = 478;   /* sift1B dataset, index files num */
+    bool ascending = true;
+
+    std::vector<int32_t> thread_vec = {4, 8};
+    std::vector<int32_t> nq_vec = {1, 10, 100};
+    std::vector<int32_t> topk_vec = {1, 4, 16, 64};
+    int32_t NQ = nq_vec[nq_vec.size() - 1];
+    int32_t TOPK = topk_vec[topk_vec.size() - 1];
+
+    std::vector<std::vector<int64_t>> id_vec;
+    std::vector<std::vector<float>> dist_vec;
+    std::vector<int64_t> input_ids;
+    std::vector<float> input_distance;
+    int32_t i, k, step;
+
+    /* generate testing data */
+    for (i = 0; i < index_file_num; i++) {
+        BuildResult(input_ids, input_distance, TOPK, TOPK, NQ, ascending);
+        id_vec.push_back(input_ids);
+        dist_vec.push_back(input_distance);
+    }
+
+    for (int32_t max_thread_num : thread_vec) {
+        milvus::ThreadPool threadPool(max_thread_num);
+        std::list<std::future<void>> threads_list;
+
+        for (int32_t nq : nq_vec) {
+            for (int32_t top_k : topk_vec) {
+                ms::ResultSet final_result, final_result_2, final_result_3;
+
+                std::vector<std::vector<int64_t>> id_vec_1(index_file_num);
+                std::vector<std::vector<float>> dist_vec_1(index_file_num);
+                for (i = 0; i < index_file_num; i++) {
+                    CopyResult(id_vec_1[i], dist_vec_1[i], top_k, id_vec[i], dist_vec[i], TOPK, nq);
+                }
+
+                std::string str1 = "Method-1 " + std::to_string(max_thread_num) + " " +
+                                   std::to_string(nq) + " " + std::to_string(top_k);
+                milvus::TimeRecorder rc1(str1);
+
+                ///////////////////////////////////////////////////////////////////////////////////////
+                /* method-1 */
+                for (i = 0; i < index_file_num; i++) {
+                    ms::XSearchTask::MergeTopkToResultSet(id_vec_1[i],
+                                                          dist_vec_1[i],
+                                                          top_k,
+                                                          nq,
+                                                          top_k,
+                                                          ascending,
+                                                          final_result);
+                    ASSERT_EQ(final_result.size(), nq);
+                }
+
+                rc1.RecordSection("reduce done");
+
+//                ///////////////////////////////////////////////////////////////////////////////////////
+//                /* method-2 */
+//                std::vector<std::vector<int64_t>> id_vec_2(index_file_num);
+//                std::vector<std::vector<float>> dist_vec_2(index_file_num);
+//                std::vector<uint64_t> k_vec_2(index_file_num);
+//                for (i = 0; i < index_file_num; i++) {
+//                    CopyResult(id_vec_2[i], dist_vec_2[i], top_k, id_vec[i], dist_vec[i], TOPK, nq);
+//                    k_vec_2[i] = top_k;
+//                }
+//
+//                std::string str2 = "Method-2 " + std::to_string(max_thread_num) + " " +
+//                                    std::to_string(nq) + " " + std::to_string(top_k);
+//                milvus::TimeRecorder rc2(str2);
+//
+//                for (step = 1; step < index_file_num; step *= 2) {
+//                    for (i = 0; i + step < index_file_num; i += step * 2) {
+//                        ms::XSearchTask::MergeTopkArray(id_vec_2[i], dist_vec_2[i], k_vec_2[i],
+//                                                        id_vec_2[i + step], dist_vec_2[i + step], k_vec_2[i + step],
+//                                                        nq, top_k, ascending);
+//                    }
+//                }
+//                ms::XSearchTask::MergeTopkToResultSet(id_vec_2[0],
+//                                                      dist_vec_2[0],
+//                                                      k_vec_2[0],
+//                                                      nq,
+//                                                      top_k,
+//                                                      ascending,
+//                                                      final_result_2);
+//                ASSERT_EQ(final_result_2.size(), nq);
+//
+//                rc2.RecordSection("reduce done");
+//
+//                for (i = 0; i < nq; i++) {
+//                    ASSERT_EQ(final_result[i].size(), final_result_2[i].size());
+//                    for (k = 0; k < final_result[i].size(); k++) {
+//                        if (final_result[i][k].first != final_result_2[i][k].first) {
+//                            std::cout << i << " " << k << std::endl;
+//                        }
+//                        ASSERT_EQ(final_result[i][k].first, final_result_2[i][k].first);
+//                        ASSERT_EQ(final_result[i][k].second, final_result_2[i][k].second);
+//                    }
+//                }
+//
+//                ///////////////////////////////////////////////////////////////////////////////////////
+//                /* method-3 parallel */
+//                std::vector<std::vector<int64_t>> id_vec_3(index_file_num);
+//                std::vector<std::vector<float>> dist_vec_3(index_file_num);
+//                std::vector<uint64_t> k_vec_3(index_file_num);
+//                for (i = 0; i < index_file_num; i++) {
+//                    CopyResult(id_vec_3[i], dist_vec_3[i], top_k, id_vec[i], dist_vec[i], TOPK, nq);
+//                    k_vec_3[i] = top_k;
+//                }
+//
+//                std::string str3 = "Method-3 " + std::to_string(max_thread_num) + " " +
+//                                    std::to_string(nq) + " " + std::to_string(top_k);
+//                milvus::TimeRecorder rc3(str3);
+//
+//                for (step = 1; step < index_file_num; step *= 2) {
+//                    for (i = 0; i + step < index_file_num; i += step * 2) {
+//                        threads_list.push_back(
+//                            threadPool.enqueue(ms::XSearchTask::MergeTopkArray,
+//                                               std::ref(id_vec_3[i]),
+//                                               std::ref(dist_vec_3[i]),
+//                                               std::ref(k_vec_3[i]),
+//                                               std::ref(id_vec_3[i + step]),
+//                                               std::ref(dist_vec_3[i + step]),
+//                                               std::ref(k_vec_3[i + step]),
+//                                               nq,
+//                                               top_k,
+//                                               ascending));
+//                    }
+//
+//                    while (threads_list.size() > 0) {
+//                        int nready = 0;
+//                        for (auto it = threads_list.begin(); it != threads_list.end(); it = it) {
+//                            auto &p = *it;
+//                            std::chrono::milliseconds span(0);
+//                            if (p.wait_for(span) == std::future_status::ready) {
+//                                threads_list.erase(it++);
+//                                ++nready;
+//                            } else {
+//                                ++it;
+//                            }
+//                        }
+//
+//                        if (nready == 0) {
+//                            std::this_thread::yield();
+//                        }
+//                    }
+//                }
+//                ms::XSearchTask::MergeTopkToResultSet(id_vec_3[0],
+//                                                      dist_vec_3[0],
+//                                                      k_vec_3[0],
+//                                                      nq,
+//                                                      top_k,
+//                                                      ascending,
+//                                                      final_result_3);
+//                ASSERT_EQ(final_result_3.size(), nq);
+//
+//                rc3.RecordSection("reduce done");
+//
+//                for (i = 0; i < nq; i++) {
+//                    ASSERT_EQ(final_result[i].size(), final_result_3[i].size());
+//                    for (k = 0; k < final_result[i].size(); k++) {
+//                        ASSERT_EQ(final_result[i][k].first, final_result_3[i][k].first);
+//                        ASSERT_EQ(final_result[i][k].second, final_result_3[i][k].second);
+//                    }
+//                }
+            }
+        }
+    }
+}
diff --git a/core/unittest/db/utils.cpp b/core/unittest/db/utils.cpp
new file mode 100644
index 0000000000..67beeba36f
--- /dev/null
+++ b/core/unittest/db/utils.cpp
@@ -0,0 +1,212 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 <iostream>
+#include <thread>
+#include <memory>
+#include <string>
+#include <boost/filesystem.hpp>
+
+#include "db/utils.h"
+#include "cache/GpuCacheMgr.h"
+#include "cache/CpuCacheMgr.h"
+#include "db/DBFactory.h"
+#include "db/Options.h"
+#include "knowhere/index/vector_index/helpers/FaissGpuResourceMgr.h"
+
+INITIALIZE_EASYLOGGINGPP
+
+namespace {
+
+class DBTestEnvironment : public ::testing::Environment {
+ public:
+    explicit DBTestEnvironment(const std::string& uri)
+        : uri_(uri) {
+    }
+
+    std::string getURI() const {
+        return uri_;
+    }
+
+    void SetUp() override {
+        getURI();
+    }
+
+ private:
+    std::string uri_;
+};
+
+DBTestEnvironment* test_env = nullptr;
+
+} // namespace
+
+
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+void
+BaseTest::InitLog() {
+    el::Configurations defaultConf;
+    defaultConf.setToDefault();
+    defaultConf.set(el::Level::Debug,
+                    el::ConfigurationType::Format, "[%thread-%datetime-%level]: %msg (%fbase:%line)");
+    el::Loggers::reconfigureLogger("default", defaultConf);
+}
+
+void
+BaseTest::SetUp() {
+    InitLog();
+
+    knowhere::FaissGpuResourceMgr::GetInstance().InitDevice(0, 1024 * 1024 * 200, 1024 * 1024 * 300, 2);
+}
+
+void
+BaseTest::TearDown() {
+    milvus::cache::CpuCacheMgr::GetInstance()->ClearCache();
+    milvus::cache::GpuCacheMgr::GetInstance(0)->ClearCache();
+    knowhere::FaissGpuResourceMgr::GetInstance().Free();
+}
+
+milvus::engine::DBOptions
+BaseTest::GetOptions() {
+    auto options = milvus::engine::DBFactory::BuildOption();
+    options.meta_.path_ = "/tmp/milvus_test";
+    options.meta_.backend_uri_ = "sqlite://:@:/";
+    return options;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+void
+DBTest::SetUp() {
+    BaseTest::SetUp();
+
+    auto res_mgr = milvus::scheduler::ResMgrInst::GetInstance();
+    res_mgr->Clear();
+    res_mgr->Add(milvus::scheduler::ResourceFactory::Create("disk", "DISK", 0, true, false));
+    res_mgr->Add(milvus::scheduler::ResourceFactory::Create("cpu", "CPU", 0, true, true));
+    res_mgr->Add(milvus::scheduler::ResourceFactory::Create("gtx1660", "GPU", 0, true, true));
+
+    auto default_conn = milvus::scheduler::Connection("IO", 500.0);
+    auto PCIE = milvus::scheduler::Connection("IO", 11000.0);
+    res_mgr->Connect("disk", "cpu", default_conn);
+    res_mgr->Connect("cpu", "gtx1660", PCIE);
+    res_mgr->Start();
+    milvus::scheduler::SchedInst::GetInstance()->Start();
+
+    milvus::scheduler::JobMgrInst::GetInstance()->Start();
+
+    auto options = GetOptions();
+    db_ = milvus::engine::DBFactory::Build(options);
+}
+
+void
+DBTest::TearDown() {
+    db_->Stop();
+    db_->DropAll();
+
+    milvus::scheduler::JobMgrInst::GetInstance()->Stop();
+    milvus::scheduler::SchedInst::GetInstance()->Stop();
+    milvus::scheduler::ResMgrInst::GetInstance()->Stop();
+    milvus::scheduler::ResMgrInst::GetInstance()->Clear();
+
+    BaseTest::TearDown();
+
+    auto options = GetOptions();
+    boost::filesystem::remove_all(options.meta_.path_);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+milvus::engine::DBOptions
+DBTest2::GetOptions() {
+    auto options = milvus::engine::DBFactory::BuildOption();
+    options.meta_.path_ = "/tmp/milvus_test";
+    options.meta_.archive_conf_ = milvus::engine::ArchiveConf("delete", "disk:1");
+    options.meta_.backend_uri_ = "sqlite://:@:/";
+    return options;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+void
+MetaTest::SetUp() {
+    BaseTest::SetUp();
+
+    auto options = GetOptions();
+    impl_ = std::make_shared<milvus::engine::meta::SqliteMetaImpl>(options.meta_);
+}
+
+void
+MetaTest::TearDown() {
+    impl_->DropAll();
+
+    BaseTest::TearDown();
+
+    auto options = GetOptions();
+    boost::filesystem::remove_all(options.meta_.path_);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+milvus::engine::DBOptions
+MySqlDBTest::GetOptions() {
+    auto options = milvus::engine::DBFactory::BuildOption();
+    options.meta_.path_ = "/tmp/milvus_test";
+    options.meta_.backend_uri_ = test_env->getURI();
+
+    return options;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+void
+MySqlMetaTest::SetUp() {
+    BaseTest::SetUp();
+
+    auto options = GetOptions();
+    impl_ = std::make_shared<milvus::engine::meta::MySQLMetaImpl>(options.meta_, options.mode_);
+}
+
+void
+MySqlMetaTest::TearDown() {
+    impl_->DropAll();
+
+    BaseTest::TearDown();
+
+    auto options = GetOptions();
+    boost::filesystem::remove_all(options.meta_.path_);
+}
+
+milvus::engine::DBOptions
+MySqlMetaTest::GetOptions() {
+    auto options = milvus::engine::DBFactory::BuildOption();
+    options.meta_.path_ = "/tmp/milvus_test";
+    options.meta_.backend_uri_ = test_env->getURI();
+
+    return options;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+int
+main(int argc, char **argv) {
+    ::testing::InitGoogleTest(&argc, argv);
+
+    std::string uri;
+    if (argc > 1) {
+        uri = argv[1];
+    }
+
+    test_env = new DBTestEnvironment(uri);
+    ::testing::AddGlobalTestEnvironment(test_env);
+    return RUN_ALL_TESTS();
+}
diff --git a/core/unittest/db/utils.h b/core/unittest/db/utils.h
new file mode 100644
index 0000000000..8da160dc92
--- /dev/null
+++ b/core/unittest/db/utils.h
@@ -0,0 +1,104 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+
+#pragma once
+
+#include <gtest/gtest.h>
+#include <chrono>
+#include <memory>
+
+#include "db/DB.h"
+#include "db/meta/SqliteMetaImpl.h"
+#include "db/meta/MySQLMetaImpl.h"
+#include "scheduler/SchedInst.h"
+#include "scheduler/ResourceFactory.h"
+
+#define TIMING
+
+#ifdef TIMING
+#define INIT_TIMER auto start = std::chrono::high_resolution_clock::now();
+#define START_TIMER  start = std::chrono::high_resolution_clock::now();
+#define STOP_TIMER(name)  LOG(DEBUG) << "RUNTIME of " << name << ": " << \
+    std::chrono::duration_cast<std::chrono::milliseconds>( \
+            std::chrono::high_resolution_clock::now()-start).count() << " ms ";
+#else
+#define INIT_TIMER
+#define START_TIMER
+#define STOP_TIMER(name)
+#endif
+
+class BaseTest : public ::testing::Test {
+ protected:
+    void InitLog();
+
+    void SetUp() override;
+    void TearDown() override;
+    virtual milvus::engine::DBOptions GetOptions();
+};
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class DBTest : public BaseTest {
+ protected:
+    milvus::engine::DBPtr db_;
+
+    void SetUp() override;
+    void TearDown() override;
+};
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class DBTest2 : public DBTest {
+ protected:
+    milvus::engine::DBOptions GetOptions() override;
+};
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class EngineTest : public DBTest {
+};
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class MetaTest : public BaseTest {
+ protected:
+    std::shared_ptr<milvus::engine::meta::SqliteMetaImpl> impl_;
+
+    void SetUp() override;
+    void TearDown() override;
+};
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class MySqlDBTest : public DBTest {
+ protected:
+    milvus::engine::DBOptions GetOptions() override;
+};
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class MySqlMetaTest : public BaseTest {
+ protected:
+    std::shared_ptr<milvus::engine::meta::MySQLMetaImpl> impl_;
+
+    void SetUp() override;
+    void TearDown() override;
+    milvus::engine::DBOptions GetOptions() override;
+};
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class MemManagerTest : public MetaTest {
+};
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+class MemManagerTest2 : public DBTest {
+};
diff --git a/core/unittest/main.cpp b/core/unittest/main.cpp
new file mode 100644
index 0000000000..d17cf9da58
--- /dev/null
+++ b/core/unittest/main.cpp
@@ -0,0 +1,29 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+#include "utils/easylogging++.h"
+
+INITIALIZE_EASYLOGGINGPP
+
+int
+main(int argc, char **argv) {
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}
diff --git a/core/unittest/metrics/CMakeLists.txt b/core/unittest/metrics/CMakeLists.txt
new file mode 100644
index 0000000000..eba8146baa
--- /dev/null
+++ b/core/unittest/metrics/CMakeLists.txt
@@ -0,0 +1,31 @@
+#-------------------------------------------------------------------------------
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you 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.
+#-------------------------------------------------------------------------------
+
+aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR} test_files)
+
+add_executable(test_metrics
+        ${common_files}
+        ${test_files}
+        )
+
+target_link_libraries(test_metrics
+        knowhere
+        ${unittest_libs})
+
+install(TARGETS test_metrics DESTINATION unittest)
\ No newline at end of file
diff --git a/core/unittest/metrics/test_metricbase.cpp b/core/unittest/metrics/test_metricbase.cpp
new file mode 100644
index 0000000000..c2d43642ab
--- /dev/null
+++ b/core/unittest/metrics/test_metricbase.cpp
@@ -0,0 +1,67 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "metrics/Metrics.h"
+
+#include <gtest/gtest.h>
+#include <iostream>
+
+TEST(MetricbaseTest, METRICBASE_TEST) {
+    milvus::server::MetricsBase instance = milvus::server::MetricsBase::GetInstance();
+    instance.Init();
+    milvus::server::SystemInfo::GetInstance().Init();
+    instance.AddVectorsSuccessTotalIncrement();
+    instance.AddVectorsFailTotalIncrement();
+    instance.AddVectorsDurationHistogramOberve(1.0);
+    instance.RawFileSizeHistogramObserve(1.0);
+    instance.IndexFileSizeHistogramObserve(1.0);
+    instance.BuildIndexDurationSecondsHistogramObserve(1.0);
+    instance.CpuCacheUsageGaugeSet(1.0);
+    instance.GpuCacheUsageGaugeSet();
+    instance.MetaAccessTotalIncrement();
+    instance.MetaAccessDurationSecondsHistogramObserve(1.0);
+    instance.FaissDiskLoadDurationSecondsHistogramObserve(1.0);
+    instance.FaissDiskLoadSizeBytesHistogramObserve(1.0);
+    instance.FaissDiskLoadIOSpeedGaugeSet(1.0);
+    instance.CacheAccessTotalIncrement();
+    instance.MemTableMergeDurationSecondsHistogramObserve(1.0);
+    instance.SearchIndexDataDurationSecondsHistogramObserve(1.0);
+    instance.SearchRawDataDurationSecondsHistogramObserve(1.0);
+    instance.IndexFileSizeTotalIncrement();
+    instance.RawFileSizeTotalIncrement();
+    instance.IndexFileSizeGaugeSet(1.0);
+    instance.RawFileSizeGaugeSet(1.0);
+    instance.QueryResponseSummaryObserve(1.0);
+    instance.DiskStoreIOSpeedGaugeSet(1.0);
+    instance.DataFileSizeGaugeSet(1.0);
+    instance.AddVectorsSuccessGaugeSet(1.0);
+    instance.AddVectorsFailGaugeSet(1.0);
+    instance.QueryVectorResponseSummaryObserve(1.0, 1);
+    instance.QueryVectorResponsePerSecondGaugeSet(1.0);
+    instance.CPUUsagePercentSet();
+    instance.RAMUsagePercentSet();
+    instance.QueryResponsePerSecondGaugeSet(1.0);
+    instance.GPUPercentGaugeSet();
+    instance.GPUMemoryUsageGaugeSet();
+    instance.AddVectorsPerSecondGaugeSet(1, 1, 1);
+    instance.QueryIndexTypePerSecondSet("IVF", 1.0);
+    instance.ConnectionGaugeIncrement();
+    instance.ConnectionGaugeDecrement();
+    instance.KeepingAliveCounterIncrement();
+    instance.OctetsSet();
+}
diff --git a/core/unittest/metrics/test_metrics.cpp b/core/unittest/metrics/test_metrics.cpp
new file mode 100644
index 0000000000..c0d1044bb4
--- /dev/null
+++ b/core/unittest/metrics/test_metrics.cpp
@@ -0,0 +1,157 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 <chrono>
+#include <map>
+#include <memory>
+#include <string>
+#include <thread>
+#include <gtest/gtest.h>
+
+#include "cache/CpuCacheMgr.h"
+#include "server/Config.h"
+#include "metrics/Metrics.h"
+#include "metrics/utils.h"
+#include "db/DB.h"
+#include "db/meta/SqliteMetaImpl.h"
+
+TEST_F(MetricTest, METRIC_TEST) {
+    milvus::server::Config::GetInstance().SetMetricConfigCollector("zabbix");
+    milvus::server::Metrics::GetInstance();
+    milvus::server::Config::GetInstance().SetMetricConfigCollector("prometheus");
+    milvus::server::Metrics::GetInstance();
+
+    milvus::server::SystemInfo::GetInstance().Init();
+//    server::Metrics::GetInstance().Init();
+//    server::Metrics::GetInstance().exposer_ptr()->RegisterCollectable(server::Metrics::GetInstance().registry_ptr());
+    milvus::server::Metrics::GetInstance().Init();
+
+//    server::PrometheusMetrics::GetInstance().exposer_ptr()->RegisterCollectable(server::PrometheusMetrics::GetInstance().registry_ptr());
+    milvus::cache::CpuCacheMgr::GetInstance()->SetCapacity(1UL * 1024 * 1024 * 1024);
+    std::cout << milvus::cache::CpuCacheMgr::GetInstance()->CacheCapacity() << std::endl;
+
+    static const char *group_name = "test_group";
+    static const int group_dim = 256;
+
+    milvus::engine::meta::TableSchema group_info;
+    group_info.dimension_ = group_dim;
+    group_info.table_id_ = group_name;
+    auto stat = db_->CreateTable(group_info);
+
+    milvus::engine::meta::TableSchema group_info_get;
+    group_info_get.table_id_ = group_name;
+    stat = db_->DescribeTable(group_info_get);
+
+    milvus::engine::IDNumbers vector_ids;
+    milvus::engine::IDNumbers target_ids;
+
+    int d = 256;
+    int nb = 50;
+    float *xb = new float[d * nb];
+    for (int i = 0; i < nb; i++) {
+        for (int j = 0; j < d; j++) xb[d * i + j] = drand48();
+        xb[d * i] += i / 2000.;
+    }
+
+    int qb = 5;
+    float *qxb = new float[d * qb];
+    for (int i = 0; i < qb; i++) {
+        for (int j = 0; j < d; j++) qxb[d * i + j] = drand48();
+        qxb[d * i] += i / 2000.;
+    }
+
+    std::thread search([&]() {
+        milvus::engine::QueryResults results;
+        int k = 10;
+        std::this_thread::sleep_for(std::chrono::seconds(2));
+
+        INIT_TIMER;
+        std::stringstream ss;
+        uint64_t count = 0;
+        uint64_t prev_count = 0;
+
+        for (auto j = 0; j < 10; ++j) {
+            ss.str("");
+            db_->Size(count);
+            prev_count = count;
+
+            START_TIMER;
+//            stat = db_->Query(group_name, k, qb, qxb, results);
+            ss << "Search " << j << " With Size " << (float) (count * group_dim * sizeof(float)) / (1024 * 1024)
+               << " M";
+
+            for (auto k = 0; k < qb; ++k) {
+//                ASSERT_EQ(results[k][0].first, target_ids[k]);
+                ss.str("");
+                ss << "Result [" << k << "]:";
+//                for (auto result : results[k]) {
+//                    ss << result.first << " ";
+//                }
+            }
+            ASSERT_TRUE(count >= prev_count);
+            std::this_thread::sleep_for(std::chrono::seconds(1));
+        }
+    });
+
+    int loop = 10000;
+
+    for (auto i = 0; i < loop; ++i) {
+        if (i == 40) {
+            db_->InsertVectors(group_name, qb, qxb, target_ids);
+            ASSERT_EQ(target_ids.size(), qb);
+        } else {
+            db_->InsertVectors(group_name, nb, xb, vector_ids);
+        }
+        std::this_thread::sleep_for(std::chrono::microseconds(2000));
+    }
+
+    search.join();
+
+    delete[] xb;
+    delete[] qxb;
+}
+
+TEST_F(MetricTest, COLLECTOR_METRICS_TEST) {
+    auto status = milvus::Status::OK();
+    milvus::server::CollectInsertMetrics insert_metrics0(0, status);
+    status = milvus::Status(milvus::DB_ERROR, "error");
+    milvus::server::CollectInsertMetrics insert_metrics1(0, status);
+
+    milvus::server::CollectQueryMetrics query_metrics(10);
+
+    milvus::server::CollectMergeFilesMetrics merge_metrics();
+
+    milvus::server::CollectBuildIndexMetrics build_index_metrics();
+
+    milvus::server::CollectExecutionEngineMetrics execution_metrics(10);
+
+    milvus::server::CollectSerializeMetrics serialize_metrics(10);
+
+    milvus::server::CollectAddMetrics add_metrics(10, 128);
+
+    milvus::server::CollectDurationMetrics duration_metrics_raw(milvus::engine::meta::TableFileSchema::RAW);
+    milvus::server::CollectDurationMetrics duration_metrics_index(milvus::engine::meta::TableFileSchema::TO_INDEX);
+    milvus::server::CollectDurationMetrics duration_metrics_delete(milvus::engine::meta::TableFileSchema::TO_DELETE);
+
+    milvus::server::CollectSearchTaskMetrics search_metrics_raw(milvus::engine::meta::TableFileSchema::RAW);
+    milvus::server::CollectSearchTaskMetrics search_metrics_index(milvus::engine::meta::TableFileSchema::TO_INDEX);
+    milvus::server::CollectSearchTaskMetrics search_metrics_delete(milvus::engine::meta::TableFileSchema::TO_DELETE);
+
+    milvus::server::MetricCollector metric_collector();
+}
+
+
diff --git a/core/unittest/metrics/test_prometheus.cpp b/core/unittest/metrics/test_prometheus.cpp
new file mode 100644
index 0000000000..e90dbd56bc
--- /dev/null
+++ b/core/unittest/metrics/test_prometheus.cpp
@@ -0,0 +1,82 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "metrics/PrometheusMetrics.h"
+#include "server/Config.h"
+
+#include <gtest/gtest.h>
+#include <iostream>
+
+TEST(PrometheusTest, PROMETHEUS_TEST) {
+    milvus::server::Config::GetInstance().SetMetricConfigEnableMonitor("on");
+
+    milvus::server::PrometheusMetrics instance = milvus::server::PrometheusMetrics::GetInstance();
+    instance.Init();
+    instance.SetStartup(true);
+    milvus::server::SystemInfo::GetInstance().Init();
+    instance.AddVectorsSuccessTotalIncrement();
+    instance.AddVectorsFailTotalIncrement();
+    instance.AddVectorsDurationHistogramOberve(1.0);
+    instance.RawFileSizeHistogramObserve(1.0);
+    instance.IndexFileSizeHistogramObserve(1.0);
+    instance.BuildIndexDurationSecondsHistogramObserve(1.0);
+    instance.CpuCacheUsageGaugeSet(1.0);
+    instance.GpuCacheUsageGaugeSet();
+    instance.MetaAccessTotalIncrement();
+    instance.MetaAccessDurationSecondsHistogramObserve(1.0);
+    instance.FaissDiskLoadDurationSecondsHistogramObserve(1.0);
+    instance.FaissDiskLoadSizeBytesHistogramObserve(1.0);
+    instance.FaissDiskLoadIOSpeedGaugeSet(1.0);
+    instance.CacheAccessTotalIncrement();
+    instance.MemTableMergeDurationSecondsHistogramObserve(1.0);
+    instance.SearchIndexDataDurationSecondsHistogramObserve(1.0);
+    instance.SearchRawDataDurationSecondsHistogramObserve(1.0);
+    instance.IndexFileSizeTotalIncrement();
+    instance.RawFileSizeTotalIncrement();
+    instance.IndexFileSizeGaugeSet(1.0);
+    instance.RawFileSizeGaugeSet(1.0);
+    instance.QueryResponseSummaryObserve(1.0);
+    instance.DiskStoreIOSpeedGaugeSet(1.0);
+    instance.DataFileSizeGaugeSet(1.0);
+    instance.AddVectorsSuccessGaugeSet(1.0);
+    instance.AddVectorsFailGaugeSet(1.0);
+    instance.QueryVectorResponseSummaryObserve(1.0, 1);
+    instance.QueryVectorResponsePerSecondGaugeSet(1.0);
+    instance.CPUUsagePercentSet();
+    instance.RAMUsagePercentSet();
+    instance.QueryResponsePerSecondGaugeSet(1.0);
+    instance.GPUPercentGaugeSet();
+    instance.GPUMemoryUsageGaugeSet();
+    instance.AddVectorsPerSecondGaugeSet(1, 1, 1);
+    instance.QueryIndexTypePerSecondSet("IVF", 1.0);
+    instance.QueryIndexTypePerSecondSet("IDMap", 1.0);
+    instance.ConnectionGaugeIncrement();
+    instance.ConnectionGaugeDecrement();
+    instance.KeepingAliveCounterIncrement();
+    instance.OctetsSet();
+
+    instance.CPUCoreUsagePercentSet();
+    instance.GPUTemperature();
+    instance.CPUTemperature();
+
+    milvus::server::Config::GetInstance().SetMetricConfigEnableMonitor("off");
+    instance.Init();
+    instance.CPUCoreUsagePercentSet();
+    instance.GPUTemperature();
+    instance.CPUTemperature();
+}
diff --git a/core/unittest/metrics/utils.cpp b/core/unittest/metrics/utils.cpp
new file mode 100644
index 0000000000..72a172c4ee
--- /dev/null
+++ b/core/unittest/metrics/utils.cpp
@@ -0,0 +1,88 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 <iostream>
+#include <thread>
+#include <string>
+#include <boost/filesystem.hpp>
+
+#include "metrics/utils.h"
+#include "db/DBFactory.h"
+
+INITIALIZE_EASYLOGGINGPP
+
+namespace {
+
+class DBTestEnvironment : public ::testing::Environment {
+ public:
+    explicit DBTestEnvironment(const std::string& uri) : uri_(uri) {}
+
+    std::string getURI() const {
+        return uri_;
+    }
+
+    void SetUp() override {
+        getURI();
+    }
+
+ private:
+    std::string uri_;
+};
+
+DBTestEnvironment* test_env = nullptr;
+
+} // namespace
+
+void MetricTest::InitLog() {
+    el::Configurations defaultConf;
+    defaultConf.setToDefault();
+    defaultConf.set(el::Level::Debug,
+            el::ConfigurationType::Format, "[%thread-%datetime-%level]: %msg (%fbase:%line)");
+    el::Loggers::reconfigureLogger("default", defaultConf);
+}
+
+milvus::engine::DBOptions MetricTest::GetOptions() {
+    auto options = milvus::engine::DBFactory::BuildOption();
+    options.meta_.path_ = "/tmp/milvus_test";
+    options.meta_.backend_uri_ = "sqlite://:@:/";
+    return options;
+}
+
+void MetricTest::SetUp() {
+    boost::filesystem::remove_all("/tmp/milvus_test");
+    InitLog();
+    auto options = GetOptions();
+    db_ = milvus::engine::DBFactory::Build(options);
+}
+
+void MetricTest::TearDown() {
+    db_->Stop();
+    boost::filesystem::remove_all("/tmp/milvus_test");
+}
+
+int main(int argc, char **argv) {
+    ::testing::InitGoogleTest(&argc, argv);
+
+    std::string uri;
+    if (argc > 1) {
+        uri = argv[1];
+    }
+    test_env = new DBTestEnvironment(uri);
+    ::testing::AddGlobalTestEnvironment(test_env);
+    return RUN_ALL_TESTS();
+}
diff --git a/core/unittest/metrics/utils.h b/core/unittest/metrics/utils.h
new file mode 100644
index 0000000000..996dec89f5
--- /dev/null
+++ b/core/unittest/metrics/utils.h
@@ -0,0 +1,75 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+
+#pragma once
+
+#include <gtest/gtest.h>
+#include <chrono>
+//#include <src/db/MySQLMetaImpl.h>
+
+#include "db/DB.h"
+#include "db/meta/SqliteMetaImpl.h"
+#include "db/meta/MySQLMetaImpl.h"
+
+#define TIMING
+
+#ifdef TIMING
+#define INIT_TIMER auto start = std::chrono::high_resolution_clock::now();
+#define START_TIMER  start = std::chrono::high_resolution_clock::now();
+#define STOP_TIMER(name)  LOG(DEBUG) << "RUNTIME of " << name << ": " << \
+    std::chrono::duration_cast<std::chrono::milliseconds>( \
+            std::chrono::high_resolution_clock::now()-start).count() << " ms ";
+#else
+#define INIT_TIMER
+#define START_TIMER
+#define STOP_TIMER(name)
+#endif
+
+void
+ASSERT_STATS(milvus::Status &stat);
+
+//class TestEnv : public ::testing::Environment {
+//public:
+//
+//    static std::string getURI() {
+//        if (const char* uri = std::getenv("MILVUS_DBMETA_URI")) {
+//            return uri;
+//        }
+//        else {
+//            return "";
+//        }
+//    }
+//
+//    void SetUp() override {
+//        getURI();
+//    }
+//
+//};
+//
+//::testing::Environment* const test_env =
+//        ::testing::AddGlobalTestEnvironment(new TestEnv);
+
+class MetricTest : public ::testing::Test {
+ protected:
+    milvus::engine::DBPtr db_;
+
+    void InitLog();
+    void SetUp() override;
+    void TearDown() override;
+    virtual milvus::engine::DBOptions GetOptions();
+};
diff --git a/core/unittest/scheduler/CMakeLists.txt b/core/unittest/scheduler/CMakeLists.txt
new file mode 100644
index 0000000000..087f93f017
--- /dev/null
+++ b/core/unittest/scheduler/CMakeLists.txt
@@ -0,0 +1,33 @@
+#-------------------------------------------------------------------------------
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you 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.
+#-------------------------------------------------------------------------------
+
+aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR} test_files)
+
+cuda_add_executable(test_scheduler
+        ${common_files}
+        ${entry_file}
+        ${test_files}
+        )
+
+target_link_libraries(test_scheduler
+        knowhere
+        ${unittest_libs})
+
+install(TARGETS test_scheduler DESTINATION unittest)
+
diff --git a/core/unittest/scheduler/task_test.cpp b/core/unittest/scheduler/task_test.cpp
new file mode 100644
index 0000000000..8ea39edef9
--- /dev/null
+++ b/core/unittest/scheduler/task_test.cpp
@@ -0,0 +1,40 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "scheduler/task/SearchTask.h"
+#include "scheduler/task/BuildIndexTask.h"
+#include <gtest/gtest.h>
+
+
+namespace milvus {
+namespace scheduler {
+
+TEST(TaskTest, INVALID_INDEX) {
+    auto search_task = std::make_shared<XSearchTask>(nullptr, nullptr);
+    search_task->Load(LoadType::TEST, 10);
+
+    auto build_task = std::make_shared<XBuildIndexTask>(nullptr, nullptr);
+    build_task->Load(LoadType::TEST, 10);
+
+    build_task->Execute();
+}
+
+} // namespace scheduler
+} // namespace milvus
+
+
diff --git a/core/unittest/scheduler/test_algorithm.cpp b/core/unittest/scheduler/test_algorithm.cpp
new file mode 100644
index 0000000000..bcb9087373
--- /dev/null
+++ b/core/unittest/scheduler/test_algorithm.cpp
@@ -0,0 +1,108 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 <gtest/gtest.h>
+
+#include "scheduler/resource/Resource.h"
+#include "scheduler/ResourceMgr.h"
+#include "scheduler/resource/CpuResource.h"
+#include "scheduler/ResourceFactory.h"
+#include "scheduler/Algorithm.h"
+
+
+namespace milvus {
+namespace scheduler {
+
+class AlgorithmTest : public testing::Test {
+ protected:
+    void
+    SetUp() override {
+        ResourcePtr disk = ResourceFactory::Create("disk", "DISK", 0, true, false);
+        ResourcePtr cpu0 = ResourceFactory::Create("cpu0", "CPU", 0, true, true);
+        ResourcePtr cpu1 = ResourceFactory::Create("cpu1", "CPU", 1);
+        ResourcePtr cpu2 = ResourceFactory::Create("cpu2", "CPU", 2);
+        ResourcePtr gpu0 = ResourceFactory::Create("gpu0", "GPU", 0);
+        ResourcePtr gpu1 = ResourceFactory::Create("gpu1", "GPU", 1);
+
+        res_mgr_ = std::make_shared<ResourceMgr>();
+        disk_ = res_mgr_->Add(std::move(disk));
+        cpu_0_ = res_mgr_->Add(std::move(cpu0));
+        cpu_1_ = res_mgr_->Add(std::move(cpu1));
+        cpu_2_ = res_mgr_->Add(std::move(cpu2));
+        gpu_0_ = res_mgr_->Add(std::move(gpu0));
+        gpu_1_ = res_mgr_->Add(std::move(gpu1));
+        auto IO = Connection("IO", 5.0);
+        auto PCIE = Connection("PCIE", 11.0);
+        res_mgr_->Connect("disk", "cpu0", IO);
+        res_mgr_->Connect("cpu0", "cpu1", IO);
+        res_mgr_->Connect("cpu1", "cpu2", IO);
+        res_mgr_->Connect("cpu0", "cpu2", IO);
+        res_mgr_->Connect("cpu1", "gpu0", PCIE);
+        res_mgr_->Connect("cpu2", "gpu1", PCIE);
+    }
+
+    ResourceWPtr disk_;
+    ResourceWPtr cpu_0_;
+    ResourceWPtr cpu_1_;
+    ResourceWPtr cpu_2_;
+    ResourceWPtr gpu_0_;
+    ResourceWPtr gpu_1_;
+    ResourceMgrPtr res_mgr_;
+};
+
+TEST_F(AlgorithmTest, SHORTESTPATH_TEST) {
+    std::vector<std::string> sp;
+    uint64_t cost;
+    cost = ShortestPath(disk_.lock(), gpu_0_.lock(), res_mgr_, sp);
+    while (!sp.empty()) {
+        std::cout << sp[sp.size() - 1] << std::endl;
+        sp.pop_back();
+    }
+
+    std::cout << "************************************\n";
+    cost = ShortestPath(cpu_0_.lock(), gpu_0_.lock(), res_mgr_, sp);
+    while (!sp.empty()) {
+        std::cout << sp[sp.size() - 1] << std::endl;
+        sp.pop_back();
+    }
+
+    std::cout << "************************************\n";
+    cost = ShortestPath(disk_.lock(), disk_.lock(), res_mgr_, sp);
+    while (!sp.empty()) {
+        std::cout << sp[sp.size() - 1] << std::endl;
+        sp.pop_back();
+    }
+
+    std::cout << "************************************\n";
+    cost = ShortestPath(cpu_0_.lock(), disk_.lock(), res_mgr_, sp);
+    while (!sp.empty()) {
+        std::cout << sp[sp.size() - 1] << std::endl;
+        sp.pop_back();
+    }
+
+    std::cout << "************************************\n";
+    cost = ShortestPath(cpu_2_.lock(), gpu_0_.lock(), res_mgr_, sp);
+    while (!sp.empty()) {
+        std::cout << sp[sp.size() - 1] << std::endl;
+        sp.pop_back();
+    }
+}
+
+} // namespace scheduler
+} // namespace milvus
+
diff --git a/core/unittest/scheduler/test_event.cpp b/core/unittest/scheduler/test_event.cpp
new file mode 100644
index 0000000000..07d51e8557
--- /dev/null
+++ b/core/unittest/scheduler/test_event.cpp
@@ -0,0 +1,66 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 <gtest/gtest.h>
+#include "scheduler/resource/Resource.h"
+#include "scheduler/event/Event.h"
+#include "scheduler/event/StartUpEvent.h"
+
+
+
+namespace milvus {
+namespace scheduler {
+
+TEST(EventTest, START_UP_EVENT) {
+    ResourceWPtr res(ResourcePtr(nullptr));
+    auto event = std::make_shared<StartUpEvent>(res);
+    ASSERT_FALSE(event->Dump().empty());
+    std::cout << *event;
+    std::cout << *EventPtr(event);
+}
+
+TEST(EventTest, LOAD_COMPLETED_EVENT) {
+    ResourceWPtr res(ResourcePtr(nullptr));
+    auto event = std::make_shared<LoadCompletedEvent>(res, nullptr);
+    ASSERT_FALSE(event->Dump().empty());
+    std::cout << *event;
+    std::cout << *EventPtr(event);
+}
+
+TEST(EventTest, FINISH_TASK_EVENT) {
+    ResourceWPtr res(ResourcePtr(nullptr));
+    auto event = std::make_shared<FinishTaskEvent>(res, nullptr);
+    ASSERT_FALSE(event->Dump().empty());
+    std::cout << *event;
+    std::cout << *EventPtr(event);
+}
+
+
+TEST(EventTest, TASKTABLE_UPDATED_EVENT) {
+    ResourceWPtr res(ResourcePtr(nullptr));
+    auto event = std::make_shared<TaskTableUpdatedEvent>(res);
+    ASSERT_FALSE(event->Dump().empty());
+    std::cout << *event;
+    std::cout << *EventPtr(event);
+}
+
+} // namespace scheduler
+} // namespace milvus
+
+
diff --git a/core/unittest/scheduler/test_node.cpp b/core/unittest/scheduler/test_node.cpp
new file mode 100644
index 0000000000..9b34b73191
--- /dev/null
+++ b/core/unittest/scheduler/test_node.cpp
@@ -0,0 +1,103 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "scheduler/resource/Node.h"
+#include <gtest/gtest.h>
+
+namespace {
+
+namespace ms = milvus::scheduler;
+
+} // namespace
+
+class NodeTest : public ::testing::Test {
+ protected:
+    void
+    SetUp() override {
+        node1_ = std::make_shared<ms::Node>();
+        node2_ = std::make_shared<ms::Node>();
+        node3_ = std::make_shared<ms::Node>();
+        isolated_node1_ = std::make_shared<ms::Node>();
+        isolated_node2_ = std::make_shared<ms::Node>();
+
+        auto pcie = ms::Connection("PCIe", 11.0);
+
+        node1_->AddNeighbour(node2_, pcie);
+        node1_->AddNeighbour(node3_, pcie);
+        node2_->AddNeighbour(node1_, pcie);
+    }
+
+    ms::NodePtr node1_;
+    ms::NodePtr node2_;
+    ms::NodePtr node3_;
+    ms::NodePtr isolated_node1_;
+    ms::NodePtr isolated_node2_;
+};
+
+TEST_F(NodeTest, ADD_NEIGHBOUR) {
+    ASSERT_EQ(isolated_node1_->GetNeighbours().size(), 0);
+    ASSERT_EQ(isolated_node2_->GetNeighbours().size(), 0);
+    auto pcie = ms::Connection("PCIe", 11.0);
+    isolated_node1_->AddNeighbour(isolated_node2_, pcie);
+    ASSERT_EQ(isolated_node1_->GetNeighbours().size(), 1);
+    ASSERT_EQ(isolated_node2_->GetNeighbours().size(), 0);
+}
+
+TEST_F(NodeTest, REPEAT_ADD_NEIGHBOUR) {
+    ASSERT_EQ(isolated_node1_->GetNeighbours().size(), 0);
+    ASSERT_EQ(isolated_node2_->GetNeighbours().size(), 0);
+    auto pcie = ms::Connection("PCIe", 11.0);
+    isolated_node1_->AddNeighbour(isolated_node2_, pcie);
+    isolated_node1_->AddNeighbour(isolated_node2_, pcie);
+    ASSERT_EQ(isolated_node1_->GetNeighbours().size(), 1);
+    ASSERT_EQ(isolated_node2_->GetNeighbours().size(), 0);
+}
+
+TEST_F(NodeTest, GET_NEIGHBOURS) {
+    {
+        bool n2 = false, n3 = false;
+        auto node1_neighbours = node1_->GetNeighbours();
+        ASSERT_EQ(node1_neighbours.size(), 2);
+        for (auto &n : node1_neighbours) {
+            if (n.neighbour_node.lock() == node2_) n2 = true;
+            if (n.neighbour_node.lock() == node3_) n3 = true;
+        }
+        ASSERT_TRUE(n2);
+        ASSERT_TRUE(n3);
+    }
+
+    {
+        auto node2_neighbours = node2_->GetNeighbours();
+        ASSERT_EQ(node2_neighbours.size(), 1);
+        ASSERT_EQ(node2_neighbours[0].neighbour_node.lock(), node1_);
+    }
+
+    {
+        auto node3_neighbours = node3_->GetNeighbours();
+        ASSERT_EQ(node3_neighbours.size(), 0);
+    }
+}
+
+TEST_F(NodeTest, DUMP) {
+    std::cout << node1_->Dump();
+    ASSERT_FALSE(node1_->Dump().empty());
+
+    std::cout << node2_->Dump();
+    ASSERT_FALSE(node2_->Dump().empty());
+}
+
diff --git a/core/unittest/scheduler/test_normal.cpp b/core/unittest/scheduler/test_normal.cpp
new file mode 100644
index 0000000000..59c15395e7
--- /dev/null
+++ b/core/unittest/scheduler/test_normal.cpp
@@ -0,0 +1,73 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "scheduler/ResourceFactory.h"
+#include "scheduler/ResourceMgr.h"
+#include "scheduler/Scheduler.h"
+#include "scheduler/task/TestTask.h"
+#include "scheduler/tasklabel/DefaultLabel.h"
+#include "scheduler/SchedInst.h"
+#include "utils/Log.h"
+#include <gtest/gtest.h>
+
+namespace {
+
+namespace ms = milvus::scheduler;
+
+} // namespace
+
+TEST(NormalTest, INST_TEST) {
+    // ResourceMgr only compose resources, provide unified event
+    auto res_mgr = ms::ResMgrInst::GetInstance();
+
+    res_mgr->Add(ms::ResourceFactory::Create("disk", "DISK", 0, true, false));
+    res_mgr->Add(ms::ResourceFactory::Create("cpu", "CPU", 0, true, true));
+
+    auto IO = ms::Connection("IO", 500.0);
+    res_mgr->Connect("disk", "cpu", IO);
+
+    auto scheduler = ms::SchedInst::GetInstance();
+
+    res_mgr->Start();
+    scheduler->Start();
+
+    const uint64_t NUM_TASK = 2;
+    std::vector<std::shared_ptr<ms::TestTask>> tasks;
+    ms::TableFileSchemaPtr dummy = nullptr;
+
+    auto disks = res_mgr->GetDiskResources();
+    ASSERT_FALSE(disks.empty());
+    if (auto observe = disks[0].lock()) {
+        for (uint64_t i = 0; i < NUM_TASK; ++i) {
+            auto label = std::make_shared<ms::DefaultLabel>();
+            auto task = std::make_shared<ms::TestTask>(dummy, label);
+            task->label() = std::make_shared<ms::DefaultLabel>();
+            tasks.push_back(task);
+            observe->task_table().Put(task);
+        }
+    }
+
+    for (auto &task : tasks) {
+        task->Wait();
+        ASSERT_EQ(task->load_count_, 1);
+        ASSERT_EQ(task->exec_count_, 1);
+    }
+
+    scheduler->Stop();
+    res_mgr->Stop();
+}
diff --git a/core/unittest/scheduler/test_resource.cpp b/core/unittest/scheduler/test_resource.cpp
new file mode 100644
index 0000000000..1ff0d9fdc1
--- /dev/null
+++ b/core/unittest/scheduler/test_resource.cpp
@@ -0,0 +1,292 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "scheduler/resource/Resource.h"
+#include "scheduler/resource/DiskResource.h"
+#include "scheduler/resource/CpuResource.h"
+#include "scheduler/resource/GpuResource.h"
+#include "scheduler/resource/TestResource.h"
+#include "scheduler/task/Task.h"
+#include "scheduler/task/TestTask.h"
+#include "scheduler/tasklabel/DefaultLabel.h"
+#include "scheduler/ResourceFactory.h"
+#include <gtest/gtest.h>
+
+
+namespace milvus {
+namespace scheduler {
+
+constexpr uint64_t max_once_load = 2;
+
+/************ ResourceBaseTest ************/
+class ResourceBaseTest : public testing::Test {
+ protected:
+    void
+    SetUp() override {
+        only_loader_ = std::make_shared<DiskResource>(name1, id1, true, false);
+        only_executor_ = std::make_shared<CpuResource>(name2, id2, false, true);
+        both_enable_ = std::make_shared<GpuResource>(name3, id3, true, true);
+        both_disable_ = std::make_shared<TestResource>(name4, id4, false, false);
+    }
+
+    const std::string name1 = "only_loader_";
+    const std::string name2 = "only_executor_";
+    const std::string name3 = "both_enable_";
+    const std::string name4 = "both_disable_";
+
+    const uint64_t id1 = 1;
+    const uint64_t id2 = 2;
+    const uint64_t id3 = 3;
+    const uint64_t id4 = 4;
+
+    ResourcePtr only_loader_ = nullptr;
+    ResourcePtr only_executor_ = nullptr;
+    ResourcePtr both_enable_ = nullptr;
+    ResourcePtr both_disable_ = nullptr;
+};
+
+TEST_F(ResourceBaseTest, NAME) {
+    ASSERT_EQ(only_loader_->name(), name1);
+    ASSERT_EQ(only_executor_->name(), name2);
+    ASSERT_EQ(both_enable_->name(), name3);
+    ASSERT_EQ(both_disable_->name(), name4);
+}
+
+TEST_F(ResourceBaseTest, TYPE) {
+    ASSERT_EQ(only_loader_->type(), ResourceType::DISK);
+    ASSERT_EQ(only_executor_->type(), ResourceType::CPU);
+    ASSERT_EQ(both_enable_->type(), ResourceType::GPU);
+    ASSERT_EQ(both_disable_->type(), ResourceType::TEST);
+}
+
+TEST_F(ResourceBaseTest, DEVICE_ID) {
+    ASSERT_EQ(only_loader_->device_id(), id1);
+    ASSERT_EQ(only_executor_->device_id(), id2);
+    ASSERT_EQ(both_enable_->device_id(), id3);
+    ASSERT_EQ(both_disable_->device_id(), id4);
+}
+
+TEST_F(ResourceBaseTest, HAS_LOADER) {
+    ASSERT_TRUE(only_loader_->HasLoader());
+    ASSERT_FALSE(only_executor_->HasLoader());
+    ASSERT_TRUE(both_enable_->HasLoader());
+    ASSERT_FALSE(both_disable_->HasLoader());
+}
+
+TEST_F(ResourceBaseTest, HAS_EXECUTOR) {
+    ASSERT_FALSE(only_loader_->HasExecutor());
+    ASSERT_TRUE(only_executor_->HasExecutor());
+    ASSERT_TRUE(both_enable_->HasExecutor());
+    ASSERT_FALSE(both_disable_->HasExecutor());
+}
+
+TEST_F(ResourceBaseTest, DUMP) {
+    ASSERT_FALSE(only_loader_->Dump().empty());
+    ASSERT_FALSE(only_executor_->Dump().empty());
+    ASSERT_FALSE(both_enable_->Dump().empty());
+    ASSERT_FALSE(both_disable_->Dump().empty());
+    std::cout << *only_loader_ << *only_executor_ << *both_enable_ << *both_disable_;
+}
+
+/************ ResourceAdvanceTest ************/
+
+class ResourceAdvanceTest : public testing::Test {
+ protected:
+    void
+    SetUp() override {
+        disk_resource_ = ResourceFactory::Create("ssd", "DISK", 0);
+        cpu_resource_ = ResourceFactory::Create("cpu", "CPU", 0);
+        gpu_resource_ = ResourceFactory::Create("gpu", "GPU", 0);
+        test_resource_ = std::make_shared<TestResource>("test", 0, true, true);
+        resources_.push_back(disk_resource_);
+        resources_.push_back(cpu_resource_);
+        resources_.push_back(gpu_resource_);
+        resources_.push_back(test_resource_);
+
+        auto subscriber = [&](EventPtr event) {
+            if (event->Type() == EventType::LOAD_COMPLETED) {
+                {
+                    std::lock_guard<std::mutex> lock(load_mutex_);
+                    ++load_count_;
+                }
+                cv_.notify_one();
+            }
+
+            if (event->Type() == EventType::FINISH_TASK) {
+                {
+                    std::lock_guard<std::mutex> lock(load_mutex_);
+                    ++exec_count_;
+                }
+                cv_.notify_one();
+            }
+        };
+
+        disk_resource_->RegisterSubscriber(subscriber);
+        cpu_resource_->RegisterSubscriber(subscriber);
+        gpu_resource_->RegisterSubscriber(subscriber);
+        test_resource_->RegisterSubscriber(subscriber);
+
+        disk_resource_->Start();
+        cpu_resource_->Start();
+        gpu_resource_->Start();
+        test_resource_->Start();
+    }
+
+    void
+    TearDown() override {
+        disk_resource_->Stop();
+        cpu_resource_->Stop();
+        gpu_resource_->Stop();
+        test_resource_->Stop();
+    }
+
+    void
+    WaitLoader(uint64_t count) {
+        std::unique_lock<std::mutex> lock(load_mutex_);
+        cv_.wait(lock, [&] {
+            return load_count_ == count;
+        });
+    }
+
+    void
+    WaitExecutor(uint64_t count) {
+        std::unique_lock<std::mutex> lock(exec_mutex_);
+        cv_.wait(lock, [&] {
+            return exec_count_ == count;
+        });
+    }
+
+    ResourcePtr disk_resource_;
+    ResourcePtr cpu_resource_;
+    ResourcePtr gpu_resource_;
+    ResourcePtr test_resource_;
+    std::vector<ResourcePtr> resources_;
+    uint64_t load_count_ = 0;
+    uint64_t exec_count_ = 0;
+    std::mutex load_mutex_;
+    std::mutex exec_mutex_;
+    std::condition_variable cv_;
+};
+
+TEST_F(ResourceAdvanceTest, DISK_RESOURCE_TEST) {
+    const uint64_t NUM = max_once_load;
+    std::vector<std::shared_ptr<TestTask>> tasks;
+    TableFileSchemaPtr dummy = nullptr;
+    for (uint64_t i = 0; i < NUM; ++i) {
+        auto label = std::make_shared<DefaultLabel>();
+        auto task = std::make_shared<TestTask>(dummy, label);
+        tasks.push_back(task);
+        disk_resource_->task_table().Put(task);
+    }
+
+    disk_resource_->WakeupLoader();
+    WaitLoader(NUM);
+
+    for (uint64_t i = 0; i < NUM; ++i) {
+        ASSERT_EQ(tasks[i]->load_count_, 0);
+    }
+
+    disk_resource_->WakeupExecutor();
+    WaitExecutor(NUM);
+
+    for (uint64_t i = 0; i < NUM; ++i) {
+        ASSERT_EQ(tasks[i]->exec_count_, 0);
+    }
+}
+
+TEST_F(ResourceAdvanceTest, CPU_RESOURCE_TEST) {
+    const uint64_t NUM = max_once_load;
+    std::vector<std::shared_ptr<TestTask>> tasks;
+    TableFileSchemaPtr dummy = nullptr;
+    for (uint64_t i = 0; i < NUM; ++i) {
+        auto label = std::make_shared<DefaultLabel>();
+        auto task = std::make_shared<TestTask>(dummy, label);
+        tasks.push_back(task);
+        cpu_resource_->task_table().Put(task);
+    }
+
+    cpu_resource_->WakeupLoader();
+    WaitLoader(NUM);
+
+    for (uint64_t i = 0; i < NUM; ++i) {
+        ASSERT_EQ(tasks[i]->load_count_, 1);
+    }
+
+    cpu_resource_->WakeupExecutor();
+    WaitExecutor(NUM);
+
+    for (uint64_t i = 0; i < NUM; ++i) {
+        ASSERT_EQ(tasks[i]->exec_count_, 1);
+    }
+}
+
+TEST_F(ResourceAdvanceTest, GPU_RESOURCE_TEST) {
+    const uint64_t NUM = max_once_load;
+    std::vector<std::shared_ptr<TestTask>> tasks;
+    TableFileSchemaPtr dummy = nullptr;
+    for (uint64_t i = 0; i < NUM; ++i) {
+        auto label = std::make_shared<DefaultLabel>();
+        auto task = std::make_shared<TestTask>(dummy, label);
+        tasks.push_back(task);
+        gpu_resource_->task_table().Put(task);
+    }
+
+    gpu_resource_->WakeupLoader();
+    WaitLoader(NUM);
+
+    for (uint64_t i = 0; i < NUM; ++i) {
+        ASSERT_EQ(tasks[i]->load_count_, 1);
+    }
+
+    gpu_resource_->WakeupExecutor();
+    WaitExecutor(NUM);
+
+    for (uint64_t i = 0; i < NUM; ++i) {
+        ASSERT_EQ(tasks[i]->exec_count_, 1);
+    }
+}
+
+TEST_F(ResourceAdvanceTest, TEST_RESOURCE_TEST) {
+    const uint64_t NUM = max_once_load;
+    std::vector<std::shared_ptr<TestTask>> tasks;
+    TableFileSchemaPtr dummy = nullptr;
+    for (uint64_t i = 0; i < NUM; ++i) {
+        auto label = std::make_shared<DefaultLabel>();
+        auto task = std::make_shared<TestTask>(dummy, label);
+        tasks.push_back(task);
+        test_resource_->task_table().Put(task);
+    }
+
+    test_resource_->WakeupLoader();
+    WaitLoader(NUM);
+
+    for (uint64_t i = 0; i < NUM; ++i) {
+        ASSERT_EQ(tasks[i]->load_count_, 1);
+    }
+
+    test_resource_->WakeupExecutor();
+    WaitExecutor(NUM);
+
+    for (uint64_t i = 0; i < NUM; ++i) {
+        ASSERT_EQ(tasks[i]->exec_count_, 1);
+    }
+}
+
+} // namespace scheduler
+} // namespace milvus
+
diff --git a/core/unittest/scheduler/test_resource_factory.cpp b/core/unittest/scheduler/test_resource_factory.cpp
new file mode 100644
index 0000000000..aaad3aa2c9
--- /dev/null
+++ b/core/unittest/scheduler/test_resource_factory.cpp
@@ -0,0 +1,36 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "scheduler/ResourceFactory.h"
+#include <gtest/gtest.h>
+
+namespace {
+
+namespace ms = milvus::scheduler;
+
+} // namespace
+
+TEST(ResourceFactoryTest, CREATE) {
+    auto disk = ms::ResourceFactory::Create("ssd", "DISK", 0);
+    auto cpu = ms::ResourceFactory::Create("cpu", "CPU", 0);
+    auto gpu = ms::ResourceFactory::Create("gpu", "GPU", 0);
+
+    ASSERT_TRUE(std::dynamic_pointer_cast<ms::DiskResource>(disk));
+    ASSERT_TRUE(std::dynamic_pointer_cast<ms::CpuResource>(cpu));
+    ASSERT_TRUE(std::dynamic_pointer_cast<ms::GpuResource>(gpu));
+}
diff --git a/core/unittest/scheduler/test_resource_mgr.cpp b/core/unittest/scheduler/test_resource_mgr.cpp
new file mode 100644
index 0000000000..2534f66439
--- /dev/null
+++ b/core/unittest/scheduler/test_resource_mgr.cpp
@@ -0,0 +1,199 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "scheduler/resource/CpuResource.h"
+#include "scheduler/resource/GpuResource.h"
+#include "scheduler/resource/DiskResource.h"
+#include "scheduler/resource/TestResource.h"
+#include "scheduler/task/TestTask.h"
+#include "scheduler/tasklabel/DefaultLabel.h"
+#include "scheduler/ResourceMgr.h"
+#include <gtest/gtest.h>
+
+
+namespace milvus {
+namespace scheduler {
+
+/************ ResourceMgrBaseTest ************/
+class ResourceMgrBaseTest : public testing::Test {
+ protected:
+    void
+    SetUp() override {
+        empty_mgr_ = std::make_shared<ResourceMgr>();
+        mgr1_ = std::make_shared<ResourceMgr>();
+        disk_res = std::make_shared<DiskResource>("disk", 0, true, false);
+        cpu_res = std::make_shared<CpuResource>("cpu", 1, true, false);
+        gpu_res = std::make_shared<GpuResource>("gpu", 2, true, true);
+        mgr1_->Add(ResourcePtr(disk_res));
+        mgr1_->Add(ResourcePtr(cpu_res));
+        mgr1_->Add(ResourcePtr(gpu_res));
+    }
+
+    void
+    TearDown() override {
+    }
+
+    ResourceMgrPtr empty_mgr_;
+    ResourceMgrPtr mgr1_;
+    ResourcePtr disk_res;
+    ResourcePtr cpu_res;
+    ResourcePtr gpu_res;
+};
+
+TEST_F(ResourceMgrBaseTest, ADD) {
+    auto resource = std::make_shared<TestResource>("test", 0, true, true);
+    auto ret = empty_mgr_->Add(ResourcePtr(resource));
+    ASSERT_EQ(ret.lock(), resource);
+}
+
+TEST_F(ResourceMgrBaseTest, ADD_DISK) {
+    auto resource = std::make_shared<DiskResource>("disk", 0, true, true);
+    auto ret = empty_mgr_->Add(ResourcePtr(resource));
+    ASSERT_EQ(ret.lock(), resource);
+}
+
+TEST_F(ResourceMgrBaseTest, CONNECT) {
+    auto resource1 = std::make_shared<TestResource>("resource1", 0, true, true);
+    auto resource2 = std::make_shared<TestResource>("resource2", 2, true, true);
+    empty_mgr_->Add(resource1);
+    empty_mgr_->Add(resource2);
+    Connection io("io", 500.0);
+    ASSERT_TRUE(empty_mgr_->Connect("resource1", "resource2", io));
+}
+
+TEST_F(ResourceMgrBaseTest, INVALID_CONNECT) {
+    auto resource1 = std::make_shared<TestResource>("resource1", 0, true, true);
+    auto resource2 = std::make_shared<TestResource>("resource2", 2, true, true);
+    empty_mgr_->Add(resource1);
+    empty_mgr_->Add(resource2);
+    Connection io("io", 500.0);
+    ASSERT_FALSE(empty_mgr_->Connect("xx", "yy", io));
+}
+
+TEST_F(ResourceMgrBaseTest, CLEAR) {
+    ASSERT_EQ(mgr1_->GetNumOfResource(), 3);
+    mgr1_->Clear();
+    ASSERT_EQ(mgr1_->GetNumOfResource(), 0);
+}
+
+TEST_F(ResourceMgrBaseTest, GET_DISK_RESOURCES) {
+    auto disks = mgr1_->GetDiskResources();
+    ASSERT_EQ(disks.size(), 1);
+    ASSERT_EQ(disks[0].lock(), disk_res);
+}
+
+TEST_F(ResourceMgrBaseTest, GET_ALL_RESOURCES) {
+    bool disk = false, cpu = false, gpu = false;
+    auto resources = mgr1_->GetAllResources();
+    ASSERT_EQ(resources.size(), 3);
+    for (auto &res : resources) {
+        if (res->type() == ResourceType::DISK) disk = true;
+        if (res->type() == ResourceType::CPU) cpu = true;
+        if (res->type() == ResourceType::GPU) gpu = true;
+    }
+
+    ASSERT_TRUE(disk);
+    ASSERT_TRUE(cpu);
+    ASSERT_TRUE(gpu);
+}
+
+TEST_F(ResourceMgrBaseTest, GET_COMPUTE_RESOURCES) {
+    auto compute_resources = mgr1_->GetComputeResources();
+    ASSERT_EQ(compute_resources.size(), 1);
+    ASSERT_EQ(compute_resources[0], gpu_res);
+}
+
+TEST_F(ResourceMgrBaseTest, GET_RESOURCE_BY_TYPE_AND_DEVICEID) {
+    auto cpu = mgr1_->GetResource(ResourceType::CPU, 1);
+    ASSERT_EQ(cpu, cpu_res);
+
+    auto invalid = mgr1_->GetResource(ResourceType::GPU, 1);
+    ASSERT_EQ(invalid, nullptr);
+}
+
+TEST_F(ResourceMgrBaseTest, GET_RESOURCE_BY_NAME) {
+    auto disk = mgr1_->GetResource("disk");
+    ASSERT_EQ(disk, disk_res);
+
+    auto invalid = mgr1_->GetResource("invalid");
+    ASSERT_EQ(invalid, nullptr);
+}
+
+TEST_F(ResourceMgrBaseTest, GET_NUM_OF_RESOURCE) {
+    ASSERT_EQ(empty_mgr_->GetNumOfResource(), 0);
+    ASSERT_EQ(mgr1_->GetNumOfResource(), 3);
+}
+
+TEST_F(ResourceMgrBaseTest, GET_NUM_OF_COMPUTE_RESOURCE) {
+    ASSERT_EQ(empty_mgr_->GetNumOfComputeResource(), 0);
+    ASSERT_EQ(mgr1_->GetNumOfComputeResource(), 1);
+}
+
+TEST_F(ResourceMgrBaseTest, GET_NUM_OF_GPU_RESOURCE) {
+    ASSERT_EQ(empty_mgr_->GetNumGpuResource(), 0);
+    ASSERT_EQ(mgr1_->GetNumGpuResource(), 1);
+}
+
+TEST_F(ResourceMgrBaseTest, DUMP) {
+    ASSERT_FALSE(mgr1_->Dump().empty());
+}
+
+TEST_F(ResourceMgrBaseTest, DUMP_TASKTABLES) {
+    ASSERT_FALSE(mgr1_->DumpTaskTables().empty());
+}
+
+/************ ResourceMgrAdvanceTest ************/
+
+class ResourceMgrAdvanceTest : public testing::Test {
+ protected:
+    void
+    SetUp() override {
+        mgr1_ = std::make_shared<ResourceMgr>();
+        disk_res = std::make_shared<DiskResource>("disk", 0, true, false);
+        cpu_res = std::make_shared<CpuResource>("cpu", 0, true, true);
+        mgr1_->Add(ResourcePtr(disk_res));
+        mgr1_->Add(ResourcePtr(cpu_res));
+        mgr1_->Start();
+    }
+
+    void
+    TearDown() override {
+        mgr1_->Stop();
+    }
+
+    ResourceMgrPtr mgr1_;
+    ResourcePtr disk_res;
+    ResourcePtr cpu_res;
+};
+
+TEST_F(ResourceMgrAdvanceTest, REGISTER_SUBSCRIBER) {
+    bool flag = false;
+    auto callback = [&](EventPtr event) {
+        flag = true;
+    };
+    mgr1_->RegisterSubscriber(callback);
+    TableFileSchemaPtr dummy = nullptr;
+    auto label = std::make_shared<DefaultLabel>();
+    disk_res->task_table().Put(std::make_shared<TestTask>(dummy, label));
+    sleep(1);
+    ASSERT_TRUE(flag);
+}
+
+} // namespace scheduler
+} // namespace milvus
+
diff --git a/core/unittest/scheduler/test_scheduler.cpp b/core/unittest/scheduler/test_scheduler.cpp
new file mode 100644
index 0000000000..aebdfa2af2
--- /dev/null
+++ b/core/unittest/scheduler/test_scheduler.cpp
@@ -0,0 +1,262 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 <gtest/gtest.h>
+
+#include "scheduler/Scheduler.h"
+#include "scheduler/tasklabel/DefaultLabel.h"
+#include "scheduler/tasklabel/SpecResLabel.h"
+#include "scheduler/task/TestTask.h"
+#include "scheduler/ResourceFactory.h"
+#include "scheduler/resource/Resource.h"
+#include "cache/DataObj.h"
+#include "cache/GpuCacheMgr.h"
+#include "utils/Error.h"
+#include "wrapper/VecIndex.h"
+
+namespace milvus {
+namespace scheduler {
+
+class MockVecIndex : public engine::VecIndex {
+ public:
+    virtual Status BuildAll(const int64_t& nb,
+                            const float* xb,
+                            const int64_t* ids,
+                            const engine::Config& cfg,
+                            const int64_t& nt = 0,
+                            const float* xt = nullptr) {
+    }
+
+    engine::VecIndexPtr Clone() override {
+        return milvus::engine::VecIndexPtr();
+    }
+
+    int64_t GetDeviceId() override {
+        return 0;
+    }
+
+    engine::IndexType GetType() override {
+        return engine::IndexType::INVALID;
+    }
+
+    virtual Status Add(const int64_t& nb,
+                       const float* xb,
+                       const int64_t* ids,
+                       const engine::Config& cfg = engine::Config()) {
+    }
+
+    virtual Status Search(const int64_t& nq,
+                          const float* xq,
+                          float* dist,
+                          int64_t* ids,
+                          const engine::Config& cfg = engine::Config()) {
+    }
+
+    engine::VecIndexPtr CopyToGpu(const int64_t& device_id, const engine::Config& cfg) override {
+    }
+
+    engine::VecIndexPtr CopyToCpu(const engine::Config& cfg) override {
+    }
+
+    virtual int64_t Dimension() {
+        return dimension_;
+    }
+
+    virtual int64_t Count() {
+        return ntotal_;
+    }
+
+    virtual knowhere::BinarySet Serialize() {
+        knowhere::BinarySet binset;
+        return binset;
+    }
+
+    virtual Status Load(const knowhere::BinarySet& index_binary) {
+    }
+
+ public:
+    int64_t dimension_ = 512;
+    int64_t ntotal_ = 0;
+};
+
+class SchedulerTest : public testing::Test {
+ protected:
+    void
+    SetUp() override {
+        constexpr int64_t cache_cap = 1024 * 1024 * 1024;
+        cache::GpuCacheMgr::GetInstance(0)->SetCapacity(cache_cap);
+        cache::GpuCacheMgr::GetInstance(1)->SetCapacity(cache_cap);
+
+        ResourcePtr disk = ResourceFactory::Create("disk", "DISK", 0, true, false);
+        ResourcePtr cpu = ResourceFactory::Create("cpu", "CPU", 0, true, false);
+        ResourcePtr gpu_0 = ResourceFactory::Create("gpu0", "GPU", 0);
+        ResourcePtr gpu_1 = ResourceFactory::Create("gpu1", "GPU", 1);
+
+        res_mgr_ = std::make_shared<ResourceMgr>();
+        disk_resource_ = res_mgr_->Add(std::move(disk));
+        cpu_resource_ = res_mgr_->Add(std::move(cpu));
+        gpu_resource_0_ = res_mgr_->Add(std::move(gpu_0));
+        gpu_resource_1_ = res_mgr_->Add(std::move(gpu_1));
+
+        auto PCIE = Connection("IO", 11000.0);
+        res_mgr_->Connect("cpu", "gpu0", PCIE);
+        res_mgr_->Connect("cpu", "gpu1", PCIE);
+
+        scheduler_ = std::make_shared<Scheduler>(res_mgr_);
+
+        res_mgr_->Start();
+        scheduler_->Start();
+    }
+
+    void
+    TearDown() override {
+        scheduler_->Stop();
+        res_mgr_->Stop();
+    }
+
+    ResourceWPtr disk_resource_;
+    ResourceWPtr cpu_resource_;
+    ResourceWPtr gpu_resource_0_;
+    ResourceWPtr gpu_resource_1_;
+
+    ResourceMgrPtr res_mgr_;
+    std::shared_ptr<Scheduler> scheduler_;
+};
+
+void
+insert_dummy_index_into_gpu_cache(uint64_t device_id) {
+    MockVecIndex* mock_index = new MockVecIndex();
+    mock_index->ntotal_ = 1000;
+    engine::VecIndexPtr index(mock_index);
+
+    cache::DataObjPtr obj = std::static_pointer_cast<cache::DataObj>(index);
+
+    cache::GpuCacheMgr::GetInstance(device_id)->InsertItem("location", obj);
+}
+
+TEST_F(SchedulerTest, ON_LOAD_COMPLETED) {
+    const uint64_t NUM = 10;
+    std::vector<std::shared_ptr<TestTask>> tasks;
+    TableFileSchemaPtr dummy = std::make_shared<TableFileSchema>();
+    dummy->location_ = "location";
+
+    insert_dummy_index_into_gpu_cache(1);
+
+    for (uint64_t i = 0; i < NUM; ++i) {
+        auto label = std::make_shared<DefaultLabel>();
+        auto task = std::make_shared<TestTask>(dummy, label);
+        task->label() = std::make_shared<DefaultLabel>();
+        tasks.push_back(task);
+        cpu_resource_.lock()->task_table().Put(task);
+    }
+
+    sleep(3);
+    ASSERT_EQ(res_mgr_->GetResource(ResourceType::GPU, 1)->task_table().Size(), NUM);
+}
+
+TEST_F(SchedulerTest, PUSH_TASK_TO_NEIGHBOUR_RANDOMLY_TEST) {
+    const uint64_t NUM = 10;
+    std::vector<std::shared_ptr<TestTask>> tasks;
+    TableFileSchemaPtr dummy1 = std::make_shared<TableFileSchema>();
+    dummy1->location_ = "location";
+
+    tasks.clear();
+
+    for (uint64_t i = 0; i < NUM; ++i) {
+        auto label = std::make_shared<DefaultLabel>();
+        auto task = std::make_shared<TestTask>(dummy1, label);
+        task->label() = std::make_shared<DefaultLabel>();
+        tasks.push_back(task);
+        cpu_resource_.lock()->task_table().Put(task);
+    }
+
+    sleep(3);
+//    ASSERT_EQ(res_mgr_->GetResource(ResourceType::GPU, 1)->task_table().Size(), NUM);
+}
+
+class SchedulerTest2 : public testing::Test {
+ protected:
+    void
+    SetUp() override {
+        ResourcePtr disk = ResourceFactory::Create("disk", "DISK", 0, true, false);
+        ResourcePtr cpu0 = ResourceFactory::Create("cpu0", "CPU", 0, true, false);
+        ResourcePtr cpu1 = ResourceFactory::Create("cpu1", "CPU", 1, true, false);
+        ResourcePtr cpu2 = ResourceFactory::Create("cpu2", "CPU", 2, true, false);
+        ResourcePtr gpu0 = ResourceFactory::Create("gpu0", "GPU", 0, true, true);
+        ResourcePtr gpu1 = ResourceFactory::Create("gpu1", "GPU", 1, true, true);
+
+        res_mgr_ = std::make_shared<ResourceMgr>();
+        disk_ = res_mgr_->Add(std::move(disk));
+        cpu_0_ = res_mgr_->Add(std::move(cpu0));
+        cpu_1_ = res_mgr_->Add(std::move(cpu1));
+        cpu_2_ = res_mgr_->Add(std::move(cpu2));
+        gpu_0_ = res_mgr_->Add(std::move(gpu0));
+        gpu_1_ = res_mgr_->Add(std::move(gpu1));
+        auto IO = Connection("IO", 5.0);
+        auto PCIE1 = Connection("PCIE", 11.0);
+        auto PCIE2 = Connection("PCIE", 20.0);
+        res_mgr_->Connect("disk", "cpu0", IO);
+        res_mgr_->Connect("cpu0", "cpu1", IO);
+        res_mgr_->Connect("cpu1", "cpu2", IO);
+        res_mgr_->Connect("cpu0", "cpu2", IO);
+        res_mgr_->Connect("cpu1", "gpu0", PCIE1);
+        res_mgr_->Connect("cpu2", "gpu1", PCIE2);
+
+        scheduler_ = std::make_shared<Scheduler>(res_mgr_);
+
+        res_mgr_->Start();
+        scheduler_->Start();
+    }
+
+    void
+    TearDown() override {
+        scheduler_->Stop();
+        res_mgr_->Stop();
+        res_mgr_->Clear();
+    }
+
+    ResourceWPtr disk_;
+    ResourceWPtr cpu_0_;
+    ResourceWPtr cpu_1_;
+    ResourceWPtr cpu_2_;
+    ResourceWPtr gpu_0_;
+    ResourceWPtr gpu_1_;
+    ResourceMgrPtr res_mgr_;
+
+    std::shared_ptr<Scheduler> scheduler_;
+};
+
+//TEST_F(SchedulerTest2, SPECIFIED_RESOURCE_TEST) {
+//    const uint64_t NUM = 2;
+//    std::vector<std::shared_ptr<TestTask>> tasks;
+//    TableFileSchemaPtr dummy = std::make_shared<TableFileSchema>();
+//    dummy->location_ = "location";
+//
+//    for (uint64_t i = 0; i < NUM; ++i) {
+//        auto label = std::make_shared<DefaultLabel>();
+//        std::shared_ptr<TestTask> task = std::make_shared<TestTask>(dummy, label);
+//        task->label() = std::make_shared<SpecResLabel>(disk_);
+//        tasks.push_back(task);
+//        disk_.lock()->task_table().Put(task);
+//    }
+
+//    ASSERT_EQ(res_mgr_->GetResource(ResourceType::GPU, 1)->task_table().Size(), NUM);
+//}
+
+} // namespace scheduler
+} // namespace milvus
+
diff --git a/core/unittest/scheduler/test_tasktable.cpp b/core/unittest/scheduler/test_tasktable.cpp
new file mode 100644
index 0000000000..e717e40285
--- /dev/null
+++ b/core/unittest/scheduler/test_tasktable.cpp
@@ -0,0 +1,470 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "scheduler/TaskTable.h"
+#include "scheduler/task/TestTask.h"
+#include "scheduler/tasklabel/DefaultLabel.h"
+#include <gtest/gtest.h>
+
+/************ TaskTableBaseTest ************/
+
+class TaskTableItemTest : public ::testing::Test {
+ protected:
+    void
+    SetUp() override {
+        std::vector<milvus::scheduler::TaskTableItemState> states{
+            milvus::scheduler::TaskTableItemState::INVALID,
+            milvus::scheduler::TaskTableItemState::START,
+            milvus::scheduler::TaskTableItemState::LOADING,
+            milvus::scheduler::TaskTableItemState::LOADED,
+            milvus::scheduler::TaskTableItemState::EXECUTING,
+            milvus::scheduler::TaskTableItemState::EXECUTED,
+            milvus::scheduler::TaskTableItemState::MOVING,
+            milvus::scheduler::TaskTableItemState::MOVED};
+        for (auto &state : states) {
+            auto item = std::make_shared<milvus::scheduler::TaskTableItem>();
+            item->state = state;
+            items_.emplace_back(item);
+        }
+    }
+
+    milvus::scheduler::TaskTableItem default_;
+    std::vector<milvus::scheduler::TaskTableItemPtr> items_;
+};
+
+TEST_F(TaskTableItemTest, CONSTRUCT) {
+    ASSERT_EQ(default_.id, 0);
+    ASSERT_EQ(default_.task, nullptr);
+    ASSERT_EQ(default_.state, milvus::scheduler::TaskTableItemState::INVALID);
+}
+
+TEST_F(TaskTableItemTest, DESTRUCT) {
+    auto p_item = new milvus::scheduler::TaskTableItem();
+    delete p_item;
+}
+
+TEST_F(TaskTableItemTest, IS_FINISH) {
+    for (auto &item : items_) {
+        if (item->state == milvus::scheduler::TaskTableItemState::EXECUTED
+            || item->state == milvus::scheduler::TaskTableItemState::MOVED) {
+            ASSERT_TRUE(item->IsFinish());
+        } else {
+            ASSERT_FALSE(item->IsFinish());
+        }
+    }
+}
+
+TEST_F(TaskTableItemTest, DUMP) {
+    for (auto &item : items_) {
+        ASSERT_FALSE(item->Dump().empty());
+    }
+}
+
+TEST_F(TaskTableItemTest, LOAD) {
+    for (auto &item : items_) {
+        auto before_state = item->state;
+        auto ret = item->Load();
+        if (before_state == milvus::scheduler::TaskTableItemState::START) {
+            ASSERT_TRUE(ret);
+            ASSERT_EQ(item->state, milvus::scheduler::TaskTableItemState::LOADING);
+        } else {
+            ASSERT_FALSE(ret);
+            ASSERT_EQ(item->state, before_state);
+        }
+    }
+}
+
+TEST_F(TaskTableItemTest, LOADED) {
+    for (auto &item : items_) {
+        auto before_state = item->state;
+        auto ret = item->Loaded();
+        if (before_state == milvus::scheduler::TaskTableItemState::LOADING) {
+            ASSERT_TRUE(ret);
+            ASSERT_EQ(item->state, milvus::scheduler::TaskTableItemState::LOADED);
+        } else {
+            ASSERT_FALSE(ret);
+            ASSERT_EQ(item->state, before_state);
+        }
+    }
+}
+
+TEST_F(TaskTableItemTest, EXECUTE) {
+    for (auto &item : items_) {
+        auto before_state = item->state;
+        auto ret = item->Execute();
+        if (before_state == milvus::scheduler::TaskTableItemState::LOADED) {
+            ASSERT_TRUE(ret);
+            ASSERT_EQ(item->state, milvus::scheduler::TaskTableItemState::EXECUTING);
+        } else {
+            ASSERT_FALSE(ret);
+            ASSERT_EQ(item->state, before_state);
+        }
+    }
+}
+
+TEST_F(TaskTableItemTest, EXECUTED) {
+    for (auto &item : items_) {
+        auto before_state = item->state;
+        auto ret = item->Executed();
+        if (before_state == milvus::scheduler::TaskTableItemState::EXECUTING) {
+            ASSERT_TRUE(ret);
+            ASSERT_EQ(item->state, milvus::scheduler::TaskTableItemState::EXECUTED);
+        } else {
+            ASSERT_FALSE(ret);
+            ASSERT_EQ(item->state, before_state);
+        }
+    }
+}
+
+TEST_F(TaskTableItemTest, MOVE) {
+    for (auto &item : items_) {
+        auto before_state = item->state;
+        auto ret = item->Move();
+        if (before_state == milvus::scheduler::TaskTableItemState::LOADED) {
+            ASSERT_TRUE(ret);
+            ASSERT_EQ(item->state, milvus::scheduler::TaskTableItemState::MOVING);
+        } else {
+            ASSERT_FALSE(ret);
+            ASSERT_EQ(item->state, before_state);
+        }
+    }
+}
+
+TEST_F(TaskTableItemTest, MOVED) {
+    for (auto &item : items_) {
+        auto before_state = item->state;
+        auto ret = item->Moved();
+        if (before_state == milvus::scheduler::TaskTableItemState::MOVING) {
+            ASSERT_TRUE(ret);
+            ASSERT_EQ(item->state, milvus::scheduler::TaskTableItemState::MOVED);
+        } else {
+            ASSERT_FALSE(ret);
+            ASSERT_EQ(item->state, before_state);
+        }
+    }
+}
+
+/************ TaskTableBaseTest ************/
+
+class TaskTableBaseTest : public ::testing::Test {
+ protected:
+    void
+    SetUp() override {
+        milvus::scheduler::TableFileSchemaPtr dummy = nullptr;
+        invalid_task_ = nullptr;
+        auto label = std::make_shared<milvus::scheduler::DefaultLabel>();
+        task1_ = std::make_shared<milvus::scheduler::TestTask>(dummy, label);
+        task2_ = std::make_shared<milvus::scheduler::TestTask>(dummy, label);
+    }
+
+    milvus::scheduler::TaskPtr invalid_task_;
+    milvus::scheduler::TaskPtr task1_;
+    milvus::scheduler::TaskPtr task2_;
+    milvus::scheduler::TaskTable empty_table_;
+};
+
+TEST_F(TaskTableBaseTest, SUBSCRIBER) {
+    bool flag = false;
+    auto callback = [&]() {
+        flag = true;
+    };
+    empty_table_.RegisterSubscriber(callback);
+    empty_table_.Put(task1_);
+    ASSERT_TRUE(flag);
+}
+
+TEST_F(TaskTableBaseTest, PUT_TASK) {
+    empty_table_.Put(task1_);
+    ASSERT_EQ(empty_table_.Get(0)->task, task1_);
+}
+
+TEST_F(TaskTableBaseTest, PUT_INVALID_TEST) {
+    empty_table_.Put(invalid_task_);
+    ASSERT_EQ(empty_table_.Get(0)->task, invalid_task_);
+}
+
+TEST_F(TaskTableBaseTest, PUT_BATCH) {
+    std::vector<milvus::scheduler::TaskPtr> tasks{task1_, task2_};
+    empty_table_.Put(tasks);
+    ASSERT_EQ(empty_table_.Get(0)->task, task1_);
+    ASSERT_EQ(empty_table_.Get(1)->task, task2_);
+}
+
+TEST_F(TaskTableBaseTest, PUT_EMPTY_BATCH) {
+    std::vector<milvus::scheduler::TaskPtr> tasks{};
+    empty_table_.Put(tasks);
+}
+
+TEST_F(TaskTableBaseTest, EMPTY) {
+    ASSERT_TRUE(empty_table_.Empty());
+    empty_table_.Put(task1_);
+    ASSERT_FALSE(empty_table_.Empty());
+}
+
+TEST_F(TaskTableBaseTest, SIZE) {
+    ASSERT_EQ(empty_table_.Size(), 0);
+    empty_table_.Put(task1_);
+    ASSERT_EQ(empty_table_.Size(), 1);
+}
+
+TEST_F(TaskTableBaseTest, OPERATOR) {
+    empty_table_.Put(task1_);
+    ASSERT_EQ(empty_table_.Get(0), empty_table_[0]);
+}
+
+TEST_F(TaskTableBaseTest, PICK_TO_LOAD) {
+    const size_t NUM_TASKS = 10;
+    for (size_t i = 0; i < NUM_TASKS; ++i) {
+        empty_table_.Put(task1_);
+    }
+    empty_table_[0]->state = milvus::scheduler::TaskTableItemState::MOVED;
+    empty_table_[1]->state = milvus::scheduler::TaskTableItemState::EXECUTED;
+
+    auto indexes = empty_table_.PickToLoad(1);
+    ASSERT_EQ(indexes.size(), 1);
+    ASSERT_EQ(indexes[0], 2);
+}
+
+TEST_F(TaskTableBaseTest, PICK_TO_LOAD_LIMIT) {
+    const size_t NUM_TASKS = 10;
+    for (size_t i = 0; i < NUM_TASKS; ++i) {
+        empty_table_.Put(task1_);
+    }
+    empty_table_[0]->state = milvus::scheduler::TaskTableItemState::MOVED;
+    empty_table_[1]->state = milvus::scheduler::TaskTableItemState::EXECUTED;
+
+    auto indexes = empty_table_.PickToLoad(3);
+    ASSERT_EQ(indexes.size(), 3);
+    ASSERT_EQ(indexes[0], 2);
+    ASSERT_EQ(indexes[1], 3);
+    ASSERT_EQ(indexes[2], 4);
+}
+
+TEST_F(TaskTableBaseTest, PICK_TO_LOAD_CACHE) {
+    const size_t NUM_TASKS = 10;
+    for (size_t i = 0; i < NUM_TASKS; ++i) {
+        empty_table_.Put(task1_);
+    }
+    empty_table_[0]->state = milvus::scheduler::TaskTableItemState::MOVED;
+    empty_table_[1]->state = milvus::scheduler::TaskTableItemState::EXECUTED;
+
+    // first pick, non-cache
+    auto indexes = empty_table_.PickToLoad(1);
+    ASSERT_EQ(indexes.size(), 1);
+    ASSERT_EQ(indexes[0], 2);
+
+    // second pick, iterate from 2
+    // invalid state change
+    empty_table_[1]->state = milvus::scheduler::TaskTableItemState::START;
+    indexes = empty_table_.PickToLoad(1);
+    ASSERT_EQ(indexes.size(), 1);
+    ASSERT_EQ(indexes[0], 2);
+}
+
+TEST_F(TaskTableBaseTest, PICK_TO_EXECUTE) {
+    const size_t NUM_TASKS = 10;
+    for (size_t i = 0; i < NUM_TASKS; ++i) {
+        empty_table_.Put(task1_);
+    }
+    empty_table_[0]->state = milvus::scheduler::TaskTableItemState::MOVED;
+    empty_table_[1]->state = milvus::scheduler::TaskTableItemState::EXECUTED;
+    empty_table_[2]->state = milvus::scheduler::TaskTableItemState::LOADED;
+
+    auto indexes = empty_table_.PickToExecute(1);
+    ASSERT_EQ(indexes.size(), 1);
+    ASSERT_EQ(indexes[0], 2);
+}
+
+TEST_F(TaskTableBaseTest, PICK_TO_EXECUTE_LIMIT) {
+    const size_t NUM_TASKS = 10;
+    for (size_t i = 0; i < NUM_TASKS; ++i) {
+        empty_table_.Put(task1_);
+    }
+    empty_table_[0]->state = milvus::scheduler::TaskTableItemState::MOVED;
+    empty_table_[1]->state = milvus::scheduler::TaskTableItemState::EXECUTED;
+    empty_table_[2]->state = milvus::scheduler::TaskTableItemState::LOADED;
+    empty_table_[3]->state = milvus::scheduler::TaskTableItemState::LOADED;
+
+    auto indexes = empty_table_.PickToExecute(3);
+    ASSERT_EQ(indexes.size(), 2);
+    ASSERT_EQ(indexes[0], 2);
+    ASSERT_EQ(indexes[1], 3);
+}
+
+TEST_F(TaskTableBaseTest, PICK_TO_EXECUTE_CACHE) {
+    const size_t NUM_TASKS = 10;
+    for (size_t i = 0; i < NUM_TASKS; ++i) {
+        empty_table_.Put(task1_);
+    }
+    empty_table_[0]->state = milvus::scheduler::TaskTableItemState::MOVED;
+    empty_table_[1]->state = milvus::scheduler::TaskTableItemState::EXECUTED;
+    empty_table_[2]->state = milvus::scheduler::TaskTableItemState::LOADED;
+
+    // first pick, non-cache
+    auto indexes = empty_table_.PickToExecute(1);
+    ASSERT_EQ(indexes.size(), 1);
+    ASSERT_EQ(indexes[0], 2);
+
+    // second pick, iterate from 2
+    // invalid state change
+    empty_table_[1]->state = milvus::scheduler::TaskTableItemState::START;
+    indexes = empty_table_.PickToExecute(1);
+    ASSERT_EQ(indexes.size(), 1);
+    ASSERT_EQ(indexes[0], 2);
+}
+
+/************ TaskTableAdvanceTest ************/
+
+class TaskTableAdvanceTest : public ::testing::Test {
+ protected:
+    void
+    SetUp() override {
+        milvus::scheduler::TableFileSchemaPtr dummy = nullptr;
+        for (uint64_t i = 0; i < 8; ++i) {
+            auto label = std::make_shared<milvus::scheduler::DefaultLabel>();
+            auto task = std::make_shared<milvus::scheduler::TestTask>(dummy, label);
+            table1_.Put(task);
+        }
+
+        table1_.Get(0)->state = milvus::scheduler::TaskTableItemState::INVALID;
+        table1_.Get(1)->state = milvus::scheduler::TaskTableItemState::START;
+        table1_.Get(2)->state = milvus::scheduler::TaskTableItemState::LOADING;
+        table1_.Get(3)->state = milvus::scheduler::TaskTableItemState::LOADED;
+        table1_.Get(4)->state = milvus::scheduler::TaskTableItemState::EXECUTING;
+        table1_.Get(5)->state = milvus::scheduler::TaskTableItemState::EXECUTED;
+        table1_.Get(6)->state = milvus::scheduler::TaskTableItemState::MOVING;
+        table1_.Get(7)->state = milvus::scheduler::TaskTableItemState::MOVED;
+    }
+
+    milvus::scheduler::TaskTable table1_;
+};
+
+TEST_F(TaskTableAdvanceTest, LOAD) {
+    std::vector<milvus::scheduler::TaskTableItemState> before_state;
+    for (auto &task : table1_) {
+        before_state.push_back(task->state);
+    }
+
+    for (size_t i = 0; i < table1_.Size(); ++i) {
+        table1_.Load(i);
+    }
+
+    for (size_t i = 0; i < table1_.Size(); ++i) {
+        if (before_state[i] == milvus::scheduler::TaskTableItemState::START) {
+            ASSERT_EQ(table1_.Get(i)->state, milvus::scheduler::TaskTableItemState::LOADING);
+        } else {
+            ASSERT_EQ(table1_.Get(i)->state, before_state[i]);
+        }
+    }
+}
+
+TEST_F(TaskTableAdvanceTest, LOADED) {
+    std::vector<milvus::scheduler::TaskTableItemState> before_state;
+    for (auto &task : table1_) {
+        before_state.push_back(task->state);
+    }
+
+    for (size_t i = 0; i < table1_.Size(); ++i) {
+        table1_.Loaded(i);
+    }
+
+    for (size_t i = 0; i < table1_.Size(); ++i) {
+        if (before_state[i] == milvus::scheduler::TaskTableItemState::LOADING) {
+            ASSERT_EQ(table1_.Get(i)->state, milvus::scheduler::TaskTableItemState::LOADED);
+        } else {
+            ASSERT_EQ(table1_.Get(i)->state, before_state[i]);
+        }
+    }
+}
+
+TEST_F(TaskTableAdvanceTest, EXECUTE) {
+    std::vector<milvus::scheduler::TaskTableItemState> before_state;
+    for (auto &task : table1_) {
+        before_state.push_back(task->state);
+    }
+
+    for (size_t i = 0; i < table1_.Size(); ++i) {
+        table1_.Execute(i);
+    }
+
+    for (size_t i = 0; i < table1_.Size(); ++i) {
+        if (before_state[i] == milvus::scheduler::TaskTableItemState::LOADED) {
+            ASSERT_EQ(table1_.Get(i)->state, milvus::scheduler::TaskTableItemState::EXECUTING);
+        } else {
+            ASSERT_EQ(table1_.Get(i)->state, before_state[i]);
+        }
+    }
+}
+
+TEST_F(TaskTableAdvanceTest, EXECUTED) {
+    std::vector<milvus::scheduler::TaskTableItemState> before_state;
+    for (auto &task : table1_) {
+        before_state.push_back(task->state);
+    }
+
+    for (size_t i = 0; i < table1_.Size(); ++i) {
+        table1_.Executed(i);
+    }
+
+    for (size_t i = 0; i < table1_.Size(); ++i) {
+        if (before_state[i] == milvus::scheduler::TaskTableItemState::EXECUTING) {
+            ASSERT_EQ(table1_.Get(i)->state, milvus::scheduler::TaskTableItemState::EXECUTED);
+        } else {
+            ASSERT_EQ(table1_.Get(i)->state, before_state[i]);
+        }
+    }
+}
+
+TEST_F(TaskTableAdvanceTest, MOVE) {
+    std::vector<milvus::scheduler::TaskTableItemState> before_state;
+    for (auto &task : table1_) {
+        before_state.push_back(task->state);
+    }
+
+    for (size_t i = 0; i < table1_.Size(); ++i) {
+        table1_.Move(i);
+    }
+
+    for (size_t i = 0; i < table1_.Size(); ++i) {
+        if (before_state[i] == milvus::scheduler::TaskTableItemState::LOADED) {
+            ASSERT_EQ(table1_.Get(i)->state, milvus::scheduler::TaskTableItemState::MOVING);
+        } else {
+            ASSERT_EQ(table1_.Get(i)->state, before_state[i]);
+        }
+    }
+}
+
+TEST_F(TaskTableAdvanceTest, MOVED) {
+    std::vector<milvus::scheduler::TaskTableItemState> before_state;
+    for (auto &task : table1_) {
+        before_state.push_back(task->state);
+    }
+
+    for (size_t i = 0; i < table1_.Size(); ++i) {
+        table1_.Moved(i);
+    }
+
+    for (size_t i = 0; i < table1_.Size(); ++i) {
+        if (before_state[i] == milvus::scheduler::TaskTableItemState::MOVING) {
+            ASSERT_EQ(table1_.Get(i)->state, milvus::scheduler::TaskTableItemState::MOVED);
+        } else {
+            ASSERT_EQ(table1_.Get(i)->state, before_state[i]);
+        }
+    }
+}
+
diff --git a/core/unittest/server/CMakeLists.txt b/core/unittest/server/CMakeLists.txt
new file mode 100644
index 0000000000..180dcfa6d5
--- /dev/null
+++ b/core/unittest/server/CMakeLists.txt
@@ -0,0 +1,69 @@
+#-------------------------------------------------------------------------------
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you 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.
+#-------------------------------------------------------------------------------
+
+aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR} test_files)
+
+include_directories("${CUDA_TOOLKIT_ROOT_DIR}/include")
+link_directories("${CUDA_TOOLKIT_ROOT_DIR}/lib64")
+
+include_directories(${MILVUS_ENGINE_SRC}/grpc/gen-status)
+include_directories(${MILVUS_ENGINE_SRC}/grpc/gen-milvus)
+
+set(util_files
+        ${MILVUS_ENGINE_SRC}/utils/StringHelpFunctions.cpp
+        ${MILVUS_ENGINE_SRC}/utils/LogUtil.cpp
+        ${MILVUS_ENGINE_SRC}/utils/SignalUtil.cpp)
+
+set(grpc_service_files
+        ${MILVUS_ENGINE_SRC}/grpc/gen-milvus/milvus.grpc.pb.cc
+        ${MILVUS_ENGINE_SRC}/grpc/gen-milvus/milvus.pb.cc
+        ${MILVUS_ENGINE_SRC}/grpc/gen-status/status.grpc.pb.cc
+        ${MILVUS_ENGINE_SRC}/grpc/gen-status/status.pb.cc
+        )
+
+set(server_test_files
+        ${common_files}
+        ${server_files}
+        ${grpc_server_files}
+        ${grpc_service_files}
+        ${util_files}
+        ${entry_file}
+        ${test_files}
+        )
+
+cuda_add_executable(test_server ${server_test_files})
+
+set(client_grpc_lib
+        grpcpp_channelz
+        grpc++
+        grpc
+        grpc_protobuf
+        grpc_protoc)
+
+target_link_libraries(test_server
+        knowhere
+        stdc++
+        snappy
+        bz2
+        zstd
+        ${client_grpc_lib}
+        ${unittest_libs}
+        )
+
+install(TARGETS test_server DESTINATION unittest)
diff --git a/core/unittest/server/test_cache.cpp b/core/unittest/server/test_cache.cpp
new file mode 100644
index 0000000000..dd55e7aef6
--- /dev/null
+++ b/core/unittest/server/test_cache.cpp
@@ -0,0 +1,233 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 <gtest/gtest.h>
+#include "cache/CpuCacheMgr.h"
+#include "cache/GpuCacheMgr.h"
+#include "utils/Error.h"
+#include "wrapper/VecIndex.h"
+
+namespace {
+
+class InvalidCacheMgr : public milvus::cache::CacheMgr<milvus::cache::DataObjPtr> {
+ public:
+    InvalidCacheMgr() {
+    }
+};
+
+class LessItemCacheMgr : public milvus::cache::CacheMgr<milvus::cache::DataObjPtr> {
+ public:
+    LessItemCacheMgr() {
+        cache_ = std::make_shared<milvus::cache::Cache<milvus::cache::DataObjPtr>>(1UL << 12, 10);
+    }
+};
+
+class MockVecIndex : public milvus::engine::VecIndex {
+ public:
+    MockVecIndex(int64_t dim, int64_t total)
+        : dimension_(dim),
+          ntotal_(total) {
+    }
+
+    virtual milvus::Status BuildAll(const int64_t &nb,
+                                const float *xb,
+                                const int64_t *ids,
+                                const milvus::engine::Config &cfg,
+                                const int64_t &nt = 0,
+                                const float *xt = nullptr) {
+        return milvus::Status();
+    }
+
+    milvus::engine::VecIndexPtr Clone() override {
+        return milvus::engine::VecIndexPtr();
+    }
+
+    int64_t GetDeviceId() override {
+        return 0;
+    }
+
+    milvus::engine::IndexType GetType() override {
+        return milvus::engine::IndexType::INVALID;
+    }
+
+    virtual milvus::Status Add(const int64_t &nb,
+                           const float *xb,
+                           const int64_t *ids,
+                           const milvus::engine::Config &cfg = milvus::engine::Config()) {
+        return milvus::Status();
+    }
+
+    virtual milvus::Status Search(const int64_t &nq,
+                              const float *xq,
+                              float *dist,
+                              int64_t *ids,
+                              const milvus::engine::Config &cfg = milvus::engine::Config()) {
+        return milvus::Status();
+    }
+
+    milvus::engine::VecIndexPtr CopyToGpu(const int64_t &device_id,
+                                      const milvus::engine::Config &cfg) override {
+        return nullptr;
+    }
+
+    milvus::engine::VecIndexPtr CopyToCpu(const milvus::engine::Config &cfg) override {
+        return nullptr;
+    }
+
+    virtual int64_t Dimension() {
+        return dimension_;
+    }
+
+    virtual int64_t Count() {
+        return ntotal_;
+    }
+
+    virtual knowhere::BinarySet Serialize() {
+        knowhere::BinarySet binset;
+        return binset;
+    }
+
+    virtual milvus::Status Load(const knowhere::BinarySet &index_binary) {
+        return milvus::Status();
+    }
+
+ public:
+    int64_t dimension_ = 256;
+    int64_t ntotal_ = 0;
+};
+
+} // namespace
+
+TEST(CacheTest, DUMMY_TEST) {
+    milvus::engine::Config cfg;
+    MockVecIndex mock_index(256, 1000);
+    mock_index.Dimension();
+    mock_index.Count();
+    mock_index.Add(1, nullptr, nullptr);
+    mock_index.BuildAll(1, nullptr, nullptr, cfg);
+    mock_index.Search(1, nullptr, nullptr, nullptr, cfg);
+    mock_index.Clone();
+    mock_index.CopyToCpu(cfg);
+    mock_index.CopyToGpu(1, cfg);
+    mock_index.GetDeviceId();
+    mock_index.GetType();
+    knowhere::BinarySet index_binary;
+    mock_index.Load(index_binary);
+    mock_index.Serialize();
+}
+
+TEST(CacheTest, CPU_CACHE_TEST) {
+    auto cpu_mgr = milvus::cache::CpuCacheMgr::GetInstance();
+
+    const int64_t gbyte = 1024 * 1024 * 1024;
+    int64_t g_num = 16;
+    int64_t cap = g_num * gbyte;
+    cpu_mgr->SetCapacity(cap);
+    ASSERT_EQ(cpu_mgr->CacheCapacity(), cap);
+
+    uint64_t item_count = 20;
+    for (uint64_t i = 0; i < item_count; i++) {
+        //each vector is 1k byte, total size less than 1G
+        milvus::engine::VecIndexPtr mock_index = std::make_shared<MockVecIndex>(256, 1000000);
+        milvus::cache::DataObjPtr data_obj = std::static_pointer_cast<milvus::cache::DataObj>(mock_index);
+        cpu_mgr->InsertItem("index_" + std::to_string(i), data_obj);
+    }
+    ASSERT_LT(cpu_mgr->ItemCount(), g_num);
+
+    auto obj = cpu_mgr->GetIndex("index_0");
+    ASSERT_TRUE(obj == nullptr);
+
+    obj = cpu_mgr->GetIndex("index_" + std::to_string(item_count - 1));
+    ASSERT_TRUE(obj != nullptr);
+
+    {
+        std::string item = "index_15";
+        ASSERT_TRUE(cpu_mgr->ItemExists(item));
+        cpu_mgr->EraseItem(item);
+        ASSERT_FALSE(cpu_mgr->ItemExists(item));
+    }
+
+    {
+        g_num = 5;
+        cpu_mgr->SetCapacity(g_num * gbyte);
+
+        //each vector is 1k byte, total size less than 6G
+        milvus::engine::VecIndexPtr mock_index = std::make_shared<MockVecIndex>(256, 6000000);
+        milvus::cache::DataObjPtr data_obj = std::static_pointer_cast<milvus::cache::DataObj>(mock_index);
+        cpu_mgr->InsertItem("index_6g", data_obj);
+        ASSERT_TRUE(cpu_mgr->ItemExists("index_6g"));
+    }
+
+    cpu_mgr->PrintInfo();
+}
+
+TEST(CacheTest, GPU_CACHE_TEST) {
+    auto gpu_mgr = milvus::cache::GpuCacheMgr::GetInstance(0);
+
+    for (int i = 0; i < 20; i++) {
+        //each vector is 1k byte
+        milvus::engine::VecIndexPtr mock_index = std::make_shared<MockVecIndex>(256, 1000);
+        milvus::cache::DataObjPtr data_obj = std::static_pointer_cast<milvus::cache::DataObj>(mock_index);
+        gpu_mgr->InsertItem("index_" + std::to_string(i), data_obj);
+    }
+
+    auto obj = gpu_mgr->GetItem("index_0");
+
+    gpu_mgr->ClearCache();
+    ASSERT_EQ(gpu_mgr->ItemCount(), 0);
+
+    for (auto i = 0; i < 3; i++) {
+        // TODO(myh): use gpu index to mock
+        //each vector is 1k byte, total size less than 2G
+        milvus::engine::VecIndexPtr mock_index = std::make_shared<MockVecIndex>(256, 2000000);
+        milvus::cache::DataObjPtr data_obj = std::static_pointer_cast<milvus::cache::DataObj>(mock_index);
+        std::cout << data_obj->Size() << std::endl;
+        gpu_mgr->InsertItem("index_" + std::to_string(i), data_obj);
+    }
+
+    gpu_mgr->ClearCache();
+    ASSERT_EQ(gpu_mgr->ItemCount(), 0);
+}
+
+TEST(CacheTest, INVALID_TEST) {
+    {
+        InvalidCacheMgr mgr;
+        ASSERT_EQ(mgr.ItemCount(), 0);
+        ASSERT_FALSE(mgr.ItemExists("test"));
+        ASSERT_EQ(mgr.GetItem("test"), nullptr);
+
+        mgr.InsertItem("test", milvus::cache::DataObjPtr());
+        mgr.InsertItem("test", nullptr);
+        mgr.EraseItem("test");
+        mgr.PrintInfo();
+        mgr.ClearCache();
+        mgr.SetCapacity(100);
+        ASSERT_EQ(mgr.CacheCapacity(), 0);
+        ASSERT_EQ(mgr.CacheUsage(), 0);
+    }
+
+    {
+        LessItemCacheMgr mgr;
+        for (int i = 0; i < 20; i++) {
+            //each vector is 1k byte
+            milvus::engine::VecIndexPtr mock_index = std::make_shared<MockVecIndex>(256, 2);
+            milvus::cache::DataObjPtr data_obj = std::static_pointer_cast<milvus::cache::DataObj>(mock_index);
+            mgr.InsertItem("index_" + std::to_string(i), data_obj);
+        }
+        ASSERT_EQ(mgr.GetItem("index_0"), nullptr);
+    }
+}
diff --git a/core/unittest/server/test_config.cpp b/core/unittest/server/test_config.cpp
new file mode 100644
index 0000000000..f3adf8a2c3
--- /dev/null
+++ b/core/unittest/server/test_config.cpp
@@ -0,0 +1,114 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 <gtest/gtest.h>
+#include <gtest/gtest-death-test.h>
+
+#include "config/YamlConfigMgr.h"
+#include "utils/CommonUtil.h"
+#include "utils/ValidationUtil.h"
+#include "server/Config.h"
+#include "server/utils.h"
+
+namespace {
+
+static constexpr uint64_t KB = 1024;
+static constexpr uint64_t MB = KB * 1024;
+static constexpr uint64_t GB = MB * 1024;
+
+} // namespace
+
+TEST_F(ConfigTest, CONFIG_TEST) {
+    milvus::server::ConfigMgr *config_mgr = milvus::server::YamlConfigMgr::GetInstance();
+
+    milvus::Status s = config_mgr->LoadConfigFile("");
+    ASSERT_FALSE(s.ok());
+
+    std::string config_path(CONFIG_PATH);
+    s = config_mgr->LoadConfigFile(config_path+ INVALID_CONFIG_FILE);
+    ASSERT_FALSE(s.ok());
+
+    s = config_mgr->LoadConfigFile(config_path + VALID_CONFIG_FILE);
+    ASSERT_TRUE(s.ok());
+
+    config_mgr->Print();
+
+    milvus::server::ConfigNode &root_config = config_mgr->GetRootNode();
+    milvus::server::ConfigNode &server_config = root_config.GetChild("server_config");
+    milvus::server::ConfigNode &db_config = root_config.GetChild("db_config");
+    milvus::server::ConfigNode &metric_config = root_config.GetChild("metric_config");
+    milvus::server::ConfigNode &cache_config = root_config.GetChild("cache_config");
+    milvus::server::ConfigNode invalid_config = root_config.GetChild("invalid_config");
+    auto valus = invalid_config.GetSequence("not_exist");
+    float ff = invalid_config.GetFloatValue("not_exist", 3.0);
+    ASSERT_EQ(ff, 3.0);
+
+    std::string address = server_config.GetValue("address");
+    ASSERT_TRUE(!address.empty());
+    int64_t port = server_config.GetInt64Value("port");
+    ASSERT_NE(port, 0);
+
+    server_config.SetValue("test", "2.5");
+    double test = server_config.GetDoubleValue("test");
+    ASSERT_EQ(test, 2.5);
+
+    milvus::server::ConfigNode fake;
+    server_config.AddChild("fake", fake);
+    fake = server_config.GetChild("fake");
+    milvus::server::ConfigNodeArr arr;
+    server_config.GetChildren(arr);
+    ASSERT_EQ(arr.size(), 1UL);
+
+    server_config.ClearChildren();
+    auto children = server_config.GetChildren();
+    ASSERT_TRUE(children.empty());
+
+    server_config.ClearConfig();
+    auto configs = server_config.GetConfig();
+    ASSERT_TRUE(configs.empty());
+
+    server_config.AddSequenceItem("seq", "aaa");
+    server_config.AddSequenceItem("seq", "bbb");
+    auto seq = server_config.GetSequence("seq");
+    ASSERT_EQ(seq.size(), 2UL);
+
+    milvus::server::ConfigNode combine;
+    combine.Combine(server_config);
+
+    combine.PrintAll();
+    std::string all = combine.DumpString();
+    ASSERT_TRUE(!all.empty());
+
+    server_config.ClearSequences();
+    auto seqs = server_config.GetSequences();
+    ASSERT_TRUE(seqs.empty());
+}
+
+TEST_F(ConfigTest, SERVER_CONFIG_TEST) {
+    std::string config_path(CONFIG_PATH);
+    milvus::server::Config &config = milvus::server::Config::GetInstance();
+    milvus::Status s = config.LoadConfigFile(config_path + VALID_CONFIG_FILE);
+    ASSERT_TRUE(s.ok());
+
+    s = config.ValidateConfig();
+    ASSERT_TRUE(s.ok());
+
+    config.PrintAll();
+
+    s = config.ResetDefaultConfig();
+    ASSERT_TRUE(s.ok());
+}
diff --git a/core/unittest/server/test_rpc.cpp b/core/unittest/server/test_rpc.cpp
new file mode 100644
index 0000000000..09a56699ea
--- /dev/null
+++ b/core/unittest/server/test_rpc.cpp
@@ -0,0 +1,472 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 <gtest/gtest.h>
+#include <thread>
+#include <boost/filesystem.hpp>
+
+#include "server/Server.h"
+#include "server/grpc_impl/GrpcRequestHandler.h"
+#include "server/grpc_impl/GrpcRequestScheduler.h"
+#include "server/grpc_impl/GrpcRequestTask.h"
+#include "../version.h"
+
+#include "grpc/gen-milvus/milvus.grpc.pb.h"
+#include "grpc/gen-status/status.pb.h"
+
+#include "server/DBWrapper.h"
+#include "server/Config.h"
+#include "scheduler/SchedInst.h"
+#include "scheduler/ResourceFactory.h"
+#include "utils/CommonUtil.h"
+
+namespace {
+
+static const char *TABLE_NAME = "test_grpc";
+static constexpr int64_t TABLE_DIM = 256;
+static constexpr int64_t INDEX_FILE_SIZE = 1024;
+static constexpr int64_t VECTOR_COUNT = 1000;
+static constexpr int64_t INSERT_LOOP = 10;
+constexpr int64_t SECONDS_EACH_HOUR = 3600;
+
+class RpcHandlerTest : public testing::Test {
+ protected:
+    void
+    SetUp() override {
+        auto res_mgr = milvus::scheduler::ResMgrInst::GetInstance();
+        res_mgr->Clear();
+        res_mgr->Add(milvus::scheduler::ResourceFactory::Create("disk", "DISK", 0, true, false));
+        res_mgr->Add(milvus::scheduler::ResourceFactory::Create("cpu", "CPU", 0, true, true));
+        res_mgr->Add(milvus::scheduler::ResourceFactory::Create("gtx1660", "GPU", 0, true, true));
+
+        auto default_conn = milvus::scheduler::Connection("IO", 500.0);
+        auto PCIE = milvus::scheduler::Connection("IO", 11000.0);
+        res_mgr->Connect("disk", "cpu", default_conn);
+        res_mgr->Connect("cpu", "gtx1660", PCIE);
+        res_mgr->Start();
+        milvus::scheduler::SchedInst::GetInstance()->Start();
+        milvus::scheduler::JobMgrInst::GetInstance()->Start();
+
+        milvus::engine::DBOptions opt;
+
+        milvus::server::Config::GetInstance().SetDBConfigBackendUrl("sqlite://:@:/");
+        milvus::server::Config::GetInstance().SetDBConfigPrimaryPath("/tmp/milvus_test");
+        milvus::server::Config::GetInstance().SetDBConfigSecondaryPath("");
+        milvus::server::Config::GetInstance().SetDBConfigArchiveDiskThreshold("");
+        milvus::server::Config::GetInstance().SetDBConfigArchiveDaysThreshold("");
+        milvus::server::Config::GetInstance().SetCacheConfigCacheInsertData("");
+        milvus::server::Config::GetInstance().SetEngineConfigOmpThreadNum("");
+
+//        serverConfig.SetValue(server::CONFIG_CLUSTER_MODE, "cluster");
+//        DBWrapper::GetInstance().GetInstance().StartService();
+//        DBWrapper::GetInstance().GetInstance().StopService();
+//
+//        serverConfig.SetValue(server::CONFIG_CLUSTER_MODE, "read_only");
+//        DBWrapper::GetInstance().GetInstance().StartService();
+//        DBWrapper::GetInstance().GetInstance().StopService();
+
+        milvus::server::Config::GetInstance().SetResourceConfigMode("single");
+        milvus::server::DBWrapper::GetInstance().StartService();
+
+        //initialize handler, create table
+        handler = std::make_shared<milvus::server::grpc::GrpcRequestHandler>();
+        ::grpc::ServerContext context;
+        ::milvus::grpc::TableSchema request;
+        ::milvus::grpc::Status status;
+        request.set_table_name(TABLE_NAME);
+        request.set_dimension(TABLE_DIM);
+        request.set_index_file_size(INDEX_FILE_SIZE);
+        request.set_metric_type(1);
+        ::grpc::Status grpc_status = handler->CreateTable(&context, &request, &status);
+    }
+
+    void
+    TearDown() override {
+        milvus::server::DBWrapper::GetInstance().StopService();
+        milvus::scheduler::JobMgrInst::GetInstance()->Stop();
+        milvus::scheduler::ResMgrInst::GetInstance()->Stop();
+        milvus::scheduler::SchedInst::GetInstance()->Stop();
+        boost::filesystem::remove_all("/tmp/milvus_test");
+    }
+
+ protected:
+    std::shared_ptr<milvus::server::grpc::GrpcRequestHandler> handler;
+};
+
+void
+BuildVectors(int64_t from, int64_t to,
+             std::vector<std::vector<float >> &vector_record_array) {
+    if (to <= from) {
+        return;
+    }
+
+    vector_record_array.clear();
+    for (int64_t k = from; k < to; k++) {
+        std::vector<float> record;
+        record.resize(TABLE_DIM);
+        for (int64_t i = 0; i < TABLE_DIM; i++) {
+            record[i] = (float) (k % (i + 1));
+        }
+
+        vector_record_array.emplace_back(record);
+    }
+}
+
+std::string
+CurrentTmDate(int64_t offset_day = 0) {
+    time_t tt;
+    time(&tt);
+    tt = tt + 8 * SECONDS_EACH_HOUR;
+    tt = tt + 24 * SECONDS_EACH_HOUR * offset_day;
+    tm t;
+    gmtime_r(&tt, &t);
+
+    std::string str = std::to_string(t.tm_year + 1900) + "-" + std::to_string(t.tm_mon + 1)
+        + "-" + std::to_string(t.tm_mday);
+
+    return str;
+}
+
+} // namespace
+
+TEST_F(RpcHandlerTest, HAS_TABLE_TEST) {
+    ::grpc::ServerContext context;
+    ::milvus::grpc::TableName request;
+    ::milvus::grpc::BoolReply reply;
+    ::grpc::Status status = handler->HasTable(&context, &request, &reply);
+    request.set_table_name(TABLE_NAME);
+    status = handler->HasTable(&context, &request, &reply);
+    ASSERT_TRUE(status.error_code() == ::grpc::Status::OK.error_code());
+    int error_code = reply.status().error_code();
+    ASSERT_EQ(error_code, ::milvus::grpc::ErrorCode::SUCCESS);
+}
+
+TEST_F(RpcHandlerTest, INDEX_TEST) {
+    ::grpc::ServerContext context;
+    ::milvus::grpc::IndexParam request;
+    ::milvus::grpc::Status response;
+    ::grpc::Status grpc_status = handler->CreateIndex(&context, &request, &response);
+    request.set_table_name("test1");
+    handler->CreateIndex(&context, &request, &response);
+
+    request.set_table_name(TABLE_NAME);
+    handler->CreateIndex(&context, &request, &response);
+
+    request.mutable_index()->set_index_type(1);
+    handler->CreateIndex(&context, &request, &response);
+
+    request.mutable_index()->set_nlist(16384);
+    grpc_status = handler->CreateIndex(&context, &request, &response);
+    ASSERT_EQ(grpc_status.error_code(), ::grpc::Status::OK.error_code());
+    int error_code = response.error_code();
+//    ASSERT_EQ(error_code, ::milvus::grpc::ErrorCode::SUCCESS);
+
+    ::milvus::grpc::TableName table_name;
+    ::milvus::grpc::IndexParam index_param;
+    handler->DescribeIndex(&context, &table_name, &index_param);
+    table_name.set_table_name("test4");
+    handler->DescribeIndex(&context, &table_name, &index_param);
+    table_name.set_table_name(TABLE_NAME);
+    handler->DescribeIndex(&context, &table_name, &index_param);
+    ::milvus::grpc::Status status;
+    table_name.Clear();
+    handler->DropIndex(&context, &table_name, &status);
+    table_name.set_table_name("test5");
+    handler->DropIndex(&context, &table_name, &status);
+    table_name.set_table_name(TABLE_NAME);
+    handler->DropIndex(&context, &table_name, &status);
+}
+
+TEST_F(RpcHandlerTest, INSERT_TEST) {
+    ::grpc::ServerContext context;
+    ::milvus::grpc::InsertParam request;
+    ::milvus::grpc::Status response;
+
+    request.set_table_name(TABLE_NAME);
+    std::vector<std::vector<float>> record_array;
+    BuildVectors(0, VECTOR_COUNT, record_array);
+    ::milvus::grpc::VectorIds vector_ids;
+    for (auto &record : record_array) {
+        ::milvus::grpc::RowRecord *grpc_record = request.add_row_record_array();
+        for (size_t i = 0; i < record.size(); i++) {
+            grpc_record->add_vector_data(record[i]);
+        }
+    }
+    handler->Insert(&context, &request, &vector_ids);
+    ASSERT_EQ(vector_ids.vector_id_array_size(), VECTOR_COUNT);
+}
+
+TEST_F(RpcHandlerTest, SEARCH_TEST) {
+    ::grpc::ServerContext context;
+    ::milvus::grpc::SearchParam request;
+    ::milvus::grpc::TopKQueryResultList response;
+    //test null input
+    handler->Search(&context, nullptr, &response);
+
+    //test invalid table name
+    handler->Search(&context, &request, &response);
+
+    //test table not exist
+    request.set_table_name("test3");
+    handler->Search(&context, &request, &response);
+
+    //test invalid topk
+    request.set_table_name(TABLE_NAME);
+    handler->Search(&context, &request, &response);
+
+    //test invalid nprobe
+    request.set_topk(10);
+    handler->Search(&context, &request, &response);
+
+    //test empty query record array
+    request.set_nprobe(32);
+    handler->Search(&context, &request, &response);
+
+    std::vector<std::vector<float>> record_array;
+    BuildVectors(0, VECTOR_COUNT, record_array);
+    ::milvus::grpc::InsertParam insert_param;
+    for (auto &record : record_array) {
+        ::milvus::grpc::RowRecord *grpc_record = insert_param.add_row_record_array();
+        for (size_t i = 0; i < record.size(); i++) {
+            grpc_record->add_vector_data(record[i]);
+        }
+    }
+    //insert vectors
+    insert_param.set_table_name(TABLE_NAME);
+    ::milvus::grpc::VectorIds vector_ids;
+    handler->Insert(&context, &insert_param, &vector_ids);
+    sleep(7);
+
+    BuildVectors(0, 10, record_array);
+    for (auto &record : record_array) {
+        ::milvus::grpc::RowRecord *row_record = request.add_query_record_array();
+        for (auto &rec : record) {
+            row_record->add_vector_data(rec);
+        }
+    }
+    handler->Search(&context, &request, &response);
+
+    //test search with range
+    ::milvus::grpc::Range *range = request.mutable_query_range_array()->Add();
+    range->set_start_value(CurrentTmDate(-2));
+    range->set_end_value(CurrentTmDate(-3));
+    handler->Search(&context, &request, &response);
+    request.mutable_query_range_array()->Clear();
+
+    request.set_table_name("test2");
+    handler->Search(&context, &request, &response);
+    request.set_table_name(TABLE_NAME);
+    handler->Search(&context, &request, &response);
+
+    ::milvus::grpc::SearchInFilesParam search_in_files_param;
+    std::string *file_id = search_in_files_param.add_file_id_array();
+    *file_id = "test_tbl";
+    handler->SearchInFiles(&context, &search_in_files_param, &response);
+}
+
+TEST_F(RpcHandlerTest, TABLES_TEST) {
+    ::grpc::ServerContext context;
+    ::milvus::grpc::TableSchema tableschema;
+    ::milvus::grpc::Status response;
+    std::string tablename = "tbl";
+
+    //create table test
+    //test null input
+    handler->CreateTable(&context, nullptr, &response);
+    //test invalid table name
+    handler->CreateTable(&context, &tableschema, &response);
+    //test invalid table dimension
+    tableschema.set_table_name(tablename);
+    handler->CreateTable(&context, &tableschema, &response);
+    //test invalid index file size
+    tableschema.set_dimension(TABLE_DIM);
+//    handler->CreateTable(&context, &tableschema, &response);
+    //test invalid index metric type
+    tableschema.set_index_file_size(INDEX_FILE_SIZE);
+    handler->CreateTable(&context, &tableschema, &response);
+    //test table already exist
+    tableschema.set_metric_type(1);
+    handler->CreateTable(&context, &tableschema, &response);
+
+    //describe table test
+    //test invalid table name
+    ::milvus::grpc::TableName table_name;
+    ::milvus::grpc::TableSchema table_schema;
+    handler->DescribeTable(&context, &table_name, &table_schema);
+
+    table_name.set_table_name(TABLE_NAME);
+    ::grpc::Status status = handler->DescribeTable(&context, &table_name, &table_schema);
+    ASSERT_EQ(status.error_code(), ::grpc::Status::OK.error_code());
+
+    ::milvus::grpc::InsertParam request;
+    std::vector<std::vector<float>> record_array;
+    BuildVectors(0, VECTOR_COUNT, record_array);
+    ::milvus::grpc::VectorIds vector_ids;
+    //Insert vectors
+    //test invalid table name
+    handler->Insert(&context, &request, &vector_ids);
+    request.set_table_name(tablename);
+    //test empty row record
+    handler->Insert(&context, &request, &vector_ids);
+
+    for (auto &record : record_array) {
+        ::milvus::grpc::RowRecord *grpc_record = request.add_row_record_array();
+        for (size_t i = 0; i < record.size(); i++) {
+            grpc_record->add_vector_data(record[i]);
+        }
+    }
+    //test vector_id size not equal to row record size
+    vector_ids.clear_vector_id_array();
+    vector_ids.add_vector_id_array(1);
+    handler->Insert(&context, &request, &vector_ids);
+
+    //normally test
+    vector_ids.clear_vector_id_array();
+    handler->Insert(&context, &request, &vector_ids);
+
+    request.clear_row_record_array();
+    vector_ids.clear_vector_id_array();
+    for (uint64_t i = 0; i < 10; ++i) {
+        ::milvus::grpc::RowRecord *grpc_record = request.add_row_record_array();
+        for (size_t j = 0; j < 10; j++) {
+            grpc_record->add_vector_data(record_array[i][j]);
+        }
+    }
+    handler->Insert(&context, &request, &vector_ids);
+
+
+    //show tables
+    ::milvus::grpc::Command cmd;
+    ::milvus::grpc::TableNameList table_name_list;
+    status = handler->ShowTables(&context, &cmd, &table_name_list);
+    ASSERT_EQ(status.error_code(), ::grpc::Status::OK.error_code());
+
+    //Count Table
+    ::milvus::grpc::TableRowCount count;
+    table_name.Clear();
+    status = handler->CountTable(&context, &table_name, &count);
+    table_name.set_table_name(tablename);
+    status = handler->CountTable(&context, &table_name, &count);
+    ASSERT_EQ(status.error_code(), ::grpc::Status::OK.error_code());
+//    ASSERT_EQ(count.table_row_count(), vector_ids.vector_id_array_size());
+
+
+    //Preload Table
+    table_name.Clear();
+    status = handler->PreloadTable(&context, &table_name, &response);
+    table_name.set_table_name(TABLE_NAME);
+    status = handler->PreloadTable(&context, &table_name, &response);
+    ASSERT_EQ(status.error_code(), ::grpc::Status::OK.error_code());
+
+    //Drop table
+    table_name.set_table_name("");
+    //test invalid table name
+    ::grpc::Status grpc_status = handler->DropTable(&context, &table_name, &response);
+    table_name.set_table_name(tablename);
+    grpc_status = handler->DropTable(&context, &table_name, &response);
+    ASSERT_EQ(grpc_status.error_code(), ::grpc::Status::OK.error_code());
+    int error_code = status.error_code();
+    ASSERT_EQ(error_code, ::milvus::grpc::ErrorCode::SUCCESS);
+}
+
+TEST_F(RpcHandlerTest, CMD_TEST) {
+    ::grpc::ServerContext context;
+    ::milvus::grpc::Command command;
+    command.set_cmd("version");
+    ::milvus::grpc::StringReply reply;
+    handler->Cmd(&context, &command, &reply);
+    ASSERT_EQ(reply.string_reply(), MILVUS_VERSION);
+
+    command.set_cmd("tasktable");
+    handler->Cmd(&context, &command, &reply);
+    command.set_cmd("test");
+    handler->Cmd(&context, &command, &reply);
+}
+
+TEST_F(RpcHandlerTest, DELETE_BY_RANGE_TEST) {
+    ::grpc::ServerContext context;
+    ::milvus::grpc::DeleteByRangeParam request;
+    ::milvus::grpc::Status status;
+    handler->DeleteByRange(&context, nullptr, &status);
+    handler->DeleteByRange(&context, &request, &status);
+
+    request.set_table_name(TABLE_NAME);
+    request.mutable_range()->set_start_value(CurrentTmDate(-3));
+    request.mutable_range()->set_end_value(CurrentTmDate(-2));
+
+    ::grpc::Status grpc_status = handler->DeleteByRange(&context, &request, &status);
+    int error_code = status.error_code();
+//    ASSERT_EQ(error_code, ::milvus::grpc::ErrorCode::SUCCESS);
+
+    request.mutable_range()->set_start_value("test6");
+    grpc_status = handler->DeleteByRange(&context, &request, &status);
+    request.mutable_range()->set_start_value(CurrentTmDate(-2));
+    request.mutable_range()->set_end_value("test6");
+    grpc_status = handler->DeleteByRange(&context, &request, &status);
+    request.mutable_range()->set_end_value(CurrentTmDate(-2));
+    grpc_status = handler->DeleteByRange(&context, &request, &status);
+}
+
+//////////////////////////////////////////////////////////////////////
+namespace {
+class DummyTask : public milvus::server::grpc::GrpcBaseTask {
+ public:
+    milvus::Status
+    OnExecute() override {
+        return milvus::Status::OK();
+    }
+
+    static milvus::server::grpc::BaseTaskPtr
+    Create(std::string &dummy) {
+        return std::shared_ptr<milvus::server::grpc::GrpcBaseTask>(new DummyTask(dummy));
+    }
+
+ public:
+    explicit DummyTask(std::string &dummy) : GrpcBaseTask(dummy) {
+    }
+};
+
+class RpcSchedulerTest : public testing::Test {
+ protected:
+    void
+    SetUp() override {
+        std::string dummy = "dql";
+        task_ptr = std::make_shared<DummyTask>(dummy);
+    }
+
+    std::shared_ptr<DummyTask> task_ptr;
+};
+
+} // namespace
+
+TEST_F(RpcSchedulerTest, BASE_TASK_TEST) {
+    auto status = task_ptr->Execute();
+    ASSERT_TRUE(status.ok());
+
+    milvus::server::grpc::GrpcRequestScheduler::GetInstance().Start();
+    ::milvus::grpc::Status grpc_status;
+    std::string dummy = "dql";
+    milvus::server::grpc::BaseTaskPtr base_task_ptr = DummyTask::Create(dummy);
+    milvus::server::grpc::GrpcRequestScheduler::GetInstance().ExecTask(base_task_ptr, &grpc_status);
+
+    milvus::server::grpc::GrpcRequestScheduler::GetInstance().ExecuteTask(task_ptr);
+    task_ptr = nullptr;
+    milvus::server::grpc::GrpcRequestScheduler::GetInstance().ExecuteTask(task_ptr);
+
+    milvus::server::grpc::GrpcRequestScheduler::GetInstance().Stop();
+}
+
diff --git a/core/unittest/server/test_util.cpp b/core/unittest/server/test_util.cpp
new file mode 100644
index 0000000000..24482740bc
--- /dev/null
+++ b/core/unittest/server/test_util.cpp
@@ -0,0 +1,397 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "utils/SignalUtil.h"
+#include "utils/CommonUtil.h"
+#include "utils/Error.h"
+#include "utils/StringHelpFunctions.h"
+#include "utils/TimeRecorder.h"
+#include "utils/BlockingQueue.h"
+#include "utils/LogUtil.h"
+#include "utils/ValidationUtil.h"
+#include "db/engine/ExecutionEngine.h"
+
+#include <thread>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <boost/filesystem.hpp>
+#include <gtest/gtest.h>
+
+namespace {
+
+static const char* LOG_FILE_PATH = "./milvus/conf/log_config.conf";
+
+void
+CopyStatus(milvus::Status& st1, milvus::Status& st2) {
+    st1 = st2;
+}
+
+} // namespace
+
+TEST(UtilTest, EXCEPTION_TEST) {
+    std::string err_msg = "failed";
+    milvus::server::ServerException ex(milvus::SERVER_UNEXPECTED_ERROR, err_msg);
+    ASSERT_EQ(ex.error_code(), milvus::SERVER_UNEXPECTED_ERROR);
+    std::string msg = ex.what();
+    ASSERT_EQ(msg, err_msg);
+}
+
+TEST(UtilTest, SIGNAL_TEST) {
+    milvus::server::SignalUtil::PrintStacktrace();
+}
+
+TEST(UtilTest, COMMON_TEST) {
+    uint64_t total_mem = 0, free_mem = 0;
+    milvus::server::CommonUtil::GetSystemMemInfo(total_mem, free_mem);
+    ASSERT_GT(total_mem, 0);
+    ASSERT_GT(free_mem, 0);
+
+    uint32_t thread_cnt = 0;
+    milvus::server::CommonUtil::GetSystemAvailableThreads(thread_cnt);
+    ASSERT_GT(thread_cnt, 0);
+
+    std::string path1 = "/tmp/milvus_test/";
+    std::string path2 = path1 + "common_test_12345/";
+    std::string path3 = path2 + "abcdef";
+    milvus::Status status = milvus::server::CommonUtil::CreateDirectory(path3);
+    ASSERT_TRUE(status.ok());
+    //test again
+    status = milvus::server::CommonUtil::CreateDirectory(path3);
+    ASSERT_TRUE(status.ok());
+
+    ASSERT_TRUE(milvus::server::CommonUtil::IsDirectoryExist(path3));
+
+    status = milvus::server::CommonUtil::DeleteDirectory(path1);
+    ASSERT_TRUE(status.ok());
+    //test again
+    status = milvus::server::CommonUtil::DeleteDirectory(path1);
+    ASSERT_TRUE(status.ok());
+
+    ASSERT_FALSE(milvus::server::CommonUtil::IsDirectoryExist(path1));
+    ASSERT_FALSE(milvus::server::CommonUtil::IsFileExist(path1));
+
+    std::string exe_path = milvus::server::CommonUtil::GetExePath();
+    ASSERT_FALSE(exe_path.empty());
+
+    time_t tt;
+    time(&tt);
+    tm time_struct;
+    memset(&time_struct, 0, sizeof(tm));
+    milvus::server::CommonUtil::ConvertTime(tt, time_struct);
+    ASSERT_GT(time_struct.tm_year, 0);
+    ASSERT_GT(time_struct.tm_mon, 0);
+    ASSERT_GT(time_struct.tm_mday, 0);
+    milvus::server::CommonUtil::ConvertTime(time_struct, tt);
+    ASSERT_GT(tt, 0);
+
+    bool res = milvus::server::CommonUtil::TimeStrToTime("2019-03-23", tt, time_struct);
+    ASSERT_EQ(time_struct.tm_year, 119);
+    ASSERT_EQ(time_struct.tm_mon, 2);
+    ASSERT_EQ(time_struct.tm_mday, 23);
+    ASSERT_GT(tt, 0);
+    ASSERT_TRUE(res);
+}
+
+TEST(UtilTest, STRINGFUNCTIONS_TEST) {
+    std::string str = " test str";
+    milvus::server::StringHelpFunctions::TrimStringBlank(str);
+    ASSERT_EQ(str, "test str");
+
+    str = "\"test str\"";
+    milvus::server::StringHelpFunctions::TrimStringQuote(str, "\"");
+    ASSERT_EQ(str, "test str");
+
+    str = "a,b,c";
+    std::vector<std::string> result;
+    auto status = milvus::server::StringHelpFunctions::SplitStringByDelimeter(str, ",", result);
+    ASSERT_TRUE(status.ok());
+    ASSERT_EQ(result.size(), 3UL);
+
+    result.clear();
+    status = milvus::server::StringHelpFunctions::SplitStringByQuote(str, ",", "\"", result);
+    ASSERT_TRUE(status.ok());
+    ASSERT_EQ(result.size(), 3UL);
+
+    result.clear();
+    status = milvus::server::StringHelpFunctions::SplitStringByQuote(str, ",", "", result);
+    ASSERT_TRUE(status.ok());
+    ASSERT_EQ(result.size(), 3UL);
+
+    str = "55,\"aa,gg,yy\",b";
+    result.clear();
+    status = milvus::server::StringHelpFunctions::SplitStringByQuote(str, ",", "\"", result);
+    ASSERT_TRUE(status.ok());
+    ASSERT_EQ(result.size(), 3UL);
+}
+
+TEST(UtilTest, BLOCKINGQUEUE_TEST) {
+    milvus::server::BlockingQueue<std::string> bq;
+
+    static const size_t count = 10;
+    bq.SetCapacity(count);
+
+    for (size_t i = 1; i <= count; i++) {
+        std::string id = "No." + std::to_string(i);
+        bq.Put(id);
+    }
+
+    ASSERT_EQ(bq.Size(), count);
+    ASSERT_FALSE(bq.Empty());
+
+    std::string str = bq.Front();
+    ASSERT_EQ(str, "No.1");
+
+    str = bq.Back();
+    ASSERT_EQ(str, "No." + std::to_string(count));
+
+    for (size_t i = 1; i <= count; i++) {
+        std::string id = "No." + std::to_string(i);
+        str = bq.Take();
+        ASSERT_EQ(id, str);
+    }
+
+    ASSERT_EQ(bq.Size(), 0);
+}
+
+TEST(UtilTest, LOG_TEST) {
+    auto status = milvus::server::InitLog(LOG_FILE_PATH);
+    ASSERT_TRUE(status.ok());
+
+    EXPECT_FALSE(el::Loggers::hasFlag(el::LoggingFlag::NewLineForContainer));
+    EXPECT_FALSE(el::Loggers::hasFlag(el::LoggingFlag::LogDetailedCrashReason));
+
+    std::string fname = milvus::server::CommonUtil::GetFileName(LOG_FILE_PATH);
+    ASSERT_EQ(fname, "log_config.conf");
+}
+
+TEST(UtilTest, TIMERECORDER_TEST) {
+    for (int64_t log_level = 0; log_level <= 6; log_level++) {
+        if (log_level == 5) {
+            continue; //skip fatal
+        }
+        milvus::TimeRecorder rc("time", log_level);
+        rc.RecordSection("end");
+    }
+}
+
+TEST(UtilTest, STATUS_TEST) {
+    auto status = milvus::Status::OK();
+    std::string str = status.ToString();
+    ASSERT_FALSE(str.empty());
+
+    status = milvus::Status(milvus::DB_ERROR, "mistake");
+    ASSERT_EQ(status.code(), milvus::DB_ERROR);
+    str = status.ToString();
+    ASSERT_FALSE(str.empty());
+
+    status = milvus::Status(milvus::DB_NOT_FOUND, "mistake");
+    ASSERT_EQ(status.code(), milvus::DB_NOT_FOUND);
+    str = status.ToString();
+    ASSERT_FALSE(str.empty());
+
+    status = milvus::Status(milvus::DB_ALREADY_EXIST, "mistake");
+    ASSERT_EQ(status.code(), milvus::DB_ALREADY_EXIST);
+    str = status.ToString();
+    ASSERT_FALSE(str.empty());
+
+    status = milvus::Status(milvus::DB_META_TRANSACTION_FAILED, "mistake");
+    ASSERT_EQ(status.code(), milvus::DB_META_TRANSACTION_FAILED);
+    str = status.ToString();
+    ASSERT_FALSE(str.empty());
+
+    auto status_copy = milvus::Status::OK();
+    CopyStatus(status_copy, status);
+    ASSERT_EQ(status.code(), milvus::DB_META_TRANSACTION_FAILED);
+
+    auto status_ref(status);
+    ASSERT_EQ(status_ref.code(), status.code());
+    ASSERT_EQ(status_ref.ToString(), status.ToString());
+
+    auto status_move = std::move(status);
+    ASSERT_EQ(status_move.code(), status_ref.code());
+    ASSERT_EQ(status_move.ToString(), status_ref.ToString());
+}
+
+TEST(ValidationUtilTest, VALIDATE_TABLENAME_TEST) {
+    std::string table_name = "Normal123_";
+    auto status = milvus::server::ValidationUtil::ValidateTableName(table_name);
+    ASSERT_TRUE(status.ok());
+
+    table_name = "12sds";
+    status = milvus::server::ValidationUtil::ValidateTableName(table_name);
+    ASSERT_EQ(status.code(), milvus::SERVER_INVALID_TABLE_NAME);
+
+    table_name = "";
+    status = milvus::server::ValidationUtil::ValidateTableName(table_name);
+    ASSERT_EQ(status.code(), milvus::SERVER_INVALID_TABLE_NAME);
+
+    table_name = "_asdasd";
+    status = milvus::server::ValidationUtil::ValidateTableName(table_name);
+    ASSERT_EQ(status.code(), milvus::SERVER_SUCCESS);
+
+    table_name = "!@#!@";
+    status = milvus::server::ValidationUtil::ValidateTableName(table_name);
+    ASSERT_EQ(status.code(), milvus::SERVER_INVALID_TABLE_NAME);
+
+    table_name = "_!@#!@";
+    status = milvus::server::ValidationUtil::ValidateTableName(table_name);
+    ASSERT_EQ(status.code(), milvus::SERVER_INVALID_TABLE_NAME);
+
+    table_name = "中文";
+    status = milvus::server::ValidationUtil::ValidateTableName(table_name);
+    ASSERT_EQ(status.code(), milvus::SERVER_INVALID_TABLE_NAME);
+
+    table_name = std::string(10000, 'a');
+    status = milvus::server::ValidationUtil::ValidateTableName(table_name);
+    ASSERT_EQ(status.code(), milvus::SERVER_INVALID_TABLE_NAME);
+}
+
+TEST(ValidationUtilTest, VALIDATE_DIMENSION_TEST) {
+    ASSERT_EQ(milvus::server::ValidationUtil::ValidateTableDimension(-1).code(),
+              milvus::SERVER_INVALID_VECTOR_DIMENSION);
+    ASSERT_EQ(milvus::server::ValidationUtil::ValidateTableDimension(0).code(),
+              milvus::SERVER_INVALID_VECTOR_DIMENSION);
+    ASSERT_EQ(milvus::server::ValidationUtil::ValidateTableDimension(16385).code(),
+              milvus::SERVER_INVALID_VECTOR_DIMENSION);
+    ASSERT_EQ(milvus::server::ValidationUtil::ValidateTableDimension(16384).code(), milvus::SERVER_SUCCESS);
+    ASSERT_EQ(milvus::server::ValidationUtil::ValidateTableDimension(1).code(), milvus::SERVER_SUCCESS);
+}
+
+TEST(ValidationUtilTest, VALIDATE_INDEX_TEST) {
+    ASSERT_EQ(milvus::server::ValidationUtil::ValidateTableIndexType((int)milvus::engine::EngineType::INVALID).code(),
+              milvus::SERVER_INVALID_INDEX_TYPE);
+    for (int i = 1; i <= (int)milvus::engine::EngineType::MAX_VALUE; i++) {
+#ifndef CUSTOMIZATION
+        if (i == (int)milvus::engine::EngineType::FAISS_IVFSQ8H) {
+            continue;
+        }
+#endif
+        ASSERT_EQ(milvus::server::ValidationUtil::ValidateTableIndexType(i).code(), milvus::SERVER_SUCCESS);
+    }
+    ASSERT_EQ(milvus::server::ValidationUtil::ValidateTableIndexType(
+        (int)milvus::engine::EngineType::MAX_VALUE + 1).code(),
+              milvus::SERVER_INVALID_INDEX_TYPE);
+
+    ASSERT_EQ(milvus::server::ValidationUtil::ValidateTableIndexNlist(0).code(), milvus::SERVER_INVALID_INDEX_NLIST);
+    ASSERT_EQ(milvus::server::ValidationUtil::ValidateTableIndexNlist(100).code(), milvus::SERVER_SUCCESS);
+
+    ASSERT_EQ(milvus::server::ValidationUtil::ValidateTableIndexFileSize(0).code(),
+              milvus::SERVER_INVALID_INDEX_FILE_SIZE);
+    ASSERT_EQ(milvus::server::ValidationUtil::ValidateTableIndexFileSize(100).code(), milvus::SERVER_SUCCESS);
+
+    ASSERT_EQ(milvus::server::ValidationUtil::ValidateTableIndexMetricType(0).code(),
+              milvus::SERVER_INVALID_INDEX_METRIC_TYPE);
+    ASSERT_EQ(milvus::server::ValidationUtil::ValidateTableIndexMetricType(1).code(), milvus::SERVER_SUCCESS);
+    ASSERT_EQ(milvus::server::ValidationUtil::ValidateTableIndexMetricType(2).code(), milvus::SERVER_SUCCESS);
+}
+
+TEST(ValidationUtilTest, VALIDATE_TOPK_TEST) {
+    milvus::engine::meta::TableSchema schema;
+    ASSERT_EQ(milvus::server::ValidationUtil::ValidateSearchTopk(10, schema).code(), milvus::SERVER_SUCCESS);
+    ASSERT_NE(milvus::server::ValidationUtil::ValidateSearchTopk(65536, schema).code(), milvus::SERVER_SUCCESS);
+    ASSERT_NE(milvus::server::ValidationUtil::ValidateSearchTopk(0, schema).code(), milvus::SERVER_SUCCESS);
+}
+
+TEST(ValidationUtilTest, VALIDATE_NPROBE_TEST) {
+    milvus::engine::meta::TableSchema schema;
+    schema.nlist_ = 100;
+    ASSERT_EQ(milvus::server::ValidationUtil::ValidateSearchNprobe(10, schema).code(), milvus::SERVER_SUCCESS);
+    ASSERT_NE(milvus::server::ValidationUtil::ValidateSearchNprobe(0, schema).code(), milvus::SERVER_SUCCESS);
+    ASSERT_NE(milvus::server::ValidationUtil::ValidateSearchNprobe(101, schema).code(), milvus::SERVER_SUCCESS);
+}
+
+TEST(ValidationUtilTest, VALIDATE_GPU_TEST) {
+    ASSERT_EQ(milvus::server::ValidationUtil::ValidateGpuIndex(0).code(), milvus::SERVER_SUCCESS);
+    ASSERT_NE(milvus::server::ValidationUtil::ValidateGpuIndex(100).code(), milvus::SERVER_SUCCESS);
+
+    size_t memory = 0;
+    ASSERT_EQ(milvus::server::ValidationUtil::GetGpuMemory(0, memory).code(), milvus::SERVER_SUCCESS);
+    ASSERT_NE(milvus::server::ValidationUtil::GetGpuMemory(100, memory).code(), milvus::SERVER_SUCCESS);
+}
+
+TEST(ValidationUtilTest, VALIDATE_IPADDRESS_TEST) {
+    ASSERT_EQ(milvus::server::ValidationUtil::ValidateIpAddress("127.0.0.1").code(), milvus::SERVER_SUCCESS);
+    ASSERT_NE(milvus::server::ValidationUtil::ValidateIpAddress("not ip").code(), milvus::SERVER_SUCCESS);
+}
+
+TEST(ValidationUtilTest, VALIDATE_NUMBER_TEST) {
+    ASSERT_EQ(milvus::server::ValidationUtil::ValidateStringIsNumber("1234").code(), milvus::SERVER_SUCCESS);
+    ASSERT_NE(milvus::server::ValidationUtil::ValidateStringIsNumber("not number").code(), milvus::SERVER_SUCCESS);
+}
+
+TEST(ValidationUtilTest, VALIDATE_BOOL_TEST) {
+    std::string str = "true";
+    ASSERT_EQ(milvus::server::ValidationUtil::ValidateStringIsBool(str).code(), milvus::SERVER_SUCCESS);
+    str = "not bool";
+    ASSERT_NE(milvus::server::ValidationUtil::ValidateStringIsBool(str).code(), milvus::SERVER_SUCCESS);
+}
+
+TEST(ValidationUtilTest, VALIDATE_DOUBLE_TEST) {
+    ASSERT_EQ(milvus::server::ValidationUtil::ValidateStringIsFloat("2.5").code(), milvus::SERVER_SUCCESS);
+    ASSERT_NE(milvus::server::ValidationUtil::ValidateStringIsFloat("not double").code(), milvus::SERVER_SUCCESS);
+}
+
+TEST(ValidationUtilTest, VALIDATE_DBURI_TEST) {
+    ASSERT_EQ(milvus::server::ValidationUtil::ValidateDbURI("sqlite://:@:/").code(), milvus::SERVER_SUCCESS);
+    ASSERT_NE(milvus::server::ValidationUtil::ValidateDbURI("xxx://:@:/").code(), milvus::SERVER_SUCCESS);
+    ASSERT_NE(milvus::server::ValidationUtil::ValidateDbURI("not uri").code(), milvus::SERVER_SUCCESS);
+    ASSERT_EQ(milvus::server::ValidationUtil::ValidateDbURI("mysql://root:123456@127.0.0.1:3303/milvus").code(),
+              milvus::SERVER_SUCCESS);
+    ASSERT_NE(milvus::server::ValidationUtil::ValidateDbURI("mysql://root:123456@127.0.0.1:port/milvus").code(),
+              milvus::SERVER_SUCCESS);
+}
+
+TEST(UtilTest, ROLLOUTHANDLER_TEST) {
+    std::string dir1 = "/tmp/milvus_test";
+    std::string dir2 = "/tmp/milvus_test/log_test";
+    std::string filename[6] = {
+        "log_global.log",
+        "log_debug.log",
+        "log_warning.log",
+        "log_trace.log",
+        "log_error.log",
+        "log_fatal.log"};
+
+    el::Level list[6] = {
+        el::Level::Global,
+        el::Level::Debug,
+        el::Level::Warning,
+        el::Level::Trace,
+        el::Level::Error,
+        el::Level::Fatal};
+
+    mkdir(dir1.c_str(), S_IRWXU);
+    mkdir(dir2.c_str(), S_IRWXU);
+    for (int i = 0; i < 6; ++i) {
+        std::string tmp = dir2 + "/" + filename[i];
+
+        std::ofstream file;
+        file.open(tmp.c_str());
+        file << "test" << std::endl;
+
+        milvus::server::RolloutHandler(tmp.c_str(), 0, list[i]);
+
+        tmp.append(".1");
+        std::ifstream file2;
+        file2.open(tmp);
+
+        std::string tmp2;
+        file2 >> tmp2;
+        ASSERT_EQ(tmp2, "test");
+    }
+    boost::filesystem::remove_all(dir2);
+}
diff --git a/core/unittest/server/utils.cpp b/core/unittest/server/utils.cpp
new file mode 100644
index 0000000000..4c03da6ad9
--- /dev/null
+++ b/core/unittest/server/utils.cpp
@@ -0,0 +1,93 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "server/utils.h"
+#include "utils/CommonUtil.h"
+
+#include <fstream>
+#include <iostream>
+#include <thread>
+#include <string>
+
+namespace {
+
+static const char
+    * VALID_CONFIG_STR = "# Default values are used when you make no changes to the following parameters.\n"
+                         "\n"
+                         "server_config:\n"
+                         "  address: 0.0.0.0                  # milvus server ip address (IPv4)\n"
+                         "  port: 19530                       # port range: 1025 ~ 65534\n"
+                         "  deploy_mode: single               \n"
+                         "  time_zone: UTC+8\n"
+                         "\n"
+                         "db_config:\n"
+                         "  primary_path: /tmp/milvus    # path used to store data and meta\n"
+                         "  secondary_path:                   # path used to store data only, split by semicolon\n"
+                         "\n"
+                         "  backend_url: sqlite://:@:/        \n"
+                         "\n"
+                         "  insert_buffer_size: 4             # GB, maximum insert buffer size allowed\n"
+                         "  preload_table:                    \n"
+                         "\n"
+                         "metric_config:\n"
+                         "  enable_monitor: false             # enable monitoring or not\n"
+                         "  collector: prometheus             # prometheus\n"
+                         "  prometheus_config:\n"
+                         "    port: 8080                      # port prometheus uses to fetch metrics\n"
+                         "\n"
+                         "cache_config:\n"
+                         "  cpu_cache_capacity: 16            # GB, CPU memory used for cache\n"
+                         "  cpu_cache_threshold: 0.85         \n"
+                         "  gpu_cache_capacity: 4             # GB, GPU memory used for cache\n"
+                         "  gpu_cache_threshold: 0.85         \n"
+                         "  cache_insert_data: false          # whether to load inserted data into cache\n"
+                         "\n"
+                         "engine_config:\n"
+                         "  use_blas_threshold: 20            \n"
+                         "\n"
+                         "resource_config:\n"
+                         "  search_resources:                 \n"
+                         "    - gpu0\n"
+                         "  index_build_device: gpu0          # GPU used for building index";
+
+static const char* INVALID_CONFIG_STR = "*INVALID*";
+
+void
+WriteToFile(const std::string& file_path, const char* content) {
+    std::fstream fs(file_path.c_str(), std::ios_base::out);
+
+    //write data to file
+    fs << content;
+    fs.close();
+}
+
+} // namespace
+
+
+void
+ConfigTest::SetUp() {
+    std::string config_path(CONFIG_PATH);
+    milvus::server::CommonUtil::CreateDirectory(config_path);
+    WriteToFile(config_path + VALID_CONFIG_FILE, VALID_CONFIG_STR);
+    WriteToFile(config_path+ INVALID_CONFIG_FILE, INVALID_CONFIG_STR);
+}
+
+void
+ConfigTest::TearDown() {
+    std::string config_path(CONFIG_PATH);
+    milvus::server::CommonUtil::DeleteDirectory(config_path);
+}
diff --git a/core/unittest/server/utils.h b/core/unittest/server/utils.h
new file mode 100644
index 0000000000..2efc5e4120
--- /dev/null
+++ b/core/unittest/server/utils.h
@@ -0,0 +1,32 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+
+#pragma once
+
+#include <gtest/gtest.h>
+#include <chrono>
+
+static const char *CONFIG_PATH = "/tmp/milvus_test/";
+static const char *VALID_CONFIG_FILE = "valid_config.yaml";
+static const char *INVALID_CONFIG_FILE = "invalid_config.conf";
+
+class ConfigTest : public ::testing::Test {
+ protected:
+    void SetUp() override;
+    void TearDown() override;
+};
diff --git a/core/unittest/wrapper/CMakeLists.txt b/core/unittest/wrapper/CMakeLists.txt
new file mode 100644
index 0000000000..156d89b241
--- /dev/null
+++ b/core/unittest/wrapper/CMakeLists.txt
@@ -0,0 +1,51 @@
+#-------------------------------------------------------------------------------
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you 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.
+#-------------------------------------------------------------------------------
+
+aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR} test_files)
+
+set(wrapper_files
+        ${MILVUS_ENGINE_SRC}/wrapper/DataTransfer.cpp
+        ${MILVUS_ENGINE_SRC}/wrapper/VecImpl.cpp
+        ${MILVUS_ENGINE_SRC}/wrapper/VecIndex.cpp)
+
+set(util_files
+        utils.cpp
+        ${MILVUS_ENGINE_SRC}/utils/easylogging++.cc
+        ${MILVUS_ENGINE_SRC}/utils/Status.cpp
+        )
+
+add_executable(test_wrapper
+        ${test_files}
+        ${wrapper_files}
+        ${util_files}
+        ${common_files})
+
+target_link_libraries(test_wrapper
+        knowhere
+        ${unittest_libs})
+
+install(TARGETS test_wrapper DESTINATION unittest)
+
+configure_file(appendix/server_config.yaml
+        "${CMAKE_CURRENT_BINARY_DIR}/milvus/conf/server_config.yaml"
+        COPYONLY)
+
+configure_file(appendix/log_config.conf
+        "${CMAKE_CURRENT_BINARY_DIR}/milvus/conf/log_config.conf"
+        COPYONLY)
\ No newline at end of file
diff --git a/core/unittest/wrapper/appendix/log_config.conf b/core/unittest/wrapper/appendix/log_config.conf
new file mode 100644
index 0000000000..0a3e0d21af
--- /dev/null
+++ b/core/unittest/wrapper/appendix/log_config.conf
@@ -0,0 +1,27 @@
+* GLOBAL:
+    FORMAT                  =   "%datetime | %level | %logger | %msg"
+    FILENAME                =   "/tmp/milvus/logs/milvus-%datetime{%y-%M-%d-%H:%m}-global.log"
+    ENABLED                 =   true
+    TO_FILE                 =   true
+    TO_STANDARD_OUTPUT      =   false
+    SUBSECOND_PRECISION     =   3
+    PERFORMANCE_TRACKING    =   false
+    MAX_LOG_FILE_SIZE       =   209715200 ## Throw log files away after 200MB
+* DEBUG:
+    FILENAME                =   "/tmp/milvus/logs/milvus-%datetime{%y-%M-%d-%H:%m}-debug.log"
+    ENABLED                 =   true
+* WARNING:
+    FILENAME                =   "/tmp/milvus/logs/milvus-%datetime{%y-%M-%d-%H:%m}-warning.log"
+* TRACE:
+    FILENAME                =   "/tmp/milvus/logs/milvus-%datetime{%y-%M-%d-%H:%m}-trace.log"
+* VERBOSE:
+    FORMAT                  =   "%datetime{%d/%M/%y} | %level-%vlevel | %msg"
+    TO_FILE                 =   false
+    TO_STANDARD_OUTPUT      =   false
+## Error logs
+* ERROR:
+    ENABLED                 =   true
+    FILENAME                =   "/tmp/milvus/logs/milvus-%datetime{%y-%M-%d-%H:%m}-error.log"
+* FATAL:
+    ENABLED                 =   true
+    FILENAME                =   "/tmp/milvus/logs/milvus-%datetime{%y-%M-%d-%H:%m}-fatal.log"
diff --git a/core/unittest/wrapper/appendix/server_config.yaml b/core/unittest/wrapper/appendix/server_config.yaml
new file mode 100644
index 0000000000..f92b2f1a18
--- /dev/null
+++ b/core/unittest/wrapper/appendix/server_config.yaml
@@ -0,0 +1,37 @@
+# All the following configurations are default values.
+
+server_config:
+  address: 0.0.0.0                  # milvus server ip address (IPv4)
+  port: 19530                       # port range: 1025 ~ 65534
+  deploy_mode: single               # deployment type: single, cluster_readonly, cluster_writable
+  time_zone: UTC+8
+
+db_config:
+  primary_path: /tmp/milvus    # path used to store data and meta
+  secondary_path:                   # path used to store data only, split by semicolon
+
+  backend_url: sqlite://:@:/        # URI format: dialect://username:password@host:port/database
+                                    # Keep 'dialect://:@:/', and replace other texts with real values.
+                                    # Replace 'dialect' with 'mysql' or 'sqlite'
+
+  insert_buffer_size: 4             # GB, maximum insert buffer size allowed
+  build_index_gpu: 0                # gpu id used for building index
+
+metric_config:
+  enable_monitor: false             # enable monitoring or not
+  collector: prometheus             # prometheus
+  prometheus_config:
+    port: 8080                      # port prometheus used to fetch metrics
+
+cache_config:
+  cpu_mem_capacity: 16              # GB, CPU memory used for cache
+  cpu_mem_threshold: 0.85           # percentage of data kept when cache cleanup triggered
+  cache_insert_data: false          # whether load inserted data into cache
+
+engine_config:
+  blas_threshold: 20
+
+resource_config:
+  resource_pool:
+    - cpu
+    - gpu0
diff --git a/core/unittest/wrapper/test_hybrid_index.cpp b/core/unittest/wrapper/test_hybrid_index.cpp
new file mode 100644
index 0000000000..757d5b2098
--- /dev/null
+++ b/core/unittest/wrapper/test_hybrid_index.cpp
@@ -0,0 +1,133 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "wrapper/VecIndex.h"
+#include "wrapper/utils.h"
+#include "knowhere/index/vector_index/helpers/FaissGpuResourceMgr.h"
+#include "knowhere/index/vector_index/helpers/IndexParameter.h"
+
+#include <gtest/gtest.h>
+#include "knowhere/index/vector_index/IndexIVFSQHybrid.h"
+
+using ::testing::TestWithParam;
+using ::testing::Values;
+using ::testing::Combine;
+
+class KnowhereHybrid
+    : public DataGenBase, public ::testing::Test {
+ protected:
+    void SetUp() override {
+        knowhere::FaissGpuResourceMgr::GetInstance().InitDevice(DEVICEID, PINMEM, TEMPMEM, RESNUM);
+
+        dim = 128;
+        nb = 10000;
+        nq = 100;
+        k = 100;
+        GenData(dim, nb, nq, xb, xq, ids, k, gt_ids, gt_dis);
+    }
+
+    void TearDown() override {
+        knowhere::FaissGpuResourceMgr::GetInstance().Free();
+    }
+
+ protected:
+    milvus::engine::IndexType index_type;
+    milvus::engine::VecIndexPtr index_ = nullptr;
+    knowhere::Config conf;
+};
+
+#ifdef CUSTOMIZATION
+TEST_F(KnowhereHybrid, test_interface) {
+    assert(!xb.empty());
+
+    index_type = milvus::engine::IndexType::FAISS_IVFSQ8_HYBRID;
+    index_ = GetVecIndexFactory(index_type);
+    conf = ParamGenerator::GetInstance().Gen(index_type);
+
+    auto elems = nq * k;
+    std::vector<int64_t> res_ids(elems);
+    std::vector<float> res_dis(elems);
+
+    conf->gpu_id = DEVICEID;
+    conf->d = dim;
+    conf->k = k;
+    index_->BuildAll(nb, xb.data(), ids.data(), conf);
+    index_->Search(nq, xq.data(), res_dis.data(), res_ids.data(), conf);
+    AssertResult(res_ids, res_dis);
+    EXPECT_EQ(index_->Count(), nb);
+    EXPECT_EQ(index_->Dimension(), dim);
+
+    auto binaryset = index_->Serialize();
+    {
+        // cpu -> gpu
+        auto cpu_idx = GetVecIndexFactory(index_type);
+        cpu_idx->Load(binaryset);
+        {
+            for (int i = 0; i < 2; ++i) {
+                auto gpu_idx = cpu_idx->CopyToGpu(DEVICEID, conf);
+                gpu_idx->Search(nq, xq.data(), res_dis.data(), res_ids.data(), conf);
+                AssertResult(res_ids, res_dis);
+            }
+        }
+    }
+
+    {
+        // quantization already in gpu, only copy data
+        auto cpu_idx = GetVecIndexFactory(index_type);
+        cpu_idx->Load(binaryset);
+
+        auto pair = cpu_idx->CopyToGpuWithQuantizer(DEVICEID, conf);
+        auto gpu_idx = pair.first;
+        auto quantization = pair.second;
+
+        gpu_idx->Search(nq, xq.data(), res_dis.data(), res_ids.data(), conf);
+        AssertResult(res_ids, res_dis);
+
+        auto quantizer_conf = std::make_shared<knowhere::QuantizerCfg>();
+        quantizer_conf->mode = 2;
+        quantizer_conf->gpu_id = DEVICEID;
+        for (int i = 0; i < 2; ++i) {
+            auto hybrid_idx = GetVecIndexFactory(index_type);
+            hybrid_idx->Load(binaryset);
+
+            hybrid_idx->LoadData(quantization, quantizer_conf);
+            hybrid_idx->Search(nq, xq.data(), res_dis.data(), res_ids.data(), conf);
+            AssertResult(res_ids, res_dis);
+        }
+    }
+
+    {
+        // quantization already in gpu, only set quantization
+        auto cpu_idx = GetVecIndexFactory(index_type);
+        cpu_idx->Load(binaryset);
+
+        auto pair = cpu_idx->CopyToGpuWithQuantizer(DEVICEID, conf);
+        auto quantization = pair.second;
+
+        for (int i = 0; i < 2; ++i) {
+            auto hybrid_idx = GetVecIndexFactory(index_type);
+            hybrid_idx->Load(binaryset);
+
+            hybrid_idx->SetQuantizer(quantization);
+            hybrid_idx->Search(nq, xq.data(), res_dis.data(), res_ids.data(), conf);
+            AssertResult(res_ids, res_dis);
+            hybrid_idx->UnsetQuantizer();
+        }
+    }
+}
+
+#endif
diff --git a/core/unittest/wrapper/test_knowhere.cpp b/core/unittest/wrapper/test_knowhere.cpp
new file mode 100644
index 0000000000..e9b93fb63e
--- /dev/null
+++ b/core/unittest/wrapper/test_knowhere.cpp
@@ -0,0 +1,37 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "wrapper/KnowhereResource.h"
+#include "server/Config.h"
+
+#include <gtest/gtest.h>
+
+namespace {
+
+static const char* CONFIG_FILE_PATH = "./milvus/conf/server_config.yaml";
+static const char* LOG_FILE_PATH = "./milvus/conf/log_config.conf";
+
+} // namespace
+
+TEST(KnowhereTest, KNOWHERE_RESOURCE_TEST) {
+    milvus::server::Config &config = milvus::server::Config::GetInstance();
+    milvus::Status s = config.LoadConfigFile(CONFIG_FILE_PATH);
+    ASSERT_TRUE(s.ok());
+
+    milvus::engine::KnowhereResource::Initialize();
+    milvus::engine::KnowhereResource::Finalize();
+}
diff --git a/core/unittest/wrapper/test_wrapper.cpp b/core/unittest/wrapper/test_wrapper.cpp
new file mode 100644
index 0000000000..f112fc7e65
--- /dev/null
+++ b/core/unittest/wrapper/test_wrapper.cpp
@@ -0,0 +1,177 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 "utils/easylogging++.h"
+#include "wrapper/VecIndex.h"
+#include "knowhere/index/vector_index/helpers/FaissGpuResourceMgr.h"
+#include "knowhere/index/vector_index/helpers/IndexParameter.h"
+#include "wrapper/utils.h"
+
+#include <gtest/gtest.h>
+
+INITIALIZE_EASYLOGGINGPP
+
+using ::testing::TestWithParam;
+using ::testing::Values;
+using ::testing::Combine;
+
+class KnowhereWrapperTest
+    : public DataGenBase,
+      public TestWithParam<::std::tuple<milvus::engine::IndexType, std::string, int, int, int, int>> {
+ protected:
+    void SetUp() override {
+        knowhere::FaissGpuResourceMgr::GetInstance().InitDevice(DEVICEID, PINMEM, TEMPMEM, RESNUM);
+
+        std::string generator_type;
+        std::tie(index_type, generator_type, dim, nb, nq, k) = GetParam();
+        GenData(dim, nb, nq, xb, xq, ids, k, gt_ids, gt_dis);
+
+        index_ = GetVecIndexFactory(index_type);
+        conf = ParamGenerator::GetInstance().Gen(index_type);
+        conf->k = k;
+        conf->d = dim;
+        conf->gpu_id = DEVICEID;
+    }
+
+    void TearDown() override {
+        knowhere::FaissGpuResourceMgr::GetInstance().Free();
+    }
+
+ protected:
+    milvus::engine::IndexType index_type;
+    milvus::engine::VecIndexPtr index_ = nullptr;
+    knowhere::Config conf;
+};
+
+INSTANTIATE_TEST_CASE_P(WrapperParam, KnowhereWrapperTest,
+                        Values(
+                            //["Index type", "Generator type", "dim", "nb", "nq", "k", "build config", "search config"]
+                            std::make_tuple(milvus::engine::IndexType::FAISS_IVFFLAT_CPU,
+                                            "Default",
+                                            64,
+                                            100000,
+                                            10,
+                                            10),
+                            std::make_tuple(milvus::engine::IndexType::FAISS_IVFFLAT_GPU, "Default", DIM, NB, 10, 10),
+                            std::make_tuple(milvus::engine::IndexType::FAISS_IVFFLAT_MIX,
+                                            "Default",
+                                            64,
+                                            100000,
+                                            10,
+                                            10),
+                            std::make_tuple(milvus::engine::IndexType::FAISS_IVFSQ8_CPU, "Default", DIM, NB, 10, 10),
+//                            std::make_tuple(milvus::engine::IndexType::FAISS_IVFSQ8_GPU, "Default", DIM, NB, 10, 10),
+                            std::make_tuple(milvus::engine::IndexType::FAISS_IVFSQ8_MIX, "Default", DIM, NB, 10, 10),
+//                            std::make_tuple(IndexType::NSG_MIX, "Default", 128, 250000, 10, 10),
+//                            std::make_tuple(IndexType::SPTAG_KDT_RNT_CPU, "Default", 128, 250000, 10, 10),
+                            std::make_tuple(milvus::engine::IndexType::FAISS_IDMAP, "Default", 64, 100000, 10, 10)
+                        )
+);
+
+TEST_P(KnowhereWrapperTest, BASE_TEST) {
+    EXPECT_EQ(index_->GetType(), index_type);
+
+    auto elems = nq * k;
+    std::vector<int64_t> res_ids(elems);
+    std::vector<float> res_dis(elems);
+
+    index_->BuildAll(nb, xb.data(), ids.data(), conf);
+    index_->Search(nq, xq.data(), res_dis.data(), res_ids.data(), conf);
+    AssertResult(res_ids, res_dis);
+}
+
+TEST_P(KnowhereWrapperTest, TO_GPU_TEST) {
+    EXPECT_EQ(index_->GetType(), index_type);
+
+    auto elems = nq * k;
+    std::vector<int64_t> res_ids(elems);
+    std::vector<float> res_dis(elems);
+
+    index_->BuildAll(nb, xb.data(), ids.data(), conf);
+    index_->Search(nq, xq.data(), res_dis.data(), res_ids.data(), conf);
+    AssertResult(res_ids, res_dis);
+
+    {
+        auto dev_idx = index_->CopyToGpu(DEVICEID);
+        for (int i = 0; i < 10; ++i) {
+            dev_idx->Search(nq, xq.data(), res_dis.data(), res_ids.data(), conf);
+        }
+        AssertResult(res_ids, res_dis);
+    }
+
+    {
+        std::string file_location = "/tmp/knowhere_gpu_file";
+        write_index(index_, file_location);
+        auto new_index = milvus::engine::read_index(file_location);
+
+        auto dev_idx = new_index->CopyToGpu(DEVICEID);
+        for (int i = 0; i < 10; ++i) {
+            dev_idx->Search(nq, xq.data(), res_dis.data(), res_ids.data(), conf);
+        }
+        AssertResult(res_ids, res_dis);
+    }
+}
+
+TEST_P(KnowhereWrapperTest, SERIALIZE_TEST) {
+    EXPECT_EQ(index_->GetType(), index_type);
+
+    auto elems = nq * k;
+    std::vector<int64_t> res_ids(elems);
+    std::vector<float> res_dis(elems);
+    index_->BuildAll(nb, xb.data(), ids.data(), conf);
+    index_->Search(nq, xq.data(), res_dis.data(), res_ids.data(), conf);
+    AssertResult(res_ids, res_dis);
+
+    {
+        auto binary = index_->Serialize();
+        auto type = index_->GetType();
+        auto new_index = GetVecIndexFactory(type);
+        new_index->Load(binary);
+        EXPECT_EQ(new_index->Dimension(), index_->Dimension());
+        EXPECT_EQ(new_index->Count(), index_->Count());
+
+        std::vector<int64_t> res_ids(elems);
+        std::vector<float> res_dis(elems);
+        new_index->Search(nq, xq.data(), res_dis.data(), res_ids.data(), conf);
+        AssertResult(res_ids, res_dis);
+    }
+
+    {
+        std::string file_location = "/tmp/knowhere";
+        write_index(index_, file_location);
+        auto new_index = milvus::engine::read_index(file_location);
+        EXPECT_EQ(new_index->GetType(), ConvertToCpuIndexType(index_type));
+        EXPECT_EQ(new_index->Dimension(), index_->Dimension());
+        EXPECT_EQ(new_index->Count(), index_->Count());
+
+        std::vector<int64_t> res_ids(elems);
+        std::vector<float> res_dis(elems);
+        new_index->Search(nq, xq.data(), res_dis.data(), res_ids.data(), conf);
+        AssertResult(res_ids, res_dis);
+    }
+}
+
+#include "wrapper/ConfAdapter.h"
+TEST(whatever, test_config) {
+    milvus::engine::TempMetaConf conf;
+    auto nsg_conf = std::make_shared<milvus::engine::NSGConfAdapter>();
+    nsg_conf->Match(conf);
+    nsg_conf->MatchSearch(conf, milvus::engine::IndexType::FAISS_IVFPQ_GPU);
+
+    auto pq_conf = std::make_shared<milvus::engine::IVFPQConfAdapter>();
+    pq_conf->Match(conf);
+}
diff --git a/core/unittest/wrapper/utils.cpp b/core/unittest/wrapper/utils.cpp
new file mode 100644
index 0000000000..445b7a2de6
--- /dev/null
+++ b/core/unittest/wrapper/utils.cpp
@@ -0,0 +1,89 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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 <gtest/gtest.h>
+#include <faiss/IndexFlat.h>
+
+#include "wrapper/utils.h"
+
+void
+DataGenBase::GenData(const int &dim, const int &nb, const int &nq,
+                     float *xb, float *xq, int64_t *ids,
+                     const int &k, int64_t *gt_ids, float *gt_dis) {
+    for (auto i = 0; i < nb; ++i) {
+        for (auto j = 0; j < dim; ++j) {
+            //p_data[i * d + j] = float(base + i);
+            xb[i * dim + j] = drand48();
+        }
+        xb[dim * i] += i / 1000.;
+        ids[i] = i;
+    }
+    for (size_t i = 0; i < nq * dim; ++i) {
+        xq[i] = xb[i];
+    }
+
+    faiss::IndexFlatL2 index(dim);
+    //index.add_with_ids(nb, xb, ids);
+    index.add(nb, xb);
+    index.search(nq, xq, k, gt_dis, gt_ids);
+}
+
+void
+DataGenBase::GenData(const int &dim,
+                     const int &nb,
+                     const int &nq,
+                     std::vector<float> &xb,
+                     std::vector<float> &xq,
+                     std::vector<int64_t> &ids,
+                     const int &k,
+                     std::vector<int64_t> &gt_ids,
+                     std::vector<float> &gt_dis) {
+    xb.resize(nb * dim);
+    xq.resize(nq * dim);
+    ids.resize(nb);
+    gt_ids.resize(nq * k);
+    gt_dis.resize(nq * k);
+    GenData(dim, nb, nq, xb.data(), xq.data(), ids.data(), k, gt_ids.data(), gt_dis.data());
+}
+
+void
+DataGenBase::AssertResult(const std::vector<int64_t>& ids, const std::vector<float>& dis) {
+        EXPECT_EQ(ids.size(), nq * k);
+        EXPECT_EQ(dis.size(), nq * k);
+
+        for (auto i = 0; i < nq; i++) {
+            EXPECT_EQ(ids[i * k], gt_ids[i * k]);
+            //EXPECT_EQ(dis[i * k], gt_dis[i * k]);
+        }
+
+        int match = 0;
+        for (int i = 0; i < nq; ++i) {
+            for (int j = 0; j < k; ++j) {
+                for (int l = 0; l < k; ++l) {
+                    if (ids[i * nq + j] == gt_ids[i * nq + l]) match++;
+                }
+            }
+        }
+
+        auto precision = float(match) / (nq * k);
+        EXPECT_GT(precision, 0.5);
+        std::cout << std::endl << "Precision: " << precision
+                  << ", match: " << match
+                  << ", total: " << nq * k
+                  << std::endl;
+}
diff --git a/core/unittest/wrapper/utils.h b/core/unittest/wrapper/utils.h
new file mode 100644
index 0000000000..5a614543c9
--- /dev/null
+++ b/core/unittest/wrapper/utils.h
@@ -0,0 +1,139 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+
+#pragma once
+
+#include <memory>
+#include <vector>
+#include <cstdlib>
+#include <cstdio>
+#include <fstream>
+
+#include "wrapper/VecIndex.h"
+#include "wrapper/utils.h"
+#include "knowhere/index/vector_index/helpers/IndexParameter.h"
+
+class DataGenBase;
+
+using DataGenPtr = std::shared_ptr<DataGenBase>;
+
+constexpr int64_t DIM = 128;
+constexpr int64_t NB = 100000;
+constexpr int64_t NQ = 10;
+constexpr int64_t DEVICEID = 0;
+constexpr int64_t PINMEM = 1024 * 1024 * 200;
+constexpr int64_t TEMPMEM = 1024 * 1024 * 300;
+constexpr int64_t RESNUM = 2;
+
+class DataGenBase {
+ public:
+    virtual void GenData(const int& dim, const int& nb, const int& nq, float* xb, float* xq, int64_t* ids,
+                         const int& k, int64_t* gt_ids, float* gt_dis);
+
+    virtual void GenData(const int& dim,
+                         const int& nb,
+                         const int& nq,
+                         std::vector<float>& xb,
+                         std::vector<float>& xq,
+                         std::vector<int64_t>& ids,
+                         const int& k,
+                         std::vector<int64_t>& gt_ids,
+                         std::vector<float>& gt_dis);
+
+    void AssertResult(const std::vector<int64_t>& ids, const std::vector<float>& dis);
+
+    int dim = DIM;
+    int nb = NB;
+    int nq = NQ;
+    int k = 10;
+    std::vector<float> xb;
+    std::vector<float> xq;
+    std::vector<int64_t> ids;
+
+    // Ground Truth
+    std::vector<int64_t> gt_ids;
+    std::vector<float> gt_dis;
+};
+
+class ParamGenerator {
+ public:
+    static ParamGenerator& GetInstance() {
+        static ParamGenerator instance;
+        return instance;
+    }
+
+    knowhere::Config Gen(const milvus::engine::IndexType& type) {
+        switch (type) {
+            case milvus::engine::IndexType::FAISS_IDMAP: {
+                auto tempconf = std::make_shared<knowhere::Cfg>();
+                tempconf->metric_type = knowhere::METRICTYPE::L2;
+                return tempconf;
+            }
+            case milvus::engine::IndexType::FAISS_IVFFLAT_CPU:
+            case milvus::engine::IndexType::FAISS_IVFFLAT_GPU:
+            case milvus::engine::IndexType::FAISS_IVFFLAT_MIX: {
+                auto tempconf = std::make_shared<knowhere::IVFCfg>();
+                tempconf->nlist = 100;
+                tempconf->nprobe = 16;
+                tempconf->metric_type = knowhere::METRICTYPE::L2;
+                return tempconf;
+            }
+            case milvus::engine::IndexType::FAISS_IVFSQ8_HYBRID:
+            case milvus::engine::IndexType::FAISS_IVFSQ8_CPU:
+            case milvus::engine::IndexType::FAISS_IVFSQ8_GPU:
+            case milvus::engine::IndexType::FAISS_IVFSQ8_MIX: {
+                auto tempconf = std::make_shared<knowhere::IVFSQCfg>();
+                tempconf->nlist = 100;
+                tempconf->nprobe = 16;
+                tempconf->nbits = 8;
+                tempconf->metric_type = knowhere::METRICTYPE::L2;
+                return tempconf;
+            }
+//            case milvus::engine::IndexType::FAISS_IVFPQ_CPU:
+//            case milvus::engine::IndexType::FAISS_IVFPQ_GPU: {
+//                auto tempconf = std::make_shared<knowhere::IVFPQCfg>();
+//                tempconf->nlist = 100;
+//                tempconf->nprobe = 16;
+//                tempconf->nbits = 8;
+//                tempconf->m = 8;
+//                tempconf->metric_type = knowhere::METRICTYPE::L2;
+//                return tempconf;
+//            }
+//            case milvus::engine::IndexType::NSG_MIX: {
+//                auto tempconf = std::make_shared<knowhere::NSGCfg>();
+//                tempconf->nlist = 100;
+//                tempconf->nprobe = 16;
+//                tempconf->search_length = 8;
+//                tempconf->knng = 200;
+//                tempconf->search_length = 40; // TODO(linxj): be 20 when search
+//                tempconf->out_degree = 60;
+//                tempconf->candidate_pool_size = 200;
+//                tempconf->metric_type = knowhere::METRICTYPE::L2;
+//                return tempconf;
+//            }
+        }
+    }
+};
+
+
+//class SanityCheck : public DataGenBase {
+// public:
+//    void GenData(const int &dim, const int &nb, const int &nq, float *xb, float *xq, long *ids,
+//                 const int &k, long *gt_ids, float *gt_dis) override;
+//};
+
diff --git a/core/version.h.macro b/core/version.h.macro
new file mode 100644
index 0000000000..454d8a990a
--- /dev/null
+++ b/core/version.h.macro
@@ -0,0 +1,22 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+#pragma once
+
+#define MILVUS_VERSION "@MILVUS_VERSION@"
+#define BUILD_TYPE "@BUILD_TYPE@"
+#define BUILD_TIME @BUILD_TIME@
\ No newline at end of file
diff --git a/docker/alertmanager.yml b/docker/alertmanager.yml
new file mode 100644
index 0000000000..e1f079dce0
--- /dev/null
+++ b/docker/alertmanager.yml
@@ -0,0 +1,19 @@
+global:
+  resolve_timeout: 5m
+
+route:
+  group_by: ['alertname']
+  group_wait: 10s
+  group_interval: 10s
+  repeat_interval: 1h
+  receiver: 'web.hook'
+receivers:
+- name: 'web.hook'
+  webhook_configs:
+  - url: 'http://127.0.0.1:5001/'
+inhibit_rules:
+  - source_match:
+      severity: 'critical'
+    target_match:
+      severity: 'warning'
+    equal: ['alertname', 'dev', 'instance']
diff --git a/docker/build_env/ubuntu16.04/Dockerfile b/docker/build_env/ubuntu16.04/Dockerfile
new file mode 100644
index 0000000000..a0ccecce5f
--- /dev/null
+++ b/docker/build_env/ubuntu16.04/Dockerfile
@@ -0,0 +1,25 @@
+FROM nvidia/cuda:10.1-devel-ubuntu16.04
+
+ENV NVIDIA_DRIVER_CAPABILITIES compute,utility
+
+RUN apt-get update && apt-get install -y --no-install-recommends wget && \
+    wget -qO- "https://cmake.org/files/v3.14/cmake-3.14.3-Linux-x86_64.tar.gz" | tar --strip-components=1 -xz -C /usr/local && \
+    wget -P /tmp https://apt.repos.intel.com/intel-gpg-keys/GPG-PUB-KEY-INTEL-SW-PRODUCTS-2019.PUB && \
+    apt-key add /tmp/GPG-PUB-KEY-INTEL-SW-PRODUCTS-2019.PUB && \
+    sh -c 'echo deb https://apt.repos.intel.com/mkl all main > /etc/apt/sources.list.d/intel-mkl.list' && \
+    apt-get update && apt-get install -y --no-install-recommends \
+    git flex bison gfortran \
+    curl libtool automake libboost1.58-all-dev libssl-dev pkg-config libcurl4-openssl-dev \
+    clang-format-6.0 clang-tidy-6.0 \
+    lcov mysql-client libmysqlclient-dev intel-mkl-gnu-2019.4-243 intel-mkl-core-2019.4-243 && \
+    apt-get remove --purge -y && \
+    rm -rf /var/lib/apt/lists/*
+
+RUN ln -s /usr/lib/x86_64-linux-gnu/libmysqlclient.so /usr/lib/x86_64-linux-gnu/libmysqlclient_r.so
+
+RUN sh -c 'echo export LD_LIBRARY_PATH=/opt/intel/compilers_and_libraries_2019.4.243/linux/mkl/lib/intel64:\$LD_LIBRARY_PATH > /etc/profile.d/mkl.sh'
+
+COPY docker-entrypoint.sh /app/docker-entrypoint.sh
+ENTRYPOINT [ "/app/docker-entrypoint.sh" ]
+CMD [ "start" ]
+
diff --git a/docker/build_env/ubuntu16.04/docker-entrypoint.sh b/docker/build_env/ubuntu16.04/docker-entrypoint.sh
new file mode 100755
index 0000000000..1e85e7e9e1
--- /dev/null
+++ b/docker/build_env/ubuntu16.04/docker-entrypoint.sh
@@ -0,0 +1,10 @@
+#!/bin/bash
+
+set -e
+
+if [ "$1" = 'start' ]; then
+   tail -f /dev/null
+fi
+
+exec "$@"
+
diff --git a/docker/build_env/ubuntu18.04/Dockerfile b/docker/build_env/ubuntu18.04/Dockerfile
new file mode 100644
index 0000000000..e7c528f48e
--- /dev/null
+++ b/docker/build_env/ubuntu18.04/Dockerfile
@@ -0,0 +1,25 @@
+FROM nvidia/cuda:10.1-devel-ubuntu18.04
+
+ENV NVIDIA_DRIVER_CAPABILITIES compute,utility
+
+RUN apt-get update && apt-get install -y --no-install-recommends wget && \
+    wget -qO- "https://cmake.org/files/v3.14/cmake-3.14.3-Linux-x86_64.tar.gz" | tar --strip-components=1 -xz -C /usr/local && \
+    wget -P /tmp https://apt.repos.intel.com/intel-gpg-keys/GPG-PUB-KEY-INTEL-SW-PRODUCTS-2019.PUB && \
+    apt-key add /tmp/GPG-PUB-KEY-INTEL-SW-PRODUCTS-2019.PUB && \
+    sh -c 'echo deb https://apt.repos.intel.com/mkl all main > /etc/apt/sources.list.d/intel-mkl.list' && \
+    apt-get update && apt-get install -y --no-install-recommends \
+    git flex bison gfortran \
+    curl libtool automake libboost-all-dev libssl-dev pkg-config libcurl4-openssl-dev \
+    clang-format-6.0 clang-tidy-6.0 \
+    lcov mysql-client libmysqlclient-dev intel-mkl-gnu-2019.4-243 intel-mkl-core-2019.4-243 && \
+    apt-get remove --purge -y && \
+    rm -rf /var/lib/apt/lists/*
+
+RUN ln -s /usr/lib/x86_64-linux-gnu/libmysqlclient.so /usr/lib/x86_64-linux-gnu/libmysqlclient_r.so
+
+RUN sh -c 'echo export LD_LIBRARY_PATH=/opt/intel/compilers_and_libraries_2019.4.243/linux/mkl/lib/intel64:\$LD_LIBRARY_PATH > /etc/profile.d/mkl.sh'
+
+COPY docker-entrypoint.sh /app/docker-entrypoint.sh
+ENTRYPOINT [ "/app/docker-entrypoint.sh" ]
+CMD [ "start" ]
+
diff --git a/docker/build_env/ubuntu18.04/docker-entrypoint.sh b/docker/build_env/ubuntu18.04/docker-entrypoint.sh
new file mode 100755
index 0000000000..1e85e7e9e1
--- /dev/null
+++ b/docker/build_env/ubuntu18.04/docker-entrypoint.sh
@@ -0,0 +1,10 @@
+#!/bin/bash
+
+set -e
+
+if [ "$1" = 'start' ]; then
+   tail -f /dev/null
+fi
+
+exec "$@"
+
diff --git a/docker/deploy/ubuntu16.04/Dockerfile b/docker/deploy/ubuntu16.04/Dockerfile
new file mode 100644
index 0000000000..c5ca0ab03e
--- /dev/null
+++ b/docker/deploy/ubuntu16.04/Dockerfile
@@ -0,0 +1,23 @@
+FROM nvidia/cuda:10.1-devel-ubuntu16.04
+
+ENV NVIDIA_DRIVER_CAPABILITIES compute,utility
+
+RUN rm -rf /etc/apt/sources.list.d/nvidia-ml.list && rm -rf /etc/apt/sources.list.d/cuda.list
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    gfortran libsqlite3-dev libmysqlclient-dev libcurl4-openssl-dev python3 && \
+    apt-get remove --purge -y && \
+    rm -rf /var/lib/apt/lists/*
+
+RUN ln -s /usr/lib/x86_64-linux-gnu/libmysqlclient.so /usr/lib/x86_64-linux-gnu/libmysqlclient_r.so
+
+COPY ./docker-entrypoint.sh /opt
+COPY ./milvus /opt/milvus
+ENV LD_LIBRARY_PATH="$LD_LIBRARY_PATH:/opt/milvus/lib"
+
+ENTRYPOINT [ "/opt/docker-entrypoint.sh" ]
+
+CMD [ "start" ]
+
+EXPOSE 19530
+
diff --git a/docker/deploy/ubuntu16.04/docker-entrypoint.sh b/docker/deploy/ubuntu16.04/docker-entrypoint.sh
new file mode 100755
index 0000000000..446c174d74
--- /dev/null
+++ b/docker/deploy/ubuntu16.04/docker-entrypoint.sh
@@ -0,0 +1,10 @@
+#!/bin/bash
+
+set -e
+
+if [ "$1" == 'start' ]; then
+    cd /opt/milvus/scripts && ./start_server.sh
+fi
+
+exec "$@"
+
diff --git a/docker/deploy/ubuntu18.04/Dockerfile b/docker/deploy/ubuntu18.04/Dockerfile
new file mode 100644
index 0000000000..0d16ae46e1
--- /dev/null
+++ b/docker/deploy/ubuntu18.04/Dockerfile
@@ -0,0 +1,23 @@
+FROM nvidia/cuda:10.1-devel-ubuntu18.04
+
+ENV NVIDIA_DRIVER_CAPABILITIES compute,utility
+
+RUN rm -rf /etc/apt/sources.list.d/nvidia-ml.list && rm -rf /etc/apt/sources.list.d/cuda.list
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    gfortran libsqlite3-dev libmysqlclient-dev libcurl4-openssl-dev python3 && \
+    apt-get remove --purge -y && \
+    rm -rf /var/lib/apt/lists/*
+
+RUN ln -s /usr/lib/x86_64-linux-gnu/libmysqlclient.so /usr/lib/x86_64-linux-gnu/libmysqlclient_r.so
+
+COPY ./docker-entrypoint.sh /opt
+COPY ./milvus /opt/milvus
+ENV LD_LIBRARY_PATH="$LD_LIBRARY_PATH:/opt/milvus/lib"
+
+ENTRYPOINT [ "/opt/docker-entrypoint.sh" ]
+
+CMD [ "start" ]
+
+EXPOSE 19530
+
diff --git a/docker/deploy/ubuntu18.04/docker-entrypoint.sh b/docker/deploy/ubuntu18.04/docker-entrypoint.sh
new file mode 100755
index 0000000000..446c174d74
--- /dev/null
+++ b/docker/deploy/ubuntu18.04/docker-entrypoint.sh
@@ -0,0 +1,10 @@
+#!/bin/bash
+
+set -e
+
+if [ "$1" == 'start' ]; then
+    cd /opt/milvus/scripts && ./start_server.sh
+fi
+
+exec "$@"
+
diff --git a/docker/docker-compose-monitor.yml b/docker/docker-compose-monitor.yml
new file mode 100644
index 0000000000..ac417674be
--- /dev/null
+++ b/docker/docker-compose-monitor.yml
@@ -0,0 +1,58 @@
+version: '2.3'
+
+networks:
+    monitor:
+        driver: bridge
+
+services:
+    prometheus:
+        image: prom/prometheus:v2.11.1
+        container_name: prometheus
+        hostname: prometheus
+        restart: always
+        volumes:
+            - ./prometheus.yml:/etc/prometheus/prometheus.yml
+            - ./server_down.yml:/etc/prometheus/node_down.yml
+        ports:
+            - "9090:9090"
+        networks:
+            - monitor
+
+    alertmanager:
+        image: prom/alertmanager
+        container_name: alertmanager
+        hostname: alertmanager
+        restart: always
+        volumes:
+            - ./alertmanager.yml:/etc/alertmanager/alertmanager.yml
+        ports:
+            - "9093:9093"
+        networks:
+            - monitor
+
+    grafana:
+        image: grafana/grafana
+        container_name: grafana
+        hostname: grafana
+        restart: always
+        ports:
+            - "3000:3000"
+        networks:
+            - monitor
+
+    milvus_server:
+        runtime: nvidia
+        image: milvusdb/milvus:latest
+        restart: always
+        links:
+            - prometheus
+        environment:
+            WEB_APP: host.docker.internal
+        volumes:
+            - ../core/conf/server_config.yaml:/opt/milvus/conf/server_config.yaml
+            - ../core/conf/log_config.conf:/opt/milvus/conf/log_config.conf
+        ports:
+            - "8080:8080"
+            - "19530:19530"
+        networks:
+            - monitor
diff --git a/docker/prometheus.yml b/docker/prometheus.yml
new file mode 100644
index 0000000000..91c64458a5
--- /dev/null
+++ b/docker/prometheus.yml
@@ -0,0 +1,38 @@
+# my global config
+global:
+  scrape_interval:     15s # Set the scrape interval to every 1 seconds. Default is every 1 minute.
+  evaluation_interval: 15s # Evaluate rules every 15 seconds. The default is every 1 minute.
+  # scrape_timeout is set to the global default (10s).
+
+# Alertmanager configuration
+alerting:
+  alertmanagers:
+  - static_configs:
+    - targets: ['localhost:9093']
+
+# Load rules once and periodically evaluate them according to the global 'evaluation_interval'.
+rule_files:
+   - "serverdown.yml" # add alerting rules
+
+# A scrape configuration containing exactly one endpoint to scrape:
+# Here it's Prometheus itself.
+scrape_configs:
+  # The job name is added as a label `job=<job_name>` to any timeseries scraped from this config.
+  - job_name: 'prometheus'
+
+    # metrics_path defaults to '/metrics'
+    # scheme defaults to 'http'.
+
+    static_configs:
+    - targets: ['prometheus:9090']
+
+   # scrape metrics of server
+  - job_name: 'milvus_server'
+    scrape_interval: 1s
+    static_configs:
+    - targets: ['milvus_server:8080']
+
+   # under development
+  - job_name: 'pushgateway'
+    static_configs:
+    - targets: ['pushgateway:9091']
diff --git a/docker/server_down.yml b/docker/server_down.yml
new file mode 100644
index 0000000000..8a7077c7f8
--- /dev/null
+++ b/docker/server_down.yml
@@ -0,0 +1,8 @@
+groups:
+- name: milvus
+  rules:
+    - alert: MilvusServerDown
+      expr: up{job="milvus_server"}
+      for: 1s
+      labels:
+        serverity: page
diff --git a/tests/milvus-java-test/.gitignore b/tests/milvus-java-test/.gitignore
new file mode 100644
index 0000000000..3a553813a8
--- /dev/null
+++ b/tests/milvus-java-test/.gitignore
@@ -0,0 +1,4 @@
+target/
+.idea/
+test-output/
+lib/*
diff --git a/tests/milvus-java-test/README.md b/tests/milvus-java-test/README.md
new file mode 100644
index 0000000000..eba21bb4e4
--- /dev/null
+++ b/tests/milvus-java-test/README.md
@@ -0,0 +1,29 @@
+# Requirements
+
+- jdk-1.8
+- testng
+
+# How to use this Test Project
+
+1. package and install
+
+```shell
+mvn clean install
+```
+
+2. start or deploy your milvus server
+3. run tests
+
+```shell
+java -cp \"target/MilvusSDkJavaTest-1.0-SNAPSHOT.jar:lib/*\" com.MainClass -h 127.0.0.1
+```
+
+4. get test report
+
+```shell
+firefox test-output/index.html
+```
+
+# Contribution getting started
+
+Add test cases under testng framework
\ No newline at end of file
diff --git a/tests/milvus-java-test/bin/run.sh b/tests/milvus-java-test/bin/run.sh
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/tests/milvus-java-test/ci/function/file_transfer.groovy b/tests/milvus-java-test/ci/function/file_transfer.groovy
new file mode 100644
index 0000000000..bebae14832
--- /dev/null
+++ b/tests/milvus-java-test/ci/function/file_transfer.groovy
@@ -0,0 +1,10 @@
+def FileTransfer (sourceFiles, remoteDirectory, remoteIP, protocol = "ftp", makeEmptyDirs = true) {
+    if (protocol == "ftp") {
+        ftpPublisher masterNodeName: '', paramPublish: [parameterName: ''], alwaysPublishFromMaster: false, continueOnError: false, failOnError: true, publishers: [
+            [configName: "${remoteIP}", transfers: [
+                [asciiMode: false, cleanRemote: false, excludes: '', flatten: false, makeEmptyDirs: "${makeEmptyDirs}", noDefaultExcludes: false, patternSeparator: '[, ]+', remoteDirectory: "${remoteDirectory}", remoteDirectorySDF: false, removePrefix: '', sourceFiles: "${sourceFiles}"]], usePromotionTimestamp: true, useWorkspaceInPromotion: false, verbose: true
+                ]
+            ]
+    }
+}
+return this
diff --git a/tests/milvus-java-test/ci/jenkinsfile/cleanup.groovy b/tests/milvus-java-test/ci/jenkinsfile/cleanup.groovy
new file mode 100644
index 0000000000..2e9332fa6e
--- /dev/null
+++ b/tests/milvus-java-test/ci/jenkinsfile/cleanup.groovy
@@ -0,0 +1,13 @@
+try {
+    def result = sh script: "helm status ${env.JOB_NAME}-${env.BUILD_NUMBER}", returnStatus: true
+    if (!result) {
+        sh "helm del --purge ${env.JOB_NAME}-${env.BUILD_NUMBER}"
+    }
+} catch (exc) {
+    def result = sh script: "helm status ${env.JOB_NAME}-${env.BUILD_NUMBER}", returnStatus: true
+    if (!result) {
+        sh "helm del --purge ${env.JOB_NAME}-${env.BUILD_NUMBER}"
+    }
+    throw exc
+}
+
diff --git a/tests/milvus-java-test/ci/jenkinsfile/deploy_server.groovy b/tests/milvus-java-test/ci/jenkinsfile/deploy_server.groovy
new file mode 100644
index 0000000000..6650b7c219
--- /dev/null
+++ b/tests/milvus-java-test/ci/jenkinsfile/deploy_server.groovy
@@ -0,0 +1,16 @@
+try {
+    sh 'helm init --client-only --skip-refresh --stable-repo-url https://kubernetes.oss-cn-hangzhou.aliyuncs.com/charts'
+    sh 'helm repo add milvus https://registry.zilliz.com/chartrepo/milvus'
+    sh 'helm repo update'
+    dir ("milvus-helm") {
+        checkout([$class: 'GitSCM', branches: [[name: "${HELM_BRANCH}"]], doGenerateSubmoduleConfigurations: false, extensions: [], submoduleCfg: [], userRemoteConfigs: [[credentialsId: "${params.GIT_USER}", url: "git@192.168.1.105:megasearch/milvus-helm.git", name: 'origin', refspec: "+refs/heads/${HELM_BRANCH}:refs/remotes/origin/${HELM_BRANCH}"]]])
+        dir ("milvus/milvus-gpu") {
+            sh "helm install --wait --timeout 300 --set engine.image.tag=${IMAGE_TAG} --set expose.type=clusterIP --name ${env.JOB_NAME}-${env.BUILD_NUMBER} -f ci/values.yaml --namespace milvus-sdk-test --version 0.3.1 ."
+        }
+    }
+} catch (exc) {
+    echo 'Helm running failed!'
+    sh "helm del --purge ${env.JOB_NAME}-${env.BUILD_NUMBER}"
+    throw exc
+}
+
diff --git a/tests/milvus-java-test/ci/jenkinsfile/integration_test.groovy b/tests/milvus-java-test/ci/jenkinsfile/integration_test.groovy
new file mode 100644
index 0000000000..662c93bc77
--- /dev/null
+++ b/tests/milvus-java-test/ci/jenkinsfile/integration_test.groovy
@@ -0,0 +1,13 @@
+timeout(time: 30, unit: 'MINUTES') {
+    try {
+        dir ("milvus-java-test") {
+            sh "mvn clean install"
+            sh "java -cp \"target/MilvusSDkJavaTest-1.0-SNAPSHOT.jar:lib/*\" com.MainClass -h ${env.JOB_NAME}-${env.BUILD_NUMBER}-milvus-gpu-engine.milvus-sdk-test.svc.cluster.local"
+        }
+
+    } catch (exc) {
+        echo 'Milvus-SDK-Java Integration Test Failed !'
+        throw exc
+    }
+}
+
diff --git a/tests/milvus-java-test/ci/jenkinsfile/notify.groovy b/tests/milvus-java-test/ci/jenkinsfile/notify.groovy
new file mode 100644
index 0000000000..0a257b8cd8
--- /dev/null
+++ b/tests/milvus-java-test/ci/jenkinsfile/notify.groovy
@@ -0,0 +1,15 @@
+def notify() {
+    if (!currentBuild.resultIsBetterOrEqualTo('SUCCESS')) {
+        // Send an email only if the build status has changed from green/unstable to red
+        emailext subject: '$DEFAULT_SUBJECT',
+        body: '$DEFAULT_CONTENT',
+        recipientProviders: [
+            [$class: 'DevelopersRecipientProvider'],
+            [$class: 'RequesterRecipientProvider']
+        ], 
+        replyTo: '$DEFAULT_REPLYTO',
+        to: '$DEFAULT_RECIPIENTS'
+    }
+}
+return this
+
diff --git a/tests/milvus-java-test/ci/jenkinsfile/upload_unit_test_out.groovy b/tests/milvus-java-test/ci/jenkinsfile/upload_unit_test_out.groovy
new file mode 100644
index 0000000000..7e106c0296
--- /dev/null
+++ b/tests/milvus-java-test/ci/jenkinsfile/upload_unit_test_out.groovy
@@ -0,0 +1,13 @@
+timeout(time: 5, unit: 'MINUTES') {
+    dir ("${PROJECT_NAME}_test") {
+        if (fileExists('test_out')) {
+            def fileTransfer = load "${env.WORKSPACE}/ci/function/file_transfer.groovy"
+            fileTransfer.FileTransfer("test_out/", "${PROJECT_NAME}/test/${JOB_NAME}-${BUILD_ID}", 'nas storage')
+            if (currentBuild.resultIsBetterOrEqualTo('SUCCESS')) {
+                echo "Milvus Dev Test Out Viewer \"ftp://192.168.1.126/data/${PROJECT_NAME}/test/${JOB_NAME}-${BUILD_ID}\""
+            }
+        } else {
+            error("Milvus Dev Test Out directory don't exists!")
+        }
+    }
+}
diff --git a/tests/milvus-java-test/ci/main_jenkinsfile b/tests/milvus-java-test/ci/main_jenkinsfile
new file mode 100644
index 0000000000..5df9d61ccb
--- /dev/null
+++ b/tests/milvus-java-test/ci/main_jenkinsfile
@@ -0,0 +1,110 @@
+pipeline {
+    agent none
+
+    options {
+        timestamps()
+    }
+
+    environment {
+        SRC_BRANCH = "master"
+        IMAGE_TAG = "${params.IMAGE_TAG}-release"
+        HELM_BRANCH = "${params.IMAGE_TAG}" 
+        TEST_URL = "git@192.168.1.105:Test/milvus-java-test.git"
+        TEST_BRANCH = "${params.IMAGE_TAG}"
+    }
+
+    stages {
+        stage("Setup env") {
+            agent {
+                kubernetes {
+                    label 'dev-test'
+                    defaultContainer 'jnlp'
+                    yaml """
+                        apiVersion: v1
+                        kind: Pod
+                        metadata:
+                          labels:
+                            app: milvus
+                            componet: test
+                        spec:
+                          containers:
+                          - name: milvus-testframework-java
+                            image: registry.zilliz.com/milvus/milvus-java-test:v0.1
+                            command:
+                            - cat
+                            tty: true
+                            volumeMounts:
+                            - name: kubeconf
+                              mountPath: /root/.kube/
+                              readOnly: true
+                          volumes:
+                          - name: kubeconf
+                            secret:
+                              secretName: test-cluster-config
+                        """
+                }
+            }
+
+            stages {
+                stage("Deploy Server") {
+                    steps {
+                        gitlabCommitStatus(name: 'Deloy Server') {
+                            container('milvus-testframework-java') {
+                                script {
+                                    load "${env.WORKSPACE}/milvus-java-test/ci/jenkinsfile/deploy_server.groovy"
+                                }
+                            }
+                        }
+                    }
+                }
+                stage("Integration Test") {
+                    steps {
+                        gitlabCommitStatus(name: 'Integration Test') {
+                            container('milvus-testframework-java') {
+                                script {
+                                    print "In integration test stage"
+                                    load "${env.WORKSPACE}/milvus-java-test/ci/jenkinsfile/integration_test.groovy"
+                                }
+                            }
+                        }
+                    }
+                }
+                stage ("Cleanup Env") {
+                    steps {
+                        gitlabCommitStatus(name: 'Cleanup Env') {
+                            container('milvus-testframework-java') {
+                                script {
+                                    load "${env.WORKSPACE}/milvus-java-test/ci/jenkinsfile/cleanup.groovy"
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            post {
+                always {
+                    container('milvus-testframework-java') {
+                        script {
+                            load "${env.WORKSPACE}/milvus-java-test/ci/jenkinsfile/cleanup.groovy"
+                        }
+                    }
+                }
+                success {
+                    script {
+                        echo "Milvus java-sdk test success !"
+                    }
+                }
+                aborted {
+                    script {
+                        echo "Milvus java-sdk test aborted !"
+                    }
+                }
+                failure {
+                    script {
+                        echo "Milvus java-sdk test failed !"
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/tests/milvus-java-test/ci/pod_containers/milvus-testframework.yaml b/tests/milvus-java-test/ci/pod_containers/milvus-testframework.yaml
new file mode 100644
index 0000000000..1381e1454f
--- /dev/null
+++ b/tests/milvus-java-test/ci/pod_containers/milvus-testframework.yaml
@@ -0,0 +1,13 @@
+apiVersion: v1
+kind: Pod
+metadata:
+  labels:
+    app: milvus
+    componet: testframework-java
+spec:
+  containers:
+  - name: milvus-testframework-java
+    image: maven:3.6.2-jdk-8
+    command:
+    - cat
+    tty: true
diff --git a/tests/milvus-java-test/milvus-java-test.iml b/tests/milvus-java-test/milvus-java-test.iml
new file mode 100644
index 0000000000..78b2cc53b2
--- /dev/null
+++ b/tests/milvus-java-test/milvus-java-test.iml
@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4" />
\ No newline at end of file
diff --git a/tests/milvus-java-test/pom.xml b/tests/milvus-java-test/pom.xml
new file mode 100644
index 0000000000..4da715e292
--- /dev/null
+++ b/tests/milvus-java-test/pom.xml
@@ -0,0 +1,137 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>milvus</groupId>
+    <artifactId>MilvusSDkJavaTest</artifactId>
+    <version>1.0-SNAPSHOT</version>
+
+    <build>
+        <plugins>
+            <plugin>
+            <groupId>org.apache.maven.plugins</groupId>
+            <artifactId>maven-dependency-plugin</artifactId>
+            <executions>
+                <execution>
+                    <id>copy-dependencies</id>
+                    <phase>package</phase>
+                    <goals>
+                        <goal>copy-dependencies</goal>
+                    </goals>
+                    <configuration>
+                        <outputDirectory>lib</outputDirectory>
+                        <overWriteReleases>false</overWriteReleases>
+                        <overWriteSnapshots>true</overWriteSnapshots>
+                    </configuration>
+                </execution>
+            </executions>
+            </plugin>
+        </plugins>
+    </build>
+
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <grpc.version>1.23.0</grpc.version><!-- CURRENT_GRPC_VERSION -->
+        <protobuf.version>3.9.0</protobuf.version>
+        <protoc.version>3.9.0</protoc.version>
+        <maven.compiler.source>1.8</maven.compiler.source>
+        <maven.compiler.target>1.8</maven.compiler.target>
+    </properties>
+
+<!--    <dependencyManagement>-->
+<!--        <dependencies>-->
+<!--            <dependency>-->
+<!--                <groupId>io.grpc</groupId>-->
+<!--                <artifactId>grpc-bom</artifactId>-->
+<!--                <version>${grpc.version}</version>-->
+<!--                <type>pom</type>-->
+<!--                <scope>import</scope>-->
+<!--            </dependency>-->
+<!--        </dependencies>-->
+<!--    </dependencyManagement>-->
+
+    <repositories>
+        <repository>
+            <id>oss.sonatype.org-snapshot</id>
+            <url>http://oss.sonatype.org/content/repositories/snapshots</url>
+            <releases>
+                <enabled>false</enabled>
+            </releases>
+            <snapshots>
+                <enabled>true</enabled>
+            </snapshots>
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+            <version>3.4</version>
+        </dependency>
+
+        <dependency>
+            <groupId>commons-cli</groupId>
+            <artifactId>commons-cli</artifactId>
+            <version>1.3</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.testng</groupId>
+            <artifactId>testng</artifactId>
+            <version>6.10</version>
+        </dependency>
+
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.9</version>
+        </dependency>
+
+<!--        <dependency>-->
+<!--            <groupId>io.milvus</groupId>-->
+<!--            <artifactId>milvus-sdk-java</artifactId>-->
+<!--            <version>0.1.0</version>-->
+<!--        </dependency>-->
+
+        <dependency>
+            <groupId>io.milvus</groupId>
+            <artifactId>milvus-sdk-java</artifactId>
+            <version>0.2.0-SNAPSHOT</version>
+        </dependency>
+
+<!--        <dependency>-->
+<!--            <groupId>io.grpc</groupId>-->
+<!--            <artifactId>grpc-netty-sher staded</artifactId>-->
+<!--            <scope>runtime</scope>-->
+<!--        </dependency>-->
+<!--        <dependency>-->
+<!--            <groupId>io.grpc</groupId>-->
+<!--            <artifactId>grpc-protobuf</artifactId>-->
+<!--        </dependency>-->
+<!--        <dependency>-->
+<!--            <groupId>io.grpc</groupId>-->
+<!--            <artifactId>grpc-stub</artifactId>-->
+<!--        </dependency>-->
+<!--        <dependency>-->
+<!--            <groupId>javax.annotation</groupId>-->
+<!--            <artifactId>javax.annotation-api</artifactId>-->
+<!--            <version>1.2</version>-->
+<!--            <scope>provided</scope> &lt;!&ndash; not needed at runtime &ndash;&gt;-->
+<!--        </dependency>-->
+<!--        <dependency>-->
+<!--            <groupId>io.grpc</groupId>-->
+<!--            <artifactId>grpc-testing</artifactId>-->
+<!--            <scope>test</scope>-->
+<!--        </dependency>-->
+<!--        <dependency>-->
+<!--            <groupId>com.google.protobuf</groupId>-->
+<!--            <artifactId>protobuf-java-util</artifactId>-->
+<!--            <version>${protobuf.version}</version>-->
+<!--        </dependency>-->
+
+    </dependencies>
+
+</project>
\ No newline at end of file
diff --git a/tests/milvus-java-test/src/main/java/com/MainClass.java b/tests/milvus-java-test/src/main/java/com/MainClass.java
new file mode 100644
index 0000000000..8928843f01
--- /dev/null
+++ b/tests/milvus-java-test/src/main/java/com/MainClass.java
@@ -0,0 +1,146 @@
+package com;
+
+import io.milvus.client.*;
+import org.apache.commons.cli.*;
+import org.apache.commons.lang3.RandomStringUtils;
+import org.testng.SkipException;
+import org.testng.TestNG;
+import org.testng.annotations.DataProvider;
+import org.testng.xml.XmlClass;
+import org.testng.xml.XmlSuite;
+import org.testng.xml.XmlTest;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class MainClass {
+    private static String host = "127.0.0.1";
+    private static String port = "19530";
+    private int index_file_size = 50;
+    public int dimension = 128;
+
+    public static void setHost(String host) {
+        MainClass.host = host;
+    }
+
+    public static void setPort(String port) {
+        MainClass.port = port;
+    }
+
+    @DataProvider(name="DefaultConnectArgs")
+    public static Object[][] defaultConnectArgs(){
+        return new Object[][]{{host, port}};
+    }
+
+    @DataProvider(name="ConnectInstance")
+    public Object[][] connectInstance() throws ConnectFailedException {
+        MilvusClient client = new MilvusGrpcClient();
+        ConnectParam connectParam = new ConnectParam.Builder()
+                .withHost(host)
+                .withPort(port)
+                .build();
+        client.connect(connectParam);
+        String tableName = RandomStringUtils.randomAlphabetic(10);
+        return new Object[][]{{client, tableName}};
+    }
+
+    @DataProvider(name="DisConnectInstance")
+    public Object[][] disConnectInstance() throws ConnectFailedException {
+        // Generate connection instance
+        MilvusClient client = new MilvusGrpcClient();
+        ConnectParam connectParam = new ConnectParam.Builder()
+                .withHost(host)
+                .withPort(port)
+                .build();
+        client.connect(connectParam);
+        try {
+            client.disconnect();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        String tableName = RandomStringUtils.randomAlphabetic(10);
+        return new Object[][]{{client, tableName}};
+    }
+
+    @DataProvider(name="Table")
+    public Object[][] provideTable() throws ConnectFailedException {
+        Object[][] tables = new Object[2][2];
+        MetricType[] metricTypes = { MetricType.L2, MetricType.IP };
+        for (int i = 0; i < metricTypes.length; ++i) {
+            String tableName = metricTypes[i].toString()+"_"+RandomStringUtils.randomAlphabetic(10);
+            // Generate connection instance
+            MilvusClient client = new MilvusGrpcClient();
+            ConnectParam connectParam = new ConnectParam.Builder()
+                    .withHost(host)
+                    .withPort(port)
+                    .build();
+            client.connect(connectParam);
+            TableSchema tableSchema = new TableSchema.Builder(tableName, dimension)
+                    .withIndexFileSize(index_file_size)
+                    .withMetricType(metricTypes[i])
+                    .build();
+            Response res = client.createTable(tableSchema);
+            if (!res.ok()) {
+                System.out.println(res.getMessage());
+                throw new SkipException("Table created failed");
+            }
+            tables[i] = new Object[]{client, tableName};
+        }
+        return tables;
+    }
+
+    public static void main(String[] args) {
+        CommandLineParser parser = new DefaultParser();
+        Options options = new Options();
+        options.addOption("h", "host", true, "milvus-server hostname/ip");
+        options.addOption("p", "port", true, "milvus-server port");
+        try {
+            CommandLine cmd = parser.parse(options, args);
+            String host = cmd.getOptionValue("host");
+            if (host != null) {
+                setHost(host);
+            }
+            String port = cmd.getOptionValue("port");
+            if (port != null) {
+                setPort(port);
+            }
+            System.out.println("Host: "+host+", Port: "+port);
+        }
+        catch(ParseException exp) {
+            System.err.println("Parsing failed.  Reason: " + exp.getMessage() );
+        }
+
+//        TestListenerAdapter tla = new TestListenerAdapter();
+//        TestNG testng = new TestNG();
+//        testng.setTestClasses(new Class[] { TestPing.class });
+//        testng.setTestClasses(new Class[] { TestConnect.class });
+//        testng.addListener(tla);
+//        testng.run();
+
+        XmlSuite suite = new XmlSuite();
+        suite.setName("TmpSuite");
+
+        XmlTest test = new XmlTest(suite);
+        test.setName("TmpTest");
+        List<XmlClass> classes = new ArrayList<XmlClass>();
+
+        classes.add(new XmlClass("com.TestPing"));
+        classes.add(new XmlClass("com.TestAddVectors"));
+        classes.add(new XmlClass("com.TestConnect"));
+        classes.add(new XmlClass("com.TestDeleteVectors"));
+        classes.add(new XmlClass("com.TestIndex"));
+        classes.add(new XmlClass("com.TestSearchVectors"));
+        classes.add(new XmlClass("com.TestTable"));
+        classes.add(new XmlClass("com.TestTableCount"));
+
+        test.setXmlClasses(classes) ;
+
+        List<XmlSuite> suites = new ArrayList<XmlSuite>();
+        suites.add(suite);
+        TestNG tng = new TestNG();
+        tng.setXmlSuites(suites);
+        tng.run();
+
+    }
+
+}
diff --git a/tests/milvus-java-test/src/main/java/com/TestAddVectors.java b/tests/milvus-java-test/src/main/java/com/TestAddVectors.java
new file mode 100644
index 0000000000..215f526179
--- /dev/null
+++ b/tests/milvus-java-test/src/main/java/com/TestAddVectors.java
@@ -0,0 +1,150 @@
+package com;
+
+import io.milvus.client.InsertParam;
+import io.milvus.client.InsertResponse;
+import io.milvus.client.MilvusClient;
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+import java.util.*;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class TestAddVectors {
+    int dimension = 128;
+
+    public List<List<Float>> gen_vectors(Integer nb) {
+        List<List<Float>> xb = new LinkedList<>();
+        Random random = new Random();
+        for (int i = 0; i < nb; ++i) {
+            LinkedList<Float> vector = new LinkedList<>();
+            for (int j = 0; j < dimension; j++) {
+                vector.add(random.nextFloat());
+            }
+            xb.add(vector);
+        }
+        return xb;
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_add_vectors_table_not_existed(MilvusClient client, String tableName) throws InterruptedException {
+        int nb = 10000;
+        List<List<Float>> vectors = gen_vectors(nb);
+        String tableNameNew = tableName + "_";
+        InsertParam insertParam = new InsertParam.Builder(tableNameNew, vectors).build();
+        InsertResponse res = client.insert(insertParam);
+        assert(!res.getResponse().ok());
+    }
+
+    @Test(dataProvider = "DisConnectInstance", dataProviderClass = MainClass.class)
+    public void test_add_vectors_without_connect(MilvusClient client, String tableName) throws InterruptedException {
+        int nb = 100;
+        List<List<Float>> vectors = gen_vectors(nb);
+        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).build();
+        InsertResponse res = client.insert(insertParam);
+        assert(!res.getResponse().ok());
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_add_vectors(MilvusClient client, String tableName) throws InterruptedException {
+        int nb = 10000;
+        List<List<Float>> vectors = gen_vectors(nb);
+        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).build();
+        InsertResponse res = client.insert(insertParam);
+        assert(res.getResponse().ok());
+        Thread.currentThread().sleep(1000);
+        // Assert table row count
+        Assert.assertEquals(client.getTableRowCount(tableName).getTableRowCount(), nb);
+    }
+
+//    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+//    public void test_add_vectors_timeout(MilvusClient client, String tableName) throws InterruptedException {
+//        int nb = 200000;
+//        List<List<Float>> vectors = gen_vectors(nb);
+//        System.out.println(new Date());
+//        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).withTimeout(1).build();
+//        InsertResponse res = client.insert(insertParam);
+//        assert(!res.getResponse().ok());
+//    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_add_vectors_big_data(MilvusClient client, String tableName) throws InterruptedException {
+        int nb = 500000;
+        List<List<Float>> vectors = gen_vectors(nb);
+        System.out.println(new Date());
+        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).build();
+        InsertResponse res = client.insert(insertParam);
+        assert(res.getResponse().ok());
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_add_vectors_with_ids(MilvusClient client, String tableName) throws InterruptedException {
+        int nb = 10000;
+        List<List<Float>> vectors = gen_vectors(nb);
+        // Add vectors with ids
+        List<Long> vectorIds;
+        vectorIds = Stream.iterate(0L, n -> n)
+                .limit(nb)
+                .collect(Collectors.toList());
+        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).withVectorIds(vectorIds).build();
+        InsertResponse res = client.insert(insertParam);
+        assert(res.getResponse().ok());
+        Thread.currentThread().sleep(2000);
+        // Assert table row count
+        Assert.assertEquals(client.getTableRowCount(tableName).getTableRowCount(), nb);
+    }
+
+    // TODO: MS-628
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_add_vectors_with_invalid_ids(MilvusClient client, String tableName) {
+        int nb = 10;
+        List<List<Float>> vectors = gen_vectors(nb);
+        // Add vectors with ids
+        List<Long> vectorIds;
+        vectorIds = Stream.iterate(0L, n -> n)
+                .limit(nb+1)
+                .collect(Collectors.toList());
+        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).withVectorIds(vectorIds).build();
+        InsertResponse res = client.insert(insertParam);
+        assert(!res.getResponse().ok());
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_add_vectors_with_invalid_dimension(MilvusClient client, String tableName) {
+        int nb = 10000;
+        List<List<Float>> vectors = gen_vectors(nb);
+        vectors.get(0).add((float) 0);
+        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).build();
+        InsertResponse res = client.insert(insertParam);
+        assert(!res.getResponse().ok());
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_add_vectors_with_invalid_vectors(MilvusClient client, String tableName) {
+        int nb = 10000;
+        List<List<Float>> vectors = gen_vectors(nb);
+        vectors.set(0, new ArrayList<>());
+        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).build();
+        InsertResponse res = client.insert(insertParam);
+        assert(!res.getResponse().ok());
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_add_vectors_repeatably(MilvusClient client, String tableName) throws InterruptedException {
+        int nb = 100000;
+        int loops = 10;
+        List<List<Float>> vectors = gen_vectors(nb);
+        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).build();
+        InsertResponse res = null;
+        for (int i = 0; i < loops; ++i ) {
+            long startTime = System.currentTimeMillis();
+            res = client.insert(insertParam);
+            long endTime = System.currentTimeMillis();
+            System.out.println("Total execution time: " + (endTime-startTime) + "ms");
+        }
+        Thread.currentThread().sleep(1000);
+        // Assert table row count
+        Assert.assertEquals(client.getTableRowCount(tableName).getTableRowCount(), nb * loops);
+    }
+
+}
diff --git a/tests/milvus-java-test/src/main/java/com/TestConnect.java b/tests/milvus-java-test/src/main/java/com/TestConnect.java
new file mode 100644
index 0000000000..8f6d556f8b
--- /dev/null
+++ b/tests/milvus-java-test/src/main/java/com/TestConnect.java
@@ -0,0 +1,89 @@
+package com;
+
+import io.milvus.client.*;
+import org.testng.Assert;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+public class TestConnect {
+    @Test(dataProvider = "DefaultConnectArgs", dataProviderClass = MainClass.class)
+    public void test_connect(String host, String port) throws ConnectFailedException {
+        System.out.println("Host: "+host+", Port: "+port);
+        MilvusClient client = new MilvusGrpcClient();
+        ConnectParam connectParam = new ConnectParam.Builder()
+                .withHost(host)
+                .withPort(port)
+                .build();
+        Response res = client.connect(connectParam);
+        assert(res.ok());
+        assert(client.isConnected());
+    }
+
+    @Test(dataProvider = "DefaultConnectArgs", dataProviderClass = MainClass.class)
+    public void test_connect_repeat(String host, String port) {
+        MilvusGrpcClient client = new MilvusGrpcClient();
+        ConnectParam connectParam = new ConnectParam.Builder()
+                .withHost(host)
+                .withPort(port)
+                .build();
+        Response res = null;
+        try {
+            res = client.connect(connectParam);
+            res = client.connect(connectParam);
+        } catch (ConnectFailedException e) {
+            e.printStackTrace();
+        }
+        assert (res.ok());
+        assert(client.isConnected());
+    }
+
+    @Test(dataProvider="InvalidConnectArgs")
+    public void test_connect_invalid_connect_args(String ip, String port) {
+        MilvusClient client = new MilvusGrpcClient();
+        ConnectParam connectParam = new ConnectParam.Builder()
+                .withHost(ip)
+                .withPort(port)
+                .build();
+        Response res = null;
+        try {
+            res = client.connect(connectParam);
+        } catch (ConnectFailedException e) {
+            e.printStackTrace();
+        }
+        Assert.assertEquals(res, null);
+        assert(!client.isConnected());
+    }
+
+    // TODO: MS-615
+    @DataProvider(name="InvalidConnectArgs")
+    public Object[][] generate_invalid_connect_args() {
+        String port = "19530";
+        String ip = "";
+        return new Object[][]{
+                {"1.1.1.1", port},
+                {"255.255.0.0", port},
+                {"1.2.2", port},
+                {"中文", port},
+                {"www.baidu.com", "100000"},
+                {"127.0.0.1", "100000"},
+                {"www.baidu.com", "80"},
+        };
+    }
+
+    @Test(dataProvider = "DisConnectInstance", dataProviderClass = MainClass.class)
+    public void test_disconnect(MilvusClient client, String tableName){
+        assert(!client.isConnected());
+    }
+
+    @Test(dataProvider = "DisConnectInstance", dataProviderClass = MainClass.class)
+    public void test_disconnect_repeatably(MilvusClient client, String tableName){
+        Response res = null;
+        try {
+            res = client.disconnect();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+        assert(!res.ok());
+        assert(!client.isConnected());
+    }
+}
diff --git a/tests/milvus-java-test/src/main/java/com/TestDeleteVectors.java b/tests/milvus-java-test/src/main/java/com/TestDeleteVectors.java
new file mode 100644
index 0000000000..d5fde0e570
--- /dev/null
+++ b/tests/milvus-java-test/src/main/java/com/TestDeleteVectors.java
@@ -0,0 +1,116 @@
+package com;
+
+import java.util.*;
+
+public class TestDeleteVectors {
+    int index_file_size = 50;
+    int dimension = 128;
+
+    public List<List<Float>> gen_vectors(Integer nb) {
+        List<List<Float>> xb = new LinkedList<>();
+        Random random = new Random();
+        for (int i = 0; i < nb; ++i) {
+            LinkedList<Float> vector = new LinkedList<>();
+            for (int j = 0; j < dimension; j++) {
+                vector.add(random.nextFloat());
+            }
+            xb.add(vector);
+        }
+        return xb;
+    }
+
+    public static Date getDeltaDate(int delta) {
+        Date today = new Date();
+        Calendar c = Calendar.getInstance();
+        c.setTime(today);
+        c.add(Calendar.DAY_OF_MONTH, delta);
+        return c.getTime();
+    }
+
+//    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+//    public void test_delete_vectors(MilvusClient client, String tableName) throws InterruptedException {
+//        int nb = 10000;
+//        List<List<Float>> vectors = gen_vectors(nb);
+//        // Add vectors
+//        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).build();
+//        InsertResponse res = client.insert(insertParam);
+//        assert(res.getResponse().ok());
+//        Thread.sleep(1000);
+//        DateRange dateRange = new DateRange(getDeltaDate(-1), getDeltaDate(1));
+//        DeleteByRangeParam param = new DeleteByRangeParam.Builder(dateRange, tableName).build();
+//        Response res_delete = client.deleteByRange(param);
+//        assert(res_delete.ok());
+//        Thread.sleep(1000);
+//        // Assert table row count
+//        Assert.assertEquals(client.getTableRowCount(tableParam).getTableRowCount(), 0);
+//    }
+
+//    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+//    public void test_delete_vectors_table_not_existed(MilvusClient client, String tableName) throws InterruptedException {
+//        String tableNameNew = tableName + "_";
+//        DateRange dateRange = new DateRange(getDeltaDate(-1), getDeltaDate(1));
+//        DeleteByRangeParam param = new DeleteByRangeParam.Builder(dateRange, tableNameNew).build();
+//        Response res_delete = client.deleteByRange(param);
+//        assert(!res_delete.ok());
+//    }
+
+//    @Test(dataProvider = "DisConnectInstance", dataProviderClass = MainClass.class)
+//    public void test_delete_vectors_without_connect(MilvusClient client, String tableName) throws InterruptedException {
+//        DateRange dateRange = new DateRange(getDeltaDate(-1), getDeltaDate(1));
+//        DeleteByRangeParam param = new DeleteByRangeParam.Builder(dateRange, tableName).build();
+//        Response res_delete = client.deleteByRange(param);
+//        assert(!res_delete.ok());
+//    }
+//
+//    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+//    public void test_delete_vectors_table_empty(MilvusClient client, String tableName) throws InterruptedException {
+//        DateRange dateRange = new DateRange(getDeltaDate(-1), getDeltaDate(1));
+//        DeleteByRangeParam param = new DeleteByRangeParam.Builder(dateRange, tableName).build();
+//        Response res_delete = client.deleteByRange(param);
+//        assert(res_delete.ok());
+//    }
+
+//    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+//    public void test_delete_vectors_invalid_date_range(MilvusClient client, String tableName) throws InterruptedException {
+//        int nb = 100;
+//        List<List<Float>> vectors = gen_vectors(nb);
+//        // Add vectors
+//        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).build();
+//        InsertResponse res = client.insert(insertParam);
+//        assert(res.getResponse().ok());
+//        Thread.sleep(1000);
+//        DateRange dateRange = new DateRange(getDeltaDate(1), getDeltaDate(0));
+//        DeleteByRangeParam param = new DeleteByRangeParam.Builder(dateRange, tableName).build();
+//        Response res_delete = client.deleteByRange(param);
+//        assert(!res_delete.ok());
+//    }
+
+//    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+//    public void test_delete_vectors_invalid_date_range_1(MilvusClient client, String tableName) throws InterruptedException {
+//        int nb = 100;
+//        List<List<Float>> vectors = gen_vectors(nb);
+//        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).build();
+//        InsertResponse res = client.insert(insertParam);
+//        assert(res.getResponse().ok());
+//        DateRange dateRange = new DateRange(getDeltaDate(2), getDeltaDate(-1));
+//        DeleteByRangeParam param = new DeleteByRangeParam.Builder(dateRange, tableName).build();
+//        Response res_delete = client.deleteByRange(param);
+//        assert(!res_delete.ok());
+//    }
+
+//    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+//    public void test_delete_vectors_no_result(MilvusClient client, String tableName) throws InterruptedException {
+//        int nb = 100;
+//        List<List<Float>> vectors = gen_vectors(nb);
+//        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).build();
+//        InsertResponse res = client.insert(insertParam);
+//        assert(res.getResponse().ok());
+//        Thread.sleep(1000);
+//        DateRange dateRange = new DateRange(getDeltaDate(-3), getDeltaDate(-2));
+//        DeleteByRangeParam param = new DeleteByRangeParam.Builder(dateRange, tableName).build();
+//        Response res_delete = client.deleteByRange(param);
+//        assert(res_delete.ok());
+//        Assert.assertEquals(client.getTableRowCount(tableParam).getTableRowCount(), nb);
+//    }
+
+}
diff --git a/tests/milvus-java-test/src/main/java/com/TestIndex.java b/tests/milvus-java-test/src/main/java/com/TestIndex.java
new file mode 100644
index 0000000000..eaf0c8dc10
--- /dev/null
+++ b/tests/milvus-java-test/src/main/java/com/TestIndex.java
@@ -0,0 +1,324 @@
+package com;
+
+import io.milvus.client.*;
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Random;
+
+public class TestIndex {
+    int index_file_size = 10;
+    int dimension = 128;
+    int n_list = 1024;
+    int default_n_list = 16384;
+    int nb = 100000;
+    IndexType indexType = IndexType.IVF_SQ8;
+    IndexType defaultIndexType = IndexType.FLAT;
+
+    public List<List<Float>> gen_vectors(Integer nb) {
+        List<List<Float>> xb = new LinkedList<>();
+        Random random = new Random();
+        for (int i = 0; i < nb; ++i) {
+            LinkedList<Float> vector = new LinkedList<>();
+            for (int j = 0; j < dimension; j++) {
+                vector.add(random.nextFloat());
+            }
+            xb.add(vector);
+        }
+        return xb;
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_create_index(MilvusClient client, String tableName) throws InterruptedException {
+        List<List<Float>> vectors = gen_vectors(nb);
+        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).build();
+        client.insert(insertParam);
+        Index index = new Index.Builder().withIndexType(indexType)
+                .withNList(n_list)
+                .build();
+        CreateIndexParam createIndexParam = new CreateIndexParam.Builder(tableName).withIndex(index).build();
+        Response res_create = client.createIndex(createIndexParam);
+        assert(res_create.ok());
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_create_index_repeatably(MilvusClient client, String tableName) throws InterruptedException {
+        List<List<Float>> vectors = gen_vectors(nb);
+        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).build();
+        client.insert(insertParam);
+        Index index = new Index.Builder().withIndexType(indexType)
+                .withNList(n_list)
+                .build();
+        CreateIndexParam createIndexParam = new CreateIndexParam.Builder(tableName).withIndex(index).build();
+        Response res_create = client.createIndex(createIndexParam);
+        res_create = client.createIndex(createIndexParam);
+        assert(res_create.ok());
+        DescribeIndexResponse res = client.describeIndex(tableName);
+        assert(res.getResponse().ok());
+        Index index1 = res.getIndex().get();
+        Assert.assertEquals(index1.getNList(), n_list);
+        Assert.assertEquals(index1.getIndexType(), indexType);
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_create_index_FLAT(MilvusClient client, String tableName) throws InterruptedException {
+        IndexType indexType = IndexType.FLAT;
+        List<List<Float>> vectors = gen_vectors(nb);
+        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).build();
+        client.insert(insertParam);
+        Index index = new Index.Builder().withIndexType(indexType)
+                .withNList(n_list)
+                .build();
+        CreateIndexParam createIndexParam = new CreateIndexParam.Builder(tableName).withIndex(index).build();
+        Response res_create = client.createIndex(createIndexParam);
+        assert(res_create.ok());
+        DescribeIndexResponse res = client.describeIndex(tableName);
+        assert(res.getResponse().ok());
+        Index index1 = res.getIndex().get();
+        Assert.assertEquals(index1.getIndexType(), indexType);
+    }
+
+//    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+//    public void test_create_index_FLAT_timeout(MilvusClient client, String tableName) throws InterruptedException {
+//        int nb = 500000;
+//        IndexType indexType = IndexType.IVF_SQ8;
+//        List<List<Float>> vectors = gen_vectors(nb);
+//        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).build();
+//        client.insert(insertParam);
+//        Index index = new Index.Builder().withIndexType(indexType)
+//                .withNList(n_list)
+//                .build();
+//        System.out.println(new Date());
+//        CreateIndexParam createIndexParam = new CreateIndexParam.Builder(tableName).withIndex(index).withTimeout(1).build();
+//        Response res_create = client.createIndex(createIndexParam);
+//        assert(!res_create.ok());
+//    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_create_index_IVFLAT(MilvusClient client, String tableName) throws InterruptedException {
+        IndexType indexType = IndexType.IVFLAT;
+        List<List<Float>> vectors = gen_vectors(nb);
+        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).build();
+        client.insert(insertParam);
+        Index index = new Index.Builder().withIndexType(indexType)
+                .withNList(n_list)
+                .build();
+        CreateIndexParam createIndexParam = new CreateIndexParam.Builder(tableName).withIndex(index).build();
+        Response res_create = client.createIndex(createIndexParam);
+        assert(res_create.ok());
+        DescribeIndexResponse res = client.describeIndex(tableName);
+        assert(res.getResponse().ok());
+        Index index1 = res.getIndex().get();
+        Assert.assertEquals(index1.getIndexType(), indexType);
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_create_index_IVFSQ8(MilvusClient client, String tableName) throws InterruptedException {
+        IndexType indexType = IndexType.IVF_SQ8;
+        List<List<Float>> vectors = gen_vectors(nb);
+        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).build();
+        client.insert(insertParam);
+        Index index = new Index.Builder().withIndexType(indexType)
+                .withNList(n_list)
+                .build();
+        CreateIndexParam createIndexParam = new CreateIndexParam.Builder(tableName).withIndex(index).build();
+        Response res_create = client.createIndex(createIndexParam);
+        assert(res_create.ok());
+        DescribeIndexResponse res = client.describeIndex(tableName);
+        assert(res.getResponse().ok());
+        Index index1 = res.getIndex().get();
+        Assert.assertEquals(index1.getIndexType(), indexType);
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_create_index_IVFSQ8H(MilvusClient client, String tableName) throws InterruptedException {
+        IndexType indexType = IndexType.IVF_SQ8H;
+        List<List<Float>> vectors = gen_vectors(nb);
+        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).build();
+        client.insert(insertParam);
+        Index index = new Index.Builder().withIndexType(indexType)
+                .withNList(n_list)
+                .build();
+        CreateIndexParam createIndexParam = new CreateIndexParam.Builder(tableName).withIndex(index).build();
+        Response res_create = client.createIndex(createIndexParam);
+        assert(res_create.ok());
+        DescribeIndexResponse res = client.describeIndex(tableName);
+        assert(res.getResponse().ok());
+        Index index1 = res.getIndex().get();
+        Assert.assertEquals(index1.getIndexType(), indexType);
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_create_index_with_no_vector(MilvusClient client, String tableName) {
+        Index index = new Index.Builder().withIndexType(indexType)
+                .withNList(n_list)
+                .build();
+        CreateIndexParam createIndexParam = new CreateIndexParam.Builder(tableName).withIndex(index).build();
+        Response res_create = client.createIndex(createIndexParam);
+        assert(res_create.ok());
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_create_index_table_not_existed(MilvusClient client, String tableName) throws InterruptedException {
+        String tableNameNew = tableName + "_";
+        Index index = new Index.Builder().withIndexType(indexType)
+                .withNList(n_list)
+                .build();
+        CreateIndexParam createIndexParam = new CreateIndexParam.Builder(tableNameNew).withIndex(index).build();
+        Response res_create = client.createIndex(createIndexParam);
+        assert(!res_create.ok());
+    }
+
+    @Test(dataProvider = "DisConnectInstance", dataProviderClass = MainClass.class)
+    public void test_create_index_without_connect(MilvusClient client, String tableName) throws InterruptedException {
+        Index index = new Index.Builder().withIndexType(indexType)
+                .withNList(n_list)
+                .build();
+        CreateIndexParam createIndexParam = new CreateIndexParam.Builder(tableName).withIndex(index).build();
+        Response res_create = client.createIndex(createIndexParam);
+        assert(!res_create.ok());
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_create_index_invalid_n_list(MilvusClient client, String tableName) throws InterruptedException {
+        int n_list = 0;
+        List<List<Float>> vectors = gen_vectors(nb);
+        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).build();
+        client.insert(insertParam);
+        Index index = new Index.Builder().withIndexType(indexType)
+                .withNList(n_list)
+                .build();
+        CreateIndexParam createIndexParam = new CreateIndexParam.Builder(tableName).withIndex(index).build();
+        Response res_create = client.createIndex(createIndexParam);
+        assert(!res_create.ok());
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_describe_index(MilvusClient client, String tableName) throws InterruptedException {
+        List<List<Float>> vectors = gen_vectors(nb);
+        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).build();
+        client.insert(insertParam);
+        Index index = new Index.Builder().withIndexType(indexType)
+                .withNList(n_list)
+                .build();
+        CreateIndexParam createIndexParam = new CreateIndexParam.Builder(tableName).withIndex(index).build();
+        Response res_create = client.createIndex(createIndexParam);
+        assert(res_create.ok());
+        DescribeIndexResponse res = client.describeIndex(tableName);
+        assert(res.getResponse().ok());
+        Index index1 = res.getIndex().get();
+        Assert.assertEquals(index1.getNList(), n_list);
+        Assert.assertEquals(index1.getIndexType(), indexType);
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_alter_index(MilvusClient client, String tableName) throws InterruptedException {
+        List<List<Float>> vectors = gen_vectors(nb);
+        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).build();
+        client.insert(insertParam);
+        Index index = new Index.Builder().withIndexType(indexType)
+                .withNList(n_list)
+                .build();
+        CreateIndexParam createIndexParam = new CreateIndexParam.Builder(tableName).withIndex(index).build();
+        Response res_create = client.createIndex(createIndexParam);
+        assert(res_create.ok());
+        // Create another index
+        IndexType indexTypeNew = IndexType.IVFLAT;
+        int n_list_new = n_list + 1;
+        Index index_new = new Index.Builder().withIndexType(indexTypeNew)
+                .withNList(n_list_new)
+                .build();
+        CreateIndexParam createIndexParamNew = new CreateIndexParam.Builder(tableName).withIndex(index_new).build();
+        Response res_create_new = client.createIndex(createIndexParamNew);
+        assert(res_create_new.ok());
+        DescribeIndexResponse res = client.describeIndex(tableName);
+        assert(res_create.ok());
+        Index index1 = res.getIndex().get();
+        Assert.assertEquals(index1.getNList(), n_list_new);
+        Assert.assertEquals(index1.getIndexType(), indexTypeNew);
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_describe_index_table_not_existed(MilvusClient client, String tableName) throws InterruptedException {
+        String tableNameNew = tableName + "_";
+        DescribeIndexResponse res = client.describeIndex(tableNameNew);
+        assert(!res.getResponse().ok());
+    }
+
+    @Test(dataProvider = "DisConnectInstance", dataProviderClass = MainClass.class)
+    public void test_describe_index_without_connect(MilvusClient client, String tableName) throws InterruptedException {
+        DescribeIndexResponse res = client.describeIndex(tableName);
+        assert(!res.getResponse().ok());
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_drop_index(MilvusClient client, String tableName) throws InterruptedException {
+        List<List<Float>> vectors = gen_vectors(nb);
+        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).build();
+        client.insert(insertParam);
+        Index index = new Index.Builder().withIndexType(defaultIndexType)
+                .withNList(n_list)
+                .build();
+        CreateIndexParam createIndexParam = new CreateIndexParam.Builder(tableName).withIndex(index).build();
+        Response res_create = client.createIndex(createIndexParam);
+        assert(res_create.ok());
+        Response res_drop = client.dropIndex(tableName);
+        assert(res_drop.ok());
+        DescribeIndexResponse res = client.describeIndex(tableName);
+        assert(res.getResponse().ok());
+        Index index1 = res.getIndex().get();
+        Assert.assertEquals(index1.getNList(), default_n_list);
+        Assert.assertEquals(index1.getIndexType(), defaultIndexType);
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_drop_index_repeatably(MilvusClient client, String tableName) throws InterruptedException {
+        List<List<Float>> vectors = gen_vectors(nb);
+        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).build();
+        client.insert(insertParam);
+        Index index = new Index.Builder().withIndexType(defaultIndexType)
+                .withNList(n_list)
+                .build();
+        CreateIndexParam createIndexParam = new CreateIndexParam.Builder(tableName).withIndex(index).build();
+        Response res_create = client.createIndex(createIndexParam);
+        assert(res_create.ok());
+        Response res_drop = client.dropIndex(tableName);
+        res_drop = client.dropIndex(tableName);
+        assert(res_drop.ok());
+        DescribeIndexResponse res = client.describeIndex(tableName);
+        assert(res.getResponse().ok());
+        Index index1 = res.getIndex().get();
+        Assert.assertEquals(index1.getNList(), default_n_list);
+        Assert.assertEquals(index1.getIndexType(), defaultIndexType);
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_drop_index_table_not_existed(MilvusClient client, String tableName) throws InterruptedException {
+        String tableNameNew = tableName + "_";
+        Response res_drop = client.dropIndex(tableNameNew);
+        assert(!res_drop.ok());
+    }
+
+    @Test(dataProvider = "DisConnectInstance", dataProviderClass = MainClass.class)
+    public void test_drop_index_without_connect(MilvusClient client, String tableName) throws InterruptedException {
+        Response res_drop = client.dropIndex(tableName);
+        assert(!res_drop.ok());
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_drop_index_no_index_created(MilvusClient client, String tableName) throws InterruptedException {
+        List<List<Float>> vectors = gen_vectors(nb);
+        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).build();
+        client.insert(insertParam);
+        Response res_drop = client.dropIndex(tableName);
+        assert(res_drop.ok());
+        DescribeIndexResponse res = client.describeIndex(tableName);
+        assert(res.getResponse().ok());
+        Index index1 = res.getIndex().get();
+        Assert.assertEquals(index1.getNList(), default_n_list);
+        Assert.assertEquals(index1.getIndexType(), defaultIndexType);
+    }
+
+}
diff --git a/tests/milvus-java-test/src/main/java/com/TestMix.java b/tests/milvus-java-test/src/main/java/com/TestMix.java
new file mode 100644
index 0000000000..7c33da7094
--- /dev/null
+++ b/tests/milvus-java-test/src/main/java/com/TestMix.java
@@ -0,0 +1,225 @@
+package com;
+
+import io.milvus.client.*;
+import org.apache.commons.lang3.RandomStringUtils;
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.ForkJoinPool;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+
+public class TestMix {
+    private int dimension = 128;
+    private int nb = 100000;
+    int n_list = 8192;
+    int n_probe = 20;
+    int top_k = 10;
+    double epsilon = 0.001;
+    int index_file_size = 20;
+
+    public List<Float> normalize(List<Float> w2v){
+        float squareSum = w2v.stream().map(x -> x * x).reduce((float) 0, Float::sum);
+        final float norm = (float) Math.sqrt(squareSum);
+        w2v = w2v.stream().map(x -> x / norm).collect(Collectors.toList());
+        return w2v;
+    }
+
+    public List<List<Float>> gen_vectors(int nb, boolean norm) {
+        List<List<Float>> xb = new ArrayList<>();
+        Random random = new Random();
+        for (int i = 0; i < nb; ++i) {
+            List<Float> vector = new ArrayList<>();
+            for (int j = 0; j < dimension; j++) {
+                vector.add(random.nextFloat());
+            }
+            if (norm == true) {
+                vector = normalize(vector);
+            }
+            xb.add(vector);
+        }
+        return xb;
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_search_vectors_threads(MilvusClient client, String tableName) throws InterruptedException {
+        int thread_num = 10;
+        int nq = 5;
+        List<List<Float>> vectors = gen_vectors(nb, false);
+        List<List<Float>> queryVectors = vectors.subList(0,nq);
+        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).build();
+        client.insert(insertParam);
+        Index index = new Index.Builder().withIndexType(IndexType.IVF_SQ8)
+                .withNList(n_list)
+                .build();
+        CreateIndexParam createIndexParam = new CreateIndexParam.Builder(tableName).withIndex(index).build();
+        client.createIndex(createIndexParam);
+        ForkJoinPool executor = new ForkJoinPool();
+        for (int i = 0; i < thread_num; i++) {
+            executor.execute(
+                    () -> {
+                        SearchParam searchParam = new SearchParam.Builder(tableName, queryVectors).withNProbe(n_probe).withTopK(top_k).build();
+                        SearchResponse res_search = client.search(searchParam);
+                        assert (res_search.getResponse().ok());
+                    });
+        }
+        executor.awaitQuiescence(100, TimeUnit.SECONDS);
+        executor.shutdown();
+    }
+
+    @Test(dataProvider = "DefaultConnectArgs", dataProviderClass = MainClass.class)
+    public void test_connect_threads(String host, String port) throws ConnectFailedException {
+        int thread_num = 100;
+        ForkJoinPool executor = new ForkJoinPool();
+        for (int i = 0; i < thread_num; i++) {
+            executor.execute(
+                    () -> {
+                        MilvusClient client = new MilvusGrpcClient();
+                        ConnectParam connectParam = new ConnectParam.Builder()
+                                .withHost(host)
+                                .withPort(port)
+                                .build();
+                        try {
+                            client.connect(connectParam);
+                        } catch (ConnectFailedException e) {
+                            e.printStackTrace();
+                        }
+                        assert(client.isConnected());
+                        try {
+                            client.disconnect();
+                        } catch (InterruptedException e) {
+                            e.printStackTrace();
+                        }
+                    });
+        }
+        executor.awaitQuiescence(100, TimeUnit.SECONDS);
+        executor.shutdown();
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_add_vectors_threads(MilvusClient client, String tableName) throws InterruptedException {
+        int thread_num = 10;
+        List<List<Float>> vectors = gen_vectors(nb,false);
+        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).build();
+        ForkJoinPool executor = new ForkJoinPool();
+        for (int i = 0; i < thread_num; i++) {
+            executor.execute(
+                    () -> {
+                        InsertResponse res_insert = client.insert(insertParam);
+                        assert (res_insert.getResponse().ok());
+                    });
+        }
+        executor.awaitQuiescence(100, TimeUnit.SECONDS);
+        executor.shutdown();
+
+        Thread.sleep(2000);
+        GetTableRowCountResponse getTableRowCountResponse = client.getTableRowCount(tableName);
+        Assert.assertEquals(getTableRowCountResponse.getTableRowCount(), thread_num * nb);
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_add_index_vectors_threads(MilvusClient client, String tableName) throws InterruptedException {
+        int thread_num = 50;
+        List<List<Float>> vectors = gen_vectors(nb,false);
+        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).build();
+        ForkJoinPool executor = new ForkJoinPool();
+        for (int i = 0; i < thread_num; i++) {
+            executor.execute(
+                    () -> {
+                        InsertResponse res_insert = client.insert(insertParam);
+                        Index index = new Index.Builder().withIndexType(IndexType.IVF_SQ8)
+                                .withNList(n_list)
+                                .build();
+                        CreateIndexParam createIndexParam = new CreateIndexParam.Builder(tableName).withIndex(index).build();
+                        client.createIndex(createIndexParam);
+                        assert (res_insert.getResponse().ok());
+                    });
+        }
+        executor.awaitQuiescence(300, TimeUnit.SECONDS);
+        executor.shutdown();
+        Thread.sleep(2000);
+        GetTableRowCountResponse getTableRowCountResponse = client.getTableRowCount(tableName);
+        Assert.assertEquals(getTableRowCountResponse.getTableRowCount(), thread_num * nb);
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_add_search_vectors_threads(MilvusClient client, String tableName) throws InterruptedException {
+        int thread_num = 50;
+        int nq = 5;
+        List<List<Float>> vectors = gen_vectors(nb, true);
+        List<List<Float>> queryVectors = vectors.subList(0,nq);
+        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).build();
+        ForkJoinPool executor = new ForkJoinPool();
+        for (int i = 0; i < thread_num; i++) {
+            executor.execute(
+                    () -> {
+                        InsertResponse res_insert = client.insert(insertParam);
+                        assert (res_insert.getResponse().ok());
+                        try {
+                            TimeUnit.SECONDS.sleep(1);
+                        } catch (InterruptedException e) {
+                            e.printStackTrace();
+                        }
+                        SearchParam searchParam = new SearchParam.Builder(tableName, queryVectors).withNProbe(n_probe).withTopK(top_k).build();
+                        SearchResponse res_search = client.search(searchParam);
+                        assert (res_search.getResponse().ok());
+                        List<List<SearchResponse.QueryResult>> res = client.search(searchParam).getQueryResultsList();
+                        double distance = res.get(0).get(0).getDistance();
+                        if (tableName.startsWith("L2")) {
+                            Assert.assertEquals(distance, 0.0, epsilon);
+                        }else if (tableName.startsWith("IP")) {
+                            Assert.assertEquals(distance, 1.0, epsilon);
+                        }
+                    });
+        }
+        executor.awaitQuiescence(300, TimeUnit.SECONDS);
+        executor.shutdown();
+        Thread.sleep(2000);
+        GetTableRowCountResponse getTableRowCountResponse = client.getTableRowCount(tableName);
+        Assert.assertEquals(getTableRowCountResponse.getTableRowCount(), thread_num * nb);
+    }
+
+    @Test(dataProvider = "DefaultConnectArgs", dataProviderClass = MainClass.class)
+    public void test_create_insert_delete_threads(String host, String port) {
+        int thread_num = 100;
+        List<List<Float>> vectors = gen_vectors(nb,false);
+        ForkJoinPool executor = new ForkJoinPool();
+        for (int i = 0; i < thread_num; i++) {
+            executor.execute(
+                    () -> {
+                        MilvusClient client = new MilvusGrpcClient();
+                        ConnectParam connectParam = new ConnectParam.Builder()
+                                .withHost(host)
+                                .withPort(port)
+                                .build();
+                        try {
+                            client.connect(connectParam);
+                        } catch (ConnectFailedException e) {
+                            e.printStackTrace();
+                        }
+                        assert(client.isConnected());
+                        String tableName = RandomStringUtils.randomAlphabetic(10);
+                        TableSchema tableSchema = new TableSchema.Builder(tableName, dimension)
+                                                                 .withIndexFileSize(index_file_size)
+                                                                 .withMetricType(MetricType.IP)
+                                                                 .build();
+                        client.createTable(tableSchema);
+                        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).build();
+                        client.insert(insertParam);
+                        Response response = client.dropTable(tableName);
+                        Assert.assertTrue(response.ok());
+                        try {
+                            client.disconnect();
+                        } catch (InterruptedException e) {
+                            e.printStackTrace();
+                        }
+                    });
+        }
+        executor.awaitQuiescence(100, TimeUnit.SECONDS);
+        executor.shutdown();
+    }
+
+}
diff --git a/tests/milvus-java-test/src/main/java/com/TestPing.java b/tests/milvus-java-test/src/main/java/com/TestPing.java
new file mode 100644
index 0000000000..1ed462e47d
--- /dev/null
+++ b/tests/milvus-java-test/src/main/java/com/TestPing.java
@@ -0,0 +1,25 @@
+package com;
+
+import io.milvus.client.*;
+import org.testng.annotations.Test;
+
+public class TestPing {
+    @Test(dataProvider = "DefaultConnectArgs", dataProviderClass = MainClass.class)
+    public void test_server_status(String host, String port) throws ConnectFailedException {
+        System.out.println("Host: "+host+", Port: "+port);
+        MilvusClient client = new MilvusGrpcClient();
+        ConnectParam connectParam = new ConnectParam.Builder()
+                .withHost(host)
+                .withPort(port)
+                .build();
+        client.connect(connectParam);
+        Response res = client.getServerStatus();
+        assert (res.ok());
+    }
+
+    @Test(dataProvider = "DisConnectInstance", dataProviderClass = MainClass.class)
+    public void test_server_status_without_connected(MilvusGrpcClient client, String tableName){
+        Response res = client.getServerStatus();
+        assert (!res.ok());
+    }
+}
\ No newline at end of file
diff --git a/tests/milvus-java-test/src/main/java/com/TestSearchVectors.java b/tests/milvus-java-test/src/main/java/com/TestSearchVectors.java
new file mode 100644
index 0000000000..de69a1c065
--- /dev/null
+++ b/tests/milvus-java-test/src/main/java/com/TestSearchVectors.java
@@ -0,0 +1,470 @@
+package com;
+
+import io.milvus.client.*;
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+import java.util.*;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class TestSearchVectors {
+    int index_file_size = 10;
+    int dimension = 128;
+    int n_list = 1024;
+    int default_n_list = 16384;
+    int nb = 100000;
+    int n_probe = 20;
+    int top_k = 10;
+    double epsilon = 0.001;
+    IndexType indexType = IndexType.IVF_SQ8;
+    IndexType defaultIndexType = IndexType.FLAT;
+
+
+    public List<Float> normalize(List<Float> w2v){
+        float squareSum = w2v.stream().map(x -> x * x).reduce((float) 0, Float::sum);
+        final float norm = (float) Math.sqrt(squareSum);
+        w2v = w2v.stream().map(x -> x / norm).collect(Collectors.toList());
+        return w2v;
+    }
+
+    public List<List<Float>> gen_vectors(int nb, boolean norm) {
+        List<List<Float>> xb = new ArrayList<>();
+        Random random = new Random();
+        for (int i = 0; i < nb; ++i) {
+            List<Float> vector = new ArrayList<>();
+            for (int j = 0; j < dimension; j++) {
+                vector.add(random.nextFloat());
+            }
+            if (norm == true) {
+                vector = normalize(vector);
+            }
+            xb.add(vector);
+        }
+        return xb;
+    }
+
+    public static Date getDeltaDate(int delta) {
+        Date today = new Date();
+        Calendar c = Calendar.getInstance();
+        c.setTime(today);
+        c.add(Calendar.DAY_OF_MONTH, delta);
+        return c.getTime();
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_search_table_not_existed(MilvusClient client, String tableName) throws InterruptedException {
+        String tableNameNew = tableName + "_";
+        int nq = 5;
+        int nb = 100;
+        List<List<Float>> vectors = gen_vectors(nb, false);
+        List<List<Float>> queryVectors = vectors.subList(0,nq);
+        SearchParam searchParam = new SearchParam.Builder(tableNameNew, queryVectors).withNProbe(n_probe).withTopK(top_k).build();
+        SearchResponse res_search = client.search(searchParam);
+        assert (!res_search.getResponse().ok());
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_search_index_IVFLAT(MilvusClient client, String tableName) throws InterruptedException {
+        IndexType indexType = IndexType.IVFLAT;
+        int nq = 5;
+        List<List<Float>> vectors = gen_vectors(nb, false);
+        List<List<Float>> queryVectors = vectors.subList(0,nq);
+        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).build();
+        client.insert(insertParam);
+        Index index = new Index.Builder().withIndexType(indexType)
+                .withNList(n_list)
+                .build();
+        CreateIndexParam createIndexParam = new CreateIndexParam.Builder(tableName).withIndex(index).build();
+        client.createIndex(createIndexParam);
+        SearchParam searchParam = new SearchParam.Builder(tableName, queryVectors).withNProbe(n_probe).withTopK(top_k).build();
+        List<List<SearchResponse.QueryResult>> res_search = client.search(searchParam).getQueryResultsList();
+        Assert.assertEquals(res_search.size(), nq);
+        Assert.assertEquals(res_search.get(0).size(), top_k);
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_search_ids_IVFLAT(MilvusClient client, String tableName) throws InterruptedException {
+        IndexType indexType = IndexType.IVFLAT;
+        int nq = 5;
+        List<List<Float>> vectors = gen_vectors(nb, true);
+        List<List<Float>> queryVectors = vectors.subList(0,nq);
+        List<Long> vectorIds;
+        vectorIds = Stream.iterate(0L, n -> n)
+                .limit(nb)
+                .collect(Collectors.toList());
+        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).withVectorIds(vectorIds).build();
+        client.insert(insertParam);
+        Index index = new Index.Builder().withIndexType(indexType)
+                .withNList(n_list)
+                .build();
+        CreateIndexParam createIndexParam = new CreateIndexParam.Builder(tableName).withIndex(index).build();
+        client.createIndex(createIndexParam);
+        SearchParam searchParam = new SearchParam.Builder(tableName, queryVectors).withNProbe(n_probe).withTopK(top_k).build();
+        List<List<SearchResponse.QueryResult>> res_search = client.search(searchParam).getQueryResultsList();
+        Assert.assertEquals(res_search.get(0).get(0).getVectorId(), 0L);
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_search_IVFLAT(MilvusClient client, String tableName) throws InterruptedException {
+        IndexType indexType = IndexType.IVFLAT;
+        int nq = 5;
+        List<List<Float>> vectors = gen_vectors(nb, false);
+        List<List<Float>> queryVectors = vectors.subList(0,nq);
+        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).build();
+        client.insert(insertParam);
+        Thread.sleep(2000);
+        SearchParam searchParam = new SearchParam.Builder(tableName, queryVectors).withNProbe(n_probe).withTopK(top_k).build();
+        List<List<SearchResponse.QueryResult>> res_search = client.search(searchParam).getQueryResultsList();
+        Assert.assertEquals(res_search.size(), nq);
+        Assert.assertEquals(res_search.get(0).size(), top_k);
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_search_distance_IVFLAT(MilvusClient client, String tableName) throws InterruptedException {
+        IndexType indexType = IndexType.IVFLAT;
+        int nq = 5;
+        List<List<Float>> vectors = gen_vectors(nb, true);
+        List<List<Float>> queryVectors = vectors.subList(0,nq);
+        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).build();
+        client.insert(insertParam);
+        Index index = new Index.Builder().withIndexType(indexType)
+                .withNList(n_list)
+                .build();
+        CreateIndexParam createIndexParam = new CreateIndexParam.Builder(tableName).withIndex(index).build();
+        client.createIndex(createIndexParam);
+        SearchParam searchParam = new SearchParam.Builder(tableName, queryVectors).withNProbe(n_probe).withTopK(top_k).build();
+        List<List<SearchResponse.QueryResult>> res_search = client.search(searchParam).getQueryResultsList();
+        double distance = res_search.get(0).get(0).getDistance();
+        if (tableName.startsWith("L2")) {
+            Assert.assertEquals(distance, 0.0, epsilon);
+        }else if (tableName.startsWith("IP")) {
+            Assert.assertEquals(distance, 1.0, epsilon);
+        }
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_search_index_IVFSQ8(MilvusClient client, String tableName) throws InterruptedException {
+        IndexType indexType = IndexType.IVF_SQ8;
+        int nq = 5;
+        List<List<Float>> vectors = gen_vectors(nb, false);
+        List<List<Float>> queryVectors = vectors.subList(0,nq);
+        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).build();
+        client.insert(insertParam);
+        Index index = new Index.Builder().withIndexType(indexType)
+                .withNList(n_list)
+                .build();
+        CreateIndexParam createIndexParam = new CreateIndexParam.Builder(tableName).withIndex(index).build();
+        client.createIndex(createIndexParam);
+        SearchParam searchParam = new SearchParam.Builder(tableName, queryVectors).withNProbe(n_probe).withTopK(top_k).build();
+        List<List<SearchResponse.QueryResult>> res_search = client.search(searchParam).getQueryResultsList();
+        Assert.assertEquals(res_search.size(), nq);
+        Assert.assertEquals(res_search.get(0).size(), top_k);
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_search_IVFSQ8(MilvusClient client, String tableName) throws InterruptedException {
+        IndexType indexType = IndexType.IVF_SQ8;
+        int nq = 5;
+        List<List<Float>> vectors = gen_vectors(nb, false);
+        List<List<Float>> queryVectors = vectors.subList(0,nq);
+        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).build();
+        client.insert(insertParam);
+        Thread.sleep(1000);
+        SearchParam searchParam = new SearchParam.Builder(tableName, queryVectors).withNProbe(n_probe).withTopK(top_k).build();
+        List<List<SearchResponse.QueryResult>> res_search = client.search(searchParam).getQueryResultsList();
+        Assert.assertEquals(res_search.size(), nq);
+        Assert.assertEquals(res_search.get(0).size(), top_k);
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_search_distance_IVFSQ8(MilvusClient client, String tableName) throws InterruptedException {
+        IndexType indexType = IndexType.IVF_SQ8;
+        int nq = 5;
+        int nb = 1000;
+        List<List<Float>> vectors = gen_vectors(nb, true);
+        List<List<Float>> queryVectors = vectors.subList(0,nq);
+        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).build();
+        client.insert(insertParam);
+        Index index = new Index.Builder().withIndexType(indexType)
+                .withNList(default_n_list)
+                .build();
+        CreateIndexParam createIndexParam = new CreateIndexParam.Builder(tableName).withIndex(index).build();
+        client.createIndex(createIndexParam);
+        SearchParam searchParam = new SearchParam.Builder(tableName, queryVectors).withNProbe(n_probe).withTopK(top_k).build();
+        List<List<Double>> res_search = client.search(searchParam).getResultDistancesList();
+        for (int i = 0; i < nq; i++) {
+            double distance = res_search.get(i).get(0);
+            System.out.println(distance);
+            if (tableName.startsWith("L2")) {
+                Assert.assertEquals(distance, 0.0, epsilon);
+            }else if (tableName.startsWith("IP")) {
+                Assert.assertEquals(distance, 1.0, epsilon);
+            }
+        }
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_search_index_FLAT(MilvusClient client, String tableName) throws InterruptedException {
+        IndexType indexType = IndexType.FLAT;
+        int nq = 5;
+        List<List<Float>> vectors = gen_vectors(nb, false);
+        List<List<Float>> queryVectors = vectors.subList(0,nq);
+        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).build();
+        client.insert(insertParam);
+        Index index = new Index.Builder().withIndexType(indexType)
+                .withNList(n_list)
+                .build();
+        CreateIndexParam createIndexParam = new CreateIndexParam.Builder(tableName).withIndex(index).build();
+        client.createIndex(createIndexParam);
+        SearchParam searchParam = new SearchParam.Builder(tableName, queryVectors).withNProbe(n_probe).withTopK(top_k).build();
+        List<List<SearchResponse.QueryResult>> res_search = client.search(searchParam).getQueryResultsList();
+        Assert.assertEquals(res_search.size(), nq);
+        Assert.assertEquals(res_search.get(0).size(), top_k);
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_search_FLAT(MilvusClient client, String tableName) throws InterruptedException {
+        IndexType indexType = IndexType.FLAT;
+        int nq = 5;
+        List<List<Float>> vectors = gen_vectors(nb, false);
+        List<List<Float>> queryVectors = vectors.subList(0,nq);
+        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).build();
+        client.insert(insertParam);
+        Thread.sleep(1000);
+        SearchParam searchParam = new SearchParam.Builder(tableName, queryVectors).withNProbe(n_probe).withTopK(top_k).build();
+        List<List<SearchResponse.QueryResult>> res_search = client.search(searchParam).getQueryResultsList();
+        Assert.assertEquals(res_search.size(), nq);
+        Assert.assertEquals(res_search.get(0).size(), top_k);
+    }
+
+//    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+//    public void test_search_FLAT_timeout(MilvusClient client, String tableName) throws InterruptedException {
+//        IndexType indexType = IndexType.FLAT;
+//        int nb = 100000;
+//        int nq = 1000;
+//        int top_k = 2048;
+//        List<List<Float>> vectors = gen_vectors(nb, false);
+//        List<List<Float>> vectors = gen_vectors(nb, false);
+//        List<List<Float>> queryVectors = vectors.subList(0,nq);
+//        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).build();
+//        client.insert(insertParam);
+//        Thread.sleep(1000);
+//        SearchParam searchParam = new SearchParam.Builder(tableName, queryVectors).withNProbe(n_probe).withTopK(top_k).withTimeout(1).build();
+//        System.out.println(new Date());
+//        SearchResponse res_search = client.search(searchParam);
+//        assert (!res_search.getResponse().ok());
+//    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_search_FLAT_big_data_size(MilvusClient client, String tableName) throws InterruptedException {
+        IndexType indexType = IndexType.FLAT;
+        int nb = 100000;
+        int nq = 2000;
+        int top_k = 2048;
+        List<List<Float>> vectors = gen_vectors(nb, false);
+        List<List<Float>> queryVectors = vectors.subList(0,nq);
+        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).build();
+        client.insert(insertParam);
+        Thread.sleep(1000);
+        SearchParam searchParam = new SearchParam.Builder(tableName, queryVectors).withNProbe(n_probe).withTopK(top_k).build();
+        System.out.println(new Date());
+        SearchResponse res_search = client.search(searchParam);
+        assert (res_search.getResponse().ok());
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_search_distance_FLAT(MilvusClient client, String tableName) throws InterruptedException {
+        IndexType indexType = IndexType.FLAT;
+        int nq = 5;
+        List<List<Float>> vectors = gen_vectors(nb, true);
+        List<List<Float>> queryVectors = vectors.subList(0,nq);
+        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).build();
+        client.insert(insertParam);
+        Index index = new Index.Builder().withIndexType(indexType)
+                .withNList(n_list)
+                .build();
+        CreateIndexParam createIndexParam = new CreateIndexParam.Builder(tableName).withIndex(index).build();
+        client.createIndex(createIndexParam);
+        SearchParam searchParam = new SearchParam.Builder(tableName, queryVectors).withNProbe(n_probe).withTopK(top_k).build();
+        List<List<SearchResponse.QueryResult>> res_search = client.search(searchParam).getQueryResultsList();
+        double distance = res_search.get(0).get(0).getDistance();
+        if (tableName.startsWith("L2")) {
+            Assert.assertEquals(distance, 0.0, epsilon);
+        }else if (tableName.startsWith("IP")) {
+            Assert.assertEquals(distance, 1.0, epsilon);
+        }
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_search_invalid_n_probe(MilvusClient client, String tableName) throws InterruptedException {
+        IndexType indexType = IndexType.IVF_SQ8;
+        int nq = 5;
+        int n_probe_new = 0;
+        List<List<Float>> vectors = gen_vectors(nb, false);
+        List<List<Float>> queryVectors = vectors.subList(0,nq);
+        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).build();
+        client.insert(insertParam);
+        Index index = new Index.Builder().withIndexType(indexType)
+                .withNList(n_list)
+                .build();
+        CreateIndexParam createIndexParam = new CreateIndexParam.Builder(tableName).withIndex(index).build();
+        client.createIndex(createIndexParam);
+        SearchParam searchParam = new SearchParam.Builder(tableName, queryVectors).withNProbe(n_probe_new).withTopK(top_k).build();
+        SearchResponse res_search = client.search(searchParam);
+        assert (!res_search.getResponse().ok());
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_search_invalid_top_k(MilvusClient client, String tableName) throws InterruptedException {
+        IndexType indexType = IndexType.IVF_SQ8;
+        int nq = 5;
+        int top_k_new = 0;
+        List<List<Float>> vectors = gen_vectors(nb, false);
+        List<List<Float>> queryVectors = vectors.subList(0,nq);
+        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).build();
+        client.insert(insertParam);
+        Index index = new Index.Builder().withIndexType(indexType)
+                .withNList(n_list)
+                .build();
+        CreateIndexParam createIndexParam = new CreateIndexParam.Builder(tableName).withIndex(index).build();
+        client.createIndex(createIndexParam);
+        SearchParam searchParam = new SearchParam.Builder(tableName, queryVectors).withNProbe(n_probe).withTopK(top_k_new).build();
+        SearchResponse res_search = client.search(searchParam);
+        assert (!res_search.getResponse().ok());
+    }
+
+//    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+//    public void test_search_invalid_query_vectors(MilvusClient client, String tableName) throws InterruptedException {
+//        IndexType indexType = IndexType.IVF_SQ8;
+//        int nq = 5;
+//        List<List<Float>> vectors = gen_vectors(nb, false);
+//        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).build();
+//        client.insert(insertParam);
+//        Index index = new Index.Builder().withIndexType(indexType)
+//                .withNList(n_list)
+//                .build();
+//        CreateIndexParam createIndexParam = new CreateIndexParam.Builder(tableName).withIndex(index).build();
+//        client.createIndex(createIndexParam);
+//        TableParam tableParam = new TableParam.Builder(tableName).build();
+//        SearchParam searchParam = new SearchParam.Builder(tableName, null).withNProbe(n_probe).withTopK(top_k).build();
+//        SearchResponse res_search = client.search(searchParam);
+//        assert (!res_search.getResponse().ok());
+//    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_search_index_range(MilvusClient client, String tableName) throws InterruptedException {
+        IndexType indexType = IndexType.IVF_SQ8;
+        int nq = 5;
+        List<List<Float>> vectors = gen_vectors(nb, false);
+        List<List<Float>> queryVectors = vectors.subList(0,nq);
+        List<DateRange> dateRange = new ArrayList<>();
+        dateRange.add(new DateRange(getDeltaDate(-1), getDeltaDate(1)));
+        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).build();
+        client.insert(insertParam);
+        Index index = new Index.Builder().withIndexType(indexType)
+                .withNList(n_list)
+                .build();
+        CreateIndexParam createIndexParam = new CreateIndexParam.Builder(tableName).withIndex(index).build();
+        client.createIndex(createIndexParam);
+        SearchParam searchParam = new SearchParam.Builder(tableName, queryVectors).withNProbe(n_probe).withTopK(top_k).withDateRanges(dateRange).build();
+        SearchResponse res_search = client.search(searchParam);
+        assert (res_search.getResponse().ok());
+        List<List<SearchResponse.QueryResult>> res = client.search(searchParam).getQueryResultsList();
+        Assert.assertEquals(res.size(), nq);
+        Assert.assertEquals(res.get(0).size(), top_k);
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_search_range(MilvusClient client, String tableName) throws InterruptedException {
+        int nq = 5;
+        List<List<Float>> vectors = gen_vectors(nb, false);
+        List<List<Float>> queryVectors = vectors.subList(0,nq);
+        List<DateRange> dateRange = new ArrayList<>();
+        dateRange.add(new DateRange(getDeltaDate(-1), getDeltaDate(1)));
+        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).build();
+        client.insert(insertParam);
+        Thread.sleep(1000);
+        SearchParam searchParam = new SearchParam.Builder(tableName, queryVectors).withNProbe(n_probe).withTopK(top_k).withDateRanges(dateRange).build();
+        SearchResponse res_search = client.search(searchParam);
+        assert (res_search.getResponse().ok());
+        List<List<SearchResponse.QueryResult>> res = client.search(searchParam).getQueryResultsList();
+        Assert.assertEquals(res.size(), nq);
+        Assert.assertEquals(res.get(0).size(), top_k);
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_search_index_range_no_result(MilvusClient client, String tableName) throws InterruptedException {
+        IndexType indexType = IndexType.IVF_SQ8;
+        int nq = 5;
+        List<List<Float>> vectors = gen_vectors(nb, false);
+        List<List<Float>> queryVectors = vectors.subList(0,nq);
+        List<DateRange> dateRange = new ArrayList<>();
+        dateRange.add(new DateRange(getDeltaDate(-3), getDeltaDate(-1)));
+        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).build();
+        client.insert(insertParam);
+        Index index = new Index.Builder().withIndexType(indexType)
+                .withNList(n_list)
+                .build();
+        CreateIndexParam createIndexParam = new CreateIndexParam.Builder(tableName).withIndex(index).build();
+        client.createIndex(createIndexParam);
+        SearchParam searchParam = new SearchParam.Builder(tableName, queryVectors).withNProbe(n_probe).withTopK(top_k).withDateRanges(dateRange).build();
+        SearchResponse res_search = client.search(searchParam);
+        assert (res_search.getResponse().ok());
+        List<List<SearchResponse.QueryResult>> res = client.search(searchParam).getQueryResultsList();
+        Assert.assertEquals(res.size(), 0);
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_search_range_no_result(MilvusClient client, String tableName) throws InterruptedException {
+        int nq = 5;
+        List<List<Float>> vectors = gen_vectors(nb, false);
+        List<List<Float>> queryVectors = vectors.subList(0,nq);
+        List<DateRange> dateRange = new ArrayList<>();
+        dateRange.add(new DateRange(getDeltaDate(-3), getDeltaDate(-1)));
+        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).build();
+        client.insert(insertParam);
+        Thread.sleep(1000);
+        SearchParam searchParam = new SearchParam.Builder(tableName, queryVectors).withNProbe(n_probe).withTopK(top_k).withDateRanges(dateRange).build();
+        SearchResponse res_search = client.search(searchParam);
+        assert (res_search.getResponse().ok());
+        List<List<SearchResponse.QueryResult>> res = client.search(searchParam).getQueryResultsList();
+        Assert.assertEquals(res.size(), 0);
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_search_index_range_invalid(MilvusClient client, String tableName) throws InterruptedException {
+        IndexType indexType = IndexType.IVF_SQ8;
+        int nq = 5;
+        List<List<Float>> vectors = gen_vectors(nb, false);
+        List<List<Float>> queryVectors = vectors.subList(0,nq);
+        List<DateRange> dateRange = new ArrayList<>();
+        dateRange.add(new DateRange(getDeltaDate(2), getDeltaDate(-1)));
+        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).build();
+        client.insert(insertParam);
+        Index index = new Index.Builder().withIndexType(indexType)
+                .withNList(n_list)
+                .build();
+        CreateIndexParam createIndexParam = new CreateIndexParam.Builder(tableName).withIndex(index).build();
+        client.createIndex(createIndexParam);
+        SearchParam searchParam = new SearchParam.Builder(tableName, queryVectors).withNProbe(n_probe).withTopK(top_k).withDateRanges(dateRange).build();
+        SearchResponse res_search = client.search(searchParam);
+        assert (!res_search.getResponse().ok());
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_search_range_invalid(MilvusClient client, String tableName) throws InterruptedException {
+        int nq = 5;
+        List<List<Float>> vectors = gen_vectors(nb, false);
+        List<List<Float>> queryVectors = vectors.subList(0,nq);
+        List<DateRange> dateRange = new ArrayList<>();
+        dateRange.add(new DateRange(getDeltaDate(2), getDeltaDate(-1)));
+        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).build();
+        client.insert(insertParam);
+        Thread.sleep(1000);
+        SearchParam searchParam = new SearchParam.Builder(tableName, queryVectors).withNProbe(n_probe).withTopK(top_k).withDateRanges(dateRange).build();
+        SearchResponse res_search = client.search(searchParam);
+        assert (!res_search.getResponse().ok());
+    }
+
+}
diff --git a/tests/milvus-java-test/src/main/java/com/TestTable.java b/tests/milvus-java-test/src/main/java/com/TestTable.java
new file mode 100644
index 0000000000..e722db23df
--- /dev/null
+++ b/tests/milvus-java-test/src/main/java/com/TestTable.java
@@ -0,0 +1,142 @@
+package com;
+
+
+import io.milvus.client.*;
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+import java.util.List;
+
+public class TestTable {
+    int index_file_size = 50;
+    int dimension = 128;
+
+    @Test(dataProvider = "ConnectInstance", dataProviderClass = MainClass.class)
+    public void test_create_table(MilvusClient client, String tableName){
+        TableSchema tableSchema = new TableSchema.Builder(tableName, dimension)
+                .withIndexFileSize(index_file_size)
+                .withMetricType(MetricType.L2)
+                .build();
+        Response res = client.createTable(tableSchema);
+        assert(res.ok());
+        Assert.assertEquals(res.ok(), true);
+    }
+
+    @Test(dataProvider = "DisConnectInstance", dataProviderClass = MainClass.class)
+    public void test_create_table_disconnect(MilvusClient client, String tableName){
+        TableSchema tableSchema = new TableSchema.Builder(tableName, dimension)
+                .withIndexFileSize(index_file_size)
+                .withMetricType(MetricType.L2)
+                .build();
+        Response res = client.createTable(tableSchema);
+        assert(!res.ok());
+    }
+
+    @Test(dataProvider = "ConnectInstance", dataProviderClass = MainClass.class)
+    public void test_create_table_repeatably(MilvusClient client, String tableName){
+        TableSchema tableSchema = new TableSchema.Builder(tableName, dimension)
+                .withIndexFileSize(index_file_size)
+                .withMetricType(MetricType.L2)
+                .build();
+        Response res = client.createTable(tableSchema);
+        Assert.assertEquals(res.ok(), true);
+        Response res_new = client.createTable(tableSchema);
+        Assert.assertEquals(res_new.ok(), false);
+    }
+
+    @Test(dataProvider = "ConnectInstance", dataProviderClass = MainClass.class)
+    public void test_create_table_wrong_params(MilvusClient client, String tableName){
+        Integer dimension = 0;
+        TableSchema tableSchema = new TableSchema.Builder(tableName, dimension)
+                .withIndexFileSize(index_file_size)
+                .withMetricType(MetricType.L2)
+                .build();
+        Response res = client.createTable(tableSchema);
+        System.out.println(res.toString());
+        Assert.assertEquals(res.ok(), false);
+    }
+
+    @Test(dataProvider = "ConnectInstance", dataProviderClass = MainClass.class)
+    public void test_show_tables(MilvusClient client, String tableName){
+        Integer tableNum = 10;
+        ShowTablesResponse res = null;
+        for (int i = 0; i < tableNum; ++i) {
+            String tableNameNew = tableName+"_"+Integer.toString(i);
+            TableSchema tableSchema = new TableSchema.Builder(tableNameNew, dimension)
+                    .withIndexFileSize(index_file_size)
+                    .withMetricType(MetricType.L2)
+                    .build();
+            client.createTable(tableSchema);
+            List<String> tableNames = client.showTables().getTableNames();
+            Assert.assertTrue(tableNames.contains(tableNameNew));
+        }
+    }
+
+    @Test(dataProvider = "DisConnectInstance", dataProviderClass = MainClass.class)
+    public void test_show_tables_without_connect(MilvusClient client, String tableName){
+        ShowTablesResponse res = client.showTables();
+        assert(!res.getResponse().ok());
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_drop_table(MilvusClient client, String tableName) throws InterruptedException {
+        Response res = client.dropTable(tableName);
+        assert(res.ok());
+        Thread.currentThread().sleep(1000);
+        List<String> tableNames = client.showTables().getTableNames();
+        Assert.assertFalse(tableNames.contains(tableName));
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_drop_table_not_existed(MilvusClient client, String tableName) throws InterruptedException {
+        Response res = client.dropTable(tableName+"_");
+        assert(!res.ok());
+        List<String> tableNames = client.showTables().getTableNames();
+        Assert.assertTrue(tableNames.contains(tableName));
+    }
+
+    @Test(dataProvider = "DisConnectInstance", dataProviderClass = MainClass.class)
+    public void test_drop_table_without_connect(MilvusClient client, String tableName) throws InterruptedException {
+        Response res = client.dropTable(tableName);
+        assert(!res.ok());
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_describe_table(MilvusClient client, String tableName) throws InterruptedException {
+        DescribeTableResponse res = client.describeTable(tableName);
+        assert(res.getResponse().ok());
+        TableSchema tableSchema = res.getTableSchema().get();
+        Assert.assertEquals(tableSchema.getDimension(), dimension);
+        Assert.assertEquals(tableSchema.getTableName(), tableName);
+        Assert.assertEquals(tableSchema.getIndexFileSize(), index_file_size);
+        Assert.assertEquals(tableSchema.getMetricType().name(), tableName.substring(0,2));
+    }
+
+    @Test(dataProvider = "DisConnectInstance", dataProviderClass = MainClass.class)
+    public void test_describe_table_without_connect(MilvusClient client, String tableName) throws InterruptedException {
+        DescribeTableResponse res = client.describeTable(tableName);
+        assert(!res.getResponse().ok());
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_has_table_not_existed(MilvusClient client, String tableName) throws InterruptedException {
+        HasTableResponse res = client.hasTable(tableName+"_");
+        assert(res.getResponse().ok());
+        Assert.assertFalse(res.hasTable());
+    }
+
+    @Test(dataProvider = "DisConnectInstance", dataProviderClass = MainClass.class)
+    public void test_has_table_without_connect(MilvusClient client, String tableName) throws InterruptedException {
+        HasTableResponse res = client.hasTable(tableName);
+        assert(!res.getResponse().ok());
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_has_table(MilvusClient client, String tableName) throws InterruptedException {
+        HasTableResponse res = client.hasTable(tableName);
+        assert(res.getResponse().ok());
+        Assert.assertTrue(res.hasTable());
+    }
+
+
+}
diff --git a/tests/milvus-java-test/src/main/java/com/TestTableCount.java b/tests/milvus-java-test/src/main/java/com/TestTableCount.java
new file mode 100644
index 0000000000..5cda18e812
--- /dev/null
+++ b/tests/milvus-java-test/src/main/java/com/TestTableCount.java
@@ -0,0 +1,83 @@
+package com;
+
+import io.milvus.client.*;
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+public class TestTableCount {
+    int index_file_size = 50;
+    int dimension = 128;
+
+    public List<List<Float>> gen_vectors(Integer nb) {
+        List<List<Float>> xb = new ArrayList<>();
+        Random random = new Random();
+        for (int i = 0; i < nb; ++i) {
+            ArrayList<Float> vector = new ArrayList<>();
+            for (int j = 0; j < dimension; j++) {
+                vector.add(random.nextFloat());
+            }
+            xb.add(vector);
+        }
+        return xb;
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_table_count_no_vectors(MilvusClient client, String tableName) {
+        Assert.assertEquals(client.getTableRowCount(tableName).getTableRowCount(), 0);
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_table_count_table_not_existed(MilvusClient client, String tableName) {
+        GetTableRowCountResponse res = client.getTableRowCount(tableName+"_");
+        assert(!res.getResponse().ok());
+    }
+
+    @Test(dataProvider = "DisConnectInstance", dataProviderClass = MainClass.class)
+    public void test_table_count_without_connect(MilvusClient client, String tableName) {
+        GetTableRowCountResponse res = client.getTableRowCount(tableName+"_");
+        assert(!res.getResponse().ok());
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_table_count(MilvusClient client, String tableName) throws InterruptedException {
+        int nb = 10000;
+        List<List<Float>> vectors = gen_vectors(nb);
+        // Add vectors
+        InsertParam insertParam = new InsertParam.Builder(tableName, vectors).build();;
+        client.insert(insertParam);
+        Thread.currentThread().sleep(2000);
+        Assert.assertEquals(client.getTableRowCount(tableName).getTableRowCount(), nb);
+    }
+
+    @Test(dataProvider = "Table", dataProviderClass = MainClass.class)
+    public void test_table_count_multi_tables(MilvusClient client, String tableName) throws InterruptedException {
+        int nb = 10000;
+        List<List<Float>> vectors = gen_vectors(nb);
+        Integer tableNum = 10;
+        GetTableRowCountResponse res = null;
+        for (int i = 0; i < tableNum; ++i) {
+            String tableNameNew = tableName + "_" + Integer.toString(i);
+            TableSchema tableSchema = new TableSchema.Builder(tableNameNew, dimension)
+                    .withIndexFileSize(index_file_size)
+                    .withMetricType(MetricType.L2)
+                    .build();
+            client.createTable(tableSchema);
+            // Add vectors
+            InsertParam insertParam = new InsertParam.Builder(tableNameNew, vectors).build();
+            client.insert(insertParam);
+        }
+        Thread.currentThread().sleep(1000);
+        for (int i = 0; i < tableNum; ++i) {
+            String tableNameNew = tableName + "_" + Integer.toString(i);
+            res = client.getTableRowCount(tableNameNew);
+            Assert.assertEquals(res.getTableRowCount(), nb);
+        }
+    }
+
+}
+
+
diff --git a/tests/milvus-java-test/testng.xml b/tests/milvus-java-test/testng.xml
new file mode 100644
index 0000000000..19520f7eab
--- /dev/null
+++ b/tests/milvus-java-test/testng.xml
@@ -0,0 +1,8 @@
+<suite name="Test-class Suite">
+    <test name="Test-class test" >
+        <classes>
+            <class name="com.TestConnect" />
+            <class name="com.TestMix" />
+        </classes>
+    </test>
+</suite>
\ No newline at end of file
diff --git a/tests/milvus_ann_acc/.gitignore b/tests/milvus_ann_acc/.gitignore
new file mode 100644
index 0000000000..f250cab9fe
--- /dev/null
+++ b/tests/milvus_ann_acc/.gitignore
@@ -0,0 +1,2 @@
+__pycache__/
+logs/
diff --git a/tests/milvus_ann_acc/README.md b/tests/milvus_ann_acc/README.md
new file mode 100644
index 0000000000..f5ab9d8168
--- /dev/null
+++ b/tests/milvus_ann_acc/README.md
@@ -0,0 +1,21 @@
+# Requirements
+
+- python 3.6+
+- pip install -r requirements.txt
+
+# How to use this Test Project
+
+This project is used to test search accuracy based on the given datasets (https://github.com/erikbern/ann-benchmarks#data-sets)
+
+1. start your milvus server
+2. update your test configuration in test.py
+3. run command
+
+```shell
+python test.py
+```
+
+# Contribution getting started
+
+- Follow PEP-8 for naming and black for formatting.
+
diff --git a/tests/milvus_ann_acc/client.py b/tests/milvus_ann_acc/client.py
new file mode 100644
index 0000000000..de4ef17cb6
--- /dev/null
+++ b/tests/milvus_ann_acc/client.py
@@ -0,0 +1,149 @@
+import pdb
+import random
+import logging
+import json
+import time, datetime
+from multiprocessing import Process
+import numpy
+import sklearn.preprocessing
+from milvus import Milvus, IndexType, MetricType
+
+logger = logging.getLogger("milvus_ann_acc.client")
+
+SERVER_HOST_DEFAULT = "127.0.0.1"
+SERVER_PORT_DEFAULT = 19530
+
+
+def time_wrapper(func):
+    """
+    This decorator prints the execution time for the decorated function.
+    """
+    def wrapper(*args, **kwargs):
+        start = time.time()
+        result = func(*args, **kwargs)
+        end = time.time()
+        logger.info("Milvus {} run in {}s".format(func.__name__, round(end - start, 2)))
+        return result
+    return wrapper
+
+
+class MilvusClient(object):
+    def __init__(self, table_name=None, ip=None, port=None):
+        self._milvus = Milvus()
+        self._table_name = table_name
+        try:
+            if not ip:
+                self._milvus.connect(
+                    host = SERVER_HOST_DEFAULT,
+                    port = SERVER_PORT_DEFAULT)
+            else:
+                self._milvus.connect(
+                    host = ip,
+                    port = port)
+        except Exception as e:
+            raise e
+
+    def __str__(self):
+        return 'Milvus table %s' % self._table_name
+
+    def check_status(self, status):
+        if not status.OK():
+            logger.error(status.message)
+            raise Exception("Status not ok")
+
+    def create_table(self, table_name, dimension, index_file_size, metric_type):
+        if not self._table_name:
+            self._table_name = table_name
+        if metric_type == "l2":
+            metric_type = MetricType.L2
+        elif metric_type == "ip":
+            metric_type = MetricType.IP
+        else:
+            logger.error("Not supported metric_type: %s" % metric_type)
+        self._metric_type = metric_type
+        create_param = {'table_name': table_name,
+                 'dimension': dimension,
+                 'index_file_size': index_file_size, 
+                 "metric_type": metric_type}
+        status = self._milvus.create_table(create_param)
+        self.check_status(status)
+
+    @time_wrapper
+    def insert(self, X, ids):
+        if self._metric_type == MetricType.IP:
+            logger.info("Set normalize for metric_type: Inner Product")
+            X = sklearn.preprocessing.normalize(X, axis=1, norm='l2')
+        X = X.astype(numpy.float32)
+        status, result = self._milvus.add_vectors(self._table_name, X.tolist(), ids=ids)
+        self.check_status(status)
+        return status, result
+
+    @time_wrapper
+    def create_index(self, index_type, nlist):
+        if index_type == "flat":
+            index_type = IndexType.FLAT
+        elif index_type == "ivf_flat":
+            index_type = IndexType.IVFLAT
+        elif index_type == "ivf_sq8":
+            index_type = IndexType.IVF_SQ8
+        elif index_type == "ivf_sq8h":
+            index_type = IndexType.IVF_SQ8H
+        elif index_type == "mix_nsg":
+            index_type = IndexType.MIX_NSG
+        index_params = {
+            "index_type": index_type,
+            "nlist": nlist,
+        }
+        logger.info("Building index start, table_name: %s, index_params: %s" % (self._table_name, json.dumps(index_params)))
+        status = self._milvus.create_index(self._table_name, index=index_params, timeout=6*3600)
+        self.check_status(status)
+
+    def describe_index(self):
+        return self._milvus.describe_index(self._table_name)
+
+    def drop_index(self):
+        logger.info("Drop index: %s" % self._table_name)
+        return self._milvus.drop_index(self._table_name)
+
+    @time_wrapper
+    def query(self, X, top_k, nprobe):
+        if self._metric_type == MetricType.IP:
+            logger.info("Set normalize for metric_type: Inner Product")
+            X = sklearn.preprocessing.normalize(X, axis=1, norm='l2')
+        X = X.astype(numpy.float32)
+        status, results = self._milvus.search_vectors(self._table_name, top_k, nprobe, X.tolist())
+        self.check_status(status)
+        # logger.info(results[0])
+        ids = []
+        for result in results:
+            tmp_ids = []
+            for item in result:
+                tmp_ids.append(item.id)
+            ids.append(tmp_ids)
+        return ids
+
+    def count(self):
+        return self._milvus.get_table_row_count(self._table_name)[1]
+
+    def delete(self, timeout=60):
+        logger.info("Start delete table: %s" % self._table_name)
+        self._milvus.delete_table(self._table_name)
+        i = 0
+        while i < timeout:
+            if self.count():
+                time.sleep(1)
+                i = i + 1
+            else:
+                break
+        if i >= timeout:
+            logger.error("Delete table timeout")
+
+    def describe(self):
+        return self._milvus.describe_table(self._table_name)
+
+    def exists_table(self):
+        return self._milvus.has_table(self._table_name)
+
+    @time_wrapper
+    def preload_table(self):
+        return self._milvus.preload_table(self._table_name)
diff --git a/tests/milvus_ann_acc/config.yaml b/tests/milvus_ann_acc/config.yaml
new file mode 100644
index 0000000000..e2ac2c1bfb
--- /dev/null
+++ b/tests/milvus_ann_acc/config.yaml
@@ -0,0 +1,17 @@
+datasets: 
+  sift-128-euclidean: 
+    cpu_cache_size: 16
+    gpu_cache_size: 5
+    index_file_size: [1024]
+  nytimes-16-angular:
+    cpu_cache_size: 16
+    gpu_cache_size: 5
+    index_file_size: [1024]
+
+index:
+  index_types: ['flat', 'ivf_flat', 'ivf_sq8']
+  nlists: [8092, 16384]
+  
+search:
+  nprobes: [1, 8, 32]
+  top_ks: [10]
diff --git a/tests/milvus_ann_acc/main.py b/tests/milvus_ann_acc/main.py
new file mode 100644
index 0000000000..308e8246c7
--- /dev/null
+++ b/tests/milvus_ann_acc/main.py
@@ -0,0 +1,26 @@
+
+import argparse
+
+def main():
+    parser = argparse.ArgumentParser(
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    parser.add_argument(
+        '--dataset',
+        metavar='NAME',
+        help='the dataset to load training points from',
+        default='glove-100-angular',
+        choices=DATASETS.keys())
+    parser.add_argument(
+        "-k", "--count",
+        default=10,
+        type=positive_int,
+        help="the number of near neighbours to search for")
+    parser.add_argument(
+        '--definitions',
+        metavar='FILE',
+        help='load algorithm definitions from FILE',
+        default='algos.yaml')
+    parser.add_argument(
+        '--image-tag',
+        default=None,
+        help='pull image first')
\ No newline at end of file
diff --git a/tests/milvus_ann_acc/requirements.txt b/tests/milvus_ann_acc/requirements.txt
new file mode 100644
index 0000000000..8c10e71b1f
--- /dev/null
+++ b/tests/milvus_ann_acc/requirements.txt
@@ -0,0 +1,4 @@
+numpy==1.16.3
+pymilvus>=0.2.0
+scikit-learn==0.19.1
+h5py==2.7.1
diff --git a/tests/milvus_ann_acc/test.py b/tests/milvus_ann_acc/test.py
new file mode 100644
index 0000000000..c4fbc33195
--- /dev/null
+++ b/tests/milvus_ann_acc/test.py
@@ -0,0 +1,132 @@
+import os
+import pdb
+import time
+import random
+import sys
+import h5py
+import numpy
+import logging
+from logging import handlers
+
+from client import MilvusClient
+
+LOG_FOLDER = "logs"
+logger = logging.getLogger("milvus_ann_acc")
+
+formatter = logging.Formatter('[%(asctime)s] [%(levelname)-4s] [%(pathname)s:%(lineno)d] %(message)s')
+if not os.path.exists(LOG_FOLDER):
+    os.system('mkdir -p %s' % LOG_FOLDER)
+fileTimeHandler = handlers.TimedRotatingFileHandler(os.path.join(LOG_FOLDER, 'acc'), "D", 1, 10)
+fileTimeHandler.suffix = "%Y%m%d.log"
+fileTimeHandler.setFormatter(formatter)
+logging.basicConfig(level=logging.DEBUG)
+fileTimeHandler.setFormatter(formatter)
+logger.addHandler(fileTimeHandler)
+
+
+def get_dataset_fn(dataset_name):
+    file_path = "/test/milvus/ann_hdf5/"
+    if not os.path.exists(file_path):
+        raise Exception("%s not exists" % file_path)
+    return os.path.join(file_path, '%s.hdf5' % dataset_name)
+
+
+def get_dataset(dataset_name):
+    hdf5_fn = get_dataset_fn(dataset_name)
+    hdf5_f = h5py.File(hdf5_fn)
+    return hdf5_f
+
+
+def parse_dataset_name(dataset_name):
+    data_type = dataset_name.split("-")[0]
+    dimension = int(dataset_name.split("-")[1])
+    metric = dataset_name.split("-")[-1]
+    # metric = dataset.attrs['distance']
+    # dimension = len(dataset["train"][0])
+    if metric == "euclidean":
+        metric_type = "l2"
+    elif metric  == "angular":
+        metric_type = "ip"
+    return ("ann"+data_type, dimension, metric_type)
+
+
+def get_table_name(dataset_name, index_file_size):
+    data_type, dimension, metric_type = parse_dataset_name(dataset_name)
+    dataset = get_dataset(dataset_name)
+    table_size = len(dataset["train"])
+    table_size = str(table_size // 1000000)+"m"
+    table_name = data_type+'_'+table_size+'_'+str(index_file_size)+'_'+str(dimension)+'_'+metric_type
+    return table_name
+
+
+def main(dataset_name, index_file_size, nlist=16384, force=False):
+    top_k = 10
+    nprobes = [32, 128]
+
+    dataset = get_dataset(dataset_name)
+    table_name = get_table_name(dataset_name, index_file_size)
+    m = MilvusClient(table_name)
+    if m.exists_table():
+        if force is True:
+            logger.info("Re-create table: %s" % table_name)
+            m.delete()
+            time.sleep(10)
+        else:
+            logger.info("Table name: %s existed" % table_name)
+            return
+    data_type, dimension, metric_type = parse_dataset_name(dataset_name)
+    m.create_table(table_name, dimension, index_file_size, metric_type)
+    print(m.describe())
+    vectors = numpy.array(dataset["train"])
+    query_vectors = numpy.array(dataset["test"])
+    # m.insert(vectors)
+
+    interval = 100000
+    loops = len(vectors) // interval + 1
+
+    for i in range(loops):
+        start = i*interval
+        end = min((i+1)*interval, len(vectors))
+        tmp_vectors = vectors[start:end]
+        if start < end:
+            m.insert(tmp_vectors, ids=[i for i in range(start, end)])
+    
+    time.sleep(60)
+    print(m.count())
+
+    for index_type in ["ivf_flat", "ivf_sq8", "ivf_sq8h"]:
+        m.create_index(index_type, nlist)
+        print(m.describe_index())
+        if m.count() != len(vectors):
+            return
+        m.preload_table()
+        true_ids = numpy.array(dataset["neighbors"])
+        for nprobe in nprobes:
+            print("nprobe: %s" % nprobe)
+            sum_radio = 0.0; avg_radio = 0.0
+            result_ids = m.query(query_vectors, top_k, nprobe)
+            # print(result_ids[:10])
+            for index, result_item in enumerate(result_ids):
+                if len(set(true_ids[index][:top_k])) != len(set(result_item)):
+                    logger.info("Error happened")
+                    # logger.info(query_vectors[index])
+                    # logger.info(true_ids[index][:top_k], result_item)
+                tmp = set(true_ids[index][:top_k]).intersection(set(result_item))
+                sum_radio = sum_radio + (len(tmp) / top_k)
+            avg_radio = round(sum_radio / len(result_ids), 4) 
+            logger.info(avg_radio)
+        m.drop_index()
+
+
+if __name__ == "__main__":
+    print("glove-25-angular")
+    # main("sift-128-euclidean", 1024, force=True)
+    for index_file_size in [50, 1024]:
+        print("Index file size: %d" % index_file_size)
+        main("glove-25-angular", index_file_size, force=True)
+
+    print("sift-128-euclidean")
+    for index_file_size in [50, 1024]:
+        print("Index file size: %d" % index_file_size)
+        main("sift-128-euclidean", index_file_size, force=True)
+    # m = MilvusClient()
\ No newline at end of file
diff --git a/tests/milvus_benchmark/.gitignore b/tests/milvus_benchmark/.gitignore
new file mode 100644
index 0000000000..70af07bba8
--- /dev/null
+++ b/tests/milvus_benchmark/.gitignore
@@ -0,0 +1,8 @@
+random_data
+benchmark_logs/
+db/
+logs/
+*idmap*.txt
+__pycache__/
+venv
+.idea
\ No newline at end of file
diff --git a/tests/milvus_benchmark/README.md b/tests/milvus_benchmark/README.md
new file mode 100644
index 0000000000..05268057a4
--- /dev/null
+++ b/tests/milvus_benchmark/README.md
@@ -0,0 +1,23 @@
+# Requirements
+
+- python 3.6+
+- pip install -r requirements.txt
+
+# How to use this Test Project
+
+This project is used to test performance / accuracy /  stability of milvus server
+
+1. update your test configuration in suites_*.yaml
+2. run command
+
+```shell
+### docker mode:
+python main.py --image=milvusdb/milvus:latest --run-count=2 --run-type=performance
+
+### local mode:
+python main.py --local --run-count=2 --run-type=performance --ip=127.0.0.1 --port=19530
+```
+
+# Contribution getting started
+
+- Follow PEP-8 for naming and black for formatting.
\ No newline at end of file
diff --git a/tests/milvus_benchmark/__init__.py b/tests/milvus_benchmark/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/tests/milvus_benchmark/client.py b/tests/milvus_benchmark/client.py
new file mode 100644
index 0000000000..4744c10854
--- /dev/null
+++ b/tests/milvus_benchmark/client.py
@@ -0,0 +1,244 @@
+import pdb
+import random
+import logging
+import json
+import sys
+import time, datetime
+from multiprocessing import Process
+from milvus import Milvus, IndexType, MetricType
+
+logger = logging.getLogger("milvus_benchmark.client")
+
+SERVER_HOST_DEFAULT = "127.0.0.1"
+SERVER_PORT_DEFAULT = 19530
+
+
+def time_wrapper(func):
+    """
+    This decorator prints the execution time for the decorated function.
+    """
+    def wrapper(*args, **kwargs):
+        start = time.time()
+        result = func(*args, **kwargs)
+        end = time.time()
+        logger.info("Milvus {} run in {}s".format(func.__name__, round(end - start, 2)))
+        return result
+    return wrapper
+
+
+class MilvusClient(object):
+    def __init__(self, table_name=None, ip=None, port=None):
+        self._milvus = Milvus()
+        self._table_name = table_name
+        try:
+            if not ip:
+                self._milvus.connect(
+                    host = SERVER_HOST_DEFAULT,
+                    port = SERVER_PORT_DEFAULT)
+            else:
+                self._milvus.connect(
+                    host = ip,
+                    port = port)
+        except Exception as e:
+            raise e
+
+    def __str__(self):
+        return 'Milvus table %s' % self._table_name
+
+    def check_status(self, status):
+        if not status.OK():
+            logger.error(status.message)
+            raise Exception("Status not ok")
+
+    def create_table(self, table_name, dimension, index_file_size, metric_type):
+        if not self._table_name:
+            self._table_name = table_name
+        if metric_type == "l2":
+            metric_type = MetricType.L2
+        elif metric_type == "ip":
+            metric_type = MetricType.IP
+        else:
+            logger.error("Not supported metric_type: %s" % metric_type)
+        create_param = {'table_name': table_name,
+                 'dimension': dimension,
+                 'index_file_size': index_file_size, 
+                 "metric_type": metric_type}
+        status = self._milvus.create_table(create_param)
+        self.check_status(status)
+
+    @time_wrapper
+    def insert(self, X, ids=None):
+        status, result = self._milvus.add_vectors(self._table_name, X, ids)
+        self.check_status(status)
+        return status, result
+
+    @time_wrapper
+    def create_index(self, index_type, nlist):
+        if index_type == "flat":
+            index_type = IndexType.FLAT
+        elif index_type == "ivf_flat":
+            index_type = IndexType.IVFLAT
+        elif index_type == "ivf_sq8":
+            index_type = IndexType.IVF_SQ8
+        elif index_type == "mix_nsg":
+            index_type = IndexType.MIX_NSG
+        elif index_type == "ivf_sq8h":
+            index_type = IndexType.IVF_SQ8H
+        index_params = {
+            "index_type": index_type,
+            "nlist": nlist,
+        }
+        logger.info("Building index start, table_name: %s, index_params: %s" % (self._table_name, json.dumps(index_params)))
+        status = self._milvus.create_index(self._table_name, index=index_params, timeout=6*3600)
+        self.check_status(status)
+
+    def describe_index(self):
+        return self._milvus.describe_index(self._table_name)
+
+    def drop_index(self):
+        logger.info("Drop index: %s" % self._table_name)
+        return self._milvus.drop_index(self._table_name)
+
+    @time_wrapper
+    def query(self, X, top_k, nprobe):
+        status, result = self._milvus.search_vectors(self._table_name, top_k, nprobe, X)
+        self.check_status(status)
+        return status, result
+
+    def count(self):
+        return self._milvus.get_table_row_count(self._table_name)[1]
+
+    def delete(self, timeout=60):
+        logger.info("Start delete table: %s" % self._table_name)
+        self._milvus.delete_table(self._table_name)
+        i = 0
+        while i < timeout:
+            if self.count():
+                time.sleep(1)
+                i = i + 1
+                continue
+            else:
+                break
+        if i < timeout:
+            logger.error("Delete table timeout")
+
+    def describe(self):
+        return self._milvus.describe_table(self._table_name)
+
+    def exists_table(self):
+        return self._milvus.has_table(self._table_name)
+
+    @time_wrapper
+    def preload_table(self):
+        return self._milvus.preload_table(self._table_name, timeout=3000)
+
+
+def fit(table_name, X):
+    milvus = Milvus()
+    milvus.connect(host = SERVER_HOST_DEFAULT, port = SERVER_PORT_DEFAULT) 
+    start = time.time()
+    status, ids = milvus.add_vectors(table_name, X)
+    end = time.time()
+    logger(status, round(end - start, 2))
+
+
+def fit_concurrent(table_name, process_num, vectors):
+    processes = []
+
+    for i in range(process_num):
+        p = Process(target=fit, args=(table_name, vectors, ))
+        processes.append(p)
+        p.start()
+    for p in processes:             
+        p.join()
+    
+
+if __name__ == "__main__":
+
+    # table_name = "sift_2m_20_128_l2"
+    table_name = "test_tset1"
+    m = MilvusClient(table_name)
+    # m.create_table(table_name, 128, 50, "l2")
+
+    print(m.describe())
+    # print(m.count())
+    # print(m.describe_index())
+    insert_vectors = [[random.random() for _ in range(128)] for _ in range(10000)]
+    for i in range(5):
+        m.insert(insert_vectors)
+    print(m.create_index("ivf_sq8h", 16384))
+    X = [insert_vectors[0]]
+    top_k = 10
+    nprobe = 10
+    print(m.query(X, top_k, nprobe))
+
+    # # # print(m.drop_index())
+    # # print(m.describe_index())
+    # # sys.exit()
+    # # # insert_vectors = [[random.random() for _ in range(128)] for _ in range(100000)]
+    # # # for i in range(100):
+    # # #     m.insert(insert_vectors)
+    # # # time.sleep(5)
+    # # # print(m.describe_index())
+    # # # print(m.drop_index())
+    # # m.create_index("ivf_sq8h", 16384)
+    # print(m.count())
+    # print(m.describe_index())
+
+
+
+    # sys.exit()
+    # print(m.create_index("ivf_sq8h", 16384))
+    # print(m.count())
+    # print(m.describe_index())
+    import numpy as np
+
+    def mmap_fvecs(fname):
+        x = np.memmap(fname, dtype='int32', mode='r')
+        d = x[0]
+        return x.view('float32').reshape(-1, d + 1)[:, 1:]
+
+    print(mmap_fvecs("/poc/deep1b/deep1B_queries.fvecs"))
+    # SIFT_SRC_QUERY_DATA_DIR = '/poc/yuncong/ann_1000m'
+    # file_name = SIFT_SRC_QUERY_DATA_DIR+'/'+'query.npy'
+    # data = numpy.load(file_name)
+    # query_vectors = data[0:2].tolist()
+    # print(len(query_vectors))
+    # results = m.query(query_vectors, 10, 10)
+    # result_ids = []
+    # for result in results[1]:
+    #     tmp = []
+    #     for item in result:
+    #         tmp.append(item.id)
+    #     result_ids.append(tmp)
+    # print(result_ids[0][:10])
+    # # gt
+    # file_name = SIFT_SRC_QUERY_DATA_DIR+"/gnd/"+"idx_1M.ivecs"
+    # a = numpy.fromfile(file_name, dtype='int32')
+    # d = a[0]
+    # true_ids = a.reshape(-1, d + 1)[:, 1:].copy()
+    # print(true_ids[:3, :2])
+
+    # print(len(true_ids[0]))
+    # import numpy as np
+    # import sklearn.preprocessing
+
+    # def mmap_fvecs(fname):
+    #     x = np.memmap(fname, dtype='int32', mode='r')
+    #     d = x[0]
+    #     return x.view('float32').reshape(-1, d + 1)[:, 1:]
+
+    # data = mmap_fvecs("/poc/deep1b/deep1B_queries.fvecs")
+    # print(data[0], len(data[0]), len(data))
+
+    # total_size = 10000
+    # # total_size = 1000000000
+    # file_size = 1000
+    # # file_size = 100000
+    # file_num = total_size // file_size
+    # for i in range(file_num):
+    #     fname = "/test/milvus/raw_data/deep1b/binary_96_%05d" % i
+    #     print(fname, i*file_size, (i+1)*file_size)
+    #     single_data = data[i*file_size : (i+1)*file_size]
+    #     single_data = sklearn.preprocessing.normalize(single_data, axis=1, norm='l2')
+    #     np.save(fname, single_data)
diff --git a/tests/milvus_benchmark/conf/log_config.conf b/tests/milvus_benchmark/conf/log_config.conf
new file mode 100644
index 0000000000..c9c14d57f4
--- /dev/null
+++ b/tests/milvus_benchmark/conf/log_config.conf
@@ -0,0 +1,28 @@
+* GLOBAL:
+    FORMAT                  =   "%datetime | %level | %logger | %msg"
+    FILENAME                =   "/opt/milvus/logs/milvus-%datetime{%H:%m}-global.log"
+    ENABLED                 =   true
+    TO_FILE                 =   true
+    TO_STANDARD_OUTPUT      =   false
+    SUBSECOND_PRECISION     =   3
+    PERFORMANCE_TRACKING    =   false
+    MAX_LOG_FILE_SIZE       =   2097152 ## Throw log files away after 2MB
+* DEBUG:
+    FILENAME                =   "/opt/milvus/logs/milvus-%datetime{%H:%m}-debug.log"
+    ENABLED                 =   true
+* WARNING:
+    FILENAME                =   "/opt/milvus/logs/milvus-%datetime{%H:%m}-warning.log"
+* TRACE:
+    FILENAME                =   "/opt/milvus/logs/milvus-%datetime{%H:%m}-trace.log"
+* VERBOSE:
+    FORMAT                  =   "%datetime{%d/%M/%y} | %level-%vlevel | %msg"
+    TO_FILE                 =   false
+    TO_STANDARD_OUTPUT      =   false
+## Error logs
+* ERROR:
+    ENABLED                 =   true
+    FILENAME                =   "/opt/milvus/logs/milvus-%datetime{%H:%m}-error.log"
+* FATAL:
+    ENABLED                 =   true
+    FILENAME                =   "/opt/milvus/logs/milvus-%datetime{%H:%m}-fatal.log"
+
diff --git a/tests/milvus_benchmark/conf/server_config.yaml b/tests/milvus_benchmark/conf/server_config.yaml
new file mode 100644
index 0000000000..a5d2081b8a
--- /dev/null
+++ b/tests/milvus_benchmark/conf/server_config.yaml
@@ -0,0 +1,28 @@
+cache_config:
+  cache_insert_data: false
+  cpu_cache_capacity: 16
+  gpu_cache_capacity: 6
+  cpu_cache_threshold: 0.85
+db_config:
+  backend_url: sqlite://:@:/
+  build_index_gpu: 0
+  insert_buffer_size: 4
+  preload_table: null
+  primary_path: /opt/milvus
+  secondary_path: null
+engine_config:
+  use_blas_threshold: 20
+metric_config:
+  collector: prometheus
+  enable_monitor: true
+  prometheus_config:
+    port: 8080
+resource_config:
+  resource_pool:
+  - cpu
+  - gpu0
+server_config:
+  address: 0.0.0.0
+  deploy_mode: single
+  port: 19530
+  time_zone: UTC+8
diff --git a/tests/milvus_benchmark/conf/server_config.yaml.cpu b/tests/milvus_benchmark/conf/server_config.yaml.cpu
new file mode 100644
index 0000000000..95ab5f5343
--- /dev/null
+++ b/tests/milvus_benchmark/conf/server_config.yaml.cpu
@@ -0,0 +1,31 @@
+server_config:
+  address: 0.0.0.0            
+  port: 19530                 
+  deploy_mode: single                
+  time_zone: UTC+8  
+            
+db_config:
+  primary_path: /opt/milvus             
+  secondary_path:                        
+  backend_url: sqlite://:@:/    
+  insert_buffer_size: 4               
+  build_index_gpu: 0  
+  preload_table:             
+
+metric_config:
+  enable_monitor: false             
+  collector: prometheus             
+  prometheus_config:
+    port: 8080        
+
+cache_config:
+  cpu_cache_capacity: 16           
+  cpu_cache_threshold: 0.85     
+  cache_insert_data: false 
+
+engine_config:
+  use_blas_threshold: 20            
+
+resource_config:
+  resource_pool:
+    - cpu
\ No newline at end of file
diff --git a/tests/milvus_benchmark/conf/server_config.yaml.multi b/tests/milvus_benchmark/conf/server_config.yaml.multi
new file mode 100644
index 0000000000..002d3bd2a6
--- /dev/null
+++ b/tests/milvus_benchmark/conf/server_config.yaml.multi
@@ -0,0 +1,33 @@
+server_config:
+  address: 0.0.0.0            
+  port: 19530                 
+  deploy_mode: single                
+  time_zone: UTC+8  
+            
+db_config:
+  primary_path: /opt/milvus             
+  secondary_path:                        
+  backend_url: sqlite://:@:/    
+  insert_buffer_size: 4               
+  build_index_gpu: 0  
+  preload_table:             
+
+metric_config:
+  enable_monitor: false             
+  collector: prometheus             
+  prometheus_config:
+    port: 8080        
+
+cache_config:
+  cpu_cache_capacity: 16           
+  cpu_cache_threshold: 0.85     
+  cache_insert_data: false 
+
+engine_config:
+  use_blas_threshold: 20            
+
+resource_config:
+  resource_pool:
+    - cpu
+    - gpu0
+    - gpu1
\ No newline at end of file
diff --git a/tests/milvus_benchmark/conf/server_config.yaml.single b/tests/milvus_benchmark/conf/server_config.yaml.single
new file mode 100644
index 0000000000..033d8868d1
--- /dev/null
+++ b/tests/milvus_benchmark/conf/server_config.yaml.single
@@ -0,0 +1,32 @@
+server_config:
+  address: 0.0.0.0            
+  port: 19530                 
+  deploy_mode: single                
+  time_zone: UTC+8  
+            
+db_config:
+  primary_path: /opt/milvus             
+  secondary_path:                        
+  backend_url: sqlite://:@:/    
+  insert_buffer_size: 4               
+  build_index_gpu: 0  
+  preload_table:       
+
+metric_config:
+  enable_monitor: false             
+  collector: prometheus             
+  prometheus_config:
+    port: 8080        
+
+cache_config:
+  cpu_cache_capacity: 16           
+  cpu_cache_threshold: 0.85     
+  cache_insert_data: false 
+
+engine_config:
+  use_blas_threshold: 20            
+
+resource_config:
+  resource_pool:
+    - cpu
+    - gpu0
\ No newline at end of file
diff --git a/tests/milvus_benchmark/demo.py b/tests/milvus_benchmark/demo.py
new file mode 100644
index 0000000000..27152e0980
--- /dev/null
+++ b/tests/milvus_benchmark/demo.py
@@ -0,0 +1,51 @@
+import os
+import logging
+import pdb
+import time
+import random
+from multiprocessing import Process
+import numpy as np
+from client import MilvusClient
+
+nq = 100000
+dimension = 128
+run_count = 1
+table_name = "sift_10m_1024_128_ip"
+insert_vectors = [[random.random() for _ in range(dimension)] for _ in range(nq)]
+
+def do_query(milvus, table_name, top_ks, nqs, nprobe, run_count):
+    bi_res = []
+    for index, nq in enumerate(nqs):
+        tmp_res = []
+        for top_k in top_ks:
+            avg_query_time = 0.0
+            total_query_time = 0.0
+            vectors = insert_vectors[0:nq]
+            for i in range(run_count):
+                start_time = time.time()
+                status, query_res = milvus.query(vectors, top_k, nprobe)
+                total_query_time = total_query_time + (time.time() - start_time)
+                if status.code:
+                    print(status.message)
+            avg_query_time = round(total_query_time / run_count, 2)
+            tmp_res.append(avg_query_time)
+        bi_res.append(tmp_res)
+    return bi_res
+
+while 1:
+    milvus_instance = MilvusClient(table_name, ip="192.168.1.197", port=19530)
+    top_ks = random.sample([x for x in range(1, 100)], 4)
+    nqs = random.sample([x for x in range(1, 1000)], 3)
+    nprobe = random.choice([x for x in range(1, 500)])
+    res = do_query(milvus_instance, table_name, top_ks, nqs, nprobe, run_count)
+    status, res = milvus_instance.insert(insert_vectors, ids=[x for x in range(len(insert_vectors))])
+    if not status.OK():
+        logger.error(status.message)
+
+    # status = milvus_instance.drop_index()
+    if not status.OK():
+        print(status.message)
+    index_type = "ivf_sq8"
+    status = milvus_instance.create_index(index_type, 16384)
+    if not status.OK():
+        print(status.message)
\ No newline at end of file
diff --git a/tests/milvus_benchmark/docker_runner.py b/tests/milvus_benchmark/docker_runner.py
new file mode 100644
index 0000000000..008c9866b4
--- /dev/null
+++ b/tests/milvus_benchmark/docker_runner.py
@@ -0,0 +1,261 @@
+import os
+import logging
+import pdb
+import time
+import random
+from multiprocessing import Process
+import numpy as np
+from client import MilvusClient
+import utils
+import parser
+from runner import Runner
+
+logger = logging.getLogger("milvus_benchmark.docker")
+
+
+class DockerRunner(Runner):
+    """run docker mode"""
+    def __init__(self, image):
+        super(DockerRunner, self).__init__()
+        self.image = image
+        
+    def run(self, definition, run_type=None):
+        if run_type == "performance":
+            for op_type, op_value in definition.items():
+                # run docker mode
+                run_count = op_value["run_count"]
+                run_params = op_value["params"]
+                container = None
+                
+                if op_type == "insert":
+                    for index, param in enumerate(run_params):
+                        logger.info("Definition param: %s" % str(param))
+                        table_name = param["table_name"]
+                        volume_name = param["db_path_prefix"]
+                        print(table_name)
+                        (data_type, table_size, index_file_size, dimension, metric_type) = parser.table_parser(table_name)
+                        for k, v in param.items():
+                            if k.startswith("server."):
+                                # Update server config
+                                utils.modify_config(k, v, type="server", db_slave=None)
+                        container = utils.run_server(self.image, test_type="remote", volume_name=volume_name, db_slave=None)
+                        time.sleep(2)
+                        milvus = MilvusClient(table_name)
+                        # Check has table or not
+                        if milvus.exists_table():
+                            milvus.delete()
+                            time.sleep(10)
+                        milvus.create_table(table_name, dimension, index_file_size, metric_type)
+                        res = self.do_insert(milvus, table_name, data_type, dimension, table_size, param["ni_per"])
+                        logger.info(res)
+
+                        # wait for file merge
+                        time.sleep(6 * (table_size / 500000))
+                        # Clear up
+                        utils.remove_container(container)
+
+                elif op_type == "query":
+                    for index, param in enumerate(run_params):
+                        logger.info("Definition param: %s" % str(param))
+                        table_name = param["dataset"]
+                        volume_name = param["db_path_prefix"]
+                        (data_type, table_size, index_file_size, dimension, metric_type) = parser.table_parser(table_name)
+                        for k, v in param.items():
+                            if k.startswith("server."):                   
+                                utils.modify_config(k, v, type="server")
+                        container = utils.run_server(self.image, test_type="remote", volume_name=volume_name, db_slave=None)
+                        time.sleep(2)
+                        milvus = MilvusClient(table_name)
+                        logger.debug(milvus._milvus.show_tables())
+                        # Check has table or not
+                        if not milvus.exists_table():
+                            logger.warning("Table %s not existed, continue exec next params ..." % table_name)
+                            continue
+                        # parse index info
+                        index_types = param["index.index_types"]
+                        nlists = param["index.nlists"]
+                        # parse top-k, nq, nprobe
+                        top_ks, nqs, nprobes = parser.search_params_parser(param)
+                        for index_type in index_types:
+                            for nlist in nlists:
+                                result = milvus.describe_index()
+                                logger.info(result)
+                                milvus.create_index(index_type, nlist)
+                                result = milvus.describe_index()
+                                logger.info(result)
+                                # preload index
+                                milvus.preload_table()
+                                logger.info("Start warm up query")
+                                res = self.do_query(milvus, table_name, [1], [1], 1, 1)
+                                logger.info("End warm up query")
+                                # Run query test
+                                for nprobe in nprobes:
+                                    logger.info("index_type: %s, nlist: %s, metric_type: %s, nprobe: %s" % (index_type, nlist, metric_type, nprobe))
+                                    res = self.do_query(milvus, table_name, top_ks, nqs, nprobe, run_count)
+                                    headers = ["Nprobe/Top-k"]
+                                    headers.extend([str(top_k) for top_k in top_ks])
+                                    utils.print_table(headers, nqs, res)
+                        utils.remove_container(container)
+
+        elif run_type == "accuracy":
+            """
+            {
+                "dataset": "random_50m_1024_512", 
+                "index.index_types": ["flat", ivf_flat", "ivf_sq8"],
+                "index.nlists": [16384],
+                "nprobes": [1, 32, 128], 
+                "nqs": [100],
+                "top_ks": [1, 64], 
+                "server.use_blas_threshold": 1100, 
+                "server.cpu_cache_capacity": 256
+            }
+            """
+            for op_type, op_value in definition.items():
+                if op_type != "query":
+                    logger.warning("invalid operation: %s in accuracy test, only support query operation" % op_type)
+                    break
+                run_count = op_value["run_count"]
+                run_params = op_value["params"]
+                container = None
+
+                for index, param in enumerate(run_params):
+                    logger.info("Definition param: %s" % str(param))
+                    table_name = param["dataset"]
+                    sift_acc = False
+                    if "sift_acc" in param:
+                        sift_acc = param["sift_acc"]
+                    (data_type, table_size, index_file_size, dimension, metric_type) = parser.table_parser(table_name)
+                    for k, v in param.items():
+                        if k.startswith("server."):                   
+                            utils.modify_config(k, v, type="server")
+                    volume_name = param["db_path_prefix"]
+                    container = utils.run_server(self.image, test_type="remote", volume_name=volume_name, db_slave=None)
+                    time.sleep(2)
+                    milvus = MilvusClient(table_name)
+                    # Check has table or not
+                    if not milvus.exists_table():
+                        logger.warning("Table %s not existed, continue exec next params ..." % table_name)
+                        continue
+
+                    # parse index info
+                    index_types = param["index.index_types"]
+                    nlists = param["index.nlists"]
+                    # parse top-k, nq, nprobe
+                    top_ks, nqs, nprobes = parser.search_params_parser(param)
+
+                    if sift_acc is True:
+                        # preload groundtruth data
+                        true_ids_all = self.get_groundtruth_ids(table_size)
+
+                    acc_dict = {}
+                    for index_type in index_types:
+                        for nlist in nlists:
+                            result = milvus.describe_index()
+                            logger.info(result)
+                            milvus.create_index(index_type, nlist)
+                            # preload index
+                            milvus.preload_table()
+                            # Run query test
+                            for nprobe in nprobes:
+                                logger.info("index_type: %s, nlist: %s, metric_type: %s, nprobe: %s" % (index_type, nlist, metric_type, nprobe))
+                                for top_k in top_ks:
+                                    for nq in nqs:
+                                        result_ids = []
+                                        id_prefix = "%s_index_%s_nlist_%s_metric_type_%s_nprobe_%s_top_k_%s_nq_%s" % \
+                                                    (table_name, index_type, nlist, metric_type, nprobe, top_k, nq)
+                                        if sift_acc is False:
+                                            self.do_query_acc(milvus, table_name, top_k, nq, nprobe, id_prefix)
+                                            if index_type != "flat":
+                                                # Compute accuracy
+                                                base_name = "%s_index_flat_nlist_%s_metric_type_%s_nprobe_%s_top_k_%s_nq_%s" % \
+                                                    (table_name, nlist, metric_type, nprobe, top_k, nq)
+                                                avg_acc = self.compute_accuracy(base_name, id_prefix)
+                                                logger.info("Query: <%s> accuracy: %s" % (id_prefix, avg_acc))
+                                        else:
+                                            result_ids = self.do_query_ids(milvus, table_name, top_k, nq, nprobe)
+                                            acc_value = self.get_recall_value(true_ids_all[:nq, :top_k].tolist(), result_ids)
+                                            logger.info("Query: <%s> accuracy: %s" % (id_prefix, acc_value))
+                    # # print accuracy table
+                    # headers = [table_name]
+                    # headers.extend([str(top_k) for top_k in top_ks])
+                    # utils.print_table(headers, nqs, res)
+
+                    # remove container, and run next definition
+                    logger.info("remove container, and run next definition")
+                    utils.remove_container(container)
+
+        elif run_type == "stability":
+            for op_type, op_value in definition.items():
+                if op_type != "query":
+                    logger.warning("invalid operation: %s in accuracy test, only support query operation" % op_type)
+                    break
+                run_count = op_value["run_count"]
+                run_params = op_value["params"]
+                container = None
+                for index, param in enumerate(run_params):
+                    logger.info("Definition param: %s" % str(param))
+                    table_name = param["dataset"]
+                    volume_name = param["db_path_prefix"]
+                    (data_type, table_size, index_file_size, dimension, metric_type) = parser.table_parser(table_name)
+                    
+                    # set default test time
+                    if "during_time" not in param:
+                        during_time = 100 # seconds
+                    else:
+                        during_time = int(param["during_time"]) * 60
+                    # set default query process num
+                    if "query_process_num" not in param:
+                        query_process_num = 10
+                    else:
+                        query_process_num = int(param["query_process_num"])
+
+                    for k, v in param.items():
+                        if k.startswith("server."):                   
+                            utils.modify_config(k, v, type="server")
+
+                    container = utils.run_server(self.image, test_type="remote", volume_name=volume_name, db_slave=None)
+                    time.sleep(2)
+                    milvus = MilvusClient(table_name)
+                    # Check has table or not
+                    if not milvus.exists_table():
+                        logger.warning("Table %s not existed, continue exec next params ..." % table_name)
+                        continue
+
+                    start_time = time.time()
+                    insert_vectors = [[random.random() for _ in range(dimension)] for _ in range(10000)]
+                    while time.time() < start_time + during_time:
+                        processes = []
+                        # do query
+                        # for i in range(query_process_num):
+                        #     milvus_instance = MilvusClient(table_name)
+                        #     top_k = random.choice([x for x in range(1, 100)])
+                        #     nq = random.choice([x for x in range(1, 100)])
+                        #     nprobe = random.choice([x for x in range(1, 1000)])
+                        #     # logger.info("index_type: %s, nlist: %s, metric_type: %s, nprobe: %s" % (index_type, nlist, metric_type, nprobe))
+                        #     p = Process(target=self.do_query, args=(milvus_instance, table_name, [top_k], [nq], [nprobe], run_count, ))
+                        #     processes.append(p)
+                        #     p.start()
+                        #     time.sleep(0.1)
+                        # for p in processes:
+                        #     p.join()
+                        milvus_instance = MilvusClient(table_name)
+                        top_ks = random.sample([x for x in range(1, 100)], 3)
+                        nqs = random.sample([x for x in range(1, 1000)], 3)
+                        nprobe = random.choice([x for x in range(1, 500)])
+                        res = self.do_query(milvus, table_name, top_ks, nqs, nprobe, run_count)
+                        if int(time.time() - start_time) % 120 == 0:
+                            status, res = milvus_instance.insert(insert_vectors, ids=[x for x in range(len(insert_vectors))])
+                            if not status.OK():
+                                logger.error(status)
+                            # status = milvus_instance.drop_index()
+                            # if not status.OK():
+                            #     logger.error(status)
+                            # index_type = random.choice(["flat", "ivf_flat", "ivf_sq8"])
+                            result = milvus.describe_index()
+                            logger.info(result)
+                            milvus_instance.create_index("ivf_sq8", 16384)
+                    utils.remove_container(container)
+
+        else:
+            logger.warning("Run type: %s not supported" % run_type)
+
diff --git a/tests/milvus_benchmark/local_runner.py b/tests/milvus_benchmark/local_runner.py
new file mode 100644
index 0000000000..1067f500bc
--- /dev/null
+++ b/tests/milvus_benchmark/local_runner.py
@@ -0,0 +1,132 @@
+import os
+import logging
+import pdb
+import time
+import random
+from multiprocessing import Process
+import numpy as np
+from client import MilvusClient
+import utils
+import parser
+from runner import Runner
+
+logger = logging.getLogger("milvus_benchmark.local_runner")
+
+
+class LocalRunner(Runner):
+    """run local mode"""
+    def __init__(self, ip, port):
+        super(LocalRunner, self).__init__()
+        self.ip = ip
+        self.port = port
+
+    def run(self, definition, run_type=None):
+        if run_type == "performance":
+            for op_type, op_value in definition.items():
+                run_count = op_value["run_count"]
+                run_params = op_value["params"]
+
+                if op_type == "insert":
+                    for index, param in enumerate(run_params):
+                        table_name = param["table_name"]
+                        # random_1m_100_512
+                        (data_type, table_size, index_file_size, dimension, metric_type) = parser.table_parser(table_name)
+                        milvus = MilvusClient(table_name, ip=self.ip, port=self.port)
+                        # Check has table or not
+                        if milvus.exists_table():
+                            milvus.delete()
+                            time.sleep(10)
+                        milvus.create_table(table_name, dimension, index_file_size, metric_type)
+                        res = self.do_insert(milvus, table_name, data_type, dimension, table_size, param["ni_per"])
+                        logger.info(res)
+
+                elif op_type == "query":
+                    for index, param in enumerate(run_params):
+                        logger.info("Definition param: %s" % str(param))
+                        table_name = param["dataset"]
+                        (data_type, table_size, index_file_size, dimension, metric_type) = parser.table_parser(table_name)
+
+                        milvus = MilvusClient(table_name, ip=self.ip, port=self.port)
+                        # parse index info
+                        index_types = param["index.index_types"]
+                        nlists = param["index.nlists"]
+                        # parse top-k, nq, nprobe
+                        top_ks, nqs, nprobes = parser.search_params_parser(param)
+
+                        for index_type in index_types:
+                            for nlist in nlists:
+                                milvus.create_index(index_type, nlist)
+                                # preload index
+                                milvus.preload_table()
+                                # Run query test
+                                for nprobe in nprobes:
+                                    logger.info("index_type: %s, nlist: %s, metric_type: %s, nprobe: %s" % (index_type, nlist, metric_type, nprobe))
+                                    res = self.do_query(milvus, table_name, top_ks, nqs, nprobe, run_count)
+                                    headers = [param["dataset"]]
+                                    headers.extend([str(top_k) for top_k in top_ks])
+                                    utils.print_table(headers, nqs, res)
+
+        elif run_type == "stability":
+            for op_type, op_value in definition.items():
+                if op_type != "query":
+                    logger.warning("invalid operation: %s in accuracy test, only support query operation" % op_type)
+                    break
+                run_count = op_value["run_count"]
+                run_params = op_value["params"]
+                nq = 10000
+
+                for index, param in enumerate(run_params):
+                    logger.info("Definition param: %s" % str(param))
+                    table_name = param["dataset"]
+                    (data_type, table_size, index_file_size, dimension, metric_type) = parser.table_parser(table_name)
+                    
+                    # set default test time
+                    if "during_time" not in param:
+                        during_time = 100 # seconds
+                    else:
+                        during_time = int(param["during_time"]) * 60
+                    # set default query process num
+                    if "query_process_num" not in param:
+                        query_process_num = 10
+                    else:
+                        query_process_num = int(param["query_process_num"])
+                    milvus = MilvusClient(table_name)
+                    # Check has table or not
+                    if not milvus.exists_table():
+                        logger.warning("Table %s not existed, continue exec next params ..." % table_name)
+                        continue
+
+                    start_time = time.time()
+                    insert_vectors = [[random.random() for _ in range(dimension)] for _ in range(nq)]
+                    while time.time() < start_time + during_time:
+                        processes = []
+                        # # do query
+                        # for i in range(query_process_num):
+                        #     milvus_instance = MilvusClient(table_name)
+                        #     top_k = random.choice([x for x in range(1, 100)])
+                        #     nq = random.choice([x for x in range(1, 1000)])
+                        #     nprobe = random.choice([x for x in range(1, 500)])
+                        #     logger.info(nprobe)
+                        #     p = Process(target=self.do_query, args=(milvus_instance, table_name, [top_k], [nq], 64, run_count, ))
+                        #     processes.append(p)
+                        #     p.start()
+                        #     time.sleep(0.1)
+                        # for p in processes:
+                        #     p.join()
+                        milvus_instance = MilvusClient(table_name)
+                        top_ks = random.sample([x for x in range(1, 100)], 4)
+                        nqs = random.sample([x for x in range(1, 1000)], 3)
+                        nprobe = random.choice([x for x in range(1, 500)])
+                        res = self.do_query(milvus, table_name, top_ks, nqs, nprobe, run_count)
+                        # milvus_instance = MilvusClient(table_name)
+                        status, res = milvus_instance.insert(insert_vectors, ids=[x for x in range(len(insert_vectors))])
+                        if not status.OK():
+                            logger.error(status.message)
+                        if (time.time() - start_time) % 300 == 0:
+                            status = milvus_instance.drop_index()
+                            if not status.OK():
+                                logger.error(status.message)
+                            index_type = random.choice(["flat", "ivf_flat", "ivf_sq8"])
+                            status = milvus_instance.create_index(index_type, 16384)
+                            if not status.OK():
+                                logger.error(status.message)
diff --git a/tests/milvus_benchmark/main.py b/tests/milvus_benchmark/main.py
new file mode 100644
index 0000000000..c11237c5e7
--- /dev/null
+++ b/tests/milvus_benchmark/main.py
@@ -0,0 +1,131 @@
+import os
+import sys
+import time
+import pdb
+import argparse
+import logging
+import utils
+from yaml import load, dump
+from logging import handlers
+from parser import operations_parser
+from local_runner import LocalRunner
+from docker_runner import DockerRunner
+
+DEFAULT_IMAGE = "milvusdb/milvus:latest"
+LOG_FOLDER = "benchmark_logs"
+logger = logging.getLogger("milvus_benchmark")
+
+formatter = logging.Formatter('[%(asctime)s] [%(levelname)-4s] [%(pathname)s:%(lineno)d] %(message)s')
+if not os.path.exists(LOG_FOLDER):
+    os.system('mkdir -p %s' % LOG_FOLDER)
+fileTimeHandler = handlers.TimedRotatingFileHandler(os.path.join(LOG_FOLDER, 'milvus_benchmark'), "D", 1, 10)
+fileTimeHandler.suffix = "%Y%m%d.log"
+fileTimeHandler.setFormatter(formatter)
+logging.basicConfig(level=logging.DEBUG)
+fileTimeHandler.setFormatter(formatter)
+logger.addHandler(fileTimeHandler)
+
+
+def positive_int(s):
+    i = None
+    try:
+        i = int(s)
+    except ValueError:
+        pass
+    if not i or i < 1:
+        raise argparse.ArgumentTypeError("%r is not a positive integer" % s)
+    return i
+
+
+# # link random_data if not exists
+# def init_env():
+#     if not os.path.islink(BINARY_DATA_FOLDER):
+#         try:
+#             os.symlink(SRC_BINARY_DATA_FOLDER, BINARY_DATA_FOLDER)
+#         except Exception as e:
+#             logger.error("Create link failed: %s" % str(e))
+#             sys.exit()
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    parser.add_argument(
+        '--image',
+        help='use the given image')
+    parser.add_argument(
+        '--local',
+        action='store_true',
+        help='use local milvus server')
+    parser.add_argument(
+        "--run-count",
+        default=1,
+        type=positive_int,
+        help="run each db operation times")
+    # performance / stability / accuracy test
+    parser.add_argument(
+        "--run-type",
+        default="performance",
+        help="run type, default performance")
+    parser.add_argument(
+        '--suites',
+        metavar='FILE',
+        help='load test suites from FILE',
+        default='suites.yaml')
+    parser.add_argument(
+        '--ip',
+        help='server ip param for local mode',
+        default='127.0.0.1')
+    parser.add_argument(
+        '--port',
+        help='server port param for local mode',
+        default='19530')
+
+    args = parser.parse_args()
+
+    operations = None
+    # Get all benchmark test suites
+    if args.suites:
+        with open(args.suites) as f:
+            suites_dict = load(f)
+            f.close()
+        # With definition order
+        operations = operations_parser(suites_dict, run_type=args.run_type)
+
+    # init_env()
+    run_params = {"run_count": args.run_count}
+
+    if args.image:
+        # for docker mode
+        if args.local:
+            logger.error("Local mode and docker mode are incompatible arguments")
+            sys.exit(-1)
+        # Docker pull image
+        if not utils.pull_image(args.image):
+            raise Exception('Image %s pull failed' % image)
+
+        # TODO: Check milvus server port is available
+        logger.info("Init: remove all containers created with image: %s" % args.image)
+        utils.remove_all_containers(args.image)
+        runner = DockerRunner(args.image)
+        for operation_type in operations:
+            logger.info("Start run test, test type: %s" % operation_type)
+            run_params["params"] = operations[operation_type]
+            runner.run({operation_type: run_params}, run_type=args.run_type)
+            logger.info("Run params: %s" % str(run_params))
+
+    if args.local:
+        # for local mode
+        ip = args.ip
+        port = args.port
+
+        runner = LocalRunner(ip, port)
+        for operation_type in operations:
+            logger.info("Start run local mode test, test type: %s" % operation_type)
+            run_params["params"] = operations[operation_type]
+            runner.run({operation_type: run_params}, run_type=args.run_type)
+            logger.info("Run params: %s" % str(run_params))
+
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git a/tests/milvus_benchmark/operation.py b/tests/milvus_benchmark/operation.py
new file mode 100644
index 0000000000..348fa47f4a
--- /dev/null
+++ b/tests/milvus_benchmark/operation.py
@@ -0,0 +1,10 @@
+from __future__ import absolute_import
+import pdb
+import time
+
+class Base(object):
+    pass
+
+
+class Insert(Base):
+    pass
\ No newline at end of file
diff --git a/tests/milvus_benchmark/parser.py b/tests/milvus_benchmark/parser.py
new file mode 100644
index 0000000000..1c1d2605f2
--- /dev/null
+++ b/tests/milvus_benchmark/parser.py
@@ -0,0 +1,66 @@
+import pdb
+import logging
+
+logger = logging.getLogger("milvus_benchmark.parser")
+
+
+def operations_parser(operations, run_type="performance"):
+    definitions = operations[run_type]
+    return definitions
+
+
+def table_parser(table_name):
+    tmp = table_name.split("_")
+    # if len(tmp) != 5:
+    #     return None
+    data_type = tmp[0]
+    table_size_unit = tmp[1][-1]
+    table_size = tmp[1][0:-1]
+    if table_size_unit == "m":
+        table_size = int(table_size) * 1000000
+    elif table_size_unit == "b":
+        table_size = int(table_size) * 1000000000
+    index_file_size = int(tmp[2])
+    dimension = int(tmp[3])
+    metric_type = str(tmp[4])
+    return (data_type, table_size, index_file_size, dimension, metric_type)
+
+
+def search_params_parser(param):
+    # parse top-k, set default value if top-k not in param
+    if "top_ks" not in param:
+        top_ks = [10]
+    else:
+        top_ks = param["top_ks"]
+    if isinstance(top_ks, int):
+        top_ks = [top_ks]
+    elif isinstance(top_ks, list):
+        top_ks = list(top_ks)
+    else:
+        logger.warning("Invalid format top-ks: %s" % str(top_ks))
+
+    # parse nqs, set default value if nq not in param
+    if "nqs" not in param:
+        nqs = [10]
+    else:
+        nqs = param["nqs"]
+    if isinstance(nqs, int):
+        nqs = [nqs]
+    elif isinstance(nqs, list):
+        nqs = list(nqs)
+    else:
+        logger.warning("Invalid format nqs: %s" % str(nqs))
+
+    # parse nprobes
+    if "nprobes" not in param:
+        nprobes = [1]
+    else:
+        nprobes = param["nprobes"]
+    if isinstance(nprobes, int):
+        nprobes = [nprobes]
+    elif isinstance(nprobes, list):
+        nprobes = list(nprobes)
+    else:
+        logger.warning("Invalid format nprobes: %s" % str(nprobes))    
+
+    return top_ks, nqs, nprobes
\ No newline at end of file
diff --git a/tests/milvus_benchmark/report.py b/tests/milvus_benchmark/report.py
new file mode 100644
index 0000000000..6041311513
--- /dev/null
+++ b/tests/milvus_benchmark/report.py
@@ -0,0 +1,10 @@
+# from tablereport import Table
+# from tablereport.shortcut import write_to_excel
+
+# RESULT_FOLDER = "results"
+
+# def create_table(headers, bodys, table_name):
+# 	table = Table(header=[headers],
+# 	              body=[bodys])
+
+# 	write_to_excel('%s/%s.xlsx' % (RESULT_FOLDER, table_name), table)
\ No newline at end of file
diff --git a/tests/milvus_benchmark/requirements.txt b/tests/milvus_benchmark/requirements.txt
new file mode 100644
index 0000000000..328cff1eb4
--- /dev/null
+++ b/tests/milvus_benchmark/requirements.txt
@@ -0,0 +1,6 @@
+numpy==1.16.3
+pymilvus>=0.1.18
+pyyaml==5.1
+docker==4.0.2
+tableprint==0.8.0
+ansicolors==1.1.8
\ No newline at end of file
diff --git a/tests/milvus_benchmark/runner.py b/tests/milvus_benchmark/runner.py
new file mode 100644
index 0000000000..d3ad345da9
--- /dev/null
+++ b/tests/milvus_benchmark/runner.py
@@ -0,0 +1,219 @@
+import os
+import logging
+import pdb
+import time
+import random
+from multiprocessing import Process
+import numpy as np
+from client import MilvusClient
+import utils
+import parser
+
+logger = logging.getLogger("milvus_benchmark.runner")
+
+SERVER_HOST_DEFAULT = "127.0.0.1"
+SERVER_PORT_DEFAULT = 19530
+VECTORS_PER_FILE = 1000000
+SIFT_VECTORS_PER_FILE = 100000
+MAX_NQ = 10001
+FILE_PREFIX = "binary_"
+
+RANDOM_SRC_BINARY_DATA_DIR = '/tmp/random/binary_data'
+SIFT_SRC_DATA_DIR = '/tmp/sift1b/query'
+SIFT_SRC_BINARY_DATA_DIR = '/tmp/sift1b/binary_data'
+SIFT_SRC_GROUNDTRUTH_DATA_DIR = '/tmp/sift1b/groundtruth'
+
+WARM_TOP_K = 1
+WARM_NQ = 1
+DEFAULT_DIM = 512
+
+GROUNDTRUTH_MAP = {
+    "1000000": "idx_1M.ivecs",
+    "2000000": "idx_2M.ivecs",
+    "5000000": "idx_5M.ivecs",
+    "10000000": "idx_10M.ivecs",
+    "20000000": "idx_20M.ivecs",
+    "50000000": "idx_50M.ivecs",
+    "100000000": "idx_100M.ivecs",
+    "200000000": "idx_200M.ivecs",
+    "500000000": "idx_500M.ivecs",
+    "1000000000": "idx_1000M.ivecs",
+}
+
+
+def gen_file_name(idx, table_dimension, data_type):
+    s = "%05d" % idx
+    fname = FILE_PREFIX + str(table_dimension) + "d_" + s + ".npy"
+    if data_type == "random":
+        fname = RANDOM_SRC_BINARY_DATA_DIR+'/'+fname
+    elif data_type == "sift":
+        fname = SIFT_SRC_BINARY_DATA_DIR+'/'+fname
+    return fname
+
+
+def get_vectors_from_binary(nq, dimension, data_type):
+    # use the first file, nq should be less than VECTORS_PER_FILE
+    if nq > MAX_NQ:
+        raise Exception("Over size nq")
+    if data_type == "random":
+        file_name = gen_file_name(0, dimension, data_type)
+    elif data_type == "sift":
+        file_name = SIFT_SRC_DATA_DIR+'/'+'query.npy'
+    data = np.load(file_name)
+    vectors = data[0:nq].tolist()
+    return vectors
+
+
+class Runner(object):
+    def __init__(self):
+        pass
+
+    def do_insert(self, milvus, table_name, data_type, dimension, size, ni):
+        '''
+        @params:
+            mivlus: server connect instance
+            dimension: table dimensionn
+            # index_file_size: size trigger file merge
+            size: row count of vectors to be insert
+            ni: row count of vectors to be insert each time
+            # store_id: if store the ids returned by call add_vectors or not
+        @return:
+            total_time: total time for all insert operation
+            qps: vectors added per second
+            ni_time: avarage insert operation time
+        '''
+        bi_res = {}
+        total_time = 0.0
+        qps = 0.0
+        ni_time = 0.0
+        if data_type == "random":
+            vectors_per_file = VECTORS_PER_FILE
+        elif data_type == "sift":
+            vectors_per_file = SIFT_VECTORS_PER_FILE
+        if size % vectors_per_file or ni > vectors_per_file:
+            raise Exception("Not invalid table size or ni")
+        file_num = size // vectors_per_file
+        for i in range(file_num):
+            file_name = gen_file_name(i, dimension, data_type)
+            logger.info("Load npy file: %s start" % file_name)
+            data = np.load(file_name)
+            logger.info("Load npy file: %s end" % file_name)
+            loops = vectors_per_file // ni
+            for j in range(loops):
+                vectors = data[j*ni:(j+1)*ni].tolist()
+                ni_start_time = time.time()
+                # start insert vectors
+                start_id = i * vectors_per_file + j * ni
+                end_id = start_id + len(vectors)
+                logger.info("Start id: %s, end id: %s" % (start_id, end_id))
+                ids = [k for k in range(start_id, end_id)]
+                status, ids = milvus.insert(vectors, ids=ids)
+                ni_end_time = time.time()
+                total_time = total_time + ni_end_time - ni_start_time
+
+        qps = round(size / total_time, 2)
+        ni_time = round(total_time / (loops * file_num), 2)
+        bi_res["total_time"] = round(total_time, 2)
+        bi_res["qps"] = qps
+        bi_res["ni_time"] = ni_time
+        return bi_res
+
+    def do_query(self, milvus, table_name, top_ks, nqs, nprobe, run_count):
+        (data_type, table_size, index_file_size, dimension, metric_type) = parser.table_parser(table_name)
+        base_query_vectors = get_vectors_from_binary(MAX_NQ, dimension, data_type)
+
+        bi_res = []
+        for index, nq in enumerate(nqs):
+            tmp_res = []
+            for top_k in top_ks:
+                avg_query_time = 0.0
+                total_query_time = 0.0
+                vectors = base_query_vectors[0:nq]
+                logger.info("Start query, query params: top-k: {}, nq: {}, actually length of vectors: {}".format(top_k, nq, len(vectors)))
+                for i in range(run_count):
+                    logger.info("Start run query, run %d of %s" % (i+1, run_count))
+                    start_time = time.time()
+                    status, query_res = milvus.query(vectors, top_k, nprobe)
+                    total_query_time = total_query_time + (time.time() - start_time)
+                    if status.code:
+                        logger.error("Query failed with message: %s" % status.message)
+                avg_query_time = round(total_query_time / run_count, 2)
+                logger.info("Avarage query time: %.2f" % avg_query_time)
+                tmp_res.append(avg_query_time)
+            bi_res.append(tmp_res)
+        return bi_res
+
+    def do_query_ids(self, milvus, table_name, top_k, nq, nprobe):
+        (data_type, table_size, index_file_size, dimension, metric_type) = parser.table_parser(table_name)
+        base_query_vectors = get_vectors_from_binary(MAX_NQ, dimension, data_type)
+        vectors = base_query_vectors[0:nq]
+        logger.info("Start query, query params: top-k: {}, nq: {}, actually length of vectors: {}".format(top_k, nq, len(vectors)))
+        status, query_res = milvus.query(vectors, top_k, nprobe)
+        if not status.OK():
+            msg = "Query failed with message: %s" % status.message
+            raise Exception(msg)
+        result_ids = []
+        for result in query_res:
+            tmp = []
+            for item in result:
+                tmp.append(item.id)
+            result_ids.append(tmp)
+        return result_ids
+
+    def do_query_acc(self, milvus, table_name, top_k, nq, nprobe, id_store_name):
+        (data_type, table_size, index_file_size, dimension, metric_type) = parser.table_parser(table_name)
+        base_query_vectors = get_vectors_from_binary(MAX_NQ, dimension, data_type)
+        vectors = base_query_vectors[0:nq]
+        logger.info("Start query, query params: top-k: {}, nq: {}, actually length of vectors: {}".format(top_k, nq, len(vectors)))
+        status, query_res = milvus.query(vectors, top_k, nprobe)
+        if not status.OK():
+            msg = "Query failed with message: %s" % status.message
+            raise Exception(msg)
+        # if file existed, cover it
+        if os.path.isfile(id_store_name):
+            os.remove(id_store_name)
+        with open(id_store_name, 'a+') as fd:
+            for nq_item in query_res:
+                for item in nq_item:
+                    fd.write(str(item.id)+'\t')
+                fd.write('\n')
+
+    # compute and print accuracy
+    def compute_accuracy(self, flat_file_name, index_file_name):
+        flat_id_list = []; index_id_list = []
+        logger.info("Loading flat id file: %s" % flat_file_name)
+        with open(flat_file_name, 'r') as flat_id_fd:
+            for line in flat_id_fd:
+                tmp_list = line.strip("\n").strip().split("\t")
+                flat_id_list.append(tmp_list)
+        logger.info("Loading index id file: %s" % index_file_name)
+        with open(index_file_name) as index_id_fd:
+            for line in index_id_fd:
+                tmp_list = line.strip("\n").strip().split("\t")
+                index_id_list.append(tmp_list)
+        if len(flat_id_list) != len(index_id_list):
+            raise Exception("Flat index result length: <flat: %s, index: %s> not match, Acc compute exiting ..." % (len(flat_id_list), len(index_id_list)))
+        # get the accuracy
+        return self.get_recall_value(flat_id_list, index_id_list)
+
+    def get_recall_value(self, flat_id_list, index_id_list):
+        """
+        Use the intersection length
+        """
+        sum_radio = 0.0
+        for index, item in enumerate(index_id_list):
+            tmp = set(item).intersection(set(flat_id_list[index]))
+            sum_radio = sum_radio + len(tmp) / len(item)
+        return round(sum_radio / len(index_id_list), 3)
+
+    """
+    Implementation based on:
+        https://github.com/facebookresearch/faiss/blob/master/benchs/datasets.py
+    """
+    def get_groundtruth_ids(self, table_size):
+        fname = GROUNDTRUTH_MAP[str(table_size)]
+        fname = SIFT_SRC_GROUNDTRUTH_DATA_DIR + "/" + fname
+        a = np.fromfile(fname, dtype='int32')
+        d = a[0]
+        true_ids = a.reshape(-1, d + 1)[:, 1:].copy()
+        return true_ids
diff --git a/tests/milvus_benchmark/suites.yaml b/tests/milvus_benchmark/suites.yaml
new file mode 100644
index 0000000000..f30b963c03
--- /dev/null
+++ b/tests/milvus_benchmark/suites.yaml
@@ -0,0 +1,38 @@
+# data sets
+datasets:
+  hf5:
+    gist-960,sift-128
+  npy:
+    50000000-512, 100000000-512
+
+operations:
+  # interface: search_vectors
+  query:
+    # dataset: table name you have already created
+    # key starts with "server." need to reconfig and restart server, including nprpbe/nlist/use_blas_threshold/..
+    [
+      # debug
+      # {"dataset": "ip_ivfsq8_1000", "top_ks": [16], "nqs": [1], "server.nprobe": 1, "server.use_blas_threshold": 800, "server.cpu_cache_capacity": 110},
+      
+      {"dataset": "ip_ivfsq8_1000", "top_ks": [1, 2, 4, 8, 16, 32, 64, 128, 256, 512], "nqs": [1, 10, 100, 500, 800, 1000], "server.nprobe": 1, "server.use_blas_threshold": 800, "server.cpu_cache_capacity": 110},
+      {"dataset": "ip_ivfsq8_1000", "top_ks": [1, 2, 4, 8, 16, 32, 64, 128, 256, 512], "nqs": [1, 10, 100, 500, 800, 1000], "server.nprobe": 10, "server.use_blas_threshold": 20, "server.cpu_cache_capacity": 110},
+      {"dataset": "ip_ivfsq8_5000", "top_ks": [1, 2, 4, 8, 16, 32, 64, 128, 256, 512], "nqs": [1, 10, 100, 500, 800, 1000], "server.nprobe": 1, "server.use_blas_threshold": 800, "server.cpu_cache_capacity": 110},
+      {"dataset": "ip_ivfsq8_5000", "top_ks": [1, 2, 4, 8, 16, 32, 64, 128, 256, 512], "nqs": [1, 10, 100, 500, 800, 1000], "server.nprobe": 10, "server.use_blas_threshold": 20, "server.cpu_cache_capacity": 110},
+      {"dataset": "ip_ivfsq8_40000", "top_ks": [1, 2, 4, 8, 16, 32, 64, 128, 256, 512], "nqs": [1, 10, 100, 500, 800, 1000], "server.nprobe": 1, "server.use_blas_threshold": 800, "server.cpu_cache_capacity": 110},
+      # {"dataset": "ip_ivfsq8_40000", "top_ks": [1, 2, 4, 8, 16, 32, 64, 128, 256], "nqs": [1, 10, 100, 1000], "server.nprobe": 10, "server.use_blas_threshold": 20, "server.cpu_cache_capacity": 110},
+    ]
+
+  # interface: add_vectors
+  insert:
+    # index_type: flat/ivf_flat/ivf_sq8
+    [
+      # debug
+
+
+      {"table_name": "ip_ivf_flat_20m_1024", "table.index_type": "ivf_flat", "server.index_building_threshold": 1024, "table.size": 20000000, "table.ni": 100000, "table.dim": 512, "server.cpu_cache_capacity": 110},
+      {"table_name": "ip_ivf_sq8_50m_1024", "table.index_type": "ivf_sq8", "server.index_building_threshold": 1024, "table.size": 50000000, "table.ni": 100000, "table.dim": 512, "server.cpu_cache_capacity": 110},
+    ]
+
+  # TODO: interface: build_index
+  build: []
+
diff --git a/tests/milvus_benchmark/suites_accuracy.yaml b/tests/milvus_benchmark/suites_accuracy.yaml
new file mode 100644
index 0000000000..fd8a5904fa
--- /dev/null
+++ b/tests/milvus_benchmark/suites_accuracy.yaml
@@ -0,0 +1,121 @@
+
+accuracy:
+  # interface: search_vectors
+  query:
+    [
+      {
+        "dataset": "random_20m_1024_512_ip",
+        # index info
+        "index.index_types": ["flat", "ivf_sq8"],
+        "index.nlists": [16384],
+        "index.metric_types": ["ip"],
+        "nprobes": [1, 16, 64], 
+        "top_ks": [64], 
+        "nqs": [100], 
+        "server.cpu_cache_capacity": 100,
+        "server.resources": ["cpu", "gpu0"],
+        "db_path_prefix": "/test/milvus/db_data/random_20m_1024_512_ip",
+      },
+      # {
+      #   "dataset": "sift_50m_1024_128_l2",
+      #   # index info
+      #   "index.index_types": ["ivf_sq8h"],
+      #   "index.nlists": [16384],
+      #   "index.metric_types": ["l2"],
+      #   "nprobes": [1, 16, 64], 
+      #   "top_ks": [64], 
+      #   "nqs": [100], 
+      #   "server.cpu_cache_capacity": 160,
+      #   "server.resources": ["cpu", "gpu0"],
+      #   "db_path_prefix": "/test/milvus/db_data/sift_50m_1024_128_l2",
+      #   "sift_acc": true
+      # },
+      # {
+      #   "dataset": "sift_50m_1024_128_l2",
+      #   # index info
+      #   "index.index_types": ["ivf_sq8"],
+      #   "index.nlists": [16384],
+      #   "index.metric_types": ["l2"],
+      #   "nprobes": [1, 16, 64], 
+      #   "top_ks": [64], 
+      #   "nqs": [100], 
+      #   "server.cpu_cache_capacity": 160,
+      #   "server.resources": ["cpu", "gpu0"],
+      #   "db_path_prefix": "/test/milvus/db_data/sift_50m_1024_128_l2_sq8",
+      #   "sift_acc": true
+      # },
+      # {
+      #   "dataset": "sift_1b_2048_128_l2",
+      #   # index info
+      #   "index.index_types": ["ivf_sq8h"],
+      #   "index.nlists": [16384],
+      #   "index.metric_types": ["l2"],
+      #   "nprobes": [1, 16, 64, 128], 
+      #   "top_ks": [64], 
+      #   "nqs": [100], 
+      #   "server.cpu_cache_capacity": 200,
+      #   "server.resources": ["cpu"],
+      #   "db_path_prefix": "/test/milvus/db_data/sift_1b_2048_128_l2_sq8h",
+      #   "sift_acc": true
+      # },
+      # {
+      #   "dataset": "sift_1b_2048_128_l2",
+      #   # index info
+      #   "index.index_types": ["ivf_sq8h"],
+      #   "index.nlists": [16384],
+      #   "index.metric_types": ["l2"],
+      #   "nprobes": [1, 16, 64, 128], 
+      #   "top_ks": [64], 
+      #   "nqs": [100], 
+      #   "server.cpu_cache_capacity": 200,
+      #   "server.resources": ["cpu", "gpu0"],
+      #   "db_path_prefix": "/test/milvus/db_data/sift_1b_2048_128_l2_sq8h",
+      #   "sift_acc": true
+      # },
+      # {
+      #   "dataset": "sift_1b_2048_128_l2",
+      #   # index info
+      #   "index.index_types": ["ivf_sq8h"],
+      #   "index.nlists": [16384],
+      #   "index.metric_types": ["l2"],
+      #   "nprobes": [1, 16, 64, 128], 
+      #   "top_ks": [64], 
+      #   "nqs": [100], 
+      #   "server.cpu_cache_capacity": 200,
+      #   "server.resources": ["cpu", "gpu0", "gpu1"],
+      #   "db_path_prefix": "/test/milvus/db_data/sift_1b_2048_128_l2_sq8h",
+      #   "sift_acc": true
+      # },
+      # {
+      #   "dataset": "sift_1m_1024_128_l2", 
+      #   "index.index_types": ["flat", "ivf_sq8"], 
+      #   "index.nlists": [16384],
+      #   "nprobes": [1, 32, 128, 256, 512], 
+      #   "nqs": 10,
+      #   "top_ks": 10, 
+      #   "server.use_blas_threshold": 1100, 
+      #   "server.cpu_cache_capacity": 16,
+      # },
+      # {
+      #   "dataset": "sift_10m_1024_128_l2", 
+      #   "index.index_types": ["flat", "ivf_sq8"], 
+      #   "index.nlists": [16384],
+      #   "nprobes": [1, 32, 128, 256, 512], 
+      #   "nqs": 10,
+      #   "top_ks": 10, 
+      #   "server.use_blas_threshold": 1100, 
+      #   "server.cpu_cache_capacity": 32,
+      # },
+      # {
+      #   "dataset": "sift_50m_1024_128_l2", 
+      #   "index.index_types": ["flat", "ivf_sq8"], 
+      #   "index.nlists": [16384],
+      #   "nprobes": [1, 32, 128, 256, 512], 
+      #   "nqs": 10,
+      #   "top_ks": 10, 
+      #   "server.use_blas_threshold": 1100, 
+      #   "server.cpu_cache_capacity": 64,
+      # }
+
+
+    ]
\ No newline at end of file
diff --git a/tests/milvus_benchmark/suites_performance.yaml b/tests/milvus_benchmark/suites_performance.yaml
new file mode 100644
index 0000000000..52d457a400
--- /dev/null
+++ b/tests/milvus_benchmark/suites_performance.yaml
@@ -0,0 +1,258 @@
+performance:
+
+  # interface: add_vectors
+  insert:
+    # index_type: flat/ivf_flat/ivf_sq8/mix_nsg
+    [
+      # debug
+      # data_type / data_size / index_file_size / dimension
+      # data_type: random / ann_sift
+      # data_size: 10m / 1b
+      # {
+      #   "table_name": "random_50m_1024_512_ip", 
+      #   "ni_per": 100000, 
+      #   "processes": 5, # multiprocessing
+      #   "server.cpu_cache_capacity": 16,
+      #   # "server.resources": ["gpu0", "gpu1"],
+      #   "db_path_prefix": "/test/milvus/db_data"
+      # },
+      # {
+      #   "table_name": "random_5m_1024_512_ip", 
+      #   "ni_per": 100000, 
+      #   "processes": 5, # multiprocessing
+      #   "server.cpu_cache_capacity": 16,
+      #   "server.resources": ["gpu0", "gpu1"],
+      #   "db_path_prefix": "/test/milvus/db_data/random_5m_1024_512_ip"
+      # },
+      # {
+      #   "table_name": "sift_1m_50_128_l2", 
+      #   "ni_per": 100000, 
+      #   "processes": 5, # multiprocessing
+      #   # "server.cpu_cache_capacity": 16,
+      #   "db_path_prefix": "/test/milvus/db_data"
+      # },
+      # {
+      #   "table_name": "sift_1m_256_128_l2", 
+      #   "ni_per": 100000, 
+      #   "processes": 5, # multiprocessing
+      #   # "server.cpu_cache_capacity": 16,
+      #   "db_path_prefix": "/test/milvus/db_data"
+      # }
+      # {
+      #   "table_name": "sift_50m_1024_128_l2", 
+      #   "ni_per": 100000, 
+      #   "processes": 5, # multiprocessing
+      #   # "server.cpu_cache_capacity": 16,
+      # },
+      # {
+      #   "table_name": "sift_100m_1024_128_l2", 
+      #   "ni_per": 100000, 
+      #   "processes": 5, # multiprocessing
+      # },
+      # {
+      #   "table_name": "sift_1b_2048_128_l2", 
+      #   "ni_per": 100000, 
+      #   "processes": 5, # multiprocessing
+      #   "server.cpu_cache_capacity": 16,
+      # }
+    ]
+
+  # interface: search_vectors
+  query:
+    # dataset: table name you have already created
+    # key starts with "server." need to reconfig and restart server, including use_blas_threshold/cpu_cache_capacity ..
+    [
+      # {
+      #   "dataset": "sift_1b_2048_128_l2",
+      #   # index info
+      #   "index.index_types": ["ivf_sq8h"],
+      #   "index.nlists": [16384],
+      #   "nprobes": [8, 32], 
+      #   "top_ks": [1, 8, 16, 32, 64, 128, 256, 512, 1000], 
+      #   "nqs": [1, 10, 100, 500, 1000], 
+      #   "processes": 1, # multiprocessing
+      #   "server.use_blas_threshold": 1100, 
+      #   "server.cpu_cache_capacity": 200,
+      #   "server.resources": ["cpu", "gpu0"],
+      #   "db_path_prefix": "/test/milvus/db_data/sift_1b_2048_128_l2_sq8h"
+      # },
+      # {
+      #   "dataset": "sift_1b_2048_128_l2",
+      #   # index info
+      #   "index.index_types": ["ivf_sq8"],
+      #   "index.nlists": [16384],
+      #   "nprobes": [8, 32], 
+      #   "top_ks": [1, 8, 16, 32, 64, 128, 256, 512, 1000], 
+      #   "nqs": [1, 10, 100, 500, 1000], 
+      #   "processes": 1, # multiprocessing
+      #   "server.use_blas_threshold": 1100, 
+      #   "server.cpu_cache_capacity": 200,
+      #   "server.resources": ["cpu", "gpu0"],
+      #   "db_path_prefix": "/test/milvus/db_data/sift_1b_2048_128_l2"
+      # },
+      # {
+      #   "dataset": "sift_1b_2048_128_l2",
+      #   # index info
+      #   "index.index_types": ["ivf_sq8h"],
+      #   "index.nlists": [16384],
+      #   "nprobes": [8, 32], 
+      #   "top_ks": [1, 8, 16, 32, 64, 128, 256, 512, 1000], 
+      #   "nqs": [1, 10, 100, 500, 1000], 
+      #   "processes": 1, # multiprocessing
+      #   "server.use_blas_threshold": 1100, 
+      #   "server.cpu_cache_capacity": 200,
+      #   "server.resources": ["cpu"],
+      #   "db_path_prefix": "/test/milvus/db_data"
+      # },
+      {
+        "dataset": "random_50m_1024_512_ip",
+        "index.index_types": ["ivf_sq8h"],
+        "index.nlists": [16384],
+        "nprobes": [8], 
+        # "top_ks": [1, 8, 16, 32, 64, 128, 256, 512, 1000], 
+        "top_ks": [512], 
+        # "nqs": [1, 10, 100, 500, 1000], 
+        "nqs": [500], 
+        "server.use_blas_threshold": 1100, 
+        "server.cpu_cache_capacity": 150,
+        "server.gpu_cache_capacity": 6,
+        "server.resources": ["cpu", "gpu0", "gpu1"],
+        "db_path_prefix": "/test/milvus/db_data/random_50m_1024_512_ip"
+      },
+      # {
+      #   "dataset": "random_50m_1024_512_ip",
+      #   "index.index_types": ["ivf_sq8"],
+      #   "index.nlists": [16384],
+      #   "nprobes": [8, 32], 
+      #   "top_ks": [1, 8, 16, 32, 64, 128, 256, 512, 1000], 
+      #   "nqs": [1, 10, 100, 500, 1000], 
+      #   "server.use_blas_threshold": 1100, 
+      #   "server.cpu_cache_capacity": 150,
+      #   "server.resources": ["cpu", "gpu0", "gpu1"],
+      #   "db_path_prefix": "/test/milvus/db_data/random_50m_1024_512_ip_sq8"
+      # },
+      # {
+      #   "dataset": "random_20m_1024_512_ip",
+      #   "index.index_types": ["flat"],
+      #   "index.nlists": [16384],
+      #   "nprobes": [50], 
+      #   "top_ks": [64], 
+      #   "nqs": [10], 
+      #   "server.use_blas_threshold": 1100, 
+      #   "server.cpu_cache_capacity": 100,
+      #   "server.resources": ["cpu", "gpu0", "gpu1"],
+      #   "db_path_prefix": "/test/milvus/db_data/random_20m_1024_512_ip"
+      # },
+      # {
+      #   "dataset": "random_100m_1024_512_ip",
+      #   # index info
+      #   "index.index_types": ["ivf_sq8"],
+      #   "index.nlists": [16384],
+      #   "nprobes": [8, 32], 
+      #   "top_ks": [1, 8, 16, 32, 64, 128, 256, 512, 1000], 
+      #   "nqs": [1, 10, 100, 500, 1000], 
+      #   "processes": 1, # multiprocessing
+      #   "server.use_blas_threshold": 1100, 
+      #   "server.cpu_cache_capacity": 250,
+      #   "server.resources": ["cpu", "gpu0"],
+      #   "db_path_prefix": "/test/milvus/db_data"
+      # },
+      # {
+      #   "dataset": "random_100m_1024_512_ip",
+      #   # index info
+      #   "index.index_types": ["ivf_sq8"],
+      #   "index.nlists": [16384],
+      #   "nprobes": [8, 32], 
+      #   "top_ks": [1, 8, 16, 32, 64, 128, 256, 512, 1000], 
+      #   "nqs": [1, 10, 100, 500, 1000], 
+      #   "processes": 1, # multiprocessing
+      #   "server.use_blas_threshold": 1100, 
+      #   "server.cpu_cache_capacity": 250,
+      #   "server.resources": ["cpu"],
+      #   "db_path_prefix": "/test/milvus/db_data"
+      # },
+      # {
+      #   "dataset": "random_10m_1024_512_ip",
+      #   # index info
+      #   "index.index_types": ["ivf_sq8"],
+      #   "index.nlists": [16384],
+      #   "nprobes": [1], 
+      #   "top_ks": [1, 2, 4, 8, 16, 32, 64, 128, 256], 
+      #   "nqs": [1, 10, 100, 500, 800], 
+      #   "processes": 1, # multiprocessing
+      #   # "server.use_blas_threshold": 1100, 
+      #   "server.cpu_cache_capacity": 16,
+      # },
+      # {
+      #   "dataset": "random_10m_1024_512_l2",
+      #   # index info
+      #   "index.index_types": ["ivf_sq8"],
+      #   "index.nlists": [16384],
+      #   "nprobes": [1], 
+      #   "top_ks": [1, 2, 4, 8, 16, 32, 64, 128, 256], 
+      #   "nqs": [1, 10, 100, 500, 800], 
+      #   "processes": 1, # multiprocessing
+      #   "server.use_blas_threshold": 1100, 
+      #   "server.cpu_cache_capacity": 64
+      # },
+      # {
+      #   "dataset": "sift_500m_1024_128_l2",
+      #   # index info
+      #   "index.index_types": ["ivf_sq8"],
+      #   "index.nlists": [16384],
+      #   "nprobes": [1], 
+      #   "top_ks": [1, 8, 16, 64, 256, 512, 1000], 
+      #   "nqs": [1, 100, 500, 800, 1000, 1500], 
+      #   # "top_ks": [256],
+      #   # "nqs": [800],
+      #   "processes": 1, # multiprocessing
+      #   # "server.use_blas_threshold": 1100, 
+      #   "server.cpu_cache_capacity": 120,
+      #   "server.resources": ["gpu0", "gpu1"],
+      #   "db_path_prefix": "/test/milvus/db_data"
+      # },
+      # {
+      #    "dataset": "sift_1b_2048_128_l2",
+      #    # index info
+      #    "index.index_types": ["ivf_sq8h"],
+      #    "index.nlists": [16384],
+      #    "nprobes": [1], 
+      #    # "top_ks": [1], 
+      #    # "nqs": [1], 
+      #    "top_ks": [256],
+      #    "nqs": [800],
+      #    "processes": 1, # multiprocessing
+      #    "server.use_blas_threshold": 1100, 
+      #    "server.cpu_cache_capacity": 110,
+      #    "server.resources": ["cpu", "gpu0"],
+      #    "db_path_prefix": "/test/milvus/db_data"
+      # },
+      # {
+      #   "dataset": "random_50m_1024_512_l2",
+      #   # index info
+      #   "index.index_types": ["ivf_sq8"],
+      #   "index.nlists": [16384],
+      #   "nprobes": [1], 
+      #   "top_ks": [1, 2, 4, 8, 16, 32, 64, 128, 256], 
+      #   "nqs": [1, 10, 100, 500, 800], 
+      #   # "top_ks": [256],
+      #   # "nqs": [800],
+      #   "processes": 1, # multiprocessing
+      #   "server.use_blas_threshold": 1100, 
+      #   "server.cpu_cache_capacity": 128
+      # },
+    # [
+    #   {
+    #     "dataset": "sift_1m_50_128_l2",
+    #     # index info
+    #     "index.index_types": ["ivf_sq8"],
+    #     "index.nlists": [16384],
+    #     "nprobes": [1], 
+    #     "top_ks": [1], 
+    #     "nqs": [1], 
+    #     "db_path_prefix": "/test/milvus/db_data"
+    #     # "processes": 1, # multiprocessing
+    #     # "server.use_blas_threshold": 1100, 
+    #     # "server.cpu_cache_capacity": 256
+    #   }
+    ]
\ No newline at end of file
diff --git a/tests/milvus_benchmark/suites_stability.yaml b/tests/milvus_benchmark/suites_stability.yaml
new file mode 100644
index 0000000000..408221079e
--- /dev/null
+++ b/tests/milvus_benchmark/suites_stability.yaml
@@ -0,0 +1,17 @@
+
+stability:
+  # interface: search_vectors / add_vectors mix operation
+  query:
+    [
+      {
+        "dataset": "random_20m_1024_512_ip",
+        # "nqs": [1, 10, 100, 1000, 10000],
+        # "pds": [0.1, 0.44, 0.44, 0.02],
+        "query_process_num": 10,
+        # each 10s, do an insertion
+        # "insert_interval": 1,
+        # minutes
+        "during_time": 360,
+        "server.cpu_cache_capacity": 100
+      },
+    ]
\ No newline at end of file
diff --git a/tests/milvus_benchmark/suites_yzb.yaml b/tests/milvus_benchmark/suites_yzb.yaml
new file mode 100644
index 0000000000..59efcb37e4
--- /dev/null
+++ b/tests/milvus_benchmark/suites_yzb.yaml
@@ -0,0 +1,171 @@
+#"server.resources": ["gpu0", "gpu1"]
+
+performance:
+  # interface: search_vectors
+  query:
+    # dataset: table name you have already created
+    # key starts with "server." need to reconfig and restart server, including use_blas_threshold/cpu_cache_capacity ..
+    [
+      # debug
+      # {
+      #   "dataset": "random_10m_1024_512_ip",
+      #   # index info
+      #   "index.index_types": ["ivf_sq8"],
+      #   "index.nlists": [16384],
+      #   "nprobes": [1],
+      #   "top_ks": [1, 2, 4, 8, 16, 32, 64, 128, 256],
+      #   "nqs": [1, 10, 100, 500, 800],
+      #   "processes": 1, # multiprocessing
+      #   "server.use_blas_threshold": 1100,
+      #   "server.cpu_cache_capacity": 16,
+      # },
+      # {
+      #   "dataset": "random_10m_1024_512_ip",
+      #   # index info
+      #   "index.index_types": ["ivf_sq8"],
+      #   "index.nlists": [16384],
+      #   "nprobes": [1],
+      #   "top_ks": [1, 2, 4, 8, 16, 32, 64, 128, 256],
+      #   "nqs": [1, 10, 100, 500, 800],
+      #   "processes": 1, # multiprocessing
+      #   "server.use_blas_threshold": 1100,
+      #   "server.cpu_cache_capacity": 16,
+      # },
+      # {
+      #   "dataset": "random_10m_1024_512_ip",
+      #   # index info
+      #   "index.index_types": ["ivf_sq8"],
+      #   "index.nlists": [16384],
+      #   "nprobes": [1],
+      #   "top_ks": [1, 2, 4, 8, 16, 32, 64, 128, 256],
+      #   "nqs": [1, 10, 100, 500, 800],
+      #   "processes": 1, # multiprocessing
+      #   # "server.use_blas_threshold": 1100,
+      #   "server.cpu_cache_capacity": 16,
+      # },
+      # {
+      #   "dataset": "random_10m_1024_512_ip",
+      #   # index info
+      #   "index.index_types": ["ivf_sq8"],
+      #   "index.nlists": [16384],
+      #   "nprobes": [1],
+      #   "top_ks": [1, 2, 4, 8, 16, 32, 64, 128, 256],
+      #   "nqs": [1, 10, 100, 500, 800],
+      #   "processes": 1, # multiprocessing
+      #   # "server.use_blas_threshold": 1100,
+      #   "server.cpu_cache_capacity": 16,
+      # },
+      # {
+      #   "dataset": "random_10m_1024_512_l2",
+      #   # index info
+      #   "index.index_types": ["ivf_sq8"],
+      #   "index.nlists": [16384],
+      #   "nprobes": [1],
+      #   "top_ks": [1, 2, 4, 8, 16, 32, 64, 128, 256],
+      #   "nqs": [1, 10, 100, 500, 800],
+      #   "processes": 1, # multiprocessing
+      #   "server.use_blas_threshold": 1100,
+      #   "server.cpu_cache_capacity": 64
+      # },
+#       {
+#        "dataset": "sift_50m_1024_128_l2",
+#        # index info
+#        "index.index_types": ["ivf_sq8"],
+#        "index.nlists": [16384],
+#        "nprobes": [1, 32, 128],
+#        "top_ks": [1, 2, 4, 8, 16, 32, 64, 128, 256],
+#        "nqs": [1, 10, 100, 500, 800],
+#        # "top_ks": [256],
+#        # "nqs": [800],
+#        "processes": 1, # multiprocessing
+#         "server.use_blas_threshold": 1100,
+#         "server.cpu_cache_capacity": 310,
+#        "server.resources": ["gpu0", "gpu1"]
+#       },
+       {
+        "dataset": "sift_1m_1024_128_l2",
+        # index info
+        "index.index_types": ["ivf_sq8"],
+        "index.nlists": [16384],
+        "nprobes": [32],
+        "top_ks": [10],
+        "nqs": [100],
+        # "top_ks": [256],
+        # "nqs": [800],
+        "processes": 1, # multiprocessing
+         "server.use_blas_threshold": 1100,
+         "server.cpu_cache_capacity": 310,
+        "server.resources": ["cpu"]
+       },
+       {
+        "dataset": "sift_1m_1024_128_l2",
+        # index info
+        "index.index_types": ["ivf_sq8"],
+        "index.nlists": [16384],
+        "nprobes": [32],
+        "top_ks": [10],
+        "nqs": [100],
+        # "top_ks": [256],
+        # "nqs": [800],
+        "processes": 1, # multiprocessing
+         "server.use_blas_threshold": 1100,
+         "server.cpu_cache_capacity": 310,
+        "server.resources": ["gpu0"]
+       },
+       {
+        "dataset": "sift_1m_1024_128_l2",
+        # index info
+        "index.index_types": ["ivf_sq8"],
+        "index.nlists": [16384],
+        "nprobes": [32],
+        "top_ks": [10],
+        "nqs": [100],
+        # "top_ks": [256],
+        # "nqs": [800],
+        "processes": 1, # multiprocessing
+         "server.use_blas_threshold": 1100,
+         "server.cpu_cache_capacity": 310,
+        "server.resources": ["gpu0", "gpu1"]
+       },
+      # {
+      #    "dataset": "sift_1b_2048_128_l2",
+      #    # index info
+      #    "index.index_types": ["ivf_sq8"],
+      #    "index.nlists": [16384],
+      #    "nprobes": [1],
+      #    "top_ks": [1, 2, 4, 8, 16, 32, 64, 128, 256],
+      #    "nqs": [1, 10, 100, 500, 800],
+      #     # "top_ks": [256],
+      #     #   "nqs": [800],
+      #    "processes": 1, # multiprocessing
+      #    "server.use_blas_threshold": 1100,
+      #    "server.cpu_cache_capacity": 310
+      # },
+#       {
+#         "dataset": "random_50m_1024_512_l2",
+#         # index info
+#         "index.index_types": ["ivf_sq8"],
+#         "index.nlists": [16384],
+#         "nprobes": [1],
+#         "top_ks": [1, 2, 4, 8, 16, 32, 64, 128, 256],
+#         "nqs": [1, 10, 100, 500, 800],
+#         # "top_ks": [256],
+#         # "nqs": [800],
+#         "processes": 1, # multiprocessing
+#         "server.use_blas_threshold": 1100,
+#         "server.cpu_cache_capacity": 128,
+#         "server.resources": ["gpu0", "gpu1"]
+#       },
+      # {
+      #   "dataset": "random_100m_1024_512_ip",
+      #   # index info
+      #   "index.index_types": ["ivf_sq8"],
+      #   "index.nlists": [16384],
+      #   "nprobes": [1],
+      #   "top_ks": [1, 2, 4, 8, 16, 32, 64, 128, 256],
+      #   "nqs": [1, 10, 100, 500, 800],
+      #   "processes": 1, # multiprocessing
+      #   "server.use_blas_threshold": 1100,
+      #   "server.cpu_cache_capacity": 256
+      # },
+    ]
\ No newline at end of file
diff --git a/tests/milvus_benchmark/utils.py b/tests/milvus_benchmark/utils.py
new file mode 100644
index 0000000000..f6522578ad
--- /dev/null
+++ b/tests/milvus_benchmark/utils.py
@@ -0,0 +1,194 @@
+# -*- coding: utf-8 -*-
+from __future__ import print_function
+
+__true_print = print  # noqa
+
+import os
+import sys
+import pdb
+import time
+import datetime
+import argparse
+import threading
+import logging
+import docker
+import multiprocessing
+import numpy
+# import psutil
+from yaml import load, dump
+import tableprint as tp
+
+logger = logging.getLogger("milvus_benchmark.utils")
+
+MULTI_DB_SLAVE_PATH = "/opt/milvus/data2;/opt/milvus/data3"
+
+
+def get_current_time():
+    return time.strftime('%Y-%m-%d %H:%M:%S', time.localtime())
+
+
+def print_table(headers, columns, data):
+    bodys = []
+    for index, value in enumerate(columns):
+        tmp = [value]
+        tmp.extend(data[index])
+        bodys.append(tmp)
+    tp.table(bodys, headers)
+
+
+def modify_config(k, v, type=None, file_path="conf/server_config.yaml", db_slave=None):
+    if not os.path.isfile(file_path):
+        raise Exception('File: %s not found' % file_path)
+    with open(file_path) as f:
+        config_dict = load(f)
+        f.close()
+    if config_dict:
+        if k.find("use_blas_threshold") != -1:
+            config_dict['engine_config']['use_blas_threshold'] = int(v)
+        elif k.find("cpu_cache_capacity") != -1:
+            config_dict['cache_config']['cpu_cache_capacity'] = int(v)
+        elif k.find("gpu_cache_capacity") != -1:
+            config_dict['cache_config']['gpu_cache_capacity'] = int(v)
+        elif k.find("resource_pool") != -1:
+            config_dict['resource_config']['resource_pool'] = v
+
+        if db_slave:
+            config_dict['db_config']['db_slave_path'] = MULTI_DB_SLAVE_PATH
+        with open(file_path, 'w') as f:
+            dump(config_dict, f, default_flow_style=False)
+        f.close()
+    else:
+        raise Exception('Load file:%s error' % file_path)
+
+
+def pull_image(image):
+    registry = image.split(":")[0]
+    image_tag = image.split(":")[1]
+    client = docker.APIClient(base_url='unix://var/run/docker.sock')
+    logger.info("Start pulling image: %s" % image)
+    return client.pull(registry, image_tag)
+
+
+def run_server(image, mem_limit=None, timeout=30, test_type="local", volume_name=None, db_slave=None):
+    import colors
+
+    client = docker.from_env()
+    # if mem_limit is None:
+    #     mem_limit = psutil.virtual_memory().available
+    # logger.info('Memory limit:', mem_limit)
+    # cpu_limit = "0-%d" % (multiprocessing.cpu_count() - 1)
+    # logger.info('Running on CPUs:', cpu_limit)
+    for dir_item in ['logs', 'db']:
+        try:
+            os.mkdir(os.path.abspath(dir_item))
+        except Exception as e:
+            pass
+
+    if test_type == "local":
+        volumes = {
+            os.path.abspath('conf'):
+                {'bind': '/opt/milvus/conf', 'mode': 'ro'},
+            os.path.abspath('logs'):
+                {'bind': '/opt/milvus/logs', 'mode': 'rw'},
+            os.path.abspath('db'):
+                {'bind': '/opt/milvus/db', 'mode': 'rw'},
+        }
+    elif test_type == "remote":
+        if volume_name is None:
+            raise Exception("No volume name")
+        remote_log_dir = volume_name+'/logs'
+        remote_db_dir = volume_name+'/db'
+
+        for dir_item in [remote_log_dir, remote_db_dir]:
+            if not os.path.isdir(dir_item):
+                os.makedirs(dir_item, exist_ok=True)
+        volumes = {
+            os.path.abspath('conf'):
+                {'bind': '/opt/milvus/conf', 'mode': 'ro'},
+            remote_log_dir:
+                {'bind': '/opt/milvus/logs', 'mode': 'rw'},
+            remote_db_dir:
+                {'bind': '/opt/milvus/db', 'mode': 'rw'}
+        }
+        # add volumes
+        if db_slave and isinstance(db_slave, int):
+            for i in range(2, db_slave+1):
+                remote_db_dir = volume_name+'/data'+str(i)
+                if not os.path.isdir(remote_db_dir):
+                    os.makedirs(remote_db_dir, exist_ok=True)
+                volumes[remote_db_dir] = {'bind': '/opt/milvus/data'+str(i), 'mode': 'rw'}
+
+    container = client.containers.run(
+        image,
+        volumes=volumes,
+        runtime="nvidia",
+        ports={'19530/tcp': 19530, '8080/tcp': 8080},
+        environment=["OMP_NUM_THREADS=48"],
+        # cpuset_cpus=cpu_limit,
+        # mem_limit=mem_limit,
+        # environment=[""],
+        detach=True)
+
+    def stream_logs():
+        for line in container.logs(stream=True):
+            logger.info(colors.color(line.decode().rstrip(), fg='blue'))
+
+    if sys.version_info >= (3, 0):
+        t = threading.Thread(target=stream_logs, daemon=True)
+    else:
+        t = threading.Thread(target=stream_logs)
+        t.daemon = True
+    t.start()
+
+    logger.info('Container: %s started' % container)
+    return container
+    # exit_code = container.wait(timeout=timeout)
+    # # Exit if exit code
+    # if exit_code == 0:
+    #     return container
+    # elif exit_code is not None:
+    #     print(colors.color(container.logs().decode(), fg='red'))
+    #     raise Exception('Child process raised exception %s' % str(exit_code))
+
+def restart_server(container):
+    client = docker.APIClient(base_url='unix://var/run/docker.sock')
+
+    client.restart(container.name)
+    logger.info('Container: %s restarted' % container.name)
+    return container
+
+
+def remove_container(container):
+    container.remove(force=True)
+    logger.info('Container: %s removed' % container)
+
+
+def remove_all_containers(image):
+    client = docker.from_env()
+    try:
+        for container in client.containers.list():
+            if image in container.image.tags:
+                container.stop(timeout=30)
+                container.remove(force=True)
+    except Exception as e:
+        logger.error("Containers removed failed")
+
+
+def container_exists(image):
+    '''
+    Check if container existed with the given image name
+    @params: image name
+    @return: container if exists
+    '''
+    res = False
+    client = docker.from_env()
+    for container in client.containers.list():
+        if image in container.image.tags:
+            # True
+            res = container
+    return res
+
+
+if __name__ == '__main__':
+    # print(pull_image('branch-0.3.1-debug'))
+    stop_server()
\ No newline at end of file
diff --git a/tests/milvus_python_test/.dockerignore b/tests/milvus_python_test/.dockerignore
new file mode 100644
index 0000000000..c97d9d043c
--- /dev/null
+++ b/tests/milvus_python_test/.dockerignore
@@ -0,0 +1,14 @@
+node_modules
+npm-debug.log
+Dockerfile*
+docker-compose*
+.dockerignore
+.git
+.gitignore
+.env
+*/bin
+*/obj
+README.md
+LICENSE
+.vscode
+__pycache__
\ No newline at end of file
diff --git a/tests/milvus_python_test/.gitignore b/tests/milvus_python_test/.gitignore
new file mode 100644
index 0000000000..9bd7345e51
--- /dev/null
+++ b/tests/milvus_python_test/.gitignore
@@ -0,0 +1,13 @@
+.python-version
+.pytest_cache
+__pycache__
+.vscode
+.idea
+
+test_out/
+*.pyc
+
+db/
+logs/
+
+.coverage
diff --git a/tests/milvus_python_test/Dockerfile b/tests/milvus_python_test/Dockerfile
new file mode 100644
index 0000000000..ec78b943dc
--- /dev/null
+++ b/tests/milvus_python_test/Dockerfile
@@ -0,0 +1,14 @@
+FROM python:3.6.8-jessie
+
+LABEL Name=megasearch_engine_test Version=0.0.1
+
+WORKDIR /app
+ADD . /app
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    libc-dev build-essential && \
+    python3 -m pip install -r requirements.txt && \
+    apt-get remove --purge -y 
+
+ENTRYPOINT [ "/app/docker-entrypoint.sh" ]
+CMD [ "start" ]
\ No newline at end of file
diff --git a/tests/milvus_python_test/MilvusCases.md b/tests/milvus_python_test/MilvusCases.md
new file mode 100644
index 0000000000..ea6372c373
--- /dev/null
+++ b/tests/milvus_python_test/MilvusCases.md
@@ -0,0 +1,143 @@
+# Milvus test cases
+
+## * Interfaces test
+
+### 1. 连接测试
+
+#### 1.1 连接
+
+| cases            | expected                                     |
+| ---------------- | -------------------------------------------- |
+| 非法IP 123.0.0.2 | method: connect raise error in given timeout |
+| 正常 uri         | attr: connected assert true                  |
+| 非法 uri         | method: connect raise error in given timeout |
+| 最大连接数       | all connection attrs: connected assert true  |
+|                  |                                              |
+
+#### 1.2 断开连接
+
+| cases                    | expected            |
+| ------------------------ | ------------------- |
+| 正常连接下，断开连接     | connect raise error |
+| 正常连接下，重复断开连接 | connect raise error |
+
+### 2. Table operation
+
+#### 2.1 表创建
+
+##### 2.1.1 表名
+
+| cases                     | expected    |
+| ------------------------- | ----------- |
+| 基础功能，参数正常        | status pass |
+| 表名已存在                | status fail |
+| 表名："中文"              | status pass |
+| 表名带特殊字符: "-39fsd-" | status pass |
+| 表名带空格: "test1 2"     | status pass |
+| invalid dim: 0            | raise error |
+| invalid dim: -1           | raise error |
+| invalid dim: 100000000    | raise error |
+| invalid dim: "string"     | raise error |
+| index_type: 0             | status pass |
+| index_type: 1             | status pass |
+| index_type: 2             | status pass |
+| index_type: string        | raise error |
+|                           |             |
+
+##### 2.1.2 维数支持
+
+| cases                 | expected    |
+| --------------------- | ----------- |
+| 维数: 0               | raise error |
+| 维数负数: -1          | raise error |
+| 维数最大值: 100000000 | raise error |
+| 维数字符串: "string"  | raise error |
+|                       |             |
+
+##### 2.1.3 索引类型支持
+
+| cases            | expected    |
+| ---------------- | ----------- |
+| 索引类型: 0      | status pass |
+| 索引类型: 1      | status pass |
+| 索引类型: 2      | status pass |
+| 索引类型: string | raise error |
+|                  |             |
+
+#### 2.2 表说明
+
+| cases                  | expected                         |
+| ---------------------- | -------------------------------- |
+| 创建表后，执行describe | 返回结构体，元素与创建表参数一致 |
+|                        |                                  |
+
+#### 2.3 表删除
+
+| cases          | expected               |
+| -------------- | ---------------------- |
+| 删除已存在表名 | has_table return False |
+| 删除不存在表名 | status fail            |
+|                |                        |
+
+#### 2.4 表是否存在
+
+| cases                   | expected     |
+| ----------------------- | ------------ |
+| 存在表，调用has_table   | assert true  |
+| 不存在表，调用has_table | assert false |
+|                         |              |
+
+#### 2.5 查询表记录条数
+
+| cases                | expected                 |
+| -------------------- | ------------------------ |
+| 空表                 | 0                        |
+| 空表插入数据（单条） | 1                        |
+| 空表插入数据（多条） | assert length of vectors |
+
+#### 2.6 查询表数量
+
+| cases                                         | expected                         |
+| --------------------------------------------- | -------------------------------- |
+| 两张表，一张空表，一张有数据：调用show tables | assert length of table list == 2 |
+|                                               |                                  |
+
+### 3. Add vectors
+
+| interfaces  | cases                                                     | expected                             |
+| ----------- | --------------------------------------------------------- | ------------------------------------ |
+| add_vectors | add basic                                                 | assert length of ids == nq           |
+|             | add vectors into table not existed                        | status fail                          |
+|             | dim not match: single vector                              | status fail                          |
+|             | dim not match: vector list                                | status fail                          |
+|             | single vector element empty                               | status fail                          |
+|             | vector list element empty                                 | status fail                          |
+|             | query immediately after adding                            | status pass                          |
+|             | query immediately after sleep 6s                          | status pass && length of result == 1 |
+|             | concurrent add with multi threads(share one connection)   | status pass                          |
+|             | concurrent add with multi threads(independent connection) | status pass                          |
+|             | concurrent add with multi process(independent connection) | status pass                          |
+|             | index_type: 2                                             | status pass                          |
+|             | index_type: string                                        | raise error                          |
+|             |                                                           |                                      |
+
+### 4. Search vectors
+
+| interfaces     | cases                                             | expected                         |
+| -------------- | ------------------------------------------------- | -------------------------------- |
+| search_vectors | search basic(query vector in vectors, top-k<nq)   | assert length of result == nq    |
+|                | search vectors into table not existed             | status fail                      |
+|                | basic top-k                                       | score of query vectors  == 100.0 |
+|                | invalid top-k: 0                                  | raise error                      |
+|                | invalid top-k: -1                                 | raise error                      |
+|                | invalid top-k: "string"                           | raise error                      |
+|                | top-k > nq                                        | assert length of result == nq    |
+|                | concurrent search                                 | status pass                      |
+|                | query_range(get_current_day(), get_current_day()) | assert length of result == nq    |
+|                | invalid query_range: ""                           | raise error                      |
+|                | query_range(get_last_day(2), get_last_day(1))     | assert length of result == 0     |
+|                | query_range(get_last_day(2), get_current_day())   | assert length of result == nq    |
+|                | query_range((get_last_day(2), get_next_day(2))    | assert length of result == nq    |
+|                | query_range((get_current_day(), get_next_day(2))  | assert length of result == nq    |
+|                | query_range(get_next_day(1), get_next_day(2))     | assert length of result == 0     |
+|                | score: vector[i] = vector[i]+-0.01                | score > 99.9                     |
\ No newline at end of file
diff --git a/tests/milvus_python_test/README.md b/tests/milvus_python_test/README.md
new file mode 100644
index 0000000000..6a87bf1ff8
--- /dev/null
+++ b/tests/milvus_python_test/README.md
@@ -0,0 +1,23 @@
+# Requirements
+* python 3.6.8+
+* pip install -r requirements.txt
+
+# How to use this Test Project
+```shell
+pytest . --level=1
+```
+or test connect function only
+
+```shell
+pytest test_connect.py --level=1
+```
+
+with allure test report
+
+ ```shell
+pytest --alluredir=test_out . -q -v
+allure serve test_out
+ ```
+# Contribution getting started
+* Follow PEP-8 for naming and black for formatting.
+
diff --git a/tests/milvus_python_test/conftest.py b/tests/milvus_python_test/conftest.py
new file mode 100644
index 0000000000..8bab824606
--- /dev/null
+++ b/tests/milvus_python_test/conftest.py
@@ -0,0 +1,132 @@
+import socket 
+import pdb
+import logging
+
+import pytest
+from utils import gen_unique_str
+from milvus import Milvus, IndexType, MetricType
+
+index_file_size = 10
+
+
+def pytest_addoption(parser):
+    parser.addoption("--ip", action="store", default="localhost")
+    parser.addoption("--port", action="store", default=19530)
+    parser.addoption("--internal", action="store", default=False)
+
+
+def check_server_connection(request):
+    ip = request.config.getoption("--ip")
+    port = request.config.getoption("--port")
+    connected = True
+    if ip and (ip not in ['localhost', '127.0.0.1']):
+        try:
+            socket.getaddrinfo(ip, port, 0, 0, socket.IPPROTO_TCP) 
+        except Exception as e:
+            print("Socket connnet failed: %s" % str(e))
+            connected = False
+    return connected
+
+
+def get_args(request):
+    args = {
+        "ip": request.config.getoption("--ip"),
+        "port": request.config.getoption("--port")
+    }
+    return args
+
+
+@pytest.fixture(scope="module")
+def connect(request):
+    ip = request.config.getoption("--ip")
+    port = request.config.getoption("--port")
+    milvus = Milvus()
+    try:
+        milvus.connect(host=ip, port=port)
+    except:
+        pytest.exit("Milvus server can not connected, exit pytest ...")
+
+    def fin():
+        try:
+            milvus.disconnect()
+        except:
+            pass
+
+    request.addfinalizer(fin)
+    return milvus
+
+
+@pytest.fixture(scope="module")
+def dis_connect(request):
+    ip = request.config.getoption("--ip")
+    port = request.config.getoption("--port")
+    milvus = Milvus()
+    milvus.connect(host=ip, port=port)
+    milvus.disconnect()
+    def fin():
+        try:
+            milvus.disconnect()
+        except:
+            pass
+
+    request.addfinalizer(fin)
+    return milvus
+
+
+@pytest.fixture(scope="module")
+def args(request):
+    ip = request.config.getoption("--ip")
+    port = request.config.getoption("--port")
+    internal = request.config.getoption("--internal")
+    args = {"ip": ip, "port": port}
+    if internal:
+        args = {"ip": ip, "port": port, "internal": internal}
+    return args
+
+
+@pytest.fixture(scope="function")
+def table(request, connect):
+    ori_table_name = getattr(request.module, "table_id", "test")
+    table_name = gen_unique_str(ori_table_name)
+    dim = getattr(request.module, "dim", "128")
+    param = {'table_name': table_name,
+             'dimension': dim,
+             'index_file_size': index_file_size,
+             'metric_type': MetricType.L2}
+    status = connect.create_table(param)
+    # logging.getLogger().info(status)
+    if not status.OK():
+        pytest.exit("Table can not be created, exit pytest ...")
+
+    def teardown():
+        status, table_names = connect.show_tables()
+        for table_name in table_names:
+            connect.delete_table(table_name)
+
+    request.addfinalizer(teardown)
+
+    return table_name
+
+
+@pytest.fixture(scope="function")
+def ip_table(request, connect):
+    ori_table_name = getattr(request.module, "table_id", "test")
+    table_name = gen_unique_str(ori_table_name)
+    dim = getattr(request.module, "dim", "128")
+    param = {'table_name': table_name,
+             'dimension': dim,
+             'index_file_size': index_file_size,
+             'metric_type': MetricType.IP}
+    status = connect.create_table(param)
+    # logging.getLogger().info(status)
+    if not status.OK():
+        pytest.exit("Table can not be created, exit pytest ...")
+
+    def teardown():
+        status, table_names = connect.show_tables()
+        for table_name in table_names:
+            connect.delete_table(table_name)
+
+    request.addfinalizer(teardown)
+
+    return table_name
\ No newline at end of file
diff --git a/tests/milvus_python_test/docker-entrypoint.sh b/tests/milvus_python_test/docker-entrypoint.sh
new file mode 100755
index 0000000000..af9ba0ba66
--- /dev/null
+++ b/tests/milvus_python_test/docker-entrypoint.sh
@@ -0,0 +1,9 @@
+#!/bin/bash
+
+set -e
+
+if [ "$1" = 'start' ]; then
+   tail -f /dev/null
+fi
+
+exec "$@"
\ No newline at end of file
diff --git a/tests/milvus_python_test/pytest.ini b/tests/milvus_python_test/pytest.ini
new file mode 100644
index 0000000000..3f95dc29b8
--- /dev/null
+++ b/tests/milvus_python_test/pytest.ini
@@ -0,0 +1,9 @@
+[pytest]
+log_format = [%(asctime)s-%(levelname)s-%(name)s]: %(message)s (%(filename)s:%(lineno)s)
+
+log_cli = true
+log_level = 20
+
+timeout = 300
+
+level = 1
\ No newline at end of file
diff --git a/tests/milvus_python_test/requirements.txt b/tests/milvus_python_test/requirements.txt
new file mode 100644
index 0000000000..4bdecd6033
--- /dev/null
+++ b/tests/milvus_python_test/requirements.txt
@@ -0,0 +1,25 @@
+astroid==2.2.5
+atomicwrites==1.3.0
+attrs==19.1.0
+importlib-metadata==0.15
+isort==4.3.20
+lazy-object-proxy==1.4.1
+mccabe==0.6.1
+more-itertools==7.0.0
+numpy==1.16.3
+pluggy==0.12.0
+py==1.8.0
+pylint==2.3.1
+pytest==4.5.0
+pytest-timeout==1.3.3
+pytest-repeat==0.8.0
+allure-pytest==2.7.0
+pytest-print==0.1.2
+pytest-level==0.1.1
+six==1.12.0
+thrift==0.11.0
+typed-ast==1.3.5
+wcwidth==0.1.7
+wrapt==1.11.1
+zipp==0.5.1
+pymilvus-test>=0.2.0
diff --git a/tests/milvus_python_test/requirements_cluster.txt b/tests/milvus_python_test/requirements_cluster.txt
new file mode 100644
index 0000000000..a1f3b69be9
--- /dev/null
+++ b/tests/milvus_python_test/requirements_cluster.txt
@@ -0,0 +1,25 @@
+astroid==2.2.5
+atomicwrites==1.3.0
+attrs==19.1.0
+importlib-metadata==0.15
+isort==4.3.20
+lazy-object-proxy==1.4.1
+mccabe==0.6.1
+more-itertools==7.0.0
+numpy==1.16.3
+pluggy==0.12.0
+py==1.8.0
+pylint==2.3.1
+pytest==4.5.0
+pytest-timeout==1.3.3
+pytest-repeat==0.8.0
+allure-pytest==2.7.0
+pytest-print==0.1.2
+pytest-level==0.1.1
+six==1.12.0
+thrift==0.11.0
+typed-ast==1.3.5
+wcwidth==0.1.7
+wrapt==1.11.1
+zipp==0.5.1
+pymilvus>=0.1.24
diff --git a/tests/milvus_python_test/requirements_no_pymilvus.txt b/tests/milvus_python_test/requirements_no_pymilvus.txt
new file mode 100644
index 0000000000..45884c0c71
--- /dev/null
+++ b/tests/milvus_python_test/requirements_no_pymilvus.txt
@@ -0,0 +1,24 @@
+astroid==2.2.5
+atomicwrites==1.3.0
+attrs==19.1.0
+importlib-metadata==0.15
+isort==4.3.20
+lazy-object-proxy==1.4.1
+mccabe==0.6.1
+more-itertools==7.0.0
+numpy==1.16.3
+pluggy==0.12.0
+py==1.8.0
+pylint==2.3.1
+pytest==4.5.0
+pytest-timeout==1.3.3
+pytest-repeat==0.8.0
+allure-pytest==2.7.0
+pytest-print==0.1.2
+pytest-level==0.1.1
+six==1.12.0
+thrift==0.11.0
+typed-ast==1.3.5
+wcwidth==0.1.7
+wrapt==1.11.1
+zipp==0.5.1
diff --git a/tests/milvus_python_test/run.sh b/tests/milvus_python_test/run.sh
new file mode 100644
index 0000000000..cee5b061f5
--- /dev/null
+++ b/tests/milvus_python_test/run.sh
@@ -0,0 +1,4 @@
+#/bin/bash
+
+
+pytest . $@
\ No newline at end of file
diff --git a/tests/milvus_python_test/test.template b/tests/milvus_python_test/test.template
new file mode 100644
index 0000000000..0403d72860
--- /dev/null
+++ b/tests/milvus_python_test/test.template
@@ -0,0 +1,41 @@
+'''
+Copyright 上海赜睿信息科技有限公司(Zilliz) - All Rights Reserved
+Unauthorized copying of this file, via any medium is strictly prohibited.
+Proprietary and confidential.
+'''
+
+'''
+Test Description:
+
+This document is only a template to show how to write a auto-test script
+
+本文档仅仅是个展示如何编写自动化测试脚本的模板
+
+'''
+
+import pytest
+from milvus import Milvus
+
+
+class TestConnection:
+    def test_connect_localhost(self):
+
+        """
+        TestCase1.1
+        Test target: This case is to check if the server can be connected.
+        Test method: Call API: milvus.connect to connect local milvus server, ip address: 127.0.0.1 and port: 19530, check the return status
+        Expectation: Return status is OK.
+
+        测试目的：本用例测试客户端是否可以与服务器建立连接
+        测试方法：调用SDK API: milvus.connect方法连接本地服务器，IP地址：127.0.0.1，端口：19530，检查调用返回状态
+        期望结果：返回状态是：OK
+
+        """
+
+        milvus = Milvus()
+        milvus.connect(host='127.0.0.1', port='19530')
+        assert milvus.connected
+
+
+
+
diff --git a/tests/milvus_python_test/test_add_vectors.py b/tests/milvus_python_test/test_add_vectors.py
new file mode 100644
index 0000000000..51c12dcd87
--- /dev/null
+++ b/tests/milvus_python_test/test_add_vectors.py
@@ -0,0 +1,1231 @@
+import time
+import random
+import pdb
+import threading
+import logging
+from multiprocessing import Pool, Process
+import pytest
+from milvus import Milvus, IndexType, MetricType
+from utils import *
+
+
+dim = 128
+index_file_size = 10
+table_id = "test_add"
+ADD_TIMEOUT = 60
+nprobe = 1
+epsilon = 0.0001
+
+index_params = random.choice(gen_index_params())
+logging.getLogger().info(index_params)
+
+
+class TestAddBase:
+    """
+    ******************************************************************
+      The following cases are used to test `add_vectors / index / search / delete` mixed function
+    ******************************************************************
+    """
+
+    def test_add_vector_create_table(self, connect, table):
+        '''
+        target: test add vector, then create table again
+        method: add vector and create table
+        expected: status not ok
+        '''
+        vector = gen_single_vector(dim)
+        status, ids = connect.add_vectors(table, vector)
+        param = {'table_name': table,
+                 'dimension': dim,
+                 'index_file_size': index_file_size,
+                 'metric_type': MetricType.L2}
+        status = connect.create_table(param)
+        assert not status.OK()
+
+    def test_add_vector_has_table(self, connect, table):
+        '''
+        target: test add vector, then check table existence
+        method: add vector and call HasTable
+        expected: table exists, status ok
+        '''
+        vector = gen_single_vector(dim)
+        status, ids = connect.add_vectors(table, vector)
+        assert assert_has_table(connect, table)
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_delete_table_add_vector(self, connect, table):
+        '''
+        target: test add vector after table deleted
+        method: delete table and add vector
+        expected: status not ok
+        '''
+        status = connect.delete_table(table)
+        vector = gen_single_vector(dim)
+        status, ids = connect.add_vectors(table, vector)
+        assert not status.OK()
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_delete_table_add_vector_another(self, connect, table):
+        '''
+        target: test add vector to table_1 after table_2 deleted
+        method: delete table_2 and add vector to table_1
+        expected: status ok
+        '''
+        param = {'table_name': 'test_delete_table_add_vector_another',
+                 'dimension': dim,
+                 'index_file_size': index_file_size,
+                 'metric_type': MetricType.L2}
+        status = connect.create_table(param)
+        status = connect.delete_table(table)
+        vector = gen_single_vector(dim)
+        status, ids = connect.add_vectors(param['table_name'], vector)
+        connect.delete_table(param['table_name'])
+        assert status.OK()
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_add_vector_delete_table(self, connect, table):
+        '''
+        target: test delete table after add vector
+        method: add vector and delete table
+        expected: status ok
+        '''
+        vector = gen_single_vector(dim)
+        status, ids = connect.add_vectors(table, vector)
+        status = connect.delete_table(table)
+        assert status.OK()
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_add_vector_delete_another_table(self, connect, table):
+        '''
+        target: test delete table_1 table after add vector to table_2
+        method: add vector and delete table
+        expected: status ok
+        '''
+        param = {'table_name': 'test_add_vector_delete_another_table',
+                 'dimension': dim,
+                 'index_file_size': index_file_size,
+                 'metric_type': MetricType.L2}
+        status = connect.create_table(param)
+        vector = gen_single_vector(dim)
+        status, ids = connect.add_vectors(table, vector)
+        status = connect.delete_table(param['table_name'])
+        assert status.OK()
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_add_vector_sleep_delete_table(self, connect, table):
+        '''
+        target: test delete table after add vector for a while
+        method: add vector, sleep, and delete table
+        expected: status ok
+        '''
+        vector = gen_single_vector(dim)
+        status, ids = connect.add_vectors(table, vector)
+        time.sleep(1)
+        status = connect.delete_table(table)
+        assert status.OK()
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_add_vector_sleep_delete_another_table(self, connect, table):
+        '''
+        target: test delete table_1 table after add vector to table_2 for a while
+        method: add vector , sleep, and delete table
+        expected: status ok
+        '''
+        param = {'table_name': 'test_add_vector_sleep_delete_another_table',
+                 'dimension': dim,
+                 'index_file_size': index_file_size,
+                 'metric_type': MetricType.L2}
+        status = connect.create_table(param)
+        vector = gen_single_vector(dim)
+        status, ids = connect.add_vectors(table, vector)
+        time.sleep(1)
+        status = connect.delete_table(param['table_name'])
+        assert status.OK()
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_create_index_add_vector(self, connect, table):
+        '''
+        target: test add vector after build index
+        method: build index and add vector
+        expected: status ok
+        '''
+        status = connect.create_index(table, index_params)
+        vector = gen_single_vector(dim)
+        status, ids = connect.add_vectors(table, vector)
+        assert status.OK()
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_create_index_add_vector_another(self, connect, table):
+        '''
+        target: test add vector to table_2 after build index for table_1
+        method: build index and add vector
+        expected: status ok
+        '''
+        param = {'table_name': 'test_create_index_add_vector_another',
+                 'dimension': dim,
+                 'index_file_size': index_file_size,
+                 'metric_type': MetricType.L2}
+        status = connect.create_table(param)
+        status = connect.create_index(table, index_params)
+        vector = gen_single_vector(dim)
+        status, ids = connect.add_vectors(table, vector)
+        connect.delete_table(param['table_name'])
+        assert status.OK()
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_add_vector_create_index(self, connect, table):
+        '''
+        target: test build index add after vector
+        method: add vector and build index
+        expected: status ok
+        '''
+        vector = gen_single_vector(dim)
+        status, ids = connect.add_vectors(table, vector)
+        status = connect.create_index(table, index_params)
+        assert status.OK()
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_add_vector_create_index_another(self, connect, table):
+        '''
+        target: test add vector to table_2 after build index for table_1
+        method: build index and add vector
+        expected: status ok
+        '''
+        param = {'table_name': 'test_add_vector_create_index_another',
+                 'dimension': dim,
+                 'index_file_size': index_file_size,
+                 'metric_type': MetricType.L2}
+        status = connect.create_table(param)
+        vector = gen_single_vector(dim)
+        status, ids = connect.add_vectors(table, vector)
+        status = connect.create_index(param['table_name'], index_params)
+        connect.delete_table(param['table_name'])
+        assert status.OK()
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_add_vector_sleep_create_index(self, connect, table):
+        '''
+        target: test build index add after vector for a while
+        method: add vector and build index
+        expected: status ok
+        '''
+        vector = gen_single_vector(dim)
+        status, ids = connect.add_vectors(table, vector)
+        time.sleep(1)
+        status = connect.create_index(table, index_params)
+        assert status.OK()
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_add_vector_sleep_create_index_another(self, connect, table):
+        '''
+        target: test add vector to table_2 after build index for table_1 for a while
+        method: build index and add vector
+        expected: status ok
+        '''
+        param = {'table_name': 'test_add_vector_sleep_create_index_another',
+                 'dimension': dim,
+                 'index_file_size': index_file_size,
+                 'metric_type': MetricType.L2}
+        status = connect.create_table(param)
+        vector = gen_single_vector(dim)
+        status, ids = connect.add_vectors(table, vector)
+        time.sleep(1)
+        status = connect.create_index(param['table_name'], index_params)
+        connect.delete_table(param['table_name'])
+        assert status.OK()
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_search_vector_add_vector(self, connect, table):
+        '''
+        target: test add vector after search table
+        method: search table and add vector
+        expected: status ok
+        '''
+        vector = gen_single_vector(dim)
+        status, result = connect.search_vectors(table, 1, nprobe, vector)
+        status, ids = connect.add_vectors(table, vector)
+        assert status.OK()
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_search_vector_add_vector_another(self, connect, table):
+        '''
+        target: test add vector to table_1 after search table_2
+        method: search table and add vector
+        expected: status ok
+        '''
+        param = {'table_name': 'test_search_vector_add_vector_another',
+                 'dimension': dim,
+                 'index_file_size': index_file_size,
+                 'metric_type': MetricType.L2}
+        status = connect.create_table(param)
+        vector = gen_single_vector(dim)
+        status, result = connect.search_vectors(table, 1, nprobe, vector)
+        status, ids = connect.add_vectors(param['table_name'], vector)
+        connect.delete_table(param['table_name'])
+        assert status.OK()
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_add_vector_search_vector(self, connect, table):
+        '''
+        target: test search vector after add vector
+        method: add vector and search table
+        expected: status ok
+        '''
+        vector = gen_single_vector(dim)
+        status, ids = connect.add_vectors(table, vector)
+        status, result = connect.search_vectors(table, 1, nprobe, vector)
+        assert status.OK()
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_add_vector_search_vector_another(self, connect, table):
+        '''
+        target: test add vector to table_1 after search table_2
+        method: search table and add vector
+        expected: status ok
+        '''
+        param = {'table_name': 'test_add_vector_search_vector_another',
+                 'dimension': dim,
+                 'index_file_size': index_file_size,
+                 'metric_type': MetricType.L2}
+        status = connect.create_table(param)
+        vector = gen_single_vector(dim)
+        status, ids = connect.add_vectors(table, vector)
+        status, result = connect.search_vectors(param['table_name'], 1, nprobe, vector)
+        connect.delete_table(param['table_name'])
+        assert status.OK()
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_add_vector_sleep_search_vector(self, connect, table):
+        '''
+        target: test search vector after add vector after a while
+        method: add vector, sleep, and search table
+        expected: status ok
+        '''
+        vector = gen_single_vector(dim)
+        status, ids = connect.add_vectors(table, vector)
+        time.sleep(1)
+        status, result = connect.search_vectors(table, 1, nprobe, vector)
+        assert status.OK()
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_add_vector_sleep_search_vector_another(self, connect, table):
+        '''
+        target: test add vector to table_1 after search table_2 a while
+        method: search table , sleep, and add vector
+        expected: status ok
+        '''
+        param = {'table_name': 'test_add_vector_sleep_search_vector_another',
+                 'dimension': dim,
+                 'index_file_size': index_file_size,
+                 'metric_type': MetricType.L2}
+        status = connect.create_table(param)
+        vector = gen_single_vector(dim)
+        status, ids = connect.add_vectors(table, vector)
+        time.sleep(1)
+        status, result = connect.search_vectors(param['table_name'], 1, nprobe, vector)
+        connect.delete_table(param['table_name'])
+        assert status.OK()
+
+    """
+    ******************************************************************
+      The following cases are used to test `add_vectors` function
+    ******************************************************************
+    """
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_add_vectors_ids(self, connect, table):
+        '''
+        target: test add vectors in table, use customize ids
+        method: create table and add vectors in it, check the ids returned and the table length after vectors added
+        expected: the length of ids and the table row count
+        '''
+        nq = 5; top_k = 1; nprobe = 1
+        vectors = gen_vectors(nq, dim)
+        ids = [i for i in range(nq)]
+        status, ids = connect.add_vectors(table, vectors, ids)
+        time.sleep(2)
+        assert status.OK()
+        assert len(ids) == nq
+        # check search result
+        status, result = connect.search_vectors(table, top_k, nprobe, vectors)
+        logging.getLogger().info(result)
+        assert len(result) == nq
+        for i in range(nq):
+            assert result[i][0].id == i
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_add_vectors_twice_ids_no_ids(self, connect, table):
+        '''
+        target: check the result of add_vectors, with params ids and no ids
+        method: test add vectors twice, use customize ids first, and then use no ids
+        expected: status not OK 
+        '''
+        nq = 5; top_k = 1; nprobe = 1
+        vectors = gen_vectors(nq, dim)
+        ids = [i for i in range(nq)]
+        status, ids = connect.add_vectors(table, vectors, ids)
+        assert status.OK()
+        status, ids = connect.add_vectors(table, vectors)
+        logging.getLogger().info(status)
+        logging.getLogger().info(ids)
+        assert not status.OK()
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_add_vectors_twice_not_ids_ids(self, connect, table):
+        '''
+        target: check the result of add_vectors, with params ids and no ids
+        method: test add vectors twice, use not ids first, and then use customize ids
+        expected: status not OK 
+        '''
+        nq = 5; top_k = 1; nprobe = 1
+        vectors = gen_vectors(nq, dim)
+        ids = [i for i in range(nq)]
+        status, ids = connect.add_vectors(table, vectors)
+        assert status.OK()
+        status, ids = connect.add_vectors(table, vectors, ids)
+        logging.getLogger().info(status)
+        logging.getLogger().info(ids)
+        assert not status.OK()
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_add_vectors_ids_length_not_match(self, connect, table):
+        '''
+        target: test add vectors in table, use customize ids, len(ids) != len(vectors)
+        method: create table and add vectors in it
+        expected: raise an exception
+        '''
+        nq = 5
+        vectors = gen_vectors(nq, dim)
+        ids = [i for i in range(1, nq)]
+        with pytest.raises(Exception) as e:
+            status, ids = connect.add_vectors(table, vectors, ids)
+
+    @pytest.fixture(
+        scope="function",
+        params=gen_invalid_vector_ids()
+    )
+    def get_vector_id(self, request):
+        yield request.param
+
+    def test_add_vectors_ids_invalid(self, connect, table, get_vector_id):
+        '''
+        target: test add vectors in table, use customize ids, which are not int64
+        method: create table and add vectors in it
+        expected: raise an exception
+        '''
+        nq = 5
+        vectors = gen_vectors(nq, dim)
+        vector_id = get_vector_id
+        ids = [vector_id for i in range(nq)]
+        with pytest.raises(Exception) as e:
+            status, ids = connect.add_vectors(table, vectors, ids)
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_add_vectors(self, connect, table):
+        '''
+        target: test add vectors in table created before
+        method: create table and add vectors in it, check the ids returned and the table length after vectors added
+        expected: the length of ids and the table row count
+        '''
+        nq = 5
+        vectors = gen_vectors(nq, dim)
+        status, ids = connect.add_vectors(table, vectors)
+        assert status.OK()
+        assert len(ids) == nq
+
+    @pytest.mark.level(2)
+    def test_add_vectors_without_connect(self, dis_connect, table):
+        '''
+        target: test add vectors without connection
+        method: create table and add vectors in it, check if added successfully
+        expected: raise exception
+        '''
+        nq = 5
+        vectors = gen_vectors(nq, dim)
+        with pytest.raises(Exception) as e:
+            status, ids = dis_connect.add_vectors(table, vectors)
+
+    def test_add_table_not_existed(self, connect):
+        '''
+        target: test add vectors in table, which not existed before
+        method: add vectors table not existed, check the status
+        expected: status not ok
+        '''
+        nq = 5
+        vector = gen_single_vector(dim)
+        status, ids = connect.add_vectors(gen_unique_str("not_exist_table"), vector)
+        assert not status.OK()
+        assert not ids
+
+    def test_add_vector_dim_not_matched(self, connect, table):
+        '''
+        target: test add vector, the vector dimension is not equal to the table dimension
+        method: the vector dimension is half of the table dimension, check the status
+        expected: status not ok
+        '''
+        vector = gen_single_vector(int(dim)//2)
+        status, ids = connect.add_vectors(table, vector)
+        assert not status.OK()
+
+    def test_add_vectors_dim_not_matched(self, connect, table):
+        '''
+        target: test add vectors, the vector dimension is not equal to the table dimension
+        method: the vectors dimension is half of the table dimension, check the status
+        expected: status not ok
+        '''
+        nq = 5
+        vectors = gen_vectors(nq, int(dim)//2)
+        status, ids = connect.add_vectors(table, vectors)
+        assert not status.OK()
+
+    def test_add_vector_query_after_sleep(self, connect, table):
+        '''
+        target: test add vectors, and search it after sleep
+        method: set vector[0][1] as query vectors
+        expected: status ok and result length is 1
+        '''
+        nq = 5
+        vectors = gen_vectors(nq, dim)
+        status, ids = connect.add_vectors(table, vectors)
+        time.sleep(3)
+        status, result = connect.search_vectors(table, 1, nprobe, [vectors[0]])
+        assert status.OK()
+        assert len(result) == 1
+
+    # @pytest.mark.repeat(5)
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def _test_add_vector_multi_threading(self, connect, table):
+        '''
+        target: test add vectors, with multi threading
+        method: 10 thread add vectors concurrently
+        expected: status ok and result length is equal to the length off added vectors
+        '''
+        thread_num = 4
+        loops = 100
+        threads = []
+        total_ids = []
+        vector = gen_single_vector(dim)
+        def add():
+            i = 0
+            while i < loops:
+                status, ids = connect.add_vectors(table, vector)
+                total_ids.append(ids[0])
+                i = i + 1
+        for i in range(thread_num):
+            x = threading.Thread(target=add, args=())
+            threads.append(x)
+            x.start()
+            time.sleep(0.2)
+        for th in threads:
+            th.join()
+        assert len(total_ids) == thread_num * loops
+        # make sure ids not the same
+        assert len(set(total_ids)) == thread_num * loops
+
+    # TODO: enable
+    # @pytest.mark.repeat(5)
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def _test_add_vector_with_multiprocessing(self, args):
+        '''
+        target: test add vectors, with multi processes
+        method: 10 processed add vectors concurrently
+        expected: status ok and result length is equal to the length off added vectors
+        '''
+        table = gen_unique_str("test_add_vector_with_multiprocessing")
+        uri = "tcp://%s:%s" % (args["ip"], args["port"])
+        param = {'table_name': table,
+                 'dimension': dim,
+                 'index_file_size': index_file_size}
+        # create table
+        milvus = Milvus()
+        milvus.connect(uri=uri)
+        milvus.create_table(param)
+        vector = gen_single_vector(dim)
+
+        process_num = 4
+        loop_num = 10
+        processes = []
+        # with dependent connection
+        def add(milvus):
+            i = 0
+            while i < loop_num:
+                status, ids = milvus.add_vectors(table, vector)
+                i = i + 1
+        for i in range(process_num):
+            milvus = Milvus()
+            milvus.connect(uri=uri)
+            p = Process(target=add, args=(milvus,))
+            processes.append(p)
+            p.start()
+            time.sleep(0.2)
+        for p in processes:
+            p.join()
+        time.sleep(3)
+        status, count = milvus.get_table_row_count(table)
+        assert count == process_num * loop_num
+
+    def test_add_vector_multi_tables(self, connect):
+        '''
+        target: test add vectors is correct or not with multiple tables of L2
+        method: create 50 tables and add vectors into them in turn
+        expected: status ok
+        '''
+        nq = 100
+        vectors = gen_vectors(nq, dim)
+        table_list = []
+        for i in range(50):
+            table_name = gen_unique_str('test_add_vector_multi_tables')
+            table_list.append(table_name)
+            param = {'table_name': table_name,
+                     'dimension': dim,
+                     'index_file_size': index_file_size,
+                     'metric_type': MetricType.L2}
+            connect.create_table(param)
+        time.sleep(2)
+        for j in range(10):
+            for i in range(50):
+                status, ids = connect.add_vectors(table_name=table_list[i], records=vectors)
+                assert status.OK()
+
+class TestAddIP:
+    """
+    ******************************************************************
+      The following cases are used to test `add_vectors / index / search / delete` mixed function
+    ******************************************************************
+    """
+
+    def test_add_vector_create_table(self, connect, ip_table):
+        '''
+        target: test add vector, then create table again
+        method: add vector and create table
+        expected: status not ok
+        '''
+        vector = gen_single_vector(dim)
+        status, ids = connect.add_vectors(ip_table, vector)
+        param = {'table_name': ip_table,
+                 'dimension': dim,
+                 'index_file_size': index_file_size,
+                 'metric_type': MetricType.L2}
+        status = connect.create_table(param)
+        assert not status.OK()
+
+    def test_add_vector_has_table(self, connect, ip_table):
+        '''
+        target: test add vector, then check table existence
+        method: add vector and call HasTable
+        expected: table exists, status ok
+        '''
+        vector = gen_single_vector(dim)
+        status, ids = connect.add_vectors(ip_table, vector)
+        assert assert_has_table(connect, ip_table)
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_delete_table_add_vector(self, connect, ip_table):
+        '''
+        target: test add vector after table deleted
+        method: delete table and add vector
+        expected: status not ok
+        '''
+        status = connect.delete_table(ip_table)
+        vector = gen_single_vector(dim)
+        status, ids = connect.add_vectors(ip_table, vector)
+        assert not status.OK()
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_delete_table_add_vector_another(self, connect, ip_table):
+        '''
+        target: test add vector to table_1 after table_2 deleted
+        method: delete table_2 and add vector to table_1
+        expected: status ok
+        '''
+        param = {'table_name': 'test_delete_table_add_vector_another',
+                 'dimension': dim,
+                 'index_file_size': index_file_size,
+                 'metric_type': MetricType.L2}
+        status = connect.create_table(param)
+        status = connect.delete_table(ip_table)
+        vector = gen_single_vector(dim)
+        status, ids = connect.add_vectors(param['table_name'], vector)
+        connect.delete_table(param['table_name'])
+        assert status.OK()
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_add_vector_delete_table(self, connect, ip_table):
+        '''
+        target: test delete table after add vector
+        method: add vector and delete table
+        expected: status ok
+        '''
+        vector = gen_single_vector(dim)
+        status, ids = connect.add_vectors(ip_table, vector)
+        status = connect.delete_table(ip_table)
+        assert status.OK()
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_add_vector_delete_another_table(self, connect, ip_table):
+        '''
+        target: test delete table_1 table after add vector to table_2
+        method: add vector and delete table
+        expected: status ok
+        '''
+        param = {'table_name': 'test_add_vector_delete_another_table',
+                 'dimension': dim,
+                 'index_file_size': index_file_size,
+                 'metric_type': MetricType.L2}
+        status = connect.create_table(param)
+        vector = gen_single_vector(dim)
+        status, ids = connect.add_vectors(ip_table, vector)
+        status = connect.delete_table(param['table_name'])
+        assert status.OK()
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_add_vector_sleep_delete_table(self, connect, ip_table):
+        '''
+        target: test delete table after add vector for a while
+        method: add vector, sleep, and delete table
+        expected: status ok
+        '''
+        vector = gen_single_vector(dim)
+        status, ids = connect.add_vectors(ip_table, vector)
+        time.sleep(1)
+        status = connect.delete_table(ip_table)
+        assert status.OK()
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_add_vector_sleep_delete_another_table(self, connect, ip_table):
+        '''
+        target: test delete table_1 table after add vector to table_2 for a while
+        method: add vector , sleep, and delete table
+        expected: status ok
+        '''
+        param = {'table_name': 'test_add_vector_sleep_delete_another_table',
+                 'dimension': dim,
+                 'index_file_size': index_file_size,
+                 'metric_type': MetricType.L2}
+        status = connect.create_table(param)
+        vector = gen_single_vector(dim)
+        status, ids = connect.add_vectors(ip_table, vector)
+        time.sleep(1)
+        status = connect.delete_table(param['table_name'])
+        assert status.OK()
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_create_index_add_vector(self, connect, ip_table):
+        '''
+        target: test add vector after build index
+        method: build index and add vector
+        expected: status ok
+        '''
+        status = connect.create_index(ip_table, index_params)
+        vector = gen_single_vector(dim)
+        status, ids = connect.add_vectors(ip_table, vector)
+        assert status.OK()
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_create_index_add_vector_another(self, connect, ip_table):
+        '''
+        target: test add vector to table_2 after build index for table_1
+        method: build index and add vector
+        expected: status ok
+        '''
+        param = {'table_name': 'test_create_index_add_vector_another',
+                 'dimension': dim,
+                 'index_file_size': index_file_size,
+                 'metric_type': MetricType.L2}
+        status = connect.create_table(param)
+        status = connect.create_index(ip_table, index_params)
+        vector = gen_single_vector(dim)
+        status, ids = connect.add_vectors(ip_table, vector)
+        connect.delete_table(param['table_name'])
+        assert status.OK()
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_add_vector_create_index(self, connect, ip_table):
+        '''
+        target: test build index add after vector
+        method: add vector and build index
+        expected: status ok
+        '''
+        vector = gen_single_vector(dim)
+        status, ids = connect.add_vectors(ip_table, vector)
+        status = connect.create_index(ip_table, index_params)
+        assert status.OK()
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_add_vector_create_index_another(self, connect, ip_table):
+        '''
+        target: test add vector to table_2 after build index for table_1
+        method: build index and add vector
+        expected: status ok
+        '''
+        param = {'table_name': 'test_add_vector_create_index_another',
+                 'dimension': dim,
+                 'index_file_size': index_file_size,
+                 'metric_type': MetricType.L2}
+        status = connect.create_table(param)
+        vector = gen_single_vector(dim)
+        status, ids = connect.add_vectors(ip_table, vector)
+        status = connect.create_index(param['table_name'], index_params)
+        connect.delete_table(param['table_name'])
+        assert status.OK()
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_add_vector_sleep_create_index(self, connect, ip_table):
+        '''
+        target: test build index add after vector for a while
+        method: add vector and build index
+        expected: status ok
+        '''
+        vector = gen_single_vector(dim)
+        status, ids = connect.add_vectors(ip_table, vector)
+        time.sleep(1)
+        status = connect.create_index(ip_table, index_params)
+        assert status.OK()
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_add_vector_sleep_create_index_another(self, connect, ip_table):
+        '''
+        target: test add vector to table_2 after build index for table_1 for a while
+        method: build index and add vector
+        expected: status ok
+        '''
+        param = {'table_name': 'test_add_vector_sleep_create_index_another',
+                 'dimension': dim,
+                 'index_file_size': index_file_size,
+                 'metric_type': MetricType.L2}
+        status = connect.create_table(param)
+        vector = gen_single_vector(dim)
+        status, ids = connect.add_vectors(ip_table, vector)
+        time.sleep(1)
+        status = connect.create_index(param['table_name'], index_params)
+        connect.delete_table(param['table_name'])
+        assert status.OK()
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_search_vector_add_vector(self, connect, ip_table):
+        '''
+        target: test add vector after search table
+        method: search table and add vector
+        expected: status ok
+        '''
+        vector = gen_single_vector(dim)
+        status, result = connect.search_vectors(ip_table, 1, nprobe, vector)
+        status, ids = connect.add_vectors(ip_table, vector)
+        assert status.OK()
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_search_vector_add_vector_another(self, connect, ip_table):
+        '''
+        target: test add vector to table_1 after search table_2
+        method: search table and add vector
+        expected: status ok
+        '''
+        param = {'table_name': 'test_search_vector_add_vector_another',
+                 'dimension': dim,
+                 'index_file_size': index_file_size,
+                 'metric_type': MetricType.L2}
+        status = connect.create_table(param)
+        vector = gen_single_vector(dim)
+        status, result = connect.search_vectors(ip_table, 1, nprobe, vector)
+        status, ids = connect.add_vectors(param['table_name'], vector)
+        connect.delete_table(param['table_name'])
+        assert status.OK()
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_add_vector_search_vector(self, connect, ip_table):
+        '''
+        target: test search vector after add vector
+        method: add vector and search table
+        expected: status ok
+        '''
+        vector = gen_single_vector(dim)
+        status, ids = connect.add_vectors(ip_table, vector)
+        status, result = connect.search_vectors(ip_table, 1, nprobe, vector)
+        assert status.OK()
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_add_vector_search_vector_another(self, connect, ip_table):
+        '''
+        target: test add vector to table_1 after search table_2
+        method: search table and add vector
+        expected: status ok
+        '''
+        param = {'table_name': 'test_add_vector_search_vector_another',
+                 'dimension': dim,
+                 'index_file_size': index_file_size,
+                 'metric_type': MetricType.L2}
+        status = connect.create_table(param)
+        vector = gen_single_vector(dim)
+        status, ids = connect.add_vectors(ip_table, vector)
+        status, result = connect.search_vectors(param['table_name'], 1, nprobe, vector)
+        connect.delete_table(param['table_name'])
+        assert status.OK()
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_add_vector_sleep_search_vector(self, connect, ip_table):
+        '''
+        target: test search vector after add vector after a while
+        method: add vector, sleep, and search table
+        expected: status ok
+        '''
+        vector = gen_single_vector(dim)
+        status, ids = connect.add_vectors(ip_table, vector)
+        time.sleep(1)
+        status, result = connect.search_vectors(ip_table, 1, nprobe, vector)
+        assert status.OK()
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_add_vector_sleep_search_vector_another(self, connect, ip_table):
+        '''
+        target: test add vector to table_1 after search table_2 a while
+        method: search table , sleep, and add vector
+        expected: status ok
+        '''
+        param = {'table_name': 'test_add_vector_sleep_search_vector_another',
+                 'dimension': dim,
+                 'index_file_size': index_file_size,
+                 'metric_type': MetricType.L2}
+        status = connect.create_table(param)
+        vector = gen_single_vector(dim)
+        status, ids = connect.add_vectors(ip_table, vector)
+        time.sleep(1)
+        status, result = connect.search_vectors(param['table_name'], 1, nprobe, vector)
+        connect.delete_table(param['table_name'])
+        assert status.OK()
+
+    """
+    ******************************************************************
+      The following cases are used to test `add_vectors` function
+    ******************************************************************
+    """
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_add_vectors_ids(self, connect, ip_table):
+        '''
+        target: test add vectors in table, use customize ids
+        method: create table and add vectors in it, check the ids returned and the table length after vectors added
+        expected: the length of ids and the table row count
+        '''
+        nq = 5; top_k = 1; nprobe = 1
+        vectors = gen_vectors(nq, dim)
+        ids = [i for i in range(nq)]
+        status, ids = connect.add_vectors(ip_table, vectors, ids)
+        time.sleep(2)
+        assert status.OK()
+        assert len(ids) == nq
+        # check search result
+        status, result = connect.search_vectors(ip_table, top_k, nprobe, vectors)
+        logging.getLogger().info(result)
+        assert len(result) == nq
+        for i in range(nq):
+            assert result[i][0].id == i
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_add_vectors_twice_ids_no_ids(self, connect, ip_table):
+        '''
+        target: check the result of add_vectors, with params ids and no ids
+        method: test add vectors twice, use customize ids first, and then use no ids
+        expected: status not OK 
+        '''
+        nq = 5; top_k = 1; nprobe = 1
+        vectors = gen_vectors(nq, dim)
+        ids = [i for i in range(nq)]
+        status, ids = connect.add_vectors(ip_table, vectors, ids)
+        assert status.OK()
+        status, ids = connect.add_vectors(ip_table, vectors)
+        logging.getLogger().info(status)
+        logging.getLogger().info(ids)
+        assert not status.OK()
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_add_vectors_twice_not_ids_ids(self, connect, ip_table):
+        '''
+        target: check the result of add_vectors, with params ids and no ids
+        method: test add vectors twice, use not ids first, and then use customize ids
+        expected: status not OK 
+        '''
+        nq = 5; top_k = 1; nprobe = 1
+        vectors = gen_vectors(nq, dim)
+        ids = [i for i in range(nq)]
+        status, ids = connect.add_vectors(ip_table, vectors)
+        assert status.OK()
+        status, ids = connect.add_vectors(ip_table, vectors, ids)
+        logging.getLogger().info(status)
+        logging.getLogger().info(ids)
+        assert not status.OK()
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_add_vectors_ids_length_not_match(self, connect, ip_table):
+        '''
+        target: test add vectors in table, use customize ids, len(ids) != len(vectors)
+        method: create table and add vectors in it
+        expected: raise an exception
+        '''
+        nq = 5
+        vectors = gen_vectors(nq, dim)
+        ids = [i for i in range(1, nq)]
+        with pytest.raises(Exception) as e:
+            status, ids = connect.add_vectors(ip_table, vectors, ids)
+
+    @pytest.fixture(
+        scope="function",
+        params=gen_invalid_vector_ids()
+    )
+    def get_vector_id(self, request):
+        yield request.param
+
+    def test_add_vectors_ids_invalid(self, connect, ip_table, get_vector_id):
+        '''
+        target: test add vectors in table, use customize ids, which are not int64
+        method: create table and add vectors in it
+        expected: raise an exception
+        '''
+        nq = 5
+        vectors = gen_vectors(nq, dim)
+        vector_id = get_vector_id
+        ids = [vector_id for i in range(nq)]
+        with pytest.raises(Exception) as e:
+            status, ids = connect.add_vectors(ip_table, vectors, ids)
+
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def test_add_vectors(self, connect, ip_table):
+        '''
+        target: test add vectors in table created before
+        method: create table and add vectors in it, check the ids returned and the table length after vectors added
+        expected: the length of ids and the table row count
+        '''
+        nq = 5
+        vectors = gen_vectors(nq, dim)
+        status, ids = connect.add_vectors(ip_table, vectors)
+        assert status.OK()
+        assert len(ids) == nq
+
+    @pytest.mark.level(2)
+    def test_add_vectors_without_connect(self, dis_connect, ip_table):
+        '''
+        target: test add vectors without connection
+        method: create table and add vectors in it, check if added successfully
+        expected: raise exception
+        '''
+        nq = 5
+        vectors = gen_vectors(nq, dim)
+        with pytest.raises(Exception) as e:
+            status, ids = dis_connect.add_vectors(ip_table, vectors)
+
+    def test_add_vector_dim_not_matched(self, connect, ip_table):
+        '''
+        target: test add vector, the vector dimension is not equal to the table dimension
+        method: the vector dimension is half of the table dimension, check the status
+        expected: status not ok
+        '''
+        vector = gen_single_vector(int(dim)//2)
+        status, ids = connect.add_vectors(ip_table, vector)
+        assert not status.OK()
+
+    def test_add_vectors_dim_not_matched(self, connect, ip_table):
+        '''
+        target: test add vectors, the vector dimension is not equal to the table dimension
+        method: the vectors dimension is half of the table dimension, check the status
+        expected: status not ok
+        '''
+        nq = 5
+        vectors = gen_vectors(nq, int(dim)//2)
+        status, ids = connect.add_vectors(ip_table, vectors)
+        assert not status.OK()
+
+    def test_add_vector_query_after_sleep(self, connect, ip_table):
+        '''
+        target: test add vectors, and search it after sleep
+        method: set vector[0][1] as query vectors
+        expected: status ok and result length is 1
+        '''
+        nq = 5
+        vectors = gen_vectors(nq, dim)
+        status, ids = connect.add_vectors(ip_table, vectors)
+        time.sleep(3)
+        status, result = connect.search_vectors(ip_table, 1, nprobe, [vectors[0]])
+        assert status.OK()
+        assert len(result) == 1
+
+    # @pytest.mark.repeat(5)
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def _test_add_vector_multi_threading(self, connect, ip_table):
+        '''
+        target: test add vectors, with multi threading
+        method: 10 thread add vectors concurrently
+        expected: status ok and result length is equal to the length off added vectors
+        '''
+        thread_num = 4
+        loops = 100
+        threads = []
+        total_ids = []
+        vector = gen_single_vector(dim)
+        def add():
+            i = 0
+            while i < loops:
+                status, ids = connect.add_vectors(ip_table, vector)
+                total_ids.append(ids[0])
+                i = i + 1
+        for i in range(thread_num):
+            x = threading.Thread(target=add, args=())
+            threads.append(x)
+            x.start()
+            time.sleep(0.2)
+        for th in threads:
+            th.join()
+        assert len(total_ids) == thread_num * loops
+        # make sure ids not the same
+        assert len(set(total_ids)) == thread_num * loops
+
+    # TODO: enable
+    # @pytest.mark.repeat(5)
+    @pytest.mark.timeout(ADD_TIMEOUT)
+    def _test_add_vector_with_multiprocessing(self, args):
+        '''
+        target: test add vectors, with multi processes
+        method: 10 processed add vectors concurrently
+        expected: status ok and result length is equal to the length off added vectors
+        '''
+        table = gen_unique_str("test_add_vector_with_multiprocessing")
+        uri = "tcp://%s:%s" % (args["ip"], args["port"])
+        param = {'table_name': table,
+                 'dimension': dim,
+                 'index_file_size': index_file_size}
+        # create table
+        milvus = Milvus()
+        milvus.connect(uri=uri)
+        milvus.create_table(param)
+        vector = gen_single_vector(dim)
+
+        process_num = 4
+        loop_num = 10
+        processes = []
+        # with dependent connection
+        def add(milvus):
+            i = 0
+            while i < loop_num:
+                status, ids = milvus.add_vectors(table, vector)
+                i = i + 1
+        for i in range(process_num):
+            milvus = Milvus()
+            milvus.connect(uri=uri)
+            p = Process(target=add, args=(milvus,))
+            processes.append(p)
+            p.start()
+            time.sleep(0.2)
+        for p in processes:
+            p.join()
+        time.sleep(3)
+        status, count = milvus.get_table_row_count(table)
+        assert count == process_num * loop_num
+
+    def test_add_vector_multi_tables(self, connect):
+        '''
+        target: test add vectors is correct or not with multiple tables of IP
+        method: create 50 tables and add vectors into them in turn
+        expected: status ok
+        '''
+        nq = 100
+        vectors = gen_vectors(nq, dim)
+        table_list = []
+        for i in range(50):
+            table_name = gen_unique_str('test_add_vector_multi_tables')
+            table_list.append(table_name)
+            param = {'table_name': table_name,
+                     'dimension': dim,
+                     'index_file_size': index_file_size,
+                     'metric_type': MetricType.IP}
+            connect.create_table(param)
+        time.sleep(2)
+        for j in range(10):
+            for i in range(50):
+                status, ids = connect.add_vectors(table_name=table_list[i], records=vectors)
+                assert status.OK()
+
+class TestAddAdvance:
+
+    @pytest.fixture(
+        scope="function",
+        params=[
+            1,
+            10,
+            100,
+            1000,
+            pytest.param(5000 - 1, marks=pytest.mark.xfail),
+            pytest.param(5000, marks=pytest.mark.xfail),
+            pytest.param(5000 + 1, marks=pytest.mark.xfail),
+        ],
+    )
+    def insert_count(self, request):
+        yield request.param
+
+    def test_insert_much(self, connect, table, insert_count):
+        '''
+        target: test add vectors with different length of vectors
+        method: set different vectors as add method params
+        expected: length of ids is equal to the length of vectors
+        '''
+        nb = insert_count
+        insert_vec_list = gen_vectors(nb, dim)
+        status, ids = connect.add_vectors(table, insert_vec_list)
+        assert len(ids) == nb
+        assert status.OK()
+
+    def test_insert_much_ip(self, connect, ip_table, insert_count):
+        '''
+        target: test add vectors with different length of vectors
+        method: set different vectors as add method params
+        expected: length of ids is equal to the length of vectors
+        '''
+        nb = insert_count
+        insert_vec_list = gen_vectors(nb, dim)
+        status, ids = connect.add_vectors(ip_table, insert_vec_list)
+        assert len(ids) == nb
+        assert status.OK()
+
+class TestAddTableNameInvalid(object):
+    """
+    Test adding vectors with invalid table names
+    """
+    @pytest.fixture(
+        scope="function",
+        params=gen_invalid_table_names()
+    )
+    def get_table_name(self, request):
+        yield request.param
+
+    @pytest.mark.level(2)
+    def test_add_vectors_with_invalid_tablename(self, connect, get_table_name):
+        table_name = get_table_name
+        vectors = gen_vectors(1, dim)
+        status, result = connect.add_vectors(table_name, vectors)
+        assert not status.OK()
+
+
+class TestAddTableVectorsInvalid(object):
+    single_vector = gen_single_vector(dim)
+    vectors = gen_vectors(2, dim)
+
+    """
+    Test adding vectors with invalid vectors
+    """
+    @pytest.fixture(
+        scope="function",
+        params=gen_invalid_vectors()
+    )
+    def gen_vector(self, request):
+        yield request.param
+
+    @pytest.mark.level(2)
+    def test_add_vector_with_invalid_vectors(self, connect, table, gen_vector):
+        tmp_single_vector = copy.deepcopy(self.single_vector)
+        tmp_single_vector[0][1] = gen_vector
+        with pytest.raises(Exception) as e:
+            status, result = connect.add_vectors(table, tmp_single_vector)
+
+    @pytest.mark.level(1)
+    def test_add_vectors_with_invalid_vectors(self, connect, table, gen_vector):
+        tmp_vectors = copy.deepcopy(self.vectors)
+        tmp_vectors[1][1] = gen_vector
+        with pytest.raises(Exception) as e:
+            status, result = connect.add_vectors(table, tmp_vectors)
\ No newline at end of file
diff --git a/tests/milvus_python_test/test_connect.py b/tests/milvus_python_test/test_connect.py
new file mode 100644
index 0000000000..5ec9539011
--- /dev/null
+++ b/tests/milvus_python_test/test_connect.py
@@ -0,0 +1,386 @@
+import pytest
+from milvus import Milvus
+import pdb
+import threading
+from multiprocessing import Process
+from utils import *
+
+__version__ = '0.5.0'
+CONNECT_TIMEOUT = 12
+
+
+class TestConnect:
+
+    def local_ip(self, args):
+        '''
+        check if ip is localhost or not
+        '''
+        if not args["ip"] or args["ip"] == 'localhost' or args["ip"] == "127.0.0.1":
+            return True
+        else:
+            return False
+
+    def test_disconnect(self, connect):
+        '''
+        target: test disconnect
+        method: disconnect a connected client
+        expected: connect failed after disconnected
+        '''
+        res = connect.disconnect()
+        assert res.OK()
+        with pytest.raises(Exception) as e:
+            res = connect.server_version()
+
+    def test_disconnect_repeatedly(self, connect, args):
+        '''
+        target: test disconnect repeatedly
+        method: disconnect a connected client, disconnect again
+        expected: raise an error after disconnected
+        '''
+        if not connect.connected():
+            milvus = Milvus()
+            uri_value = "tcp://%s:%s" % (args["ip"], args["port"])
+            milvus.connect(uri=uri_value)
+            res = milvus.disconnect()
+            with pytest.raises(Exception) as e:
+                res = milvus.disconnect()
+        else:
+            res = connect.disconnect()
+            with pytest.raises(Exception) as e:
+                res = connect.disconnect()
+
+    def test_connect_correct_ip_port(self, args):
+        '''
+        target: test connect with corrent ip and port value
+        method: set correct ip and port
+        expected: connected is True        
+        '''
+        milvus = Milvus()
+        milvus.connect(host=args["ip"], port=args["port"])
+        assert milvus.connected()
+
+    def test_connect_connected(self, args):
+        '''
+        target: test connect and disconnect with corrent ip and port value, assert connected value
+        method: set correct ip and port
+        expected: connected is False        
+        '''
+        milvus = Milvus()
+        milvus.connect(host=args["ip"], port=args["port"])
+        milvus.disconnect()
+        assert not milvus.connected()
+
+    # TODO: Currently we test with remote IP, localhost testing need to add
+    def _test_connect_ip_localhost(self, args):
+        '''
+        target: test connect with ip value: localhost
+        method: set host localhost
+        expected: connected is True
+        '''
+        milvus = Milvus()
+        milvus.connect(host='localhost', port=args["port"])
+        assert milvus.connected()
+
+    @pytest.mark.timeout(CONNECT_TIMEOUT)
+    def test_connect_wrong_ip_null(self, args):
+        '''
+        target: test connect with wrong ip value
+        method: set host null
+        expected: not use default ip, connected is False
+        '''
+        milvus = Milvus()
+        ip = ""
+        with pytest.raises(Exception) as e:
+            milvus.connect(host=ip, port=args["port"], timeout=1)
+        assert not milvus.connected()
+
+    def test_connect_uri(self, args):
+        '''
+        target: test connect with correct uri
+        method: uri format and value are both correct
+        expected: connected is True        
+        '''
+        milvus = Milvus()
+        uri_value = "tcp://%s:%s" % (args["ip"], args["port"])
+        milvus.connect(uri=uri_value)
+        assert milvus.connected()
+
+    def test_connect_uri_null(self, args):
+        '''
+        target: test connect with null uri
+        method: uri set null
+        expected: connected is True        
+        '''
+        milvus = Milvus()
+        uri_value = ""
+        
+        if self.local_ip(args):
+            milvus.connect(uri=uri_value, timeout=1)
+            assert milvus.connected()
+        else:
+            with pytest.raises(Exception) as e:
+                milvus.connect(uri=uri_value, timeout=1)
+            assert not milvus.connected()
+
+    @pytest.mark.level(2)
+    @pytest.mark.timeout(CONNECT_TIMEOUT)
+    def test_connect_wrong_uri_wrong_port_null(self, args):
+        '''
+        target: test uri connect with port value wouldn't connected
+        method: set uri port null
+        expected: connected is True        
+        '''
+        milvus = Milvus()
+        uri_value = "tcp://%s:" % args["ip"]
+        with pytest.raises(Exception) as e:
+            milvus.connect(uri=uri_value, timeout=1)
+
+    @pytest.mark.level(2)
+    @pytest.mark.timeout(CONNECT_TIMEOUT)
+    def test_connect_wrong_uri_wrong_ip_null(self, args):
+        '''
+        target: test uri connect with ip value wouldn't connected
+        method: set uri ip null
+        expected: connected is True        
+        '''
+        milvus = Milvus()
+        uri_value = "tcp://:%s" % args["port"]
+        
+        with pytest.raises(Exception) as e:
+            milvus.connect(uri=uri_value, timeout=1)
+        assert not milvus.connected()
+
+    # TODO: enable
+    def _test_connect_with_multiprocess(self, args):
+        '''
+        target: test uri connect with multiprocess
+        method: set correct uri, test with multiprocessing connecting
+        expected: all connection is connected        
+        '''
+        uri_value = "tcp://%s:%s" % (args["ip"], args["port"])
+        process_num = 4
+        processes = []
+
+        def connect(milvus):
+            milvus.connect(uri=uri_value)
+            with pytest.raises(Exception) as e:
+                milvus.connect(uri=uri_value)
+            assert milvus.connected()
+
+        for i in range(process_num):
+            milvus = Milvus()
+            p = Process(target=connect, args=(milvus, ))
+            processes.append(p)
+            p.start()
+        for p in processes:
+            p.join()
+
+    def test_connect_repeatedly(self, args):
+        '''
+        target: test connect repeatedly
+        method: connect again
+        expected: status.code is 0, and status.message shows have connected already
+        '''
+        milvus = Milvus()
+        uri_value = "tcp://%s:%s" % (args["ip"], args["port"])
+        milvus.connect(uri=uri_value)
+        
+        milvus.connect(uri=uri_value)
+        assert milvus.connected()
+
+    def test_connect_disconnect_repeatedly_once(self, args):
+        '''
+        target: test connect and disconnect repeatedly
+        method: disconnect, and then connect, assert connect status
+        expected: status.code is 0
+        '''
+        milvus = Milvus()
+        uri_value = "tcp://%s:%s" % (args["ip"], args["port"])
+        milvus.connect(uri=uri_value)
+        
+        milvus.disconnect()
+        milvus.connect(uri=uri_value)
+        assert milvus.connected()
+
+    def test_connect_disconnect_repeatedly_times(self, args):
+        '''
+        target: test connect and disconnect for 10 times repeatedly
+        method: disconnect, and then connect, assert connect status
+        expected: status.code is 0
+        '''
+        times = 10
+        milvus = Milvus()
+        uri_value = "tcp://%s:%s" % (args["ip"], args["port"])
+        milvus.connect(uri=uri_value)
+        for i in range(times):
+            milvus.disconnect()
+            milvus.connect(uri=uri_value)
+        assert milvus.connected()
+
+    # TODO: enable
+    def _test_connect_disconnect_with_multiprocess(self, args):
+        '''
+        target: test uri connect and disconnect repeatly with multiprocess
+        method: set correct uri, test with multiprocessing connecting and disconnecting
+        expected: all connection is connected after 10 times operation       
+        '''
+        uri_value = "tcp://%s:%s" % (args["ip"], args["port"])
+        process_num = 4
+        processes = []
+
+        def connect(milvus):
+            milvus.connect(uri=uri_value)
+            milvus.disconnect()
+            milvus.connect(uri=uri_value)
+            assert milvus.connected()
+
+        for i in range(process_num):
+            milvus = Milvus()
+            p = Process(target=connect, args=(milvus, ))
+            processes.append(p)
+            p.start()
+        for p in processes:
+            p.join()
+
+    def test_connect_param_priority_no_port(self, args):
+        '''
+        target: both host_ip_port / uri are both given, if port is null, use the uri params
+        method: port set "", check if wrong uri connection is ok
+        expected: connect raise an exception and connected is false
+        '''
+        milvus = Milvus()
+        uri_value = "tcp://%s:19540" % args["ip"]
+        milvus.connect(host=args["ip"], port="", uri=uri_value)
+        assert milvus.connected()
+
+    def test_connect_param_priority_uri(self, args):
+        '''
+        target: both host_ip_port / uri are both given, if host is null, use the uri params
+        method: host set "", check if correct uri connection is ok
+        expected: connected is False
+        '''
+        milvus = Milvus()
+        uri_value = "tcp://%s:%s" % (args["ip"], args["port"])
+        with pytest.raises(Exception) as e:
+            milvus.connect(host="", port=args["port"], uri=uri_value, timeout=1)
+        assert not milvus.connected()
+
+    def test_connect_param_priority_both_hostip_uri(self, args):
+        '''
+        target: both host_ip_port / uri are both given, and not null, use the uri params
+        method: check if wrong uri connection is ok
+        expected: connect raise an exception and connected is false
+        '''
+        milvus = Milvus()
+        uri_value = "tcp://%s:%s" % (args["ip"], args["port"])
+        with pytest.raises(Exception) as e:
+            milvus.connect(host=args["ip"], port=19540, uri=uri_value, timeout=1)
+        assert not milvus.connected()
+
+    def _test_add_vector_and_disconnect_concurrently(self):
+        '''
+        Target: test disconnect in the middle of add vectors
+        Method:
+            a. use coroutine or multi-processing, to simulate network crashing
+            b. data_set not too large incase disconnection happens when data is underd-preparing
+            c. data_set not too small incase disconnection happens when data has already been transferred
+            d. make sure disconnection happens when data is in-transport
+        Expected: Failure, get_table_row_count == 0
+
+        '''
+        pass
+
+    def _test_search_vector_and_disconnect_concurrently(self):
+        '''
+        Target: Test disconnect in the middle of search vectors(with large nq and topk)multiple times, and search/add vectors still work
+        Method:
+            a. coroutine or multi-processing, to simulate network crashing
+            b. connect, search and disconnect,  repeating many times
+            c. connect and search, add vectors
+        Expected: Successfully searched back, successfully added
+
+        '''
+        pass
+
+    def _test_thread_safe_with_one_connection_shared_in_multi_threads(self):
+       '''
+        Target: test 1 connection thread safe
+        Method: 1 connection shared in multi-threads, all adding vectors, or other things
+        Expected: Functional as one thread
+
+       '''
+       pass
+
+
+class TestConnectIPInvalid(object):
+    """
+    Test connect server with invalid ip
+    """
+    @pytest.fixture(
+        scope="function",
+        params=gen_invalid_ips()
+    )
+    def get_invalid_ip(self, request):
+        yield request.param
+
+    @pytest.mark.level(2)
+    @pytest.mark.timeout(CONNECT_TIMEOUT)
+    def test_connect_with_invalid_ip(self, args, get_invalid_ip):
+        milvus = Milvus()
+        ip = get_invalid_ip
+        with pytest.raises(Exception) as e:
+            milvus.connect(host=ip, port=args["port"], timeout=1)
+        assert not milvus.connected()
+
+
+class TestConnectPortInvalid(object):
+    """
+    Test connect server with invalid ip
+    """
+
+    @pytest.fixture(
+        scope="function",
+        params=gen_invalid_ports()
+    )
+    def get_invalid_port(self, request):
+        yield request.param
+
+    @pytest.mark.level(2)
+    @pytest.mark.timeout(CONNECT_TIMEOUT)
+    def test_connect_with_invalid_port(self, args, get_invalid_port):
+        '''
+        target: test ip:port connect with invalid port value
+        method: set port in gen_invalid_ports
+        expected: connected is False        
+        '''
+        milvus = Milvus()
+        port = get_invalid_port
+        with pytest.raises(Exception) as e:
+            milvus.connect(host=args["ip"], port=port, timeout=1)
+        assert not milvus.connected()
+
+
+class TestConnectURIInvalid(object):
+    """
+    Test connect server with invalid uri
+    """
+    @pytest.fixture(
+        scope="function",
+        params=gen_invalid_uris()
+    )
+    def get_invalid_uri(self, request):
+        yield request.param
+
+    @pytest.mark.level(2)
+    @pytest.mark.timeout(CONNECT_TIMEOUT)
+    def test_connect_with_invalid_uri(self, get_invalid_uri):
+        '''
+        target: test uri connect with invalid uri value
+        method: set port in gen_invalid_uris
+        expected: connected is False        
+        '''
+        milvus = Milvus()
+        uri_value = get_invalid_uri
+        with pytest.raises(Exception) as e:
+            milvus.connect(uri=uri_value, timeout=1)
+        assert not milvus.connected()
diff --git a/tests/milvus_python_test/test_delete_vectors.py b/tests/milvus_python_test/test_delete_vectors.py
new file mode 100644
index 0000000000..57ab76770f
--- /dev/null
+++ b/tests/milvus_python_test/test_delete_vectors.py
@@ -0,0 +1,425 @@
+# import time
+# import random
+# import pdb
+# import logging
+# import threading
+# from builtins import Exception
+# from multiprocessing import Pool, Process
+# import pytest
+
+# from milvus import Milvus, IndexType
+# from utils import *
+
+
+# dim = 128
+# index_file_size = 10
+# table_id = "test_delete"
+# DELETE_TIMEOUT = 60
+# vectors = gen_vectors(100, dim)
+
+# class TestDeleteVectorsBase:
+#     """
+#     generate invalid query range params
+#     """
+#     @pytest.fixture(
+#         scope="function",
+#         params=[
+#             (get_current_day(), get_current_day()),
+#             (get_last_day(1), get_last_day(1)),
+#             (get_next_day(1), get_next_day(1))
+#         ]
+#     )
+#     def get_invalid_range(self, request):
+#         yield request.param
+
+#     @pytest.mark.timeout(DELETE_TIMEOUT)
+#     def test_delete_vectors_invalid_range(self, connect, table, get_invalid_range):
+#         '''
+#         target: test delete vectors, no index created
+#         method: call `delete_vectors_by_range`, with invalid date params
+#         expected: return code 0
+#         '''
+#         start_date = get_invalid_range[0]
+#         end_date = get_invalid_range[1]
+#         status, ids = connect.add_vectors(table, vectors)
+#         status = connect.delete_vectors_by_range(table, start_date, end_date)
+#         assert not status.OK()
+
+#     """
+#     generate valid query range params, no search result
+#     """
+#     @pytest.fixture(
+#         scope="function",
+#         params=[
+#             (get_last_day(2), get_last_day(1)),
+#             (get_last_day(2), get_current_day()),
+#             (get_next_day(1), get_next_day(2))
+#         ]
+#     )
+#     def get_valid_range_no_result(self, request):
+#         yield request.param
+
+#     @pytest.mark.timeout(DELETE_TIMEOUT)
+#     def test_delete_vectors_valid_range_no_result(self, connect, table, get_valid_range_no_result):
+#         '''
+#         target: test delete vectors, no index created
+#         method: call `delete_vectors_by_range`, with valid date params
+#         expected: return code 0
+#         '''
+#         start_date = get_valid_range_no_result[0]
+#         end_date = get_valid_range_no_result[1]
+#         status, ids = connect.add_vectors(table, vectors)
+#         time.sleep(2)
+#         status = connect.delete_vectors_by_range(table, start_date, end_date)
+#         assert status.OK()
+#         status, result = connect.get_table_row_count(table)
+#         assert result == 100
+
+#     """
+#     generate valid query range params, no search result
+#     """
+#     @pytest.fixture(
+#         scope="function",
+#         params=[
+#             (get_last_day(2), get_next_day(2)),
+#             (get_current_day(), get_next_day(2)),
+#         ]
+#     )
+#     def get_valid_range(self, request):
+#         yield request.param
+
+#     @pytest.mark.timeout(DELETE_TIMEOUT)
+#     def test_delete_vectors_valid_range(self, connect, table, get_valid_range):
+#         '''
+#         target: test delete vectors, no index created
+#         method: call `delete_vectors_by_range`, with valid date params
+#         expected: return code 0
+#         '''
+#         start_date = get_valid_range[0]
+#         end_date = get_valid_range[1]
+#         status, ids = connect.add_vectors(table, vectors)
+#         time.sleep(2)
+#         status = connect.delete_vectors_by_range(table, start_date, end_date)
+#         assert status.OK()
+#         status, result = connect.get_table_row_count(table)
+#         assert result == 0
+
+#     @pytest.fixture(
+#         scope="function",
+#         params=gen_index_params()
+#     )
+#     def get_index_params(self, request, args):
+#         if "internal" not in args:
+#             if request.param["index_type"] == IndexType.IVF_SQ8H:
+#                 pytest.skip("sq8h not support in open source")
+#         return request.param
+
+#     @pytest.mark.timeout(DELETE_TIMEOUT)
+#     def test_delete_vectors_valid_range_index_created(self, connect, table, get_index_params):
+#         '''
+#         target: test delete vectors, no index created
+#         method: call `delete_vectors_by_range`, with valid date params
+#         expected: return code 0
+#         '''
+#         start_date = get_current_day()
+#         end_date = get_next_day(2)
+#         index_params = get_index_params
+#         logging.getLogger().info(index_params)
+#         status, ids = connect.add_vectors(table, vectors)
+#         status = connect.create_index(table, index_params)
+#         logging.getLogger().info(status)
+#         logging.getLogger().info("Start delete vectors by range: %s:%s" % (start_date, end_date))
+#         status = connect.delete_vectors_by_range(table, start_date, end_date)
+#         assert status.OK()
+#         status, result = connect.get_table_row_count(table)
+#         assert result == 0
+
+#     @pytest.mark.timeout(DELETE_TIMEOUT)
+#     def test_delete_vectors_no_data(self, connect, table):
+#         '''
+#         target: test delete vectors, no index created
+#         method: call `delete_vectors_by_range`, with valid date params, and no data in db
+#         expected: return code 0
+#         '''
+#         start_date = get_current_day()
+#         end_date = get_next_day(2)
+#         # status, ids = connect.add_vectors(table, vectors)
+#         status = connect.delete_vectors_by_range(table, start_date, end_date)
+#         assert status.OK()
+
+#     @pytest.mark.timeout(DELETE_TIMEOUT)
+#     def test_delete_vectors_table_not_existed(self, connect):
+#         '''
+#         target: test delete vectors, table not existed in db
+#         method: call `delete_vectors_by_range`, with table not existed
+#         expected: return code not 0
+#         '''
+#         start_date = get_current_day()
+#         end_date = get_next_day(2)
+#         table_name = gen_unique_str("not_existed_table")
+#         status = connect.delete_vectors_by_range(table_name, start_date, end_date)
+#         assert not status.OK()
+
+#     @pytest.mark.timeout(DELETE_TIMEOUT)
+#     def test_delete_vectors_table_None(self, connect, table):
+#         '''
+#         target: test delete vectors, table set Nope
+#         method: call `delete_vectors_by_range`, with table value is None
+#         expected: return code not 0
+#         '''
+#         start_date = get_current_day()
+#         end_date = get_next_day(2)
+#         table_name = None
+#         with pytest.raises(Exception) as e:
+#             status = connect.delete_vectors_by_range(table_name, start_date, end_date)
+
+#     @pytest.mark.timeout(DELETE_TIMEOUT)
+#     def test_delete_vectors_valid_range_multi_tables(self, connect, get_valid_range):
+#         '''
+#         target: test delete vectors is correct or not with multiple tables of L2
+#         method: create 50 tables and add vectors into them , then delete vectors
+#                 in valid range
+#         expected: return code 0
+#         '''
+#         nq = 100
+#         vectors = gen_vectors(nq, dim)
+#         table_list = []
+#         for i in range(50):
+#             table_name = gen_unique_str('test_delete_vectors_valid_range_multi_tables')
+#             table_list.append(table_name)
+#             param = {'table_name': table_name,
+#                      'dimension': dim,
+#                      'index_file_size': index_file_size,
+#                      'metric_type': MetricType.L2}
+#             connect.create_table(param)
+#             status, ids = connect.add_vectors(table_name=table_name, records=vectors)
+#         time.sleep(2)
+#         start_date = get_valid_range[0]
+#         end_date = get_valid_range[1]
+#         for i in range(50):
+#             status = connect.delete_vectors_by_range(table_list[i], start_date, end_date)
+#             assert status.OK()
+#             status, result = connect.get_table_row_count(table_list[i])
+#             assert result == 0
+
+
+# class TestDeleteVectorsIP:
+#     """
+#     generate invalid query range params
+#     """
+#     @pytest.fixture(
+#         scope="function",
+#         params=[
+#             (get_current_day(), get_current_day()),
+#             (get_last_day(1), get_last_day(1)),
+#             (get_next_day(1), get_next_day(1))
+#         ]
+#     )
+#     def get_invalid_range(self, request):
+#         yield request.param
+
+#     @pytest.mark.timeout(DELETE_TIMEOUT)
+#     def test_delete_vectors_invalid_range(self, connect, ip_table, get_invalid_range):
+#         '''
+#         target: test delete vectors, no index created
+#         method: call `delete_vectors_by_range`, with invalid date params
+#         expected: return code 0
+#         '''
+#         start_date = get_invalid_range[0]
+#         end_date = get_invalid_range[1]
+#         status, ids = connect.add_vectors(ip_table, vectors)
+#         status = connect.delete_vectors_by_range(ip_table, start_date, end_date)
+#         assert not status.OK()
+
+#     """
+#     generate valid query range params, no search result
+#     """
+#     @pytest.fixture(
+#         scope="function",
+#         params=[
+#             (get_last_day(2), get_last_day(1)),
+#             (get_last_day(2), get_current_day()),
+#             (get_next_day(1), get_next_day(2))
+#         ]
+#     )
+#     def get_valid_range_no_result(self, request):
+#         yield request.param
+
+#     @pytest.mark.timeout(DELETE_TIMEOUT)
+#     def test_delete_vectors_valid_range_no_result(self, connect, ip_table, get_valid_range_no_result):
+#         '''
+#         target: test delete vectors, no index created
+#         method: call `delete_vectors_by_range`, with valid date params
+#         expected: return code 0
+#         '''
+#         start_date = get_valid_range_no_result[0]
+#         end_date = get_valid_range_no_result[1]
+#         status, ids = connect.add_vectors(ip_table, vectors)
+#         time.sleep(2)
+#         status = connect.delete_vectors_by_range(ip_table, start_date, end_date)
+#         assert status.OK()
+#         status, result = connect.get_table_row_count(ip_table)
+#         assert result == 100
+
+#     """
+#     generate valid query range params, no search result
+#     """
+#     @pytest.fixture(
+#         scope="function",
+#         params=[
+#             (get_last_day(2), get_next_day(2)),
+#             (get_current_day(), get_next_day(2)),
+#         ]
+#     )
+#     def get_valid_range(self, request):
+#         yield request.param
+
+#     @pytest.mark.timeout(DELETE_TIMEOUT)
+#     def test_delete_vectors_valid_range(self, connect, ip_table, get_valid_range):
+#         '''
+#         target: test delete vectors, no index created
+#         method: call `delete_vectors_by_range`, with valid date params
+#         expected: return code 0
+#         '''
+#         start_date = get_valid_range[0]
+#         end_date = get_valid_range[1]
+#         status, ids = connect.add_vectors(ip_table, vectors)
+#         time.sleep(2)
+#         status = connect.delete_vectors_by_range(ip_table, start_date, end_date)
+#         assert status.OK()
+#         status, result = connect.get_table_row_count(ip_table)
+#         assert result == 0
+
+#     @pytest.fixture(
+#         scope="function",
+#         params=gen_index_params()
+#     )
+#     def get_index_params(self, request, args):
+#         if "internal" not in args:
+#             if request.param["index_type"] == IndexType.IVF_SQ8H:
+#                 pytest.skip("sq8h not support in open source")
+#         return request.param
+
+#     @pytest.mark.timeout(DELETE_TIMEOUT)
+#     def test_delete_vectors_valid_range_index_created(self, connect, ip_table, get_index_params):
+#         '''
+#         target: test delete vectors, no index created
+#         method: call `delete_vectors_by_range`, with valid date params
+#         expected: return code 0
+#         '''
+#         start_date = get_current_day()
+#         end_date = get_next_day(2)
+#         index_params = get_index_params
+#         logging.getLogger().info(index_params)
+#         status, ids = connect.add_vectors(ip_table, vectors)
+#         status = connect.create_index(ip_table, index_params)
+#         logging.getLogger().info(status)
+#         logging.getLogger().info("Start delete vectors by range: %s:%s" % (start_date, end_date))
+#         status = connect.delete_vectors_by_range(ip_table, start_date, end_date)
+#         assert status.OK()
+#         status, result = connect.get_table_row_count(ip_table)
+#         assert result == 0
+
+#     @pytest.mark.timeout(DELETE_TIMEOUT)
+#     def test_delete_vectors_no_data(self, connect, ip_table):
+#         '''
+#         target: test delete vectors, no index created
+#         method: call `delete_vectors_by_range`, with valid date params, and no data in db
+#         expected: return code 0
+#         '''
+#         start_date = get_current_day()
+#         end_date = get_next_day(2)
+#         # status, ids = connect.add_vectors(table, vectors)
+#         status = connect.delete_vectors_by_range(ip_table, start_date, end_date)
+#         assert status.OK()
+
+#     @pytest.mark.timeout(DELETE_TIMEOUT)
+#     def test_delete_vectors_table_None(self, connect, ip_table):
+#         '''
+#         target: test delete vectors, table set Nope
+#         method: call `delete_vectors_by_range`, with table value is None
+#         expected: return code not 0
+#         '''
+#         start_date = get_current_day()
+#         end_date = get_next_day(2)
+#         table_name = None
+#         with pytest.raises(Exception) as e:
+#             status = connect.delete_vectors_by_range(table_name, start_date, end_date)
+
+#     @pytest.mark.timeout(DELETE_TIMEOUT)
+#     def test_delete_vectors_valid_range_multi_tables(self, connect, get_valid_range):
+#         '''
+#         target: test delete vectors is correct or not with multiple tables of IP
+#         method: create 50 tables and add vectors into them , then delete vectors
+#                 in valid range
+#         expected: return code 0
+#         '''
+#         nq = 100
+#         vectors = gen_vectors(nq, dim)
+#         table_list = []
+#         for i in range(50):
+#             table_name = gen_unique_str('test_delete_vectors_valid_range_multi_tables')
+#             table_list.append(table_name)
+#             param = {'table_name': table_name,
+#                      'dimension': dim,
+#                      'index_file_size': index_file_size,
+#                      'metric_type': MetricType.IP}
+#             connect.create_table(param)
+#             status, ids = connect.add_vectors(table_name=table_name, records=vectors)
+#         time.sleep(2)
+#         start_date = get_valid_range[0]
+#         end_date = get_valid_range[1]
+#         for i in range(50):
+#             status = connect.delete_vectors_by_range(table_list[i], start_date, end_date)
+#             assert status.OK()
+#             status, result = connect.get_table_row_count(table_list[i])
+#             assert result == 0
+
+# class TestDeleteVectorsParamsInvalid:
+
+#     """
+#     Test search table with invalid table names
+#     """
+#     @pytest.fixture(
+#         scope="function",
+#         params=gen_invalid_table_names()
+#     )
+#     def get_table_name(self, request):
+#         yield request.param
+
+#     @pytest.mark.level(2)
+#     def test_delete_vectors_table_invalid_name(self, connect, get_table_name):
+#         '''
+#         '''
+#         start_date = get_current_day()
+#         end_date = get_next_day(2)
+#         table_name = get_table_name
+#         logging.getLogger().info(table_name)
+#         top_k = 1
+#         nprobe = 1 
+#         status = connect.delete_vectors_by_range(table_name, start_date, end_date)
+#         assert not status.OK()
+
+#     """
+#     Test search table with invalid query ranges
+#     """
+#     @pytest.fixture(
+#         scope="function",
+#         params=gen_invalid_query_ranges()
+#     )
+#     def get_query_ranges(self, request):
+#         yield request.param
+
+#     @pytest.mark.timeout(DELETE_TIMEOUT)
+#     def test_delete_vectors_range_invalid(self, connect, table, get_query_ranges):
+#         '''
+#         target: test search fuction, with the wrong query_range
+#         method: search with query_range
+#         expected: raise an error, and the connection is normal
+#         '''
+#         start_date = get_query_ranges[0][0]
+#         end_date = get_query_ranges[0][1]
+#         status, ids = connect.add_vectors(table, vectors)
+#         logging.getLogger().info(get_query_ranges)
+#         with pytest.raises(Exception) as e:
+#             status = connect.delete_vectors_by_range(table, start_date, end_date)
\ No newline at end of file
diff --git a/tests/milvus_python_test/test_index.py b/tests/milvus_python_test/test_index.py
new file mode 100644
index 0000000000..435a547855
--- /dev/null
+++ b/tests/milvus_python_test/test_index.py
@@ -0,0 +1,972 @@
+"""
+   For testing index operations, including `create_index`, `describe_index` and `drop_index` interfaces
+"""
+import logging
+import pytest
+import time
+import pdb
+import threading
+from multiprocessing import Pool, Process
+import numpy
+from milvus import Milvus, IndexType, MetricType
+from utils import *
+
+nb = 100000
+dim = 128
+index_file_size = 10
+vectors = gen_vectors(nb, dim)
+vectors /= numpy.linalg.norm(vectors)
+vectors = vectors.tolist()
+BUILD_TIMEOUT = 60
+nprobe = 1
+
+
+class TestIndexBase:
+    @pytest.fixture(
+        scope="function",
+        params=gen_index_params()
+    )
+    def get_index_params(self, request, args):
+        if "internal" not in args:
+            if request.param["index_type"] == IndexType.IVF_SQ8H:
+                pytest.skip("sq8h not support in open source")
+        return request.param
+
+    @pytest.fixture(
+        scope="function",
+        params=gen_simple_index_params()
+    )
+    def get_simple_index_params(self, request):
+        yield request.param
+
+    """
+    ******************************************************************
+      The following cases are used to test `create_index` function
+    ******************************************************************
+    """
+
+    @pytest.mark.timeout(BUILD_TIMEOUT)
+    def test_create_index(self, connect, table, get_index_params):
+        '''
+        target: test create index interface
+        method: create table and add vectors in it, create index
+        expected: return code equals to 0, and search success
+        '''
+        index_params = get_index_params
+        logging.getLogger().info(index_params)
+        status, ids = connect.add_vectors(table, vectors)
+        status = connect.create_index(table, index_params)
+        assert status.OK()
+
+    @pytest.mark.level(2)
+    def test_create_index_without_connect(self, dis_connect, table):
+        '''
+        target: test create index without connection
+        method: create table and add vectors in it, check if added successfully
+        expected: raise exception
+        '''
+        with pytest.raises(Exception) as e:
+            status = dis_connect.create_index(table, random.choice(gen_index_params()))
+
+    @pytest.mark.timeout(BUILD_TIMEOUT)
+    def test_create_index_search_with_query_vectors(self, connect, table, get_index_params):
+        '''
+        target: test create index interface, search with more query vectors
+        method: create table and add vectors in it, create index
+        expected: return code equals to 0, and search success
+        '''
+        index_params = get_index_params
+        logging.getLogger().info(index_params)
+        status, ids = connect.add_vectors(table, vectors)
+        status = connect.create_index(table, index_params)
+        logging.getLogger().info(connect.describe_index(table))
+        query_vecs = [vectors[0], vectors[1], vectors[2]]
+        top_k = 5
+        status, result = connect.search_vectors(table, top_k, nprobe, query_vecs)
+        assert status.OK()
+        assert len(result) == len(query_vecs)
+        logging.getLogger().info(result)
+
+    # TODO: enable
+    @pytest.mark.timeout(BUILD_TIMEOUT)
+    @pytest.mark.level(2)
+    def _test_create_index_multiprocessing(self, connect, table, args):
+        '''
+        target: test create index interface with multiprocess
+        method: create table and add vectors in it, create index
+        expected: return code equals to 0, and search success
+        '''
+        status, ids = connect.add_vectors(table, vectors)
+
+        def build(connect):
+            status = connect.create_index(table)
+            assert status.OK()
+
+        process_num = 8
+        processes = []
+        uri = "tcp://%s:%s" % (args["ip"], args["port"])
+
+        for i in range(process_num):
+            m = Milvus()
+            m.connect(uri=uri)
+            p = Process(target=build, args=(m,))
+            processes.append(p)
+            p.start()
+            time.sleep(0.2)
+        for p in processes:
+            p.join()
+
+        query_vec = [vectors[0]]
+        top_k = 1
+        status, result = connect.search_vectors(table, top_k, nprobe, query_vec)
+        assert len(result) == 1
+        assert len(result[0]) == top_k
+        assert result[0][0].distance == 0.0
+
+    # TODO: enable
+    @pytest.mark.timeout(BUILD_TIMEOUT)
+    def _test_create_index_multiprocessing_multitable(self, connect, args):
+        '''
+        target: test create index interface with multiprocess
+        method: create table and add vectors in it, create index
+        expected: return code equals to 0, and search success
+        '''
+        process_num = 8
+        loop_num = 8
+        processes = []
+
+        table = []
+        j = 0
+        while j < (process_num*loop_num):
+            table_name = gen_unique_str("test_create_index_multiprocessing")
+            table.append(table_name)
+            param = {'table_name': table_name,
+                    'dimension': dim,
+                    'index_type': IndexType.FLAT,
+                    'store_raw_vector': False}
+            connect.create_table(param)
+            j = j + 1
+
+        def create_index():
+            i = 0
+            while i < loop_num:
+                # assert connect.has_table(table[ids*process_num+i])
+                status, ids = connect.add_vectors(table[ids*process_num+i], vectors)
+
+                status = connect.create_index(table[ids*process_num+i])
+                assert status.OK()
+                query_vec = [vectors[0]]
+                top_k = 1
+                status, result = connect.search_vectors(table[ids*process_num+i], top_k, nprobe, query_vec)
+                assert len(result) == 1
+                assert len(result[0]) == top_k
+                assert result[0][0].distance == 0.0
+                i = i + 1
+
+        uri = "tcp://%s:%s" % (args["ip"], args["port"])
+
+        for i in range(process_num):
+            m = Milvus()
+            m.connect(uri=uri)
+            ids = i
+            p = Process(target=create_index, args=(m,ids))
+            processes.append(p)
+            p.start()
+            time.sleep(0.2)
+        for p in processes:
+            p.join()
+
+    def test_create_index_table_not_existed(self, connect):
+        '''
+        target: test create index interface when table name not existed
+        method: create table and add vectors in it, create index with an random table_name
+            , make sure the table name not in index
+        expected: return code not equals to 0, create index failed
+        '''
+        table_name = gen_unique_str(self.__class__.__name__)
+        status = connect.create_index(table_name, random.choice(gen_index_params()))
+        assert not status.OK()
+
+    def test_create_index_table_None(self, connect):
+        '''
+        target: test create index interface when table name is None
+        method: create table and add vectors in it, create index with an table_name: None
+        expected: return code not equals to 0, create index failed
+        '''
+        table_name = None
+        with pytest.raises(Exception) as e:
+            status = connect.create_index(table_name, random.choice(gen_index_params()))
+
+    def test_create_index_no_vectors(self, connect, table):
+        '''
+        target: test create index interface when there is no vectors in table
+        method: create table and add no vectors in it, and then create index
+        expected: return code equals to 0
+        '''
+        status = connect.create_index(table, random.choice(gen_index_params()))
+        assert status.OK()
+
+    @pytest.mark.timeout(BUILD_TIMEOUT)
+    def test_create_index_no_vectors_then_add_vectors(self, connect, table):
+        '''
+        target: test create index interface when there is no vectors in table, and does not affect the subsequent process
+        method: create table and add no vectors in it, and then create index, add vectors in it
+        expected: return code equals to 0
+        '''
+        status = connect.create_index(table, random.choice(gen_index_params()))
+        status, ids = connect.add_vectors(table, vectors)
+        assert status.OK()
+
+    @pytest.mark.timeout(BUILD_TIMEOUT)
+    def test_create_same_index_repeatedly(self, connect, table):
+        '''
+        target: check if index can be created repeatedly, with the same create_index params
+        method: create index after index have been built
+        expected: return code success, and search ok
+        '''
+        status, ids = connect.add_vectors(table, vectors)
+        index_params = random.choice(gen_index_params())
+        # index_params = get_index_params
+        status = connect.create_index(table, index_params)
+        status = connect.create_index(table, index_params)
+        assert status.OK()
+        query_vec = [vectors[0]]
+        top_k = 1
+        status, result = connect.search_vectors(table, top_k, nprobe, query_vec)
+        assert len(result) == 1
+        assert len(result[0]) == top_k
+
+    @pytest.mark.timeout(BUILD_TIMEOUT)
+    def test_create_different_index_repeatedly(self, connect, table):
+        '''
+        target: check if index can be created repeatedly, with the different create_index params
+        method: create another index with different index_params after index have been built
+        expected: return code 0, and describe index result equals with the second index params
+        '''
+        status, ids = connect.add_vectors(table, vectors)
+        index_params = random.sample(gen_index_params(), 2)
+        logging.getLogger().info(index_params)
+        status = connect.create_index(table, index_params[0])
+        status = connect.create_index(table, index_params[1])
+        assert status.OK()
+        status, result = connect.describe_index(table)
+        assert result._nlist == index_params[1]["nlist"]
+        assert result._table_name == table
+        assert result._index_type == index_params[1]["index_type"]
+
+    """
+    ******************************************************************
+      The following cases are used to test `describe_index` function
+    ******************************************************************
+    """
+
+    def test_describe_index(self, connect, table, get_index_params):
+        '''
+        target: test describe index interface
+        method: create table and add vectors in it, create index, call describe index
+        expected: return code 0, and index instructure
+        '''
+        index_params = get_index_params
+        logging.getLogger().info(index_params)
+        status, ids = connect.add_vectors(table, vectors)
+        status = connect.create_index(table, index_params)
+        status, result = connect.describe_index(table)
+        logging.getLogger().info(result)
+        assert result._nlist == index_params["nlist"]
+        assert result._table_name == table
+        assert result._index_type == index_params["index_type"]
+
+    def test_describe_and_drop_index_multi_tables(self, connect, get_simple_index_params):
+        '''
+        target: test create, describe and drop index interface with multiple tables of L2
+        method: create tables and add vectors in it, create index, call describe index
+        expected: return code 0, and index instructure
+        '''
+        nq = 100
+        vectors = gen_vectors(nq, dim)
+        table_list = []
+        for i in range(10):
+            table_name = gen_unique_str('test_create_index_multi_tables')
+            table_list.append(table_name)
+            param = {'table_name': table_name,
+                     'dimension': dim,
+                     'index_file_size': index_file_size,
+                     'metric_type': MetricType.L2}
+            connect.create_table(param)
+            index_params = get_simple_index_params
+            logging.getLogger().info(index_params)
+            status, ids = connect.add_vectors(table_name=table_name, records=vectors)
+            status = connect.create_index(table_name, index_params)
+            assert status.OK()
+
+        for i in range(10):
+            status, result = connect.describe_index(table_list[i])
+            logging.getLogger().info(result)
+            assert result._nlist == index_params["nlist"]
+            assert result._table_name == table_list[i]
+            assert result._index_type == index_params["index_type"]
+
+        for i in range(10):
+            status = connect.drop_index(table_list[i])
+            assert status.OK()
+            status, result = connect.describe_index(table_list[i])
+            logging.getLogger().info(result)
+            assert result._nlist == 16384
+            assert result._table_name == table_list[i]
+            assert result._index_type == IndexType.FLAT
+
+    @pytest.mark.level(2)
+    def test_describe_index_without_connect(self, dis_connect, table):
+        '''
+        target: test describe index without connection
+        method: describe index, and check if describe successfully
+        expected: raise exception
+        '''
+        with pytest.raises(Exception) as e:
+            status = dis_connect.describe_index(table)
+
+    def test_describe_index_table_not_existed(self, connect):
+        '''
+        target: test describe index interface when table name not existed
+        method: create table and add vectors in it, create index with an random table_name
+            , make sure the table name not in index
+        expected: return code not equals to 0, describe index failed
+        '''
+        table_name = gen_unique_str(self.__class__.__name__)
+        status, result = connect.describe_index(table_name)
+        assert not status.OK()
+
+    def test_describe_index_table_None(self, connect):
+        '''
+        target: test describe index interface when table name is None
+        method: create table and add vectors in it, create index with an table_name: None
+        expected: return code not equals to 0, describe index failed
+        '''
+        table_name = None
+        with pytest.raises(Exception) as e:
+            status = connect.describe_index(table_name)
+
+    def test_describe_index_not_create(self, connect, table):
+        '''
+        target: test describe index interface when index not created
+        method: create table and add vectors in it, create index with an random table_name
+            , make sure the table name not in index
+        expected: return code not equals to 0, describe index failed
+        '''
+        status, ids = connect.add_vectors(table, vectors)
+        status, result = connect.describe_index(table)
+        logging.getLogger().info(result)
+        assert status.OK()
+        # assert result._nlist == index_params["nlist"]
+        # assert result._table_name == table
+        # assert result._index_type == index_params["index_type"]
+
+    """
+    ******************************************************************
+      The following cases are used to test `drop_index` function
+    ******************************************************************
+    """
+
+    def test_drop_index(self, connect, table, get_index_params):
+        '''
+        target: test drop index interface
+        method: create table and add vectors in it, create index, call drop index
+        expected: return code 0, and default index param
+        '''
+        index_params = get_index_params
+        status, ids = connect.add_vectors(table, vectors)
+        status = connect.create_index(table, index_params)
+        assert status.OK()
+        status, result = connect.describe_index(table)
+        logging.getLogger().info(result)
+        status = connect.drop_index(table)
+        assert status.OK()
+        status, result = connect.describe_index(table)
+        logging.getLogger().info(result)
+        assert result._nlist == 16384
+        assert result._table_name == table
+        assert result._index_type == IndexType.FLAT
+
+    def test_drop_index_repeatly(self, connect, table, get_simple_index_params):
+        '''
+        target: test drop index repeatly
+        method: create index, call drop index, and drop again
+        expected: return code 0
+        '''
+        index_params = get_simple_index_params
+        status, ids = connect.add_vectors(table, vectors)
+        status = connect.create_index(table, index_params)
+        assert status.OK()
+        status, result = connect.describe_index(table)
+        logging.getLogger().info(result)
+        status = connect.drop_index(table)
+        assert status.OK()
+        status = connect.drop_index(table)
+        assert status.OK()
+        status, result = connect.describe_index(table)
+        logging.getLogger().info(result)
+        assert result._nlist == 16384
+        assert result._table_name == table
+        assert result._index_type == IndexType.FLAT
+
+    @pytest.mark.level(2)
+    def test_drop_index_without_connect(self, dis_connect, table):
+        '''
+        target: test drop index without connection
+        method: drop index, and check if drop successfully
+        expected: raise exception
+        '''
+        with pytest.raises(Exception) as e:
+            status = dis_connect.drop_index(table)
+
+    def test_drop_index_table_not_existed(self, connect):
+        '''
+        target: test drop index interface when table name not existed
+        method: create table and add vectors in it, create index with an random table_name
+            , make sure the table name not in index, and then drop it
+        expected: return code not equals to 0, drop index failed
+        '''
+        table_name = gen_unique_str(self.__class__.__name__)
+        status = connect.drop_index(table_name)
+        assert not status.OK()
+
+    def test_drop_index_table_None(self, connect):
+        '''
+        target: test drop index interface when table name is None
+        method: create table and add vectors in it, create index with an table_name: None
+        expected: return code not equals to 0, drop index failed
+        '''
+        table_name = None
+        with pytest.raises(Exception) as e:
+            status = connect.drop_index(table_name)
+
+    def test_drop_index_table_not_create(self, connect, table):
+        '''
+        target: test drop index interface when index not created
+        method: create table and add vectors in it, create index
+        expected: return code not equals to 0, drop index failed
+        '''
+        index_params = random.choice(gen_index_params())
+        logging.getLogger().info(index_params)
+        status, ids = connect.add_vectors(table, vectors)
+        status, result = connect.describe_index(table)
+        logging.getLogger().info(result)
+        # no create index
+        status = connect.drop_index(table)
+        logging.getLogger().info(status)
+        assert status.OK()
+
+    def test_create_drop_index_repeatly(self, connect, table, get_simple_index_params):
+        '''
+        target: test create / drop index repeatly, use the same index params
+        method: create index, drop index, four times
+        expected: return code 0
+        '''
+        index_params = get_simple_index_params
+        status, ids = connect.add_vectors(table, vectors)
+        for i in range(2):
+            status = connect.create_index(table, index_params)
+            assert status.OK()
+            status, result = connect.describe_index(table)
+            logging.getLogger().info(result)
+            status = connect.drop_index(table)
+            assert status.OK()
+            status, result = connect.describe_index(table)
+            logging.getLogger().info(result)
+            assert result._nlist == 16384
+            assert result._table_name == table
+            assert result._index_type == IndexType.FLAT
+
+    def test_create_drop_index_repeatly_different_index_params(self, connect, table):
+        '''
+        target: test create / drop index repeatly, use the different index params
+        method: create index, drop index, four times, each tme use different index_params to create index
+        expected: return code 0
+        '''
+        index_params = random.sample(gen_index_params(), 2)
+        status, ids = connect.add_vectors(table, vectors)
+        for i in range(2):
+            status = connect.create_index(table, index_params[i])
+            assert status.OK()
+            status, result = connect.describe_index(table)
+            logging.getLogger().info(result)
+            status = connect.drop_index(table)
+            assert status.OK()
+            status, result = connect.describe_index(table)
+            logging.getLogger().info(result)
+            assert result._nlist == 16384
+            assert result._table_name == table
+            assert result._index_type == IndexType.FLAT
+
+
+class TestIndexIP:
+    @pytest.fixture(
+        scope="function",
+        params=gen_index_params()
+    )
+    def get_index_params(self, request, args):
+        if "internal" not in args:
+            if request.param["index_type"] == IndexType.IVF_SQ8H:
+                pytest.skip("sq8h not support in open source")
+        return request.param
+
+    @pytest.fixture(
+        scope="function",
+        params=gen_simple_index_params()
+    )
+    def get_simple_index_params(self, request):
+        yield request.param
+
+    """
+    ******************************************************************
+      The following cases are used to test `create_index` function
+    ******************************************************************
+    """
+
+    @pytest.mark.timeout(BUILD_TIMEOUT)
+    def test_create_index(self, connect, ip_table, get_index_params):
+        '''
+        target: test create index interface
+        method: create table and add vectors in it, create index
+        expected: return code equals to 0, and search success
+        '''
+        index_params = get_index_params
+        logging.getLogger().info(index_params)
+        status, ids = connect.add_vectors(ip_table, vectors)
+        status = connect.create_index(ip_table, index_params)
+        assert status.OK()
+
+    @pytest.mark.level(2)
+    def test_create_index_without_connect(self, dis_connect, ip_table):
+        '''
+        target: test create index without connection
+        method: create table and add vectors in it, check if added successfully
+        expected: raise exception
+        '''
+        with pytest.raises(Exception) as e:
+            status = dis_connect.create_index(ip_table, random.choice(gen_index_params()))
+
+    @pytest.mark.timeout(BUILD_TIMEOUT)
+    def test_create_index_search_with_query_vectors(self, connect, ip_table, get_index_params):
+        '''
+        target: test create index interface, search with more query vectors
+        method: create table and add vectors in it, create index
+        expected: return code equals to 0, and search success
+        '''
+        index_params = get_index_params
+        logging.getLogger().info(index_params)
+        status, ids = connect.add_vectors(ip_table, vectors)
+        status = connect.create_index(ip_table, index_params)
+        logging.getLogger().info(connect.describe_index(ip_table))
+        query_vecs = [vectors[0], vectors[1], vectors[2]]
+        top_k = 5
+        status, result = connect.search_vectors(ip_table, top_k, nprobe, query_vecs)
+        assert status.OK()
+        assert len(result) == len(query_vecs)
+        # logging.getLogger().info(result)
+
+    # TODO: enable
+    @pytest.mark.timeout(BUILD_TIMEOUT)
+    @pytest.mark.level(2)
+    def _test_create_index_multiprocessing(self, connect, ip_table, args):
+        '''
+        target: test create index interface with multiprocess
+        method: create table and add vectors in it, create index
+        expected: return code equals to 0, and search success
+        '''
+        status, ids = connect.add_vectors(ip_table, vectors)
+
+        def build(connect):
+            status = connect.create_index(ip_table)
+            assert status.OK()
+
+        process_num = 8
+        processes = []
+        uri = "tcp://%s:%s" % (args["ip"], args["port"])
+
+        for i in range(process_num):
+            m = Milvus()
+            m.connect(uri=uri)
+            p = Process(target=build, args=(m,))
+            processes.append(p)
+            p.start()
+            time.sleep(0.2)
+        for p in processes:
+            p.join()
+
+        query_vec = [vectors[0]]
+        top_k = 1
+        status, result = connect.search_vectors(ip_table, top_k, nprobe, query_vec)
+        assert len(result) == 1
+        assert len(result[0]) == top_k
+        assert result[0][0].distance == 0.0
+
+    # TODO: enable
+    @pytest.mark.timeout(BUILD_TIMEOUT)
+    def _test_create_index_multiprocessing_multitable(self, connect, args):
+        '''
+        target: test create index interface with multiprocess
+        method: create table and add vectors in it, create index
+        expected: return code equals to 0, and search success
+        '''
+        process_num = 8
+        loop_num = 8
+        processes = []
+
+        table = []
+        j = 0
+        while j < (process_num*loop_num):
+            table_name = gen_unique_str("test_create_index_multiprocessing")
+            table.append(table_name)
+            param = {'table_name': table_name,
+                    'dimension': dim}
+            connect.create_table(param)
+            j = j + 1
+
+        def create_index():
+            i = 0
+            while i < loop_num:
+                # assert connect.has_table(table[ids*process_num+i])
+                status, ids = connect.add_vectors(table[ids*process_num+i], vectors)
+
+                status = connect.create_index(table[ids*process_num+i])
+                assert status.OK()
+                query_vec = [vectors[0]]
+                top_k = 1
+                status, result = connect.search_vectors(table[ids*process_num+i], top_k, nprobe, query_vec)
+                assert len(result) == 1
+                assert len(result[0]) == top_k
+                assert result[0][0].distance == 0.0
+                i = i + 1
+
+        uri = "tcp://%s:%s" % (args["ip"], args["port"])
+
+        for i in range(process_num):
+            m = Milvus()
+            m.connect(uri=uri)
+            ids = i
+            p = Process(target=create_index, args=(m,ids))
+            processes.append(p)
+            p.start()
+            time.sleep(0.2)
+        for p in processes:
+            p.join()
+
+    def test_create_index_no_vectors(self, connect, ip_table):
+        '''
+        target: test create index interface when there is no vectors in table
+        method: create table and add no vectors in it, and then create index
+        expected: return code equals to 0
+        '''
+        status = connect.create_index(ip_table, random.choice(gen_index_params()))
+        assert status.OK()
+
+    @pytest.mark.timeout(BUILD_TIMEOUT)
+    def test_create_index_no_vectors_then_add_vectors(self, connect, ip_table):
+        '''
+        target: test create index interface when there is no vectors in table, and does not affect the subsequent process
+        method: create table and add no vectors in it, and then create index, add vectors in it
+        expected: return code equals to 0
+        '''
+        status = connect.create_index(ip_table, random.choice(gen_index_params()))
+        status, ids = connect.add_vectors(ip_table, vectors)
+        assert status.OK()
+
+    @pytest.mark.timeout(BUILD_TIMEOUT)
+    def test_create_same_index_repeatedly(self, connect, ip_table):
+        '''
+        target: check if index can be created repeatedly, with the same create_index params
+        method: create index after index have been built
+        expected: return code success, and search ok
+        '''
+        status, ids = connect.add_vectors(ip_table, vectors)
+        index_params = random.choice(gen_index_params())
+        # index_params = get_index_params
+        status = connect.create_index(ip_table, index_params)
+        status = connect.create_index(ip_table, index_params)
+        assert status.OK()
+        query_vec = [vectors[0]]
+        top_k = 1
+        status, result = connect.search_vectors(ip_table, top_k, nprobe, query_vec)
+        assert len(result) == 1
+        assert len(result[0]) == top_k
+
+    @pytest.mark.timeout(BUILD_TIMEOUT)
+    def test_create_different_index_repeatedly(self, connect, ip_table):
+        '''
+        target: check if index can be created repeatedly, with the different create_index params
+        method: create another index with different index_params after index have been built
+        expected: return code 0, and describe index result equals with the second index params
+        '''
+        status, ids = connect.add_vectors(ip_table, vectors)
+        index_params = random.sample(gen_index_params(), 2)
+        logging.getLogger().info(index_params)
+        status = connect.create_index(ip_table, index_params[0])
+        status = connect.create_index(ip_table, index_params[1])
+        assert status.OK()
+        status, result = connect.describe_index(ip_table)
+        assert result._nlist == index_params[1]["nlist"]
+        assert result._table_name == ip_table
+        assert result._index_type == index_params[1]["index_type"]
+
+    """
+    ******************************************************************
+      The following cases are used to test `describe_index` function
+    ******************************************************************
+    """
+
+    def test_describe_index(self, connect, ip_table, get_index_params):
+        '''
+        target: test describe index interface
+        method: create table and add vectors in it, create index, call describe index
+        expected: return code 0, and index instructure
+        '''
+        index_params = get_index_params
+        logging.getLogger().info(index_params)
+        status, ids = connect.add_vectors(ip_table, vectors)
+        status = connect.create_index(ip_table, index_params)
+        status, result = connect.describe_index(ip_table)
+        logging.getLogger().info(result)
+        assert result._nlist == index_params["nlist"]
+        assert result._table_name == ip_table
+        assert result._index_type == index_params["index_type"]
+
+    def test_describe_and_drop_index_multi_tables(self, connect, get_simple_index_params):
+        '''
+        target: test create, describe and drop index interface with multiple tables of IP
+        method: create tables and add vectors in it, create index, call describe index
+        expected: return code 0, and index instructure
+        '''
+        nq = 100
+        vectors = gen_vectors(nq, dim)
+        table_list = []
+        for i in range(10):
+            table_name = gen_unique_str('test_create_index_multi_tables')
+            table_list.append(table_name)
+            param = {'table_name': table_name,
+                     'dimension': dim,
+                     'index_file_size': index_file_size,
+                     'metric_type': MetricType.IP}
+            connect.create_table(param)
+            index_params = get_simple_index_params
+            logging.getLogger().info(index_params)
+            status, ids = connect.add_vectors(table_name=table_name, records=vectors)
+            status = connect.create_index(table_name, index_params)
+            assert status.OK()
+
+        for i in range(10):
+            status, result = connect.describe_index(table_list[i])
+            logging.getLogger().info(result)
+            assert result._nlist == index_params["nlist"]
+            assert result._table_name == table_list[i]
+            assert result._index_type == index_params["index_type"]
+
+        for i in range(10):
+            status = connect.drop_index(table_list[i])
+            assert status.OK()
+            status, result = connect.describe_index(table_list[i])
+            logging.getLogger().info(result)
+            assert result._nlist == 16384
+            assert result._table_name == table_list[i]
+            assert result._index_type == IndexType.FLAT
+
+    @pytest.mark.level(2)
+    def test_describe_index_without_connect(self, dis_connect, ip_table):
+        '''
+        target: test describe index without connection
+        method: describe index, and check if describe successfully
+        expected: raise exception
+        '''
+        with pytest.raises(Exception) as e:
+            status = dis_connect.describe_index(ip_table)
+
+    def test_describe_index_not_create(self, connect, ip_table):
+        '''
+        target: test describe index interface when index not created
+        method: create table and add vectors in it, create index with an random table_name
+            , make sure the table name not in index
+        expected: return code not equals to 0, describe index failed
+        '''
+        status, ids = connect.add_vectors(ip_table, vectors)
+        status, result = connect.describe_index(ip_table)
+        logging.getLogger().info(result)
+        assert status.OK()
+        # assert result._nlist == index_params["nlist"]
+        # assert result._table_name == table
+        # assert result._index_type == index_params["index_type"]
+
+    """
+    ******************************************************************
+      The following cases are used to test `drop_index` function
+    ******************************************************************
+    """
+
+    def test_drop_index(self, connect, ip_table, get_index_params):
+        '''
+        target: test drop index interface
+        method: create table and add vectors in it, create index, call drop index
+        expected: return code 0, and default index param
+        '''
+        index_params = get_index_params
+        status, ids = connect.add_vectors(ip_table, vectors)
+        status = connect.create_index(ip_table, index_params)
+        assert status.OK()
+        status, result = connect.describe_index(ip_table)
+        logging.getLogger().info(result)
+        status = connect.drop_index(ip_table)
+        assert status.OK()
+        status, result = connect.describe_index(ip_table)
+        logging.getLogger().info(result)
+        assert result._nlist == 16384
+        assert result._table_name == ip_table
+        assert result._index_type == IndexType.FLAT
+
+    def test_drop_index_repeatly(self, connect, ip_table, get_simple_index_params):
+        '''
+        target: test drop index repeatly
+        method: create index, call drop index, and drop again
+        expected: return code 0
+        '''
+        index_params = get_simple_index_params
+        status, ids = connect.add_vectors(ip_table, vectors)
+        status = connect.create_index(ip_table, index_params)
+        assert status.OK()
+        status, result = connect.describe_index(ip_table)
+        logging.getLogger().info(result)
+        status = connect.drop_index(ip_table)
+        assert status.OK()
+        status = connect.drop_index(ip_table)
+        assert status.OK()
+        status, result = connect.describe_index(ip_table)
+        logging.getLogger().info(result)
+        assert result._nlist == 16384
+        assert result._table_name == ip_table
+        assert result._index_type == IndexType.FLAT
+
+    @pytest.mark.level(2)
+    def test_drop_index_without_connect(self, dis_connect, ip_table):
+        '''
+        target: test drop index without connection
+        method: drop index, and check if drop successfully
+        expected: raise exception
+        '''
+        with pytest.raises(Exception) as e:
+            status = dis_connect.drop_index(ip_table, random.choice(gen_index_params()))
+
+    def test_drop_index_table_not_create(self, connect, ip_table):
+        '''
+        target: test drop index interface when index not created
+        method: create table and add vectors in it, create index
+        expected: return code not equals to 0, drop index failed
+        '''
+        index_params = random.choice(gen_index_params())
+        logging.getLogger().info(index_params)
+        status, ids = connect.add_vectors(ip_table, vectors)
+        status, result = connect.describe_index(ip_table)
+        logging.getLogger().info(result)
+        # no create index
+        status = connect.drop_index(ip_table)
+        logging.getLogger().info(status)
+        assert status.OK()
+
+    def test_create_drop_index_repeatly(self, connect, ip_table, get_simple_index_params):
+        '''
+        target: test create / drop index repeatly, use the same index params
+        method: create index, drop index, four times
+        expected: return code 0
+        '''
+        index_params = get_simple_index_params
+        status, ids = connect.add_vectors(ip_table, vectors)
+        for i in range(2):
+            status = connect.create_index(ip_table, index_params)
+            assert status.OK()
+            status, result = connect.describe_index(ip_table)
+            logging.getLogger().info(result)
+            status = connect.drop_index(ip_table)
+            assert status.OK()
+            status, result = connect.describe_index(ip_table)
+            logging.getLogger().info(result)
+            assert result._nlist == 16384
+            assert result._table_name == ip_table
+            assert result._index_type == IndexType.FLAT
+
+    def test_create_drop_index_repeatly_different_index_params(self, connect, ip_table):
+        '''
+        target: test create / drop index repeatly, use the different index params
+        method: create index, drop index, four times, each tme use different index_params to create index
+        expected: return code 0
+        '''
+        index_params = random.sample(gen_index_params(), 2)
+        status, ids = connect.add_vectors(ip_table, vectors)
+        for i in range(2):
+            status = connect.create_index(ip_table, index_params[i])
+            assert status.OK()
+            status, result = connect.describe_index(ip_table)
+            assert result._nlist == index_params[i]["nlist"]
+            assert result._table_name == ip_table
+            assert result._index_type == index_params[i]["index_type"]
+            status, result = connect.describe_index(ip_table)
+            logging.getLogger().info(result)
+            status = connect.drop_index(ip_table)
+            assert status.OK()
+            status, result = connect.describe_index(ip_table)
+            logging.getLogger().info(result)
+            assert result._nlist == 16384
+            assert result._table_name == ip_table
+            assert result._index_type == IndexType.FLAT
+
+
+class TestIndexTableInvalid(object):
+    """
+    Test create / describe / drop index interfaces with invalid table names
+    """
+    @pytest.fixture(
+        scope="function",
+        params=gen_invalid_table_names()
+    )
+    def get_table_name(self, request):
+        yield request.param
+
+    # @pytest.mark.level(1)
+    def test_create_index_with_invalid_tablename(self, connect, get_table_name):
+        table_name = get_table_name
+        status = connect.create_index(table_name, random.choice(gen_index_params()))
+        assert not status.OK()
+
+    # @pytest.mark.level(1)
+    def test_describe_index_with_invalid_tablename(self, connect, get_table_name):
+        table_name = get_table_name
+        status, result = connect.describe_index(table_name)
+        assert not status.OK()   
+
+    # @pytest.mark.level(1)
+    def test_drop_index_with_invalid_tablename(self, connect, get_table_name):
+        table_name = get_table_name
+        status = connect.drop_index(table_name)
+        assert not status.OK()
+
+
+class TestCreateIndexParamsInvalid(object):
+    """
+    Test Building index with invalid table names, table names not in db
+    """
+    @pytest.fixture(
+        scope="function",
+        params=gen_invalid_index_params()
+    )
+    def get_index_params(self, request):
+        yield request.param
+
+    @pytest.mark.level(2)
+    def test_create_index_with_invalid_index_params(self, connect, table, get_index_params):
+        index_params = get_index_params
+        index_type = index_params["index_type"]
+        nlist = index_params["nlist"]
+        logging.getLogger().info(index_params)
+        status, ids = connect.add_vectors(table, vectors)
+        # if not isinstance(index_type, int) or not isinstance(nlist, int):
+        with pytest.raises(Exception) as e:
+            status = connect.create_index(table, index_params)
+        # else:
+        #     status = connect.create_index(table, index_params)
+        #     assert not status.OK()
diff --git a/tests/milvus_python_test/test_mix.py b/tests/milvus_python_test/test_mix.py
new file mode 100644
index 0000000000..4578e330b3
--- /dev/null
+++ b/tests/milvus_python_test/test_mix.py
@@ -0,0 +1,180 @@
+import pdb
+import copy
+import pytest
+import threading
+import datetime
+import logging
+from time import sleep
+from multiprocessing import Process
+import numpy
+from milvus import Milvus, IndexType, MetricType
+from utils import *
+
+dim = 128
+index_file_size = 10
+table_id = "test_mix"
+add_interval_time = 2
+vectors = gen_vectors(100000, dim)
+vectors /= numpy.linalg.norm(vectors)
+vectors = vectors.tolist()
+top_k = 1
+nprobe = 1
+epsilon = 0.0001
+index_params = {'index_type': IndexType.IVFLAT, 'nlist': 16384}
+
+
+class TestMixBase:
+
+    # TODO: enable
+    def _test_search_during_createIndex(self, args):
+        loops = 100000
+        table = "test_search_during_createIndex"
+        query_vecs = [vectors[0], vectors[1]]
+        uri = "tcp://%s:%s" % (args["ip"], args["port"])
+        id_0 = 0; id_1 = 0
+        milvus_instance = Milvus()
+        milvus_instance.connect(uri=uri)
+        milvus_instance.create_table({'table_name': table,
+             'dimension': dim,
+             'index_file_size': index_file_size,
+             'metric_type': MetricType.L2})
+        for i in range(10):
+            status, ids = milvus_instance.add_vectors(table, vectors)
+            # logging.getLogger().info(ids)
+            if i == 0:
+                id_0 = ids[0]; id_1 = ids[1]
+        def create_index(milvus_instance):
+            logging.getLogger().info("In create index")
+            status = milvus_instance.create_index(table, index_params)
+            logging.getLogger().info(status)
+            status, result = milvus_instance.describe_index(table)
+            logging.getLogger().info(result)
+        def add_vectors(milvus_instance):
+            logging.getLogger().info("In add vectors")
+            status, ids = milvus_instance.add_vectors(table, vectors)
+            logging.getLogger().info(status)
+        def search(milvus_instance):
+            for i in range(loops):
+                status, result = milvus_instance.search_vectors(table, top_k, nprobe, query_vecs)
+                logging.getLogger().info(status)
+                assert result[0][0].id == id_0
+                assert result[1][0].id == id_1
+        milvus_instance = Milvus()
+        milvus_instance.connect(uri=uri)
+        p_search = Process(target=search, args=(milvus_instance, ))
+        p_search.start()
+        milvus_instance = Milvus()
+        milvus_instance.connect(uri=uri)
+        p_create = Process(target=add_vectors, args=(milvus_instance, ))
+        p_create.start()
+        p_create.join()
+
+    def test_mix_multi_tables(self, connect):
+        '''
+        target: test functions with multiple tables of different metric_types and index_types
+        method: create 60 tables which 30 are L2 and the other are IP, add vectors into them
+                and test describe index and search
+        expected: status ok
+        '''
+        nq = 10000
+        vectors = gen_vectors(nq, dim)
+        table_list = []
+        idx = []
+
+        #create table and add vectors
+        for i in range(30):
+            table_name = gen_unique_str('test_mix_multi_tables')
+            table_list.append(table_name)
+            param = {'table_name': table_name,
+                     'dimension': dim,
+                     'index_file_size': index_file_size,
+                     'metric_type': MetricType.L2}
+            connect.create_table(param)
+            status, ids = connect.add_vectors(table_name=table_name, records=vectors)
+            idx.append(ids[0])
+            idx.append(ids[10])
+            idx.append(ids[20])
+            assert status.OK()
+        for i in range(30):
+            table_name = gen_unique_str('test_mix_multi_tables')
+            table_list.append(table_name)
+            param = {'table_name': table_name,
+                     'dimension': dim,
+                     'index_file_size': index_file_size,
+                     'metric_type': MetricType.IP}
+            connect.create_table(param)
+            status, ids = connect.add_vectors(table_name=table_name, records=vectors)
+            idx.append(ids[0])
+            idx.append(ids[10])
+            idx.append(ids[20])
+            assert status.OK()
+        time.sleep(2)
+
+        #create index
+        for i in range(10):
+            index_params = {'index_type': IndexType.FLAT, 'nlist': 16384}
+            status = connect.create_index(table_list[i], index_params)
+            assert status.OK()
+            status = connect.create_index(table_list[30 + i], index_params)
+            assert status.OK()
+            index_params = {'index_type': IndexType.IVFLAT, 'nlist': 16384}
+            status = connect.create_index(table_list[10 + i], index_params)
+            assert status.OK()
+            status = connect.create_index(table_list[40 + i], index_params)
+            assert status.OK()
+            index_params = {'index_type': IndexType.IVF_SQ8, 'nlist': 16384}
+            status = connect.create_index(table_list[20 + i], index_params)
+            assert status.OK()
+            status = connect.create_index(table_list[50 + i], index_params)
+            assert status.OK()
+
+        #describe index
+        for i in range(10):
+            status, result = connect.describe_index(table_list[i])
+            logging.getLogger().info(result)
+            assert result._nlist == 16384
+            assert result._table_name == table_list[i]
+            assert result._index_type == IndexType.FLAT
+            status, result = connect.describe_index(table_list[10 + i])
+            logging.getLogger().info(result)
+            assert result._nlist == 16384
+            assert result._table_name == table_list[10 + i]
+            assert result._index_type == IndexType.IVFLAT
+            status, result = connect.describe_index(table_list[20 + i])
+            logging.getLogger().info(result)
+            assert result._nlist == 16384
+            assert result._table_name == table_list[20 + i]
+            assert result._index_type == IndexType.IVF_SQ8
+            status, result = connect.describe_index(table_list[30 + i])
+            logging.getLogger().info(result)
+            assert result._nlist == 16384
+            assert result._table_name == table_list[30 + i]
+            assert result._index_type == IndexType.FLAT
+            status, result = connect.describe_index(table_list[40 + i])
+            logging.getLogger().info(result)
+            assert result._nlist == 16384
+            assert result._table_name == table_list[40 + i]
+            assert result._index_type == IndexType.IVFLAT
+            status, result = connect.describe_index(table_list[50 + i])
+            logging.getLogger().info(result)
+            assert result._nlist == 16384
+            assert result._table_name == table_list[50 + i]
+            assert result._index_type == IndexType.IVF_SQ8
+
+        #search
+        query_vecs = [vectors[0], vectors[10], vectors[20]]
+        for i in range(60):
+            table = table_list[i]
+            status, result = connect.search_vectors(table, top_k, nprobe, query_vecs)
+            assert status.OK()
+            assert len(result) == len(query_vecs)
+            for j in range(len(query_vecs)):
+                assert len(result[j]) == top_k
+            for j in range(len(query_vecs)):
+                assert check_result(result[j], idx[3 * i + j])
+
+def check_result(result, id):
+    if len(result) >= 5:
+        return id in [result[0].id, result[1].id, result[2].id, result[3].id, result[4].id]
+    else:
+        return id in (i.id for i in result)
\ No newline at end of file
diff --git a/tests/milvus_python_test/test_ping.py b/tests/milvus_python_test/test_ping.py
new file mode 100644
index 0000000000..a55559bc63
--- /dev/null
+++ b/tests/milvus_python_test/test_ping.py
@@ -0,0 +1,77 @@
+import logging
+import pytest
+
+__version__ = '0.5.0'
+
+
+class TestPing:
+    def test_server_version(self, connect):
+        '''
+        target: test get the server version
+        method: call the server_version method after connected
+        expected: version should be the pymilvus version
+        '''
+        status, res = connect.server_version()
+        assert res == __version__
+
+    def test_server_status(self, connect):
+        '''
+        target: test get the server status
+        method: call the server_status method after connected
+        expected: status returned should be ok
+        '''
+        status, msg = connect.server_status()
+        assert status.OK()
+
+    def _test_server_cmd_with_params_version(self, connect):
+        '''
+        target: test cmd: version
+        method: cmd = "version" ...
+        expected: when cmd = 'version', return version of server;
+        '''
+        cmd = "version"
+        status, msg = connect.cmd(cmd)
+        logging.getLogger().info(status)
+        logging.getLogger().info(msg)
+        assert status.OK()
+        assert msg == __version__
+
+    def _test_server_cmd_with_params_others(self, connect):
+        '''
+        target: test cmd: lalala
+        method: cmd = "lalala" ...
+        expected: when cmd = 'version', return version of server;
+        '''
+        cmd = "rm -rf test"
+        status, msg = connect.cmd(cmd)
+        logging.getLogger().info(status)
+        logging.getLogger().info(msg)
+        assert status.OK()
+        # assert msg == __version__
+
+    def test_connected(self, connect):
+        assert connect.connected()
+
+
+class TestPingDisconnect:
+    def test_server_version(self, dis_connect):
+        '''
+        target: test get the server version, after disconnect
+        method: call the server_version method after connected
+        expected: version should not be the pymilvus version
+        '''
+        res = None
+        with pytest.raises(Exception) as e:
+            status, res = connect.server_version()
+        assert res is None
+
+    def test_server_status(self, dis_connect):
+        '''
+        target: test get the server status, after disconnect
+        method: call the server_status method after connected
+        expected: status returned should be not ok
+        '''
+        status = None
+        with pytest.raises(Exception) as e:
+            status, msg = connect.server_status()
+        assert status is None
diff --git a/tests/milvus_python_test/test_search_vectors.py b/tests/milvus_python_test/test_search_vectors.py
new file mode 100644
index 0000000000..e52e0d2d08
--- /dev/null
+++ b/tests/milvus_python_test/test_search_vectors.py
@@ -0,0 +1,653 @@
+import pdb
+import copy
+import pytest
+import threading
+import datetime
+import logging
+from time import sleep
+from multiprocessing import Process
+import numpy
+from milvus import Milvus, IndexType, MetricType
+from utils import *
+
+dim = 128
+table_id = "test_search"
+add_interval_time = 2
+vectors = gen_vectors(100, dim)
+# vectors /= numpy.linalg.norm(vectors)
+# vectors = vectors.tolist()
+nrpobe = 1
+epsilon = 0.001
+
+
+class TestSearchBase:
+    def init_data(self, connect, table, nb=100):
+        '''
+        Generate vectors and add it in table, before search vectors
+        '''
+        global vectors
+        if nb == 100:
+            add_vectors = vectors
+        else:  
+            add_vectors = gen_vectors(nb, dim)
+            # add_vectors /= numpy.linalg.norm(add_vectors)
+            # add_vectors = add_vectors.tolist()
+        status, ids = connect.add_vectors(table, add_vectors)
+        sleep(add_interval_time)
+        return add_vectors, ids
+
+    """
+    generate valid create_index params
+    """
+    @pytest.fixture(
+        scope="function",
+        params=gen_index_params()
+    )
+    def get_index_params(self, request, args):
+        if "internal" not in args:
+            if request.param["index_type"] == IndexType.IVF_SQ8H:
+                pytest.skip("sq8h not support in open source")
+        return request.param
+
+    """
+    generate top-k params
+    """
+    @pytest.fixture(
+        scope="function",
+        params=[1, 99, 101, 1024, 2048, 2049]
+    )
+    def get_top_k(self, request):
+        yield request.param
+
+
+    def test_search_top_k_flat_index(self, connect, table, get_top_k):
+        '''
+        target: test basic search fuction, all the search params is corrent, change top-k value
+        method: search with the given vectors, check the result
+        expected: search status ok, and the length of the result is top_k
+        '''
+        vectors, ids = self.init_data(connect, table)
+        query_vec = [vectors[0]]
+        top_k = get_top_k
+        nprobe = 1
+        status, result = connect.search_vectors(table, top_k, nrpobe, query_vec)
+        if top_k <= 2048:
+            assert status.OK()
+            assert len(result[0]) == min(len(vectors), top_k)
+            assert result[0][0].distance <= epsilon
+            assert check_result(result[0], ids[0])
+        else:
+            assert not status.OK()
+
+    def test_search_l2_index_params(self, connect, table, get_index_params):
+        '''
+        target: test basic search fuction, all the search params is corrent, test all index params, and build
+        method: search with the given vectors, check the result
+        expected: search status ok, and the length of the result is top_k
+        '''
+        
+        index_params = get_index_params
+        logging.getLogger().info(index_params)
+        vectors, ids = self.init_data(connect, table)
+        status = connect.create_index(table, index_params)
+        query_vec = [vectors[0]]
+        top_k = 10
+        nprobe = 1
+        status, result = connect.search_vectors(table, top_k, nrpobe, query_vec)
+        logging.getLogger().info(result)
+        if top_k <= 1024:
+            assert status.OK()
+            assert len(result[0]) == min(len(vectors), top_k)
+            assert check_result(result[0], ids[0])
+            assert result[0][0].distance <= epsilon
+        else:
+            assert not status.OK()
+
+    def test_search_ip_index_params(self, connect, ip_table, get_index_params):
+        '''
+        target: test basic search fuction, all the search params is corrent, test all index params, and build
+        method: search with the given vectors, check the result
+        expected: search status ok, and the length of the result is top_k
+        '''
+        
+        index_params = get_index_params
+        logging.getLogger().info(index_params)
+        vectors, ids = self.init_data(connect, ip_table)
+        status = connect.create_index(ip_table, index_params)
+        query_vec = [vectors[0]]
+        top_k = 10
+        nprobe = 1
+        status, result = connect.search_vectors(ip_table, top_k, nrpobe, query_vec)
+        logging.getLogger().info(result)
+
+        if top_k <= 1024:
+            assert status.OK()
+            assert len(result[0]) == min(len(vectors), top_k)
+            assert check_result(result[0], ids[0])
+            assert abs(result[0][0].distance - numpy.inner(numpy.array(query_vec[0]), numpy.array(query_vec[0]))) <= gen_inaccuracy(result[0][0].distance)
+        else:
+            assert not status.OK()
+
+    @pytest.mark.level(2)
+    def test_search_vectors_without_connect(self, dis_connect, table):
+        '''
+        target: test search vectors without connection
+        method: use dis connected instance, call search method and check if search successfully
+        expected: raise exception
+        '''
+        query_vectors = [vectors[0]]
+        top_k = 1
+        nprobe = 1
+        with pytest.raises(Exception) as e:
+            status, ids = dis_connect.search_vectors(table, top_k, nprobe, query_vectors)
+
+    def test_search_table_name_not_existed(self, connect, table):
+        '''
+        target: search table not existed
+        method: search with the random table_name, which is not in db
+        expected: status not ok
+        '''
+        table_name = gen_unique_str("not_existed_table")
+        top_k = 1
+        nprobe = 1
+        query_vecs = [vectors[0]]
+        status, result = connect.search_vectors(table_name, top_k, nprobe, query_vecs)
+        assert not status.OK()
+
+    def test_search_table_name_None(self, connect, table):
+        '''
+        target: search table that table name is None
+        method: search with the table_name: None
+        expected: status not ok
+        '''
+        table_name = None
+        top_k = 1
+        nprobe = 1
+        query_vecs = [vectors[0]]
+        with pytest.raises(Exception) as e: 
+            status, result = connect.search_vectors(table_name, top_k, nprobe, query_vecs)
+
+    def test_search_top_k_query_records(self, connect, table):
+        '''
+        target: test search fuction, with search params: query_records
+        method: search with the given query_records, which are subarrays of the inserted vectors
+        expected: status ok and the returned vectors should be query_records
+        '''
+        top_k = 10
+        nprobe = 1
+        vectors, ids = self.init_data(connect, table)
+        query_vecs = [vectors[0],vectors[55],vectors[99]]
+        status, result = connect.search_vectors(table, top_k, nprobe, query_vecs)
+        assert status.OK()
+        assert len(result) == len(query_vecs)
+        for i in range(len(query_vecs)):
+            assert len(result[i]) == top_k
+            assert result[i][0].distance <= epsilon
+
+    """
+    generate invalid query range params
+    """
+    @pytest.fixture(
+        scope="function",
+        params=[
+            (get_current_day(), get_current_day()),
+            (get_last_day(1), get_last_day(1)),
+            (get_next_day(1), get_next_day(1))
+        ]
+    )
+    def get_invalid_range(self, request):
+        yield request.param
+
+    def test_search_invalid_query_ranges(self, connect, table, get_invalid_range):
+        '''
+        target: search table with query ranges
+        method: search with the same query ranges
+        expected: status not ok
+        '''
+        top_k = 2
+        nprobe = 1
+        vectors, ids = self.init_data(connect, table)
+        query_vecs = [vectors[0]]
+        query_ranges = [get_invalid_range]
+        status, result = connect.search_vectors(table, top_k, nprobe, query_vecs, query_ranges=query_ranges)
+        assert not status.OK()
+        assert len(result) == 0
+
+    """
+    generate valid query range params, no search result
+    """
+    @pytest.fixture(
+        scope="function",
+        params=[
+            (get_last_day(2), get_last_day(1)),
+            (get_last_day(2), get_current_day()),
+            (get_next_day(1), get_next_day(2))
+        ]
+    )
+    def get_valid_range_no_result(self, request):
+        yield request.param
+
+    def test_search_valid_query_ranges_no_result(self, connect, table, get_valid_range_no_result):
+        '''
+        target: search table with normal query ranges, but no data in db
+        method: search with query ranges (low, low)
+        expected: length of result is 0
+        '''
+        top_k = 2
+        nprobe = 1
+        vectors, ids = self.init_data(connect, table)
+        query_vecs = [vectors[0]]
+        query_ranges = [get_valid_range_no_result]
+        status, result = connect.search_vectors(table, top_k, nprobe, query_vecs, query_ranges=query_ranges)
+        assert status.OK()
+        assert len(result) == 0
+
+    """
+    generate valid query range params, no search result
+    """
+    @pytest.fixture(
+        scope="function",
+        params=[
+            (get_last_day(2), get_next_day(2)),
+            (get_current_day(), get_next_day(2)),
+        ]
+    )
+    def get_valid_range(self, request):
+        yield request.param
+
+    def test_search_valid_query_ranges(self, connect, table, get_valid_range):
+        '''
+        target: search table with normal query ranges, but no data in db
+        method: search with query ranges (low, normal)
+        expected: length of result is 0
+        '''
+        top_k = 2
+        nprobe = 1
+        vectors, ids = self.init_data(connect, table)
+        query_vecs = [vectors[0]]
+        query_ranges = [get_valid_range]
+        status, result = connect.search_vectors(table, top_k, nprobe, query_vecs, query_ranges=query_ranges)
+        assert status.OK()
+        assert len(result) == 1
+        assert result[0][0].distance <= epsilon
+
+    def test_search_distance_l2_flat_index(self, connect, table):
+        '''
+        target: search table, and check the result: distance
+        method: compare the return distance value with value computed with Euclidean
+        expected: the return distance equals to the computed value
+        '''
+        nb = 2
+        top_k = 1
+        nprobe = 1
+        vectors, ids = self.init_data(connect, table, nb=nb)
+        query_vecs = [[0.50 for i in range(dim)]]
+        distance_0 = numpy.linalg.norm(numpy.array(query_vecs[0]) - numpy.array(vectors[0]))
+        distance_1 = numpy.linalg.norm(numpy.array(query_vecs[0]) - numpy.array(vectors[1]))
+        status, result = connect.search_vectors(table, top_k, nprobe, query_vecs)
+        assert abs(numpy.sqrt(result[0][0].distance) - min(distance_0, distance_1)) <= gen_inaccuracy(result[0][0].distance)
+
+    def test_search_distance_ip_flat_index(self, connect, ip_table):
+        '''
+        target: search ip_table, and check the result: distance
+        method: compare the return distance value with value computed with Inner product
+        expected: the return distance equals to the computed value
+        '''
+        nb = 2
+        top_k = 1
+        nprobe = 1
+        vectors, ids = self.init_data(connect, ip_table, nb=nb)
+        index_params = {
+            "index_type": IndexType.FLAT,
+            "nlist": 16384
+        }
+        connect.create_index(ip_table, index_params)
+        logging.getLogger().info(connect.describe_index(ip_table))
+        query_vecs = [[0.50 for i in range(dim)]]
+        distance_0 = numpy.inner(numpy.array(query_vecs[0]), numpy.array(vectors[0]))
+        distance_1 = numpy.inner(numpy.array(query_vecs[0]), numpy.array(vectors[1]))
+        status, result = connect.search_vectors(ip_table, top_k, nprobe, query_vecs)
+        assert abs(result[0][0].distance - max(distance_0, distance_1)) <= gen_inaccuracy(result[0][0].distance)
+
+    def test_search_distance_ip_index_params(self, connect, ip_table, get_index_params):
+        '''
+        target: search table, and check the result: distance
+        method: compare the return distance value with value computed with Inner product
+        expected: the return distance equals to the computed value
+        '''
+        top_k = 2
+        nprobe = 1
+        vectors, ids = self.init_data(connect, ip_table, nb=2)
+        index_params = get_index_params
+        connect.create_index(ip_table, index_params)
+        logging.getLogger().info(connect.describe_index(ip_table))
+        query_vecs = [[0.50 for i in range(dim)]]
+        status, result = connect.search_vectors(ip_table, top_k, nprobe, query_vecs)
+        distance_0 = numpy.inner(numpy.array(query_vecs[0]), numpy.array(vectors[0]))
+        distance_1 = numpy.inner(numpy.array(query_vecs[0]), numpy.array(vectors[1]))
+        assert abs(result[0][0].distance - max(distance_0, distance_1)) <= gen_inaccuracy(result[0][0].distance)
+
+    # TODO: enable
+    # @pytest.mark.repeat(5)
+    @pytest.mark.timeout(30)
+    def _test_search_concurrent(self, connect, table):
+        vectors, ids = self.init_data(connect, table)
+        thread_num = 10
+        nb = 100
+        top_k = 10
+        threads = []
+        query_vecs = vectors[nb//2:nb]
+        def search():
+            status, result = connect.search_vectors(table, top_k, query_vecs)
+            assert len(result) == len(query_vecs)
+            for i in range(len(query_vecs)):
+                assert result[i][0].id in ids
+                assert result[i][0].distance == 0.0
+        for i in range(thread_num):
+            x = threading.Thread(target=search, args=())
+            threads.append(x)
+            x.start()
+        for th in threads:
+            th.join()
+
+    # TODO: enable
+    @pytest.mark.timeout(30)
+    def _test_search_concurrent_multiprocessing(self, args):
+        '''
+        target: test concurrent search with multiprocessess
+        method: search with 10 processes, each process uses dependent connection
+        expected: status ok and the returned vectors should be query_records
+        '''
+        nb = 100
+        top_k = 10
+        process_num = 4
+        processes = []
+        table = gen_unique_str("test_search_concurrent_multiprocessing")
+        uri = "tcp://%s:%s" % (args["ip"], args["port"])
+        param = {'table_name': table,
+             'dimension': dim,
+             'index_type': IndexType.FLAT,
+             'store_raw_vector': False}
+        # create table
+        milvus = Milvus()
+        milvus.connect(uri=uri)
+        milvus.create_table(param)
+        vectors, ids = self.init_data(milvus, table, nb=nb)
+        query_vecs = vectors[nb//2:nb]
+        def search(milvus):
+            status, result = milvus.search_vectors(table, top_k, query_vecs)
+            assert len(result) == len(query_vecs)
+            for i in range(len(query_vecs)):
+                assert result[i][0].id in ids
+                assert result[i][0].distance == 0.0
+
+        for i in range(process_num):
+            milvus = Milvus()
+            milvus.connect(uri=uri)
+            p = Process(target=search, args=(milvus, ))
+            processes.append(p)
+            p.start()
+            time.sleep(0.2)
+        for p in processes:
+            p.join()
+
+    def test_search_multi_table_L2(search, args):
+        '''
+        target: test search multi tables of L2
+        method: add vectors into 10 tables, and search
+        expected: search status ok, the length of result
+        '''
+        num = 10
+        top_k = 10
+        nprobe = 1
+        tables = []
+        idx = []
+        for i in range(num):
+            table = gen_unique_str("test_add_multitable_%d" % i)
+            uri = "tcp://%s:%s" % (args["ip"], args["port"])
+            param = {'table_name': table,
+                     'dimension': dim,
+                     'index_file_size': 10,
+                     'metric_type': MetricType.L2}
+            # create table
+            milvus = Milvus()
+            milvus.connect(uri=uri)
+            milvus.create_table(param)
+            status, ids = milvus.add_vectors(table, vectors)
+            assert status.OK()
+            assert len(ids) == len(vectors)
+            tables.append(table)
+            idx.append(ids[0])
+            idx.append(ids[10])
+            idx.append(ids[20])
+        time.sleep(6)
+        query_vecs = [vectors[0], vectors[10], vectors[20]]
+        # start query from random table
+        for i in range(num):
+            table = tables[i]
+            status, result = milvus.search_vectors(table, top_k, nprobe, query_vecs)
+            assert status.OK()
+            assert len(result) == len(query_vecs)
+            for j in range(len(query_vecs)):
+                assert len(result[j]) == top_k
+            for j in range(len(query_vecs)):
+                assert check_result(result[j], idx[3 * i + j])
+
+    def test_search_multi_table_IP(search, args):
+        '''
+        target: test search multi tables of IP
+        method: add vectors into 10 tables, and search
+        expected: search status ok, the length of result
+        '''
+        num = 10
+        top_k = 10
+        nprobe = 1
+        tables = []
+        idx = []
+        for i in range(num):
+            table = gen_unique_str("test_add_multitable_%d" % i)
+            uri = "tcp://%s:%s" % (args["ip"], args["port"])
+            param = {'table_name': table,
+                     'dimension': dim,
+                     'index_file_size': 10,
+                     'metric_type': MetricType.L2}
+            # create table
+            milvus = Milvus()
+            milvus.connect(uri=uri)
+            milvus.create_table(param)
+            status, ids = milvus.add_vectors(table, vectors)
+            assert status.OK()
+            assert len(ids) == len(vectors)
+            tables.append(table)
+            idx.append(ids[0])
+            idx.append(ids[10])
+            idx.append(ids[20])
+        time.sleep(6)
+        query_vecs = [vectors[0], vectors[10], vectors[20]]
+        # start query from random table
+        for i in range(num):
+            table = tables[i]
+            status, result = milvus.search_vectors(table, top_k, nprobe, query_vecs)
+            assert status.OK()
+            assert len(result) == len(query_vecs)
+            for j in range(len(query_vecs)):
+                assert len(result[j]) == top_k
+            for j in range(len(query_vecs)):
+                assert check_result(result[j], idx[3 * i + j])
+"""
+******************************************************************
+#  The following cases are used to test `search_vectors` function 
+#  with invalid table_name top-k / nprobe / query_range
+******************************************************************
+"""
+
+class TestSearchParamsInvalid(object):
+    index_params = random.choice(gen_index_params())
+    logging.getLogger().info(index_params)
+
+    def init_data(self, connect, table, nb=100):
+        '''
+        Generate vectors and add it in table, before search vectors
+        '''
+        global vectors
+        if nb == 100:
+            add_vectors = vectors
+        else:  
+            add_vectors = gen_vectors(nb, dim)
+        status, ids = connect.add_vectors(table, add_vectors)
+        sleep(add_interval_time)
+        return add_vectors, ids
+
+    """
+    Test search table with invalid table names
+    """
+    @pytest.fixture(
+        scope="function",
+        params=gen_invalid_table_names()
+    )
+    def get_table_name(self, request):
+        yield request.param
+
+    @pytest.mark.level(2)
+    def test_search_with_invalid_tablename(self, connect, get_table_name):
+        table_name = get_table_name
+        logging.getLogger().info(table_name)
+        top_k = 1
+        nprobe = 1 
+        query_vecs = gen_vectors(1, dim)
+        status, result = connect.search_vectors(table_name, top_k, nprobe, query_vecs)
+        assert not status.OK()
+
+    """
+    Test search table with invalid top-k
+    """
+    @pytest.fixture(
+        scope="function",
+        params=gen_invalid_top_ks()
+    )
+    def get_top_k(self, request):
+        yield request.param
+
+    @pytest.mark.level(2)
+    def test_search_with_invalid_top_k(self, connect, table, get_top_k):
+        '''
+        target: test search fuction, with the wrong top_k
+        method: search with top_k
+        expected: raise an error, and the connection is normal
+        '''
+        top_k = get_top_k
+        logging.getLogger().info(top_k)
+        nprobe = 1
+        query_vecs = gen_vectors(1, dim)
+        with pytest.raises(Exception) as e:
+            status, result = connect.search_vectors(table, top_k, nprobe, query_vecs)
+        res = connect.server_version()
+
+    @pytest.mark.level(2)
+    def test_search_with_invalid_top_k_ip(self, connect, ip_table, get_top_k):
+        '''
+        target: test search fuction, with the wrong top_k
+        method: search with top_k
+        expected: raise an error, and the connection is normal
+        '''
+        top_k = get_top_k
+        logging.getLogger().info(top_k)
+        nprobe = 1
+        query_vecs = gen_vectors(1, dim)
+        with pytest.raises(Exception) as e:
+            status, result = connect.search_vectors(ip_table, top_k, nprobe, query_vecs)
+        res = connect.server_version()
+
+    """
+    Test search table with invalid nprobe
+    """
+    @pytest.fixture(
+        scope="function",
+        params=gen_invalid_nprobes()
+    )
+    def get_nprobes(self, request):
+        yield request.param
+
+    @pytest.mark.level(2)
+    def test_search_with_invalid_nrpobe(self, connect, table, get_nprobes):
+        '''
+        target: test search fuction, with the wrong top_k
+        method: search with top_k
+        expected: raise an error, and the connection is normal
+        '''
+        top_k = 1
+        nprobe = get_nprobes
+        logging.getLogger().info(nprobe)
+        query_vecs = gen_vectors(1, dim)
+        if isinstance(nprobe, int) and nprobe > 0:
+            status, result = connect.search_vectors(table, top_k, nprobe, query_vecs)
+            assert not status.OK()
+        else:
+            with pytest.raises(Exception) as e:
+                status, result = connect.search_vectors(table, top_k, nprobe, query_vecs)
+
+    @pytest.mark.level(2)
+    def test_search_with_invalid_nrpobe_ip(self, connect, ip_table, get_nprobes):
+        '''
+        target: test search fuction, with the wrong top_k
+        method: search with top_k
+        expected: raise an error, and the connection is normal
+        '''
+        top_k = 1
+        nprobe = get_nprobes
+        logging.getLogger().info(nprobe)
+        query_vecs = gen_vectors(1, dim)
+        if isinstance(nprobe, int) and nprobe > 0:
+            status, result = connect.search_vectors(ip_table, top_k, nprobe, query_vecs)
+            assert not status.OK()
+        else:
+            with pytest.raises(Exception) as e:
+                status, result = connect.search_vectors(ip_table, top_k, nprobe, query_vecs)
+
+    """
+    Test search table with invalid query ranges
+    """
+    @pytest.fixture(
+        scope="function",
+        params=gen_invalid_query_ranges()
+    )
+    def get_query_ranges(self, request):
+        yield request.param
+
+    @pytest.mark.level(2)
+    def test_search_flat_with_invalid_query_range(self, connect, table, get_query_ranges):
+        '''
+        target: test search fuction, with the wrong query_range
+        method: search with query_range
+        expected: raise an error, and the connection is normal
+        '''
+        top_k = 1
+        nprobe = 1
+        query_vecs = [vectors[0]]
+        query_ranges = get_query_ranges
+        logging.getLogger().info(query_ranges)
+        with pytest.raises(Exception) as e:
+            status, result = connect.search_vectors(table, 1, nprobe, query_vecs, query_ranges=query_ranges)
+
+
+    @pytest.mark.level(2)
+    def test_search_flat_with_invalid_query_range_ip(self, connect, ip_table, get_query_ranges):
+        '''
+        target: test search fuction, with the wrong query_range
+        method: search with query_range
+        expected: raise an error, and the connection is normal
+        '''
+        top_k = 1
+        nprobe = 1
+        query_vecs = [vectors[0]]
+        query_ranges = get_query_ranges
+        logging.getLogger().info(query_ranges)
+        with pytest.raises(Exception) as e:
+            status, result = connect.search_vectors(ip_table, 1, nprobe, query_vecs, query_ranges=query_ranges)
+
+
+def check_result(result, id):
+    if len(result) >= 5:
+        return id in [result[0].id, result[1].id, result[2].id, result[3].id, result[4].id]
+    else:
+        return id in (i.id for i in result)
\ No newline at end of file
diff --git a/tests/milvus_python_test/test_table.py b/tests/milvus_python_test/test_table.py
new file mode 100644
index 0000000000..eb538281ed
--- /dev/null
+++ b/tests/milvus_python_test/test_table.py
@@ -0,0 +1,885 @@
+import random
+import pdb
+import pytest
+import logging
+import itertools
+
+from time import sleep
+from multiprocessing import Process
+import numpy
+from milvus import Milvus
+from milvus import IndexType, MetricType
+from utils import *
+
+dim = 128
+delete_table_interval_time = 3
+index_file_size = 10
+vectors = gen_vectors(100, dim)
+
+
+class TestTable:
+
+    """
+    ******************************************************************
+      The following cases are used to test `create_table` function
+    ******************************************************************
+    """
+
+    def test_create_table(self, connect):
+        '''
+        target: test create normal table 
+        method: create table with corrent params
+        expected: create status return ok
+        '''
+        table_name = gen_unique_str("test_table")
+        param = {'table_name': table_name,
+                 'dimension': dim,
+                 'index_file_size': index_file_size, 
+                 'metric_type': MetricType.L2}
+        status = connect.create_table(param)
+        assert status.OK()
+
+    def test_create_table_ip(self, connect):
+        '''
+        target: test create normal table 
+        method: create table with corrent params
+        expected: create status return ok
+        '''
+        table_name = gen_unique_str("test_table")
+        param = {'table_name': table_name,
+                 'dimension': dim,
+                 'index_file_size': index_file_size, 
+                 'metric_type': MetricType.IP}
+        status = connect.create_table(param)
+        assert status.OK()
+
+    @pytest.mark.level(2)
+    def test_create_table_without_connection(self, dis_connect):
+        '''
+        target: test create table, without connection
+        method: create table with correct params, with a disconnected instance
+        expected: create raise exception
+        '''
+        table_name = gen_unique_str("test_table")
+        param = {'table_name': table_name,
+                 'dimension': dim,
+                 'index_file_size': index_file_size, 
+                 'metric_type': MetricType.L2}
+        with pytest.raises(Exception) as e:
+            status = dis_connect.create_table(param)
+
+    def test_create_table_existed(self, connect):
+        '''
+        target: test create table but the table name have already existed
+        method: create table with the same table_name
+        expected: create status return not ok
+        '''
+        table_name = gen_unique_str("test_table")
+        param = {'table_name': table_name,
+                 'dimension': dim,
+                 'index_file_size': index_file_size, 
+                 'metric_type': MetricType.L2}
+        status = connect.create_table(param)
+        status = connect.create_table(param)
+        assert not status.OK()
+
+    @pytest.mark.level(2)
+    def test_create_table_existed_ip(self, connect):
+        '''
+        target: test create table but the table name have already existed
+        method: create table with the same table_name
+        expected: create status return not ok
+        '''
+        table_name = gen_unique_str("test_table")
+        param = {'table_name': table_name,
+                 'dimension': dim,
+                 'index_file_size': index_file_size, 
+                 'metric_type': MetricType.IP}
+        status = connect.create_table(param)
+        status = connect.create_table(param)
+        assert not status.OK()
+
+    def test_create_table_None(self, connect):
+        '''
+        target: test create table but the table name is None
+        method: create table, param table_name is None
+        expected: create raise error
+        '''
+        param = {'table_name': None,
+                 'dimension': dim,
+                 'index_file_size': index_file_size, 
+                 'metric_type': MetricType.L2}
+        with pytest.raises(Exception) as e:
+            status = connect.create_table(param)
+
+    def test_create_table_no_dimension(self, connect):
+        '''
+        target: test create table with no dimension params
+        method: create table with corrent params
+        expected: create status return ok
+        '''
+        table_name = gen_unique_str("test_table")
+        param = {'table_name': table_name,
+                 'index_file_size': index_file_size,
+                 'metric_type': MetricType.L2}
+        with pytest.raises(Exception) as e:
+            status = connect.create_table(param)
+
+    def test_create_table_no_file_size(self, connect):
+        '''
+        target: test create table with no index_file_size params
+        method: create table with corrent params
+        expected: create status return ok, use default 1024
+        '''
+        table_name = gen_unique_str("test_table")
+        param = {'table_name': table_name,
+                 'dimension': dim,
+                 'metric_type': MetricType.L2}
+        status = connect.create_table(param)
+        logging.getLogger().info(status)
+        status, result = connect.describe_table(table_name)
+        logging.getLogger().info(result)
+        assert result.index_file_size == 1024
+
+    def test_create_table_no_metric_type(self, connect):
+        '''
+        target: test create table with no metric_type params
+        method: create table with corrent params
+        expected: create status return ok, use default L2
+        '''
+        table_name = gen_unique_str("test_table")
+        param = {'table_name': table_name,
+                 'dimension': dim,
+                 'index_file_size': index_file_size}
+        status = connect.create_table(param)
+        status, result = connect.describe_table(table_name)
+        logging.getLogger().info(result)
+        assert result.metric_type == MetricType.L2
+
+    """
+    ******************************************************************
+      The following cases are used to test `describe_table` function
+    ******************************************************************
+    """
+
+    def test_table_describe_result(self, connect):
+        '''
+        target: test describe table created with correct params 
+        method: create table, assert the value returned by describe method
+        expected: table_name equals with the table name created
+        '''
+        table_name = gen_unique_str("test_table")
+        param = {'table_name': table_name,
+                 'dimension': dim,
+                 'index_file_size': index_file_size,
+                 'metric_type': MetricType.L2}
+        connect.create_table(param)
+        status, res = connect.describe_table(table_name)
+        assert res.table_name == table_name
+        assert res.metric_type == MetricType.L2
+
+    def test_table_describe_table_name_ip(self, connect):
+        '''
+        target: test describe table created with correct params 
+        method: create table, assert the value returned by describe method
+        expected: table_name equals with the table name created
+        '''
+        table_name = gen_unique_str("test_table")
+        param = {'table_name': table_name,
+                 'dimension': dim,
+                 'index_file_size': index_file_size,
+                 'metric_type': MetricType.IP}
+        connect.create_table(param)
+        status, res = connect.describe_table(table_name)
+        assert res.table_name == table_name
+        assert res.metric_type == MetricType.IP
+
+    # TODO: enable
+    @pytest.mark.level(2)
+    def _test_table_describe_table_name_multiprocessing(self, connect, args):
+        '''
+        target: test describe table created with multiprocess 
+        method: create table, assert the value returned by describe method
+        expected: table_name equals with the table name created
+        '''
+        table_name = gen_unique_str("test_table")
+        uri = "tcp://%s:%s" % (args["ip"], args["port"])
+        param = {'table_name': table_name,
+                 'dimension': dim,
+                 'index_file_size': index_file_size, 
+                 'metric_type': MetricType.L2}
+        connect.create_table(param)
+
+        def describetable(milvus):
+            status, res = milvus.describe_table(table_name)
+            assert res.table_name == table_name
+
+        process_num = 4
+        processes = []
+        for i in range(process_num):
+            milvus = Milvus()
+            milvus.connect(uri=uri)
+            p = Process(target=describetable, args=(milvus,))
+            processes.append(p)
+            p.start()
+        for p in processes:
+            p.join()
+    
+    @pytest.mark.level(2)
+    def test_table_describe_without_connection(self, table, dis_connect):
+        '''
+        target: test describe table, without connection
+        method: describe table with correct params, with a disconnected instance
+        expected: describe raise exception
+        '''
+        with pytest.raises(Exception) as e:
+            status = dis_connect.describe_table(table)
+
+    def test_table_describe_dimension(self, connect):
+        '''
+        target: test describe table created with correct params 
+        method: create table, assert the dimention value returned by describe method
+        expected: dimention equals with dimention when created
+        '''
+        table_name = gen_unique_str("test_table")
+        param = {'table_name': table_name,
+                 'dimension': dim+1,
+                 'index_file_size': index_file_size,
+                 'metric_type': MetricType.L2}
+        connect.create_table(param)
+        status, res = connect.describe_table(table_name)
+        assert res.dimension == dim+1
+
+    """
+    ******************************************************************
+      The following cases are used to test `delete_table` function
+    ******************************************************************
+    """
+
+    def test_delete_table(self, connect, table):
+        '''
+        target: test delete table created with correct params 
+        method: create table and then delete, 
+            assert the value returned by delete method
+        expected: status ok, and no table in tables
+        '''
+        status = connect.delete_table(table)
+        assert not assert_has_table(connect, table)
+
+    def test_delete_table_ip(self, connect, ip_table):
+        '''
+        target: test delete table created with correct params 
+        method: create table and then delete, 
+            assert the value returned by delete method
+        expected: status ok, and no table in tables
+        '''
+        status = connect.delete_table(ip_table)
+        assert not assert_has_table(connect, ip_table)
+
+    @pytest.mark.level(2)
+    def test_table_delete_without_connection(self, table, dis_connect):
+        '''
+        target: test describe table, without connection
+        method: describe table with correct params, with a disconnected instance
+        expected: describe raise exception
+        '''
+        with pytest.raises(Exception) as e:
+            status = dis_connect.delete_table(table)
+
+    def test_delete_table_not_existed(self, connect):
+        '''
+        target: test delete table not in index
+        method: delete all tables, and delete table again, 
+            assert the value returned by delete method
+        expected: status not ok
+        '''
+        table_name = gen_unique_str("test_table")
+        status = connect.delete_table(table_name)
+        assert not status.code==0
+
+    def test_delete_table_repeatedly(self, connect):
+        '''
+        target: test delete table created with correct params 
+        method: create table and delete new table repeatedly, 
+            assert the value returned by delete method
+        expected: create ok and delete ok
+        '''
+        loops = 1
+        for i in range(loops):
+            table_name = gen_unique_str("test_table")
+            param = {'table_name': table_name,
+                 'dimension': dim,
+                 'index_file_size': index_file_size,
+                 'metric_type': MetricType.L2}
+            connect.create_table(param)
+            status = connect.delete_table(table_name)
+            time.sleep(1)
+            assert not assert_has_table(connect, table_name)
+
+    def test_delete_create_table_repeatedly(self, connect):
+        '''
+        target: test delete and create the same table repeatedly
+        method: try to create the same table and delete repeatedly,
+            assert the value returned by delete method
+        expected: create ok and delete ok
+        '''
+        loops = 5
+        for i in range(loops):
+            table_name = "test_table"
+            param = {'table_name': table_name,
+                 'dimension': dim,
+                 'index_file_size': index_file_size,
+                 'metric_type': MetricType.L2}
+            connect.create_table(param)
+            status = connect.delete_table(table_name)
+            time.sleep(2)
+            assert status.OK()
+
+    @pytest.mark.level(2)
+    def test_delete_create_table_repeatedly_ip(self, connect):
+        '''
+        target: test delete and create the same table repeatedly
+        method: try to create the same table and delete repeatedly,
+            assert the value returned by delete method
+        expected: create ok and delete ok
+        '''
+        loops = 5
+        for i in range(loops):
+            table_name = "test_table"
+            param = {'table_name': table_name,
+                 'dimension': dim,
+                 'index_file_size': index_file_size,
+                 'metric_type': MetricType.IP}
+            connect.create_table(param)
+            status = connect.delete_table(table_name)
+            time.sleep(2)
+            assert status.OK()
+
+    # TODO: enable
+    @pytest.mark.level(2)
+    def _test_delete_table_multiprocessing(self, args):
+        '''
+        target: test delete table with multiprocess 
+        method: create table and then delete, 
+            assert the value returned by delete method
+        expected: status ok, and no table in tables
+        '''
+        process_num = 6
+        processes = []
+        uri = "tcp://%s:%s" % (args["ip"], args["port"])
+
+        def deletetable(milvus):
+            status = milvus.delete_table(table)
+            # assert not status.code==0
+            assert assert_has_table(milvus, table)
+            assert status.OK()
+
+        for i in range(process_num):
+            milvus = Milvus()
+            milvus.connect(uri=uri)
+            p = Process(target=deletetable, args=(milvus,))
+            processes.append(p)
+            p.start()
+        for p in processes:
+            p.join()
+
+    # TODO: enable
+    @pytest.mark.level(2)
+    def _test_delete_table_multiprocessing_multitable(self, connect):
+        '''
+        target: test delete table with multiprocess 
+        method: create table and then delete, 
+            assert the value returned by delete method
+        expected: status ok, and no table in tables
+        '''
+        process_num = 5
+        loop_num = 2
+        processes = []
+
+        table = []
+        j = 0
+        while j < (process_num*loop_num):
+            table_name = gen_unique_str("test_delete_table_with_multiprocessing")
+            table.append(table_name)
+            param = {'table_name': table_name,
+                 'dimension': dim,
+                 'index_file_size': index_file_size,
+                 'metric_type': MetricType.L2}
+            connect.create_table(param)
+            j = j + 1
+
+        def delete(connect,ids):
+            i = 0
+            while i < loop_num:
+                status = connect.delete_table(table[ids*process_num+i])
+                time.sleep(2)
+                assert status.OK()
+                assert not assert_has_table(connect, table[ids*process_num+i])
+                i = i + 1
+
+        for i in range(process_num):
+            ids = i
+            p = Process(target=delete, args=(connect,ids))
+            processes.append(p)
+            p.start()
+        for p in processes:
+            p.join()
+
+    """
+    ******************************************************************
+      The following cases are used to test `has_table` function
+    ******************************************************************
+    """
+
+    def test_has_table(self, connect):
+        '''
+        target: test if the created table existed
+        method: create table, assert the value returned by has_table method
+        expected: True
+        '''
+        table_name = gen_unique_str("test_table")
+        param = {'table_name': table_name,
+                 'dimension': dim,
+                 'index_file_size': index_file_size,
+                 'metric_type': MetricType.L2}
+        connect.create_table(param)
+        assert assert_has_table(connect, table_name)
+
+    def test_has_table_ip(self, connect):
+        '''
+        target: test if the created table existed
+        method: create table, assert the value returned by has_table method
+        expected: True
+        '''
+        table_name = gen_unique_str("test_table")
+        param = {'table_name': table_name,
+                 'dimension': dim,
+                 'index_file_size': index_file_size,
+                 'metric_type': MetricType.IP}
+        connect.create_table(param)
+        assert assert_has_table(connect, table_name)
+
+    @pytest.mark.level(2)
+    def test_has_table_without_connection(self, table, dis_connect):
+        '''
+        target: test has table, without connection
+        method: calling has table with correct params, with a disconnected instance
+        expected: has table raise exception
+        '''
+        with pytest.raises(Exception) as e:
+            assert_has_table(dis_connect, table)
+
+    def test_has_table_not_existed(self, connect):
+        '''
+        target: test if table not created
+        method: random a table name, which not existed in db, 
+            assert the value returned by has_table method
+        expected: False
+        '''
+        table_name = gen_unique_str("test_table")
+        assert not assert_has_table(connect, table_name)
+
+    """
+    ******************************************************************
+      The following cases are used to test `show_tables` function
+    ******************************************************************
+    """
+
+    def test_show_tables(self, connect):
+        '''
+        target: test show tables is correct or not, if table created
+        method: create table, assert the value returned by show_tables method is equal to 0
+        expected: table_name in show tables   
+        '''
+        table_name = gen_unique_str("test_table")
+        param = {'table_name': table_name,
+                 'dimension': dim,
+                 'index_file_size': index_file_size,
+                 'metric_type': MetricType.L2}
+        connect.create_table(param)    
+        status, result = connect.show_tables()
+        assert status.OK()
+        assert table_name in result
+
+    def test_show_tables_ip(self, connect):
+        '''
+        target: test show tables is correct or not, if table created
+        method: create table, assert the value returned by show_tables method is equal to 0
+        expected: table_name in show tables   
+        '''
+        table_name = gen_unique_str("test_table")
+        param = {'table_name': table_name,
+                 'dimension': dim,
+                 'index_file_size': index_file_size,
+                 'metric_type': MetricType.IP}
+        connect.create_table(param)    
+        status, result = connect.show_tables()
+        assert status.OK()
+        assert table_name in result
+
+    @pytest.mark.level(2)
+    def test_show_tables_without_connection(self, dis_connect):
+        '''
+        target: test show_tables, without connection
+        method: calling show_tables with correct params, with a disconnected instance
+        expected: show_tables raise exception
+        '''
+        with pytest.raises(Exception) as e:
+            status = dis_connect.show_tables()
+
+    def test_show_tables_no_table(self, connect):
+        '''
+        target: test show tables is correct or not, if no table in db
+        method: delete all tables,
+            assert the value returned by show_tables method is equal to []
+        expected: the status is ok, and the result is equal to []      
+        '''
+        status, result = connect.show_tables()
+        if result:
+            for table_name in result:
+                connect.delete_table(table_name)
+        time.sleep(delete_table_interval_time)
+        status, result = connect.show_tables()
+        assert status.OK()
+        assert len(result) == 0
+
+    # TODO: enable
+    @pytest.mark.level(2)
+    def _test_show_tables_multiprocessing(self, connect, args):
+        '''
+        target: test show tables is correct or not with processes
+        method: create table, assert the value returned by show_tables method is equal to 0
+        expected: table_name in show tables
+        '''
+        table_name = gen_unique_str("test_table")
+        uri = "tcp://%s:%s" % (args["ip"], args["port"])
+        param = {'table_name': table_name,
+                 'dimension': dim,
+                 'index_file_size': index_file_size,
+                 'metric_type': MetricType.L2}
+        connect.create_table(param)
+
+        def showtables(milvus):
+            status, result = milvus.show_tables()
+            assert status.OK()
+            assert table_name in result
+
+        process_num = 8
+        processes = []
+
+        for i in range(process_num):
+            milvus = Milvus()
+            milvus.connect(uri=uri)
+            p = Process(target=showtables, args=(milvus,))
+            processes.append(p)
+            p.start()
+        for p in processes:
+            p.join()
+
+    """
+    ******************************************************************
+      The following cases are used to test `preload_table` function
+    ******************************************************************
+    """
+
+    """
+    generate valid create_index params
+    """
+    @pytest.fixture(
+        scope="function",
+        params=gen_index_params()
+    )
+    def get_index_params(self, request, args):
+        if "internal" not in args:
+            if request.param["index_type"] == IndexType.IVF_SQ8H:
+                pytest.skip("sq8h not support in open source")
+        return request.param
+
+    @pytest.mark.level(1)
+    def test_preload_table(self, connect, table, get_index_params):
+        index_params = get_index_params
+        status, ids = connect.add_vectors(table, vectors)
+        status = connect.create_index(table, index_params)
+        status = connect.preload_table(table)
+        assert status.OK()
+
+    @pytest.mark.level(1)
+    def test_preload_table_ip(self, connect, ip_table, get_index_params):
+        index_params = get_index_params
+        status, ids = connect.add_vectors(ip_table, vectors)
+        status = connect.create_index(ip_table, index_params)
+        status = connect.preload_table(ip_table)
+        assert status.OK()
+
+    @pytest.mark.level(1)
+    def test_preload_table_not_existed(self, connect, table):
+        table_name = gen_unique_str("test_preload_table_not_existed")
+        index_params = random.choice(gen_index_params())
+        status, ids = connect.add_vectors(table, vectors)
+        status = connect.create_index(table, index_params)
+        status = connect.preload_table(table_name)
+        assert not status.OK()
+
+    @pytest.mark.level(1)
+    def test_preload_table_not_existed_ip(self, connect, ip_table):
+        table_name = gen_unique_str("test_preload_table_not_existed")
+        index_params = random.choice(gen_index_params())
+        status, ids = connect.add_vectors(ip_table, vectors)
+        status = connect.create_index(ip_table, index_params)
+        status = connect.preload_table(table_name)
+        assert not status.OK()
+
+    @pytest.mark.level(1)
+    def test_preload_table_no_vectors(self, connect, table):
+        status = connect.preload_table(table)
+        assert status.OK()
+
+    @pytest.mark.level(1)
+    def test_preload_table_no_vectors_ip(self, connect, ip_table):
+        status = connect.preload_table(ip_table)
+        assert status.OK()
+
+    # TODO: psutils get memory usage
+    @pytest.mark.level(1)
+    def test_preload_table_memory_usage(self, connect, table):
+        pass
+
+
+class TestTableInvalid(object):
+    """
+    Test creating table with invalid table names
+    """
+    @pytest.fixture(
+        scope="function",
+        params=gen_invalid_table_names()
+    )
+    def get_table_name(self, request):
+        yield request.param
+
+    def test_create_table_with_invalid_tablename(self, connect, get_table_name):
+        table_name = get_table_name
+        param = {'table_name': table_name,
+                 'dimension': dim,
+                 'index_file_size': index_file_size,
+                 'metric_type': MetricType.L2}
+        status = connect.create_table(param)
+        assert not status.OK()
+
+    def test_create_table_with_empty_tablename(self, connect):
+        table_name = ''
+        param = {'table_name': table_name,
+                 'dimension': dim,
+                 'index_file_size': index_file_size,
+                 'metric_type': MetricType.L2}
+        with pytest.raises(Exception) as e:
+            status = connect.create_table(param)
+
+    def test_preload_table_with_invalid_tablename(self, connect):
+        table_name = ''
+        with pytest.raises(Exception) as e:
+            status = connect.preload_table(table_name)
+
+
+class TestCreateTableDimInvalid(object):
+    """
+    Test creating table with invalid dimension
+    """
+    @pytest.fixture(
+        scope="function",
+        params=gen_invalid_dims()
+    )
+    def get_dim(self, request):
+        yield request.param
+
+    @pytest.mark.timeout(5)
+    def test_create_table_with_invalid_dimension(self, connect, get_dim):
+        dimension = get_dim
+        table = gen_unique_str("test_create_table_with_invalid_dimension")
+        param = {'table_name': table,
+                 'dimension': dimension,
+                 'index_file_size': index_file_size,
+                 'metric_type': MetricType.L2}
+        if isinstance(dimension, int):
+            status = connect.create_table(param)
+            assert not status.OK()
+        else:
+            with pytest.raises(Exception) as e:
+                status = connect.create_table(param)
+            
+
+# TODO: max / min index file size
+class TestCreateTableIndexSizeInvalid(object):
+    """
+    Test creating tables with invalid index_file_size
+    """
+    @pytest.fixture(
+        scope="function",
+        params=gen_invalid_file_sizes()
+    )
+    def get_file_size(self, request):
+        yield request.param
+
+    @pytest.mark.level(2)
+    def test_create_table_with_invalid_file_size(self, connect, table, get_file_size):
+        file_size = get_file_size
+        param = {'table_name': table,
+                 'dimension': dim,
+                 'index_file_size': file_size,
+                 'metric_type': MetricType.L2}
+        if isinstance(file_size, int) and file_size > 0:
+            status = connect.create_table(param)
+            assert not status.OK()
+        else:
+            with pytest.raises(Exception) as e:
+                status = connect.create_table(param)
+
+
+class TestCreateMetricTypeInvalid(object):
+    """
+    Test creating tables with invalid metric_type
+    """
+    @pytest.fixture(
+        scope="function",
+        params=gen_invalid_metric_types()
+    )
+    def get_metric_type(self, request):
+        yield request.param
+
+    @pytest.mark.level(2)
+    def test_create_table_with_invalid_file_size(self, connect, table, get_metric_type):
+        metric_type = get_metric_type
+        param = {'table_name': table,
+                 'dimension': dim,
+                 'index_file_size': 10,
+                 'metric_type': metric_type}
+        with pytest.raises(Exception) as e:
+            status = connect.create_table(param)
+
+
+def create_table(connect, **params):
+    param = {'table_name': params["table_name"],
+             'dimension': params["dimension"],
+             'index_file_size': index_file_size,
+             'metric_type': MetricType.L2}
+    status = connect.create_table(param)
+    return status
+
+def search_table(connect, **params):
+    status, result = connect.search_vectors(
+        params["table_name"], 
+        params["top_k"], 
+        params["nprobe"],
+        params["query_vectors"])
+    return status
+
+def preload_table(connect, **params):
+    status = connect.preload_table(params["table_name"])
+    return status
+
+def has(connect, **params):
+    status = assert_has_table(connect, params["table_name"])
+    return status
+
+def show(connect, **params):
+    status, result = connect.show_tables()
+    return status
+
+def delete(connect, **params):
+    status = connect.delete_table(params["table_name"])
+    return status
+
+def describe(connect, **params):
+    status, result = connect.describe_table(params["table_name"])
+    return status
+
+def rowcount(connect, **params):
+    status, result = connect.get_table_row_count(params["table_name"])
+    return status
+
+def create_index(connect, **params):
+    status = connect.create_index(params["table_name"], params["index_params"])
+    return status
+
+func_map = { 
+    # 0:has, 
+    1:show,
+    10:create_table, 
+    11:describe,
+    12:rowcount,
+    13:search_table,
+    14:preload_table,
+    15:create_index,
+    30:delete
+}
+
+def gen_sequence():
+    raw_seq = func_map.keys()
+    result = itertools.permutations(raw_seq)
+    for x in result:
+        yield x
+
+class TestTableLogic(object):
+
+    @pytest.mark.parametrize("logic_seq", gen_sequence())
+    @pytest.mark.level(2)
+    def test_logic(self, connect, logic_seq):
+        if self.is_right(logic_seq):
+            self.execute(logic_seq, connect)
+        else:
+            self.execute_with_error(logic_seq, connect)
+
+    def is_right(self, seq):
+        if sorted(seq) == seq:
+            return True
+
+        not_created = True
+        has_deleted = False
+        for i in range(len(seq)):
+            if seq[i] > 10 and not_created:
+                return False
+            elif seq [i] > 10 and has_deleted:
+                return False
+            elif seq[i] == 10:
+                not_created = False
+            elif seq[i] == 30:
+                has_deleted = True
+
+        return True
+
+    def execute(self, logic_seq, connect):
+        basic_params = self.gen_params()
+        for i in range(len(logic_seq)):
+            # logging.getLogger().info(logic_seq[i])
+            f = func_map[logic_seq[i]]
+            status = f(connect, **basic_params)
+            assert status.OK()
+
+    def execute_with_error(self, logic_seq, connect):
+        basic_params = self.gen_params()
+
+        error_flag = False
+        for i in range(len(logic_seq)):
+            f = func_map[logic_seq[i]]
+            status = f(connect, **basic_params)
+            if not status.OK():
+                # logging.getLogger().info(logic_seq[i])
+                error_flag = True
+                break
+        assert error_flag == True
+
+    def gen_params(self):
+        table_name = gen_unique_str("test_table")
+        top_k = 1
+        vectors = gen_vectors(2, dim)
+        param = {'table_name': table_name,
+                 'dimension': dim,
+                 'index_type': IndexType.IVFLAT,
+                 'metric_type': MetricType.L2,
+                 'nprobe': 1,
+                 'top_k': top_k,
+                 'index_params': {
+                        'index_type': IndexType.IVF_SQ8,
+                        'nlist': 16384
+                 },
+                 'query_vectors': vectors}
+        return param
diff --git a/tests/milvus_python_test/test_table_count.py b/tests/milvus_python_test/test_table_count.py
new file mode 100644
index 0000000000..820fb9d546
--- /dev/null
+++ b/tests/milvus_python_test/test_table_count.py
@@ -0,0 +1,302 @@
+import random
+import pdb
+
+import pytest
+import logging
+import itertools
+
+from time import sleep
+from multiprocessing import Process
+from milvus import Milvus
+from utils import *
+from milvus import IndexType, MetricType
+
+dim = 128
+index_file_size = 10
+add_time_interval = 5
+
+
+class TestTableCount:
+    """
+    params means different nb, the nb value may trigger merge, or not
+    """
+    @pytest.fixture(
+        scope="function",
+        params=[
+            100,
+            5000,
+            100000,
+        ],
+    )
+    def add_vectors_nb(self, request):
+        yield request.param
+
+    """
+    generate valid create_index params
+    """
+    @pytest.fixture(
+        scope="function",
+        params=gen_index_params()
+    )
+    def get_index_params(self, request, args):
+        if "internal" not in args:
+            if request.param["index_type"] == IndexType.IVF_SQ8H:
+                pytest.skip("sq8h not support in open source")
+        return request.param
+
+    def test_table_rows_count(self, connect, table, add_vectors_nb):
+        '''
+        target: test table rows_count is correct or not
+        method: create table and add vectors in it,
+            assert the value returned by get_table_row_count method is equal to length of vectors
+        expected: the count is equal to the length of vectors
+        '''
+        nb = add_vectors_nb
+        vectors = gen_vectors(nb, dim)
+        res = connect.add_vectors(table_name=table, records=vectors)
+        time.sleep(add_time_interval)
+        status, res = connect.get_table_row_count(table)
+        assert res == nb
+
+    def test_table_rows_count_after_index_created(self, connect, table, get_index_params):
+        '''
+        target: test get_table_row_count, after index have been created
+        method: add vectors in db, and create index, then calling get_table_row_count with correct params 
+        expected: get_table_row_count raise exception
+        '''
+        nb = 100
+        index_params = get_index_params
+        vectors = gen_vectors(nb, dim)
+        res = connect.add_vectors(table_name=table, records=vectors)
+        time.sleep(add_time_interval)
+        # logging.getLogger().info(index_params)
+        connect.create_index(table, index_params)
+        status, res = connect.get_table_row_count(table)
+        assert res == nb
+
+    @pytest.mark.level(2)
+    def test_count_without_connection(self, table, dis_connect):
+        '''
+        target: test get_table_row_count, without connection
+        method: calling get_table_row_count with correct params, with a disconnected instance
+        expected: get_table_row_count raise exception
+        '''
+        with pytest.raises(Exception) as e:
+            status = dis_connect.get_table_row_count(table)
+
+    def test_table_rows_count_no_vectors(self, connect, table):
+        '''
+        target: test table rows_count is correct or not, if table is empty
+        method: create table and no vectors in it,
+            assert the value returned by get_table_row_count method is equal to 0
+        expected: the count is equal to 0
+        '''
+        table_name = gen_unique_str("test_table")
+        param = {'table_name': table_name,
+                 'dimension': dim,
+                 'index_file_size': index_file_size}
+        connect.create_table(param)        
+        status, res = connect.get_table_row_count(table)
+        assert res == 0
+
+    # TODO: enable
+    @pytest.mark.level(2)
+    @pytest.mark.timeout(20)
+    def _test_table_rows_count_multiprocessing(self, connect, table, args):
+        '''
+        target: test table rows_count is correct or not with multiprocess
+        method: create table and add vectors in it,
+            assert the value returned by get_table_row_count method is equal to length of vectors
+        expected: the count is equal to the length of vectors
+        '''
+        nq = 2
+        uri = "tcp://%s:%s" % (args["ip"], args["port"])
+        vectors = gen_vectors(nq, dim)
+        res = connect.add_vectors(table_name=table, records=vectors)
+        time.sleep(add_time_interval)
+
+        def rows_count(milvus):
+            status, res = milvus.get_table_row_count(table)
+            logging.getLogger().info(status)
+            assert res == nq
+
+        process_num = 8
+        processes = []
+        for i in range(process_num):
+            milvus = Milvus()
+            milvus.connect(uri=uri)
+            p = Process(target=rows_count, args=(milvus, ))
+            processes.append(p)
+            p.start()
+            logging.getLogger().info(p)
+        for p in processes:
+            p.join()
+
+    def test_table_rows_count_multi_tables(self, connect):
+        '''
+        target: test table rows_count is correct or not with multiple tables of L2
+        method: create table and add vectors in it,
+            assert the value returned by get_table_row_count method is equal to length of vectors
+        expected: the count is equal to the length of vectors
+        '''
+        nq = 100
+        vectors = gen_vectors(nq, dim)
+        table_list = []
+        for i in range(50):
+            table_name = gen_unique_str('test_table_rows_count_multi_tables')
+            table_list.append(table_name)
+            param = {'table_name': table_name,
+                     'dimension': dim,
+                     'index_file_size': index_file_size,
+                     'metric_type': MetricType.L2}
+            connect.create_table(param)
+            res = connect.add_vectors(table_name=table_name, records=vectors)
+        time.sleep(2)
+        for i in range(50):
+            status, res = connect.get_table_row_count(table_list[i])
+            assert status.OK()
+            assert res == nq
+
+
+class TestTableCountIP:
+    """
+    params means different nb, the nb value may trigger merge, or not
+    """
+
+    @pytest.fixture(
+        scope="function",
+        params=[
+            100,
+            5000,
+            100000,
+        ],
+    )
+    def add_vectors_nb(self, request):
+        yield request.param
+
+    """
+    generate valid create_index params
+    """
+
+    @pytest.fixture(
+        scope="function",
+        params=gen_index_params()
+    )
+    def get_index_params(self, request, args):
+        if "internal" not in args:
+            if request.param["index_type"] == IndexType.IVF_SQ8H:
+                pytest.skip("sq8h not support in open source")
+        return request.param
+
+    def test_table_rows_count(self, connect, ip_table, add_vectors_nb):
+        '''
+        target: test table rows_count is correct or not
+        method: create table and add vectors in it,
+            assert the value returned by get_table_row_count method is equal to length of vectors
+        expected: the count is equal to the length of vectors
+        '''
+        nb = add_vectors_nb
+        vectors = gen_vectors(nb, dim)
+        res = connect.add_vectors(table_name=ip_table, records=vectors)
+        time.sleep(add_time_interval)
+        status, res = connect.get_table_row_count(ip_table)
+        assert res == nb
+
+    def test_table_rows_count_after_index_created(self, connect, ip_table, get_index_params):
+        '''
+        target: test get_table_row_count, after index have been created
+        method: add vectors in db, and create index, then calling get_table_row_count with correct params
+        expected: get_table_row_count raise exception
+        '''
+        nb = 100
+        index_params = get_index_params
+        vectors = gen_vectors(nb, dim)
+        res = connect.add_vectors(table_name=ip_table, records=vectors)
+        time.sleep(add_time_interval)
+        # logging.getLogger().info(index_params)
+        connect.create_index(ip_table, index_params)
+        status, res = connect.get_table_row_count(ip_table)
+        assert res == nb
+
+    @pytest.mark.level(2)
+    def test_count_without_connection(self, ip_table, dis_connect):
+        '''
+        target: test get_table_row_count, without connection
+        method: calling get_table_row_count with correct params, with a disconnected instance
+        expected: get_table_row_count raise exception
+        '''
+        with pytest.raises(Exception) as e:
+            status = dis_connect.get_table_row_count(ip_table)
+
+    def test_table_rows_count_no_vectors(self, connect, ip_table):
+        '''
+        target: test table rows_count is correct or not, if table is empty
+        method: create table and no vectors in it,
+            assert the value returned by get_table_row_count method is equal to 0
+        expected: the count is equal to 0
+        '''
+        table_name = gen_unique_str("test_table")
+        param = {'table_name': table_name,
+                 'dimension': dim,
+                 'index_file_size': index_file_size}
+        connect.create_table(param)
+        status, res = connect.get_table_row_count(ip_table)
+        assert res == 0
+
+    # TODO: enable
+    @pytest.mark.level(2)
+    @pytest.mark.timeout(20)
+    def _test_table_rows_count_multiprocessing(self, connect, ip_table, args):
+        '''
+        target: test table rows_count is correct or not with multiprocess
+        method: create table and add vectors in it,
+            assert the value returned by get_table_row_count method is equal to length of vectors
+        expected: the count is equal to the length of vectors
+        '''
+        nq = 2
+        uri = "tcp://%s:%s" % (args["ip"], args["port"])
+        vectors = gen_vectors(nq, dim)
+        res = connect.add_vectors(table_name=ip_table, records=vectors)
+        time.sleep(add_time_interval)
+
+        def rows_count(milvus):
+            status, res = milvus.get_table_row_count(ip_table)
+            logging.getLogger().info(status)
+            assert res == nq
+
+        process_num = 8
+        processes = []
+        for i in range(process_num):
+            milvus = Milvus()
+            milvus.connect(uri=uri)
+            p = Process(target=rows_count, args=(milvus,))
+            processes.append(p)
+            p.start()
+            logging.getLogger().info(p)
+        for p in processes:
+            p.join()
+
+    def test_table_rows_count_multi_tables(self, connect):
+        '''
+        target: test table rows_count is correct or not with multiple tables of IP
+        method: create table and add vectors in it,
+            assert the value returned by get_table_row_count method is equal to length of vectors
+        expected: the count is equal to the length of vectors
+        '''
+        nq = 100
+        vectors = gen_vectors(nq, dim)
+        table_list = []
+        for i in range(50):
+            table_name = gen_unique_str('test_table_rows_count_multi_tables')
+            table_list.append(table_name)
+            param = {'table_name': table_name,
+                     'dimension': dim,
+                     'index_file_size': index_file_size,
+                     'metric_type': MetricType.IP}
+            connect.create_table(param)
+            res = connect.add_vectors(table_name=table_name, records=vectors)
+        time.sleep(2)
+        for i in range(50):
+            status, res = connect.get_table_row_count(table_list[i])
+            assert status.OK()
+            assert res == nq
\ No newline at end of file
diff --git a/tests/milvus_python_test/utils.py b/tests/milvus_python_test/utils.py
new file mode 100644
index 0000000000..806af62f57
--- /dev/null
+++ b/tests/milvus_python_test/utils.py
@@ -0,0 +1,551 @@
+# STL imports
+import random
+import string
+import struct
+import sys
+import time, datetime
+import copy
+import numpy as np
+from utils import *
+from milvus import Milvus, IndexType, MetricType
+
+
+def gen_inaccuracy(num):
+    return num/255.0
+
+def gen_vectors(num, dim):
+    return [[random.random() for _ in range(dim)] for _ in range(num)]
+
+
+def gen_single_vector(dim):
+    return [[random.random() for _ in range(dim)]]
+
+
+def gen_vector(nb, d, seed=np.random.RandomState(1234)):
+    xb = seed.rand(nb, d).astype("float32")
+    return xb.tolist()
+
+
+def gen_unique_str(str=None):
+    prefix = "".join(random.choice(string.ascii_letters + string.digits) for _ in range(8))
+    return prefix if str is None else str + "_" + prefix
+
+
+def get_current_day():
+    return time.strftime('%Y-%m-%d', time.localtime())
+
+
+def get_last_day(day):
+    tmp = datetime.datetime.now()-datetime.timedelta(days=day)
+    return tmp.strftime('%Y-%m-%d')
+
+
+def get_next_day(day):
+    tmp = datetime.datetime.now()+datetime.timedelta(days=day)
+    return tmp.strftime('%Y-%m-%d')
+
+
+def gen_long_str(num):
+    string = ''
+    for _ in range(num):
+        char = random.choice('tomorrow')
+        string += char
+
+
+def gen_invalid_ips():
+    ips = [
+            "255.0.0.0",
+            "255.255.0.0",
+            "255.255.255.0",
+            "255.255.255.255",
+            "127.0.0",
+            "123.0.0.2",
+            "12-s",
+            " ",
+            "12 s",
+            "BB。A",
+            " siede ",
+            "(mn)",
+            "\n",
+            "\t",
+            "中文",
+            "a".join("a" for i in range(256))
+    ]
+    return ips
+
+
+def gen_invalid_ports():
+    ports = [
+            # empty
+            " ",
+            -1,
+            # too big port
+            100000,
+            # not correct port
+            39540,
+            "BB。A",
+            " siede ",
+            "(mn)",
+            "\n",
+            "\t",
+            "中文"
+    ]
+    return ports
+
+
+def gen_invalid_uris():
+    ip = None
+    port = 19530
+
+    uris = [
+            " ",
+            "中文",
+
+            # invalid protocol
+            # "tc://%s:%s" % (ip, port),
+            # "tcp%s:%s" % (ip, port),
+
+            # # invalid port
+            # "tcp://%s:100000" % ip,
+            # "tcp://%s: " % ip,
+            # "tcp://%s:19540" % ip,
+            # "tcp://%s:-1" % ip,
+            # "tcp://%s:string" % ip,
+
+            # invalid ip
+            "tcp:// :%s" % port,
+            "tcp://123.0.0.1:%s" % port,
+            "tcp://127.0.0:%s" % port,
+            "tcp://255.0.0.0:%s" % port,
+            "tcp://255.255.0.0:%s" % port,
+            "tcp://255.255.255.0:%s" % port,
+            "tcp://255.255.255.255:%s" % port,
+            "tcp://\n:%s" % port,
+
+    ]
+    return uris
+
+
+def gen_invalid_table_names():
+    table_names = [
+            "12-s",
+            "12/s",
+            " ",
+            # "",
+            # None,
+            "12 s",
+            "BB。A",
+            "c|c",
+            " siede ",
+            "(mn)",
+            "#12s",
+            "pip+",
+            "=c",
+            "\n",
+            "\t",
+            "中文",
+            "a".join("a" for i in range(256))
+    ]
+    return table_names
+
+
+def gen_invalid_top_ks():
+    top_ks = [
+            0,
+            -1,
+            None,
+            [1,2,3],
+            (1,2),
+            {"a": 1},
+            " ",
+            "",
+            "String",
+            "12-s",
+            "BB。A",
+            " siede ",
+            "(mn)",
+            "#12s",
+            "pip+",
+            "=c",
+            "\n",
+            "\t",
+            "中文",
+            "a".join("a" for i in range(256))
+    ]
+    return top_ks
+
+
+def gen_invalid_dims():
+    dims = [
+            0,
+            -1,
+            100001,
+            1000000000000001,
+            None,
+            False,
+            [1,2,3],
+            (1,2),
+            {"a": 1},
+            " ",
+            "",
+            "String",
+            "12-s",
+            "BB。A",
+            " siede ",
+            "(mn)",
+            "#12s",
+            "pip+",
+            "=c",
+            "\n",
+            "\t",
+            "中文",
+            "a".join("a" for i in range(256))
+    ]
+    return dims
+
+
+def gen_invalid_file_sizes():
+    file_sizes = [
+            0,
+            -1,
+            1000000000000001,
+            None,
+            False,
+            [1,2,3],
+            (1,2),
+            {"a": 1},
+            " ",
+            "",
+            "String",
+            "12-s",
+            "BB。A",
+            " siede ",
+            "(mn)",
+            "#12s",
+            "pip+",
+            "=c",
+            "\n",
+            "\t",
+            "中文",
+            "a".join("a" for i in range(256))
+    ]
+    return file_sizes
+
+
+def gen_invalid_index_types():
+    invalid_types = [
+            0,
+            -1,
+            100,
+            1000000000000001,
+            # None,
+            False,
+            [1,2,3],
+            (1,2),
+            {"a": 1},
+            " ",
+            "",
+            "String",
+            "12-s",
+            "BB。A",
+            " siede ",
+            "(mn)",
+            "#12s",
+            "pip+",
+            "=c",
+            "\n",
+            "\t",
+            "中文",
+            "a".join("a" for i in range(256))
+    ]
+    return invalid_types
+
+
+def gen_invalid_nlists():
+    nlists = [
+            0,
+            -1,
+            1000000000000001,
+            # None,
+            [1,2,3],
+            (1,2),
+            {"a": 1},
+            " ",
+            "",
+            "String",
+            "12-s",
+            "BB。A",
+            " siede ",
+            "(mn)",
+            "#12s",
+            "pip+",
+            "=c",
+            "\n",
+            "\t",
+            "中文"
+    ]
+    return nlists
+
+
+def gen_invalid_nprobes():
+    nprobes = [
+            0,
+            -1,
+            1000000000000001,
+            None,
+            [1,2,3],
+            (1,2),
+            {"a": 1},
+            " ",
+            "",
+            "String",
+            "12-s",
+            "BB。A",
+            " siede ",
+            "(mn)",
+            "#12s",
+            "pip+",
+            "=c",
+            "\n",
+            "\t",
+            "中文"
+    ]
+    return nprobes
+
+
+def gen_invalid_metric_types():
+    metric_types = [
+            0,
+            -1,
+            1000000000000001,
+            # None,
+            [1,2,3],
+            (1,2),
+            {"a": 1},
+            " ",
+            "",
+            "String",
+            "12-s",
+            "BB。A",
+            " siede ",
+            "(mn)",
+            "#12s",
+            "pip+",
+            "=c",
+            "\n",
+            "\t",
+            "中文"    
+    ]
+    return metric_types
+
+
+def gen_invalid_vectors():
+    invalid_vectors = [
+            "1*2",
+            [],
+            [1],
+            [1,2],
+            [" "],
+            ['a'],
+            [None],
+            None,
+            (1,2),
+            {"a": 1},
+            " ",
+            "",
+            "String",
+            "12-s",
+            "BB。A",
+            " siede ",
+            "(mn)",
+            "#12s",
+            "pip+",
+            "=c",
+            "\n",
+            "\t",
+            "中文",
+            "a".join("a" for i in range(256))
+    ]
+    return invalid_vectors
+
+
+def gen_invalid_vector_ids():
+    invalid_vector_ids = [
+            1.0,
+            -1.0,
+            None,
+            # int 64
+            10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,
+            " ",
+            "",
+            "String",
+            "BB。A",
+            " siede ",
+            "(mn)",
+            "#12s",
+            "=c",
+            "\n",
+            "中文",
+    ]
+    return invalid_vector_ids
+
+
+
+def gen_invalid_query_ranges():
+    query_ranges = [
+            [(get_last_day(1), "")],
+            [(get_current_day(), "")],
+            [(get_next_day(1), "")],
+            [(get_current_day(), get_last_day(1))],
+            [(get_next_day(1), get_last_day(1))],
+            [(get_next_day(1), get_current_day())],
+            [(0, get_next_day(1))],
+            [(-1, get_next_day(1))],
+            [(1, get_next_day(1))],
+            [(100001, get_next_day(1))],
+            [(1000000000000001, get_next_day(1))],
+            [(None, get_next_day(1))],
+            [([1,2,3], get_next_day(1))],
+            [((1,2), get_next_day(1))],
+            [({"a": 1}, get_next_day(1))],
+            [(" ", get_next_day(1))],
+            [("", get_next_day(1))],
+            [("String", get_next_day(1))],
+            [("12-s", get_next_day(1))],
+            [("BB。A", get_next_day(1))],
+            [(" siede ", get_next_day(1))],
+            [("(mn)", get_next_day(1))],
+            [("#12s", get_next_day(1))],
+            [("pip+", get_next_day(1))],
+            [("=c", get_next_day(1))],
+            [("\n", get_next_day(1))],
+            [("\t", get_next_day(1))],
+            [("中文", get_next_day(1))],
+            [("a".join("a" for i in range(256)), get_next_day(1))]
+    ]
+    return query_ranges
+
+
+def gen_invalid_index_params():
+    index_params = []
+    for index_type in gen_invalid_index_types():
+        index_param = {"index_type": index_type, "nlist": 16384}
+        index_params.append(index_param)
+    for nlist in gen_invalid_nlists():
+        index_param = {"index_type": IndexType.IVFLAT, "nlist": nlist}
+        index_params.append(index_param)
+    return index_params
+
+
+def gen_index_params():
+    index_params = []
+    index_types = [IndexType.FLAT, IndexType.IVFLAT, IndexType.IVF_SQ8, IndexType.IVF_SQ8H]
+    nlists = [1, 16384, 50000]
+
+    def gen_params(index_types, nlists):
+        return [ {"index_type": index_type, "nlist": nlist} \
+            for index_type in index_types \
+                for nlist in nlists]
+
+    return gen_params(index_types, nlists)
+
+def gen_simple_index_params():
+    index_params = []
+    index_types = [IndexType.FLAT, IndexType.IVFLAT, IndexType.IVF_SQ8, IndexType.IVF_SQ8H]
+    nlists = [16384]
+
+    def gen_params(index_types, nlists):
+        return [ {"index_type": index_type, "nlist": nlist} \
+            for index_type in index_types \
+                for nlist in nlists]
+
+    return gen_params(index_types, nlists)
+
+
+def assert_has_table(conn, table_name):
+    status, ok = conn.has_table(table_name)
+    return status.OK() and ok
+    
+
+if __name__ == "__main__":
+    import numpy
+
+    dim = 128
+    nq = 10000
+    table = "test"
+
+
+    file_name = '/poc/yuncong/ann_1000m/query.npy'
+    data = np.load(file_name)
+    vectors = data[0:nq].tolist()
+    # print(vectors)
+
+    connect = Milvus()
+    # connect.connect(host="192.168.1.27")
+    # print(connect.show_tables())
+    # print(connect.get_table_row_count(table))
+    # sys.exit()
+    connect.connect(host="127.0.0.1")
+    connect.delete_table(table)
+    # sys.exit()
+    # time.sleep(2)
+    print(connect.get_table_row_count(table))
+    param = {'table_name': table,
+         'dimension': dim,
+         'metric_type': MetricType.L2,
+         'index_file_size': 10}
+    status = connect.create_table(param)
+    print(status)
+    print(connect.get_table_row_count(table))
+    # add vectors
+    for i in range(10):
+        status, ids = connect.add_vectors(table, vectors)
+        print(status)
+        print(ids[0])
+    # print(ids[0])
+    index_params = {"index_type": IndexType.IVFLAT, "nlist": 16384}
+    status = connect.create_index(table, index_params)
+    print(status)
+    # sys.exit()
+    query_vec = [vectors[0]]
+    # print(numpy.inner(numpy.array(query_vec[0]), numpy.array(query_vec[0])))
+    top_k = 12
+    nprobe = 1
+    for i in range(2):
+        result = connect.search_vectors(table, top_k, nprobe, query_vec)
+        print(result)
+    sys.exit()
+
+
+    table = gen_unique_str("test_add_vector_with_multiprocessing")
+    uri = "tcp://%s:%s" % (args["ip"], args["port"])
+    param = {'table_name': table,
+             'dimension': dim,
+             'index_file_size': index_file_size}
+    # create table
+    milvus = Milvus()
+    milvus.connect(uri=uri)
+    milvus.create_table(param)
+    vector = gen_single_vector(dim)
+
+    process_num = 4
+    loop_num = 10
+    processes = []
+    # with dependent connection
+    def add(milvus):
+        i = 0
+        while i < loop_num:
+            status, ids = milvus.add_vectors(table, vector)
+            i = i + 1
+    for i in range(process_num):
+        milvus = Milvus()
+        milvus.connect(uri=uri)
+        p = Process(target=add, args=(milvus,))
+        processes.append(p)
+        p.start()
+        time.sleep(0.2)
+    for p in processes:
+        p.join()
+    time.sleep(3)
+    status, count = milvus.get_table_row_count(table)
+    assert count == process_num * loop_num
\ No newline at end of file