ベクトルAtlas Searchのフィールドにインデックスを付ける方法

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 create --clusterName [cluster_name] --file [vector_index].json

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
}

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

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
14
	ctx := context.TODO()
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.Fatal(err)
24
	}
25
	defer 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
	name, err := coll.SearchIndexes().CreateOne(ctx, indexModel)
58
	if err != nil {
59
		panic(err)
60
	}
61
	fmt.Println("Name of Index Created: " + name)
62
}

go run <file-name>.go

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(result);
37
   } finally {
38
     await client.close();
39
   }
40
}
41
run().catch(console.dir);

node <file-name>.js

python <file-name>.py

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

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

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
16
	ctx := context.TODO()
17
18
	// Replace the placeholder with your Atlas connection string
19
	const uri = "<connectionString>"
20
21
	// Connect to your Atlas cluster
22
	clientOptions := options.Client().ApplyURI(uri)
23
	client, err := mongo.Connect(ctx, clientOptions)
24
	if err != nil {
25
		log.Fatal(err)
26
	}
27
	defer client.Disconnect(ctx)
28
29
	// Set the namespace
30
	coll := client.Database("<databaseName>").Collection("<collectionName>")
31
32
	// Specify the options for the index to retrieve
33
	indexName := "<indexName>"
34
	opts := options.SearchIndexes().SetName(indexName)
35
36
	// Get the index
37
	cursor, err := coll.SearchIndexes().List(ctx, opts)
38
39
	// Print the index details to the console as JSON
40
	var results []bson.M
41
	if err := cursor.All(ctx, &results); err != nil {
42
		log.Panic(err)
43
	}
44
	res, _ := json.Marshal(results)
45
	fmt.Println(string(res))
46
}

go run <file-name>.go

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

node <file-name>.js

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)

python <file-name>.py

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

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

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
14
	ctx := context.TODO()
15
16
	// Replace the placeholder with your Atlas connection string
17
	const uri = "<connection-string>"
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.Fatal(err)
24
	}
25
	defer client.Disconnect(ctx)
26
27
	// Set the namespace
28
	coll := client.Database("<databaseName>").Collection("<collectionName>")
29
	indexName := "<indexName>"
30
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
	definition := vectorDefinition{
43
		Fields: []vectorDefinitionField{{
44
			Type:          "vector",
45
			Path:          "<fieldToIndex>",
46
			NumDimensions: <numberOfDimensions>,
47
			Similarity:    "euclidean | cosine | dotProduct"}},
48
	}
49
	coll.SearchIndexes().UpdateOne(ctx, indexName, definition)
50
51
	if err != nil {
52
		panic(err)
53
	}
54
55
	fmt.Println("Successfully updated the search index")
56
}

go run <file-name>.go

1
const { MongoClient } = require("mongodb");
2
3
// connect to your Atlas deployment
4
const uri =  "<connection-string>";
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 Search index
14
    const index = {
15
        name: "<indexName>",
16
        type: "vectorSearch",
17
        //updated search index definition
18
        definition: {
19
          "fields": [
20
            {
21
              "type": "vector",
22
              "numDimensions": <numberOfDimensions>,
23
              "path": "<field-to-index>",
24
              "similarity": "euclidean | cosine | dotProduct"
25
            },
26
            {
27
              "type": "filter",
28
              "path": "<fieldToIndex>"
29
            },
30
            ...
31
          ]
32
        }
33
    }
34
35
    // run the helper method
36
    await collection.updateSearchIndex("<index-name>", index);
37
  } finally {
38
    await client.close();
39
  }
40
}
41
run().catch(console.dir);

node <file-name>.js

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
definition = {
12
  "fields": [
13
    {
14
      "type": "vector",
15
      "numDimensions": <numberofDimensions>,
16
      "path": "<fieldToIndex>",
17
      "similarity": "euclidean | cosine | dotProduct"
18
    },
19
    {
20
      "type": "filter",
21
      "path": "<fieldToIndex>"
22
    },
23
    ...
24
  ]
25
}
26
    
27
# Update your search index
28
collection.update_search_index("<indexName>", definition)

python <file-name>.py

atlas clusters search indexes delete <indexId> [options]

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

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
14
	ctx := context.TODO()
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.Fatal(err)
24
	}
25
	defer client.Disconnect(ctx)
26
27
	// Set the namespace
28
	coll := client.Database("<databaseName>").Collection("<collectionName>")
29
	indexName := "<indexName>"
30
31
	coll.SearchIndexes().DropOne(ctx, indexName)
32
33
	if err != nil {
34
		panic(err)
35
	}
36
37
	fmt.Println("Successfully dropped the Vector Search index")
38
}