向量库历史版本（V1）快速入门--向量数据库VikingDB-火山引擎

文档中心

向量数据库VikingDB

向量库历史版本（V1）

向量库历史版本（V1）快速入门

以下最佳实践基于旧版API实现，后续我们会基于新版API V2更新，若使用新版API V2想参考最佳实践请联系我们。

以下最佳实践基于新版本的控制台前端及新版本的API V1 实现，请您关注自己的版本对应使用：
如何判断自己是否是旧版本：
若您是2025.08.14前开通的用户，页面如下图所示，则为旧版本。

若您是2025.08.14后开通的用户则无法使用此版本，请使用新版本，具体可参考向量库新版本（V2）快速入门
若您已升级为新版本，也可通过下图左上角按钮切换为旧版本，使用旧版本下的数据集。但不推荐您新的场景使用旧版本。

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

开通向量库

分为以下三个步骤：

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

注册账号

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

实名认证

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

开通向量数据库

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

配置向量库

第一步，创建数据集

创建数据集有两种方式：

方式一：首页点击向量数据库，进入控制台的开始使用页面，单击页面上方教程栏第一步中的创建数据集
方式二：首页点击向量数据库，进入控制台。在控制台左侧导航栏单击数据集，进入数据集页面，再点击左上方创建数据集。

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

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

在创建数据集页面填写相关参数，包括数据集基础信息、向量配置和数据库内字段。参照右图示例完成具体配置。
填写完成后单击右下角提交，完成数据集创建流程。

（示例）

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

数据集配置项目

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

第二步，创建索引

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

在创建索引页面填写相关参数，包括索引基础信息和具体的索引配置
填写完成后单击右下角提交，完成索引创建流程。

第三步，写入数据

创建完数据集后，你可以根据弹出的写入数据指引向数据集中写入数据。
在数据集页面，你也可以点击对应数据集卡片的写入数据按钮找到这个弹窗。
在开始使用页面，你也可以单击页面上方教程栏第三步中的写入数据找到这个弹窗。

数据写入现在支持在线同步写入、在线异步写入、本地数据导入和单条数据插入四种形式。

在线同步写入

适用于在线服务数据实时写入生效场景，提供流式写入接口。

安装/升级 SDK

# 使用 pip 安装 SDK for Python，支持 Python 3.7 及其以上版本
pip3 install --user volcengine

//推荐通过 Maven 依赖使用火山引擎 SDK for Java
<dependency>
    <groupId>com.volcengine</groupId>
    <artifactId>volc-sdk-java</artifactId>
    <version>最新版本</version>
</dependency>

//安装 SDK for Go，支持Go 1.14及其以上版本
go get -u github.com/volcengine/volc-sdk-golang

//推荐使用 pnpm 管理依赖，请使用 Node version >= 12，SDK 版本 >= 1.19.0
pnpm add @volcengine/openapi

初始化SDK

from volcengine.viking_db import *
vikingdb_service = VikingDBService("host", "region")
vikingdb_service.set_ak("Your ak")
vikingdb_service.set_sk("Your sk")

VikingDBService vikingDBService = new VikingDBService("host", "region", "Your ak", "Your sk", "scheme");
//获取更多数据写入信息，请参阅我们的文档获取详细信息和示例。
//Java SDK 接入指南

service := vikingDB.NewVikingDBService("host", "region", "Your ak", "Your sk", "scheme");
//获取更多数据写入信息，请参阅我们的文档获取详细信息和示例。
//Go SDK 接入指南

import { vikingdb } from '@volcengine/openapi'

const vikingdbService = new vikingdb.VikingdbService({
  ak: 'Your ak',
  sk: 'Your sk',
  region: 'Your region',
})
// 获取更多数据写入信息，请参阅我们的文档获取详细信息和示例。
// NodeJS 接入指南

写入数据

在写入数据时请根据选择"从向量化开始"或"已有向量数据"来决定上传时需要写入的参数。

如果选择“已有向量数据”，请上传"vector"类型数据。
如果选择“从向量化开始”，请根据需要向量化的数据类型上传“text”或“image”类型数据。

请注意：根据所选数据集创建方式，vector字段和text字段只能选择一个进行上传。

# 获取指定数据集，程序初始化时调用即可，无需重复调用
collection = vikingdb_service.get_collection("example")

def gen_random_vector(dim):    # 构建指定维度的随机向量
    return [random.random() - 0.5 for _ in range(dim)]  # 生成随机向量
# field中的字段名称根据所建立数据集的字段名称而定
field = {
    "doc_id": "11",
    # 如果选择“从向量化开始”，请根据需求上传需要向量化的字段“text”，“image”
    "text": "这是一段需要自动embedding的文本示例",
    # 若需要上传多模态数据，请先将图片上传至TOS，并将图片存储路径传入"image"字段
    "image": "tos://your-bucket-name/path/to/image.jpg",  # 图片存储路径
    # 如果选择“已有向量数据”，请将已有向量上传至"text_vector"字段。
    #"text_vector": gen_random_vector(12),  # 生成12维随机向量
    "price": 1.11,
    "author": ["zh"],
    "aim": True,
}
data = Data(field)
collection.upsert_data([data])  # 插入或更新单条数据

async def upsert_data():
    collection = await vikingdb_service.async_get_collection("async")   # 异步上传示例数据
    field = {
        "doc_id": "111",
        "text_vector": gen_random_vector(10),  # 生成10维随机向量
        "like": 1,
        "price": 1.11,
        "author": ["gy"],
        "aim": True,
    }
    data = Data(field)
    await collection.async_upsert_data([data])  # 异步插入或更新单条数据
asyncio.run(upsert_data())

//getCollection获取指定数据集，程序初始化时调用即可，无需重复调用
Collection collection = vikingDBService.getCollection("javaSDKTest");

// 构建向量方法
HashMap<String, Object> field = new HashMap<>();
List<String> authors = new ArrayList<>();
authors.add("name1");
authors.add("name2");

// 填充示例数据
field.put("doc_id", "11");
field.put("text_sparse_vector", Map.of("hello", 0.34, "world", 0.03, "!", 0.11)); // 稀疏向量
// 如果选择“从向量化开始”，请根据需求上传需要向量化的字段"text"和"image"
field.put("text", "这是一段需要自动embedding的文本示例");
// 若需要上传多模态数据，请先将图片上传至TOS，并将图片存储路径传入"image"字段
// 如果选择“已有向量数据”，请将已有向量上传至"text_vector"字段。
//field.put("text_vector", genRandomVector(12)); // 生成12维随机向量
field.put("image", "tos://your-bucket-name/path/to/image.jpg");
field.put("like", 1);
field.put("price", 1.11);
field.put("aim", true);
field.put("author", authors);

// 创建 DataObject
DataObject dataObject = new DataObject()
                        .setFields(field)
                        .build();

// 写入数据到集合
collection.upsertData(Collections.singletonList(dataObject)); // 插入单条数据
//获取更多数据写入信息，请参阅我们的文档获取详细信息和示例。
//Java SDK 接入指南

//GetCollection获取指定数据集，程序初始化时调用即可，无需重复调用
collection, _ := service.GetCollection("go")

//构建向量
field1 := map[string]interface{}{
    "doc_id":      "111",
    "text_sparse_vector":map[string]float64{"hello": 0.34, "world": 0.03, "!": 0.11}
    "text":        "这是一段需要自动embedding的文本示例", // 新增字段
    "image":       "tos://your-bucket-name/path/to/image.jpg", // 新增字段
    //"text_vector": genRandomVector(12),
    "like":        1,
    "price":       1.11,
    "author":      []string{"gy"},
    "aim":         true,
}

data1 := vikingdb.Data{
    Fields: field1,
}
datas := []vikingdb.Data{
    data1,
}
err := collection.UpsertData(datas)
if err != nil {
    print(err.Error())
}
//获取更多数据写入信息，请参阅我们的文档获取详细信息和示例。
//Go SDK 接入指南

import { vikingdb } from '@volcengine/openapi'

declare const service: vikingdb.VikingdbService // 替换为你初始化好的实例

await service.data.UpsertData({
  CollectionName: 'test_collection_1',
  Fields: [
    { Id: 1, Name: 'Tom' },
    { Id: 2, Name: 'Jerry' },
    
  ],
})

// 获取更多数据写入信息，请参阅我们的文档获取详细信息和示例。
// NodeJS 接入指南

在线异步写入

完成SDK安装与初始化的基础上，您可以使用在线异步写入的方式写入数据。
异步写入可以提供比同步写入大10倍的写入带宽，适用于更大规模数据量级的实时更新场景。

import multiprocessing
import struct, base64, uuid, tqdm, time
from volcengine.viking_db import *

queue = multiprocessing.Queue(maxsize=10)
event = multiprocessing.Event()
def consumer():
    """消费者函数：从队列中取出数据并处理"""
    vikingdb_service = VikingDBService()
    vikingdb_service.set_ak("ak")
    vikingdb_service.set_sk("sk")
    collection = vikingdb_service.get_collection("")
    items = []
    while not event.is_set() or not queue.empty():
        item = queue.get()
        items.append(item)
        if len(items) == 50:
            collection.upsert_data(items, async_upsert=True)
            items = []
    print("Consumer received event. Exiting...")
if __name__ == "__main__":         # 创建消费者进程
    processors = []
    for i in range(10):
        p = multiprocessing.Process(target=consumer)
        p.start()
        processors.append(p)
    datas = []      #  准备数据
    for i in range(100000):       # 压缩向量
        float_array = [0.124135132531424]*1024
        packed_data = struct.pack('f'*len(float_array), *float_array)
        s =  base64.b64encode(packed_data).decode()
        uuid4 = uuid.uuid4()  # 此处用户可修改为自己希望的id
        datas.append(Data({"id": str(uuid4), "text_vertor": s}))
    for data in tqdm.tqdm(datas):
        queue.put(data)
    event.set()        # 通知消费者停止工作
    for p in processors:
        p.join()
    print("Main process exiting...")

class Consumer implements Runnable {
    private final LinkedBlockingQueue<DataObject> queue;
    private final AtomicBoolean event;

    public Consumer(LinkedBlockingQueue<DataObject> queue, AtomicBoolean event) {
        this.queue = queue;
        this.event = event;
    }

    @Override
    public void run() {
        VikingDBService vikingdbService = null;
        try {
            vikingdbService = new VikingDBService();
        } catch (Exception e) {
            e.printStackTrace();
        }
        Collection collection = null;
        try {
            collection = vikingdbService.getCollection("");
        } catch (Exception e) {
            e.printStackTrace();
        }
        List<DataObject> items = new ArrayList<>();

        while (!event.get() || !queue.isEmpty()) {
            try {
                DataObject item = queue.poll(1, TimeUnit.SECONDS);
                if (item != null) {
                    items.add(item);
                    if (items.size() == 50) {
                        try {
                            collection.upsertData(items, true);
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                        items.clear();
                    }
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }

        System.out.println("Consumer received event. Exiting...");
    }
}

public class test {
    public static List<Double> genRandomVector(int dim){
        List<Double> res = new ArrayList<>();
        for(int i=0;i<dim;i++){
            res.add(new Random().nextDouble());
        }
        return res;
    }

    public static void main(String[] args) throws Exception {
        VikingDBService vikingDBService = new VikingDBService();
        LinkedBlockingQueue<DataObject> queue = new LinkedBlockingQueue<>(10);
        AtomicBoolean event = new AtomicBoolean(false);
        List<Thread> processors = new ArrayList<>();

        for (int i = 0; i < 10; i++) {
            Thread p = new Thread(new Consumer(queue, event));
            p.start();
            processors.add(p);
        }
        int num = 10000;

        List<DataObject> datas = new ArrayList<>();
        for (int i = 0; i < num; i++) {
            float[] floatArray = new float[1024];
            Arrays.fill(floatArray, 0.124135132531424f);
            ByteBuffer byteBuffer = ByteBuffer.allocate(floatArray.length * Float.BYTES);
            byteBuffer.asFloatBuffer().put(floatArray);
            String s = Base64.getEncoder().encodeToString(byteBuffer.array());
            UUID uuid4 = UUID.randomUUID();

            HashMap<String,Object> field = new HashMap<String,Object>();
            field.put("id", uuid4);
            field.put("text_vector", s);
            DataObject dataObject = new DataObject()
               .setFields(field)
               .build();
            datas.add(dataObject);
        }

        ProgressBar pb = new ProgressBar("Processing", num);
        for (DataObject data : datas) {
            queue.put(data);
            pb.step();
        }
        pb.close();

        event.set(true);
        for (Thread p : processors) {
            p.join();
        }
        System.out.println("Main process exiting...");
     }
 }

var wg sync.WaitGroup

func consumer(queue <-chan vikingdb.Data, vikingDBService *vikingdb.VikingDBService, stopChan <-chan struct{}) {
    defer wg.Done()
    collection, err := vikingDBService.GetCollection("")
    if err != nil {
        fmt.Println(err)
    }
    items := make([]vikingdb.Data, 0, 50)

    for {
        select {
        case item := <-queue:
            items = append(items, item)
            if len(items) == 50 {
                collection.UpsertData(items, vikingdb.WithAsyncUpsert(true))
                items = items[:0]
            }
        case <-stopChan:
            if len(items) > 0 {
                collection.UpsertData(items, vikingdb.WithAsyncUpsert(true))
            }
            return
        }
    }
}

func main() {
    queue := make(chan vikingdb.Data, 10)
    stopChan := make(chan struct{})
    vikingDBService := vikingdb.NewVikingDBService()

    // 创建消费者
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go consumer(queue, vikingDBService, stopChan)
    }

    // 准备数据
    num := 10000
    floatArray := make([]float32, 1024)
    for j := range floatArray {
        floatArray[j] = 0.124135132531424
    }

    var datas []vikingdb.Data
    for i := 0; i < num; i++ {
        packedData := make([]byte, 1024*4)
        for j, v := range floatArray {
            binary.LittleEndian.PutUint32(packedData[j*4:], math.Float32bits(v))
        }
        s := base64.StdEncoding.EncodeToString(packedData)
        id := uuid.New().String()
        field := map[string]interface{}{
            "id":          id,
            "text_vector": s,
        }
        datas = append(datas, vikingdb.Data{Fields: field})
    }
    progressBar := pb.StartNew(num)

    for _, data := range datas {
        queue <- data
        progressBar.Increment()
    }
    close(stopChan)

    progressBar.Finish()

    // 等待所有消费者完成工作
    wg.Wait()
    fmt.Println("Main process exiting...")
}

本地数据导入适用于首次建库，一次性大批量离线数据上传场景，提供大批量处理能力，速度更快。

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

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

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

具体执行逻辑可参考如下流程图。

本地数据导入
1. 安装/升级 SDK

# 使用 pip 安装 SDK for Python，支持 Python 3.7 及其以上版本
pip3 install --user volcengine

//安装 SDK for Go，支持Go 1.14及其以上版本
go get -u github.com/volcengine/volc-sdk-golang

//推荐通过 Maven 依赖使用火山引擎 SDK for Java
<dependency>
    <groupId>com.volcengine</groupId>
    <artifactId>volc-sdk-java</artifactId>
    <version>最新版本</version>
</dependency>

本地数据导入

您可以下载代码样例文件后通过文件导入本地数据
pythonDemo.py
您可以下载代码样例文件后通过文件导入本地数据
goDemo.go
您可以下载代码样例文件后通过文件导入本地数据
javaDemo.java
本地数据导入时，如果您需要上传多模态信息，也请上传tos地址。

单条数据插入

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

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

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

在线异步写入示例

如您在第一步中按示例创建了数据集，并完成了SDK的初始化，您可以使用以下代码写入一份测试数据。

import asyncio
import nest_asyncio

nest_asyncio.apply()
# 异步插入数据函数
async def upsert_data():
    try:     # 获取异步集合对象     
        collection = await vikingdb_service.async_get_collection("VikingDB_Example")
        fields = [  # 数据内容
            {"ID": 1, "description": "苹果是红色的", "title": "水果", "date": "202408"},
            {"ID": 2, "description": "香蕉是黄色的", "title": "水果", "date": "202408"},
            {"ID": 3, "description": "苹果长在苹果树上", "title": "水果", "date": "202410"},
            {"ID": 4, "description": "鱼生活在水里", "title": "动物", "date": "202411"},
            {"ID": 5, "description": "欢迎使用VikingDB", "title": "欢迎", "date": "202412"}
        ]        
        datas = [   # 构造数据对象列表
            Data({
                "ID": str(field["ID"]),          # 文档唯一标识符
                "description": field["description"],  # 文本描述
                "title": field["title"],         # 数据分类
                "date": field["date"]            # 日期字段
            }) 
            for field in fields
        ]        
        await collection.async_upsert_data(datas)     # 异步插入或更新数据
        print("数据插入完成！")  # 日志输出
    except Exception as e:     # 捕获并处理可能的异常        
        print(f"插入数据时发生错误: {e}")
# 执行异步函数
await upsert_data()

func main() {
        collection := vikingdb.GetCollection("VikingDB_Example")  // 获取指定数据集
        // 数据内容
        field1 := map[string]interface{}{
                "ID":          1,
                "description": "苹果是红色的",
                "title":       "水果",
                "date":        "202408",
        }
        field2 := map[string]interface{}{
                "ID":          2,
                "description": "香蕉是黄色的",
                "title":       "水果",
                "date":        "202408",
        }
        field3 := map[string]interface{}{
                "ID":          3,
                "description": "苹果长在苹果树上",
                "title":       "水果",
                "date":        "202410",
        }
        field4 := map[string]interface{}{
                "ID":          4,
                "description": "鱼生活在水里",
                "title":       "动物",
                "date":        "202411",
        }
        field5 := map[string]interface{}{
                "ID":          5,
                "description": "欢迎使用VikingDB",
                "title":       "欢迎",
                "date":        "202412",
        }
        // 创建数据对象
        data1 := vikingdb.Data{
                Fields: field1,
        }
        data2 := vikingdb.Data{
                Fields: field2,
        }
        data3 := vikingdb.Data{
                Fields: field3,
        }
        data4 := vikingdb.Data{
                Fields: field4,
        }
        data5 := vikingdb.Data{
                Fields: field5,
        }
        datas := []vikingdb.Data{data1, data2, data3, data4, data5}// 将数据对象添加到数据列表
        err := collection.UpsertData(datas)    // 执行数据插入
        if err != nil {
                log.Fatal("插入数据时发生错误:", err)
        } else {
                fmt.Println("数据插入完成！")
        }
}

import java.util.*;
public class VikingDBExample {
    public static void main(String[] args) {
        try {
            // 获取指定数据集
            Collection collection = vikingDBService.getCollection("VikingDB_Example");
            List<Map<String, Object>> fieldsList = Arrays.asList(   // 数据内容
                createField(1, "苹果是红色的", "水果", "202408"),
                createField(2, "香蕉是黄色的", "水果", "202408"),
                createField(3, "苹果长在苹果树上", "水果", "202410"),
                createField(4, "鱼生活在水里", "动物", "202411"),
                createField(5, "欢迎使用VikingDB", "欢迎", "202412")
            );
            List<DataObject> dataObjects = new ArrayList<>();
            for (Map<String, Object> field : fieldsList) {
                dataObjects.add(new DataObject().setFields(field).build());
            }
            collection.upsertData(dataObjects);   // 执行数据插入
            System.out.println("数据插入完成！");
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("插入数据时发生错误: " + e.getMessage());
        }
    }
    private static Map<String, Object> createField(int id, String description, String title, String date) {
        Map<String, Object> field = new HashMap<>();
        field.put("ID", id);
        field.put("description", description);
        field.put("title", title);
        field.put("date", date);
        return field;
    }
}

import { vikingdb } from '@volcengine/openapi';
declare const service: vikingdb.VikingdbService // 替换为你初始化好的实例
// 准备要插入的数据
const fields = [
  { Id: 1, description: "苹果是红色的", title: "水果", date: "202408" },
  { Id: 2, description: "香蕉是黄色的", title: "水果", date: "202408" },
  { Id: 3, description: "苹果长在苹果树上", title: "水果", date: "202410" },
  { Id: 4, description: "鱼生活在水里", title: "动物", date: "202411" },
  { Id: 5, description: "欢迎使用VikingDB", title: "欢迎", date: "202412" }
];
// 插入数据函数
async function insertData() {
  try {
    // 使用 UpsertData 插入数据
    await service.data.UpsertData({
      CollectionName: 'VikingDB_Example', // 指定集合名称
      Fields: fields, // 数据字段
    });
    console.log("数据插入完成！");
  } catch (error) {
    console.error("插入数据时发生错误:", error);
  }
}
// 执行插入数据操作
insertData();

第四步，检索查询

在索引列表页面操作列，单击指定索引的检索测试按钮，进入检索测试页面。

检索测试页会根据您的数据集配置给出对应的测试方法。
- 您可以输入查询向量、限制（Top-K）、子索引进行检索测试
- 如果您按照上面的示例配置，在创建数据集时配置了向量化模型，您可以在输入框中输入文本来进行端到端的文本检索。
- 检索测试将会有dense_weight参数，用于控制混合检索中稠密向量的权重。
点击查询后，页面右侧会按照输入的查询向量检索出相似的 K 个向量，查询结果默认按照 score 从高到低排序。
如果您创建了直接导入向量的数据集，且包含了稠密向量和稀疏向量的混合索引，您需要同时输入稠密向量和稀疏向量进行检索。

（配置了文本向量化模型可直接进行文本检索）

（配置了图文向量化模型可直接进行多模态检索）

（稠密向量和稀疏向量的混合检索）

此外，我们在开始使用页面还为您准备了探索指南，您可以根据需要按照指引深入探索VikingDB向量数据库：

快速入门：了解如何开始使用并快速创建您的向量数据库。
最佳实践：学习在多模态搜索、多模态标注等高频场景下向量数据库最佳实践，帮助找到符合您场景的使用方式。
常见问题：解答您在使用过程中遇到的常见问题，提供解决方案和建议。
SDK参考：查阅 SDK 的详细文档，包括 API、示例代码和集成指南，帮助您高效开发。

最近更新时间：2026.06.18 16:58:08

这个页面对您有帮助吗？

有用

无用

向量数据库VikingDB

注册账号 #

实名认证 #

开通向量数据库 #

数据集配置项目 #

在线同步写入 #

在线异步写入 #

本地数据导入 适用于首次建库，一次性大批量离线数据上传场景，提供大批量处理能力，速度更快。 #

单条数据插入 #

在线异步写入示例 #