벡터 검색을 위해 필드를 인덱싱하는 방법

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

using query_quick_start;
var indexService = new IndexService();
indexService.CreateVectorIndex();

dotnet run

1
package main
2
3
import (
4
	"context"
5
	"fmt"
6
	"log"
7
8
	"go.mongodb.org/mongo-driver/v2/bson"
9
	"go.mongodb.org/mongo-driver/v2/mongo"
10
	"go.mongodb.org/mongo-driver/v2/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(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
}

go run create-index.go

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 com.mongodb.client.model.SearchIndexModel;
6
import com.mongodb.client.model.SearchIndexType;
7
import org.bson.Document;
8
import org.bson.conversions.Bson;
9
10
import java.util.Arrays;
11
import java.util.Collections;
12
import java.util.List;
13
14
public class VectorIndex {
15
16
    public static void main(String[] args) {
17
18
        // Replace the placeholder with your Atlas connection string
19
        String uri = "<connectionString>";
20
21
        // Connect to your Atlas cluster
22
        try (MongoClient mongoClient = MongoClients.create(uri)) {
23
24
            // Set the namespace
25
            MongoDatabase database = mongoClient.getDatabase("<databaseName>");
26
            MongoCollection<Document> collection = database.getCollection("<collectionName>");
27
28
            // Define the index details
29
            String indexName = "<indexName>";
30
            Bson definition = new Document(
31
                "fields",
32
                Arrays.asList(
33
                    new Document("type", "vector")
34
                        .append("path", "<fieldToIndex>")
35
                        .append("numDimensions", <numberOfDimensions>)
36
                        .append("similarity", "euclidean | cosine | dotProduct"),
37
                    new Document("type", "filter")
38
                        .append("path", "<fieldToIndex>"),
39
                    ...));
40
41
            // Define the index model
42
            SearchIndexModel indexModel = new SearchIndexModel(
43
                indexName,
44
                definition,
45
                SearchIndexType.vectorSearch()
46
            );
47
48
             // Create the index using the defined model
49
            List<String> result = collection.createSearchIndexes(Collections.singletonList(indexModel));
50
            System.out.println("Successfully created vector index named: " + result.get(0));
51
            System.out.println("It may take up to a minute for the index to leave the BUILDING status and become queryable.");
52
53
            // Wait for Atlas to build the index
54
            System.out.println("Polling to confirm the index has left the BUILDING status.");
55
            // No special handling in case of a timeout. Custom handling can be implemented.           
56
            waitForIndex(collection, indexName);
57
        }
58
    }
59
60
    /**
61
     * Polls the collection to check whether the specified index is ready to query.
62
     */
63
    public static <T> boolean waitForIndex(final MongoCollection<T> collection, final String indexName) {
64
        long startTime = System.nanoTime();
65
        long timeoutNanos = TimeUnit.SECONDS.toNanos(60);
66
        while (System.nanoTime() - startTime < timeoutNanos) {
67
            Document indexRecord = StreamSupport.stream(collection.listSearchIndexes().spliterator(), false)
68
                    .filter(index -> indexName.equals(index.getString("name")))
69
                    .findAny().orElse(null);
70
            if (indexRecord != null) {
71
                if ("FAILED".equals(indexRecord.getString("status"))) {
72
                    throw new RuntimeException("Search index has FAILED status.");
73
                }
74
                if (indexRecord.getBoolean("queryable")) {
75
                    System.out.println(indexName + " index is ready to query");
76
                    return true;
77
                }
78
            }
79
            try {
80
                Thread.sleep(100); // busy-wait, avoid in production
81
            } catch (InterruptedException e) {
82
                Thread.currentThread().interrupt();
83
                throw new RuntimeException(e);
84
            }
85
        }
86
        return false;
87
    }
88
}

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