AI 助理
文档备案控制台
官方文档
首页 对象存储 用户指南 OSS Vectors 向量Index

向量Index

更新时间：
复制 MD 格式
产品详情
我的收藏

向量索引 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

控制台

  1. 在向量Bucket页面，单击已创建的向量Bucket。

  2. 在索引列表页面，单击创建索引表。

  3. 配置索引参数：

    • 索引表名称：1~63字符，由英文字母、数字组成，首字母必须为英文字母，在向量 Bucket 内全局唯一。

    • 向量数据类型：系统默认float32：浮点型。

    • 向量维度：1~4096维，添加到此索引中的所有向量必须具有完全相同的数值个数。

    • 距离度量函数：根据业务场景选择距离计算方式。

      • 欧氏距离：空间中两点间的直线距离，适用于衡量数值差异。

      • 余弦距离：衡量两个向量在方向上的差异，适用于文本、图像等高维语义相似度计算。

    • 元数据配置：配置非过滤元数据字段，用于存储不参与搜索过滤的附加信息，作为向量数据的描述信息。非过滤元数据配置。有如下输入限制：

      • 元数据个数为 1~100 个

      • 每个元数据主键名称的长度 1~63 字节

  4. 单击确定完成创建。

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 put-vector-index-fusion --bucket value --index-name value --vector-mode value --schema-configuration value --account-id value

参数说明

参数

类型

说明

--account-id

string

阿里云账号ID。该选项为必填项，未指定时命令会返回AccountId is null错误。

--bucket

string

向量Bucket名称。

--index-name

string

向量索引名称。

--vector-mode

string

向量索引模式，创建Fusion模式索引时固定为fusion。

--schema-configuration

string

向量索引的Schema配置，JSON格式。当选项值包含file://前缀时，表示从文件中读取配置。各字段的含义请参见PutVectorIndexFusion接口文档。

--schema-configuration

--schema-configuration配置选项支持JSON语法，当选项值包含file://前缀时，表示从文件中读取配置。JSON语法如下：

{
    "fields": [
      {
        "name": "string",
        "type": "vector",
        "dataType": "float32",
        "dimension": int,
        "distanceMetric": "euclidean"
      },
      {
        "name": "string",
        "type": "long",
        "isArray": bool
      },
      {
        "name": "string",
        "type": "double",
        "isArray": bool
      },
      {
        "name": "string",
        "type": "ip"
      },
      {
        "name": "string",
        "type": "geoPoint"
      },
      {
        "name": "string",
        "type": "string",
        "isPartitionKey": bool
      },
      {
        "name": "string",
        "type": "string",
        "exactMatch": bool,
        "text": {
          "enabled": bool,
          "analyzer": "standard",
          "analyzerParameters": {
            "caseSensitive": bool,
            "delimitWord": bool
          }
        }
      },
      {
        "name": "string",
        "type": "string",
        "exactMatch": bool,
        "text": {
          "enabled": bool,
          "analyzer": "split",
          "analyzerParameters": {
            "caseSensitive": bool,
            "delimiter": "string"
          }
        }
      }
    ]
}
说明

  • 本命令需要ossutil 2.4.1及以上版本。更低版本请通过泛化命令invoke-operation调用PutVectorIndexFusion接口。

  • 关于支持的全局命令行选项，请参见支持的全局命令行选项。

使用示例

在名为examplebucket的向量Bucket中创建名为my_index的Fusion模式向量索引，该索引包含两个向量字段（text_vector、image_vector）、一个支持全文检索的字段（title）、一个数组类型标量字段（category）和一个数值字段（year）。

方式一：从JSON文件读取Schema配置。示例配置文件schema-configuration.json的内容如下：

{
  "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"
    }
  ]
}
ossutil vectors-api put-vector-index-fusion --bucket examplebucket --index-name my_index --vector-mode fusion --schema-configuration file://schema-configuration.json --account-id 123456789012****

方式二：在命令行中直接传入JSON字符串。

ossutil vectors-api put-vector-index-fusion --bucket examplebucket --index-name my_index --vector-mode fusion --schema-configuration '{"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"}]}' --account-id 123456789012****

SDK

Python

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

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()

    # 从环境变量中加载访问凭证
    credentials_provider = oss.credentials.EnvironmentVariableCredentialsProvider()

    # 使用 SDK 默认配置
    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

    vector_client = oss_vectors.Client(cfg)

    # Fusion 索引通过 Schema 描述所有字段，区别于 put_vector_index 仅配置单个向量字段。
    # 以下为典型的电商商品 Schema：两个向量字段用于文本和图片双路召回，
    # 标量字段用于过滤和排序，分词后的标题字段用于全文检索。
    #
    # Schema 使用 dict 描述，服务端支持的任何字段类型和属性均可透传。
    # 文本字段默认使用 "standard" 分词器（英文按词、中文按字分词）。
    # 需要明确表示 false 时务必写出，省略和设为 false 对于服务端含义不同。
    # mode 默认为 "fusion"，此处省略。
    schema_configuration = {
        "fields": [
            {
                "name": "text_vector",
                "type": "vector",
                "dataType": "float32",
                "dimension": 768,
                "distanceMetric": "euclidean"
            },
            {
                "name": "image_vector",
                "type": "vector",
                "dataType": "float32",
                "dimension": 512,
                "distanceMetric": "euclidean"
            },
            {
                "name": "title",
                "type": "string",
                "exactMatch": True,
                "text": {
                    "enabled": True,
                    "analyzer": "standard"
                }
            },
            {
                "name": "brand",
                "type": "string"
            },
            {
                "name": "category",
                "type": "string",
                "isArray": True
            },
            {
                "name": "price",
                "type": "double"
            },
            {
                "name": "stock",
                "type": "long"
            },
            {
                "name": "on_sale",
                "type": "bool"
            }
        ]
    }

    result = vector_client.put_vector_index_fusion(oss_vectors.models.PutVectorIndexFusionRequest(
        bucket=args.bucket,
        index_name=args.index_name,
        schema_configuration=schema_configuration
    ))

    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, 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)

	// 使用 FieldSchema 结构体构建 Schema 字段列表
	request := &vectors.PutVectorIndexFusionRequest{
		Bucket:    oss.Ptr(bucketName),
		IndexName: oss.Ptr(indexName),
		Mode:      oss.Ptr("fusion"),
		SchemaConfiguration: &vectors.SchemaConfiguration{
			Fields: []map[string]any{
				vectors.FieldSchema{
					Name:           oss.Ptr("vector_1"),
					Type:           oss.Ptr("vector"),
					DataType:       oss.Ptr("float32"),
					Dimension:      oss.Ptr(1024),
					DistanceMetric: oss.Ptr("cosine"),
				}.ToMap(),
				vectors.FieldSchema{
					Name:           oss.Ptr("vector_2"),
					Type:           oss.Ptr("vector"),
					DataType:       oss.Ptr("float32"),
					Dimension:      oss.Ptr(512),
					DistanceMetric: oss.Ptr("cosine"),
				}.ToMap(),
				vectors.FieldSchema{
					Name:    oss.Ptr("timestamps"),
					Type:    oss.Ptr("long"),
					IsArray: oss.Ptr(true),
				}.ToMap(),
				vectors.FieldSchema{
					Name: oss.Ptr("price"),
					Type: oss.Ptr("double"),
				}.ToMap(),
				vectors.FieldSchema{
					Name: oss.Ptr("ip"),
					Type: oss.Ptr("ip"),
				}.ToMap(),
				vectors.FieldSchema{
					Name: oss.Ptr("location"),
					Type: oss.Ptr("geoPoint"),
				}.ToMap(),
				vectors.FieldSchema{
					Name: oss.Ptr("tag"),
					Type: oss.Ptr("string"),
				}.ToMap(),
				vectors.FieldSchema{
					Name:           oss.Ptr("user_id"),
					Type:           oss.Ptr("string"),
					IsPartitionKey: oss.Ptr(true),
				}.ToMap(),
				vectors.FieldSchema{
					Name:    oss.Ptr("tags"),
					Type:    oss.Ptr("string"),
					IsArray: oss.Ptr(true),
				}.ToMap(),
				vectors.FieldSchema{
					Name:       oss.Ptr("title_1"),
					Type:       oss.Ptr("string"),
					ExactMatch: oss.Ptr(true),
					Text: &vectors.TextSchema{
						Enabled:  oss.Ptr(true),
						Analyzer: oss.Ptr("standard"),
						AnalyzerParameters: &vectors.AnalyzerParameters{
							CaseSensitive: oss.Ptr(true),
							DelimitWord:   oss.Ptr(false),
						},
					},
				}.ToMap(),
				vectors.FieldSchema{
					Name:       oss.Ptr("title_2"),
					Type:       oss.Ptr("string"),
					ExactMatch: oss.Ptr(false),
					Text: &vectors.TextSchema{
						Enabled:  oss.Ptr(true),
						Analyzer: oss.Ptr("split"),
						AnalyzerParameters: &vectors.AnalyzerParameters{
							CaseSensitive: oss.Ptr(true),
							Delimiter:     oss.Ptr(" "),
						},
					},
				}.ToMap(),
			},
		},
	}

	result, err := client.PutVectorIndexFusion(context.TODO(), request)
	if err != nil {
		log.Fatalf("failed to put vector index fusion: %v", err)
	}
	log.Printf("put vector index fusion 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.AnalyzerParameters;
import com.aliyun.sdk.service.oss2.vectors.models.AnalyzerType;
import com.aliyun.sdk.service.oss2.vectors.models.DistanceMetricType;
import com.aliyun.sdk.service.oss2.vectors.models.FieldSchema;
import com.aliyun.sdk.service.oss2.vectors.models.FieldType;
import com.aliyun.sdk.service.oss2.vectors.models.IndexModeType;
import com.aliyun.sdk.service.oss2.vectors.models.PutVectorIndexFusionRequest;
import com.aliyun.sdk.service.oss2.vectors.models.PutVectorIndexFusionResult;
import com.aliyun.sdk.service.oss2.vectors.models.SchemaConfiguration;
import com.aliyun.sdk.service.oss2.vectors.models.TextSchema;
import com.aliyun.sdk.service.oss2.vectors.models.VectorDataType;

import java.util.Arrays;
import java.util.List;

public class PutVectorIndexFusionSample {
    public static void main(String[] args) {
        CredentialsProvider provider = new EnvironmentVariableCredentialsProvider();

        try (OSSVectorsClient client = OSSVectorsClient.newBuilder()
                .region("cn-hangzhou")
                .accountId("1234567890")
                .credentialsProvider(provider)
                .build()) {

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

            // 定义向量字段
            FieldSchema vectorField = FieldSchema.newBuilder()
                    .name("vector_1")
                    .type(FieldType.VECTOR)
                    .dataType(VectorDataType.FLOAT32)
                    .dimension(1024)
                    .distanceMetric(DistanceMetricType.COSINE)
                    .build();

            // 定义分区键字段（仅支持一个 String 类型字段作为分区键）
            FieldSchema partitionKey = FieldSchema.newBuilder()
                    .name("user_id")
                    .type(FieldType.STRING)
                    .isPartitionKey(true)
                    .build();

            // 定义启用全文检索的字符串字段
            FieldSchema title = FieldSchema.newBuilder()
                    .name("title")
                    .type(FieldType.STRING)
                    .exactMatch(true)
                    .text(TextSchema.newBuilder()
                            .enabled(true)
                            .analyzer(AnalyzerType.STANDARD)
                            .analyzerParameters(AnalyzerParameters.newBuilder()
                                    .caseSensitive(false)
                                    .delimitWord(false)
                                    .build())
                            .build())
                    .build();

            // 定义数组字段
            FieldSchema timestamps = FieldSchema.newBuilder()
                    .name("timestamps")
                    .type(FieldType.LONG)
                    .isArray(true)
                    .build();

            List<FieldSchema> fields = Arrays.asList(vectorField, partitionKey, title, timestamps);

            PutVectorIndexFusionRequest request = PutVectorIndexFusionRequest.newBuilder()
                    .bucket(bucket)
                    .indexName(indexName)
                    .mode(IndexModeType.FUSION)
                    .schemaConfiguration(SchemaConfiguration.newBuilder().fields(fields).build())
                    .build();

            PutVectorIndexFusionResult result = client.putVectorIndexFusion(request);

            System.out.printf("Status code:%d, request id:%s%n",
                    result.statusCode(), result.requestId());
        }
    }
}

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接口以删除向量索引。

上一篇：向量Bucket下一篇：向量Vectors