如何为向量搜索建立索引字段
在此页面上
您可以使用 vectorSearch
类型对字段进行索引以运行 $vectorSearch
查询。您可以为要查询的向量嵌入以及要用于预过滤数据的布尔值、日期、objectId、数值、字符串或 UUID 值定义索引。过滤数据有助于缩小语义搜索范围,并确保在比较时(例如在多租户环境中)不考虑某些向量嵌入。
您可以使用 Atlas UI、Administration API、Atlas CLI、 mongosh
或支持的 MongoDB 驱动程序来创建 Atlas Vector Search 索引。
注意
您不能使用已弃用的 knnBeta 操作符来查询使用 vectorSearch
类型索引定义索引的字段。
Considerations
在vectorSearch
类型索引定义中,您可以仅使用单个元素对数组进行索引。 您无法对文档数组内的字段或对象数组内的字段进行索引。 您可以使用点表示法对文档内的字段进行索引。
在为嵌入编制索引之前,我们建议将嵌入转换为 BSON BinData vector
子类型 float32
或int8
向量,以便在 Atlas 集群中高效存储和摄取向量。要了解更多信息,请参阅如何将嵌入转换为 BSON 向量。
支持的客户端
您可以通过Atlas 用户界面、mongosh
、 Atlas CLI、 Atlas Administration API和以下MongoDB驱动程序创建和管理Atlas Vector Search索引:
语法
以下语法定义了 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 索引字段
Atlas Vector Search 索引定义采用以下字段:
选项 | 类型 | 必要性 | 用途 |
---|---|---|---|
| 文档数组 | 必需 | 要索引的向量和过滤字段,每个文档一个。至少有一个文档必须包含向量字段的字段定义。您还可以选择对布尔值、日期、数字、objectId、string 和 UUID 字段进行索引(每个文档一个),用于预筛选数据。 |
| 字符串 | 必需 | 用于为
|
| 字符串 | 必需 | 要为其创建索引的字段名称。对于嵌套字段,使用点表示法来指定嵌入式字段的路径。 不能为包含两个连续点或以点结尾的字段名称创建索引。例如,Atlas Vector Search 不支持为以下字段名称创建索引: |
| int | 必需 | Atlas Vector Search 在索引时和查询时强制执行的向量维数。您必须指定小于或等于 |
| 字符串 | 必需 | 用于搜索前 K 个最近邻的向量相似度函数。您只能为
|
关于 vector
类型
索引定义的 vector
字段必须包含以下类型之一的数字数组:
注意
要学习;了解有关为数据生成BSON BinDatavector
子类型float32
或vector
子类型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
类似的测量计算,但考虑了向量的幅度。如果对幅度进行归一化,则cosine
和dotProduct
在衡量相似性方面几乎相同。要使用
dotProduct
,您必须在索引时和查询时将向量规范化为单位长度。
为获得最佳性能,请检查您的嵌入模型,以确定哪个相似度函数适合嵌入模型的培训进程。如果没有任何指导,请从 dotProduct
开始。将 fields.similarity
设置为 dotProduct
值可让您根据角度和幅度有效地衡量相似性。 dotProduct
比 cosine
消耗的计算资源更少,并且在向量为单位长度时非常高效。但是,如果您的向量未标准化,请评估 euclidean
距离和 cosine
相似度的示例查询结果中的相似度分数,以确定哪一个对应于合理的结果。
关于 filter
类型
您可以选择对布尔值、日期、数字、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 Vector Search 索引
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.11
、7.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
请求。
1 curl --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
类型,并将 genres
和 year
字段索引为 filter
类型。 plot_embedding
字段包含使用 OpenAI 的 text-embedding-ada-002
嵌入模型创建的嵌入。索引定义指定了 1536
个向量维度,并使用 dotProduct
函数测量相似性。
以下索引定义仅对用于执行向量Atlas Search的向量嵌入字段进行索引。
1 curl --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 。
1 curl --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 索引,请执行以下步骤:
创建 .json
文件,并在文件中定义索引。
您的索引定义应遵循以下格式:
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
的文件。
替换以下占位符值并保存文件。
| 包含要为其创建索引的集合的数据库。 |
| 要为其创建索引的集合。 |
| 索引的名称。如果省略索引名称,Atlas Vector Search 会将索引命名为 |
| Atlas Vector Search 在索引时和查询时实施的向量维度数。 |
| 要索引的向量和筛选器字段。 |
例子
将以下索引定义复制并粘贴到 vector-index.json
文件中。以下索引定义在Atlas Vector Search索引中将 plot_embedding
字段索引为 vector
类型,并将 genres
和 year
字段索引为 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 }
运行以下命令以创建索引。
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 集群搜索索引创建命令。
AtlasGoClusters在Atlas中,Go项目的 页面。
如果尚未显示,请从导航栏上的 Organizations 菜单中选择包含所需项目的组织。
如果尚未显示,请从导航栏的Projects菜单中选择所需的项目。
如果尚未出现,请单击侧边栏中的 Clusters(集群)。
会显示集群页面。
转到集群的 Atlas Search 页面。
您可以从侧边栏、 Data Explorer 或集群详细信息页面转到 Atlas Search 页面。
在侧边栏中,单击 Services 标题下的 Atlas Search。
从 Select data source 下拉菜单中选择您的集群并单击 Go to Atlas Search。
将显示 Atlas Search 页面。
单击集群的对应 Browse Collections 按钮。
展开数据库并选择集合。
单击该集合的 Search Indexes 标签页。
将显示 Atlas Search 页面。
单击集群的名称。
单击 Atlas Search 标签页。
将显示 Atlas Search 页面。
输入 Index Name(索引名称),然后设置 Database and Collection(数据库和集合)。
在 Index Name(索引名称)字段中,输入索引的名称。
无论索引类型如何,索引名称在命名空间内都必须是唯一的。
例子
输入 vector_index 作为示例索引的名称。如果此集合上已有名为 vector_index 的索引,请为该索引输入其他名称。
在 Database and Collection 部分中,找到数据库,然后选择集合。
提示
如果您从 Data Explorer导航到此页面,则可以跳过此步骤,因为 Atlas 会预先选择您在 Data Explorer 中选择的数据库和集合。
例子
在 Database and Collection(数据库和集合)部分中找到
sample_mflix
数据库,然后选择embedded_movies
集合。
指定索引定义。
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
类型,并将 genres
和 year
字段索引为 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 }
要为使用 mongosh
v2.1.2 或更高版本的集合创建 Atlas Search 索引,请执行以下步骤:
使用 mongosh
连接到 Atlas 集群。
要了解更多信息,请参阅通过 mongosh
进行连接。
运行 db.collection.createSearchIndex()
方法。
db.collection.createSearchIndex()
方法使用的语法如下:
1 db.<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
类型,并将 genres
和 year
字段索引为 filter
类型。 plot_embedding
字段包含使用 OpenAI 的 text-embedding-ada-002
嵌入模型创建的嵌入。索引定义指定了 1536
个向量维度,并使用 dotProduct
函数测量相似性。
以下索引定义仅对用于执行向量Atlas Search的向量嵌入字段进行索引。
1 db.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 。
1 db.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 索引,请执行以下步骤:
创建 .go
文件,并在文件中定义索引。
1 package main 2 3 import ( 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 13 func 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
的文件。
替换以下值并保存文件。
| Atlas连接string 。 要了解更多信息,请参阅通过驱动程序连接。 |
| 包含要为其创建索引的集合的数据库。 |
| 要为其创建索引的集合。 |
| 索引的名称。 如果省略索引名称,Atlas Search 会将索引命名为 |
| Atlas Vector Search 在索引时和查询时实施的向量维度数。 |
| 要索引的向量和筛选器字段。 |
例子
将以下内容复制并粘贴到 vector-index.go
文件,并替换 <connectionString>
占位符值。以下索引定义在Atlas Vector Search索引中将 plot_embedding
字段索引为 vector
类型,并将 genres
和 year
字段索引为 filter
类型。 plot_embedding
字段包含使用 OpenAI 的 text-embedding-ada-002
嵌入模型创建的嵌入。索引定义指定了 1536
个向量维度,并使用 dotProduct
函数测量相似度。
以下索引定义仅对用于执行向量Atlas Search的向量嵌入字段 (plot_embedding
) 编制索引。
1 package main 2 3 import ( 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 14 func 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 。
1 package main 2 3 import ( 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 14 func 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 }
要使用 MongoDB Java 驱动程序 v5.2.0 或更高版本为集合创建 Atlas Vector Search 索引,请执行以下步骤:
创建 .java
文件,并在文件中定义索引。
1 import com.mongodb.client.ListSearchIndexesIterable; 2 import com.mongodb.client.MongoClient; 3 import com.mongodb.client.MongoClients; 4 import com.mongodb.client.MongoCollection; 5 import com.mongodb.client.MongoCursor; 6 import com.mongodb.client.MongoDatabase; 7 import com.mongodb.client.model.SearchIndexModel; 8 import com.mongodb.client.model.SearchIndexType; 9 import org.bson.Document; 10 import org.bson.conversions.Bson; 11 12 import java.util.Arrays; 13 import java.util.Collections; 14 import java.util.List; 15 16 public 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 }
替换以下值并保存文件。
| Atlas连接string 。 要了解更多信息,请参阅通过驱动程序连接。 |
| 包含要为其创建索引的集合的数据库。 |
| 要为其创建索引的集合。 |
| 索引的名称。 如果省略索引名称,Atlas Search 会将索引命名为 |
| Atlas Vector Search 在索引时和查询时实施的向量维度数。 |
| 要索引的向量和筛选器字段。 |
以下是索引定义示例:
在 Atlas Vector Search 索引中,将
plot_embedding
字段作为vector
类型,并将genres
和year
字段作为filter
类型进行索引。将
plot_embedding
字段指定为向量嵌入字段,其中包含使用 OpenAI 的text-embedding-ada-002
嵌入模型创建的嵌入。指定
1536
向量维度并使用dotProduct
函数衡量相似性。
此索引定义仅对向量嵌入字段 (plot_embedding
) 进行索引以执行向量搜索。
将以下内容复制并粘贴到您创建的文件中,然后替换 <connectionString>
占位符值。
1 import com.mongodb.client.ListSearchIndexesIterable; 2 import com.mongodb.client.MongoClient; 3 import com.mongodb.client.MongoClients; 4 import com.mongodb.client.MongoCollection; 5 import com.mongodb.client.MongoCursor; 6 import com.mongodb.client.MongoDatabase; 7 import com.mongodb.client.model.SearchIndexModel; 8 import com.mongodb.client.model.SearchIndexType; 9 import org.bson.Document; 10 import org.bson.conversions.Bson; 11 12 import java.util.Collections; 13 import java.util.List; 14 15 public 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>
占位符值。
1 import com.mongodb.client.ListSearchIndexesIterable; 2 import com.mongodb.client.MongoClient; 3 import com.mongodb.client.MongoClients; 4 import com.mongodb.client.MongoCollection; 5 import com.mongodb.client.MongoCursor; 6 import com.mongodb.client.MongoDatabase; 7 import com.mongodb.client.model.SearchIndexModel; 8 import com.mongodb.client.model.SearchIndexType; 9 import org.bson.Document; 10 import org.bson.conversions.Bson; 11 12 import java.util.Arrays; 13 import java.util.Collections; 14 import java.util.List; 15 16 public 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 }
要使用MongoDB 节点驱动程序v 6.6.0或更高版本为集合创建 Atlas Vector Search 索引,请执行以下步骤:
创建 .js
文件,并在文件中定义索引。
1 const { MongoClient } = require("mongodb"); 2 3 // connect to your Atlas deployment 4 const uri = "<connectionString>"; 5 6 const client = new MongoClient(uri); 7 8 async 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 } 57 run().catch(console.dir);
例子
创建一个名为 vector-index.js
的文件。
替换以下值并保存文件。
| Atlas连接string 。 要了解更多信息,请参阅通过驱动程序连接。 |
| 包含要为其创建索引的集合的数据库。 |
| 要为其创建索引的集合。 |
| 索引的名称。 如果省略索引名称,Atlas Search 会将索引命名为 |
| Atlas Vector Search 在索引时和查询时实施的向量维度数。 |
| 要索引的向量和筛选器字段。 |
例子
将以下内容复制并粘贴到 vector-index.js
文件,并替换 <connectionString>
占位符值。以下索引定义在Atlas Vector Search索引中将 plot_embedding
字段索引为 vector
类型,并将 genres
和 year
字段索引为 filter
类型。 plot_embedding
字段包含使用 OpenAI 的 text-embedding-ada-002
嵌入模型创建的嵌入。索引定义指定了 1536
个向量维度,并使用 dotProduct
函数测量相似度。
以下索引定义仅对用于执行向量Atlas Search的向量嵌入字段 (plot_embedding
) 编制索引。
1 const { MongoClient } = require("mongodb"); 2 3 // connect to your Atlas deployment 4 const uri = "<connectionString>"; 5 6 const client = new MongoClient(uri); 7 8 async 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 } 53 run().catch(console.dir);
此索引定义对以下字段进行索引:
用于预过滤数据的 string 字段 (
genres
) 和数字字段 (year
)。向量嵌入字段 (
plot_embedding
),用于针对预筛选数据执行向量Atlas Search 。
1 const { MongoClient } = require("mongodb"); 2 3 // connect to your Atlas deployment 4 const uri = "<connectionString>"; 5 6 const client = new MongoClient(uri); 7 8 async 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 } 61 run().catch(console.dir);
要使用PyMongo驱动程序 v 4.7或更高版本为集合创建 Atlas Vector Search 索引,请执行以下步骤:
创建 .py
文件,并在文件中定义索引。
1 import pymongo 2 from pymongo.mongo_client import MongoClient 3 from pymongo.operations import SearchIndexModel 4 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 model, then create the search index 14 search_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 34 result = collection.create_search_index(model=search_index_model) 35 print("New search index named " + result + " is building.") 36 37 # Wait for initial sync to complete 38 print("Polling to check if the index is ready. This may take up to a minute.") 39 predicate=None 40 if predicate is None: 41 predicate = lambda index: index.get("queryable") is True 42 43 while True: 44 indices = list(collection.list_search_indexes(result)) 45 if len(indices) and predicate(indices[0]): 46 break 47 time.sleep(5) 48 print(result + " is ready for querying.") 49 50 client.close()
要了解详情,请参阅 create_search_index() 方法。
1 from pymongo.mongo_client import MongoClient 2 from pymongo.operations import SearchIndexModel 3 4 def 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
的文件。
替换以下值并保存文件。
| Atlas连接string 。 要了解更多信息,请参阅通过驱动程序连接。 |
| 包含要为其创建索引的集合的数据库。 |
| 要为其创建索引的集合。 |
| 索引的名称。 如果省略索引名称,Atlas Search 会将索引命名为 |
| Atlas Vector Search 在索引时和查询时实施的向量维度数。 |
| 要索引的向量和筛选器字段。 |
例子
将以下内容复制并粘贴到 vector-index.py
中,并替换 <connectionString>
占位符值。以下索引定义在Atlas Vector Search索引中将 plot_embedding
字段索引为 vector
类型,并将 genres
和 year
字段索引为 filter
类型。 plot_embedding
字段包含使用 OpenAI 的 text-embedding-ada-002
嵌入模型创建的嵌入。索引定义指定了 1536
个向量维度,并使用 dotProduct
函数测量相似度。
以下索引定义仅对用于执行向量Atlas Search的向量嵌入字段 (plot_embedding
) 编制索引。
1 from pymongo.mongo_client import MongoClient 2 from pymongo.operations import SearchIndexModel 3 import time 4 5 # Connect to your Atlas deployment 6 uri = "<connectionString>" 7 client = MongoClient(uri) 8 9 # Access your database and collection 10 database = client["sample_mflix"] 11 collection = database["embedded_movies"] 12 13 # Create your index model, then create the search index 14 search_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 29 result = collection.create_search_index(model=search_index_model) 30 print("New search index named " + result + " is building.") 31 # Wait for initial sync to complete 32 print("Polling to check if the index is ready. This may take up to a minute.") 33 predicate=None 34 if predicate is None: 35 predicate = lambda index: index.get("queryable") is True 36 37 while True: 38 indices = list(collection.list_search_indexes(name)) 39 if len(indices) and predicate(indices[0]): 40 break 41 time.sleep(5) 42 print(result + " is ready for querying.") 43 44 client.close()
此索引定义对以下字段进行索引:
用于预过滤数据的 string 字段 (
genres
) 和数字字段 (year
)。向量嵌入字段 (
plot_embedding
),用于针对预筛选数据执行向量Atlas Search 。
1 from pymongo.mongo_client import MongoClient 2 from pymongo.operations import SearchIndexModel 3 import time 4 5 # Connect to your Atlas deployment 6 uri = "<connectionString>" 7 client = MongoClient(uri) 8 9 # Access your database and collection 10 database = client["sample_mflix"] 11 collection = database["embedded_movies"] 12 13 # Create your index model, then create the search index 14 search_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 37 result = collection.create_search_index(model=search_index_model) 38 print("New search index named " + result + " is building.") 39 # Wait for initial sync to complete 40 print("Polling to check if the index is ready. This may take up to a minute.") 41 predicate=None 42 if predicate is None: 43 predicate = lambda index: index.get("queryable") is True 44 45 while True: 46 indices = list(collection.list_search_indexes(result)) 47 if len(indices) and predicate(indices[0]): 48 break 49 time.sleep(5) 50 print(result + " is ready for querying.") 51 52 client.close()
查看 Atlas Vector Search 索引
您可以通过 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
请求。
1 curl --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 或名称。
1 curl --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 索引,请执行以下步骤:
运行以下命令来检索集合的索引。
atlas clusters search indexes list --clusterName [cluster_name] --db <db-name> --collection <collection-name>
在命令中,替换以下占位符值:
cluster-name
- 包含索引集合的 Atlas 集群的名称。db-name
- 包含要检索其索引的集合的数据库名称。collection-name
- 要检索其索引的集合的名称。
要了解有关命令语法和参数的更多信息,请参阅 Atlas CLI 文档中的 Atlas 集群搜索索引列表命令。
AtlasGoClusters在Atlas中,Go项目的 页面。
如果尚未显示,请从导航栏上的 Organizations 菜单中选择包含所需项目的组织。
如果尚未显示,请从导航栏的Projects菜单中选择所需的项目。
如果尚未出现,请单击侧边栏中的 Clusters(集群)。
会显示集群页面。
转到集群的 Atlas Search 页面。
您可以从侧边栏、 Data Explorer 或集群详细信息页面转到 Atlas Search 页面。
在侧边栏中,单击 Services 标题下的 Atlas Search。
从 Select data source 下拉菜单中选择您的集群并单击 Go to Atlas Search。
将显示 Atlas Search 页面。
单击集群的对应 Browse Collections 按钮。
展开数据库并选择集合。
单击该集合的 Search Indexes 标签页。
将显示 Atlas Search 页面。
单击集群的名称。
单击 Atlas Search 标签页。
将显示 Atlas Search 页面。
此页面会显示页面上索引的以下详细信息:
名称 | 标识索引的标签。 |
索引类型 | 指示 Atlas Search 或 Atlas Vector Search 索引的标签。 值包括:
|
索引字段 | 包含此索引索引的字段的列表。 |
状态 | 集群主节点 (primary node in the replica set)节点上索引的当前状态。有关有效值,请参阅索引状态。 |
size | 主节点上索引的大小。 |
文档 (Document) | 已建立索引的文档数与集合中文档总数的比值。 |
操作 | 可以对索引执行的操作。 您可以: 您无法在Search Tester 用户界面中针对 |
要使用 mongosh
查看集合的 Atlas Vector Search 索引,请执行以下步骤:
使用 mongosh
连接到 Atlas 集群。
要了解更多信息,请参阅通过 mongosh
进行连接。
运行 db.collection.getSearchIndexes()
方法。
db.collection.getSearchIndexes()
方法使用的语法如下:
1 db.<collectionName>.getSearchIndexes( "<index-name>" );
要使用 MongoDB Go 驱动程序 v 1.16.0 或更高版本查看集合的 Atlas Vector Search 索引,请执行以下步骤:
创建 .go
文件并使用 SearchIndexes().List()
方法检索索引。
1 package main 2 3 import ( 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 14 func 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 }
替换以下值并保存文件。
| Atlas 连接字符串。要了解更多信息,请参阅通过驱动程序连接。 |
| 包含该集合的数据库。 |
| 要检索其索引的集合。 |
| 如果要检索特定索引,请输入索引的名称。 要返回集合上的所有索引,请省略此值。 |
要使用 MongoDB Java 驱动程序 v5.2.0 或更高版本查看集合的 Atlas Vector Search 索引,请执行以下步骤:
创建 .java
文件并使用 listSearchIndexes()
方法检索索引。
1 import com.mongodb.client.MongoClient; 2 import com.mongodb.client.MongoClients; 3 import com.mongodb.client.MongoCollection; 4 import com.mongodb.client.MongoDatabase; 5 import org.bson.Document; 6 7 public 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 }
替换以下值并保存文件。
| Atlas 连接字符串。要了解更多信息,请参阅通过驱动程序连接。 |
| 包含该集合的数据库。 |
| 要检索其索引的集合。 |
| 如果要检索特定索引,请输入索引的名称。 要返回集合上的所有索引,请省略此值。 |
要使用 MongoDB 节点驱动程序 v6.6.0 或更高版本查看集合的 Atlas Vector Search 索引,请执行以下步骤:
创建 .js
文件并使用 listSearchIndexes()
方法检索索引。
1 const { MongoClient } = require("mongodb"); 2 3 // connect to your Atlas deployment 4 const uri = "<connectionString>"; 5 6 const client = new MongoClient(uri); 7 8 async 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 } 20 run().catch(console.dir);
替换以下值并保存文件。
| Atlas 连接字符串。要了解更多信息,请参阅通过驱动程序连接。 |
| 包含该集合的数据库。 |
| 要检索其索引的集合。 |
| 如果要检索特定索引,请输入索引的名称。 要返回集合上的所有索引,请省略此值。 |
要使用 PyMongo 驱动程序 v4.7 或更高版本查看某个集合的 Atlas Vector Search 索引,请执行以下步骤:
创建 .py
文件并使用 list_search_indexes()
方法检索集合的索引。
1 from pymongo.mongo_client import MongoClient 2 3 # Connect to your Atlas deployment 4 uri = "<connectionString>" 5 client = MongoClient(uri) 6 7 # Access your database and collection 8 database = client["<databaseName>"] 9 collection = database["<collectionName>"] 10 11 # Get a list of the collection's search indexes and print them 12 cursor = collection.list_search_indexes() 13 for index in cursor: 14 print(index)
要了解更多信息,请参阅 list_search_indexes() 方法。
替换以下值并保存文件。
| Atlas 连接字符串。要了解更多信息,请参阅通过驱动程序连接。 |
| 包含该集合的数据库名称。 |
| 集合的名称。 |
编辑 Atlas Vector Search 索引
您可以通过 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 或名称。
1 curl --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 索引,请执行以下步骤:
创建一个 .json
文件,并在文件中定义索引的更改。
您的索引定义应遵循以下格式:
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 }
运行以下命令以更新索引。
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 命令。
AtlasGoClusters在Atlas中,Go项目的 页面。
如果尚未显示,请从导航栏上的 Organizations 菜单中选择包含所需项目的组织。
如果尚未显示,请从导航栏的Projects菜单中选择所需的项目。
如果尚未出现,请单击侧边栏中的 Clusters(集群)。
会显示集群页面。
转到集群的 Atlas Search 页面。
您可以从侧边栏、 Data Explorer 或集群详细信息页面转到 Atlas Search 页面。
在侧边栏中,单击 Services 标题下的 Atlas Search。
从 Select data source 下拉菜单中选择您的集群并单击 Go to Atlas Search。
将显示 Atlas Search 页面。
单击集群的对应 Browse Collections 按钮。
展开数据库并选择集合。
单击该集合的 Search Indexes 标签页。
将显示 Atlas Search 页面。
单击集群的名称。
单击 Atlas Search 标签页。
将显示 Atlas Search 页面。
编辑索引。
找到要编辑的
vectorSearch
类型索引。从该索引的 Actions 下拉列表中,单击 Edit Index。
检查当前配置设置,并根据需要进行编辑。
要了解有关 Atlas Vector Search 索引中的字段的更多信息,请参阅如何对 Vector Search 字段编制索引。
单击 Save(保存)以应用更改。
索引的状态从 Active(有效)变为 Building(正在构建)。在该状态下,您可以继续使用旧索引,因为在更新的索引可供使用之前,Atlas Vector Search 不会删除旧索引。在状态恢复为 Active(有效)后,就可以使用修改的索引了。
要使用 mongosh
编辑集合的 Atlas Vector Search 索引,请执行以下步骤:
使用 mongosh
连接到 Atlas 集群。
要了解更多信息,请参阅通过 mongosh
进行连接。
运行 db.collection.updateSearchIndex()
方法。
db.collection.updateSearchIndex()
方法使用的语法如下:
1 db.<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 索引,请执行以下步骤:
创建 go
文件,并在文件中定义索引更改。
1 package main 2 3 import ( 4 "context" 5 "fmt" 6 "log" 7 8 "go.mongodb.org/mongo-driver/mongo" 9 "go.mongodb.org/mongo-driver/mongo/options" 10 ) 11 12 func 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 }
替换以下值并保存文件。
| Atlas连接string 。 要了解更多信息,请参阅通过驱动程序连接。 |
| 包含要为其创建索引的集合的数据库。 |
| 要为其创建索引的集合。 |
| 索引的名称。 如果省略索引名称,Atlas Search 会将索引命名为 |
| Atlas Vector Search 在索引时和查询时实施的向量维度数。 |
| 要索引的向量和筛选器字段。 |
要使用 MongoDB Java 驱动程序 v5.2.0 或更高版本编辑某个集合的 Atlas Vector Search 索引,请执行以下步骤: