vectordb-bench 0.0.30__py3-none-any.whl → 1.0.0__py3-none-any.whl

vectordb_bench/frontend/components/label_filter/charts.py

@@ -0,0 +1,60 @@
+import plotly.express as px
+from vectordb_bench.metric import metric_unit_map
+
+
+def drawCharts(st, allData, **kwargs):
+    dataset_names = list(set([data["dataset_name"] for data in allData]))
+    dataset_names.sort()
+    for dataset_name in dataset_names:
+        container = st.container()
+        container.subheader(dataset_name)
+        data = [d for d in allData if d["dataset_name"] == dataset_name]
+        drawChartByMetric(container, data, **kwargs)
+
+
+def drawChartByMetric(st, data, metrics=("qps", "recall"), **kwargs):
+    columns = st.columns(len(metrics))
+    for i, metric in enumerate(metrics):
+        container = columns[i]
+        container.markdown(f"#### {metric}")
+        drawChart(container, data, metric)
+
+
+def getRange(metric, data, padding_multipliers):
+    minV = min([d.get(metric, 0) for d in data])
+    maxV = max([d.get(metric, 0) for d in data])
+    padding = maxV - minV
+    rangeV = [
+        minV - padding * padding_multipliers[0],
+        maxV + padding * padding_multipliers[1],
+    ]
+    return rangeV
+
+
+def drawChart(st, data: list[object], metric):
+    unit = metric_unit_map.get(metric, "")
+    x = "filter_rate"
+    xrange = getRange(x, data, [0.05, 0.1])
+
+    y = metric
+    yrange = getRange(y, data, [0.2, 0.1])
+
+    data.sort(key=lambda a: a[x])
+
+    fig = px.line(
+        data,
+        x=x,
+        y=y,
+        color="db_name",
+        line_group="db_name",
+        text=metric,
+        markers=True,
+    )
+    fig.update_xaxes(range=xrange)
+    fig.update_yaxes(range=yrange)
+    fig.update_traces(textposition="bottom right", texttemplate="%{y:,.4~r}" + unit)
+    fig.update_layout(
+        margin=dict(l=0, r=0, t=40, b=0, pad=8),
+        legend=dict(orientation="h", yanchor="bottom", y=1, xanchor="right", x=1, title=""),
+    )
+    st.plotly_chart(fig, use_container_width=True)

vectordb_bench/frontend/components/run_test/caseSelector.py

@@ -1,8 +1,21 @@
-from vectordb_bench.frontend.config.styles import *
-from vectordb_bench.frontend.config.dbCaseConfigs import *
+from vectordb_bench.backend.clients import DB
+from vectordb_bench.frontend.components.run_test.inputWidget import inputWidget
 from collections import defaultdict
+from vectordb_bench.frontend.config.dbCaseConfigs import (
+    UI_CASE_CLUSTERS,
+    UICaseItem,
+    UICaseItemCluster,
+    get_case_config_inputs,
+    get_custom_case_cluter,
+)
+from vectordb_bench.frontend.config.styles import (
+    CASE_CONFIG_SETTING_COLUMNS,
+    CHECKBOX_INDENT,
+    DB_CASE_CONFIG_SETTING_COLUMNS,
+)
 
 from vectordb_bench.frontend.utils import addHorizontalLine
+from vectordb_bench.models import CaseConfig
 
 
 def caseSelector(st, activedDbList: list[DB]):
@@ -24,7 +37,7 @@ def caseSelector(st, activedDbList: list[DB]):
         activedCaseList += caseClusterExpander(st, caseCluster, dbToCaseClusterConfigs, activedDbList)
     for db in dbToCaseClusterConfigs:
         for uiCaseItem in dbToCaseClusterConfigs[db]:
-            for case in uiCaseItem.cases:
+            for case in uiCaseItem.get_cases():
                 dbToCaseConfigs[db][case] = dbToCaseClusterConfigs[db][uiCaseItem]
 
     return activedCaseList, dbToCaseConfigs
@@ -48,15 +61,38 @@ def caseItemCheckbox(st, dbToCaseClusterConfigs, uiCaseItem: UICaseItem, actived
         unsafe_allow_html=True,
     )
 
+    caseConfigSetting(st.container(), uiCaseItem)
+
     if selected:
-        caseConfigSetting(st.container(), dbToCaseClusterConfigs, uiCaseItem, activedDbList)
+        dbCaseConfigSetting(st.container(), dbToCaseClusterConfigs, uiCaseItem, activedDbList)
+
+    return uiCaseItem.get_cases() if selected else []
+
+
+def caseConfigSetting(st, uiCaseItem: UICaseItem):
+    config_inputs = uiCaseItem.extra_custom_case_config_inputs
+    if len(config_inputs) == 0:
+        return
 
-    return uiCaseItem.cases if selected else []
+    columns = st.columns(
+        [
+            1,
+            *[DB_CASE_CONFIG_SETTING_COLUMNS / CASE_CONFIG_SETTING_COLUMNS] * CASE_CONFIG_SETTING_COLUMNS,
+        ]
+    )
+    columns[0].markdown(
+        f"<div style='margin: 0 0 24px {CHECKBOX_INDENT}px; font-size: 18px; font-weight: 600;'>Custom Config</div>",
+        unsafe_allow_html=True,
+    )
+    for i, config_input in enumerate(config_inputs):
+        column = columns[1 + i % CASE_CONFIG_SETTING_COLUMNS]
+        key = f"custom-config-{uiCaseItem.label}-{config_input.label.value}"
+        uiCaseItem.tmp_custom_config[config_input.label.value] = inputWidget(column, config=config_input, key=key)
 
 
-def caseConfigSetting(st, dbToCaseClusterConfigs, uiCaseItem: UICaseItem, activedDbList: list[DB]):
+def dbCaseConfigSetting(st, dbToCaseClusterConfigs, uiCaseItem: UICaseItem, activedDbList: list[DB]):
     for db in activedDbList:
-        columns = st.columns(1 + CASE_CONFIG_SETTING_COLUMNS)
+        columns = st.columns(1 + DB_CASE_CONFIG_SETTING_COLUMNS)
         # column 0 - title
         dbColumn = columns[0]
         dbColumn.markdown(
@@ -64,52 +100,12 @@ def caseConfigSetting(st, dbToCaseClusterConfigs, uiCaseItem: UICaseItem, active
             unsafe_allow_html=True,
         )
         k = 0
-        caseConfig = dbToCaseClusterConfigs[db][uiCaseItem]
-        for config in CASE_CONFIG_MAP.get(db, {}).get(uiCaseItem.caseLabel, []):
-            if config.isDisplayed(caseConfig):
-                column = columns[1 + k % CASE_CONFIG_SETTING_COLUMNS]
+        dbCaseConfig = dbToCaseClusterConfigs[db][uiCaseItem]
+        for config in get_case_config_inputs(db, uiCaseItem.caseLabel):
+            if config.isDisplayed(dbCaseConfig):
+                column = columns[1 + k % DB_CASE_CONFIG_SETTING_COLUMNS]
                 key = "%s-%s-%s" % (db, uiCaseItem.label, config.label.value)
-                if config.inputType == InputType.Text:
-                    caseConfig[config.label] = column.text_input(
-                        config.displayLabel if config.displayLabel else config.label.value,
-                        key=key,
-                        help=config.inputHelp,
-                        value=config.inputConfig["value"],
-                    )
-                elif config.inputType == InputType.Option:
-                    caseConfig[config.label] = column.selectbox(
-                        config.displayLabel if config.displayLabel else config.label.value,
-                        config.inputConfig["options"],
-                        key=key,
-                        help=config.inputHelp,
-                    )
-                elif config.inputType == InputType.Number:
-                    caseConfig[config.label] = column.number_input(
-                        config.displayLabel if config.displayLabel else config.label.value,
-                        # format="%d",
-                        step=config.inputConfig.get("step", 1),
-                        min_value=config.inputConfig["min"],
-                        max_value=config.inputConfig["max"],
-                        key=key,
-                        value=config.inputConfig["value"],
-                        help=config.inputHelp,
-                    )
-                elif config.inputType == InputType.Float:
-                    caseConfig[config.label] = column.number_input(
-                        config.displayLabel if config.displayLabel else config.label.value,
-                        step=config.inputConfig.get("step", 0.1),
-                        min_value=config.inputConfig["min"],
-                        max_value=config.inputConfig["max"],
-                        key=key,
-                        value=config.inputConfig["value"],
-                        help=config.inputHelp,
-                    )
-                elif config.inputType == InputType.Bool:
-                    caseConfig[config.label] = column.checkbox(
-                        config.displayLabel if config.displayLabel else config.label.value,
-                        value=config.inputConfig["value"],
-                        help=config.inputHelp,
-                    )
+                dbCaseConfig[config.label] = inputWidget(column, config, key)
                 k += 1
         if k == 0:
             columns[1].write("Auto")

vectordb_bench/frontend/components/run_test/dbSelector.py

@@ -1,9 +1,10 @@
 from streamlit.runtime.media_file_storage import MediaFileStorageError
 from vectordb_bench.frontend.config.styles import DB_SELECTOR_COLUMNS, DB_TO_ICON
 from vectordb_bench.frontend.config.dbCaseConfigs import DB_LIST
+import streamlit as st
 
 
-def dbSelector(st):
+def dbSelector(st: st):
     st.markdown(
         "<div style='height: 12px;'></div>",
         unsafe_allow_html=True,
@@ -20,11 +21,14 @@ def dbSelector(st):
     for i, db in enumerate(DB_LIST):
         column = dbContainerColumns[i % DB_SELECTOR_COLUMNS]
         dbIsActived[db] = column.checkbox(db.name)
-        try:
-            column.image(DB_TO_ICON.get(db, ""))
-        except MediaFileStorageError:
+        image_src = DB_TO_ICON.get(db, None)
+        if image_src:
+            column.markdown(
+                f'<img src="{image_src}" style="width:100px;height:100px;object-fit:contain;object-position:center;margin-bottom:10px;">',
+                unsafe_allow_html=True,
+            )
+        else:
             column.warning(f"{db.name} image not available")
-            pass
     activedDbList = [db for db in DB_LIST if dbIsActived[db]]
 
     return activedDbList

vectordb_bench/frontend/components/run_test/inputWidget.py

@@ -0,0 +1,48 @@
+from vectordb_bench.frontend.config.dbCaseConfigs import CaseConfigInput, InputType
+
+
+def inputWidget(st, config: CaseConfigInput, key: str):
+    if config.inputType == InputType.Text:
+        return st.text_input(
+            config.displayLabel if config.displayLabel else config.label.value,
+            key=key,
+            help=config.inputHelp,
+            value=config.inputConfig["value"],
+        )
+    if config.inputType == InputType.Option:
+        return st.selectbox(
+            config.displayLabel if config.displayLabel else config.label.value,
+            config.inputConfig["options"],
+            key=key,
+            help=config.inputHelp,
+        )
+    if config.inputType == InputType.Number:
+        return st.number_input(
+            config.displayLabel if config.displayLabel else config.label.value,
+            # format="%d",
+            step=config.inputConfig.get("step", 1),
+            min_value=config.inputConfig["min"],
+            max_value=config.inputConfig["max"],
+            key=key,
+            value=config.inputConfig["value"],
+            help=config.inputHelp,
+        )
+    if config.inputType == InputType.Float:
+        return st.number_input(
+            config.displayLabel if config.displayLabel else config.label.value,
+            step=config.inputConfig.get("step", 0.1),
+            min_value=config.inputConfig["min"],
+            max_value=config.inputConfig["max"],
+            key=key,
+            value=config.inputConfig["value"],
+            help=config.inputHelp,
+        )
+    if config.inputType == InputType.Bool:
+        return st.selectbox(
+            config.displayLabel if config.displayLabel else config.label.value,
+            options=[True, False],
+            index=0 if config.inputConfig["value"] else 1,
+            key=key,
+            help=config.inputHelp,
+        )
+    raise Exception(f"Invalid InputType: {config.inputType}")

vectordb_bench/frontend/components/run_test/submitTask.py

@@ -86,7 +86,9 @@ def controlPanel(st, tasks: list[TaskConfig], taskLabel, isAllValid):
         currentTaskId = benchmark_runner.get_current_task_id()
         tasksCount = benchmark_runner.get_tasks_count()
         text = f":running: Running Task {currentTaskId} / {tasksCount}"
-        st.progress(currentTaskId / tasksCount, text=text)
+
+        if tasksCount > 0:
+            st.progress(currentTaskId / tasksCount, text=text)
 
         columns = st.columns(6)
         columns[0].button(

vectordb_bench/frontend/components/streaming/charts.py

@@ -0,0 +1,253 @@
+import plotly.graph_objects as go
+
+from vectordb_bench.frontend.components.streaming.data import (
+    DisplayedMetric,
+    StreamingData,
+    get_streaming_data,
+)
+from vectordb_bench.frontend.config.styles import (
+    COLORS_10,
+    COLORS_2,
+    SCATTER_LINE_WIDTH,
+    SCATTER_MAKER_SIZE,
+    STREAMING_CHART_COLUMNS,
+)
+
+
+def drawChartsByCase(
+    st,
+    allData,
+    showCaseNames: list[str],
+    **kwargs,
+):
+    allData = [d for d in allData if len(d["st_search_stage_list"]) > 0]
+    for case_name in showCaseNames:
+        data = [d for d in allData if d["case_name"] == case_name]
+        if len(data) == 0:
+            continue
+        container = st.container()
+        container.write("")  # blank line
+        container.subheader(case_name)
+        drawChartByMetric(container, data, case_name=case_name, **kwargs)
+        container.write("")  # blank line
+
+
+def drawChartByMetric(
+    st,
+    case_data,
+    case_name: str,
+    line_chart_displayed_y_metrics: list[tuple[DisplayedMetric, str]],
+    **kwargs,
+):
+    columns = st.columns(STREAMING_CHART_COLUMNS)
+    streaming_data = get_streaming_data(case_data)
+
+    # line chart
+    for i, metric_info in enumerate(line_chart_displayed_y_metrics):
+        metric, note = metric_info
+        container = columns[i % STREAMING_CHART_COLUMNS]
+        container.markdown(f"#### {metric.value.capitalize()}")
+        container.markdown(f"{note}")
+        key = f"{case_name}-{metric.value}"
+        drawLineChart(container, streaming_data, metric=metric, key=key, **kwargs)
+
+    # bar chart
+    container = columns[len(line_chart_displayed_y_metrics) % STREAMING_CHART_COLUMNS]
+    container.markdown("#### Duration")
+    container.markdown(
+        "insert more than ideal-insert-duration (dash-line) means exceeding the maximum processing capacity.",
+        help="vectordb need more time to process accumulated insert requests.",
+    )
+    key = f"{case_name}-duration"
+    drawBarChart(container, case_data, key=key, **kwargs)
+    # drawLineChart(container, data, line_x_displayed_label, label)
+    # drawTestChart(container)
+
+
+def drawLineChart(
+    st,
+    streaming_data: list[StreamingData],
+    metric: DisplayedMetric,
+    key: str,
+    with_last_optimized_data=True,
+    **kwargs,
+):
+    db_names = list({d.db_name for d in streaming_data})
+    db_names.sort()
+    x_metric = kwargs.get("line_chart_displayed_x_metric", DisplayedMetric.search_stage)
+    fig = go.Figure()
+    if x_metric == DisplayedMetric.search_time:
+        ideal_insert_duration = streaming_data[0].ideal_insert_duration
+        fig.add_shape(
+            type="line",
+            y0=min([getattr(d, metric.value) for d in streaming_data]),
+            y1=max([getattr(d, metric.value) for d in streaming_data]),
+            x0=ideal_insert_duration,
+            x1=ideal_insert_duration,
+            line=dict(color="#999", width=SCATTER_LINE_WIDTH, dash="dot"),
+            showlegend=True,
+            name="insert 100% standard time",
+        )
+    for i, db_name in enumerate(db_names):
+        data = [d for d in streaming_data if d.db_name == db_name]
+        color = COLORS_10[i]
+        if with_last_optimized_data:
+            fig.add_trace(
+                get_optimized_scatter(
+                    data,
+                    db_name=db_name,
+                    metric=metric,
+                    color=color,
+                    **kwargs,
+                )
+            )
+        fig.add_trace(
+            get_normal_scatter(
+                data,
+                db_name=db_name,
+                metric=metric,
+                color=color,
+                **kwargs,
+            )
+        )
+    fig.update_layout(
+        margin=dict(l=0, r=0, t=40, b=0, pad=8),
+        legend=dict(orientation="h", yanchor="bottom", y=1, xanchor="left", x=0, title=""),
+    )
+
+    x_title = "Search Stages (%)"
+    if x_metric == DisplayedMetric.search_time:
+        x_title = "Actual Time (s)"
+    fig.update_layout(xaxis_title=x_title)
+    st.plotly_chart(fig, use_container_width=True, key=key)
+
+
+def get_normal_scatter(
+    data: list[StreamingData],
+    db_name: str,
+    metric: DisplayedMetric,
+    color: str,
+    line_chart_displayed_x_metric: DisplayedMetric,
+    **kwargs,
+):
+    unit = ""
+    if "latency" in metric.value:
+        unit = "ms"
+    data.sort(key=lambda x: getattr(x, line_chart_displayed_x_metric.value))
+    data = [d for d in data if not d.optimized]
+    hovertemplate = f"%{{text}}% data inserted.<br>{metric.value}=%{{y:.4g}}{unit}"
+    if line_chart_displayed_x_metric == DisplayedMetric.search_time:
+        hovertemplate = f"%{{text}}% data inserted.<br>actual_time=%{{x:.4g}}s<br>{metric.value}=%{{y:.4g}}{unit}"
+    return go.Scatter(
+        x=[getattr(d, line_chart_displayed_x_metric.value) for d in data],
+        y=[getattr(d, metric.value) for d in data],
+        text=[d.search_stage for d in data],
+        mode="markers+lines",
+        name=db_name,
+        marker=dict(color=color, size=SCATTER_MAKER_SIZE),
+        line=dict(dash="solid", width=SCATTER_LINE_WIDTH, color=color),
+        legendgroup=db_name,
+        hovertemplate=hovertemplate,
+    )
+
+
+def get_optimized_scatter(
+    data: list[StreamingData],
+    db_name: str,
+    metric: DisplayedMetric,
+    color: str,
+    line_chart_displayed_x_metric: DisplayedMetric,
+    **kwargs,
+):
+    unit = ""
+    if "latency" in metric.value:
+        unit = "ms"
+    data.sort(key=lambda x: x.search_stage)
+    if not data[-1].optimized or len(data) < 2:
+        return go.Scatter()
+    data = data[-2:]
+    hovertemplate = f"all data inserted and <b style='color: #333;'>optimized</b>.<br>{metric.value}=%{{y:.4g}}{unit}"
+    if line_chart_displayed_x_metric == DisplayedMetric.search_time:
+        hovertemplate = f"all data inserted and <b style='color: #333;'>optimized</b>.<br>actual_time=%{{x:.4g}}s<br>{metric.value}=%{{y:.4g}}{unit}"
+    return go.Scatter(
+        x=[getattr(d, line_chart_displayed_x_metric.value) for d in data],
+        y=[getattr(d, metric.value) for d in data],
+        text=[d.search_stage for d in data],
+        mode="markers+lines",
+        name=db_name,
+        legendgroup=db_name,
+        marker=dict(color=color, size=[0, SCATTER_MAKER_SIZE]),
+        line=dict(dash="dash", width=SCATTER_LINE_WIDTH, color=color),
+        hovertemplate=hovertemplate,
+        showlegend=False,
+    )
+
+
+def drawBarChart(
+    st,
+    data,
+    key: str,
+    with_last_optimized_data=True,
+    **kwargs,
+):
+    if len(data) < 1:
+        return
+    fig = go.Figure()
+
+    # ideal insert duration
+    ideal_insert_duration = data[0]["st_ideal_insert_duration"]
+    fig.add_shape(
+        type="line",
+        y0=-0.5,
+        y1=len(data) - 0.5,
+        x0=ideal_insert_duration,
+        x1=ideal_insert_duration,
+        line=dict(color="#999", width=SCATTER_LINE_WIDTH, dash="dot"),
+        showlegend=True,
+        name="insert 100% standard time",
+    )
+
+    # insert duration
+    fig.add_trace(
+        get_bar(
+            data,
+            metric=DisplayedMetric.insert_duration,
+            color=COLORS_2[0],
+            **kwargs,
+        )
+    )
+
+    # optimized duration
+    if with_last_optimized_data:
+        fig.add_trace(
+            get_bar(
+                data,
+                metric=DisplayedMetric.optimize_duration,
+                color=COLORS_2[1],
+                **kwargs,
+            )
+        )
+    fig.update_layout(
+        margin=dict(l=0, r=0, t=40, b=0, pad=8),
+        legend=dict(orientation="h", yanchor="bottom", y=1, xanchor="left", x=0, title=""),
+    )
+    fig.update_layout(xaxis_title="time (s)")
+    fig.update_layout(barmode="stack")
+    fig.update_traces(width=0.15)
+    st.plotly_chart(fig, use_container_width=True, key=key)
+
+
+def get_bar(
+    data: list[StreamingData],
+    metric: DisplayedMetric,
+    color: str,
+    **kwargs,
+):
+    return go.Bar(
+        x=[d[metric.value] for d in data],
+        y=[d["db_name"] for d in data],
+        name=metric,
+        marker_color=color,
+        orientation="h",
+        hovertemplate="%{y} %{x:.2f}s",
+    )

vectordb_bench/frontend/components/streaming/data.py

@@ -0,0 +1,62 @@
+from enum import StrEnum
+from dataclasses import dataclass
+
+
+class DisplayedMetric(StrEnum):
+    db = "db"
+    db_name = "db_name"
+    search_stage = "search_stage"
+    search_time = "search_time"
+    qps = "qps"
+    recall = "recall"
+    ndcg = "ndcg"
+    adjusted_recall = "adjusted_recall"
+    adjusted_ndcg = "adjusted_ndcg"
+    latency_p99 = "latency_p99"
+    # st_ideal_insert_duration = "st_ideal_insert_duration"
+    # st_search_time_list = "st_search_time_list"
+    insert_duration = "insert_duration"
+    optimize_duration = "optimize_duration"
+
+
+@dataclass
+class StreamingData:
+    db: str
+    db_name: str
+    search_stage: int
+    search_time: float
+    qps: float
+    recall: float
+    ndcg: float
+    adjusted_recall: float
+    adjusted_ndcg: float
+    latency_p99: float
+    ideal_insert_duration: int
+    insert_duration: float
+    optimize_duration: float
+
+    @property
+    def optimized(self) -> bool:
+        return self.search_stage > 100
+
+
+def get_streaming_data(data) -> list[StreamingData]:
+    return [
+        StreamingData(
+            db=d["db"],
+            db_name=d["db_name"],
+            search_stage=search_stage,
+            search_time=d["st_search_time_list"][i],
+            qps=d["st_max_qps_list_list"][i],
+            recall=d["st_recall_list"][i],
+            ndcg=d["st_ndcg_list"][i],
+            adjusted_recall=round(d["st_recall_list"][i] / min(search_stage, 100) * 100, 4),
+            adjusted_ndcg=round(d["st_ndcg_list"][i] / min(search_stage, 100) * 100, 4),
+            latency_p99=round(d["st_serial_latency_p99_list"][i] * 1000, 2),
+            ideal_insert_duration=d["st_ideal_insert_duration"],
+            insert_duration=d["insert_duration"],
+            optimize_duration=d["optimize_duration"],
+        )
+        for d in data
+        for i, search_stage in enumerate(d["st_search_stage_list"])
+    ]

vectordb_bench/frontend/components/tables/data.py

@@ -24,7 +24,7 @@ def formatData(caseResults: list[CaseResult]):
         db = caseResult.task_config.db.value
         db_label = caseResult.task_config.db_config.db_label
         case_config = caseResult.task_config.case_config
-        case = case_config.case_id.case_cls()
+        case = case_config.case
         filter_rate = case.filter_rate
         dataset = case.dataset.data.name
         metrics = asdict(caseResult.metrics)

vectordb_bench/frontend/components/welcome/explainPrams.py

@@ -0,0 +1,66 @@
+def explainPrams(st):
+    st.markdown("## descriptions")
+    st.markdown("### 1.Overview")
+    st.markdown(
+        """
+- **VectorDBBench** is an open-source benchmarking tool designed specifically for vector databases. Its main features include:
+    - (1) An easy-to-use **web UI** for configuration of tests and visual analysis of results.
+    - (2) A comprehensive set of **standards for testing and metric collection**.
+    - (3) Support for **various scenarios**, including additional support for **Filter** and **Streaming** based on standard tests.
+- VectorDBBench embraces open-source and welcome contributions of code and test result submissions. The testing process and extended scenarios of VectorDBBench, as well as the intention behind our design will be introduced as follows.
+"""
+    )
+    st.markdown("### 2.Dataset")
+    st.markdown(
+        """
+- We provide two embedding datasets:
+    - (1)*[Cohere 768dim](https://huggingface.co/datasets/Cohere/wikipedia-22-12)*, generated using the **Cohere** model based on the Wikipedia corpus. 
+    - (2)*[Cohere 1024dim](https://huggingface.co/datasets/Cohere/beir-embed-english-v3)*, generated using the **Cohere** embed-english-v3.0 model based on the bioasq corpus.
+    - (3)*OpenAI 1536dim*, generated using the **OpenAI** model based on the [C4 corpus](https://huggingface.co/datasets/legacy-datasets/c4).
+"""
+    )
+    st.markdown("### 3.Standard Test")
+    st.markdown(
+        """
+The test is actually divided into 3 sub-processes
+- **3.1 Test Part 1 - Load (Insert + Optimize)**
+    - (1) Use a single process to perform serial inserts until all data is inserted, and record the time taken as **insert_duration**.
+    - (2) For most vector databases, index construction requires additional time to optimize to achieve an optimal state, and record the time taken as **optimize_duration**.
+    - (3) **Load_duration (insert_duration + optimize_duration)** can be understood as the time from the start of insertion until the database is ready to query.
+        - load_duration can serve as a reference for the insert capability of a vector database to some extent. However, it should be noted that some vector databases may perform better under **concurrent insert operations**.
+- **3.2 Test Part 2 - Serial Search Test**
+    - (1) Use a single process to perform serial searches, record the results and time taken for each search, and calculate **recall** and **latency**.
+    - (2) **Recall**: For vector databases, most searches are approximately nearest neighbor(ANN) searches rather than perfectly accurate results. In production environments, commonly targeted recall rates are 0.9 or 0.95.
+        - Note that there is a **trade-off** between **accuracy** and **search performance**. By adjusting parameters, it is possible to sacrifice some accuracy in exchange for better performance. We recommend comparing performance while ensuring that the recall rates remain reasonably close.
+    - (3) **Latency**:**p99** rather than average. **latency_p99** focuses on **the slowest 1% of requests**. In many high-demand applications, ensuring that most user requests stay within acceptable latency limits is critical, whereas **latency_avg** can be skewed by faster requests.
+        - **serial_latency** can serve as a reference for a database's search capability to some extent. However, serial_latency is significantly affected by network conditions. We recommend running the test client and database server within the same local network.
+- **3.3 Test Part 3 - Concurrent Search Test**
+    - (1) Create multiple processes, each perform serial searches independently to test the database's **maximum throughput(max-qps)**.
+    - (2) Since different databases may reach peak throughput under different conditions, we conduct multiple test rounds. The number of processes **starts at 1 by default and gradually increases up to 80**, with each test group running for **30 seconds**.
+        - Detailed latency and QPS metrics at different concurrency levels can be viewed on the <a href="concurrent" target="_self" style="text-decoration: none;">*concurrent*</a> page.
+        - The highest recorded QPS value from these tests will be selected as the final max-qps.
+""",
+        unsafe_allow_html=True,
+    )
+    st.markdown("### 4.Filter Search Test")
+    st.markdown(
+        """
+- Compared to the Standard Test, the **Filter Search** introduces additional scalar constraints (e.g. **color == red**) during the Search Test. Different **filter_ratios** present varying levels of challenge to the VectorDB's search performance.
+- We provide an additional **string column** containing 10 labels with different distribution ratios (50%,20%,10%,5%,2%,1%,0.5%,0.2%,0.1%). For each label, we conduct both a **Serial Test** and a **Concurrency Test** to observe the VectorDB's performance in terms of **QPS, latency, and recall** under different filtering conditions.
+"""
+    )
+    st.markdown("### 5.Streaming Search Test")
+    st.markdown(
+        """
+Different from Standard's load and search separation, Streaming Search Test primarily focuses on **search performance during the insertion process**. 
+Different **base dataset sizes** and varying **insertion rates** set distinct challenges to the VectorDB's search capabilities.
+VectorDBBench will send insert requests at a **fixed rate**, maintaining consistent insertion pressure. The search test consists of three steps as follows:
+- 1.**Streaming Search** 
+    - Users can configure **multiple search stages**. When the inserted data volume reaches a specified stage, a **Serial Test** and a **Concurrent Test** will be conducted, recording qps, latency, and recall performance.
+- 2.**Streaming Final Search**
+    - After all of the data is inserted, a Serial Test and a Concurrent Test are immediately performed, recording qps, latency, and recall performance. 
+        - Note: at this time, the insertion pressure drops to zero since data insertion is complete.
+- 3.**Optimized Search (Optional)**
+    - Users can optionally perform an additional optimization step followed by a Serial Test and a Concurrent Test, recording qps, latency, and recall performance. This step **compares performance in Streaming section with the theoretically optimal performance**.
+"""
+    )