Docs 菜单
Docs 主页
/
MongoDB Atlas
/

如何为向量搜索建立索引字段

在此页面上

  • Considerations
  • 支持的客户端
  • 语法
  • Atlas Vector Search 索引字段
  • 关于 vector类型
  • 关于 filter 类型
  • 创建 Atlas Vector Search 索引
  • 先决条件
  • 必需的访问权限
  • 索引限制
  • 步骤
  • 查看 Atlas Vector Search 索引
  • 必需的访问权限
  • 步骤
  • 编辑 Atlas Vector Search 索引
  • 必需的访问权限
  • 步骤
  • 删除 Atlas Vector Search 索引
  • 必需的访问权限
  • 步骤
  • 索引状态

您可以使用 vectorSearch 类型对字段进行索引以运行 $vectorSearch 查询。您可以为要查询的向量嵌入以及要用于预过滤数据的布尔值、日期、objectId、数值、字符串或 UUID 值定义索引。过滤数据有助于缩小语义搜索范围,并确保在比较时(例如在多租户环境中)不考虑某些向量嵌入。

您可以使用 Atlas UI、Administration API、Atlas CLI、 mongosh 或支持的 MongoDB 驱动程序创建 Atlas Vector Search 索引。

注意

您不能使用已弃用的 knnBeta 操作符来查询使用 vectorSearch 类型索引定义索引的字段。

vectorSearch类型索引定义中,您可以仅使用单个元素对数组进行索引。 您无法对文档数组内的字段或对象数组内的字段进行索引。 您可以使用点表示法对文档内的字段进行索引。

在为嵌入编制索引之前,我们建议将嵌入转换为 BSON BinData vector 子类型 float32int8 向量,以便在 Atlas 集群中高效存储和摄取向量。要了解更多信息,请参阅如何将嵌入转换为 BSON 向量。

您可以通过Atlas 用户界面、mongosh 、 Atlas CLI、 Atlas Administration API和以下MongoDB驱动程序创建和管理Atlas Vector Search索引:

MongoDB 驱动
版本

1.28.0 或更高

3.11.0 或更高

1.16.0 或更高

5.2.0 或更高

5.2.0 或更高

6.6.0 或更高

1.20.0 或更高

4.7 或更高

3.1.0 或更高

5.2.0 或更高

以下语法定义了 vectorSearch 索引类型:

1{
2 "fields":[
3 {
4 "type": "vector",
5 "path": "<field-to-index>",
6 "numDimensions": <number-of-dimensions>,
7 "similarity": "euclidean | cosine | dotProduct"
8 },
9 {
10 "type": "filter",
11 "path": "<field-to-index>"
12 },
13 ...
14 ]
15}

Atlas Vector Search 索引定义采用以下字段:

选项
类型
必要性
用途

fields

文档数组

必需

要索引的向量和过滤字段,每个文档一个。至少有一个文档必须包含向量字段的字段定义。您还可以选择对布尔值、日期、数字、objectId、string 和 UUID 字段进行索引(每个文档一个),用于预筛选数据。

fields.type

字符串

必需

用于为 $vectorSearch 的字段索引的字段类型。您可以指定以下值之一:

  • vector - 对于包含向量嵌入的字段。

  • filter - 对于包含布尔值、日期、objectId、数字、string 或 UUID 值的字段。

fields.path

字符串

必需

要为其创建索引的字段名称。对于嵌套字段,使用点表示法来指定嵌入式字段的路径。

不能为包含两个连续点或以点结尾的字段名称创建索引。例如,Atlas Vector Search 不支持为以下字段名称创建索引:foo..barfoo_bar.

fields.numDimensions

int

必需

Atlas Vector Search 在索引时和查询时强制执行的向量维数。您必须指定小于或等于 4096 的值。您只能为 vector 类型字段设置此字段。

fields.similarity

字符串

必需

用于搜索前 K 个最近邻的向量相似度函数。您只能为 vector 类型字段设置此字段。值可以是以下值之一:

  • euclidean — 测量向量两端之间的距离。

  • cosine — 根据向量之间的角度测量相似度。

  • dotProduct - 测量类似于 cosine 的相似度,但会考虑向量的幅度。

要学习;了解更多信息,请参阅关于相似度函数。

索引定义的 vector 字段必须包含以下类型之一的数字数组:

  • BSON double

  • BSON BinData vector 子类型 float32

  • BSON BinData vector 子类型 int8

注意

要学习;了解有关为数据生成BSON BinDatavector 子类型float32vector 子类型int8 向量的更多信息,请参阅如何摄取量化向量。

您必须在 fields 数组中将向量字段作为 vector 类型进行索引。

以下语法定义了 vector 字段类型:

1{
2 "fields":[
3 {
4 "type": "vector",
5 "path": <field-to-index>,
6 "numDimensions": <number-of-dimensions>,
7 "similarity": "euclidean | cosine | dotProduct"
8 },
9 ...
10 ]
11}

Atlas Vector Search支持以下相似度函数:

  • euclidean — 测量向量两端之间的距离。您可以通过该值根据不同的维度衡量相似性。要了解更多信息,请参阅欧几里得。

  • cosine — 根据向量之间的角度测量相似度。通过该值,您可以衡量不按幅度缩放的相似度。不能将零幅度向量与 cosine 一起使用。要衡量余弦相似度,我们建议您对向量进行归一化并改用 dotProduct

  • dotProduct - 与 cosine 类似的测量计算,但考虑了向量的幅度。如果对幅度进行归一化,则 cosinedotProduct 在衡量相似性方面几乎相同。

    要使用 dotProduct ,您必须在索引时和查询时将向量规范化为单位长度。

为获得最佳性能,请检查您的嵌入模型,以确定哪个相似度函数适合嵌入模型的培训进程。如果没有任何指导,请从 dotProduct 开始。将 fields.similarity 设置为 dotProduct 值可让您根据角度和幅度有效地衡量相似性。 dotProductcosine 消耗的计算资源更少,并且在向量为单位长度时非常高效。但是,如果您的向量未标准化,请评估 euclidean 距离和 cosine 相似度的示例查询结果中的相似度分数,以确定哪一个对应于合理的结果。

您可以选择对布尔值、日期、数字、objectId、字符串和 UUID 字段建立索引,以预筛选数据。筛选数据有助于缩小语义搜索的范围,并确保不会考虑所有向量进行比较。它减少了要运行相似性比较的文档数量,从而减少查询延迟并提高搜索结果的准确性。

您必须使用 fields大量内的 filter 类型为要过滤的字段建立索引。

以下语法定义了 filter 字段类型:

1{
2 "fields":[
3 {
4 "type": "vector",
5 ...
6 },
7 {
8 "type": "filter",
9 "path": "<field-to-index>"
10 },
11 ...
12 ]
13}

注意

对数据进行预过滤不会影响 Atlas Vector Search 使用 $vectorSearchScore 进行 $vectorSearch 查询时返回的分数。

Atlas Search 索引是一种数据结构,它会以易于搜索的格式对数据进行分类。它是术语与包含这些术语的文档之间的映射。Atlas Search 索引可以使用某些标识符更快地检索文档。您必须配置 Atlas Search 索引才能使用 Atlas Search 查询 Atlas 集群中的数据。

您可在单个字段或多个字段上创建 Atlas Search 索引。我们建议您对经常用于排序或筛选数据的字段建立索引,以便在查询时快速检索包含相关数据的文档。

您可以通过 Atlas UI、Atlas Administration API、Atlas CLI、mongosh 或受支持的 MongoDB 驱动程序,为包含长度小于或等于 4096 维的向量嵌入的所有集合创建 Atlas Vector Search 索引。

要创建 Atlas Vector Search 索引,Atlas 集群必须满足以下先决条件:

  • MongoDB 版本6.0.117.0.2或更高版本

  • 为其创建 Atlas Vector Search 索引的集合

注意

您可以使用mongosh 命令或驾驶员助手方法在所有AtlasAtlas Search Atlas集群层上创建Atlas Search索引。有关支持的驾驶员版本的列表,请参阅支持的客户端。

您需要 Project Data Access Admin 或更高级别的角色才能创建和管理 Atlas Vector Search 索引。

您创建的内容不能超过:

  • M0 集群上具有 3 个索引。

  • M2 集群上有 5 个索引。

  • M5 集群上有 10 个索引。

我们建议您在单个 M10+集群上创建不超过 2 个、500 个搜索索引。


➤ 使用选择语言下拉菜单选择要用于创建索引的客户端。


注意

该过程包括sample_mflix数据库中embedded_movies集合的索引定义示例。 如果您在集群上加载样本数据并为此集合创建示例 Atlas Search 索引,则可以对此集合运行样本$vectorSearch查询。 要了解有关可以运行的示例查询的更多信息,请参阅$vectorSearch 示例。

要使用 Atlas Administration API 为集合创建 Atlas Vector Search 索引,请使用所需参数向 Atlas Search indexes 端点发送 POST 请求。

1curl --user "{PUBLIC-KEY}:{PRIVATE-KEY}" --digest \
2--header "Accept: application/json" \
3--header "Content-Type: application/json" \
4--include \
5--request POST "https://cloud.mongodb.com/api/atlas/v2/groups/{groupId}/clusters/{clusterName}/search/indexes" \
6--data '
7 {
8 "database": "<name-of-database>",
9 "collectionName": "<name-of-collection>",
10 "type": "vectorSearch",
11 "name": "<index-name>",
12 "definition": {
13 "fields":[
14 {
15 "type": "vector",
16 "path": <field-to-index>,
17 "numDimensions": <number-of-dimensions>,
18 "similarity": "euclidean | cosine | dotProduct"
19 },
20 {
21 "type": "filter",
22 "path": "<field-to-index>"
23 },
24 ...
25 }
26 ]
27 }'

要了解有关端点语法和参数的更多信息,请参阅创建一个 Atlas Search 索引。

例子

以下索引定义在Atlas Vector Search索引中将 plot_embedding字段索引为 vector 类型,并将 genresyear 字段索引为 filter 类型。 plot_embedding字段包含使用 OpenAI 的 text-embedding-ada-002 嵌入模型创建的嵌入。索引定义指定了 1536 个向量维度,并使用 dotProduct 函数测量相似性。

以下索引定义仅对用于执行向量Atlas Search的向量嵌入字段进行索引。

1curl --user "{PUBLIC-KEY}:{PRIVATE-KEY}" --digest \
2--header "Accept: application/json" \
3--header "Content-Type: application/json" \
4--include \
5--request POST "https://cloud.mongodb.com/api/atlas/v2/groups/{groupId}/clusters/{clusterName}/search/indexes" \
6--data '
7 {
8 "database": "sample_mflix",
9 "collectionName": "embedded_movies",
10 "type": "vectorSearch",
11 "name": "vector_index",
12 "definition: {
13 "fields":[
14 {
15 "type": "vector",
16 "path": "plot_embedding",
17 "numDimensions": 1536,
18 "similarity": "dotProduct"
19 }
20 ]
21 }
22 }'

此索引定义对以下字段进行索引:

  • 用于预过滤数据的 string 字段 (genres) 和数字字段 (year)。

  • 向量嵌入字段 (plot_embedding),用于针对预筛选数据执行向量Atlas Search 。

1curl --user "{PUBLIC-KEY}:{PRIVATE-KEY}" --digest \
2--header "Accept: application/json" \
3--header "Content-Type: application/json" \
4--include \
5--request POST "https://cloud.mongodb.com/api/atlas/v2/groups/{groupId}/clusters/{clusterName}/search/indexes" \
6--data '
7 {
8 "database": "sample_mflix",
9 "collectionName": "embedded_movies",
10 "type": "vectorSearch",
11 "name": "vector_index",
12 "definition: {
13 "fields":[
14 {
15 "type": "vector",
16 "path": "plot_embedding",
17 "numDimensions": 1536,
18 "similarity": "dotProduct"
19 },
20 {
21 "type": "filter",
22 "path": "genres"
23 },
24 {
25 "type": "filter",
26 "path": "year"
27 }
28 ]
29 }
30 }'

要使用 Atlas CLI v1.14.3 或更高版本为集合创建 Atlas Vector Search 索引,请执行以下步骤:

1

您的索引定义应遵循以下格式:

1{
2 "database": "<name-of-database>",
3 "collectionName": "<name-of-collection>",
4 "type": "vectorSearch",
5 "name": "<index-name>",
6 "fields":[
7 {
8 "type": "vector",
9 "path": "<field-to-index>",
10 "numDimensions": <number-of-dimensions>,
11 "similarity": "euclidean | cosine | dotProduct"
12 },
13 {
14 "type": "filter",
15 "path": "<field-to-index>"
16 },
17 ...
18 ]
19}

例子

创建一个名为 vector-index.json 的文件。

2

<name-of-database>

包含要为其创建索引的集合的数据库。

<name-of-collection>

要为其创建索引的集合。

<index-name>

索引的名称。如果省略索引名称,Atlas Vector Search 会将索引命名为 vector_index

<number-of-dimensions>

Atlas Vector Search 在索引时和查询时实施的向量维度数。

<field-to-index>

要索引的向量和筛选器字段。

例子

将以下索引定义复制并粘贴到 vector-index.json文件中。以下索引定义在Atlas Vector Search索引中将 plot_embedding字段索引为 vector 类型,并将 genresyear 字段索引为 filter 类型。 plot_embedding字段包含使用 OpenAI 的 text-embedding-ada-002 嵌入模型创建的嵌入。索引定义指定了 1536 个向量维度,并使用 dotProduct 函数测量相似性。

以下索引定义仅对用于执行向量Atlas Search的向量嵌入字段进行索引。

1{
2 "database": "sample_mflix",
3 "collectionName": "embedded_movies",
4 "type": "vectorSearch",
5 "name": "vector_index",
6 "fields": [
7 {
8 "type": "vector",
9 "path": "plot_embedding",
10 "numDimensions": 1536,
11 "similarity": "dotProduct"
12 }
13 ]
14}

此索引定义对以下字段进行索引:

  • 用于预过滤数据的 string 字段 (genres) 和数字字段 (year)。

  • 向量嵌入字段 (plot_embedding),用于针对预筛选数据执行向量Atlas Search 。

1{
2 "database": "sample_mflix",
3 "collectionName": "embedded_movies",
4 "type": "vectorSearch",
5 "name": "vector_index",
6 "fields":[
7 {
8 "type": "vector",
9 "path": "plot_embedding",
10 "numDimensions": 1536,
11 "similarity": "dotProduct"
12 },
13 {
14 "type": "filter",
15 "path": "genres"
16 },
17 {
18 "type": "filter",
19 "path": "year"
20 }
21 ]
22}
3
atlas clusters search indexes create --clusterName [cluster_name] --file [vector_index].json

在命令中,替换以下占位符值:

  • cluster_name 是包含要为其创建索引的集合的 Atlas 集群的名称。

  • vector_index 是包含 Atlas Vector Search 索引定义的 JSON 文件的名称。

例子

atlas clusters search indexes create --clusterName [cluster_name] --file vector-index.json

要了解有关命令语法和参数的更多信息,请参阅 Atlas CLI 文档中的 Atlas 集群搜索索引创建命令。

1
  1. 如果尚未显示,请从导航栏上的 Organizations 菜单中选择包含所需项目的组织。

  2. 如果尚未显示,请从导航栏的Projects菜单中选择所需的项目。

  3. 如果尚未出现,请单击侧边栏中的 Clusters(集群)。

    会显示集群页面。

2

您可以从侧边栏、 Data Explorer 或集群详细信息页面转到 Atlas Search 页面。

  1. 在侧边栏中,单击 Services 标题下的 Atlas Search

  2. Select data source 下拉菜单中选择您的集群并单击 Go to Atlas Search

    将显示 Atlas Search 页面。

  1. 单击集群的对应 Browse Collections 按钮。

  2. 展开数据库并选择集合。

  3. 单击该集合的 Search Indexes 标签页。

    将显示 Atlas Search 页面。

  1. 单击集群的名称。

  2. 单击 Atlas Search 标签页。

    将显示 Atlas Search 页面。

3

要进行创建,请单击 Create Search Index

4
创建 Atlas Vector Search 索引的屏幕截图
点击放大
5
  1. Index Name(索引名称)字段中,输入索引的名称。

    无论索引类型如何,索引名称在命名空间内都必须是唯一的。

    例子

    输入 vector_index 作为示例索引的名称。如果此集合上已有名为 vector_index 的索引,请为该索引输入其他名称。

  2. Database and Collection 部分中,找到数据库,然后选择集合。

    提示

    如果您从 Data Explorer导航到此页面,则可以跳过此步骤,因为 Atlas 会预先选择您在 Data Explorer 中选择的数据库和集合。

    例子

    Database and Collection(数据库和集合)部分中找到 sample_mflix 数据库,然后选择 embedded_movies 集合。

6

Atlas Vector Search 索引类似于以下示例:

1{
2 "fields":[
3 {
4 "type": "vector",
5 "path": <field-to-index>,
6 "numDimensions": <number-of-dimensions>,
7 "similarity": "euclidean | cosine | dotProduct"
8 },
9 {
10 "type": "filter",
11 "path": "<field-to-index>"
12 },
13 ...
14 ]
15}

要了解有关索引中的字段的更多信息,请参阅如何对 Vector Search 字段建立索引

例子

以下索引定义在Atlas Vector Search索引中将 plot_embedding字段索引为 vector 类型,并将 genresyear 字段索引为 filter 类型。 plot_embedding字段包含使用 OpenAI 的 text-embedding-ada-002 嵌入模型创建的嵌入。索引定义指定了 1536 个向量维度,并使用 dotProduct 函数测量相似性。

以下索引定义仅对用于执行向量Atlas Search的向量嵌入字段进行索引。

1{
2 "fields": [{
3 "type": "vector",
4 "path": "plot_embedding",
5 "numDimensions": 1536,
6 "similarity": "dotProduct"
7 }]
8}

此索引定义对以下字段进行索引:

  • 用于预过滤数据的 string 字段 (genres) 和数字字段 (year)。

  • 向量嵌入字段 (plot_embedding),用于针对预筛选数据执行向量Atlas Search 。

1{
2 "fields": [{
3 "type": "vector",
4 "path": "plot_embedding",
5 "numDimensions": 1536,
6 "similarity": "dotProduct"
7 },
8 {
9 "type": "filter",
10 "path": "genres"
11 },
12 {
13 "type": "filter",
14 "path": "year"
15 }]
16}
7
8

Atlas 会显示一个模态窗口,让您知道您的索引正在构建中。

9
10

新创建的索引会出现在 Atlas Search 标签页上。在构建索引期间,Status 字段显示为 Build in Progress。索引构建完成后,Status 字段将显示为Active

注意

较大的集合需要较长的索引时间。索引构建完成后,您将收到电子邮件通知。

要为使用 mongosh v2.1.2 或更高版本的集合创建 Atlas Search 索引,请执行以下步骤:

1

要了解更多信息,请参阅通过 mongosh 进行连接

2

例子

use sample_mflix
switched to db sample_mflix
3

db.collection.createSearchIndex() 方法使用的语法如下:

1db.<collectionName>.createSearchIndex(
2 "<index-name>",
3 "vectorSearch", //index type
4 {
5 fields: [
6 {
7 "type": "vector",
8 "numDimensions": <number-of-dimensions>,
9 "path": "<field-to-index>",
10 "similarity": "euclidean | cosine | dotProduct"
11 },
12 {
13 "type": "filter",
14 "path": "<field-to-index>"
15 },
16 ...
17 ]
18 }
19);

例子

以下索引定义在Atlas Vector Search索引中将 plot_embedding字段索引为 vector 类型,并将 genresyear 字段索引为 filter 类型。 plot_embedding字段包含使用 OpenAI 的 text-embedding-ada-002 嵌入模型创建的嵌入。索引定义指定了 1536 个向量维度,并使用 dotProduct 函数测量相似性。

以下索引定义仅对用于执行向量Atlas Search的向量嵌入字段进行索引。

1db.embedded_movies.createSearchIndex(
2 "vector_index",
3 "vectorSearch",
4 {
5 "fields": [
6 {
7 "type": "vector",
8 "path": "plot_embedding",
9 "numDimensions": 1536,
10 "similarity": "dotProduct"
11 }
12 ]
13 }
14);

此索引定义对以下字段进行索引:

  • 用于预过滤数据的 string 字段 (genres) 和数字字段 (year)。

  • 向量嵌入字段 (plot_embedding),用于针对预筛选数据执行向量Atlas Search 。

1db.embedded_movies.createSearchIndex(
2 "vector_index",
3 "vectorSearch",
4 {
5 "fields": [
6 {
7 "type": "vector",
8 "path": "plot_embedding",
9 "numDimensions": 1536,
10 "similarity": "dotProduct"
11 },
12 {
13 "type": "filter",
14 "path": "genres"
15 },
16 {
17 "type": "filter",
18 "path": "year"
19 }
20 ]
21 }
22);

要使用 MongoDB Go 驱动程序 v1.16.0 或更高版本为集合创建 Atlas Vector Search 索引,请执行以下步骤:

1
1package main
2
3import (
4 "context"
5 "fmt"
6 "log"
7
8 "go.mongodb.org/mongo-driver/bson"
9 "go.mongodb.org/mongo-driver/mongo"
10 "go.mongodb.org/mongo-driver/mongo/options"
11)
12
13func main() {
14 ctx := context.Background()
15
16 // Replace the placeholder with your Atlas connection string
17 const uri = "<connectionString>"
18
19 // Connect to your Atlas cluster
20 clientOptions := options.Client().ApplyURI(uri)
21 client, err := mongo.Connect(ctx, clientOptions)
22 if err != nil {
23 log.Fatalf("failed to connect to the server: %v", err)
24 }
25 defer func() { _ = client.Disconnect(ctx) }()
26
27 // Set the namespace
28 coll := client.Database("<databaseName>").Collection("<collectionName>")
29
30 // Define the index details
31 type vectorDefinitionField struct {
32 Type string `bson:"type"`
33 Path string `bson:"path"`
34 NumDimensions int `bson:"numDimensions"`
35 Similarity string `bson:"similarity"`
36 }
37
38 type vectorDefinition struct {
39 Fields []vectorDefinitionField `bson:"fields"`
40 }
41
42 indexName := "<indexName>"
43 opts := options.SearchIndexes().SetName(indexName).SetType("vectorSearch")
44
45 indexModel := mongo.SearchIndexModel{
46 Definition: vectorDefinition{
47 Fields: []vectorDefinitionField{{
48 Type: "vector",
49 Path: "<fieldToIndex>",
50 NumDimensions: <numberOfDimensions>,
51 Similarity: "euclidean | cosine | dotProduct"}},
52 },
53 Options: opts,
54 }
55
56 // Create the index
57 log.Println("Creating the index.")
58 searchIndexName, err := coll.SearchIndexes().CreateOne(ctx, indexModel)
59 if err != nil {
60 log.Fatalf("failed to create the search index: %v", err)
61 }
62
63 // Await the creation of the index.
64 log.Println("Polling to confirm successful index creation.")
65 log.Println("NOTE: This may take up to a minute.")
66 searchIndexes := coll.SearchIndexes()
67 var doc bson.Raw
68 for doc == nil {
69 cursor, err := searchIndexes.List(ctx, options.SearchIndexes().SetName(searchIndexName))
70 if err != nil {
71 fmt.Errorf("failed to list search indexes: %w", err)
72 }
73
74 if !cursor.Next(ctx) {
75 break
76 }
77
78 name := cursor.Current.Lookup("name").StringValue()
79 queryable := cursor.Current.Lookup("queryable").Boolean()
80 if name == searchIndexName && queryable {
81 doc = cursor.Current
82 } else {
83 time.Sleep(5 * time.Second)
84 }
85 }
86
87 log.Println("Name of Index Created: " + searchIndexName)
88}

例子

创建一个名为 vector-index.go 的文件。

2

<connectionString>

Atlas连接string 。 要了解更多信息,请参阅通过驱动程序连接。

<databaseName>

包含要为其创建索引的集合的数据库。

<collectionName>

要为其创建索引的集合。

<indexName>

索引的名称。 如果省略索引名称,Atlas Search 会将索引命名为vector_index

<numberOfDimensions>

Atlas Vector Search 在索引时和查询时实施的向量维度数。

<fieldToIndex>

要索引的向量和筛选器字段。

例子

将以下内容复制并粘贴到 vector-index.go文件,并替换 <connectionString> 占位符值。以下索引定义在Atlas Vector Search索引中将 plot_embedding字段索引为 vector 类型,并将 genresyear 字段索引为 filter 类型。 plot_embedding字段包含使用 OpenAI 的 text-embedding-ada-002 嵌入模型创建的嵌入。索引定义指定了 1536 个向量维度,并使用 dotProduct 函数测量相似度。

以下索引定义仅对用于执行向量Atlas Search的向量嵌入字段 (plot_embedding) 编制索引。

1package main
2
3import (
4 "context"
5 "fmt"
6 "log"
7 "time"
8
9 "go.mongodb.org/mongo-driver/bson"
10 "go.mongodb.org/mongo-driver/mongo"
11 "go.mongodb.org/mongo-driver/mongo/options"
12)
13
14func main() {
15 ctx := context.Background()
16
17 // Replace the placeholder with your Atlas connection string
18 const uri = "<connectionString>"
19
20 // Connect to your Atlas cluster
21 clientOptions := options.Client().ApplyURI(uri)
22 client, err := mongo.Connect(ctx, clientOptions)
23 if err != nil {
24 log.Fatalf("failed to connect to the server: %v", err)
25 }
26 defer func() { _ = client.Disconnect(ctx) }()
27
28 // Set the namespace
29 coll := client.Database("sample_mflix").Collection("embedded_movies")
30
31 // Define the index details
32 type vectorDefinitionField struct {
33 Type string `bson:"type"`
34 Path string `bson:"path"`
35 NumDimensions int `bson:"numDimensions"`
36 Similarity string `bson:"similarity"`
37 }
38
39 type vectorDefinition struct {
40 Fields []vectorDefinitionField `bson:"fields"`
41 }
42
43 indexName := "vector_index"
44 opts := options.SearchIndexes().SetName(indexName).SetType("vectorSearch")
45
46 indexModel := mongo.SearchIndexModel{
47 Definition: vectorDefinition{
48 Fields: []vectorDefinitionField{{
49 Type: "vector",
50 Path: "plot_embedding",
51 NumDimensions: 1536,
52 Similarity: "dotProduct"}},
53 },
54 Options: opts,
55 }
56
57 // Create the index
58 searchIndexName, err := coll.SearchIndexes().CreateOne(ctx, indexModel)
59 if err != nil {
60 log.Fatalf("failed to create the search index: %v", err)
61 }
62 log.Println("New search index named " + searchIndexName + " is building.")
63
64 // Await the creation of the index.
65 log.Println("Polling to check if the index is ready. This may take up to a minute.")
66 searchIndexes := coll.SearchIndexes()
67 var doc bson.Raw
68 for doc == nil {
69 cursor, err := searchIndexes.List(ctx, options.SearchIndexes().SetName(searchIndexName))
70 if err != nil {
71 fmt.Errorf("failed to list search indexes: %w", err)
72 }
73
74 if !cursor.Next(ctx) {
75 break
76 }
77
78 name := cursor.Current.Lookup("name").StringValue()
79 queryable := cursor.Current.Lookup("queryable").Boolean()
80 if name == searchIndexName && queryable {
81 doc = cursor.Current
82 } else {
83 time.Sleep(5 * time.Second)
84 }
85 }
86
87 log.Println(searchIndexName + " is ready for querying.")
88}

此索引定义对以下字段进行索引:

  • 用于预过滤数据的 string 字段 (genres) 和数字字段 (year)。

  • 向量嵌入字段 (plot_embedding),用于针对预筛选数据执行向量Atlas Search 。

1package main
2
3import (
4 "context"
5 "fmt"
6 "log"
7 "time"
8
9 "go.mongodb.org/mongo-driver/bson"
10 "go.mongodb.org/mongo-driver/mongo"
11 "go.mongodb.org/mongo-driver/mongo/options"
12)
13
14func main() {
15 ctx := context.Background()
16
17 // Replace the placeholder with your Atlas connection string
18 const uri = "<connectionString>"
19
20 // Connect to your Atlas cluster
21 clientOptions := options.Client().ApplyURI(uri)
22 client, err := mongo.Connect(ctx, clientOptions)
23 if err != nil {
24 log.Fatalf("failed to connect to the server: %v", err)
25 }
26 defer func() { _ = client.Disconnect(ctx) }()
27
28 // Set the namespace
29 coll := client.Database("sample_mflix").Collection("embedded_movies")
30 indexName := "vector_index"
31 opts := options.SearchIndexes().SetName(indexName).SetType("vectorSearch")
32
33 type vectorDefinitionField struct {
34 Type string `bson:"type"`
35 Path string `bson:"path"`
36 NumDimensions int `bson:"numDimensions"`
37 Similarity string `bson:"similarity"`
38 }
39
40 type filterField struct {
41 Type string `bson:"type"`
42 Path string `bson:"path"`
43 }
44
45 type indexDefinition struct {
46 Fields []vectorDefinitionField `bson:"fields"`
47 }
48
49 vectorDefinition := vectorDefinitionField{
50 Type: "vector",
51 Path: "plot_embedding",
52 NumDimensions: 1536,
53 Similarity: "dotProduct"}
54 genreFilterDefinition := filterField{"filter", "genres"}
55 yearFilterDefinition := filterField{"filter", "year"}
56
57 indexModel := mongo.SearchIndexModel{
58 Definition: bson.D{{"fields", [3]interface{}{
59 vectorDefinition,
60 genreFilterDefinition,
61 yearFilterDefinition}}},
62 Options: opts,
63 }
64
65 // Create the index
66 searchIndexName, err := coll.SearchIndexes().CreateOne(ctx, indexModel)
67 if err != nil {
68 log.Fatalf("failed to create the search index: %v", err)
69 }
70 log.Println("New search index named " + searchIndexName + " is building.")
71
72 // Await the creation of the index.
73 log.Println("Polling to check if the index is ready. This may take up to a minute.")
74 searchIndexes := coll.SearchIndexes()
75 var doc bson.Raw
76 for doc == nil {
77 cursor, err := searchIndexes.List(ctx, options.SearchIndexes().SetName(searchIndexName))
78 if err != nil {
79 fmt.Errorf("failed to list search indexes: %w", err)
80 }
81
82 if !cursor.Next(ctx) {
83 break
84 }
85
86 name := cursor.Current.Lookup("name").StringValue()
87 queryable := cursor.Current.Lookup("queryable").Boolean()
88 if name == searchIndexName && queryable {
89 doc = cursor.Current
90 } else {
91 time.Sleep(5 * time.Second)
92 }
93 }
94
95 log.Println(searchIndexName + " is ready for querying.")
96}
3
go run <file-name>.go

例子

go run vector-index.go

要使用 MongoDB Java 驱动程序 v5.2.0 或更高版本为集合创建 Atlas Vector Search 索引,请执行以下步骤:

1
1import com.mongodb.client.ListSearchIndexesIterable;
2import com.mongodb.client.MongoClient;
3import com.mongodb.client.MongoClients;
4import com.mongodb.client.MongoCollection;
5import com.mongodb.client.MongoCursor;
6import com.mongodb.client.MongoDatabase;
7import com.mongodb.client.model.SearchIndexModel;
8import com.mongodb.client.model.SearchIndexType;
9import org.bson.Document;
10import org.bson.conversions.Bson;
11
12import java.util.Arrays;
13import java.util.Collections;
14import java.util.List;
15
16public class VectorIndex {
17
18 public static void main(String[] args) {
19
20 // Replace the placeholder with your Atlas connection string
21 String uri = "<connectionString>";
22
23 // Connect to your Atlas cluster
24 try (MongoClient mongoClient = MongoClients.create(uri)) {
25
26 // Set the namespace
27 MongoDatabase database = mongoClient.getDatabase("<databaseName>");
28 MongoCollection<Document> collection = database.getCollection("<collectionName>");
29
30 // Define the index details
31 String indexName = "<indexName>";
32 Bson definition = new Document(
33 "fields",
34 Arrays.asList(
35 new Document("type", "vector")
36 .append("path", "<fieldToIndex>")
37 .append("numDimensions", <numberOfDimensions>)
38 .append("similarity", "euclidean | cosine | dotProduct"),
39 new Document("type", "filter")
40 .append("path", "<fieldToIndex>"),
41 ...
42 )
43 );
44
45 // Define the index model
46 SearchIndexModel indexModel = new SearchIndexModel(
47 indexName,
48 definition,
49 SearchIndexType.vectorSearch()
50 );
51
52 // Create the index
53 try {
54 List<String> result = collection.createSearchIndexes(Collections.singletonList(indexModel));
55 System.out.println("New search index named " + result.get(0) + " is building.");
56 } catch (Exception e) {
57 throw new RuntimeException("Error creating index: " + e);
58 }
59
60
61 // Wait for Atlas to build the index
62 System.out.println("Polling to check if the index is ready. This may take up to a minute.");
63
64 ListSearchIndexesIterable<Document> searchIndexes = collection.listSearchIndexes();
65 Document doc = null;
66 while (doc == null) {
67 try (MongoCursor<Document> cursor = searchIndexes.iterator()) {
68 if (!cursor.hasNext()) {
69 break;
70 }
71 Document current = cursor.next();
72 String name = current.getString("name");
73 // When the index completes building, it becomes `queryable`
74 boolean queryable = current.getBoolean("queryable");
75 if (name.equals(indexName) && queryable) {
76 doc = current;
77 } else {
78 Thread.sleep(500);
79 }
80 } catch (Exception e) {
81 throw new RuntimeException("Failed to list search indexes: " + e);
82 mongoClient.close();
83 }
84 }
85 System.out.println(indexName + " is ready for querying.");
86
87 } catch (Exception e) {
88 throw new RuntimeException("Error connecting to MongoDB: " + e);
89 }
90 }
91}
2

<connectionString>

Atlas连接string 。 要了解更多信息,请参阅通过驱动程序连接。

<databaseName>

包含要为其创建索引的集合的数据库。

<collectionName>

要为其创建索引的集合。

<indexName>

索引的名称。 如果省略索引名称,Atlas Search 会将索引命名为vector_index

<numberOfDimensions>

Atlas Vector Search 在索引时和查询时实施的向量维度数。

<fieldToIndex>

要索引的向量和筛选器字段。

以下是索引定义示例:

  • 在 Atlas Vector Search 索引中,将 plot_embedding 字段作为 vector 类型,并将 genresyear 字段作为 filter 类型进行索引。

  • plot_embedding 字段指定为向量嵌入字段,其中包含使用 OpenAI 的 text-embedding-ada-002 嵌入模型创建的嵌入。

  • 指定 1536 向量维度并使用 dotProduct 函数衡量相似性。

此索引定义仅对向量嵌入字段 (plot_embedding) 进行索引以执行向量搜索。

将以下内容复制并粘贴到您创建的文件中,然后替换 <connectionString> 占位符值。

1import com.mongodb.client.ListSearchIndexesIterable;
2import com.mongodb.client.MongoClient;
3import com.mongodb.client.MongoClients;
4import com.mongodb.client.MongoCollection;
5import com.mongodb.client.MongoCursor;
6import com.mongodb.client.MongoDatabase;
7import com.mongodb.client.model.SearchIndexModel;
8import com.mongodb.client.model.SearchIndexType;
9import org.bson.Document;
10import org.bson.conversions.Bson;
11
12import java.util.Collections;
13import java.util.List;
14
15public class VectorIndex {
16
17 public static void main(String[] args) {
18
19 // Replace the placeholder with your Atlas connection string
20 String uri = "<connectionString>";
21
22 // Connect to your Atlas cluster
23 try (MongoClient mongoClient = MongoClients.create(uri)) {
24
25 // Set the namespace
26 MongoDatabase database = mongoClient.getDatabase("sample_mflix");
27 MongoCollection<Document> collection = database.getCollection("embedded_movies");
28
29 // Define the index details
30 String indexName = "vector_index";
31 Bson definition = new Document(
32 "fields",
33 Collections.singletonList(
34 new Document("type", "vector")
35 .append("path", "plot_embedding")
36 .append("numDimensions", 1536)
37 .append("similarity", "dotProduct")));
38
39 // Define the index model
40 SearchIndexModel indexModel = new SearchIndexModel(
41 indexName,
42 definition,
43 SearchIndexType.vectorSearch());
44
45 // Create the index
46 try {
47 List<String> result = collection.createSearchIndexes(Collections.singletonList(indexModel));
48 System.out.println("New search index named " + result.get(0) + " is building.");
49 } catch (Exception e) {
50 throw new RuntimeException("Error creating index: " + e);
51 }
52
53 // Wait for Atlas to build the index
54 System.out.println("Polling to check if the index is ready. This may take up to a minute.");
55
56 ListSearchIndexesIterable<Document> searchIndexes = collection.listSearchIndexes();
57 Document doc = null;
58 while (doc == null) {
59 try (MongoCursor<Document> cursor = searchIndexes.iterator()) {
60 if (!cursor.hasNext()) {
61 break;
62 }
63 Document current = cursor.next();
64 String name = current.getString("name");
65 // When the index completes building, it becomes `queryable`
66 boolean queryable = current.getBoolean("queryable");
67 if (name.equals(indexName) && queryable) {
68 doc = current;
69 } else {
70 Thread.sleep(500);
71 }
72 } catch (Exception e) {
73 throw new RuntimeException("Failed to list search indexes: " + e);
74 }
75 }
76 System.out.println(indexName + " is ready for querying.");
77
78 } catch (Exception e) {
79 throw new RuntimeException("Error connecting to MongoDB: " + e);
80 }
81 }
82}

此索引定义对以下字段进行索引:

  • 用于预过滤数据的 string 字段 (genres) 和数字字段 (year)。

  • 向量嵌入字段 (plot_embedding),用于针对预筛选数据执行向量Atlas Search 。

将以下内容复制并粘贴到您创建的文件中,然后替换 <connectionString> 占位符值。

1import com.mongodb.client.ListSearchIndexesIterable;
2import com.mongodb.client.MongoClient;
3import com.mongodb.client.MongoClients;
4import com.mongodb.client.MongoCollection;
5import com.mongodb.client.MongoCursor;
6import com.mongodb.client.MongoDatabase;
7import com.mongodb.client.model.SearchIndexModel;
8import com.mongodb.client.model.SearchIndexType;
9import org.bson.Document;
10import org.bson.conversions.Bson;
11
12import java.util.Arrays;
13import java.util.Collections;
14import java.util.List;
15
16public class VectorIndex {
17
18 public static void main(String[] args) {
19
20 // Replace the placeholder with your Atlas connection string
21 String uri = "<connectionString>";
22
23 // Connect to your Atlas cluster
24 try (MongoClient mongoClient = MongoClients.create(uri)) {
25
26 // Set the namespace
27 MongoDatabase database = mongoClient.getDatabase("sample_mflix");
28 MongoCollection<Document> collection = database.getCollection("embedded_movies");
29
30 // Define the index details with the filter fields
31 String indexName = "vector_index";
32 Bson definition = new Document(
33 "fields",
34 Arrays.asList(
35 new Document("type", "vector")
36 .append("path", "plot_embedding")
37 .append("numDimensions", 1536)
38 .append("similarity", "dotProduct"),
39 new Document("type", "filter")
40 .append("path", "genres"),
41 new Document("type", "filter")
42 .append("path", "year")));
43
44 // Define the index model
45 SearchIndexModel indexModel = new SearchIndexModel(
46 indexName,
47 definition,
48 SearchIndexType.vectorSearch());
49
50 // Create the filtered index
51 try {
52 List<String> result = collection.createSearchIndexes(Collections.singletonList(indexModel));
53 System.out.println("New search index named " + result.get(0) + " is building.");
54 } catch (Exception e) {
55 throw new RuntimeException("Error creating index: " + e);
56 }
57
58 // Wait for Atlas to build the index
59 System.out.println("Polling to check if the index is ready. This may take up to a minute.");
60
61 ListSearchIndexesIterable<Document> searchIndexes = collection.listSearchIndexes();
62 Document doc = null;
63 while (doc == null) {
64 try (MongoCursor<Document> cursor = searchIndexes.iterator()) {
65 if (!cursor.hasNext()) {
66 break;
67 }
68 Document current = cursor.next();
69 String name = current.getString("name");
70 // When the index completes building, it becomes `queryable`
71 boolean queryable = current.getBoolean("queryable");
72 if (name.equals(indexName) && queryable) {
73 doc = current;
74 } else {
75 Thread.sleep(500);
76 }
77 } catch (Exception e) {
78 throw new RuntimeException("Failed to list search indexes: " + e);
79 mongoClient.close();
80 }
81 }
82 System.out.println(indexName + " is ready for querying.");
83
84 } catch (Exception e) {
85 throw new RuntimeException("Error connecting to MongoDB: " + e);
86 }
87 }
88}
3

从 IDE 运行文件以创建索引。

要使用MongoDB 节点驱动程序v 6.6.0或更高版本为集合创建 Atlas Vector Search 索引,请执行以下步骤:

1
1const { MongoClient } = require("mongodb");
2
3// connect to your Atlas deployment
4const uri = "<connectionString>";
5
6const client = new MongoClient(uri);
7
8async function run() {
9 try {
10 const database = client.db("<databaseName>");
11 const collection = database.collection("<collectionName>");
12
13 // define your Atlas Vector Search index
14 const index = {
15 name: "<indexName>",
16 type: "vectorSearch",
17 definition: {
18 "fields": [
19 {
20 "type": "vector",
21 "numDimensions": <numberOfDimensions>,
22 "path": "<fieldToIndex>",
23 "similarity": "euclidean | cosine | dotProduct"
24 },
25 {
26 "type": "filter",
27 "path": "<fieldToIndex>"
28 },
29 ...
30 ]
31 }
32 }
33
34 // run the helper method
35 const result = await collection.createSearchIndex(index);
36 console.log(`New search index named ${result} is building.`);
37 // wait for the index to be ready to query
38 console.log("Polling to check if the index is ready. This may take up to a minute.")
39 let isQueryable = false;
40 while (!isQueryable) {
41 const cursor = collection.listSearchIndexes();
42 for await (const index of cursor) {
43 if (index.name === result) {
44 if (index.queryable) {
45 console.log(`${result} is ready for querying.`);
46 isQueryable = true;
47 } else {
48 await new Promise(resolve => setTimeout(resolve, 5000));
49 }
50 }
51 }
52 }
53 } finally {
54 await client.close();
55 }
56}
57run().catch(console.dir);

例子

创建一个名为 vector-index.js 的文件。

2

<connectionString>

Atlas连接string 。 要了解更多信息,请参阅通过驱动程序连接。

<databaseName>

包含要为其创建索引的集合的数据库。

<collectionName>

要为其创建索引的集合。

<indexName>

索引的名称。 如果省略索引名称,Atlas Search 会将索引命名为vector_index

<numberOfDimensions>

Atlas Vector Search 在索引时和查询时实施的向量维度数。

<fieldToIndex>

要索引的向量和筛选器字段。

例子

将以下内容复制并粘贴到 vector-index.js文件,并替换 <connectionString> 占位符值。以下索引定义在Atlas Vector Search索引中将 plot_embedding字段索引为 vector 类型,并将 genresyear 字段索引为 filter 类型。 plot_embedding字段包含使用 OpenAI 的 text-embedding-ada-002 嵌入模型创建的嵌入。索引定义指定了 1536 个向量维度,并使用 dotProduct 函数测量相似度。

以下索引定义仅对用于执行向量Atlas Search的向量嵌入字段 (plot_embedding) 编制索引。

1const { MongoClient } = require("mongodb");
2
3// connect to your Atlas deployment
4const uri = "<connectionString>";
5
6const client = new MongoClient(uri);
7
8async function run() {
9 try {
10 const database = client.db("sample_mflix");
11 const collection = database.collection("embedded_movies");
12
13 // define your Atlas Vector Search index
14 const index = {
15 name: "vector_index",
16 type: "vectorSearch",
17 definition: {
18 "fields": [
19 {
20 "type": "vector",
21 "numDimensions": 1536,
22 "path": "plot_embedding",
23 "similarity": "dotProduct"
24 }
25 ]
26 }
27 }
28
29 // run the helper method
30 const result = await collection.createSearchIndex(index);
31 console.log(`New search index named ${result} is building.`);
32
33 // wait for the index to be ready to query
34 console.log("Polling to check if the index is ready. This may take up to a minute.")
35 let isQueryable = false;
36 while (!isQueryable) {
37 const cursor = collection.listSearchIndexes();
38 for await (const index of cursor) {
39 if (index.name === result) {
40 if (index.queryable) {
41 console.log(`${result} is ready for querying.`);
42 isQueryable = true;
43 } else {
44 await new Promise(resolve => setTimeout(resolve, 5000));
45 }
46 }
47 }
48 }
49 } finally {
50 await client.close();
51 }
52}
53run().catch(console.dir);

此索引定义对以下字段进行索引:

  • 用于预过滤数据的 string 字段 (genres) 和数字字段 (year)。

  • 向量嵌入字段 (plot_embedding),用于针对预筛选数据执行向量Atlas Search 。

1const { MongoClient } = require("mongodb");
2
3// connect to your Atlas deployment
4const uri = "<connectionString>";
5
6const client = new MongoClient(uri);
7
8async function run() {
9 try {
10 const database = client.db("sample_mflix");
11 const collection = database.collection("embedded_movies");
12
13 // define your Atlas Vector Search index
14 const index = {
15 name: "vector_index",
16 type: "vectorSearch",
17 definition: {
18 "fields": [
19 {
20 "type": "vector",
21 "numDimensions": 1536,
22 "path": "plot_embedding",
23 "similarity": "dotProduct"
24 },
25 {
26 "type": "filter",
27 "path": "genres"
28 },
29 {
30 "type": "filter",
31 "path": "year"
32 }
33 ]
34 }
35 }
36
37 // run the helper method
38 const result = await collection.createSearchIndex(index);
39 console.log(`New search index named ${result} is building.`);
40
41 // wait for the index to be ready to query
42 console.log("Polling to check if the index is ready. This may take up to a minute.")
43 let isQueryable = false;
44 while (!isQueryable) {
45 const cursor = collection.listSearchIndexes();
46 for await (const index of cursor) {
47 if (index.name === result) {
48 if (index.queryable) {
49 console.log(`${result} is ready for querying.`);
50 isQueryable = true;
51 } else {
52 await new Promise(resolve => setTimeout(resolve, 5000));
53 }
54 }
55 }
56 }
57 } finally {
58 await client.close();
59 }
60}
61run().catch(console.dir);
3
node <file-name>.js

例子

node vector_index.js

要使用PyMongo驱动程序 v 4.7或更高版本为集合创建 Atlas Vector Search 索引,请执行以下步骤:

1
1import pymongo
2from pymongo.mongo_client import MongoClient
3from pymongo.operations import SearchIndexModel
4
5# Connect to your Atlas deployment
6uri = "<connectionString>"
7client = MongoClient(uri)
8
9# Access your database and collection
10database = client["<databaseName>"]
11collection = database["<collectionName>"]
12
13# Create your index model, then create the search index
14search_index_model = SearchIndexModel(
15 definition={
16 "fields": [
17 {
18 "type": "vector",
19 "numDimensions": <numberofDimensions>,
20 "path": "<fieldToIndex>",
21 "similarity": "euclidean | cosine | dotProduct"
22 },
23 {
24 "type": "filter",
25 "path": "<fieldToIndex>"
26 },
27 ...
28 ]
29 },
30 name="<indexName>",
31 type="vectorSearch",
32)
33
34result = collection.create_search_index(model=search_index_model)
35print("New search index named " + result + " is building.")
36
37# Wait for initial sync to complete
38print("Polling to check if the index is ready. This may take up to a minute.")
39predicate=None
40if predicate is None:
41 predicate = lambda index: index.get("queryable") is True
42
43while True:
44 indices = list(collection.list_search_indexes(result))
45 if len(indices) and predicate(indices[0]):
46 break
47 time.sleep(5)
48print(result + " is ready for querying.")
49
50client.close()

要了解详情,请参阅 create_search_index() 方法。

1from pymongo.mongo_client import MongoClient
2from pymongo.operations import SearchIndexModel
3
4def create_indexes():
5 # Connect to your Atlas deployment
6 uri = "<connectionString>"
7 client = MongoClient(uri)
8
9 # Access your database and collection
10 database = client["<databaseName>"]
11 collection = database["<collectionName>"]
12
13 # Create your index models and add them to an array
14 first_model = SearchIndexModel(
15 definition={
16 "fields": [
17 {
18 "type": "vector",
19 "numDimensions": <numberOfDimensions>,
20 "path": "<fieldToIndex>",
21 "similarity": "euclidean | cosine | dotProduct"
22 },
23 {
24 "type": "filter",
25 "path": "<fieldToIndex>"
26 },
27 ...
28 ]
29 },
30 name="<indexName>",
31 type="vectorSearch",
32 )
33
34 second_model = SearchIndexModel(
35 definition={
36 "fields": [
37 {
38 "type": "vector",
39 "numDimensions": <numberOfDimensions>,
40 "path": "<fieldToIndex>",
41 "similarity": "euclidean | cosine | dotProduct"
42 },
43 {
44 "type": "filter",
45 "path": "<fieldToIndex>"
46 },
47 ...
48 ]
49 },
50 name="<index name>",
51 type="vectorSearch",
52 )
53
54 ...
55
56 idx_models = [first_model, second_model, ...]
57
58 # Create the search indexes
59 result = collection.create_search_indexes(models=idx_models)
60 print(result)
61
62 client.close()

要了解详情,请参阅 create_search_indexes() 方法。

例子

创建一个名为 vector-index.py 的文件。

2

<connectionString>

Atlas连接string 。 要了解更多信息,请参阅通过驱动程序连接。

<databaseName>

包含要为其创建索引的集合的数据库。

<collectionName>

要为其创建索引的集合。

<indexName>

索引的名称。 如果省略索引名称,Atlas Search 会将索引命名为vector_index

<numberOfDimensions>

Atlas Vector Search 在索引时和查询时实施的向量维度数。

<fieldToIndex>

要索引的向量和筛选器字段。

例子

将以下内容复制并粘贴到 vector-index.py 中,并替换 <connectionString> 占位符值。以下索引定义在Atlas Vector Search索引中将 plot_embedding字段索引为 vector 类型,并将 genresyear 字段索引为 filter 类型。 plot_embedding字段包含使用 OpenAI 的 text-embedding-ada-002 嵌入模型创建的嵌入。索引定义指定了 1536 个向量维度,并使用 dotProduct 函数测量相似度。

以下索引定义仅对用于执行向量Atlas Search的向量嵌入字段 (plot_embedding) 编制索引。

1from pymongo.mongo_client import MongoClient
2from pymongo.operations import SearchIndexModel
3import time
4
5# Connect to your Atlas deployment
6uri = "<connectionString>"
7client = MongoClient(uri)
8
9# Access your database and collection
10database = client["sample_mflix"]
11collection = database["embedded_movies"]
12
13# Create your index model, then create the search index
14search_index_model = SearchIndexModel(
15 definition={
16 "fields": [
17 {
18 "type": "vector",
19 "path": "plot_embedding",
20 "numDimensions": 1536,
21 "similarity": "dotProduct"
22 }
23 ]
24 },
25 name="vector_index",
26 type="vectorSearch",
27)
28
29result = collection.create_search_index(model=search_index_model)
30print("New search index named " + result + " is building.")
31# Wait for initial sync to complete
32print("Polling to check if the index is ready. This may take up to a minute.")
33predicate=None
34if predicate is None:
35 predicate = lambda index: index.get("queryable") is True
36
37while True:
38 indices = list(collection.list_search_indexes(name))
39 if len(indices) and predicate(indices[0]):
40 break
41 time.sleep(5)
42print(result + " is ready for querying.")
43
44client.close()

此索引定义对以下字段进行索引:

  • 用于预过滤数据的 string 字段 (genres) 和数字字段 (year)。

  • 向量嵌入字段 (plot_embedding),用于针对预筛选数据执行向量Atlas Search 。

1from pymongo.mongo_client import MongoClient
2from pymongo.operations import SearchIndexModel
3import time
4
5# Connect to your Atlas deployment
6uri = "<connectionString>"
7client = MongoClient(uri)
8
9# Access your database and collection
10database = client["sample_mflix"]
11collection = database["embedded_movies"]
12
13# Create your index model, then create the search index
14search_index_model = SearchIndexModel(
15 definition={
16 "fields": [
17 {
18 "type": "vector",
19 "path": "plot_embedding",
20 "numDimensions": 1536,
21 "similarity": "dotProduct"
22 },
23 {
24 "type": "filter",
25 "path": "genres"
26 },
27 {
28 "type": "filter",
29 "path": "year"
30 }
31 ]
32 },
33 name="vector_index",
34 type="vectorSearch",
35)
36
37result = collection.create_search_index(model=search_index_model)
38print("New search index named " + result + " is building.")
39# Wait for initial sync to complete
40print("Polling to check if the index is ready. This may take up to a minute.")
41predicate=None
42if predicate is None:
43 predicate = lambda index: index.get("queryable") is True
44
45while True:
46 indices = list(collection.list_search_indexes(result))
47 if len(indices) and predicate(indices[0]):
48 break
49 time.sleep(5)
50print(result + " is ready for querying.")
51
52client.close()
3
python <file-name>.py

例子

python vector-index.py

您可以通过 Atlas UI、Atlas Administration API、Atlas CLI、mongosh 或受支持的 MongoDB 驱动程序查看所有集合的 Atlas Vector Search 索引。

您需要Project Search Index Editor或更高的角色才能查看 Atlas Vector Search 搜索索引。

注意

您可以使用mongosh 命令或驾驶员辅助方法检索所有AtlasAtlas Search Atlas集群层上的Atlas Search索引。有关支持的驾驶员版本的列表,请参阅支持的客户端。


➤ 使用选择语言下拉菜单设置本节中示例的语言。


要使用 Atlas 管理 API 检索集合的所有 Atlas Vector Search 索引,请使用数据库和集合的名称向 Atlas Search indexes 端点发送 GET 请求。

1curl --user "{PUBLIC-KEY}:{PRIVATE-KEY}" --digest \
2 --header "Accept: application/json" \
3 --include \
4 --request GET "https://cloud.mongodb.com/api/atlas/v2/groups/{groupId}/clusters/{clusterName}/search/indexes/{databaseName}/{collectionName}"

要了解有关端点语法和参数的更多信息,请参阅返回一个集合的所有 Atlas Search 索引。

要使用 Atlas Administration API 检索集合的一个 Atlas Vector Search 索引,请向 Atlas Search indexes 端点发送 GET 请求,并附上要检索的索引(第 4 行)的唯一 ID 或名称。

1curl --user "{PUBLIC-KEY}:{PRIVATE-KEY}" --digest \
2 --header "Accept: application/json" \
3 --include \
4 --request GET "https://cloud.mongodb.com/api/atlas/v2/groups/{groupId}/clusters/{clusterName}/search/indexes/{indexId} | https://cloud.mongodb.com/api/atlas/v2/groups/{groupId}/clusters/{clusterName}/search/indexes/{databaseName}/{collectionName}/{indexName|indexId}"

要了解有关端点的语法和参数的更多信息,请参阅按名称获取一个按 ID 获取一个。

要使用 Atlas CLI 返回集合的 Atlas Vector Search 索引,请执行以下步骤:

1

clusterName

Atlas 集群的名称。

db

Atlas 集群上包含您已编制索引的集合的数据库名称。

collection

数据库中索引集合的名称。

projectId

项目的唯一标识符。

2
atlas clusters search indexes list --clusterName [cluster_name] --db <db-name> --collection <collection-name>

在命令中,替换以下占位符值:

  • cluster-name - 包含索引集合的 Atlas 集群的名称。

  • db-name - 包含要检索其索引的集合的数据库名称。

  • collection-name - 要检索其索引的集合的名称。

要了解有关命令语法和参数的更多信息,请参阅 Atlas CLI 文档中的 Atlas 集群搜索索引列表命令。

1
  1. 如果尚未显示,请从导航栏上的 Organizations 菜单中选择包含所需项目的组织。

  2. 如果尚未显示,请从导航栏的Projects菜单中选择所需的项目。

  3. 如果尚未出现,请单击侧边栏中的 Clusters(集群)。

    会显示集群页面。

2

您可以从侧边栏、 Data Explorer 或集群详细信息页面转到 Atlas Search 页面。

  1. 在侧边栏中,单击 Services 标题下的 Atlas Search

  2. Select data source 下拉菜单中选择您的集群并单击 Go to Atlas Search

    将显示 Atlas Search 页面。

  1. 单击集群的对应 Browse Collections 按钮。

  2. 展开数据库并选择集合。

  3. 单击该集合的 Search Indexes 标签页。

    将显示 Atlas Search 页面。

  1. 单击集群的名称。

  2. 单击 Atlas Search 标签页。

    将显示 Atlas Search 页面。

此页面会显示页面上索引的以下详细信息:

名称

标识索引的标签。

索引类型

指示 Atlas Search 或 Atlas Vector Search 索引的标签。 值包括:

  • search 适用于 Atlas Search 索引。

  • vectorSearch 用于 Atlas Vector Search 搜索索引。

索引字段

包含此索引索引的字段的列表。

状态

size

主节点上索引的大小。

文档 (Document)

已建立索引的文档数与集合中文档总数的比值。

操作

可以对索引执行的操作。 您可以:

您无法在Search Tester 用户界面中针对vectorSearch 类型的索引运行查询。如果单击Query 按钮, Atlas Vector Search会显示示例$vectorSearch ,您可以在Atlas用户界面中以及使用其他支持的客户端复制、修改和运行该示例。

要使用 mongosh 查看集合的 Atlas Vector Search 索引,请执行以下步骤:

1

要了解更多信息,请参阅通过 mongosh 进行连接

2
3

db.collection.getSearchIndexes() 方法使用的语法如下:

1db.<collectionName>.getSearchIndexes( "<index-name>" );

要使用 MongoDB Go 驱动程序 v 1.16.0 或更高版本查看集合的 Atlas Vector Search 索引,请执行以下步骤:

1
1package main
2
3import (
4 "context"
5 "encoding/json"
6 "fmt"
7 "log"
8
9 "go.mongodb.org/mongo-driver/bson"
10 "go.mongodb.org/mongo-driver/mongo"
11 "go.mongodb.org/mongo-driver/mongo/options"
12)
13
14func main() {
15 ctx := context.Background()
16
17 // Replace the placeholder with your Atlas connection string
18 const uri = "<connectionString>"
19
20 // Connect to your Atlas cluster
21 clientOptions := options.Client().ApplyURI(uri)
22 client, err := mongo.Connect(ctx, clientOptions)
23 if err != nil {
24 log.Fatalf("failed to connect to the server: %v", err)
25 }
26 defer func() { _ = client.Disconnect(ctx) }()
27
28 // Set the namespace
29 coll := client.Database("<databaseName>").Collection("<collectionName>")
30
31 // Specify the options for the index to retrieve
32 indexName := "<indexName>"
33 opts := options.SearchIndexes().SetName(indexName)
34
35 // Get the index
36 cursor, err := coll.SearchIndexes().List(ctx, opts)
37 if err != nil {
38 log.Fatalf("failed to get the index: %v", err)
39 }
40
41 // Print the index details to the console as JSON
42 var results []bson.M
43 if err := cursor.All(ctx, &results); err != nil {
44 log.Fatalf("failed to unmarshal results to bson: %v", err)
45 }
46 res, err := json.Marshal(results)
47 if err != nil {
48 log.Fatalf("failed to marshal results to json: %v", err)
49 }
50 fmt.Println(string(res))
51}
2

<connectionString>

Atlas 连接字符串。要了解更多信息,请参阅通过驱动程序连接

<databaseName>

包含该集合的数据库。

<collectionName>

要检索其索引的集合。

<indexName>

如果要检索特定索引,请输入索引的名称。 要返回集合上的所有索引,请省略此值。

3
go run <file-name>.go

要使用 MongoDB Java 驱动程序 v5.2.0 或更高版本查看集合的 Atlas Vector Search 索引,请执行以下步骤:

1
1import com.mongodb.client.MongoClient;
2import com.mongodb.client.MongoClients;
3import com.mongodb.client.MongoCollection;
4import com.mongodb.client.MongoDatabase;
5import org.bson.Document;
6
7public class ViewVectorIndex {
8
9 public static void main(String[] args) {
10
11 // Replace the placeholder with your Atlas connection string
12 String uri = "<connectionString>";
13
14 // Connect to your Atlas cluster
15 try (MongoClient mongoClient = MongoClients.create(uri)) {
16
17 // Set the namespace
18 MongoDatabase database = mongoClient.getDatabase("<databaseName>");
19 MongoCollection<Document> collection = database.getCollection("<collectionName>");
20
21 // Specify the options for the index to retrieve
22 String indexName = "<indexName>";
23
24 // Get the index and print details to the console as JSON
25 try {
26 Document listSearchIndex = collection.listSearchIndexes().name(indexName).first();
27 if (listSearchIndex != null) {
28 System.out.println("Index found: " + listSearchIndex.toJson());
29 } else {
30 System.out.println("Index not found.");
31 }
32 } catch (Exception e) {
33 throw new RuntimeException("Error finding index: " + e);
34 }
35
36 } catch (Exception e) {
37 throw new RuntimeException("Error connecting to MongoDB: " + e);
38 }
39 }
40}
2

<connectionString>

Atlas 连接字符串。要了解更多信息,请参阅通过驱动程序连接

<databaseName>

包含该集合的数据库。

<collectionName>

要检索其索引的集合。

<indexName>

如果要检索特定索引,请输入索引的名称。 要返回集合上的所有索引,请省略此值。

3

从 IDE 运行该文件以检索指定的索引。

要使用 MongoDB 节点驱动程序 v6.6.0 或更高版本查看集合的 Atlas Vector Search 索引,请执行以下步骤:

1
1const { MongoClient } = require("mongodb");
2
3// connect to your Atlas deployment
4const uri = "<connectionString>";
5
6const client = new MongoClient(uri);
7
8async function run() {
9 try {
10 const database = client.db("<databaseName>");
11 const collection = database.collection("<collectionName>");
12
13 // run the helper method
14 const result = await collection.listSearchIndexes("<indexName>").toArray();
15 console.log(result);
16 } finally {
17 await client.close();
18 }
19}
20run().catch(console.dir);
2

<connectionString>

Atlas 连接字符串。要了解更多信息,请参阅通过驱动程序连接

<databaseName>

包含该集合的数据库。

<collectionName>

要检索其索引的集合。

<indexName>

如果要检索特定索引,请输入索引的名称。 要返回集合上的所有索引,请省略此值。

3
node <file-name>.js

要使用 PyMongo 驱动程序 v4.7 或更高版本查看某个集合的 Atlas Vector Search 索引,请执行以下步骤:

1
1from pymongo.mongo_client import MongoClient
2
3# Connect to your Atlas deployment
4uri = "<connectionString>"
5client = MongoClient(uri)
6
7# Access your database and collection
8database = client["<databaseName>"]
9collection = database["<collectionName>"]
10
11# Get a list of the collection's search indexes and print them
12cursor = collection.list_search_indexes()
13for index in cursor:
14 print(index)

要了解更多信息,请参阅 list_search_indexes() 方法。

2

<connectionString>

Atlas 连接字符串。要了解更多信息,请参阅通过驱动程序连接

<databaseName>

包含该集合的数据库名称。

<collectionName>

集合的名称。

3
python <file-name>.py

您可以通过 Atlas UI、Atlas Administration API、Atlas CLI、mongosh 或支持的 MongoDB 驱动程序更改现有 Atlas Vector Search 索引的索引定义。您无法重命名索引或更改索引类型。如果需要更改索引名称或类型,则必须创建新索引并删除旧索引。

重要

编辑索引后,Atlas Vector Search 会重建索引。重建索引时,您可以使用旧索引定义继续运行向量搜索查询。当索引完成重建后,将自动替换旧索引。此进程与标准 Atlas Search 索引的进程相同。

要了解更多信息,请参阅创建和更新 Atlas Search 索引。

您必须具有 Project Search Index Editor 或更高级别的角色才能编辑 Atlas Vector Search 索引。

注意

您可以使用mongosh 命令或驾驶员助手方法来编辑所有AtlasAtlas Search Atlas集群层上的Atlas Search索引。有关支持的驾驶员版本的列表,请参阅支持的客户端。


➤ 使用选择语言下拉菜单选择要用于编辑索引的客户端。


要使用 Atlas Administration API 编辑集合的 Atlas Vector Search 索引,请向 Atlas Search indexes 端点发送 PATCH 请求,并附上要编辑的索引(第 4 行)的唯一 ID 或名称。

1curl --user "{PUBLIC-KEY}:{PRIVATE-KEY}" --digest --include \
2 --header "Accept: application/json" \
3 --header "Content-Type: application/json" \
4 --request PATCH "https://cloud.mongodb.com/api/atlas/v2/groups/{groupId}/clusters/{clusterName}/search/indexes/{indexId} | https://cloud.mongodb.com/api/atlas/v2/groups/{groupId}/clusters/{clusterName}/search/indexes/{databaseName}/{collectionName}/{indexName|indexId}" \
5 --data'
6 {
7 "database": "<name-of-database>",
8 "collectionName": "<name-of-collection>",
9 "type": "vectorSearch",
10 "name": "<index-name>",
11 "definition": {
12 "fields":[
13 {
14 "type": "vector",
15 "path": <field-to-index>,
16 "numDimensions": <number-of-dimensions>,
17 "similarity": "euclidean | cosine | dotProduct"
18 },
19 {
20 "type": "filter",
21 "path": "<field-to-index>"
22 },
23 ...
24 }
25 ]
26 }'

要了解有关端点的语法和参数的更多信息,请参阅按名称更新一个按 ID 更新一个。

要使用 Atlas CLI 编辑集合的 Atlas Vector Search 索引,请执行以下步骤:

1

您的索引定义应遵循以下格式:

1{
2 "database": "<name-of-database>",
3 "collectionName": "<name-of-collection>",
4 "type": "vectorSearch",
5 "name": "<index-name>",
6 "fields":[
7 {
8 "type": "vector",
9 "path": "<field-to-index>",
10 "numDimensions": <number-of-dimensions>,
11 "similarity": "euclidean | cosine | dotProduct"
12 },
13 {
14 "type": "filter",
15 "path": "<field-to-index>"
16 },
17 ...
18 ]
19}
2

<name-of-database>

包含要为其创建索引的集合的数据库。

<name-of-collection>

要为其创建索引的集合。

<index-name>

索引的名称。如果省略索引名称,Atlas Vector Search 会将索引命名为 vector_index

<number-of-dimensions>

Atlas Vector Search 在索引时和查询时实施的向量维度数。

<field-to-index>

要索引的向量和筛选器字段。

3
atlas clusters search indexes update <indexId> --clusterName [cluster_name] --file [vector-_index].json

在命令中,替换以下占位符值:

  • cluster_name - 包含要更新索引的集合的 Atlas 集群的名称。

  • vector_index - 包含 Atlas Vector Search 索引的修改后索引定义的 JSON 文件名称。

要了解有关命令语法和参数的更多信息,请参阅 Atlas CLI 文档中的 atlas clusters search indexes update 命令。

1
  1. 如果尚未显示,请从导航栏上的 Organizations 菜单中选择包含所需项目的组织。

  2. 如果尚未显示,请从导航栏的Projects菜单中选择所需的项目。

  3. 如果尚未出现,请单击侧边栏中的 Clusters(集群)。

    会显示集群页面。

2

您可以从侧边栏、 Data Explorer 或集群详细信息页面转到 Atlas Search 页面。

  1. 在侧边栏中,单击 Services 标题下的 Atlas Search

  2. Select data source 下拉菜单中选择您的集群并单击 Go to Atlas Search

    将显示 Atlas Search 页面。

  1. 单击集群的对应 Browse Collections 按钮。

  2. 展开数据库并选择集合。

  3. 单击该集合的 Search Indexes 标签页。

    将显示 Atlas Search 页面。

  1. 单击集群的名称。

  2. 单击 Atlas Search 标签页。

    将显示 Atlas Search 页面。

3
  1. 找到要编辑的 vectorSearch 类型索引。

  2. 从该索引的 Actions 下拉列表中,单击 Edit Index

  3. 检查当前配置设置,并根据需要进行编辑。

    要了解有关 Atlas Vector Search 索引中的字段的更多信息,请参阅如何对 Vector Search 字段编制索引

  4. 单击 Save(保存)以应用更改。

索引的状态从 Active(有效)变为 Building(正在构建)。在该状态下,您可以继续使用旧索引,因为在更新的索引可供使用之前,Atlas Vector Search 不会删除旧索引。在状态恢复为 Active(有效)后,就可以使用修改的索引了。

要使用 mongosh 编辑集合的 Atlas Vector Search 索引,请执行以下步骤:

1

要了解更多信息,请参阅通过 mongosh 进行连接

2
3

db.collection.updateSearchIndex() 方法使用的语法如下:

1db.<collectionName>.updateSearchIndex(
2 "<index-name>",
3 {
4 fields: [
5 {
6 "type": "vector",
7 "numDimensions": <number-of-dimensions>,
8 "path": "<field-to-index>",
9 "similarity": "euclidean | cosine | dotProduct"
10 },
11 {
12 "type": "filter",
13 "path": "<field-to-index>"
14 },
15 ...
16 ]
17 }
18);

要使用 MongoDB Go 驱动程序 v 1.16.0 或更高版本更新集合的 Atlas Vector Search 索引,请执行以下步骤:

1
1package main
2
3import (
4 "context"
5 "fmt"
6 "log"
7
8 "go.mongodb.org/mongo-driver/mongo"
9 "go.mongodb.org/mongo-driver/mongo/options"
10)
11
12func main() {
13 ctx := context.Background()
14
15 // Replace the placeholder with your Atlas connection string
16 const uri = "<connection-string>"
17
18 // Connect to your Atlas cluster
19 clientOptions := options.Client().ApplyURI(uri)
20 client, err := mongo.Connect(ctx, clientOptions)
21 if err != nil {
22 log.Fatalf("failed to connect to the server: %v", err)
23 }
24 defer func() { _ = client.Disconnect(ctx) }()
25
26 // Set the namespace
27 coll := client.Database("<databaseName>").Collection("<collectionName>")
28 indexName := "<indexName>"
29
30 type vectorDefinitionField struct {
31 Type string `bson:"type"`
32 Path string `bson:"path"`
33 NumDimensions int `bson:"numDimensions"`
34 Similarity string `bson:"similarity"`
35 }
36
37 type vectorDefinition struct {
38 Fields []vectorDefinitionField `bson:"fields"`
39 }
40
41 definition := vectorDefinition{
42 Fields: []vectorDefinitionField{{
43 Type: "vector",
44 Path: "<fieldToIndex>",
45 NumDimensions: <numberOfDimensions>,
46 Similarity: "euclidean | cosine | dotProduct"}},
47 }
48 err = coll.SearchIndexes().UpdateOne(ctx, indexName, definition)
49
50 if err != nil {
51 log.Fatalf("failed to update the index: %v", err)
52 }
53
54 fmt.Println("Successfully updated the search index")
55}
2

<connectionString>

Atlas连接string 。 要了解更多信息,请参阅通过驱动程序连接。

<databaseName>

包含要为其创建索引的集合的数据库。

<collectionName>

要为其创建索引的集合。

<indexName>

索引的名称。 如果省略索引名称,Atlas Search 会将索引命名为vector_index

<numberOfDimensions>

Atlas Vector Search 在索引时和查询时实施的向量维度数。

<fieldToIndex>

要索引的向量和筛选器字段。

3
go run <file-name>.go

要使用 MongoDB Java 驱动程序 v5.2.0 或更高版本编辑某个集合的 Atlas Vector Search 索引,请执行以下步骤:

1