向量库新版本（V2）快速入门--向量数据库VikingDB-火山引擎

文档中心

向量数据库VikingDB

向量库新版本（V2）

向量库新版本（V2）快速入门

以下快速入门基于新版API V2，推荐使用此版本。

说明

以下快速入门基于新版本的控制台前端及新版本的API/SDK V2 实现，请您关注自己的版本对应使用：
如何判断自己是否是新版本？
若您是2025.08.14后开通的用户或控制台页面如下图所示，则默认使用新版本。

若您是2025.08.14前开通的用户或控制台如下图所示，可通过旧版本左上角升级至新版本，具体可参考：
向量库新版本（V2 ）升级与迁移文档

向量数据库 VikingDB 是构建于火山引擎的云基础设施之上的向量数据库系统，其核心功能涵盖了对机器学习模型产生的海量向量数据进行生产、存储、索引以及分析等操作。
在本指南里，我们会引导您在短短几分钟内迅速完成首个向量库的开通、配置工作，让您能够在我们的配置页面走完数据集创建、索引创建以及检索查询的全部流程。

开通向量库

分为以下三个步骤：

注册火山引擎账号。
完成实名认证。
开通向量数据库服务。

注册账号

进入火山引擎官网，单击页面右上角的【立即注册】。
根据要求完整填写表单后即可完成注册，更多详情参考火山引擎账号注册。

实名认证

使用已注册的火山引擎账号登录火山引擎官网。
单击右上角账号名下拉框中的【账号管理】进入对应页面。
单击左侧导航中的【实名认证】，根据实际情况选择个人或者企业，并填写对应表单或上传相关材料完成实名认证，更多详情参考实名认证。

开通向量数据库

登录火山引擎控制台，找到 VikingDB，根据对应的提示按需开通向量数据库服务。

配置向量库

第一步，创建数据集

创建数据集有三种方式：

方式一：首页点击向量数据库进入控制台页面，在我的向量库下方点击【创建数据集】
方式二：首页点击向量数据库，进入控制台的快速开始页面，单击页面上我的向量库旁边的【查看全部】，进入数据集页面，点击【创建数据集】；或在页面上方教程中点击创建数据集
方式三：首页点击向量数据库，进入控制台。在控制台左侧导航栏单击数据集，进入数据集页面，再点击左上方创建数据集；或在页面上方教程中点击创建数据集

您可以通过对图文、视频数据的向量化或直接导入已有向量两种方式创建数据集。在选择创建方式时，您可以根据数据准备的情况选择：

“已有向量数据” 适用于以下场景：
- 您已经在外部完成了文本或图像等数据的向量化处理，并拥有可直接写入的向量数据。
- 您的原始多模态数据（如图片视频）无需存储在向量库关联的对象存储TOS中，而是通过实时调用向量化服务（如 embeddingV2 API），然后仅将向量结果写入数据集。
”从向量化开始“ 适用于以下场景：
- 您尚未对数据进行向量化处理，系统会根据您配置的模型对文本、图像等字段自动进行向量化。
  本例中我们使用从向量化开始的方法创建数据集。

（“已有向量”写入向量，“从向量化开始”写入原始数据）

在 创建数据集 页面填写相关参数，包括数据集基础信息、向量配置和数据库内字段。参照右图示例完成具体配置。
1. 基本信息：填写名称、描述，选择数据类型
2. 向量化配置：
  1. 选择表征方式，可参考【向量库】表征方式配置参考
    1. 稠密向量（必选）
    2. 稀疏向量（可选）
    3. 张量（可选）
  2. 指定向量字段名称、模型和维度
    1. 若选择张量表征方式，稠密向量和张量的表征模型均为doubao-embedding-vision-251215
3. 字段配置：新增全文检索选项，支持为最多两个文本字段开启分词与关键词检索，并可与现有向量检索及过滤能力组合使用
  1. 设置主键
  2. 添加其他向量字段
  3. 勾选全文检索（可选）
  4. 设置标签
填写完成后单击右下角【创建数据集】，完成数据集创建流程。

（示例）

注意

如果需要添加稀疏向量字段，必须配置稠密向量字段，即稀疏向量不能单独出现。
如果需要添加张量字段，必须满足张量字段对应的模型、模型版本以及字段名称需与稠密向量字段一致。
用于向量化的字段不用填写在其他字段中；若其他字段中存在的其他 text、image 、video类型字段仅作为存储数据用途，不会用于向量化，字段名称也不能与向量化字段重复。

数据集配置项目

编号	参数名称	参数说明
1	基础信息（必填）	名称为必填，别名和描述为选填
2	向量信息（必填）	配置向量字段（已有向量字段）或用于向量化的字段（从向量化开始）。
3	字段配置（选填）	配置非向量字段或用于向量化的字段。字段名称：使用英文字母、数字、下划线_，并以英文字母开头，不能重复。字段类型：在下拉列表选择字段类型，可选值：string、bool、list、list、int64、float32、text、image、video。默认：当字段类型不是 text、image、video时，可输入默认值。若未填写，且在数据写入时字段数据缺失，将按系统默认设置填写。全文检索（新增）：当字段类型为 text时，可选择是否开启全文检索。开启以后，支持分词与关键词检索，并可与现有向量检索及过滤能力组合使用。一个数据集最多支持两个文本字段开启。
4	主键（必填）	主键用于唯一标识一行数据可选择自动生成主键或从其他字段中的 string/int64 类型字段中选择一个作为主键
5	费用细则与创建数据集	如果配置了向量化模型，将展示模型费用信息离线存储资源费用将在索引创建后根据存储数据量开始计费

第二步，创建索引

创建索引页面有三种进入方式：
- 方式一：在数据集列表页，单击页面上方教程栏第二步中的创建索引
- 方式二：在左侧导航栏单击索引，进入索引页面。单击索引列表页面左上角的创建索引，进入创建索引页面。
- 方式三：在左侧导航栏单击数据集，进入数据集页面。选择想要创建索引的数据集，单击对应数据集卡片右上角"..."按钮下的创建索引

在 **创建索引 **页面填写相关参数，包括索引基础信息和具体的索引配置，注意一旦创建，即开始构建索引并产生计算资源费用；预估折前价是 0.45 元 / 小时（实际费用还和数据量、折扣等因素相关，以账单为准）
填写完成后单击右下角提交，完成索引创建流程。

索引选择参考

索引类型	索引算法	介绍	使用场景
内存索引	HNSW	首选，适合稠密向量、数据规模较大、对检索性能和延迟要求高的在线场景，具有查询延迟低、吞吐高的特点。	向量维度中等、数据量在百万～上亿级，且全部为稠密向量在线推荐、语义搜索、相似内容去重等，对延迟和 QPS 要求高的场景
	HNSW-Hybrid	在 HNSW 的基础上，同时索引稠密向量和稀疏向量，在一次检索中综合“语义相似度 + 关键词匹配”两类信号。	基于HNSW，检索结果兼顾语义检索和关键词的匹配
	FLAT	全量暴力检索索引，对每个向量都计算一次距离，查询速度相对较慢，但召回率最高	向量候选集规模较小，数据量在几千～几万，对成本不敏感常见于对结果完全准确有强需求的场景，
磁盘索引	DiskANN	磁盘索引方案，大部分数据存储在 SSD 上，仅将少量结构放入内存，适合超大规模数据、内存资源有限但仍希望保持较高召回率的场景。	向量规模预期占用超大内存，数据量在亿级希望在显著降低内存成本的前提下，仍保持较高召回率和可接受的查询延迟

第三步，写入数据

创建完数据集后，你可以根据弹出的写入数据指引向数据集中写入数据。
在数据集页面，你也可以点击对应数据集卡片的写入数据按钮找到这个弹窗。

数据写入现在支持在线写入、本地数据导入、从TOS添加和单条数据插入四种形式（目前视频只支持在线写入）。

点击【写入数据】进入写入页面

在线写入
- 同步写入
- 异步写入
本地数据导入
从TOS添加
单条数据插入

第一类：在线写入

如需使用向量库新版本SDK，需进行前期准备：

安装/升级 SDK

Python SDK

Java SDK

# 使用 pip 安装 SDK for Python，支持 Python 3.7 及其以上版本
uv add vikingdb-python-sdk
// or 
python3 -m pip install -U vikingdb-python-sdk

<dependency>
    <groupId>com.volcengine</groupId>
    <artifactId>vikingdb-java-sdk</artifactId>
    <version>0.1.1</version> <!-- Please check for the latest version -->
    <!-- 推荐使用最新版本 -->
    <!-- 版本号可以参考https://central.sonatype.com/artifact/com.volcengine/vikingdb-java-sdk/versions -->
</dependency>

初始化SDK

Python SDK

Java SDK

from vikingdb import IAM
from vikingdb.vector import SearchByRandomRequest, UpsertDataRequest, VikingVector
client = VikingVector(
    host="your host",
    region="your region",
    auth=IAM(ak="your ak", sk="your sk"),
    scheme="https",
)

import com.volcengine.ApiClient;
import com.volcengine.sign.Credentials;
import com.volcengine.vikingdb.VikingdbApi;

public class QuickStart {
    public static void main(String[] args) {
        String ak = "your-access-key"; // 替换为您的 AK
        String sk = "your-secret-key"; // 替换为您的 SK
        String endpoint = "vikingdb.cn-beijing.volcengineapi.com"; // 填写您的控制面服务域名
        String region = "cn-beijing"; // 填写您的服务区域

        ApiClient apiClient = new ApiClient()
                .setEndpoint(endpoint)
                .setCredentials(Credentials.getCredentials(ak, sk))
                .setRegion(region);

        VikingdbApi api = new VikingdbApi(apiClient);

        // 您现在可以使用 'api' 对象调用 VikingDB API
        // ......
    }
}

同步写入

适用于在线服务数据实时写入生效场景，提供流式写入接口
写入数据：在写入数据时请根据选择**“从向量化开始”或“已有向量数据”**来决定上传时需要写入的参数。

具体写入流程请参考数据面API调用流程，写入数据API参考数据写入-UpsertData
多模态数据写入详见最佳实践

写入示例：
请创建数据集、填入数据集名称、aksk、字段名、json文件地址

Python SDK

Java SDK

API

import os

from vikingdb import IAM
from vikingdb.vector import UpsertDataRequest, VikingVector

auth = IAM(
    ak="your_ak",
    sk="your_sk",
)
client = VikingVector(
    host="api-vikingdb.vikingdb.cn-beijing.volces.com",
    region="cn-beijing",
    auth=auth,
    scheme="https",
)

collection_client = client.collection(collection_name="zyx_test_oncall1114")

payload = {
    "title": "Python upsert demo",
    "score": 42.5,
    "text": "示例负载，省略其余业务字段",
}
request = UpsertDataRequest(
    data=[payload],
    ttl=3600,
    async_write=False,
    ignore_unknown_fields=True,
)
response = collection_client.upsert(request)
print(f"request_id={response.request_id}")
if response.result:
    print(response.result.token_usage)

import com.volcengine.vikingdb.runtime.Util;
import com.volcengine.vikingdb.runtime.core.auth.AuthWithAkSk;
import com.volcengine.vikingdb.runtime.core.ClientConfig;
import com.volcengine.vikingdb.runtime.enums.Scheme;
import com.volcengine.vikingdb.runtime.vector.model.request.UpsertDataRequest;
import com.volcengine.vikingdb.runtime.vector.model.response.DataApiResponse;
import com.volcengine.vikingdb.runtime.vector.model.response.UpsertDataResult;
import com.volcengine.vikingdb.runtime.vector.service.VectorService;

import java.util.Arrays;
import java.util.HashMap;

public class UpsertDataExample {

    public static void main(String[] args) {
        // 1. 初始化客户端 (请替换为您的配置)
        VectorService vectorService = null;
        try {
            vectorService = new VectorService(
                    Scheme.HTTPS,
                    "api-vikingdb.vikingdb.cn-beijing.volces.com",// "your host"
                    "cn-beijing",// "your region"
                    new AuthWithAkSk("your-access-key", "your-secret-key"),
                    ClientConfig.builder().build()
            );
        } catch (Exception e) {
            System.err.println("Client initialization failed: " + e.getMessage());
            e.printStackTrace();
            return;
        }

        // 2. 准备请求
        UpsertDataRequest request = UpsertDataRequest.builder()
                .collectionName("your_collection_name") // 替换为您的集合名称
                .data(Arrays.asList(
                        new HashMap<String, Object>() {{ put("id", 1); put("field1", "value1"); put("vector", Util.generateRandomVector(128)); }},
                        new HashMap<String, Object>() {{ put("id", 2); put("field1", "value2"); put("vector", Util.generateRandomVector(128)); }},
                        new HashMap<String, Object>() {{ put("id", 3); put("field1", "value3"); put("vector", Util.generateRandomVector(128)); }}
                ))
                .build();

        // 3. 发起请求
        try {
            DataApiResponse<UpsertDataResult> response = vectorService.upsertData(request);
            System.out.println("Upsert data successfully:");
            System.out.println(response);
        } catch (Exception e) {
            System.err.println("Failed to upsert data: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

import json
import requests
from volcengine.auth.SignerV4 import SignerV4
from volcengine.Credentials import Credentials
from volcengine.base.Request import Request

def main() -> None:
    client = HTTPClient(
        ak="your ak",
        sk="your sk",
        host="your host",  # 参考https://www.volcengine.com/docs/84313/1792715
        region="your region",
    )

    req_method = "POST"
    collection_name = "your collection_name"

    upsert_body = {
        "collection_name": collection_name,
        "data": [{"id": "123", "text": "hello world"}],
    }
    upsert_resp = client.do_req(
        req_method=req_method,
        req_path="/api/vikingdb/data/upsert",
        req_params=None,
        req_body=upsert_body,
    )
    print(f"[upsert status={upsert_resp.status_code} body={upsert_resp.text}]
===")


class HTTPClient:
    def __init__(self, ak: str, sk: str, host: str, region: str):
        self.ak = ak
        self.sk = sk
        self.host = host
        self.region = region

    def prepare_request(self, method: str, path: str, params=None, data=None) -> Request:
        r = Request()
        r.set_schema("https")            # ensure HTTPS
        r.set_method(method)
        r.set_connection_timeout(10)
        r.set_socket_timeout(10)
        mheaders = {
            "Accept": "application/json",
            "Content-Type": "application/json",
            "Host": self.host,
        }
        r.set_headers(mheaders)
        if params:
            r.set_query(params)
        r.set_host(self.host)
        r.set_path(path)
        if data is not None:
            r.set_body(json.dumps(data))
        credentials = Credentials(self.ak, self.sk, "vikingdb", self.region)
        SignerV4.sign(r, credentials)
        return r

    def do_req(self, req_method: str, req_path: str, req_params, req_body):
        req = self.prepare_request(
            method=req_method,
            path=req_path,
            params=req_params,
            data=req_body,
        )
        return requests.request(
            method=req.method,
            url="{}://{}{}".format(req.schema, self.host, req.path),  # use the schema set above
            headers=req.headers,
            data=req.body,
            timeout=10000,
        )

if __name__ == "__main__":
    main()

异步写入

完成初始化的基础上，对于已有向量数据的数据集，您可以使用在线异步写入的方式写入数据。通过设置 async 参数为true。

说明

异步写入可以提供比同步写入大10倍的写入带宽，适用于更大规模数据量级的实时更新场景。

第二类：本地数据导入

说明

支持图片文本，视频暂时不支持本地写入，正在努力更新

通过前端导入：导入json/parquet格式文档

注意

本地数据导入文件格式示例：

example.json

未知大小

如果您需要上传多模态信息，也请上传 tos 地址。

第三类：从TOS导入

说明

支持图片文本，视频暂时不支持从TOS导入，正在努力更新

TOS 服务开通及授权
- TOS 服务开通
  - 点击创建 TOS 桶。去开通
- 授权 VikingDB 访问
  - 授权 VikingDB 服务可以访问您的 TOS 权限。去授权

若需要上传多模态数据，请先将图片上传至TOS，并将图片的tos存储路径传入"image"字段。

{"animal_image": "tos://best-practice-pic-search-tos/pic_search_1000_images/0009fc27d9.jpg"}

从 TOS 导入数据

直接导入：

前端选择 json/parquet 格式文档的TOS桶
通过 CreateVikingdbTask 接口导入
通过创建 TaskType 为 data_import 导入json/parquet 格式文件，接口详情请参考创建离线任务-CreateVikingdbTask

Python SDK

Java SDK

API

import os
      import volcenginesdkcore
      import volcenginesdkvikingdb as vdb
      from volcenginesdkvikingdb.api.vikingdb_api import VIKINGDBApi
      
      configuration = volcenginesdkcore.Configuration()
      configuration.ak = os.environ["VIKINGDB_AK"]
      configuration.sk = os.environ["VIKINGDB_SK"]
      configuration.region = os.environ["VIKINGDB_REGION"]
      configuration.host = os.environ["VIKINGDB_HOST"]
      configuration.scheme = "https"
      volcenginesdkcore.Configuration.set_default(configuration)
      
      client = VIKINGDBApi()
      
      task_cfg = vdb.TaskConfigForCreateVikingdbTaskInput(
          file_type="parquet",
          tos_path="your-bucket/path/to/data.parquet",
          ignore_error=False,
      )
      
      request = vdb.CreateVikingdbTaskRequest(
          project_name="default",
          collection_name="sdk_demo_collection",
          task_type="data_import",
          task_config=task_cfg,
      )
      response = client.create_vikingdb_task(request)
      print("task id:", response.task_id)
      print("message:", response.message)
      ```

package org.example.newsubproduct.console.task;
      
      import com.volcengine.ApiClient;
      import com.volcengine.ApiException;
      import com.volcengine.sign.Credentials;
      import com.volcengine.vikingdb.VikingdbApi;
      import com.volcengine.vikingdb.model.*;
      
      public class CreateVikingdbTaskDataImport {
          public static void main(String[] args) {
              String ak = System.getenv("AK"); // ak
              String sk = System.getenv("SK"); // sk
              String endpoint = "vikingdb.cn-beijing.volcengineapi.com"; // 填写向量库控制面v2的域名  https://www.volcengine.com/docs/84313/1792715
              String region = "cn-beijing"; // 服务区域
      
              ApiClient apiClient = new ApiClient()
                      .setEndpoint(endpoint)
                      .setCredentials(Credentials.getCredentials(ak, sk))
                      .setRegion(region);
      
              VikingdbApi api = new VikingdbApi(apiClient);
      
              CreateVikingdbTaskRequest request = new CreateVikingdbTaskRequest()
                      .collectionName("test_collection_for_sdk_with_vector")
                      .taskType(CreateVikingdbTaskRequest.TaskTypeEnum.DATA_IMPORT)
                      .taskConfig(
                              new TaskConfigForCreateVikingdbTaskInput()
                                      .fileType(TaskConfigForCreateVikingdbTaskInput.FileTypeEnum.JSON)
                                      .tosPath("test-doc1-tos/pic_search_1000_images.json")
                                      .ignoreError(true)
                      );
      
              try {
                  CreateVikingdbTaskResponse response = api.createVikingdbTask(request);
                  System.out.println("response body: " + response);
                  System.out.println();
                  System.out.println("response meta RequestId: " + response.getResponseMetadata().getRequestId());
                  System.out.println("response meta Service: " + response.getResponseMetadata().getService());
                  System.out.println("response meta Region: " + response.getResponseMetadata().getRegion());
                  System.out.println("response meta Action: " + response.getResponseMetadata().getAction());
                  System.out.println("response meta Version: " + response.getResponseMetadata().getVersion());
              } catch (ApiException e) {
                  System.out.println("exception http code: " + e.getCode());
                  System.out.println("exception response body: " + e.getResponseBody());
                  System.out.println();
                  System.out.println("exception RequestId: " + e.getResponseMetadata().getRequestId());
                  System.out.println("exception Action: " + e.getResponseMetadata().getAction());
                  System.out.println("exception Region: " + e.getResponseMetadata().getRegion());
                  System.out.println("exception Service: " + e.getResponseMetadata().getService());
                  System.out.println("exception Error.Code: " + e.getResponseMetadata().getError().getCode());
                  System.out.println("exception Error.Message: " + e.getResponseMetadata().getError().getMessage());
              }
          }
      }
      ```

import os
      import datetime
      import hashlib
      import hmac
      from urllib.parse import quote
      
      import requests, json
      
      def norm_query(params):
          query = ""
          for key in sorted(params.keys()):
              if type(params[key]) == list:
                  for k in params[key]:
                      query = (
                              query + quote(key, safe="-_.~") + "=" + quote(k, safe="-_.~") + "&"
                      )
              else:
                  query = (query + quote(key, safe="-_.~") + "=" + quote(params[key], safe="-_.~") + "&")
          query = query[:-1]
          return query.replace("+", "%20")
      
      def hmac_sha256(key: bytes, content: str):
          return hmac.new(key, content.encode("utf-8"), hashlib.sha256).digest()
      
      def hash_sha256(content: str):
          return hashlib.sha256(content.encode("utf-8")).hexdigest()
      
      class ClientForConsoleApi:
          def __init__(self, ak, sk, host, region):
              self.ak = ak
              self.sk = sk
              self.host = host
              self.region = region
              self.service_code = "vikingdb"
              self.version = "2025-06-09"
      
          def request(self, method, action, body, query=None, header=None):
              if query is None:
                  query = {}
              if header is None:
                  header = {}
              credential = {
                  "access_key_id": self.ak,
                  "secret_access_key": self.sk,
                  "service": self.service_code,
                  "region": self.region,
              }
              request_param = {
                  "body": json.dumps(body),
                  "host": self.host,
                  "path": "/",
                  "method": method,
                  "content_type": 'application/json',
                  "date": datetime.datetime.utcnow(),
                  "query": {"Action": action, "Version": self.version, **query},
              }
              if body is None:
                  request_param["body"] = ""
              x_date = request_param["date"].strftime("%Y%m%dT%H%M%SZ")
              short_x_date = x_date[:8]
              x_content_sha256 = hash_sha256(request_param["body"])
              sign_result = {
                  "Host": request_param["host"],
                  "X-Content-Sha256": x_content_sha256,
                  "X-Date": x_date,
                  "Content-Type": request_param["content_type"],
              }
              signed_headers_str = ";".join(
                  ["content-type", "host", "x-content-sha256", "x-date"]
              )
              canonical_request_str = "
".join(
                  [request_param["method"].upper(),
                   request_param["path"],
                   norm_query(request_param["query"]),
                   "
".join(
                       [
                           "content-type:" + request_param["content_type"],
                           "host:" + request_param["host"],
                           "x-content-sha256:" + x_content_sha256,
                           "x-date:" + x_date,
                       ]
                   ),
                   "",
                   signed_headers_str,
                   x_content_sha256,
                   ]
              )
      
              hashed_canonical_request = hash_sha256(canonical_request_str)
              credential_scope = "/".join([short_x_date, credential["region"], credential["service"], "request"])
              string_to_sign = "
".join(["HMAC-SHA256", x_date, credential_scope, hashed_canonical_request])
      
              k_date = hmac_sha256(credential["secret_access_key"].encode("utf-8"), short_x_date)
              k_region = hmac_sha256(k_date, credential["region"])
              k_service = hmac_sha256(k_region, credential["service"])
              k_signing = hmac_sha256(k_service, "request")
              signature = hmac_sha256(k_signing, string_to_sign).hex()
      
              sign_result["Authorization"] = "HMAC-SHA256 Credential={}, SignedHeaders={}, Signature={}".format(
                  credential["access_key_id"] + "/" + credential_scope,
                  signed_headers_str,
                  signature,
              )
              header = {**header, **sign_result}
              r = requests.request(method=method,
                                   url="https://{}{}".format(request_param["host"], request_param["path"]),
                                   headers=header,
                                   params=request_param["query"],
                                   data=request_param["body"],
                                   )
              return r.status_code, r.headers, r.json()
      
      if __name__ == '__main__':
          client = ClientForConsoleApi(
              ak = "*",#替换为您的ak
              sk ="*" ,#替换为您的sk
              host="vikingdb.cn-beijing.volcengineapi.com", #替换为您所在地区的域名
              region="cn-beijing"
          )
          http_code, _, result_json = client.request(
              method="POST",
              action="CreateVikingdbTask",#action替换为当前操作
              body={
                  "TaskType": "data_import",
                  "TaskConfig": {
                      "FileType": "json",
                      "NeedConfirm": True,
                      "TosPath": "test-doc1-tos/pic_search_1000_images.json",
                      "ExportAll": False
                  },
                  "ProjectName": "default",
                  "CollectionName": "test_doc1_image"
              }
          )
          print("req http status code: ", http_code)
          print("req result: 
", result_json)
      ```

上传多模态数据：以上传图片格式为例，请先将图片上传至TOS，并将图片的tos存储路径传入"image"字段。具体执行逻辑可参考如下流程图。详见【向量库】多模态搜索最佳实践

第四类：单条数据插入

此外，你还可以在数据集详情页面插入单条数据

在数据集页面点击您想要写入数据的数据集卡片进入数据集详情页面，点击右上角插入数据按钮。
在弹出的插入数据弹窗内输入对应的字段值后，点击插入按钮即可完成数据插入。

（插入一条视频数据）

写入数据后，您可以在数据集详情页面通过主键对数据进行查询

第四步，检索查询

点击数据集，在【索引管理】页面点击【检索测试】，或者在索引列表页面操作列，单击指定索引的检索测试按钮，进入检索测试页面。

检索测试页会根据您的数据集配置给出对应的测试方法。
- 您可以按照检索过滤、后处理、结果配置进行检索参数的调试
- 如果您选择了全文检索，则可以在对话框上方的筛选条件中选择您希望的检索方式，并在检索方式上选择文本检索或者关键词检索。
- 多模态检索条件下会有dense_weight参数，用于控制混合检索中稠密向量的权重。
点击查询后，页面右侧会按照输入的查询向量检索出相似的 K 个向量，查询结果默认按照 score 从高到低排序。
如果您创建了直接导入向量的数据集，且包含了稠密向量和稀疏向量的混合索引，您需要同时输入稠密向量和稀疏向量进行检索。
在检索测试页面中，您可以通过点击左上角"API调用"查看基于检索配置自动生成的 API 调用代码示例。