vectordb-bench 0.0.26__tar.gz → 0.0.28__tar.gz

{vectordb_bench-0.0.26 → vectordb_bench-0.0.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vectordb-bench
-Version: 0.0.26
+Version: 0.0.28
 Summary: VectorDBBench is not just an offering of benchmark results for mainstream vector databases and cloud services, it's your go-to tool for the ultimate performance and cost-effectiveness comparison. Designed with ease-of-use in mind, VectorDBBench is devised to help users, even non-professionals, reproduce results or test new systems, making the hunt for the optimal choice amongst a plethora of cloud services and open-source vector databases a breeze.
 Author-email: XuanYang-cn <xuan.yang@zilliz.com>
 Project-URL: repository, https://github.com/zilliztech/VectorDBBench
@@ -52,6 +52,7 @@ Requires-Dist: mariadb; extra == "all"
 Requires-Dist: PyMySQL; extra == "all"
 Requires-Dist: clickhouse-connect; extra == "all"
 Requires-Dist: pyvespa; extra == "all"
+Requires-Dist: lancedb; extra == "all"
 Provides-Extra: qdrant
 Requires-Dist: qdrant-client; extra == "qdrant"
 Provides-Extra: pinecone
@@ -87,6 +88,8 @@ Provides-Extra: clickhouse
 Requires-Dist: clickhouse-connect; extra == "clickhouse"
 Provides-Extra: vespa
 Requires-Dist: pyvespa; extra == "vespa"
+Provides-Extra: lancedb
+Requires-Dist: lancedb; extra == "lancedb"
 Dynamic: license-file
 
 # VectorDBBench: A Benchmark Tool for VectorDB
@@ -358,13 +361,13 @@ pip install -e '.[pinecone]'
 ```
 ### Run test server
 ```
-$ python -m vectordb_bench
+python -m vectordb_bench
 ```
 
 OR:
 
 ```shell
-$ init_bench
+init_bench
 ```
 
 OR:
@@ -381,13 +384,13 @@ After reopen the repository in container, run `python -m vectordb_bench` in the
 
 ### Check coding styles
 ```shell
-$ make lint
+make lint
 ```
 
 To fix the coding styles automatically
 
 ```shell
-$ make format
+make format
 ```
 
 ## How does it work?

{vectordb_bench-0.0.26 → vectordb_bench-0.0.28}/README.md

@@ -267,13 +267,13 @@ pip install -e '.[pinecone]'
 ```
 ### Run test server
 ```
-$ python -m vectordb_bench
+python -m vectordb_bench
 ```
 
 OR:
 
 ```shell
-$ init_bench
+init_bench
 ```
 
 OR:
@@ -290,13 +290,13 @@ After reopen the repository in container, run `python -m vectordb_bench` in the
 
 ### Check coding styles
 ```shell
-$ make lint
+make lint
 ```
 
 To fix the coding styles automatically
 
 ```shell
-$ make format
+make format
 ```
 
 ## How does it work?

{vectordb_bench-0.0.26 → vectordb_bench-0.0.28}/pyproject.toml

@@ -72,6 +72,7 @@ all = [
     "PyMySQL",
     "clickhouse-connect",
     "pyvespa",
+    "lancedb",
 ]
 
 qdrant          = [ "qdrant-client" ]
@@ -94,6 +95,7 @@ mariadb         = [ "mariadb" ]
 tidb            = [ "PyMySQL" ]
 clickhouse      = [ "clickhouse-connect" ]
 vespa           = [ "pyvespa" ]
+lancedb         = [ "lancedb" ]
 
 [project.urls]
 "repository" = "https://github.com/zilliztech/VectorDBBench"

{vectordb_bench-0.0.26 → vectordb_bench-0.0.28}/vectordb_bench/backend/clients/__init__.py

@@ -45,9 +45,10 @@ class DB(Enum):
     TiDB = "TiDB"
     Clickhouse = "Clickhouse"
     Vespa = "Vespa"
+    LanceDB = "LanceDB"
 
     @property
-    def init_cls(self) -> type[VectorDB]:  # noqa: PLR0911, PLR0912, C901
+    def init_cls(self) -> type[VectorDB]:  # noqa: PLR0911, PLR0912, C901, PLR0915
         """Import while in use"""
         if self == DB.Milvus:
             from .milvus.milvus import Milvus
@@ -164,11 +165,16 @@ class DB(Enum):
 
             return Vespa
 
+        if self == DB.LanceDB:
+            from .lancedb.lancedb import LanceDB
+
+            return LanceDB
+
         msg = f"Unknown DB: {self.name}"
         raise ValueError(msg)
 
     @property
-    def config_cls(self) -> type[DBConfig]:  # noqa: PLR0911, PLR0912, C901
+    def config_cls(self) -> type[DBConfig]:  # noqa: PLR0911, PLR0912, C901, PLR0915
         """Import while in use"""
         if self == DB.Milvus:
             from .milvus.config import MilvusConfig
@@ -285,6 +291,11 @@ class DB(Enum):
 
             return VespaConfig
 
+        if self == DB.LanceDB:
+            from .lancedb.config import LanceDBConfig
+
+            return LanceDBConfig
+
         msg = f"Unknown DB: {self.name}"
         raise ValueError(msg)
 
@@ -382,6 +393,11 @@ class DB(Enum):
 
             return VespaHNSWConfig
 
+        if self == DB.LanceDB:
+            from .lancedb.config import _lancedb_case_config
+
+            return _lancedb_case_config.get(index_type)
+
         # DB.Pinecone, DB.Chroma, DB.Redis
         return EmptyDBCaseConfig
 

{vectordb_bench-0.0.26 → vectordb_bench-0.0.28}/vectordb_bench/backend/clients/api.py

@@ -34,6 +34,7 @@ class IndexType(str, Enum):
     GPU_IVF_PQ = "GPU_IVF_PQ"
     GPU_CAGRA = "GPU_CAGRA"
     SCANN = "scann"
+    NONE = "NONE"
 
 
 class SQType(str, Enum):

vectordb_bench-0.0.28/vectordb_bench/backend/clients/lancedb/cli.py

@@ -0,0 +1,92 @@
+from typing import Annotated, Unpack
+
+import click
+from pydantic import SecretStr
+
+from ....cli.cli import (
+    CommonTypedDict,
+    cli,
+    click_parameter_decorators_from_typed_dict,
+    run,
+)
+from .. import DB
+from ..api import IndexType
+
+
+class LanceDBTypedDict(CommonTypedDict):
+    uri: Annotated[
+        str,
+        click.option("--uri", type=str, help="URI connection string", required=True),
+    ]
+    token: Annotated[
+        str | None,
+        click.option("--token", type=str, help="Authentication token", required=False),
+    ]
+
+
+@cli.command()
+@click_parameter_decorators_from_typed_dict(LanceDBTypedDict)
+def LanceDB(**parameters: Unpack[LanceDBTypedDict]):
+    from .config import LanceDBConfig, _lancedb_case_config
+
+    run(
+        db=DB.LanceDB,
+        db_config=LanceDBConfig(
+            db_label=parameters["db_label"],
+            uri=parameters["uri"],
+            token=SecretStr(parameters["token"]) if parameters.get("token") else None,
+        ),
+        db_case_config=_lancedb_case_config.get("NONE")(),
+        **parameters,
+    )
+
+
+@cli.command()
+@click_parameter_decorators_from_typed_dict(LanceDBTypedDict)
+def LanceDBAutoIndex(**parameters: Unpack[LanceDBTypedDict]):
+    from .config import LanceDBConfig, _lancedb_case_config
+
+    run(
+        db=DB.LanceDB,
+        db_config=LanceDBConfig(
+            db_label=parameters["db_label"],
+            uri=parameters["uri"],
+            token=SecretStr(parameters["token"]) if parameters.get("token") else None,
+        ),
+        db_case_config=_lancedb_case_config.get(IndexType.AUTOINDEX)(),
+        **parameters,
+    )
+
+
+@cli.command()
+@click_parameter_decorators_from_typed_dict(LanceDBTypedDict)
+def LanceDBIVFPQ(**parameters: Unpack[LanceDBTypedDict]):
+    from .config import LanceDBConfig, _lancedb_case_config
+
+    run(
+        db=DB.LanceDB,
+        db_config=LanceDBConfig(
+            db_label=parameters["db_label"],
+            uri=parameters["uri"],
+            token=SecretStr(parameters["token"]) if parameters.get("token") else None,
+        ),
+        db_case_config=_lancedb_case_config.get(IndexType.IVFPQ)(),
+        **parameters,
+    )
+
+
+@cli.command()
+@click_parameter_decorators_from_typed_dict(LanceDBTypedDict)
+def LanceDBHNSW(**parameters: Unpack[LanceDBTypedDict]):
+    from .config import LanceDBConfig, _lancedb_case_config
+
+    run(
+        db=DB.LanceDB,
+        db_config=LanceDBConfig(
+            db_label=parameters["db_label"],
+            uri=parameters["uri"],
+            token=SecretStr(parameters["token"]) if parameters.get("token") else None,
+        ),
+        db_case_config=_lancedb_case_config.get(IndexType.HNSW)(),
+        **parameters,
+    )

vectordb_bench-0.0.28/vectordb_bench/backend/clients/lancedb/config.py

@@ -0,0 +1,103 @@
+from pydantic import BaseModel, SecretStr
+
+from ..api import DBCaseConfig, DBConfig, IndexType, MetricType
+
+
+class LanceDBConfig(DBConfig):
+    """LanceDB connection configuration."""
+
+    db_label: str
+    uri: str
+    token: SecretStr | None = None
+
+    def to_dict(self) -> dict:
+        return {
+            "uri": self.uri,
+            "token": self.token.get_secret_value() if self.token else None,
+        }
+
+
+class LanceDBIndexConfig(BaseModel, DBCaseConfig):
+    index: IndexType = IndexType.IVFPQ
+    metric_type: MetricType = MetricType.L2
+    num_partitions: int = 0
+    num_sub_vectors: int = 0
+    nbits: int = 8  # Must be 4 or 8
+    sample_rate: int = 256
+    max_iterations: int = 50
+
+    def index_param(self) -> dict:
+        if self.index not in [
+            IndexType.IVFPQ,
+            IndexType.HNSW,
+            IndexType.AUTOINDEX,
+            IndexType.NONE,
+        ]:
+            msg = f"Index type {self.index} is not supported for LanceDB!"
+            raise ValueError(msg)
+
+        # See https://lancedb.github.io/lancedb/python/python/#lancedb.table.Table.create_index
+        params = {
+            "metric": self.parse_metric(),
+            "num_bits": self.nbits,
+            "sample_rate": self.sample_rate,
+            "max_iterations": self.max_iterations,
+        }
+
+        if self.num_partitions > 0:
+            params["num_partitions"] = self.num_partitions
+        if self.num_sub_vectors > 0:
+            params["num_sub_vectors"] = self.num_sub_vectors
+
+        return params
+
+    def search_param(self) -> dict:
+        pass
+
+    def parse_metric(self) -> str:
+        if self.metric_type in [MetricType.L2, MetricType.COSINE]:
+            return self.metric_type.value.lower()
+        if self.metric_type in [MetricType.IP, MetricType.DP]:
+            return "dot"
+        msg = f"Metric type {self.metric_type} is not supported for LanceDB!"
+        raise ValueError(msg)
+
+
+class LanceDBNoIndexConfig(LanceDBIndexConfig):
+    index: IndexType = IndexType.NONE
+
+    def index_param(self) -> dict:
+        return {}
+
+
+class LanceDBAutoIndexConfig(LanceDBIndexConfig):
+    index: IndexType = IndexType.AUTOINDEX
+
+    def index_param(self) -> dict:
+        return {}
+
+
+class LanceDBHNSWIndexConfig(LanceDBIndexConfig):
+    index: IndexType = IndexType.HNSW
+    m: int = 0
+    ef_construction: int = 0
+
+    def index_param(self) -> dict:
+        params = LanceDBIndexConfig.index_param(self)
+
+        # See https://lancedb.github.io/lancedb/python/python/#lancedb.index.HnswSq
+        params["index_type"] = "IVF_HNSW_SQ"
+        if self.m > 0:
+            params["m"] = self.m
+        if self.ef_construction > 0:
+            params["ef_construction"] = self.ef_construction
+
+        return params
+
+
+_lancedb_case_config = {
+    IndexType.IVFPQ: LanceDBIndexConfig,
+    IndexType.AUTOINDEX: LanceDBAutoIndexConfig,
+    IndexType.HNSW: LanceDBHNSWIndexConfig,
+    IndexType.NONE: LanceDBNoIndexConfig,
+}

vectordb_bench-0.0.28/vectordb_bench/backend/clients/lancedb/lancedb.py

@@ -0,0 +1,91 @@
+import logging
+from contextlib import contextmanager
+
+import lancedb
+import pyarrow as pa
+from lancedb.pydantic import LanceModel
+
+from ..api import IndexType, VectorDB
+from .config import LanceDBConfig, LanceDBIndexConfig
+
+log = logging.getLogger(__name__)
+
+
+class VectorModel(LanceModel):
+    id: int
+    vector: list[float]
+
+
+class LanceDB(VectorDB):
+    def __init__(
+        self,
+        dim: int,
+        db_config: LanceDBConfig,
+        db_case_config: LanceDBIndexConfig,
+        collection_name: str = "vector_bench_test",
+        drop_old: bool = False,
+        **kwargs,
+    ):
+        self.name = "LanceDB"
+        self.db_config = db_config
+        self.case_config = db_case_config
+        self.table_name = collection_name
+        self.dim = dim
+        self.uri = db_config["uri"]
+
+        db = lancedb.connect(self.uri)
+
+        if drop_old:
+            try:
+                db.drop_table(self.table_name)
+            except Exception as e:
+                log.warning(f"Failed to drop table {self.table_name}: {e}")
+
+        try:
+            db.open_table(self.table_name)
+        except Exception:
+            schema = pa.schema(
+                [pa.field("id", pa.int64()), pa.field("vector", pa.list_(pa.float64(), list_size=self.dim))]
+            )
+            db.create_table(self.table_name, schema=schema, mode="overwrite")
+
+    @contextmanager
+    def init(self):
+        self.db = lancedb.connect(self.uri)
+        self.table = self.db.open_table(self.table_name)
+        yield
+        self.db = None
+        self.table = None
+
+    def insert_embeddings(
+        self,
+        embeddings: list[list[float]],
+        metadata: list[int],
+    ) -> tuple[int, Exception | None]:
+        try:
+            data = [{"id": meta, "vector": emb} for meta, emb in zip(metadata, embeddings, strict=False)]
+            self.table.add(data)
+            return len(metadata), None
+        except Exception as e:
+            log.warning(f"Failed to insert data into LanceDB table ({self.table_name}), error: {e}")
+            return 0, e
+
+    def search_embedding(
+        self,
+        query: list[float],
+        k: int = 100,
+        filters: dict | None = None,
+    ) -> list[int]:
+        if filters:
+            results = self.table.search(query).where(f"id >= {filters['id']}", prefilter=True).limit(k).to_list()
+        else:
+            results = self.table.search(query).limit(k).to_list()
+        return [int(result["id"]) for result in results]
+
+    def optimize(self, data_size: int | None = None):
+        if self.table and hasattr(self, "case_config") and self.case_config.index != IndexType.NONE:
+            log.info(f"Creating index for LanceDB table ({self.table_name})")
+            self.table.create_index(**self.case_config.index_param())
+            # Better recall with IVF_PQ (though still bad) but breaks HNSW: https://github.com/lancedb/lancedb/issues/2369
+            if self.case_config.index in (IndexType.IVFPQ, IndexType.AUTOINDEX):
+                self.table.optimize()

{vectordb_bench-0.0.26 → vectordb_bench-0.0.28}/vectordb_bench/backend/dataset.py

@@ -220,10 +220,12 @@ class DatasetManager(BaseModel):
         train_files = utils.compose_train_files(file_count, use_shuffled)
         all_files = train_files
 
-        gt_file, test_file = None, None
+        test_file = "test.parquet"
+        all_files.extend([test_file])
+        gt_file = None
         if self.data.with_gt:
-            gt_file, test_file = utils.compose_gt_file(filters), "test.parquet"
-            all_files.extend([gt_file, test_file])
+            gt_file = utils.compose_gt_file(filters)
+            all_files.extend([gt_file])
 
         if not self.data.is_custom:
             source.reader().read(
@@ -232,8 +234,10 @@ class DatasetManager(BaseModel):
                 local_ds_root=self.data_dir,
             )
 
-        if gt_file is not None and test_file is not None:
+        if test_file is not None:
             self.test_data = self._read_file(test_file)
+
+        if gt_file is not None:
             self.gt_data = self._read_file(gt_file)
 
         prefix = "shuffle_train" if use_shuffled else "train"

{vectordb_bench-0.0.26 → vectordb_bench-0.0.28}/vectordb_bench/backend/runner/serial_runner.py

@@ -209,7 +209,8 @@ class SerialSearchRunner:
             ideal_dcg = get_ideal_dcg(self.k)
 
             log.debug(f"test dataset size: {len(test_data)}")
-            log.debug(f"ground truth size: {ground_truth.columns}, shape: {ground_truth.shape}")
+            if ground_truth is not None:
+                log.debug(f"ground truth size: {ground_truth.columns}, shape: {ground_truth.shape}")
 
             latencies, recalls, ndcgs = [], [], []
             for idx, emb in enumerate(test_data):
@@ -228,9 +229,13 @@ class SerialSearchRunner:
 
                 latencies.append(time.perf_counter() - s)
 
-                gt = ground_truth["neighbors_id"][idx]
-                recalls.append(calc_recall(self.k, gt[: self.k], results))
-                ndcgs.append(calc_ndcg(gt[: self.k], results, ideal_dcg))
+                if ground_truth is not None:
+                    gt = ground_truth["neighbors_id"][idx]
+                    recalls.append(calc_recall(self.k, gt[: self.k], results))
+                    ndcgs.append(calc_ndcg(gt[: self.k], results, ideal_dcg))
+                else:
+                    recalls.append(0)
+                    ndcgs.append(0)
 
                 if len(latencies) % 100 == 0:
                     log.debug(

{vectordb_bench-0.0.26 → vectordb_bench-0.0.28}/vectordb_bench/cli/cli.py

@@ -405,6 +405,7 @@ class CommonTypedDict(TypedDict):
             show_default=True,
         ),
     ]
+    task_label: Annotated[str, click.option("--task-label", help="Task label")]
 
 
 class HNSWBaseTypedDict(TypedDict):
@@ -499,10 +500,11 @@ def run(
             parameters["search_concurrent"],
         ),
     )
+    task_label = parameters["task_label"]
 
     log.info(f"Task:\n{pformat(task)}\n")
     if not parameters["dry_run"]:
-        benchmark_runner.run([task])
+        benchmark_runner.run([task], task_label)
         time.sleep(5)
         if global_result_future:
             wait([global_result_future])

{vectordb_bench-0.0.26 → vectordb_bench-0.0.28}/vectordb_bench/cli/vectordbbench.py

@@ -1,6 +1,7 @@
 from ..backend.clients.alloydb.cli import AlloyDBScaNN
 from ..backend.clients.aws_opensearch.cli import AWSOpenSearch
 from ..backend.clients.clickhouse.cli import Clickhouse
+from ..backend.clients.lancedb.cli import LanceDB
 from ..backend.clients.mariadb.cli import MariaDBHNSW
 from ..backend.clients.memorydb.cli import MemoryDB
 from ..backend.clients.milvus.cli import MilvusAutoIndex
@@ -33,6 +34,7 @@ cli.add_command(MariaDBHNSW)
 cli.add_command(TiDB)
 cli.add_command(Clickhouse)
 cli.add_command(Vespa)
+cli.add_command(LanceDB)
 
 
 if __name__ == "__main__":

{vectordb_bench-0.0.26 → vectordb_bench-0.0.28}/vectordb_bench/frontend/config/dbCaseConfigs.py

@@ -1491,6 +1491,127 @@ VespaLoadingConfig = [
 ]
 VespaPerformanceConfig = VespaLoadingConfig
 
+CaseConfigParamInput_IndexType_LanceDB = CaseConfigInput(
+    label=CaseConfigParamType.IndexType,
+    inputHelp="AUTOINDEX = IVFPQ with default parameters",
+    inputType=InputType.Option,
+    inputConfig={
+        "options": [
+            IndexType.NONE.value,
+            IndexType.AUTOINDEX.value,
+            IndexType.IVFPQ.value,
+            IndexType.HNSW.value,
+        ],
+    },
+)
+
+CaseConfigParamInput_num_partitions_LanceDB = CaseConfigInput(
+    label=CaseConfigParamType.num_partitions,
+    displayLabel="Number of Partitions",
+    inputHelp="Number of partitions (clusters) for IVF_PQ. Default (when 0): sqrt(num_rows)",
+    inputType=InputType.Number,
+    inputConfig={
+        "min": 0,
+        "max": 10000,
+        "value": 0,
+    },
+    isDisplayed=lambda config: config.get(CaseConfigParamType.IndexType, None) == IndexType.IVFPQ.value
+    or config.get(CaseConfigParamType.IndexType, None) == IndexType.HNSW.value,
+)
+
+CaseConfigParamInput_num_sub_vectors_LanceDB = CaseConfigInput(
+    label=CaseConfigParamType.num_sub_vectors,
+    displayLabel="Number of Sub-vectors",
+    inputHelp="Number of sub-vectors for PQ. Default (when 0): dim/16 or dim/8",
+    inputType=InputType.Number,
+    inputConfig={
+        "min": 0,
+        "max": 1000,
+        "value": 0,
+    },
+    isDisplayed=lambda config: config.get(CaseConfigParamType.IndexType, None) == IndexType.IVFPQ.value
+    or config.get(CaseConfigParamType.IndexType, None) == IndexType.HNSW.value,
+)
+
+CaseConfigParamInput_num_bits_LanceDB = CaseConfigInput(
+    label=CaseConfigParamType.nbits,
+    displayLabel="Number of Bits",
+    inputHelp="Number of bits per sub-vector.",
+    inputType=InputType.Option,
+    inputConfig={
+        "options": [4, 8],
+    },
+    isDisplayed=lambda config: config.get(CaseConfigParamType.IndexType, None) == IndexType.IVFPQ.value
+    or config.get(CaseConfigParamType.IndexType, None) == IndexType.HNSW.value,
+)
+
+CaseConfigParamInput_sample_rate_LanceDB = CaseConfigInput(
+    label=CaseConfigParamType.sample_rate,
+    displayLabel="Sample Rate",
+    inputHelp="Sample rate for training. Higher values are more accurate but slower",
+    inputType=InputType.Number,
+    inputConfig={
+        "min": 16,
+        "max": 1024,
+        "value": 256,
+    },
+    isDisplayed=lambda config: config.get(CaseConfigParamType.IndexType, None) == IndexType.IVFPQ.value
+    or config.get(CaseConfigParamType.IndexType, None) == IndexType.HNSW.value,
+)
+
+CaseConfigParamInput_max_iterations_LanceDB = CaseConfigInput(
+    label=CaseConfigParamType.max_iterations,
+    displayLabel="Max Iterations",
+    inputHelp="Maximum iterations for k-means clustering",
+    inputType=InputType.Number,
+    inputConfig={
+        "min": 10,
+        "max": 200,
+        "value": 50,
+    },
+    isDisplayed=lambda config: config.get(CaseConfigParamType.IndexType, None) == IndexType.IVFPQ.value
+    or config.get(CaseConfigParamType.IndexType, None) == IndexType.HNSW.value,
+)
+
+CaseConfigParamInput_m_LanceDB = CaseConfigInput(
+    label=CaseConfigParamType.m,
+    displayLabel="m",
+    inputHelp="m parameter in HNSW",
+    inputType=InputType.Number,
+    inputConfig={
+        "min": 0,
+        "max": 1000,
+        "value": 0,
+    },
+    isDisplayed=lambda config: config.get(CaseConfigParamType.IndexType, None) == IndexType.HNSW.value,
+)
+
+CaseConfigParamInput_ef_construction_LanceDB = CaseConfigInput(
+    label=CaseConfigParamType.ef_construction,
+    displayLabel="ef_construction",
+    inputHelp="ef_construction parameter in HNSW",
+    inputType=InputType.Number,
+    inputConfig={
+        "min": 0,
+        "max": 1000,
+        "value": 0,
+    },
+    isDisplayed=lambda config: config.get(CaseConfigParamType.IndexType, None) == IndexType.HNSW.value,
+)
+
+LanceDBLoadConfig = [
+    CaseConfigParamInput_IndexType_LanceDB,
+    CaseConfigParamInput_num_partitions_LanceDB,
+    CaseConfigParamInput_num_sub_vectors_LanceDB,
+    CaseConfigParamInput_num_bits_LanceDB,
+    CaseConfigParamInput_sample_rate_LanceDB,
+    CaseConfigParamInput_max_iterations_LanceDB,
+    CaseConfigParamInput_m_LanceDB,
+    CaseConfigParamInput_ef_construction_LanceDB,
+]
+
+LanceDBPerformanceConfig = LanceDBLoadConfig
+
 CASE_CONFIG_MAP = {
     DB.Milvus: {
         CaseLabel.Load: MilvusLoadConfig,
@@ -1551,4 +1672,8 @@ CASE_CONFIG_MAP = {
         CaseLabel.Load: VespaLoadingConfig,
         CaseLabel.Performance: VespaPerformanceConfig,
     },
+    DB.LanceDB: {
+        CaseLabel.Load: LanceDBLoadConfig,
+        CaseLabel.Performance: LanceDBPerformanceConfig,
+    },
 }