diff --git a/README.md b/README.md
index ce10e7910..15bdd5519 100644
--- a/README.md
+++ b/README.md
@@ -27,7 +27,7 @@ The following collection shows Milvus versions and recommended PyMilvus versions
 | 2.1.\* | 2.1.3 |
 | 2.2.\* | 2.2.15 |
 | 2.3.\* | 2.3.7 |
-| 2.4.\* | 2.4.4 |
+| 2.4.\* | 2.4.9 |
 
 
 ## Installation
@@ -43,7 +43,7 @@ $ pip3 install pymilvus[bulk_writer] # for bulk_writer
 You can install a specific version of PyMilvus by:
 
 ```shell
-$ pip3 install pymilvus==2.4.4
+$ pip3 install pymilvus==2.4.9
 ```
 
 You can upgrade PyMilvus to the latest version by:
diff --git a/examples/README.md b/examples/README.md
new file mode 100644
index 000000000..df635b4e6
--- /dev/null
+++ b/examples/README.md
@@ -0,0 +1 @@
+# Examples
diff --git a/examples/milvus_client/alias.py b/examples/alias.py
similarity index 100%
rename from examples/milvus_client/alias.py
rename to examples/alias.py
diff --git a/examples/milvus_client/bm25.py b/examples/bm25.py
similarity index 100%
rename from examples/milvus_client/bm25.py
rename to examples/bm25.py
diff --git a/examples/example_bulkinsert_csv.py b/examples/bulk_import/example_bulkinsert_csv.py
similarity index 100%
rename from examples/example_bulkinsert_csv.py
rename to examples/bulk_import/example_bulkinsert_csv.py
diff --git a/examples/example_bulkinsert_json.py b/examples/bulk_import/example_bulkinsert_json.py
similarity index 100%
rename from examples/example_bulkinsert_json.py
rename to examples/bulk_import/example_bulkinsert_json.py
diff --git a/examples/example_bulkinsert_numpy.py b/examples/bulk_import/example_bulkinsert_numpy.py
similarity index 100%
rename from examples/example_bulkinsert_numpy.py
rename to examples/bulk_import/example_bulkinsert_numpy.py
diff --git a/examples/example_bulkinsert_withfunction.py b/examples/bulk_import/example_bulkinsert_withfunction.py
similarity index 100%
rename from examples/example_bulkinsert_withfunction.py
rename to examples/bulk_import/example_bulkinsert_withfunction.py
diff --git a/examples/example_bulkwriter.py b/examples/bulk_import/example_bulkwriter.py
similarity index 100%
rename from examples/example_bulkwriter.py
rename to examples/bulk_import/example_bulkwriter.py
diff --git a/examples/data/train_embeddings.csv b/examples/bulk_import/train_embeddings.csv
similarity index 100%
rename from examples/data/train_embeddings.csv
rename to examples/bulk_import/train_embeddings.csv
diff --git a/examples/example_tls1.py b/examples/cert/example_tls1.py
similarity index 100%
rename from examples/example_tls1.py
rename to examples/cert/example_tls1.py
diff --git a/examples/example_tls2.py b/examples/cert/example_tls2.py
similarity index 100%
rename from examples/example_tls2.py
rename to examples/cert/example_tls2.py
diff --git a/examples/milvus_client/compact.py b/examples/compact.py
similarity index 100%
rename from examples/milvus_client/compact.py
rename to examples/compact.py
diff --git a/examples/multithreading_hello_milvus.py b/examples/concurrency/multithreading_hello_milvus.py
similarity index 100%
rename from examples/multithreading_hello_milvus.py
rename to examples/concurrency/multithreading_hello_milvus.py
diff --git a/examples/milvus_client/customize_schema.py b/examples/customize_schema.py
similarity index 100%
rename from examples/milvus_client/customize_schema.py
rename to examples/customize_schema.py
diff --git a/examples/milvus_client/customize_schema_auto_id.py b/examples/customize_schema_auto_id.py
similarity index 100%
rename from examples/milvus_client/customize_schema_auto_id.py
rename to examples/customize_schema_auto_id.py
diff --git a/examples/bfloat16_example.py b/examples/datatypes/bfloat16_example.py
similarity index 100%
rename from examples/bfloat16_example.py
rename to examples/datatypes/bfloat16_example.py
diff --git a/examples/binary_example.py b/examples/datatypes/binary_example.py
similarity index 100%
rename from examples/binary_example.py
rename to examples/datatypes/binary_example.py
diff --git a/examples/dynamic_field.py b/examples/datatypes/dynamic_field.py
similarity index 100%
rename from examples/dynamic_field.py
rename to examples/datatypes/dynamic_field.py
diff --git a/examples/example_str.py b/examples/datatypes/example_str.py
similarity index 100%
rename from examples/example_str.py
rename to examples/datatypes/example_str.py
diff --git a/examples/float16_example.py b/examples/datatypes/float16_example.py
similarity index 100%
rename from examples/float16_example.py
rename to examples/datatypes/float16_example.py
diff --git a/examples/fuzzy_match.py b/examples/datatypes/fuzzy_match.py
similarity index 100%
rename from examples/fuzzy_match.py
rename to examples/datatypes/fuzzy_match.py
diff --git a/examples/hello_bm25.py b/examples/datatypes/hello_bm25.py
similarity index 100%
rename from examples/hello_bm25.py
rename to examples/datatypes/hello_bm25.py
diff --git a/examples/hello_milvus_array.py b/examples/datatypes/hello_milvus_array.py
similarity index 100%
rename from examples/hello_milvus_array.py
rename to examples/datatypes/hello_milvus_array.py
diff --git a/examples/hello_sparse.py b/examples/datatypes/hello_sparse.py
similarity index 100%
rename from examples/hello_sparse.py
rename to examples/datatypes/hello_sparse.py
diff --git a/examples/milvus_client/flush.py b/examples/flush.py
similarity index 100%
rename from examples/milvus_client/flush.py
rename to examples/flush.py
diff --git a/examples/milvus_client/get_server_version.py b/examples/get_server_version.py
similarity index 100%
rename from examples/milvus_client/get_server_version.py
rename to examples/get_server_version.py
diff --git a/examples/example_gpu_brute_force.py b/examples/gpu_indx/example_gpu_brute_force.py
similarity index 100%
rename from examples/example_gpu_brute_force.py
rename to examples/gpu_indx/example_gpu_brute_force.py
diff --git a/examples/example_gpu_cagra.py b/examples/gpu_indx/example_gpu_cagra.py
similarity index 100%
rename from examples/example_gpu_cagra.py
rename to examples/gpu_indx/example_gpu_cagra.py
diff --git a/examples/hybrid_search.py b/examples/hybrid_search.py
index 6a13045f0..28ae0b309 100644
--- a/examples/hybrid_search.py
+++ b/examples/hybrid_search.py
@@ -1,9 +1,7 @@
 import numpy as np
 from pymilvus import (
-    connections,
-    utility,
-    FieldSchema, CollectionSchema, DataType,
-    Collection,
+    MilvusClient,
+    DataType,
     AnnSearchRequest, RRFRanker, WeightedRanker,
 )
 
@@ -11,25 +9,26 @@
 search_latency_fmt = "search latency = {:.4f}s"
 num_entities, dim = 3000, 8
 
-print(fmt.format("start connecting to Milvus"))
-connections.connect("default", host="localhost", port="19530")
+collection_name = "hello_milvus"
+milvus_client = MilvusClient("http://localhost:19530")
 
-has = utility.has_collection("hello_milvus")
-print(f"Does collection hello_milvus exist in Milvus: {has}")
-if has:
-    utility.drop_collection("hello_milvus")
+has_collection = milvus_client.has_collection(collection_name, timeout=5)
+if has_collection:
+    milvus_client.drop_collection(collection_name)
 
-fields = [
-    FieldSchema(name="pk", dtype=DataType.VARCHAR, is_primary=True, auto_id=False, max_length=100),
-    FieldSchema(name="random", dtype=DataType.DOUBLE),
-    FieldSchema(name="embeddings", dtype=DataType.FLOAT_VECTOR, dim=dim),
-    FieldSchema(name="embeddings2", dtype=DataType.FLOAT_VECTOR, dim=dim)
-]
+schema = milvus_client.create_schema(auto_id=False, description="hello_milvus is the simplest demo to introduce the APIs")
+schema.add_field("pk", DataType.VARCHAR, is_primary=True, max_length=100)
+schema.add_field("random", DataType.DOUBLE)
+schema.add_field("embeddings", DataType.FLOAT_VECTOR, dim=dim)
+schema.add_field("embeddings2", DataType.FLOAT_VECTOR, dim=dim)
 
-schema = CollectionSchema(fields, "hello_milvus is the simplest demo to introduce the APIs")
+index_params = milvus_client.prepare_index_params()
+index_params.add_index(field_name = "embeddings", index_type = "IVF_FLAT", metric_type="L2", nlist=128)
+index_params.add_index(field_name = "embeddings2",index_type = "IVF_FLAT", metric_type="L2", nlist=128)
 
 print(fmt.format("Create collection `hello_milvus`"))
-hello_milvus = Collection("hello_milvus", schema, consistency_level="Strong", num_shards = 4)
+
+milvus_client.create_collection(collection_name, schema=schema, index_params=index_params, consistency_level="Strong")
 
 print(fmt.format("Start inserting entities"))
 rng = np.random.default_rng(seed=19530)
@@ -41,29 +40,19 @@
     rng.random((num_entities, dim)),    # field embeddings2, supports numpy.ndarray and list
 ]
 
-insert_result = hello_milvus.insert(entities)
+rows = [ {"pk": entities[0][i], "random": entities[1][i], "embeddings": entities[2][i], "embeddings2": entities[3][i]} for i in range (num_entities)]
 
-hello_milvus.flush()
-print(f"Number of entities in Milvus: {hello_milvus.num_entities}")  # check the num_entities
+insert_result = milvus_client.insert(collection_name, rows)
 
-print(fmt.format("Start Creating index IVF_FLAT"))
-index = {
-    "index_type": "IVF_FLAT",
-    "metric_type": "L2",
-    "params": {"nlist": 128},
-}
-
-hello_milvus.create_index("embeddings", index)
-hello_milvus.create_index("embeddings2", index)
 
 print(fmt.format("Start loading"))
-hello_milvus.load()
+milvus_client.load_collection(collection_name)
 
 field_names = ["embeddings", "embeddings2"]
+field_names = ["embeddings"]
 
 req_list = []
 nq = 1
-weights = [0.2, 0.3]
 default_limit = 5
 vectors_to_search = []
 
@@ -79,15 +68,8 @@
     req = AnnSearchRequest(**search_param)
     req_list.append(req)
 
-hybrid_res = hello_milvus.hybrid_search(req_list, WeightedRanker(*weights), default_limit, output_fields=["random"])
-
-print("rank by WightedRanker")
-for hits in hybrid_res:
-    for hit in hits:
-        print(f" hybrid search hit: {hit}")
-
 print("rank by RRFRanker")
-hybrid_res = hello_milvus.hybrid_search(req_list, RRFRanker(), default_limit, output_fields=["random"])
+hybrid_res = milvus_client.hybrid_search(collection_name, req_list, RRFRanker(), default_limit, output_fields=["random"])
 for hits in hybrid_res:
     for hit in hits:
         print(f" hybrid search hit: {hit}")
diff --git a/examples/hello_hybrid_bm25.py b/examples/hybrid_search/hello_hybrid_bm25.py
similarity index 100%
rename from examples/hello_hybrid_bm25.py
rename to examples/hybrid_search/hello_hybrid_bm25.py
diff --git a/examples/hello_hybrid_sparse_dense.py b/examples/hybrid_search/hello_hybrid_sparse_dense.py
similarity index 100%
rename from examples/hello_hybrid_sparse_dense.py
rename to examples/hybrid_search/hello_hybrid_sparse_dense.py
diff --git a/examples/hybrid_search/hybrid_search.py b/examples/hybrid_search/hybrid_search.py
new file mode 100644
index 000000000..6a13045f0
--- /dev/null
+++ b/examples/hybrid_search/hybrid_search.py
@@ -0,0 +1,93 @@
+import numpy as np
+from pymilvus import (
+    connections,
+    utility,
+    FieldSchema, CollectionSchema, DataType,
+    Collection,
+    AnnSearchRequest, RRFRanker, WeightedRanker,
+)
+
+fmt = "\n=== {:30} ===\n"
+search_latency_fmt = "search latency = {:.4f}s"
+num_entities, dim = 3000, 8
+
+print(fmt.format("start connecting to Milvus"))
+connections.connect("default", host="localhost", port="19530")
+
+has = utility.has_collection("hello_milvus")
+print(f"Does collection hello_milvus exist in Milvus: {has}")
+if has:
+    utility.drop_collection("hello_milvus")
+
+fields = [
+    FieldSchema(name="pk", dtype=DataType.VARCHAR, is_primary=True, auto_id=False, max_length=100),
+    FieldSchema(name="random", dtype=DataType.DOUBLE),
+    FieldSchema(name="embeddings", dtype=DataType.FLOAT_VECTOR, dim=dim),
+    FieldSchema(name="embeddings2", dtype=DataType.FLOAT_VECTOR, dim=dim)
+]
+
+schema = CollectionSchema(fields, "hello_milvus is the simplest demo to introduce the APIs")
+
+print(fmt.format("Create collection `hello_milvus`"))
+hello_milvus = Collection("hello_milvus", schema, consistency_level="Strong", num_shards = 4)
+
+print(fmt.format("Start inserting entities"))
+rng = np.random.default_rng(seed=19530)
+entities = [
+    # provide the pk field because `auto_id` is set to False
+    [str(i) for i in range(num_entities)],
+    rng.random(num_entities).tolist(),  # field random, only supports list
+    rng.random((num_entities, dim)),    # field embeddings, supports numpy.ndarray and list
+    rng.random((num_entities, dim)),    # field embeddings2, supports numpy.ndarray and list
+]
+
+insert_result = hello_milvus.insert(entities)
+
+hello_milvus.flush()
+print(f"Number of entities in Milvus: {hello_milvus.num_entities}")  # check the num_entities
+
+print(fmt.format("Start Creating index IVF_FLAT"))
+index = {
+    "index_type": "IVF_FLAT",
+    "metric_type": "L2",
+    "params": {"nlist": 128},
+}
+
+hello_milvus.create_index("embeddings", index)
+hello_milvus.create_index("embeddings2", index)
+
+print(fmt.format("Start loading"))
+hello_milvus.load()
+
+field_names = ["embeddings", "embeddings2"]
+
+req_list = []
+nq = 1
+weights = [0.2, 0.3]
+default_limit = 5
+vectors_to_search = []
+
+for i in range(len(field_names)):
+    # 4. generate search data
+    vectors_to_search = rng.random((nq, dim))
+    search_param = {
+        "data": vectors_to_search,
+        "anns_field": field_names[i],
+        "param": {"metric_type": "L2"},
+        "limit": default_limit,
+        "expr": "random > 0.5"}
+    req = AnnSearchRequest(**search_param)
+    req_list.append(req)
+
+hybrid_res = hello_milvus.hybrid_search(req_list, WeightedRanker(*weights), default_limit, output_fields=["random"])
+
+print("rank by WightedRanker")
+for hits in hybrid_res:
+    for hit in hits:
+        print(f" hybrid search hit: {hit}")
+
+print("rank by RRFRanker")
+hybrid_res = hello_milvus.hybrid_search(req_list, RRFRanker(), default_limit, output_fields=["random"])
+for hits in hybrid_res:
+    for hit in hits:
+        print(f" hybrid search hit: {hit}")
diff --git a/examples/milvus_client/index.py b/examples/index.py
similarity index 100%
rename from examples/milvus_client/index.py
rename to examples/index.py
diff --git a/examples/milvus_client/index_params.py b/examples/index_params.py
similarity index 100%
rename from examples/milvus_client/index_params.py
rename to examples/index_params.py
diff --git a/examples/milvus_client/hybrid_search.py b/examples/milvus_client/hybrid_search.py
deleted file mode 100644
index 28ae0b309..000000000
--- a/examples/milvus_client/hybrid_search.py
+++ /dev/null
@@ -1,75 +0,0 @@
-import numpy as np
-from pymilvus import (
-    MilvusClient,
-    DataType,
-    AnnSearchRequest, RRFRanker, WeightedRanker,
-)
-
-fmt = "\n=== {:30} ===\n"
-search_latency_fmt = "search latency = {:.4f}s"
-num_entities, dim = 3000, 8
-
-collection_name = "hello_milvus"
-milvus_client = MilvusClient("http://localhost:19530")
-
-has_collection = milvus_client.has_collection(collection_name, timeout=5)
-if has_collection:
-    milvus_client.drop_collection(collection_name)
-
-schema = milvus_client.create_schema(auto_id=False, description="hello_milvus is the simplest demo to introduce the APIs")
-schema.add_field("pk", DataType.VARCHAR, is_primary=True, max_length=100)
-schema.add_field("random", DataType.DOUBLE)
-schema.add_field("embeddings", DataType.FLOAT_VECTOR, dim=dim)
-schema.add_field("embeddings2", DataType.FLOAT_VECTOR, dim=dim)
-
-index_params = milvus_client.prepare_index_params()
-index_params.add_index(field_name = "embeddings", index_type = "IVF_FLAT", metric_type="L2", nlist=128)
-index_params.add_index(field_name = "embeddings2",index_type = "IVF_FLAT", metric_type="L2", nlist=128)
-
-print(fmt.format("Create collection `hello_milvus`"))
-
-milvus_client.create_collection(collection_name, schema=schema, index_params=index_params, consistency_level="Strong")
-
-print(fmt.format("Start inserting entities"))
-rng = np.random.default_rng(seed=19530)
-entities = [
-    # provide the pk field because `auto_id` is set to False
-    [str(i) for i in range(num_entities)],
-    rng.random(num_entities).tolist(),  # field random, only supports list
-    rng.random((num_entities, dim)),    # field embeddings, supports numpy.ndarray and list
-    rng.random((num_entities, dim)),    # field embeddings2, supports numpy.ndarray and list
-]
-
-rows = [ {"pk": entities[0][i], "random": entities[1][i], "embeddings": entities[2][i], "embeddings2": entities[3][i]} for i in range (num_entities)]
-
-insert_result = milvus_client.insert(collection_name, rows)
-
-
-print(fmt.format("Start loading"))
-milvus_client.load_collection(collection_name)
-
-field_names = ["embeddings", "embeddings2"]
-field_names = ["embeddings"]
-
-req_list = []
-nq = 1
-default_limit = 5
-vectors_to_search = []
-
-for i in range(len(field_names)):
-    # 4. generate search data
-    vectors_to_search = rng.random((nq, dim))
-    search_param = {
-        "data": vectors_to_search,
-        "anns_field": field_names[i],
-        "param": {"metric_type": "L2"},
-        "limit": default_limit,
-        "expr": "random > 0.5"}
-    req = AnnSearchRequest(**search_param)
-    req_list.append(req)
-
-print("rank by RRFRanker")
-hybrid_res = milvus_client.hybrid_search(collection_name, req_list, RRFRanker(), default_limit, output_fields=["random"])
-for hits in hybrid_res:
-    for hit in hits:
-        print(f" hybrid search hit: {hit}")
diff --git a/examples/milvus_client/partition.py b/examples/milvus_client/partition.py
deleted file mode 100644
index 7466c034a..000000000
--- a/examples/milvus_client/partition.py
+++ /dev/null
@@ -1,85 +0,0 @@
-import time
-import numpy as np
-from pymilvus import (
-    MilvusClient,
-)
-
-fmt = "\n=== {:30} ===\n"
-dim = 8
-collection_name = "hello_milvus"
-milvus_client = MilvusClient("http://localhost:19530")
-
-has_collection = milvus_client.has_collection(collection_name, timeout=5)
-if has_collection:
-    milvus_client.drop_collection(collection_name)
-milvus_client.create_collection(collection_name, dim, consistency_level="Strong", metric_type="L2")
-
-print(fmt.format("    all collections    "))
-print(milvus_client.list_collections())
-
-print(fmt.format(f"schema of collection {collection_name}"))
-print(milvus_client.describe_collection(collection_name))
-
-rng = np.random.default_rng(seed=19530)
-
-milvus_client.create_partition(collection_name, partition_name = "p1")
-milvus_client.insert(collection_name, {"id": 1, "vector": rng.random((1, dim))[0], "a": 100}, partition_name = "p1")
-milvus_client.insert(collection_name, {"id": 2, "vector": rng.random((1, dim))[0], "b": 200}, partition_name = "p1")
-milvus_client.insert(collection_name, {"id": 3, "vector": rng.random((1, dim))[0], "c": 300}, partition_name = "p1")
-
-milvus_client.create_partition(collection_name, partition_name = "p2")
-milvus_client.insert(collection_name, {"id": 4, "vector": rng.random((1, dim))[0], "e": 400}, partition_name = "p2")
-milvus_client.insert(collection_name, {"id": 5, "vector": rng.random((1, dim))[0], "f": 500}, partition_name = "p2")
-milvus_client.insert(collection_name, {"id": 6, "vector": rng.random((1, dim))[0], "g": 600}, partition_name = "p2")
-
-has_p1 = milvus_client.has_partition(collection_name, "p1")
-print("has partition p1", has_p1)
-
-has_p3 = milvus_client.has_partition(collection_name, "p3")
-print("has partition p3", has_p3)
-
-partitions = milvus_client.list_partitions(collection_name)
-print("partitions:", partitions)
-
-milvus_client.release_collection(collection_name)
-milvus_client.load_partitions(collection_name, partition_names =["p1", "p2"])
-
-print(fmt.format("Start search in partiton p1"))
-vectors_to_search = rng.random((1, dim))
-result = milvus_client.search(collection_name, vectors_to_search, limit=3, output_fields=["pk", "a", "b"], partition_names = ["p1"])
-for hits in result:
-    for hit in hits:
-        print(f"hit: {hit}")
-
-milvus_client.release_partitions(collection_name, partition_names = ["p1"])
-milvus_client.drop_partition(collection_name, partition_name = "p1", timeout = 2.0)
-print("successfully drop partition p1")
-
-try:
-    milvus_client.drop_partition(collection_name, partition_name = "p2", timeout = 2.0)
-except Exception as e:
-    print(f"cacthed {e}")
-
-has_p1 = milvus_client.has_partition(collection_name, "p1")
-print("has partition of p1:", has_p1)
-
-print(fmt.format("Start query by specifying primary keys"))
-query_results = milvus_client.query(collection_name, ids=[2])
-assert len(query_results) == 0
-
-print(fmt.format("Start query by specifying primary keys"))
-query_results = milvus_client.query(collection_name, ids=[4])
-print(query_results[0])
-
-print(fmt.format("Start query by specifying filtering expression"))
-query_results = milvus_client.query(collection_name, filter= "f == 500")
-for ret in query_results: 
-    print(ret)
-
-print(fmt.format(f"Start search with retrieve serveral fields."))
-result = milvus_client.search(collection_name, vectors_to_search, limit=3, output_fields=["pk", "a", "b"])
-for hits in result:
-    for hit in hits:
-        print(f"hit: {hit}")
-
-milvus_client.drop_collection(collection_name)
diff --git a/examples/hello_model.py b/examples/milvus_model/hello_model.py
similarity index 100%
rename from examples/hello_model.py
rename to examples/milvus_model/hello_model.py
diff --git a/examples/milvus_client/non_ascii_encode.py b/examples/non_ascii_encode.py
similarity index 100%
rename from examples/milvus_client/non_ascii_encode.py
rename to examples/non_ascii_encode.py
diff --git a/examples/old_style_example.py b/examples/old_style_example.py
deleted file mode 100644
index 205bde80c..000000000
--- a/examples/old_style_example.py
+++ /dev/null
@@ -1,152 +0,0 @@
-import random
-
-from pymilvus import Milvus, DataType
-
-# This example shows how to:
-#   1. connect to Milvus server
-#   2. create a collection
-#   3. insert entities
-#   4. create index
-#   5. search
-
-_HOST = '127.0.0.1'
-_PORT = '19530'
-
-# Const names
-_COLLECTION_NAME = 'demo'
-_ID_FIELD_NAME = 'id_field'
-_VECTOR_FIELD_NAME = 'float_vector_field'
-
-# Vector parameters
-_DIM = 128
-_INDEX_FILE_SIZE = 32  # max file size of stored index
-
-# Index parameters
-_METRIC_TYPE = 'L2'
-_INDEX_TYPE = 'IVF_FLAT'
-_NLIST = 1024
-_NPROBE = 16
-_TOPK = 10
-
-# Create milvus client instance
-milvus = Milvus(_HOST, _PORT)
-
-
-def create_collection(name):
-    id_field = {
-        "name": _ID_FIELD_NAME,
-        "type": DataType.INT64,
-        "auto_id": True,
-        "is_primary": True,
-    }
-    vector_field = {
-        "name": _VECTOR_FIELD_NAME,
-        "type": DataType.FLOAT_VECTOR,
-        "params": {"dim": _DIM},
-    }
-    fields = {"fields": [id_field, vector_field]}
-
-    milvus.create_collection(collection_name=name, fields=fields)
-    print("collection created:", name)
-
-
-def drop_collection(name):
-    if milvus.has_collection(name):
-        milvus.drop_collection(name)
-        print("collection dropped:", name)
-
-
-def list_collections():
-    collections = milvus.list_collections()
-    print("list collection:")
-    print(collections)
-
-
-def get_collection_stats(name):
-    stats = milvus.get_collection_stats(name)
-    print("collection stats:")
-    print(stats)
-
-
-def insert(name, num, dim):
-    vectors = [[random.random() for _ in range(dim)] for _ in range(num)]
-    entities = [
-        {"name": _VECTOR_FIELD_NAME, "type": DataType.FLOAT_VECTOR, "values": vectors},
-    ]
-    ids = milvus.insert(name, entities)
-    return ids, vectors
-
-
-def flush(name):
-    milvus.flush([name])
-
-
-def create_index(name, field_name):
-    index_param = {
-        "metric_type": _METRIC_TYPE,
-        "index_type": _INDEX_TYPE,
-        "params": {"nlist": _NLIST}
-    }
-    milvus.create_index(name, field_name, index_param)
-    print("Create index: {}".format(index_param))
-
-
-def drop_index(name, field_name):
-    milvus.drop_index(name, field_name)
-    print("Drop index:", field_name)
-
-
-def load_collection(name):
-    milvus.load_collection(name)
-
-
-def release_collection(name):
-    milvus.release_collection(name)
-
-
-def search(name, vector_field, search_vectors, ids):
-    nq = len(search_vectors)
-    search_params = {"metric_type": _METRIC_TYPE, "params": {"nprobe": _NPROBE}}
-    results = milvus.search(name, search_vectors, vector_field, param=search_params, limit=_TOPK)
-    for i in range(nq):
-        if results[i][0].distance == 0.0 or results[i][0].id == ids[0]:
-            print("OK! search results: ", results[i][0].entity)
-        else:
-            print("FAIL! search results: ", results[i][0].entity)
-
-
-def main():
-    name = _COLLECTION_NAME
-    vector_field = _VECTOR_FIELD_NAME
-
-    drop_collection(name)
-    create_collection(name)
-
-    # show collections
-    list_collections()
-
-    # generate 10000 vectors with 128 dimension
-    ids, vectors = insert(name, 10000, _DIM)
-
-    # flush
-    flush(name)
-
-    # show row_count
-    get_collection_stats(name)
-
-    # create index
-    create_index(name, vector_field)
-
-    # load
-    load_collection(name)
-
-    # search
-    search(name, vector_field, vectors[:10], ids)
-
-    drop_index(name, vector_field)
-    release_collection(name)
-    drop_collection(name)
-
-
-if __name__ == '__main__':
-    main()
diff --git a/examples/old_style_example_index.py b/examples/old_style_example_index.py
deleted file mode 100644
index 3ca3487c6..000000000
--- a/examples/old_style_example_index.py
+++ /dev/null
@@ -1,155 +0,0 @@
-"""
-This is an example of creating index
-
-We will be using films.csv file, You can obtain it from here
-(https://raw.githubusercontent.com/milvus-io/pymilvus/0.3.0/examples/films.csv)
-There are 4 coloumns in films.csv, they are `id`, `title`, `release_year` and `embedding`, all
-the data are from MovieLens `ml-latest-small` data except id and embedding, those two columns are fake values.
-
-We will be using `films.csv` to demenstrate how can we build index and search by index on Milvus.
-We assuming you have read `example.py` and have a basic conception about how to communicate with Milvus using
-pymilvus
-
-This example is runable for Milvus(0.11.x) and pymilvus(0.3.x).
-"""
-import csv
-import random
-from pprint import pprint
-
-from pymilvus import Milvus, DataType
-
-_HOST = '127.0.0.1'
-_PORT = '19530'
-client = Milvus(_HOST, _PORT)
-
-collection_name = 'demo_index'
-if collection_name in client.list_collections():
-    client.drop_collection(collection_name)
-
-collection_param = {
-    "fields": [
-        {"name": "id", "type": DataType.INT64, "is_primary": True},
-        {"name": "release_year", "type": DataType.INT64},
-        {"name": "embedding", "type": DataType.FLOAT_VECTOR, "params": {"dim": 8}},
-    ],
-}
-
-client.create_collection(collection_name, collection_param)
-
-# ------
-# Basic create index:
-#     Now that we have a collection in Milvus with `segment_row_limit` 4096, we can create index or
-#     insert entities.
-#
-#     We can execute `create_index` BEFORE we insert any entites or AFTER. However Milvus won't actually
-#     start build index task if the segment row count is smaller than `segment_row_limit`. So if we want
-#     to make Milvus build index right away, we need to insert number of entities larger than
-#     `segment_row_limit`
-#
-#     We are going to use data in `films.csv` so you can checkout the structure. And we need to group
-#     data with same fields together, so here is a example of how we obtain the data in files and transfer
-#     them into what we need.
-# ------
-
-ids = []  # ids
-titles = []  # titles
-release_years = []  # release year
-embeddings = []  # embeddings
-films = []
-with open('films.csv', 'r') as csvfile:
-    reader = csv.reader(csvfile)
-    films = [film for film in reader]
-
-for film in films:
-    ids.append(int(film[0]))
-    titles.append(film[1])
-    release_years.append(int(film[2]))
-    embeddings.append(list(map(float, film[3][1:][:-1].split(','))))
-
-hybrid_entities = [
-    {"name": "id", "values": ids, "type": DataType.INT64},
-    {"name": "release_year", "values": release_years, "type": DataType.INT64},
-    {"name": "embedding", "values": embeddings, "type": DataType.FLOAT_VECTOR},
-]
-
-# ------
-# Basic insert:
-#     After preparing the data, we are going to insert them into our collection.
-#     The number of films inserted should be 8657.
-# ------
-ids = client.insert(collection_name, hybrid_entities)
-
-client.flush([collection_name])
-after_flush_counts = client.get_collection_stats(collection_name)
-print(" > There are {} films in collection `{}` after flush".format(after_flush_counts, collection_name))
-
-# ------
-# Basic create index:
-#     Now that we have insert all the films into Milvus, we are going to build index with these datas.
-#
-#     While build index, we have to indicate which `field` to build index for, the `index_type`,
-#     `metric_type` and params for the specific index type. In our case, we want to build a `IVF_FLAT`
-#     index, so the specific params are "nlist". See pymilvus documentation
-#     (https://milvus-io.github.io/milvus-sdk-python/pythondoc/v0.3.0/index.html) for `index_type` we
-#     support and the params accordingly
-#
-#     If there are already index for a collection and you run `create_index` with different params the
-#     older index will be replaced by new one.
-# ------
-client.create_index(collection_name, "embedding",
-                    {"index_type": "IVF_FLAT", "metric_type": "L2", "params": {"nlist": 100}})
-
-# ------
-# Basic create index:
-#     We can get the detail of the index  by `describe_collection`
-# ------
-info = client.describe_collection(collection_name)
-pprint(info)
-
-# ------
-# Basic load collection:
-#     Before search, we need to load collection data into memory.
-# ------
-client.load_collection(collection_name)
-
-# ------
-# Basic search with expressions:
-#     If we want to use index, the specific index params need to be provided, in our case, the "params"
-#     should be "nprobe", if no "params" given, Milvus will complain about it and raise a exception.
-# ------
-embedding2search = [[random.random() for _ in range(8)] for _ in range(1)]
-search_param = {
-    "data": embedding2search,
-    "anns_field": "embedding",
-    "param": {"metric_type": "L2", "params": {"nprobe": 8}},
-    "limit": 3,
-    "output_fields": ["release_year"],
-    "expression": "release_year in [1995, 2002]",
-}
-
-# ------
-# Basic hybrid search entities
-# ------
-results = client.search(collection_name, **search_param)
-for entities in results:
-    for topk_film in entities:
-        current_entity = topk_film.entity
-        print("==")
-        print(f"- id: {topk_film.id}")
-        print(f"- title: {titles[topk_film.id]}")
-        print(f"- distance: {topk_film.distance}")
-        print(f"- release_year: {current_entity.release_year}")
-
-# ------
-# Basic delete index:
-#     You can drop index we create
-# ------
-client.drop_index(collection_name, "embedding")
-
-if collection_name in client.list_collections():
-    client.drop_collection(collection_name)
-
-# ------
-# Summary:
-#     Now we've went through some basic build index operations, hope it's helpful!
-# ------
diff --git a/examples/old_style_example_str.py b/examples/old_style_example_str.py
deleted file mode 100644
index 83ec354ae..000000000
--- a/examples/old_style_example_str.py
+++ /dev/null
@@ -1,163 +0,0 @@
-import random
-
-from pymilvus import Milvus, DataType
-
-# This example shows how to:
-#   1. connect to Milvus server
-#   2. create a collection
-#   3. insert entities
-#   4. create index
-#   5. search
-
-_HOST = '127.0.0.1'
-_PORT = '19530'
-
-# Const names
-_COLLECTION_NAME = 'demo'
-_ID_FIELD_NAME = 'id_field'
-_VECTOR_FIELD_NAME = 'float_vector_field'
-
-# Vector parameters
-_DIM = 128
-_INDEX_FILE_SIZE = 32  # max file size of stored index
-
-# Index parameters
-_METRIC_TYPE = 'L2'
-_INDEX_TYPE = 'IVF_FLAT'
-_NLIST = 1024
-_NPROBE = 16
-_TOPK = 10
-
-# string
-_STR_FIELD_NAME = "str"
-_MAX_LEN = 1024
-
-# Create milvus client instance
-milvus = Milvus(_HOST, _PORT)
-
-
-def create_collection(name):
-    id_field = {
-        "name": _ID_FIELD_NAME,
-        "type": DataType.INT64,
-        "auto_id": True,
-        "is_primary": True,
-    }
-    vector_field = {
-        "name": _VECTOR_FIELD_NAME,
-        "type": DataType.FLOAT_VECTOR,
-        "params": {"dim": _DIM},
-    }
-    str_field = {
-        "name": _STR_FIELD_NAME,
-        "type": DataType.VARCHAR,
-        "params": {"max_length": _MAX_LEN},
-    }
-    fields = {"fields": [id_field, vector_field, str_field]}
-
-    milvus.create_collection(collection_name=name, fields=fields)
-    print("collection created:", name)
-
-
-def drop_collection(name):
-    if milvus.has_collection(name):
-        milvus.drop_collection(name)
-        print("collection dropped:", name)
-
-
-def list_collections():
-    collections = milvus.list_collections()
-    print("list collection:")
-    print(collections)
-
-
-def get_collection_stats(name):
-    stats = milvus.get_collection_stats(name)
-    print("collection stats:")
-    print(stats)
-
-
-def insert(name, num, dim):
-    vectors = [[random.random() for _ in range(dim)] for _ in range(num)]
-    strs = [str(random.random()) for _ in range(num)]
-    entities = [
-        {"name": _VECTOR_FIELD_NAME, "type": DataType.FLOAT_VECTOR, "values": vectors},
-        {"name": _STR_FIELD_NAME, "type": DataType.VARCHAR, "values": strs},
-    ]
-    ids = milvus.insert(name, entities)
-    return ids, vectors
-
-
-def flush(name):
-    milvus.flush([name])
-
-
-def create_index(name, field_name):
-    index_param = {
-        "metric_type": _METRIC_TYPE,
-        "index_type": _INDEX_TYPE,
-        "params": {"nlist": _NLIST}
-    }
-    milvus.create_index(name, field_name, index_param)
-    print("Create index: {}".format(index_param))
-
-
-def drop_index(name, field_name):
-    milvus.drop_index(name, field_name)
-    print("Drop index:", field_name)
-
-
-def load_collection(name):
-    milvus.load_collection(name)
-
-
-def release_collection(name):
-    milvus.release_collection(name)
-
-
-def search(name, vector_field, search_vectors, ids):
-    nq = len(search_vectors)
-    search_params = {"metric_type": _METRIC_TYPE, "params": {"nprobe": _NPROBE}}
-    results = milvus.search(name, search_vectors, vector_field, param=search_params, limit=_TOPK)
-    for i in range(nq):
-        if results[i][0].distance == 0.0 or results[i][0].id == ids[0]:
-            print("OK! search results: ", results[i][0].entity)
-        else:
-            print("FAIL! search results: ", results[i][0].entity)
-
-
-def main():
-    name = _COLLECTION_NAME
-    vector_field = _VECTOR_FIELD_NAME
-
-    drop_collection(name)
-    create_collection(name)
-
-    # show collections
-    list_collections()
-
-    # generate 10000 vectors with 128 dimension
-    ids, vectors = insert(name, 10000, _DIM)
-
-    # flush
-    flush(name)
-
-    # show row_count
-    get_collection_stats(name)
-
-    # create index
-    create_index(name, vector_field)
-
-    # load
-    load_collection(name)
-
-    # search
-    search(name, vector_field, vectors[:10], ids)
-
-    drop_index(name, vector_field)
-    release_collection(name)
-    drop_collection(name)
-
-
-if __name__ == '__main__':
-    main()
diff --git a/examples/old_style_query.py b/examples/old_style_query.py
deleted file mode 100644
index 0a031cd9f..000000000
--- a/examples/old_style_query.py
+++ /dev/null
@@ -1,62 +0,0 @@
-import random
-
-from pymilvus import Milvus, DataType
-
-if __name__ == "__main__":
-    c = Milvus("localhost", "19530")
-
-    collection_name = f"test_{random.randint(10000, 99999)}"
-
-    c.create_collection(collection_name, {"fields": [
-        {
-            "name": "f1",
-            "type": DataType.FLOAT_VECTOR,
-            "metric_type": "L2",
-            "params": {"dim": 4},
-            "indexes": [{"metric_type": "L2"}]
-        },
-        {
-            "name": "age",
-            "type": DataType.FLOAT,
-        },
-        {
-            "name": "id",
-            "type": DataType.INT64,
-            "auto_id": True,
-            "is_primary": True,
-        }
-    ],
-    }, orm=True)
-
-    assert c.has_collection(collection_name)
-
-    ids = c.insert(collection_name, [
-        {"name": "f1", "type": DataType.FLOAT_VECTOR, "values": [[1.1, 2.2, 3.3, 4.4], [5.5, 6.6, 7.7, 8.8]]},
-        {"name": "age", "type": DataType.FLOAT, "values": [3.45, 8.9]}
-    ], orm=True)
-
-    c.flush([collection_name])
-
-    c.load_collection(collection_name)
-
-    #############################################################
-    search_params = {"metric_type": "L2", "params": {"nprobe": 1}}
-
-    results = c.search(collection_name, [[1.1, 2.2, 3.3, 4.4]],
-                       "f1", param=search_params, limit=2, output_fields=["id"])
-
-    print("search results: ", results[0][0].entity, " + ", results[0][1].entity)
-    #
-    # print("Test entity.get: ", results[0][0].entity.get("age"))
-    # print("Test entity.value_of_field: ", results[0][0].entity.value_of_field("age"))
-    # print("Test entity.fields: ", results[0][0].entity.fields)
-    #############################################################
-
-    ids_expr = ",".join(str(x) for x in ids.primary_keys)
-
-    expr = "id in [ " + ids_expr + " ] "
-
-    print(expr)
-
-    res = c.query(collection_name, expr)
-    print(res)
diff --git a/examples/collection.py b/examples/orm/collection.py
similarity index 100%
rename from examples/collection.py
rename to examples/orm/collection.py
diff --git a/examples/database.py b/examples/orm/database.py
similarity index 100%
rename from examples/database.py
rename to examples/orm/database.py
diff --git a/examples/example.py b/examples/orm/example.py
similarity index 100%
rename from examples/example.py
rename to examples/orm/example.py
diff --git a/examples/example_group_by.py b/examples/orm/example_group_by.py
similarity index 100%
rename from examples/example_group_by.py
rename to examples/orm/example_group_by.py
diff --git a/examples/example_index.py b/examples/orm/example_index.py
similarity index 100%
rename from examples/example_index.py
rename to examples/orm/example_index.py
diff --git a/examples/hello_cost.py b/examples/orm/hello_cost.py
similarity index 100%
rename from examples/hello_cost.py
rename to examples/orm/hello_cost.py
diff --git a/examples/hello_milvus.ipynb b/examples/orm/hello_milvus.ipynb
similarity index 100%
rename from examples/hello_milvus.ipynb
rename to examples/orm/hello_milvus.ipynb
diff --git a/examples/hello_milvus.py b/examples/orm/hello_milvus.py
similarity index 100%
rename from examples/hello_milvus.py
rename to examples/orm/hello_milvus.py
diff --git a/examples/hello_milvus_delete.py b/examples/orm/hello_milvus_delete.py
similarity index 100%
rename from examples/hello_milvus_delete.py
rename to examples/orm/hello_milvus_delete.py
diff --git a/examples/hello_text_embedding.py b/examples/orm/hello_text_embedding.py
similarity index 100%
rename from examples/hello_text_embedding.py
rename to examples/orm/hello_text_embedding.py
diff --git a/examples/inverted_index_example.py b/examples/orm/inverted_index_example.py
similarity index 100%
rename from examples/inverted_index_example.py
rename to examples/orm/inverted_index_example.py
diff --git a/examples/iterator.py b/examples/orm/iterator.py
similarity index 100%
rename from examples/iterator.py
rename to examples/orm/iterator.py
diff --git a/examples/orm/partition.py b/examples/orm/partition.py
new file mode 100644
index 000000000..3c6bb30ce
--- /dev/null
+++ b/examples/orm/partition.py
@@ -0,0 +1,148 @@
+# Copyright (C) 2019-2020 Zilliz. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance
+# with the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software distributed under the License
+# is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+# or implied. See the License for the specific language governing permissions and limitations under the License.
+
+from pymilvus import (
+    connections, list_collections, has_partition,
+    FieldSchema, CollectionSchema, DataType,
+    Collection, Partition
+)
+
+import random
+import string
+
+default_dim = 128
+default_nb = 3000
+default_float_vec_field_name = "float_vector"
+default_segment_row_limit = 1000
+
+
+all_index_types = [
+    "FLAT",
+    "IVF_FLAT",
+    "IVF_SQ8",
+    # "IVF_SQ8_HYBRID",
+    "IVF_PQ",
+    "HNSW",
+    # "NSG",
+    "ANNOY",
+    "RHNSW_FLAT",
+    "RHNSW_PQ",
+    "RHNSW_SQ",
+    "BIN_FLAT",
+    "BIN_IVF_FLAT"
+]
+
+default_index_params = [
+    {"nlist": 128},
+    {"nlist": 128},
+    {"nlist": 128},
+    # {"nlist": 128},
+    {"nlist": 128, "m": 16, "nbits": 8},
+    {"M": 48, "efConstruction": 500},
+    # {"search_length": 50, "out_degree": 40, "candidate_pool_size": 100, "knng": 50},
+    {"n_trees": 50},
+    {"M": 48, "efConstruction": 500},
+    {"M": 48, "efConstruction": 500, "PQM": 64},
+    {"M": 48, "efConstruction": 500},
+    {"nlist": 128},
+    {"nlist": 128}
+]
+
+
+default_index = {"index_type": "IVF_FLAT", "params": {"nlist": 128}, "metric_type": "L2"}
+
+
+def gen_default_fields(auto_id=True):
+    default_fields = [
+        FieldSchema(name="count", dtype=DataType.INT64, is_primary=True),
+        FieldSchema(name="float", dtype=DataType.FLOAT),
+        FieldSchema(name=default_float_vec_field_name, dtype=DataType.FLOAT_VECTOR, dim=default_dim)
+    ]
+    default_schema = CollectionSchema(fields=default_fields, description="test collection",
+                                      segment_row_limit=default_segment_row_limit, auto_id=False)
+    return default_schema
+
+
+def gen_data(nb):
+    entities = [
+        [i for i in range(nb)],
+        [float(i) for i in range(nb)],
+        [[random.random() for _ in range(dim)] for _ in range(num)],
+    ]
+    return entities
+
+
+def gen_unique_str(str_value=None):
+    prefix = "".join(random.choice(string.ascii_letters + string.digits) for _ in range(8))
+    return "collection_" + prefix if str_value is None else str_value + "_" + prefix
+
+
+def binary_support():
+    return ["BIN_FLAT", "BIN_IVF_FLAT"]
+
+
+def gen_simple_index():
+    index_params = []
+    for i in range(len(all_index_types)):
+        if all_index_types[i] in binary_support():
+            continue
+        dic = {"index_type": all_index_types[i], "metric_type": "L2"}
+        dic.update({"params": default_index_params[i]})
+        index_params.append(dic)
+    return index_params
+
+
+def test_partition():
+    connections.connect(alias="default")
+    print("create collection")
+    collection = Collection(name=gen_unique_str(), schema=gen_default_fields())
+    print("create partition")
+    partition = Partition(collection, name=gen_unique_str())
+    print(list_collections())
+    assert has_partition(collection.name, partition.name) is True
+
+    data = gen_data(default_nb)
+    print("insert data to partition")
+    res = partition.insert(data)
+    collection.flush()
+    print(res.insert_count)
+    assert partition.is_empty is False
+    assert partition.num_entities == default_nb
+
+    print("start to create index")
+    index = {
+        "index_type": "IVF_FLAT",
+        "metric_type": "L2",
+        "params": {"nlist": 128},
+    }
+    collection.create_index(default_float_vec_field_name, index)
+
+    print("load partition")
+    partition.load()
+    topK = 5
+    round_decimal = 3
+    search_params = {"metric_type": "L2", "params": {"nprobe": 10}}
+    print("search partition")
+    res = partition.search(data[2][-2:], "float_vector", search_params, topK, "count > 100", round_decimal=round_decimal)
+    for hits in res:
+        for hit in hits:
+            print(hit)
+
+    print("release partition")
+    partition.release()
+    print("drop partition")
+    partition.drop()
+    print("drop collection")
+    collection.drop()
+
+
+if __name__ == "__main__":
+    test_partition()
diff --git a/examples/resource_group.py b/examples/orm/resource_group.py
similarity index 100%
rename from examples/resource_group.py
rename to examples/orm/resource_group.py
diff --git a/examples/resource_group_declarative_api.py b/examples/orm/resource_group_declarative_api.py
similarity index 100%
rename from examples/resource_group_declarative_api.py
rename to examples/orm/resource_group_declarative_api.py
diff --git a/examples/role_and_privilege.py b/examples/orm/role_and_privilege.py
similarity index 100%
rename from examples/role_and_privilege.py
rename to examples/orm/role_and_privilege.py
diff --git a/examples/search_with_template_expression.py b/examples/orm/search_with_template_expression.py
similarity index 100%
rename from examples/search_with_template_expression.py
rename to examples/orm/search_with_template_expression.py
diff --git a/examples/user.py b/examples/orm/user.py
similarity index 100%
rename from examples/user.py
rename to examples/orm/user.py
diff --git a/examples/partition.py b/examples/partition.py
index 3c6bb30ce..7466c034a 100644
--- a/examples/partition.py
+++ b/examples/partition.py
@@ -1,148 +1,85 @@
-# Copyright (C) 2019-2020 Zilliz. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance
-# with the License. You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software distributed under the License
-# is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
-# or implied. See the License for the specific language governing permissions and limitations under the License.
-
+import time
+import numpy as np
 from pymilvus import (
-    connections, list_collections, has_partition,
-    FieldSchema, CollectionSchema, DataType,
-    Collection, Partition
+    MilvusClient,
 )
 
-import random
-import string
-
-default_dim = 128
-default_nb = 3000
-default_float_vec_field_name = "float_vector"
-default_segment_row_limit = 1000
-
-
-all_index_types = [
-    "FLAT",
-    "IVF_FLAT",
-    "IVF_SQ8",
-    # "IVF_SQ8_HYBRID",
-    "IVF_PQ",
-    "HNSW",
-    # "NSG",
-    "ANNOY",
-    "RHNSW_FLAT",
-    "RHNSW_PQ",
-    "RHNSW_SQ",
-    "BIN_FLAT",
-    "BIN_IVF_FLAT"
-]
-
-default_index_params = [
-    {"nlist": 128},
-    {"nlist": 128},
-    {"nlist": 128},
-    # {"nlist": 128},
-    {"nlist": 128, "m": 16, "nbits": 8},
-    {"M": 48, "efConstruction": 500},
-    # {"search_length": 50, "out_degree": 40, "candidate_pool_size": 100, "knng": 50},
-    {"n_trees": 50},
-    {"M": 48, "efConstruction": 500},
-    {"M": 48, "efConstruction": 500, "PQM": 64},
-    {"M": 48, "efConstruction": 500},
-    {"nlist": 128},
-    {"nlist": 128}
-]
-
-
-default_index = {"index_type": "IVF_FLAT", "params": {"nlist": 128}, "metric_type": "L2"}
-
-
-def gen_default_fields(auto_id=True):
-    default_fields = [
-        FieldSchema(name="count", dtype=DataType.INT64, is_primary=True),
-        FieldSchema(name="float", dtype=DataType.FLOAT),
-        FieldSchema(name=default_float_vec_field_name, dtype=DataType.FLOAT_VECTOR, dim=default_dim)
-    ]
-    default_schema = CollectionSchema(fields=default_fields, description="test collection",
-                                      segment_row_limit=default_segment_row_limit, auto_id=False)
-    return default_schema
-
-
-def gen_data(nb):
-    entities = [
-        [i for i in range(nb)],
-        [float(i) for i in range(nb)],
-        [[random.random() for _ in range(dim)] for _ in range(num)],
-    ]
-    return entities
-
-
-def gen_unique_str(str_value=None):
-    prefix = "".join(random.choice(string.ascii_letters + string.digits) for _ in range(8))
-    return "collection_" + prefix if str_value is None else str_value + "_" + prefix
-
-
-def binary_support():
-    return ["BIN_FLAT", "BIN_IVF_FLAT"]
-
-
-def gen_simple_index():
-    index_params = []
-    for i in range(len(all_index_types)):
-        if all_index_types[i] in binary_support():
-            continue
-        dic = {"index_type": all_index_types[i], "metric_type": "L2"}
-        dic.update({"params": default_index_params[i]})
-        index_params.append(dic)
-    return index_params
-
-
-def test_partition():
-    connections.connect(alias="default")
-    print("create collection")
-    collection = Collection(name=gen_unique_str(), schema=gen_default_fields())
-    print("create partition")
-    partition = Partition(collection, name=gen_unique_str())
-    print(list_collections())
-    assert has_partition(collection.name, partition.name) is True
-
-    data = gen_data(default_nb)
-    print("insert data to partition")
-    res = partition.insert(data)
-    collection.flush()
-    print(res.insert_count)
-    assert partition.is_empty is False
-    assert partition.num_entities == default_nb
-
-    print("start to create index")
-    index = {
-        "index_type": "IVF_FLAT",
-        "metric_type": "L2",
-        "params": {"nlist": 128},
-    }
-    collection.create_index(default_float_vec_field_name, index)
-
-    print("load partition")
-    partition.load()
-    topK = 5
-    round_decimal = 3
-    search_params = {"metric_type": "L2", "params": {"nprobe": 10}}
-    print("search partition")
-    res = partition.search(data[2][-2:], "float_vector", search_params, topK, "count > 100", round_decimal=round_decimal)
-    for hits in res:
-        for hit in hits:
-            print(hit)
-
-    print("release partition")
-    partition.release()
-    print("drop partition")
-    partition.drop()
-    print("drop collection")
-    collection.drop()
-
-
-if __name__ == "__main__":
-    test_partition()
+fmt = "\n=== {:30} ===\n"
+dim = 8
+collection_name = "hello_milvus"
+milvus_client = MilvusClient("http://localhost:19530")
+
+has_collection = milvus_client.has_collection(collection_name, timeout=5)
+if has_collection:
+    milvus_client.drop_collection(collection_name)
+milvus_client.create_collection(collection_name, dim, consistency_level="Strong", metric_type="L2")
+
+print(fmt.format("    all collections    "))
+print(milvus_client.list_collections())
+
+print(fmt.format(f"schema of collection {collection_name}"))
+print(milvus_client.describe_collection(collection_name))
+
+rng = np.random.default_rng(seed=19530)
+
+milvus_client.create_partition(collection_name, partition_name = "p1")
+milvus_client.insert(collection_name, {"id": 1, "vector": rng.random((1, dim))[0], "a": 100}, partition_name = "p1")
+milvus_client.insert(collection_name, {"id": 2, "vector": rng.random((1, dim))[0], "b": 200}, partition_name = "p1")
+milvus_client.insert(collection_name, {"id": 3, "vector": rng.random((1, dim))[0], "c": 300}, partition_name = "p1")
+
+milvus_client.create_partition(collection_name, partition_name = "p2")
+milvus_client.insert(collection_name, {"id": 4, "vector": rng.random((1, dim))[0], "e": 400}, partition_name = "p2")
+milvus_client.insert(collection_name, {"id": 5, "vector": rng.random((1, dim))[0], "f": 500}, partition_name = "p2")
+milvus_client.insert(collection_name, {"id": 6, "vector": rng.random((1, dim))[0], "g": 600}, partition_name = "p2")
+
+has_p1 = milvus_client.has_partition(collection_name, "p1")
+print("has partition p1", has_p1)
+
+has_p3 = milvus_client.has_partition(collection_name, "p3")
+print("has partition p3", has_p3)
+
+partitions = milvus_client.list_partitions(collection_name)
+print("partitions:", partitions)
+
+milvus_client.release_collection(collection_name)
+milvus_client.load_partitions(collection_name, partition_names =["p1", "p2"])
+
+print(fmt.format("Start search in partiton p1"))
+vectors_to_search = rng.random((1, dim))
+result = milvus_client.search(collection_name, vectors_to_search, limit=3, output_fields=["pk", "a", "b"], partition_names = ["p1"])
+for hits in result:
+    for hit in hits:
+        print(f"hit: {hit}")
+
+milvus_client.release_partitions(collection_name, partition_names = ["p1"])
+milvus_client.drop_partition(collection_name, partition_name = "p1", timeout = 2.0)
+print("successfully drop partition p1")
+
+try:
+    milvus_client.drop_partition(collection_name, partition_name = "p2", timeout = 2.0)
+except Exception as e:
+    print(f"cacthed {e}")
+
+has_p1 = milvus_client.has_partition(collection_name, "p1")
+print("has partition of p1:", has_p1)
+
+print(fmt.format("Start query by specifying primary keys"))
+query_results = milvus_client.query(collection_name, ids=[2])
+assert len(query_results) == 0
+
+print(fmt.format("Start query by specifying primary keys"))
+query_results = milvus_client.query(collection_name, ids=[4])
+print(query_results[0])
+
+print(fmt.format("Start query by specifying filtering expression"))
+query_results = milvus_client.query(collection_name, filter= "f == 500")
+for ret in query_results: 
+    print(ret)
+
+print(fmt.format(f"Start search with retrieve serveral fields."))
+result = milvus_client.search(collection_name, vectors_to_search, limit=3, output_fields=["pk", "a", "b"])
+for hits in result:
+    for hit in hits:
+        print(f"hit: {hit}")
+
+milvus_client.drop_collection(collection_name)
diff --git a/examples/milvus_client/rbac.py b/examples/rbac.py
similarity index 100%
rename from examples/milvus_client/rbac.py
rename to examples/rbac.py
diff --git a/examples/milvus_client/simple.py b/examples/simple.py
similarity index 100%
rename from examples/milvus_client/simple.py
rename to examples/simple.py
diff --git a/examples/milvus_client/simple_auto_id.py b/examples/simple_auto_id.py
similarity index 100%
rename from examples/milvus_client/simple_auto_id.py
rename to examples/simple_auto_id.py
diff --git a/examples/milvus_client/simple_cost.py b/examples/simple_cost.py
similarity index 100%
rename from examples/milvus_client/simple_cost.py
rename to examples/simple_cost.py
diff --git a/examples/milvus_client/sparse.py b/examples/sparse.py
similarity index 100%
rename from examples/milvus_client/sparse.py
rename to examples/sparse.py
diff --git a/examples/milvus_client/text_embedding.py b/examples/text_embedding.py
similarity index 100%
rename from examples/milvus_client/text_embedding.py
rename to examples/text_embedding.py
diff --git a/pymilvus/milvus_client/milvus_client.py b/pymilvus/milvus_client/milvus_client.py
index bed9f5062..4ea1e79f7 100644
--- a/pymilvus/milvus_client/milvus_client.py
+++ b/pymilvus/milvus_client/milvus_client.py
@@ -33,7 +33,7 @@
 class MilvusClient:
     """The Milvus Client"""
 
-    # pylint: disable=logging-too-many-args, too-many-instance-attributes, import-outside-toplevel
+    # pylint: disable=logging-too-many-args, too-many-instance-attributes
 
     def __init__(
         self,