向量Index - 对象存储 OSS

向量索引 Index 用于存储和管理向量Bucket中的向量数据。每个 Index 定义了向量的维度、距离度量方法和元数据结构，为向量检索提供基础。

创建向量 Index

单个向量 Bucket 中最多可创建 100 张向量索引。
创建向量索引的 API （PutVectorIndex）请求频率限制为最多每秒 5 次。

说明

OSS Vectors 支持创建 Standard Mode 和 Fusion Mode 两种向量 Index。Fusion Mode 支持在单个 Index 中定义多个向量字段、标量字段以及全文检索字段，需通过单独的 PutVectorIndexFusion 接口创建，目前仅支持通过 ossutil、SDK 和 API 创建，控制台暂不支持。Fusion Mode 目前处于邀测阶段。

Standard Mode

控制台

在向量Bucket页面，单击已创建的向量Bucket。
在索引列表页面，单击创建索引表。
配置索引参数：
- 索引表名称：1~63字符，由英文字母、数字组成，首字母必须为英文字母，在向量 Bucket 内全局唯一。
- 向量数据类型：系统默认float32：浮点型。
- 向量维度：1~4096维，添加到此索引中的所有向量必须具有完全相同的数值个数。
- 距离度量函数：根据业务场景选择距离计算方式。
  - 欧氏距离：空间中两点间的直线距离，适用于衡量数值差异。
  - 余弦距离：衡量两个向量在方向上的差异，适用于文本、图像等高维语义相似度计算。
- 元数据配置：配置非过滤元数据字段，用于存储不参与搜索过滤的附加信息，作为向量数据的描述信息。非过滤元数据配置。有如下输入限制：
  - 元数据个数为 1~100 个
  - 每个元数据主键名称的长度 1~63 字节
单击确定完成创建。

ossutil

为存储桶 examplebucket 创建 index 索引：向量维度 512，数据类型float32，距离度量 euclidean。

ossutil vectors-api put-vector-index --bucket examplebucket --index-name index --data-type float32 --dimension 512 --distance-metric euclidean

SDK

Python

import argparse
import alibabacloud_oss_v2 as oss
import alibabacloud_oss_v2.vectors as oss_vectors

parser = argparse.ArgumentParser(description="vector put vector index sample")
parser.add_argument('--region', help='The region in which the bucket is located.', required=True)
parser.add_argument('--bucket', help='The name of the bucket.', required=True)
parser.add_argument('--endpoint', help='The domain names that other services can use to access OSS')
parser.add_argument('--index_name', help='The name of the vector index.', required=True)
parser.add_argument('--account_id', help='The account id.', required=True)

def main():
    args = parser.parse_args()

    # Loading credentials values from the environment variables
    credentials_provider = oss.credentials.EnvironmentVariableCredentialsProvider()

    # Using the SDK's default configuration
    cfg = oss.config.load_default()
    cfg.credentials_provider = credentials_provider
    cfg.region = args.region
    cfg.account_id = args.account_id
    cfg.use_internal_endpoint = True  # 如需通过公网访问，请将此处设置为False或删除此行
    if args.endpoint is not None:
        cfg.endpoint = args.endpoint

    vector_client = oss_vectors.Client(cfg)

    result = vector_client.put_vector_index(oss_vectors.models.PutVectorIndexRequest(
        bucket=args.bucket,
        index_name=args.index_name,
        dimension=512,
        data_type='float32',
        distance_metric='euclidean',
        metadata={"nonFilterableMetadataKeys": ["key1", "key2"]}
    ))

    print(f'status code: {result.status_code},'
          f' request id: {result.request_id},'
    )

if __name__ == "__main__":
    main()

Go

package main

import (
	"context"
	"flag"
	"log"

	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/credentials"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/vectors"
)

var (
	region     string
	bucketName string
	accountId  string
	indexName  string
)

func init() {
	flag.StringVar(&region, "region", "", "The region in which the vector bucket is located.")
	flag.StringVar(&bucketName, "bucket", "", "The name of the vector bucket.")
	flag.StringVar(&accountId, "account-id", "", "The id of vector account.")
	flag.StringVar(&indexName, "index", "", "The name of vector index.")
}

func main() {
	flag.Parse()
	if len(bucketName) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, bucket name required")
	}

	if len(region) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, region required")
	}

	if len(accountId) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, accounId required")
	}

	if len(indexName) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, index required")
	}

	cfg := oss.LoadDefaultConfig().
		WithCredentialsProvider(credentials.NewEnvironmentVariableCredentialsProvider()).
		WithRegion(region).WithAccountId(accountId).
		// 如需通过公网访问，请将此处设置为false或删除此行
		WithUseInternalEndpoint(true)

	client := vectors.NewVectorsClient(cfg)

	request := &vectors.PutVectorIndexRequest{
		Bucket:         oss.Ptr(bucketName),
		DataType:       oss.Ptr("float32"),
		Dimension:      oss.Ptr(128),
		DistanceMetric: oss.Ptr("cosine"),
		IndexName:      oss.Ptr(indexName),
		Metadata: map[string]any{
			"nonFilterableMetadataKeys": []string{"foo", "bar"},
		},
	}
	result, err := client.PutVectorIndex(context.TODO(), request)
	if err != nil {
		log.Fatalf("failed to put vector index%v", err)
	}
	log.Printf("put vector index result:%#v\n", result)
}

Java

import com.aliyun.sdk.service.oss2.credentials.CredentialsProvider;
import com.aliyun.sdk.service.oss2.credentials.EnvironmentVariableCredentialsProvider;
import com.aliyun.sdk.service.oss2.vectors.OSSVectorsClient;
import com.aliyun.sdk.service.oss2.vectors.models.PutVectorIndexRequest;
import com.aliyun.sdk.service.oss2.vectors.models.PutVectorIndexResult;

public class PutVectorIndexSample {
    public static void main(String[] args) throws Exception {
        CredentialsProvider provider = new EnvironmentVariableCredentialsProvider();
        try (OSSVectorsClient client = OSSVectorsClient.newBuilder()
                .region("cn-hangzhou")
                .accountId("1234567890")
                .credentialsProvider(provider)
                .build()) {
            PutVectorIndexRequest request = PutVectorIndexRequest.newBuilder()
                    .bucket("examplebucket")
                    .indexName("exampleindex")
                    .dataType("float32")
                    .dimension(3)
                    .distanceMetric("cosine")
                    .build();
            PutVectorIndexResult result = client.putVectorIndex(request);
            System.out.printf("status code: %d, request id: %s%n", result.statusCode(), result.requestId());
        }
    }
}

API

调用PutVectorIndex接口以创建向量Index。

Fusion Mode

Fusion Mode 需通过单独的 PutVectorIndexFusion 接口创建，请求体中通过 schemaConfiguration 定义 Index 的字段结构。您可以通过 ossutil、SDK 或 API 创建。

ossutil

命令格式

ossutil vectors-api invoke-operation --op-name putVectorIndexFusion --method POST --parameters putVectorIndexFusion --bucket value --body value

参数说明

参数	类型	说明
--op-name	string	操作名称，固定为`put-vector-index-fusion`。
--method	string	HTTP请求方法，固定为`POST`。
--parameters	stringArray	查询参数，固定为`put-vector-index-fusion`。
--bucket	string	向量Bucket名称。
--body	string	请求体，JSON格式，用于描述Fusion模式向量索引的配置。body中各字段的含义请参见PutVectorIndexFusion接口文档。

说明

本命令通过ossutil的泛化命令invoke-operation调用PutVectorIndexFusion接口发起请求。
关于支持的全局命令行选项，请参见支持的全局命令行选项。

使用示例

在名为examplebucket的向量Bucket中创建名为my_index的Fusion模式向量索引。

ossutil vectors-api invoke-operation --op-name putVectorIndexFusion --method POST --parameters putVectorIndexFusion --bucket examplebucket --body '{"indexName":"my_index","mode":"fusion","schemaConfiguration":{"fields":[{"name":"text_vector","type":"vector","dataType":"float32","dimension":4,"distanceMetric":"cosine"},{"name":"image_vector","type":"vector","dataType":"float32","dimension":4,"distanceMetric":"cosine"},{"name":"title","type":"string","exactMatch":false,"text":{"enabled":true,"analyzer":"standard","analyzerParameters":{"caseSensitive":false,"delimitWord":false}}},{"name":"category","type":"string","isArray":true},{"name":"year","type":"long"}]}}'

SDK

Python

import argparse
import base64
import hashlib
import json

from requests.structures import CaseInsensitiveDict

import alibabacloud_oss_v2 as oss
import alibabacloud_oss_v2.vectors as oss_vectors
from alibabacloud_oss_v2 import OperationInput

parser = argparse.ArgumentParser(description="put vector index fusion sample")
parser.add_argument('--region', help='The region in which the bucket is located.', required=True)
parser.add_argument('--bucket', help='The name of the bucket.', required=True)
parser.add_argument('--endpoint', help='The domain names that other services can use to access OSS')
parser.add_argument('--index_name', help='The name of the fusion vector index.', required=True)
parser.add_argument('--account_id', help='The account id.', required=True)


def main():
    args = parser.parse_args()

    # Loading credentials values from the environment variables
    credentials_provider = oss.credentials.EnvironmentVariableCredentialsProvider()

    # Using the SDK's default configuration
    cfg = oss.config.load_default()
    cfg.credentials_provider = credentials_provider
    cfg.region = args.region
    cfg.account_id = args.account_id
    if args.endpoint is not None:
        cfg.endpoint = args.endpoint

    client = oss_vectors.Client(cfg)

    # Put vector index fusion
    json_data = json.dumps({
        'indexName': args.index_name,
        'mode': 'fusion',
        'schemaConfiguration': {
            'fields': [
                {
                    'name': 'text_vector',
                    'type': 'vector',
                    'dataType': 'float32',
                    'dimension': 4,
                    'distanceMetric': 'cosine',
                },
                {
                    'name': 'image_vector',
                    'type': 'vector',
                    'dataType': 'float32',
                    'dimension': 4,
                    'distanceMetric': 'cosine',
                },
                {
                    'name': 'title',
                    'type': 'string',
                    'exactMatch': False,
                    'text': {
                        'enabled': True,
                        'analyzer': 'standard',
                        'analyzerParameters': {
                            'caseSensitive': False,
                            'delimitWord': False,
                        },
                    },
                },
                {
                    'name': 'category',
                    'type': 'string',
                    'isArray': True,
                },
                {
                    'name': 'year',
                    'type': 'long',
                },
            ],
        },
    })
    body = json_data.encode()
    content_md5 = base64.b64encode(hashlib.md5(body).digest()).decode()
    op_input = OperationInput(
        op_name='PutVectorIndexFusion',
        method='POST',
        headers=CaseInsensitiveDict({
            'Content-Type': 'application/json',
            'Content-MD5': content_md5,
        }),
        parameters={
            'putVectorIndexFusion': '',
        },
        bucket=args.bucket,
        body=body,
    )
    op_output = client.invoke_operation(op_input)
    print(f'PutVectorIndexFusion status code: {op_output.status_code},'
          f' request id: {op_output.headers.get("x-oss-request-id", "")},')


if __name__ == "__main__":
    main()

Go

package main

import (
	"bytes"
	"context"
	"encoding/json"
	"flag"
	"log"

	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/credentials"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/vectors"
)

var (
	region     string
	bucketName string
	accountId  string
	indexName  string
)

func init() {
	flag.StringVar(&region, "region", "", "The region in which the vector bucket is located.")
	flag.StringVar(&bucketName, "bucket", "", "The name of the vector bucket.")
	flag.StringVar(&accountId, "account-id", "", "The id of vector account.")
	flag.StringVar(&indexName, "index", "", "The name of vector index.")
}

func main() {
	flag.Parse()
	if len(bucketName) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, bucket name required")
	}
	if len(region) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, region required")
	}
	if len(accountId) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, accountId required")
	}
	if len(indexName) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, index required")
	}

	cfg := oss.LoadDefaultConfig().
		WithCredentialsProvider(credentials.NewEnvironmentVariableCredentialsProvider()).
		WithRegion(region).WithAccountId(accountId)

	client := vectors.NewVectorsClient(cfg)

	// 手动构造 PutVectorIndexFusion 的 JSON 请求体
	bodyMap := map[string]any{
		"indexName": indexName,
		"mode":      "fusion",
		"schemaConfiguration": map[string]any{
			"fields": []map[string]any{
				{
					"name":           "text_vector",
					"type":           "vector",
					"dataType":       "float32",
					"dimension":      4,
					"distanceMetric": "cosine",
				},
				{
					"name":           "image_vector",
					"type":           "vector",
					"dataType":       "float32",
					"dimension":      4,
					"distanceMetric": "cosine",
				},
				{
					"name":       "title",
					"type":       "string",
					"exactMatch": false,
					"text": map[string]any{
						"enabled":  true,
						"analyzer": "standard",
						"analyzerParameters": map[string]any{
							"caseSensitive": false,
							"delimitWord":   false,
						},
					},
				},
				{
					"name":    "category",
					"type":    "string",
					"isArray": true,
				},
				{
					"name": "year",
					"type": "long",
				},
			}
				{
					"name":           "vector_2",
					"type":           "vector",
					"dataType":       "float32",
					"dimension":      512,
					"distanceMetric": "cosine",
				},
				{
					"name":    "timestamps",
					"type":    "long",
					"isArray": true,
				},
				{
					"name": "price",
					"type": "double",
				},
				{
					"name": "ip",
					"type": "ip",
				},
				{
					"name": "location",
					"type": "geoPoint",
				},
				{
					"name": "tag",
					"type": "string",
				},
				{
					"name":           "user_id",
					"type":           "string",
					"isPartitionKey": true,
				},
				{
					"name":    "tags",
					"type":    "string",
					"isArray": true,
				},
				{
					"name":       "title_1",
					"type":       "string",
					"exactMatch": true,
					"text": map[string]any{
						"enabled":  true,
						"analyzer": "standard",
						"analyzerParameters": map[string]any{
							"caseSensitive": true,
							"delimitWord":   false,
						},
					},
				},
				{
					"name":       "title_2",
					"type":       "string",
					"exactMatch": false,
					"text": map[string]any{
						"enabled":  true,
						"analyzer": "split",
						"analyzerParameters": map[string]any{
							"caseSensitive": true,
							"delimiter":     " ",
						},
					},
				},
			},
		},
	}

	bodyBytes, err := json.Marshal(bodyMap)
	if err != nil {
		log.Fatalf("failed to marshal body: %v", err)
	}

	// 手动构造 OperationInput
	input := &oss.OperationInput{
		OpName: "PutVectorIndexFusion",
		Method: "POST",
		Headers: map[string]string{
			"Content-Type": "application/json",
		},
		Parameters: map[string]string{
			"putVectorIndexFusion": "",
		},
		Bucket: oss.Ptr(bucketName),
		Body:   bytes.NewReader(bodyBytes),
	}

	// 直接调用 InvokeOperation
	output, err := client.InvokeOperation(context.TODO(), input)
	if err != nil {
		log.Fatalf("failed to put vector index fusion: %v", err)
	}
	if output.Body != nil {
		output.Body.Close()
	}
	log.Printf("put vector index fusion success, status code: %d\n", output.StatusCode)
}

Java

import com.aliyun.sdk.service.oss2.OperationInput;
import com.aliyun.sdk.service.oss2.OperationOptions;
import com.aliyun.sdk.service.oss2.OperationOutput;
import com.aliyun.sdk.service.oss2.credentials.CredentialsProvider;
import com.aliyun.sdk.service.oss2.credentials.EnvironmentVariableCredentialsProvider;
import com.aliyun.sdk.service.oss2.transport.BinaryData;
import com.aliyun.sdk.service.oss2.utils.Base64Utils;
import com.aliyun.sdk.service.oss2.vectors.OSSVectorsClient;

import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.HashMap;
import java.util.Map;

public class PutVectorIndexFusionSample {
    public static void main(String[] args) throws Exception {
        CredentialsProvider provider = new EnvironmentVariableCredentialsProvider();
        try (OSSVectorsClient client = OSSVectorsClient.newBuilder()
                .region("cn-hangzhou")
                .accountId("1234567890")
                .credentialsProvider(provider)
                .build()) {

            String bucket = "examplebucket";
            String indexName = "exampleindex";

            // 构造 PutVectorIndexFusion 的 JSON 请求体
                        String putIndexJson = "{
" +
                    "  \"indexName\": \"" + indexName + "\",
" +
                    "  \"mode\": \"fusion\",
" +
                    "  \"schemaConfiguration\": {
" +
                    "    \"fields\": [
" +
                    "      {
" +
                    "        \"name\": \"text_vector\",
" +
                    "        \"type\": \"vector\",
" +
                    "        \"dataType\": \"float32\",
" +
                    "        \"dimension\": 4,
" +
                    "        \"distanceMetric\": \"cosine\"
" +
                    "      },
" +
                    "      {
" +
                    "        \"name\": \"image_vector\",
" +
                    "        \"type\": \"vector\",
" +
                    "        \"dataType\": \"float32\",
" +
                    "        \"dimension\": 4,
" +
                    "        \"distanceMetric\": \"cosine\"
" +
                    "      },
" +
                    "      {
" +
                    "        \"name\": \"title\",
" +
                    "        \"type\": \"string\",
" +
                    "        \"exactMatch\": false,
" +
                    "        \"text\": {
" +
                    "          \"enabled\": true,
" +
                    "          \"analyzer\": \"standard\",
" +
                    "          \"analyzerParameters\": {
" +
                    "            \"caseSensitive\": false,
" +
                    "            \"delimitWord\": false
" +
                    "          }
" +
                    "        }
" +
                    "      },
" +
                    "      {
" +
                    "        \"name\": \"category\",
" +
                    "        \"type\": \"string\",
" +
                    "        \"isArray\": true
" +
                    "      },
" +
                    "      {
" +
                    "        \"name\": \"year\",
" +
                    "        \"type\": \"long\"
" +
                    "      }
" +
                    "    ]
" +
                    "  }
" +
                    "}";

            Map<String, String> putIndexHeaders = new HashMap<>();
            putIndexHeaders.put("Content-Type", "application/json");
            putIndexHeaders.put("Content-MD5", calculateContentMD5(putIndexJson));

            Map<String, String> putIndexParameters = new HashMap<>();
            putIndexParameters.put("putVectorIndexFusion", "");

            OperationInput putIndexInput = OperationInput.newBuilder()
                    .opName("PutVectorIndexFusion")
                    .method("POST")
                    .bucket(bucket)
                    .headers(putIndexHeaders)
                    .parameters(putIndexParameters)
                    .body(BinaryData.fromString(putIndexJson))
                    .build();

            OperationOutput putIndexOutput = client.invokeOperation(putIndexInput, OperationOptions.defaults());

            System.out.println("PutVectorIndexFusion status code: " + putIndexOutput.statusCode() +
                    ", request id: " + putIndexOutput.headers().get("x-oss-request-id"));
        }
    }

    private static String calculateContentMD5(String content) {
        try {
            MessageDigest md = MessageDigest.getInstance("MD5");
            byte[] digest = md.digest(content.getBytes(StandardCharsets.UTF_8));
            return Base64Utils.encodeToString(digest);
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException("Failed to calculate MD5", e);
        }
    }
}

API

调用PutVectorIndexFusion接口以创建 Fusion Mode 向量 Index。

获取向量 Index 信息

Standard Mode

控制台

在向量Bucket页面，单击已创建的向量Bucket，在索引列表页面，可以查看向量 Index 信息。

ossutil

获取向量存储空间examplebucket中向量名字为index的向量索引属性。

ossutil vectors-api get-vector-index --bucket examplebucket --index-name index

SDK

Python

import argparse
import alibabacloud_oss_v2 as oss
import alibabacloud_oss_v2.vectors as oss_vectors

parser = argparse.ArgumentParser(description="vector get vector index sample")
parser.add_argument('--region', help='The region in which the bucket is located.', required=True)
parser.add_argument('--bucket', help='The name of the bucket.', required=True)
parser.add_argument('--endpoint', help='The domain names that other services can use to access OSS')
parser.add_argument('--index_name', help='The name of the vector index.', required=True)
parser.add_argument('--account_id', help='The account id.', required=True)

def main():
    args = parser.parse_args()

    # Loading credentials values from the environment variables
    credentials_provider = oss.credentials.EnvironmentVariableCredentialsProvider()

    # Using the SDK's default configuration
    cfg = oss.config.load_default()
    cfg.credentials_provider = credentials_provider
    cfg.region = args.region
    cfg.account_id = args.account_id
    cfg.use_internal_endpoint = True  # 如需通过公网访问，请将此处设置为False或删除此行
    if args.endpoint is not None:
        cfg.endpoint = args.endpoint

    vector_client = oss_vectors.Client(cfg)

    result = vector_client.get_vector_index(oss_vectors.models.GetVectorIndexRequest(
        bucket=args.bucket,
        index_name=args.index_name,
    ))

    print(f'status code: {result.status_code},'
          f' request id: {result.request_id},'
          )

    if result.index:
        print(f'index name: {result.index}')

if __name__ == "__main__":
    main()

Go

package main

import (
	"context"
	"flag"
	"log"

	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/credentials"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/vectors"
)

var (
	region     string
	bucketName string
	indexName  string
	accountId  string
)

func init() {
	flag.StringVar(&region, "region", "", "The region in which the vector bucket is located.")
	flag.StringVar(&bucketName, "bucket", "", "The name of the vector bucket.")
	flag.StringVar(&indexName, "index", "", "The name of the vector index.")
	flag.StringVar(&accountId, "account-id", "", "The id of vector account.")
}

func main() {
	flag.Parse()
	if len(bucketName) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, bucket name required")
	}

	if len(region) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, region required")
	}

	if len(indexName) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, index required")
	}

	if len(accountId) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, accounId required")
	}

	cfg := oss.LoadDefaultConfig().
		WithCredentialsProvider(credentials.NewEnvironmentVariableCredentialsProvider()).
		WithRegion(region).WithAccountId(accountId).
		// 如需通过公网访问，请将此处设置为false或删除此行
		WithUseInternalEndpoint(true)

	client := vectors.NewVectorsClient(cfg)

	request := &vectors.GetVectorIndexRequest{
		Bucket:    oss.Ptr(bucketName),
		IndexName: oss.Ptr(indexName),
	}
	result, err := client.GetVectorIndex(context.TODO(), request)
	if err != nil {
		log.Fatalf("failed to get vector index %v", err)
	}
	log.Printf("get vector index result:%#v\n", result)
}

Java

import com.aliyun.sdk.service.oss2.credentials.CredentialsProvider;
import com.aliyun.sdk.service.oss2.credentials.EnvironmentVariableCredentialsProvider;
import com.aliyun.sdk.service.oss2.vectors.OSSVectorsClient;
import com.aliyun.sdk.service.oss2.vectors.models.GetVectorIndexRequest;
import com.aliyun.sdk.service.oss2.vectors.models.GetVectorIndexResult;

public class GetVectorIndexSample {
    public static void main(String[] args) throws Exception {
        CredentialsProvider provider = new EnvironmentVariableCredentialsProvider();
        try (OSSVectorsClient client = OSSVectorsClient.newBuilder()
                .region("cn-hangzhou")
                .accountId("1234567890")
                .credentialsProvider(provider)
                .build()) {
            GetVectorIndexRequest request = GetVectorIndexRequest.newBuilder()
                    .bucket("examplebucket")
                    .indexName("exampleindex")
                    .build();
            GetVectorIndexResult result = client.getVectorIndex(request);
            System.out.printf("status code: %d, request id: %s%n", result.statusCode(), result.requestId());
        }
    }
}

API

调用GetVectorIndex接口以获取向量Index信息。

Fusion Mode

Fusion Mode 向量 Index 通过相同的 GetVectorIndex 接口获取，响应结果中会包含 mode 参数（取值为 standard 或 fusion），用于标识 Index 的类型。Fusion Mode 通过 schemaConfiguration 返回其字段结构，而非 Standard Mode 返回的向量数据类型、向量维度、距离度量函数及非过滤元数据字段。详细参数请参见 GetVectorIndex 接口文档。

列举向量 Index 信息

列举向量索引的 API （ListVectorIndexes）每次最大返回索引个数 500，可分页获取下一批索引列表，并发度上限 16 个。

Standard Mode

控制台

在向量Bucket页面，单击已创建的向量Bucket，进入索引列表页面，即列举出当前向量Bucket下所有索引。

ossutil

列举名为examplebucket的向量Bucket中所有向量索引。

ossutil vectors-api list-vector-indexes --bucket examplebucket

SDK

Python

import argparse
import alibabacloud_oss_v2 as oss
import alibabacloud_oss_v2.vectors as oss_vectors

parser = argparse.ArgumentParser(description="list vector indexes sample")

parser.add_argument('--region', help='The region in which the bucket is located.', required=True)
parser.add_argument('--endpoint', help='The domain names that other services can use to access OSS')
parser.add_argument('--account_id', help='The account id.', required=True)
parser.add_argument('--bucket', help='The name of the bucket.', required=True)

def main():

    args = parser.parse_args()

    # Loading credentials values from the environment variables
    credentials_provider = oss.credentials.EnvironmentVariableCredentialsProvider()

    # Using the SDK's default configuration
    cfg = oss.config.load_default()
    cfg.credentials_provider = credentials_provider
    cfg.region = args.region
    cfg.account_id = args.account_id
    cfg.use_internal_endpoint = True  # 如需通过公网访问，请将此处设置为False或删除此行
    if args.endpoint is not None:
        cfg.endpoint = args.endpoint

    client = oss_vectors.Client(cfg)

    # Create the Paginator for the ListVectorIndex operation
    paginator = client.list_vector_indexes_paginator()

    # Iterate through the vector index pages
    for page in paginator.iter_page(oss_vectors.models.ListVectorIndexesRequest(
        bucket=args.bucket
        )
    ):
        for o in page.indexes:
            print(f'Index: {o.get("indexName")}, {o.get("dataType")}, {o.get("dimension")}, {o.get("status")}')

if __name__ == "__main__":
    main()

Go

package main

import (
	"context"
	"flag"
	"log"

	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/credentials"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/vectors"
)

var (
	region     string
	bucketName string
	accountId  string
)

func init() {
	flag.StringVar(&region, "region", "", "The region in which the vector bucket is located.")
	flag.StringVar(&bucketName, "bucket", "", "The name of the vector bucket.")
	flag.StringVar(&accountId, "account-id", "", "The id of vector account.")
}

func main() {
	flag.Parse()
	if len(region) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, region required")
	}

	if len(bucketName) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, bucket required")
	}

	if len(accountId) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, accounId required")
	}

	cfg := oss.LoadDefaultConfig().
		WithCredentialsProvider(credentials.NewEnvironmentVariableCredentialsProvider()).
		WithRegion(region).WithAccountId(accountId).
		// 如需通过公网访问，请将此处设置为false或删除此行
		WithUseInternalEndpoint(true)

	client := vectors.NewVectorsClient(cfg)

	request := &vectors.ListVectorIndexesRequest{
		Bucket: oss.Ptr(bucketName),
	}
	p := client.NewListVectorIndexesPaginator(request)

	var i int
	log.Println("Vector Indexes:")
	for p.HasNext() {
		i++

		page, err := p.NextPage(context.TODO())
		if err != nil {
			log.Fatalf("failed to get page %v, %v", i, err)
		}

		// Log the objects found
		for _, index := range page.Indexes {
			log.Printf("index:%v, %v, %v, %v\n", oss.ToString(index.IndexName), oss.ToTime(index.CreateTime), oss.ToString(index.DataType), oss.ToString(index.Status))
		}
	}
}

Java

import com.aliyun.sdk.service.oss2.credentials.CredentialsProvider;
import com.aliyun.sdk.service.oss2.credentials.EnvironmentVariableCredentialsProvider;
import com.aliyun.sdk.service.oss2.vectors.OSSVectorsClient;
import com.aliyun.sdk.service.oss2.vectors.models.ListVectorIndexesRequest;
import com.aliyun.sdk.service.oss2.vectors.models.ListVectorIndexesResult;

public class ListVectorIndexesSample {
    public static void main(String[] args) throws Exception {
        CredentialsProvider provider = new EnvironmentVariableCredentialsProvider();
        try (OSSVectorsClient client = OSSVectorsClient.newBuilder()
                .region("cn-hangzhou")
                .accountId("1234567890")
                .credentialsProvider(provider)
                .build()) {
            ListVectorIndexesRequest request = ListVectorIndexesRequest.newBuilder()
                    .bucket("examplebucket")
                    .build();
            ListVectorIndexesResult result = client.listVectorIndexes(request);
            System.out.printf("status code: %d, request id: %s%n", result.statusCode(), result.requestId());
        }
    }
}

API

调用ListVectorIndexes接口以列举向量Bucket中的所有向量索引。

Fusion Mode

列举向量 Index 时，响应结果中每个 Index 会返回 mode 参数（取值为 standard 或 fusion）以标识其类型，同一向量Bucket下的 Standard Mode 与 Fusion Mode 向量 Index 可能同时出现在列举结果中。对于 Fusion Mode 向量 Index，列举接口仅返回基础信息（如 Index 名称、mode、状态、创建时间等），详细参数请参见 ListVectorIndexes 接口文档。如需获取 Fusion Mode 向量 Index 完整的 schemaConfiguration 字段结构，请调用 GetVectorIndex 接口获取。

删除向量 Index

删除索引会同时删除索引中的所有向量数据。删除操作不可逆，请谨慎操作，确保已备份重要数据。

控制台

在向量Bucket页面，单击已创建的向量Bucket，进入索引列表页面，选择需要删除的索引完成删除操作。

ossutil

删除向量存储空间examplebucket中名为index的向量索引。

ossutil vectors-api delete-vector-index --bucket examplebucket --index-name index

SDK

Python

import argparse
import alibabacloud_oss_v2 as oss
import alibabacloud_oss_v2.vectors as oss_vectors

parser = argparse.ArgumentParser(description="vector delete vector index sample")
parser.add_argument('--region', help='The region in which the bucket is located.', required=True)
parser.add_argument('--bucket', help='The name of the bucket.', required=True)
parser.add_argument('--endpoint', help='The domain names that other services can use to access OSS')
parser.add_argument('--index_name', help='The name of the vector index.', required=True)
parser.add_argument('--account_id', help='The account id.', required=True)

def main():
    args = parser.parse_args()

    # Loading credentials values from the environment variables
    credentials_provider = oss.credentials.EnvironmentVariableCredentialsProvider()

    # Using the SDK's default configuration
    cfg = oss.config.load_default()
    cfg.credentials_provider = credentials_provider
    cfg.region = args.region
    cfg.account_id = args.account_id
    cfg.use_internal_endpoint = True  # 如需通过公网访问，请将此处设置为False或删除此行
    if args.endpoint is not None:
        cfg.endpoint = args.endpoint

    vector_client = oss_vectors.Client(cfg)

    result = vector_client.delete_vector_index(oss_vectors.models.DeleteVectorIndexRequest(
        bucket=args.bucket,
        index_name=args.index_name,
    ))

    print(f'status code: {result.status_code},'
          f' request id: {result.request_id},'
    )

if __name__ == "__main__":
    main()

Go

package main

import (
	"context"
	"flag"
	"log"

	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/credentials"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/vectors"
)

var (
	region     string
	bucketName string
	indexName  string
	accountId  string
)

func init() {
	flag.StringVar(&region, "region", "", "The region in which the vector bucket is located.")
	flag.StringVar(&bucketName, "bucket", "", "The name of the vector bucket.")
	flag.StringVar(&indexName, "index", "", "The name of the vector index.")
	flag.StringVar(&accountId, "account-id", "", "The id of vector account.")
}

func main() {
	flag.Parse()
	if len(bucketName) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, bucket name required")
	}

	if len(region) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, region required")
	}

	if len(indexName) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, index required")
	}

	if len(accountId) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, accountId required")
	}

	cfg := oss.LoadDefaultConfig().
		WithCredentialsProvider(credentials.NewEnvironmentVariableCredentialsProvider()).
		WithRegion(region).WithAccountId(accountId).
		// 如需通过公网访问，请将此处设置为false或删除此行
		WithUseInternalEndpoint(true)

	client := vectors.NewVectorsClient(cfg)

	request := &vectors.DeleteVectorIndexRequest{
		Bucket:    oss.Ptr(bucketName),
		IndexName: oss.Ptr(indexName),
	}
	result, err := client.DeleteVectorIndex(context.TODO(), request)
	if err != nil {
		log.Fatalf("failed to delete vector index %v", err)
	}

	log.Printf("delete vector index result:%#v\n", result)
}

Java

import com.aliyun.sdk.service.oss2.credentials.CredentialsProvider;
import com.aliyun.sdk.service.oss2.credentials.EnvironmentVariableCredentialsProvider;
import com.aliyun.sdk.service.oss2.vectors.OSSVectorsClient;
import com.aliyun.sdk.service.oss2.vectors.models.DeleteVectorIndexRequest;
import com.aliyun.sdk.service.oss2.vectors.models.DeleteVectorIndexResult;

public class DeleteVectorIndexSample {
    public static void main(String[] args) throws Exception {
        CredentialsProvider provider = new EnvironmentVariableCredentialsProvider();
        try (OSSVectorsClient client = OSSVectorsClient.newBuilder()
                .region("cn-hangzhou")
                .accountId("1234567890")
                .credentialsProvider(provider)
                .build()) {
            DeleteVectorIndexRequest request = DeleteVectorIndexRequest.newBuilder()
                    .bucket("examplebucket")
                    .indexName("exampleindex")
                    .build();
            DeleteVectorIndexResult result = client.deleteVectorIndex(request);
            System.out.printf("status code: %d, request id: %s%n", result.statusCode(), result.requestId());
        }
    }
}

API

调用DeleteVectorIndex接口以删除向量索引。