ベクトル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
}

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
}

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

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
}

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

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

1
namespace query_quick_start;
2
3
using MongoDB.Bson;
4
using MongoDB.Driver;
5
using System;
6
using System.Threading;
7
8
public class IndexService
9
{
10
    // Replace the placeholder with your Atlas connection string
11
    private const string MongoConnectionString = "<connection-string>";
12
    public void CreateVectorIndex()
13
    {
14
        try
15
        {
16
            // Connect to your Atlas cluster
17
            var client = new MongoClient(MongoConnectionString);
18
            var database = client.GetDatabase("sample_mflix");
19
            var collection = database.GetCollection<BsonDocument>("embedded_movies");
20
21
            var searchIndexView = collection.SearchIndexes;
22
            var name = "vector_index";
23
            var type = SearchIndexType.VectorSearch;
24
25
            var definition = new BsonDocument
26
            {
27
                { "fields", new BsonArray
28
                    {
29
                        new BsonDocument
30
                        {
31
                            { "type", "vector" },
32
                            { "path", "plot_embedding" },
33
                            { "numDimensions", 1536 },
34
                            { "similarity", "dotProduct" }
35
                        }
36
                    }
37
                }
38
            };
39
40
            var model = new CreateSearchIndexModel(name, type, definition);
41
42
            searchIndexView.CreateOne(model);
43
            Console.WriteLine($"New search index named {name} is building.");
44
45
            // Polling for index status
46
            Console.WriteLine("Polling to check if the index is ready. This may take up to a minute.");
47
            bool queryable = false;
48
            while (!queryable)
49
            {
50
                var indexes = searchIndexView.List();
51
                foreach (var index in indexes.ToEnumerable())
52
                {
53
                    if (index["name"] == name)
54
                    {
55
                        queryable = index["queryable"].AsBoolean;
56
                    }
57
                }
58
                if (!queryable)
59
                {
60
                    Thread.Sleep(5000);
61
                }
62
            }
63
            Console.WriteLine($"{name} is ready for querying.");
64
        }
65
        catch (Exception e)
66
        {
67
            Console.WriteLine($"Exception: {e.Message}");
68
        }
69
    }
70
}

1
namespace query_quick_start;
2
3
using MongoDB.Bson;
4
using MongoDB.Driver;
5
using System;
6
using System.Threading;
7
8
public class IndexService
9
{
10
    // Replace the placeholder with your Atlas connection string
11
    private const string MongoConnectionString = "<connection-string>";
12
    public void CreateVectorIndex()
13
    {
14
        try
15
        {
16
            // Connect to your Atlas cluster
17
            var client = new MongoClient(MongoConnectionString);
18
            var database = client.GetDatabase("sample_mflix");
19
            var collection = database.GetCollection<BsonDocument>("embedded_movies");
20
21
            var searchIndexView = collection.SearchIndexes;
22
            var name = "vector_index";
23
            var type = SearchIndexType.VectorSearch;
24
25
            var definition = new BsonDocument
26
            {
27
                { "fields", new BsonArray
28
                    {
29
                        new BsonDocument
30
                        {
31
                            { "type", "vector" },
32
                            { "path", "plot_embedding" },
33
                            { "numDimensions", 1536 },
34
                            { "similarity", "dotProduct" }
35
                        },
36
                        new BsonDocument
37
                        {
38
                            {"type", "filter"},
39
                            {"path", "genres"}
40
                        },
41
                        new BsonDocument
42
                        {
43
                            {"type", "filter"},
44
                            {"path", "year"}
45
                        }
46
                    }
47
                }
48
            };
49
50
            var model = new CreateSearchIndexModel(name, type, definition);
51
52
            searchIndexView.CreateOne(model);
53
            Console.WriteLine($"New search index named {name} is building.");
54
55
            // Polling for index status
56
            Console.WriteLine("Polling to check if the index is ready. This may take up to a minute.");
57
            bool queryable = false;
58
            while (!queryable)
59
            {
60
                var indexes = searchIndexView.List();
61
                foreach (var index in indexes.ToEnumerable())
62
                {
63
                    if (index["name"] == name)
64
                    {
65
                        queryable = index["queryable"].AsBoolean;
66
                    }
67
                }
68
                if (!queryable)
69
                {
70
                    Thread.Sleep(5000);
71
                }
72
            }
73
            Console.WriteLine($"{name} is ready for querying.");
74
        }
75
        catch (Exception e)
76
        {
77
            Console.WriteLine($"Exception: {e.Message}");
78
        }
79
    }
80
}

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
}

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
}

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

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