Atlas Vector Search Quick Start

1
#include <bson/bson.h>
2
#include <mongoc/mongoc.h>
3
#include <stdio.h>
4
5
int main(void) {
6
  mongoc_client_t *client;
7
  mongoc_collection_t *collection;
8
  bson_error_t error;
9
  char database_name[] = "sample_mflix";
10
  char collection_name[] = "embedded_movies";
11
  char index_name[] = "vector_index";
12
13
  mongoc_init();
14
15
  // Replace the placeholder with your Atlas connection string
16
  client =  mongoc_client_new("<connection-string>");
17
18
  // Connect to your Atlas cluster
19
  collection = mongoc_client_get_collection (client, database_name, collection_name);
20
21
  bson_t cmd;
22
  // Create search index command.
23
  {
24
    char *cmd_str = bson_strdup_printf (
25
        BSON_STR ({
26
                    "createSearchIndexes" : "%s",
27
                    "indexes" : [{
28
                      "definition": {
29
                        "fields": [{
30
                          "type": "vector",
31
                          "path": "plot_embedding",
32
                          "numDimensions": 1536,
33
                          "similarity": "dotProduct"
34
                        }]
35
                      },
36
                      "name": "%s",
37
                      "type": "vectorSearch"
38
                    }]
39
                  }),
40
        collection_name, index_name);
41
    if (!bson_init_from_json(&cmd, cmd_str, -1, &error)) {
42
      printf("Failed to initialize BSON: %s\n", error.message);
43
      bson_free(cmd_str);
44
      return 1;
45
    }
46
    bson_free (cmd_str);
47
  }
48
  if (!mongoc_collection_command_simple (collection, &cmd, NULL /* read_prefs */, NULL /* reply */, &error)) {
49
    bson_destroy (&cmd);
50
    printf ("Failed to run createSearchIndexes: %s", error.message);
51
    return 1;
52
  } else {
53
    printf ("New search index named %s is building.\n", index_name);
54
    bson_destroy (&cmd);
55
  }
56
57
  // Polling for index status
58
  printf("Polling to check if the index is ready. This may take up to a minute.\n");
59
  int queryable = 0;
60
  while (!queryable) {
61
    const char *pipeline_str = "{\"pipeline\": [{\"$listSearchIndexes\": {}}]}";
62
    bson_t pipeline;
63
    if (!bson_init_from_json(&pipeline, pipeline_str, -1, &error)) {
64
      printf("Failed to initialize pipeline BSON: %s\n", error.message);
65
      break; // Exit the loop on error
66
    }
67
    mongoc_cursor_t *cursor = mongoc_collection_aggregate(collection, MONGOC_QUERY_NONE, &pipeline, NULL, NULL);
68
    const bson_t *got;
69
    // Check if the cursor returns any documents
70
    int found_index = 0;
71
    while (mongoc_cursor_next(cursor, &got)) {
72
      bson_iter_t iter;
73
      if (bson_iter_init(&iter, got) && bson_iter_find(&iter, "name")) {
74
        const char *name = bson_iter_utf8(&iter, NULL);
75
        if (strcmp(name, index_name) == 0) {
76
          found_index = 1; // Index found
77
          bson_iter_find(&iter, "queryable");
78
          queryable = bson_iter_bool(&iter);
79
          break; // Exit the loop since we found the index
80
        }
81
      }
82
    }
83
    if (mongoc_cursor_error(cursor, &error)) {
84
      printf("Failed to run $listSearchIndexes: %s\n", error.message);
85
      break; // Exit the loop on error
86
    }
87
    if (!found_index) {
88
      printf("Index %s not found yet. Retrying...\n", index_name);
89
    }
90
    bson_destroy(&pipeline);
91
    mongoc_cursor_destroy(cursor);
92
    sleep(5); // Sleep for 5 seconds before checking again
93
  }
94
  if (queryable) {
95
    printf("%s is ready for querying.\n", index_name);
96
  } else {
97
    printf("Error occurred or index not found.\n");
98
  }
99
100
  // Cleanup
101
  mongoc_collection_destroy(collection);
102
  mongoc_client_destroy(client);
103
  mongoc_cleanup();
104
105
  return 0;
106
}

1
#include <bsoncxx/builder/basic/document.hpp>
2
#include <iostream>
3
#include <mongocxx/client.hpp>
4
#include <mongocxx/instance.hpp>
5
#include <mongocxx/search_index_view.hpp>
6
#include <mongocxx/uri.hpp>
7
#include <thread>
8
9
using bsoncxx::builder::basic::kvp;
10
using bsoncxx::builder::basic::make_array;
11
using bsoncxx::builder::basic::make_document;
12
13
int main() {
14
  try {
15
    mongocxx::instance inst{};
16
17
    // Replace the placeholder with your Atlas connection string
18
    const auto uri = mongocxx::uri{"<connection-string>"};
19
20
    // Connect to your Atlas cluster
21
    mongocxx::client conn{uri};
22
    auto db = conn["sample_mflix"];
23
    auto collection = db["embedded_movies"];
24
25
    auto siv = collection.search_indexes();
26
    std::string name = "vector_index";
27
    auto type = "vectorSearch";
28
    auto definition = make_document(
29
        kvp("fields",
30
            make_array(make_document(
31
                kvp("type", "vector"), kvp("path", "plot_embedding"),
32
                kvp("numDimensions", 1536), kvp("similarity", "dotProduct")))));
33
    auto model =
34
        mongocxx::search_index_model(name, definition.view()).type(type);
35
    siv.create_one(model);
36
    std::cout << "New search index named " << name << " is building."
37
              << std::endl;
38
39
    // Polling for index status
40
    std::cout << "Polling to check if the index is ready. This may take up to "
41
                 "a minute."
42
              << std::endl;
43
    bool queryable = false;
44
    while (!queryable) {
45
      auto indexes = siv.list();
46
      for (const auto& index : indexes) {
47
        if (index["name"].get_value() == name) {
48
          queryable = index["queryable"].get_bool();
49
        }
50
      }
51
      if (!queryable) {
52
        std::this_thread::sleep_for(std::chrono::seconds(5));
53
      }
54
    }
55
    std::cout << name << " is ready for querying." << std::endl;
56
  } catch (const std::exception& e) {
57
    std::cout << "Exception: " << e.what() << std::endl;
58
  }
59
  return 0;
60
}

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
}

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

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
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
}

1
import com.mongodb.MongoException
2
import com.mongodb.client.model.SearchIndexModel
3
import com.mongodb.client.model.SearchIndexType
4
import com.mongodb.kotlin.client.coroutine.MongoClient
5
import kotlinx.coroutines.delay
6
import kotlinx.coroutines.flow.toList
7
import org.bson.Document
8
import kotlinx.coroutines.runBlocking
9
10
fun main() {
11
    // Replace the placeholder with your MongoDB deployment's connection string
12
    val uri = "<connection-string>"
13
    val mongoClient = MongoClient.create(uri)
14
    val database = mongoClient.getDatabase("sample_mflix")
15
    val collection = database.getCollection<Document>("embedded_movies")
16
    val indexName = "vector_index"
17
    val searchIndexModel = SearchIndexModel(
18
        indexName,
19
        Document(
20
            "fields",
21
            listOf(
22
                Document("type", "vector")
23
                    .append("path", "plot_embedding")
24
                    .append("numDimensions", 1536)
25
                    .append("similarity", "dotProduct")
26
            )
27
        ),
28
        SearchIndexType.vectorSearch()
29
    )
30
31
    runBlocking {
32
        try {
33
            collection.createSearchIndexes(listOf(searchIndexModel))
34
                .collect { result ->
35
                    println("New search index named $result is building.")
36
                }
37
38
            // Polling to check if the index is queryable
39
            println("Polling to check if the index is ready. This may take up to a minute.")
40
            var isQueryable = false
41
            while (!isQueryable) {
42
                delay(5000L) // Poll every 5 seconds
43
44
                val indexes = collection.listSearchIndexes().toList()
45
                isQueryable = indexes.any { index ->
46
                    index.getString("name") == indexName && index.getBoolean("queryable")
47
                }
48
                if (isQueryable) {
49
                    println("$indexName is ready for querying.")
50
                }
51
            }
52
        } catch (me: MongoException) {
53
            System.err.println("An error occurred: $me")
54
        }
55
    }
56
    mongoClient.close()
57
}

1
import com.mongodb.MongoException
2
import com.mongodb.client.model.SearchIndexModel
3
import com.mongodb.client.model.SearchIndexType
4
import com.mongodb.kotlin.client.MongoClient
5
import org.bson.Document
6
7
fun main() {
8
    // Replace the placeholder with your MongoDB deployment's connection string
9
    val uri = "<connection-string>"
10
    val mongoClient = MongoClient.create(uri)
11
    val database = mongoClient.getDatabase("sample_mflix")
12
    val collection = database.getCollection<Document>("embedded_movies")
13
    val indexName = "vector_index"
14
    val searchIndexModel = SearchIndexModel(
15
        indexName,
16
        Document(
17
            "fields",
18
            listOf(
19
                Document("type", "vector")
20
                    .append("path", "plot_embedding")
21
                    .append("numDimensions", 1536)
22
                    .append("similarity", "dotProduct")
23
            )
24
        ),
25
        SearchIndexType.vectorSearch()
26
    )
27
28
    try {
29
        val result = collection.createSearchIndexes(
30
            listOf(searchIndexModel)
31
        )
32
        println("New search index named ${result.get(0)} is building.")
33
34
        // Polling to check if the index is queryable
35
        println("Polling to check if the index is ready. This may take up to a minute.")
36
        var isQueryable = false
37
        while (!isQueryable) {
38
            val results = collection.listSearchIndexes()
39
            results.forEach { result ->
40
                if (result.getString("name") == indexName && result.getBoolean("queryable")) {
41
                    println("$indexName is ready for querying.")
42
                    isQueryable = true
43
                } else {
44
                    Thread.sleep(5000) // Poll every 5 seconds
45
                }
46
            }
47
        }
48
    } catch (me: MongoException) {
49
        System.err.println("An error occurred: $me")
50
    }
51
    mongoClient.close()
52
}

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
<?php
2
3
require 'vendor/autoload.php';
4
5
// Replace the placeholder with your Atlas connection string
6
$uri = "<connection-string>";
7
$client = new MongoDB\Client($uri);
8
$collection = $client->sample_mflix->embedded_movies;
9
$indexName = "vector_index";
10
try {
11
    $result = $collection->createSearchIndexes(
12
        [[
13
            'name' => $indexName,
14
            'type' => 'vectorSearch',
15
            'definition' => [
16
                'fields' => [[
17
                    'type' => 'vector',
18
                    'path' => 'plot_embedding',
19
                    'numDimensions' => 1536,
20
                    'similarity' => 'dotProduct'
21
                ]]
22
            ],
23
        ]]
24
    );
25
    echo "New search index named $result[0] is building." .PHP_EOL;
26
27
    // Polling for the index to become queryable
28
    echo "Polling to check if the index is ready. This may take up to a minute." .PHP_EOL;
29
    $isIndexQueryable = false;
30
    while (!$isIndexQueryable) {
31
        // List the search indexes
32
        $searchIndexes = $collection->listSearchIndexes();
33
        // Check if the index is present and queryable
34
        foreach ($searchIndexes as $index) {
35
            if ($index->name === $indexName) {
36
                $isIndexQueryable = $index->queryable;
37
            }
38
        }
39
        if (!$isIndexQueryable) {
40
            sleep(5); // Wait for 5 seconds before polling again
41
        }
42
    }
43
    echo "$indexName is ready for querying." .PHP_EOL;
44
}
45
catch (MongoDB\Driver\Exception\Exception $e) {
46
    print 'Error creating the index: ' .$e->getMessage() .PHP_EOL;
47
}

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

1
import org.mongodb.scala._
2
import org.mongodb.scala.model._
3
import com.mongodb.client.model.SearchIndexType
4
5
class VectorIndex {
6
  def createIndex(): Unit = {
7
    val collection =
8
      MongoClient("<connection-string>")
9
        .getDatabase("sample_mflix")
10
        .getCollection("embedded_movies")
11
    val indexName = "vector_index"
12
    val indexNameAsOption = Option(indexName)
13
    val indexDefinition = Document(
14
      "fields" -> List(
15
        Document(
16
          "type" -> "vector",
17
          "path" -> "plot_embedding",
18
          "numDimensions" -> 1536,
19
          "similarity" -> "dotProduct"
20
        )
21
      )
22
    )
23
    val indexType = Option(SearchIndexType.vectorSearch())
24
    val indexModel: SearchIndexModel = SearchIndexModel(
25
      indexNameAsOption, indexDefinition, indexType
26
    )
27
    collection.createSearchIndexes(List(indexModel)).foreach { doc => println(s"New search index named $doc is building.") }
28
    Thread.sleep(2000)
29
    println("Polling to check if the index is ready. This may take up to a minute.")
30
    var indexReady = false
31
    while (!indexReady) {
32
      val searchIndexes = collection.listSearchIndexes()
33
      searchIndexes.foreach { current =>
34
        val document = current.toBsonDocument()
35
        val name = document.get("name").asString().getValue
36
        val queryable = document.get("queryable").asBoolean().getValue
37
        if (name == indexName && queryable) {
38
          indexReady = true
39
        }
40
      }
41
      if (!indexReady) {
42
        Thread.sleep(5000)
43
      }
44
    }
45
    println(s"$indexName is ready for querying.")
46
  }
47
}

1
#include <bson/bson.h>
2
#include <mongoc/mongoc.h>
3
#include <stdio.h>
4
5
int main(void) {
6
  mongoc_client_t *client;
7
  mongoc_collection_t *collection;
8
  bson_error_t error;
9
  char database_name[] = "sample_mflix";
10
  char collection_name[] = "embedded_movies";
11
  char index_name[] = "vector_index";
12
13
  mongoc_init();
14
15
  // Replace the placeholder with your Atlas connection string
16
  client =  mongoc_client_new("<connection-string>");
17
18
  // Connect to your Atlas cluster
19
  collection = mongoc_client_get_collection (client, database_name, collection_name);
20
21
  bson_t cmd;
22
  // Create search index command.
23
  {
24
    char *cmd_str = bson_strdup_printf (
25
        BSON_STR ({
26
                    "createSearchIndexes" : "%s",
27
                    "indexes" : [{
28
                      "definition": {
29
                        "fields": [{
30
                          "type": "vector",
31
                          "path": "plot_embedding",
32
                          "numDimensions": 1536,
33
                          "similarity": "dotProduct"
34
                        }]
35
                      },
36
                      "name": "%s",
37
                      "type": "vectorSearch"
38
                    }]
39
                  }),
40
        collection_name, index_name);
41
    if (!bson_init_from_json(&cmd, cmd_str, -1, &error)) {
42
      printf("Failed to initialize BSON: %s\n", error.message);
43
      bson_free(cmd_str);
44
      return 1;
45
    }
46
    bson_free (cmd_str);
47
  }
48
  if (!mongoc_collection_command_simple (collection, &cmd, NULL /* read_prefs */, NULL /* reply */, &error)) {
49
    bson_destroy (&cmd);
50
    printf ("Failed to run createSearchIndexes: %s", error.message);
51
    return 1;
52
  } else {
53
    printf ("New search index named %s is building.\n", index_name);
54
    bson_destroy (&cmd);
55
  }
56
57
  // Polling for index status
58
  printf("Polling to check if the index is ready. This may take up to a minute.\n");
59
  int queryable = 0;
60
  while (!queryable) {
61
    const char *pipeline_str = "{\"pipeline\": [{\"$listSearchIndexes\": {}}]}";
62
    bson_t pipeline;
63
    if (!bson_init_from_json(&pipeline, pipeline_str, -1, &error)) {
64
      printf("Failed to initialize pipeline BSON: %s\n", error.message);
65
      break; // Exit the loop on error
66
    }
67
    mongoc_cursor_t *cursor = mongoc_collection_aggregate(collection, MONGOC_QUERY_NONE, &pipeline, NULL, NULL);
68
    const bson_t *got;
69
    // Check if the cursor returns any documents
70
    int found_index = 0;
71
    while (mongoc_cursor_next(cursor, &got)) {
72
      bson_iter_t iter;
73
      if (bson_iter_init(&iter, got) && bson_iter_find(&iter, "name")) {
74
        const char *name = bson_iter_utf8(&iter, NULL);
75
        if (strcmp(name, index_name) == 0) {
76
          found_index = 1; // Index found
77
          bson_iter_find(&iter, "queryable");
78
          queryable = bson_iter_bool(&iter);
79
          break; // Exit the loop since we found the index
80
        }
81
      }
82
    }
83
    if (mongoc_cursor_error(cursor, &error)) {
84
      printf("Failed to run $listSearchIndexes: %s\n", error.message);
85
      break; // Exit the loop on error
86
    }
87
    if (!found_index) {
88
      printf("Index %s not found yet. Retrying...\n", index_name);
89
    }
90
    bson_destroy(&pipeline);
91
    mongoc_cursor_destroy(cursor);
92
    sleep(5); // Sleep for 5 seconds before checking again
93
  }
94
  if (queryable) {
95
    printf("%s is ready for querying.\n", index_name);
96
  } else {
97
    printf("Error occurred or index not found.\n");
98
  }
99
100
  // Cleanup
101
  mongoc_collection_destroy(collection);
102
  mongoc_client_destroy(client);
103
  mongoc_cleanup();
104
105
  return 0;
106
}

1
#include <bsoncxx/builder/basic/document.hpp>
2
#include <iostream>
3
#include <mongocxx/client.hpp>
4
#include <mongocxx/instance.hpp>
5
#include <mongocxx/search_index_view.hpp>
6
#include <mongocxx/uri.hpp>
7
#include <thread>
8
9
using bsoncxx::builder::basic::kvp;
10
using bsoncxx::builder::basic::make_array;
11
using bsoncxx::builder::basic::make_document;
12
13
int main() {
14
  try {
15
    mongocxx::instance inst{};
16
17
    // Replace the placeholder with your Atlas connection string
18
    const auto uri = mongocxx::uri{"<connection-string>"};
19
20
    // Connect to your Atlas cluster
21
    mongocxx::client conn{uri};
22
    auto db = conn["sample_mflix"];
23
    auto collection = db["embedded_movies"];
24
25
    auto siv = collection.search_indexes();
26
    std::string name = "vector_index";
27
    auto type = "vectorSearch";
28
    auto definition = make_document(
29
        kvp("fields",
30
            make_array(make_document(
31
                kvp("type", "vector"), kvp("path", "plot_embedding"),
32
                kvp("numDimensions", 1536), kvp("similarity", "dotProduct")))));
33
    auto model =
34
        mongocxx::search_index_model(name, definition.view()).type(type);
35
    siv.create_one(model);
36
    std::cout << "New search index named " << name << " is building."
37
              << std::endl;
38
39
    // Polling for index status
40
    std::cout << "Polling to check if the index is ready. This may take up to "
41
                 "a minute."
42
              << std::endl;
43
    bool queryable = false;
44
    while (!queryable) {
45
      auto indexes = siv.list();
46
      for (const auto& index : indexes) {
47
        if (index["name"].get_value() == name) {
48
          queryable = index["queryable"].get_bool();
49
        }
50
      }
51
      if (!queryable) {
52
        std::this_thread::sleep_for(std::chrono::seconds(5));
53
      }
54
    }
55
    std::cout << name << " is ready for querying." << std::endl;
56
  } catch (const std::exception& e) {
57
    std::cout << "Exception: " << e.what() << std::endl;
58
  }
59
  return 0;
60
}