Vector Quantization

Create your Java project and install dependencies.

1. From your IDE, create a Java project using Maven or Gradle.

2. Add the following dependencies, depending on your package manager:

   Maven

   Gradle

   If you are using Maven, add the following dependencies to the dependencies array in your project's pom.xml file:

   pom.xml

   <dependencies>
       <dependency>
           <groupId>junit</groupId>
           <artifactId>junit</artifactId>
           <version>4.13.2</version>
           <scope>test</scope>
       </dependency>
       <dependency>
           <groupId>org.mongodb</groupId>
           <artifactId>mongodb-driver-sync</artifactId>
           <version>5.3.1</version>
       </dependency>
       <dependency>
           <groupId>com.cohere</groupId>
           <artifactId>cohere-java</artifactId>
           <version>1.6.0</version>
       </dependency>
       <dependency>
           <groupId>org.slf4j</groupId>
           <artifactId>slf4j-api</artifactId>
           <version>2.0.16</version>
       </dependency>
       <dependency>
           <groupId>org.slf4j</groupId>
           <artifactId>slf4j-simple</artifactId>
           <version>2.0.16</version>
           <scope>test</scope>
       </dependency>
   </dependencies>

   If you are using Gradle, add the following to the dependencies array in your project's build.gradle file:

   build.gradle

   dependencies {
       // MongoDB Java Sync Driver v5.3.1 or later
       implementation 'org.mongodb:mongodb-driver-sync:[5.3.1,)'
       // Java library for working with Cohere models
       implementation 'ai.cohere:cohere-java:1.6.0'
       // SLF4J (The Simple Logging Facade for Java)
       testImplementation("org.slf4j:slf4j-simple:2.0.16")
       implementation("org.slf4j:slf4j-api:2.0.16")
   }

3. Run your package manager to install the dependencies to your project.

Set your environment variables.

In your IDE, create a new configuration template and add the following variables to your project:

• If you are using IntelliJ IDEA, create a new Application run configuration template, then add your variables as semicolon-separated values in the Environment variables field (for example, FOO=123;BAR=456). Apply the changes and click OK.

  To learn more, see the Create a run/debug configuration from a template section of the IntelliJ IDEA documentation.

• If you are using Eclipse, create a new Java Application launch configuration, then add each variable as a new key-value pair in the Environment tab. Apply the changes and click OK.

  To learn more, see the Creating a Java application launch configuration section of the Eclipse IDE documentation.

COHERE_API_KEY=<api-key>
MONGODB_URI=<connection-string>

Update the placeholders with the following values:

• Replace the <api-key> placeholder value with your Cohere API key.

• Replace the <connection-string> placeholder value with the SRV connection string for your Atlas cluster.

  Your connection string should use the following format:

  mongodb+srv://<db_username>:<db_password>@<clusterName>.<hostname>.mongodb.net

Generate embeddings from your data.

You can use an embedding model provider to generate float, int8, and int1 embeddings for your data and then use the MongoDB Java driver to convert your native vector embedding to BSON vectors. The following sample code uses Cohere's embed API to generate full-precision vectors.

1. Create a new file named GenerateAndConvertEmbeddings.java in your Java project.

   touch GenerateAndConvertEmbeddings.java

2. Copy and paste the following code in the GenerateAndConvertEmbeddings.java file.

   This code does the following:

   • Generates the float32, int8, and ubinary vector embeddings by using Cohere's embed API.

   • Converts the embeddings to BSON binData vectors by using MongoDB Java driver.

   • Creates a file named embeddings.json and saves the data with embeddings in the file to upload to Atlas.

   GenerateAndConvertEmbeddings.java

   1
   import com.cohere.api.Cohere;
   2
   import com.cohere.api.requests.EmbedRequest;
   3
   import com.cohere.api.types.EmbedByTypeResponse;
   4
   import com.cohere.api.types.EmbedByTypeResponseEmbeddings;
   5
   import com.cohere.api.types.EmbedInputType;
   6
   import com.cohere.api.types.EmbedResponse;
   7
   import com.cohere.api.types.EmbeddingType;
   8
   import java.io.FileOutputStream;
   9
   import java.io.IOException;
   10
   import java.util.ArrayList;
   11
   import java.util.List;
   12
   import java.util.Objects;
   13
   import java.util.Optional;
   14
   import org.bson.BinaryVector;
   15
   import org.bson.Document;
   16
   17
   public class GenerateAndConvertEmbeddings {
   18
   19
       // List of text data to embed
   20
       private static final List<String> DATA = List.of(
   21
           "The Great Wall of China is visible from space.",
   22
           "The Eiffel Tower was completed in Paris in 1889.",
   23
           "Mount Everest is the highest peak on Earth at 8,848m.",
   24
           "Shakespeare wrote 37 plays and 154 sonnets during his lifetime.",
   25
           "The Mona Lisa was painted by Leonardo da Vinci."
   26
       );
   27
   28
       public static void main(String[] args) {
   29
           // Cohere API key for authentication
   30
           String apiKey = System.getenv("COHERE_API_KEY");
   31
   32
           // Fetch embeddings from the Cohere API
   33
           EmbedByTypeResponseEmbeddings embeddings = fetchEmbeddingsFromCohere(apiKey);
   34
           Document bsonEmbeddings = convertEmbeddingsToBson(embeddings);
   35
   36
           writeEmbeddingsToFile(bsonEmbeddings, "embeddings.json");
   37
       }
   38
   39
       // Fetches embeddings based on input data from the Cohere API
   40
       private static EmbedByTypeResponseEmbeddings fetchEmbeddingsFromCohere(String apiKey) {
   41
           if (Objects.isNull(apiKey) || apiKey.isEmpty()) {
   42
               throw new RuntimeException("API key not found. Please set COHERE_API_KEY in your environment.");
   43
           }
   44
   45
           Cohere cohere = Cohere.builder().token(apiKey).clientName("embed-example").build();
   46
   47
           try {
   48
               EmbedRequest request = EmbedRequest.builder()
   49
                   .model("embed-english-v3.0")
   50
                   .inputType(EmbedInputType.SEARCH_DOCUMENT)
   51
                   .texts(DATA)
   52
                   .embeddingTypes(List.of(EmbeddingType.FLOAT, EmbeddingType.INT_8, EmbeddingType.UBINARY))
   53
                   .build();
   54
   55
               EmbedResponse response = cohere.embed(request);
   56
               Optional<EmbedByTypeResponse> optionalEmbeddingsWrapper = response.getEmbeddingsByType();
   57
   58
               return optionalEmbeddingsWrapper.orElseThrow().getEmbeddings();
   59
           } catch (Exception e) {
   60
               System.err.println("Error fetching embeddings: " + e.getMessage());
   61
               throw e;
   62
           }
   63
       }
   64
   65
       // Converts embeddings to BSON binary vectors using MongoDB Java Driver
   66
       private static Document convertEmbeddingsToBson(EmbedByTypeResponseEmbeddings embeddings) {
   67
           List<List<Double>> floatEmbeddings = embeddings.getFloat().orElseThrow();
   68
           List<List<Integer>> int8Embeddings = embeddings.getInt8().orElseThrow();
   69
           List<List<Integer>> ubinaryEmbeddings = embeddings.getUbinary().orElseThrow();
   70
   71
           List<Document> bsonEmbeddings = new ArrayList<>();
   72
           for (int i = 0; i < floatEmbeddings.size(); i++) {
   73
               Document bsonEmbedding = new Document()
   74
                   .append("text", DATA.get(i))
   75
                   .append("embeddings_float32", BinaryVector.floatVector(listToFloatArray(floatEmbeddings.get(i))))
   76
                   .append("embeddings_int8", BinaryVector.int8Vector(listToByteArray(int8Embeddings.get(i))))
   77
                   .append("embeddings_int1", BinaryVector.packedBitVector(listToByteArray(ubinaryEmbeddings.get(i)), (byte) 0));
   78
   79
               bsonEmbeddings.add(bsonEmbedding);
   80
           }
   81
   82
           return new Document("data", bsonEmbeddings);
   83
       }
   84
   85
       // Writes embeddings to JSON file
   86
       private static void writeEmbeddingsToFile(Document bsonEmbeddings, String fileName) {
   87
           try (FileOutputStream fos = new FileOutputStream(fileName)) {
   88
               fos.write(bsonEmbeddings.toJson().getBytes());
   89
               System.out.println("Embeddings saved to " + fileName);
   90
           } catch (IOException e) {
   91
               System.out.println("Error writing embeddings to file: " + e.getMessage());
   92
           }
   93
       }
   94
   95
       // Convert List of Doubles to an array of floats
   96
       private static float[] listToFloatArray(List<Double> list) {
   97
           float[] array = new float[list.size()];
   98
           for (int i = 0; i < list.size(); i++) {
   99
               array[i] = list.get(i).floatValue();
   100
           }
   101
           return array;
   102
       }
   103
   104
       // Convert List of Integers to an array of bytes
   105
       private static byte[] listToByteArray(List<Integer> list) {
   106
           byte[] array = new byte[list.size()];
   107
           for (int i = 0; i < list.size(); i++) {
   108
               array[i] = list.get(i).byteValue();
   109
           }
   110
           return array;
   111
       }
   112
   }

3. Replace the COHERE_API_KEY placeholder value in the code if you didn't set the environment variable and save the file.

4. Compile and run the file using your application run configuration.

   If you are using a terminal, run the following commands to compile and execute your program.

   javac GenerateAndConvertEmbeddings.java
   java GenerateAndConvertEmbeddings

   HIDE OUTPUT

   BSON embeddings saved to embeddings.json

5. Verify the embeddings in the embeddings.json file.

To learn more about generating embeddings and converting the embeddings to binData vectors, see How to Create Vector Embeddings.

Ingest the data and create an Atlas Vector Search index.

You must upload your data and embeddings to a collection in your Atlas cluster and create an Atlas Vector Search index on the data to run $vectorSearch queries against the data.

1. Create a new file named UploadDataAndCreateIndex.java in your Java project.

   touch UploadDataAndCreateIndex.java

2. Copy and paste the following code in the UploadDataAndCreateIndex.java file.

   This code does the following:

   • Uploads the data in the embeddings.json file to your Atlas cluster.

   • Creates an Atlas Vector Search index on the embeddings_float32, embeddings_int8, and embeddings_int1 fields.

   UploadDataAndCreateIndex.java

   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.io.IOException;
   11
   import java.nio.file.Files;
   12
   import java.nio.file.Path;
   13
   import java.util.Collections;
   14
   import java.util.List;
   15
   import java.util.concurrent.TimeUnit;
   16
   import java.util.stream.StreamSupport;
   17
   18
   public class UploadDataAndCreateIndex {
   19
   20
       private static final String MONGODB_URI = System.getenv("MONGODB_URI");
   21
       private static final String DB_NAME = "<DATABASE-NAME>";
   22
       private static final String COLLECTION_NAME = "<COLLECTION-NAME>";
   23
       private static final String INDEX_NAME = "<INDEX-NAME>";
   24
   25
       public static void main(String[] args) {
   26
           try (MongoClient mongoClient = MongoClients.create(MONGODB_URI)) {
   27
               storeEmbeddings(mongoClient);
   28
               setupVectorSearchIndex(mongoClient);
   29
           } catch (IOException | InterruptedException e) {
   30
               e.printStackTrace();
   31
           }
   32
       }
   33
   34
       public static void storeEmbeddings(MongoClient client) throws IOException {
   35
           MongoDatabase database = client.getDatabase(DB_NAME);
   36
           MongoCollection<Document> collection = database.getCollection(COLLECTION_NAME);
   37
   38
           String fileContent = Files.readString(Path.of("embeddings.json"));
   39
           List<Document> documents = parseDocuments(fileContent);
   40
   41
           collection.insertMany(documents);
   42
           System.out.println("Inserted documents into MongoDB");
   43
       }
   44
   45
       private static List<Document> parseDocuments(String jsonContent) throws IOException {
   46
           Document rootDoc = Document.parse(jsonContent);
   47
           return rootDoc.getList("data", Document.class);
   48
       }
   49
   50
       public static void setupVectorSearchIndex(MongoClient client) throws InterruptedException {
   51
           MongoDatabase database = client.getDatabase(DB_NAME);
   52
           MongoCollection<Document> collection = database.getCollection(COLLECTION_NAME);
   53
           
   54
           Bson definition = new Document(
   55
               "fields",
   56
               List.of(
   57
                   new Document("type", "vector")
   58
                       .append("path", "embeddings_float32")
   59
                       .append("numDimensions", 1024)
   60
                       .append("similarity", "dotProduct"),
   61
                   new Document("type", "vector")
   62
                       .append("path", "embeddings_int8")
   63
                       .append("numDimensions", 1024)
   64
                       .append("similarity", "dotProduct"),
   65
                   new Document("type", "vector")
   66
                       .append("path", "embeddings_int1")
   67
                       .append("numDimensions", 1024)
   68
                       .append("similarity", "euclidean")
   69
               )
   70
           );
   71
           
   72
           SearchIndexModel indexModel = new SearchIndexModel(
   73
               INDEX_NAME,
   74
               definition,
   75
               SearchIndexType.vectorSearch()
   76
           );
   77
           
   78
           List<String> result = collection.createSearchIndexes(Collections.singletonList(indexModel));
   79
           System.out.println("Successfully created vector index named: " + result.get(0));
   80
           System.out.println("It may take up to a minute for the index to leave the BUILDING status and become queryable.");
   81
           
   82
           System.out.println("Polling to confirm the index has changed from the BUILDING status.");
   83
           waitForIndex(collection, INDEX_NAME);
   84
       }
   85
   86
       public static <T> boolean waitForIndex(final MongoCollection<T> collection, final String indexName) {
   87
           long startTime = System.nanoTime();
   88
           long timeoutNanos = TimeUnit.SECONDS.toNanos(60);
   89
           while (System.nanoTime() - startTime < timeoutNanos) {
   90
               Document indexRecord = StreamSupport.stream(collection.listSearchIndexes().spliterator(), false)
   91
                       .filter(index -> indexName.equals(index.getString("name")))
   92
                       .findAny().orElse(null);
   93
               if (indexRecord != null) {
   94
                   if ("FAILED".equals(indexRecord.getString("status"))) {
   95
                       throw new RuntimeException("Search index has FAILED status.");
   96
                   }
   97
                   if (indexRecord.getBoolean("queryable")) {
   98
                       System.out.println(indexName + " index is ready to query");
   99
                       return true;
   100
                   }
   101
               }
   102
               try {
   103
                   Thread.sleep(100); // busy-wait, avoid in production
   104
               } catch (InterruptedException e) {
   105
                   Thread.currentThread().interrupt();
   106
                   throw new RuntimeException(e);
   107
               }
   108
           }
   109
           return false;
   110
       }
   111
   }

3. Replace the following placeholder values in the code and save the file.

   MONGODB_URI	Your Atlas cluster connection string if you didn't set the environment variable.
   <DATABASE-NAME>	Name of the database in your Atlas cluster.
   <COLLECTION-NAME>	Name of the collection where you want to upload the data.
   <INDEX-NAME>	Name of the Atlas Vector Search index for the collection.

4. Compile and run the file using your application run configuration.

   If you are using a terminal, run the following commands to compile and execute your program.

   javac UploadDataAndCreateIndex.java
   java UploadDataAndCreateIndex

   HIDE OUTPUT

   Inserted documents into MongoDB
   Successfully created vector index named: <INDEX_NAME>
   It may take up to a minute for the index to leave the BUILDING status and become queryable.
   Polling to confirm the index has changed from the BUILDING status.
   <INDEX_NAME> index is ready to query

5. Log in to your Atlas cluster and verify the following:

   • Data in the namespace.

   • Atlas Vector Search index for the collection.

Create and run a query against the collection.

To test your embeddings, you can run a query against your collection. Use an embedding model provider to generate float, int8, and int1 embeddings for your query text. The following sample code uses Cohere's embed API to generate full-precision vectors. After generating the embeddings, use the MongoDB Java driver to convert your native vector embedding to BSON vectors and run $vectorSearch query against the collection.

1. Create a new file named CreateEmbeddingsAndRunQuery.java in your Java project.

   touch CreateEmbeddingsAndRunQuery.java

2. Copy and paste the following code in the CreateEmbeddingsAndRunQuery.java file.

   This code does the following:

   • Generates the float32, int8, and ubinary vector embeddings by using Cohere's embed API.

   • Converts the embeddings to BSON binData vectors by using MongoDB Java driver.

   • Runs the query against your collection.

   CreateEmbeddingsAndRunQuery.java

   1
   import com.cohere.api.Cohere;
   2
   import com.cohere.api.requests.EmbedRequest;
   3
   import com.cohere.api.types.EmbedResponse;
   4
   import com.cohere.api.types.EmbedByTypeResponse;
   5
   import com.cohere.api.types.EmbedByTypeResponseEmbeddings;
   6
   import com.cohere.api.types.EmbeddingType;
   7
   import com.cohere.api.types.EmbedInputType;
   8
   import com.mongodb.client.MongoClient;
   9
   import com.mongodb.client.MongoClients;
   10
   import com.mongodb.client.MongoCollection;
   11
   import com.mongodb.client.MongoDatabase;
   12
   import org.bson.Document;
   13
   import org.bson.conversions.Bson;
   14
   import org.bson.BinaryVector;
   15
   16
   import java.util.ArrayList;
   17
   import java.util.HashMap;
   18
   import java.util.List;
   19
   import java.util.Map;
   20
   import java.util.Optional;
   21
   22
   import static com.mongodb.client.model.Aggregates.project;
   23
   import static com.mongodb.client.model.Aggregates.vectorSearch;
   24
   import static com.mongodb.client.model.Projections.fields;
   25
   import static com.mongodb.client.model.Projections.include;
   26
   import static com.mongodb.client.model.Projections.exclude;
   27
   import static com.mongodb.client.model.Projections.metaVectorSearchScore;
   28
   import static com.mongodb.client.model.search.SearchPath.fieldPath;
   29
   import static com.mongodb.client.model.search.VectorSearchOptions.approximateVectorSearchOptions;
   30
   import static java.util.Arrays.asList;
   31
   32
   public class CreateEmbeddingsAndRunQuery {
   33
       private static final String COHERE_API_KEY = System.getenv("COHERE_API_KEY");
   34
       private static final String MONGODB_URI = System.getenv("MONGODB_URI");
   35
       private static final String DB_NAME = "<DATABASE-NAME>";
   36
       private static final String COLLECTION_NAME = "<COLLECTION-NAME>";
   37
       private static final String VECTOR_INDEX_NAME = "<INDEX-NAME>";
   38
       private static final String DATA_FIELD_NAME = "<DATA-FIELD>";
   39
   40
       public static void main(String[] args) {
   41
           String queryText = "<QUERY-TEXT>";
   42
   43
           try {
   44
               CreateAndRunQuery processor = new CreateAndRunQuery();
   45
               Map<String, BinaryVector> embeddingsData = processor.generateAndConvertEmbeddings(queryText);
   46
               processor.runVectorSearchQuery(embeddingsData);
   47
           } catch (Exception e) {
   48
               e.printStackTrace();
   49
           }
   50
       }
   51
   52
       // Generate embeddings using Cohere's embed API from the query text
   53
       public Map<String, BinaryVector> generateAndConvertEmbeddings(String text) throws Exception {
   54
           if (COHERE_API_KEY == null || COHERE_API_KEY.isEmpty()) {
   55
               throw new RuntimeException("API key not found. Set COHERE_API_KEY in your environment.");
   56
           }
   57
   58
           Cohere cohere = Cohere.builder().token(COHERE_API_KEY).build();
   59
   60
           EmbedRequest request = EmbedRequest.builder()
   61
                   .model("embed-english-v3.0")
   62
                   .inputType(EmbedInputType.SEARCH_QUERY)
   63
                   .texts(List.of(text))
   64
                   .embeddingTypes(List.of(EmbeddingType.FLOAT, EmbeddingType.INT_8, EmbeddingType.UBINARY))
   65
                   .build();
   66
   67
           EmbedResponse response = cohere.embed(request);
   68
           Optional<EmbedByTypeResponse> optionalEmbeddingsWrapper = response.getEmbeddingsByType();
   69
           if (optionalEmbeddingsWrapper.isEmpty()) {
   70
               throw new RuntimeException("No embeddings found in the API response.");
   71
           }
   72
   73
           EmbedByTypeResponseEmbeddings embeddings = optionalEmbeddingsWrapper.get().getEmbeddings();
   74
           return createBinaryVectorEmbeddings(embeddings);
   75
       }
   76
   77
       // Convert embeddings to BSON binary vectors using MongoDB Java Driver
   78
       private static Map<String, BinaryVector> createBinaryVectorEmbeddings(EmbedByTypeResponseEmbeddings embeddings) {
   79
           Map<String, BinaryVector> binaryVectorEmbeddings = new HashMap<>();
   80
   81
           // Convert float embeddings
   82
           List<Double> floatList = embeddings.getFloat().orElseThrow().get(0);
   83
           if (floatList != null) {
   84
               float[] floatData = listToFloatArray(floatList);
   85
               BinaryVector floatVector = BinaryVector.floatVector(floatData);
   86
               binaryVectorEmbeddings.put("float32", floatVector);
   87
           }
   88
   89
           // Convert int8 embeddings
   90
           List<Integer> int8List = embeddings.getInt8().orElseThrow().get(0);
   91
           if (int8List != null) {
   92
               byte[] int8Data = listToByteArray(int8List);
   93
               BinaryVector int8Vector = BinaryVector.int8Vector(int8Data);
   94
               binaryVectorEmbeddings.put("int8", int8Vector);
   95
           }
   96
   97
           // Convert ubinary embeddings
   98
           List<Integer> ubinaryList = embeddings.getUbinary().orElseThrow().get(0);
   99
           if (ubinaryList != null) {
   100
               byte[] int1Data = listToByteArray(ubinaryList);
   101
               BinaryVector packedBitsVector = BinaryVector.packedBitVector(int1Data, (byte) 0);
   102
               binaryVectorEmbeddings.put("int1", packedBitsVector);
   103
           }
   104
   105
           return binaryVectorEmbeddings;
   106
       }
   107
   108
       // Define and run $vectorSearch query using the embeddings
   109
       public void runVectorSearchQuery(Map<String, BinaryVector> embeddingsData) {
   110
           if (MONGODB_URI == null || MONGODB_URI.isEmpty()) {
   111
               throw new RuntimeException("MongoDB URI not found. Set MONGODB_URI in your environment.");
   112
           }
   113
   114
           try (MongoClient mongoClient = MongoClients.create(MONGODB_URI)) {
   115
               MongoDatabase database = mongoClient.getDatabase(DB_NAME);
   116
               MongoCollection<Document> collection = database.getCollection(COLLECTION_NAME);
   117
   118
               for (String path : embeddingsData.keySet()) {
   119
                   BinaryVector queryVector = embeddingsData.get(path);
   120
   121
                   List<Bson> pipeline = asList(
   122
                           vectorSearch(
   123
                                   fieldPath("embeddings_" + path),
   124
                                   queryVector,
   125
                                   VECTOR_INDEX_NAME,
   126
                                   2,
   127
                                   approximateVectorSearchOptions(5)
   128
                           ),
   129
                           project(
   130
                                   fields(
   131
                                           exclude("_id"),
   132
                                           include(DATA_FIELD_NAME),
   133
                                           metaVectorSearchScore("vectorSearchScore")
   134
                                   )
   135
                           )
   136
                   );
   137
   138
                   List<Document> results = collection.aggregate(pipeline).into(new ArrayList<>());
   139
   140
                   System.out.println("Results from " + path + " embeddings:");
   141
                   for (Document result : results) {
   142
                       System.out.println(result.toJson());
   143
                   }
   144
               }
   145
           }
   146
       }
   147
   148
       private static float[] listToFloatArray(List<Double> list) {
   149
           float[] array = new float[list.size()];
   150
           for (int i = 0; i < list.size(); i++) {
   151
               array[i] = list.get(i).floatValue();
   152
           }
   153
           return array;
   154
       }
   155
   156
       private static byte[] listToByteArray(List<Integer> list) {
   157
           byte[] array = new byte[list.size()];
   158
           for (int i = 0; i < list.size(); i++) {
   159
               array[i] = list.get(i).byteValue();
   160
           }
   161
           return array;
   162
       }
   163
   }

3. Replace the following placeholder values in the code and save the file.

   MONGODB_URI	Your Atlas cluster connection string if you didn't set the environment variable.
   COHERE_API_KEY	You Cohere API key if you didn't set the environment variable.
   <DATABASE-NAME>	Name of the database in your Atlas cluster.
   <COLLECTION-NAME>	Name of the collection where you ingested the data.
   <INDEX-NAME>	Name of the Atlas Vector Search index for the collection.
   <DATA-FIELD-NAME>	Name of the field that contain the text from which you generated embeddings. For this example, use text.
   <QUERY-TEXT>	Text for the query. For this example, use science fact.

4. Compile and run the file using your application run configuration.

   If you are using a terminal, run the following commands to compile and execute your program.

   javac CreateEmbeddingsAndRunQuery.java
   java CreateEmbeddingsAndRunQuery

   HIDE OUTPUT

   Results from int1 embeddings:
   {"text": "Mount Everest is the highest peak on Earth at 8,848m.", "score": 0.642578125}
   {"text": "The Great Wall of China is visible from space.", "score": 0.61328125}
   Results from int8 embeddings:
   {"text": "Mount Everest is the highest peak on Earth at 8,848m.", "score": 0.5149773359298706}
   {"text": "The Great Wall of China is visible from space.", "score": 0.5146723985671997}
   Results from float32 embeddings:
   {"text": "Mount Everest is the highest peak on Earth at 8,848m.", "score": 0.6583383083343506}
   {"text": "The Great Wall of China is visible from space.", "score": 0.6536108255386353}

To learn more about generating embeddings and converting the embeddings to binData vectors, see How to Create Vector Embeddings.

Create your Java project and install dependencies.

1. From your IDE, create a Java project using Maven or Gradle.

2. Add the following dependencies, depending on your package manager:

   Maven

   Gradle

   If you are using Maven, add the following dependencies to the dependencies array in your project's pom.xml file:

   pom.xml

   <dependencies>
       <dependency>
           <groupId>junit</groupId>
           <artifactId>junit</artifactId>
           <version>4.13.2</version>
           <scope>test</scope>
       </dependency>
       <dependency>
           <groupId>org.mongodb</groupId>
           <artifactId>mongodb-driver-sync</artifactId>
           <version>5.3.1</version>
       </dependency>
       <dependency>
           <groupId>com.cohere</groupId>
           <artifactId>cohere-java</artifactId>
           <version>1.6.0</version>
       </dependency>
       <dependency>
           <groupId>org.slf4j</groupId>
           <artifactId>slf4j-api</artifactId>
           <version>2.0.16</version>
       </dependency>
       <dependency>
           <groupId>org.slf4j</groupId>
           <artifactId>slf4j-simple</artifactId>
           <version>2.0.16</version>
           <scope>test</scope>
       </dependency>
   </dependencies>

   If you are using Gradle, add the following to the dependencies array in your project's build.gradle file:

   build.gradle

   dependencies {
       // MongoDB Java Sync Driver v5.3.1 or later
       implementation 'org.mongodb:mongodb-driver-sync:[5.3.1,)'
       // Java library for working with Cohere models
       implementation 'ai.cohere:cohere-java:1.6.0'
       // SLF4J (The Simple Logging Facade for Java)
       testImplementation("org.slf4j:slf4j-simple:2.0.16")
       implementation("org.slf4j:slf4j-api:2.0.16")
   }

3. Run your package manager to install the dependencies to your project.

Set your environment variables.

In your IDE, create a new configuration template and add the following variables to your project:

• If you are using IntelliJ IDEA, create a new Application run configuration template, then add your variables as semicolon-separated values in the Environment variables field (for example, FOO=123;BAR=456). Apply the changes and click OK.

  To learn more, see the Create a run/debug configuration from a template section of the IntelliJ IDEA documentation.

• If you are using Eclipse, create a new Java Application launch configuration, then add each variable as a new key-value pair in the Environment tab. Apply the changes and click OK.

  To learn more, see the Creating a Java application launch configuration section of the Eclipse IDE documentation.

COHERE_API_KEY=<api-key>
MONGODB_URI=<connection-string>

Update the placeholders with the following values:

• Replace the <api-key> placeholder value with your Cohere API key.

• Replace the <connection-string> placeholder value with the SRV connection string for your Atlas cluster.

  Your connection string should use the following format:

  mongodb+srv://<db_username>:<db_password>@<clusterName>.<hostname>.mongodb.net

(Conditional) Generate embeddings from your data.

You can use an embedding model provider to generate float, int8, and int1 embeddings for your data and then use the MongoDB Java driver to convert your native vector embedding to BSON vectors. The following sample code uses Cohere's embed API to generate full-precision vectors from the data in the sample_airbnb.listingsAndReviews namespace.

1. Create a new file named GenerateAndConvertEmbeddings.java in your Java project.

   touch GenerateAndConvertEmbeddings.java

2. Copy and paste the following code in the GenerateAndConvertEmbeddings.java file.

   This code does the following:

   • Gets the summary field from 50 documents in the sample_airbnb.listingsAndReviews namespace.

   • Generates the float32, int8, and ubinary vector embeddings by using Cohere's embed API.

   • Converts the embeddings to BSON binData vectors by using MongoDB Java driver.

   • Creates a file named embeddings.json and saves the data with embeddings in the file.

   GenerateAndConvertEmbeddings.java

   1
   import com.cohere.api.Cohere;
   2
   import com.cohere.api.requests.EmbedRequest;
   3
   import com.cohere.api.types.EmbedByTypeResponse;
   4
   import com.cohere.api.types.EmbedResponse;
   5
   import com.cohere.api.types.EmbeddingType;
   6
   import com.cohere.api.types.EmbedInputType;
   7
   import com.cohere.api.types.EmbedByTypeResponseEmbeddings;
   8
   import com.mongodb.client.MongoClient;
   9
   import com.mongodb.client.MongoClients;
   10
   import com.mongodb.client.MongoDatabase;
   11
   import com.mongodb.client.MongoCollection;
   12
   import com.mongodb.client.FindIterable;
   13
   import org.bson.BsonArray;
   14
   import org.bson.Document;
   15
   import org.bson.BinaryVector;
   16
   import org.slf4j.Logger;
   17
   import org.slf4j.LoggerFactory;
   18
   import java.io.FileOutputStream;
   19
   import java.io.IOException;
   20
   import java.util.ArrayList;
   21
   import java.util.Arrays;
   22
   import java.util.List;
   23
   import java.util.Objects;
   24
   import java.util.Optional;
   25
   26
   public class GenerateAndConvertEmbeddings {
   27
       private static final Logger logger = LoggerFactory.getLogger(GenerateAndConvertEmbeddings.class);
   28
       private static final String COHERE_API_KEY = System.getenv("COHERE_API_KEY");
   29
       private static final String MONGODB_URI = System.getenv("MONGODB_URI");
   30
   31
       public static void main(String[] args) {
   32
           try {
   33
               List<String> summaries = fetchSummariesFromMongoDB();
   34
               if (summaries.isEmpty()) {
   35
                   throw new RuntimeException("No summaries retrieved from MongoDB.");
   36
               }
   37
               EmbedByTypeResponseEmbeddings embeddingsData = fetchEmbeddingsFromCohere(COHERE_API_KEY, summaries);
   38
               if (embeddingsData == null) {
   39
                   throw new RuntimeException("Failed to fetch embeddings.");
   40
               }
   41
               convertAndSaveEmbeddings(summaries, embeddingsData);
   42
           } catch (Exception e) {
   43
               logger.error("Unexpected error: {}", e.getMessage(), e);
   44
           }
   45
       }
   46
   47
       private static List<String> fetchSummariesFromMongoDB() {
   48
           List<String> summaries = new ArrayList<>();
   49
           if (MONGODB_URI == null || MONGODB_URI.isEmpty()) {
   50
               throw new RuntimeException("MongoDB URI is not set.");
   51
           }
   52
           logger.info("Connecting to MongoDB at URI: {}", MONGODB_URI);
   53
           try (MongoClient mongoClient = MongoClients.create(MONGODB_URI)) {
   54
               String dbName = "sample_airbnb";
   55
               String collName = "listingsAndReviews";
   56
               MongoDatabase database = mongoClient.getDatabase(dbName);
   57
               MongoCollection<Document> collection = database.getCollection(collName);
   58
               Document filter = new Document("summary", new Document("$nin", Arrays.asList(null, "")));
   59
               FindIterable<Document> documentsCursor = collection.find(filter).limit(50);
   60
               for (Document doc : documentsCursor) {
   61
                   String summary = doc.getString("summary");
   62
                   if (summary != null && !summary.isEmpty()) {
   63
                       summaries.add(summary);
   64
                   }
   65
               }
   66
               logger.info("Retrieved {} summaries from MongoDB.", summaries.size());
   67
           } catch (Exception e) {
   68
               logger.error("Error fetching from MongoDB: {}", e.getMessage(), e);
   69
               throw new RuntimeException("Failed to fetch data from MongoDB", e);
   70
           }
   71
           return summaries;
   72
       }
   73
   74
       private static EmbedByTypeResponseEmbeddings fetchEmbeddingsFromCohere(String apiKey, List<String> data) {
   75
           if (Objects.isNull(apiKey) || apiKey.isEmpty()) {
   76
               throw new RuntimeException("API key is not set.");
   77
           }
   78
           Cohere cohere = Cohere.builder().token(apiKey).clientName("embed-example").build();
   79
           try {
   80
               EmbedRequest request = EmbedRequest.builder()
   81
                       .model("embed-english-v3.0")
   82
                       .inputType(EmbedInputType.SEARCH_DOCUMENT)
   83
                       .texts(data)
   84
                       .embeddingTypes(List.of(EmbeddingType.FLOAT, EmbeddingType.INT_8, EmbeddingType.UBINARY))
   85
                       .build();
   86
               EmbedResponse response = cohere.embed(request);
   87
               Optional<EmbedByTypeResponse> optionalEmbeddingsWrapper = response.getEmbeddingsByType();
   88
               if (optionalEmbeddingsWrapper.isPresent()) {
   89
                   return optionalEmbeddingsWrapper.get().getEmbeddings();
   90
               } else {
   91
                   logger.warn("No embeddings were returned.");
   92
               }
   93
           } catch (Exception e) {
   94
               logger.error("Error fetching embeddings: {}", e.getMessage(), e);
   95
           }
   96
           return null;
   97
       }
   98
   99
       private static void convertAndSaveEmbeddings(List<String> summaries, EmbedByTypeResponseEmbeddings embeddings) {
   100
           try {
   101
               Document doc = new Document();
   102
               BsonArray array = new BsonArray();
   103
               for (int i = 0; i < summaries.size(); i++) {
   104
                   String summary = summaries.get(i);
   105
   106
                   // Retrieve the embeddings for the current index
   107
                   List<Double> floatList = embeddings.getFloat().orElseThrow().get(i);
   108
                   List<Integer> int8List = embeddings.getInt8().orElseThrow().get(i);
   109
                   List<Integer> ubinaryList = embeddings.getUbinary().orElseThrow().get(i);
   110
   111
                   // Convert lists to arrays
   112
                   float[] floatData = listToFloatArray(floatList);
   113
                   byte[] int8Data = listToByteArray(int8List);
   114
                   byte[] int1Data = listToByteArray(ubinaryList);
   115
   116
                   // Create BinaryVector objects
   117
                   BinaryVector floatVector = BinaryVector.floatVector(floatData);
   118
                   BinaryVector int8Vector = BinaryVector.int8Vector(int8Data);
   119
                   BinaryVector packedBitsVector = BinaryVector.packedBitVector(int1Data, (byte) 0);
   120
   121
                   Document document = new Document()
   122
                           .append("text", summary)
   123
                           .append("embeddings_float32", floatVector)
   124
                           .append("embeddings_int8", int8Vector)
   125
                           .append("embeddings_int1", packedBitsVector);
   126
                   array.add(document.toBsonDocument());
   127
               }
   128
               doc.append("data", array);
   129
               try (FileOutputStream fos = new FileOutputStream("embeddings.json")) {
   130
                   fos.write(doc.toJson().getBytes());
   131
               }
   132
               logger.info("Embeddings with BSON vectors have been saved to embeddings.json");
   133
           } catch (IOException e) {
   134
               logger.error("Error writing embeddings to file: {}", e.getMessage(), e);
   135
           }
   136
       }
   137
   138
       private static float[] listToFloatArray(List<Double> list) {
   139
           float[] array = new float[list.size()];
   140
           for (int i = 0; i < list.size(); i++) {
   141
               array[i] = list.get(i).floatValue();
   142
           }
   143
           return array;
   144
       }
   145
   146
       private static byte[] listToByteArray(List<Integer> list) {
   147
           byte[] array = new byte[list.size()];
   148
           for (int i = 0; i < list.size(); i++) {
   149
               array[i] = list.get(i).byteValue();
   150
           }
   151
           return array;
   152
       }
   153
   }

3. Replace the following placeholder values in the code if you didn't set the environment variables and save the file.

   MONGODB_URI	Your Atlas cluster connection string if you didn't set the environment variable.
   COHERE_API_KEY	You Cohere API key if you didn't set the environment variable.

4. Compile and run the file using your application run configuration.

   If you are using a terminal, run the following commands to compile and execute your program.

   javac GenerateAndConvertEmbeddings.java
   java GenerateAndConvertEmbeddings

   HIDE OUTPUT

   [main] INFO GenerateAndConvertEmbeddings - Connecting to MongoDB at URI: <CONNECTION-STRING>
   ...
   [main] INFO GenerateAndConvertEmbeddings - Retrieved 50 summaries from MongoDB.
   [main] INFO GenerateAndConvertEmbeddings - Embeddings with BSON vectors have been saved to embeddings.json

5. Verify the embeddings in the embeddings.json file.

To learn more about generating embeddings and converting the embeddings to binData vectors, see How to Create Vector Embeddings.

Ingest the data and create an Atlas Vector Search index.

You must upload your data and embeddings to a collection in your Atlas cluster and create an Atlas Vector Search index on the data to run $vectorSearch queries against the data.

1. Create a new file named UploadDataAndCreateIndex.java in your Java project.

   touch UploadDataAndCreateIndex.java

2. Copy and paste the following code in the UploadDataAndCreateIndex.java file.

   This code does the following:

   • Uploads the float32, int8, and int1 embeddings in the embeddings.json file to your Atlas cluster.

   • Creates an Atlas Vector Search index on the embeddings.float32, embeddings.int8, and embeddings.int1 fields.

   UploadDataAndCreateIndex.java

   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
   8
   import org.bson.Document;
   9
   import org.bson.conversions.Bson;
   10
   import org.bson.BinaryVector; // Import the BinaryVector
   11
   12
   import java.io.IOException;
   13
   import java.nio.file.Files;
   14
   import java.nio.file.Path;
   15
   import java.util.Collections;
   16
   import java.util.List;
   17
   import java.util.concurrent.TimeUnit;
   18
   import java.util.stream.StreamSupport;
   19
   20
   public class UploadDataAndCreateIndex {
   21
   22
       private static final String MONGODB_URI = System.getenv("MONGODB_URI");
   23
       private static final String DB_NAME = "sample_airbnb";
   24
       private static final String COLLECTION_NAME = "listingsAndReviews";
   25
       private static final String INDEX_NAME = "<INDEX-NAME>";
   26
   27
       public static void main(String[] args) {
   28
           try (MongoClient mongoClient = MongoClients.create(MONGODB_URI)) {
   29
               uploadEmbeddingsData(mongoClient);
   30
               setupVectorSearchIndex(mongoClient);
   31
           } catch (Exception e) {
   32
               e.printStackTrace();
   33
           }
   34
       }
   35
   36
       public static void uploadEmbeddingsData(MongoClient mongoClient) throws IOException {
   37
           MongoDatabase database = mongoClient.getDatabase(DB_NAME);
   38
           MongoCollection<Document> collection = database.getCollection(COLLECTION_NAME);
   39
           String filePath = "embeddings.json";
   40
           String fileContent = Files.readString(Path.of(filePath));
   41
   42
           Document rootDoc = Document.parse(fileContent);
   43
           List<Document> embeddingsDocs = rootDoc.getList("data", Document.class);
   44
   45
           for (Document doc : embeddingsDocs) {
   46
               // Retrieve the string value from the document
   47
               String summary = doc.getString("text");
   48
   49
               // Get the BinaryVector objects from the document
   50
               BinaryVector embeddingsFloat32 = doc.get("embeddings_float32", BinaryVector.class);
   51
               BinaryVector embeddingsInt8 = doc.get("embeddings_int8", BinaryVector.class);
   52
               BinaryVector embeddingsInt1 = doc.get("embeddings_int1", BinaryVector.class);
   53
   54
               // Create filter and update documents
   55
               Document filter = new Document("summary", summary);
   56
               Document update = new Document("$set", new Document("summary", summary)
   57
                       .append("embeddings_float32", embeddingsFloat32)
   58
                       .append("embeddings_int8", embeddingsInt8)
   59
                       .append("embeddings_int1", embeddingsInt1));
   60
   61
               // Perform update operation with upsert option
   62
               collection.updateOne(filter, update, new com.mongodb.client.model.UpdateOptions().upsert(true));
   63
               System.out.println("Processed document with summary: " + summary);
   64
           }
   65
       }
   66
   67
       public static void setupVectorSearchIndex(MongoClient client) throws InterruptedException {
   68
           MongoDatabase database = client.getDatabase(DB_NAME);
   69
           MongoCollection<Document> collection = database.getCollection(COLLECTION_NAME);
   70
           // Define the index details
   71
           Bson definition = new Document(
   72
               "fields",
   73
               List.of(
   74
                   new Document("type", "vector")
   75
                       .append("path", "embeddings_float32")
   76
                       .append("numDimensions", 1024)
   77
                       .append("similarity", "dotProduct"),
   78
                   new Document("type", "vector")
   79
                       .append("path", "embeddings_int8")
   80
                       .append("numDimensions", 1024)
   81
                       .append("similarity", "dotProduct"),
   82
                   new Document("type", "vector")
   83
                       .append("path", "embeddings_int1")
   84
                       .append("numDimensions", 1024)
   85
                       .append("similarity", "euclidean")
   86
               )
   87
           );
   88
           // Define the index model
   89
           SearchIndexModel indexModel = new SearchIndexModel(
   90
               INDEX_NAME,
   91
               definition,
   92
               SearchIndexType.vectorSearch()
   93
           );
   94
           // Create the index using the defined model
   95
           List<String> result = collection.createSearchIndexes(Collections.singletonList(indexModel));
   96
           System.out.println("Successfully created vector index named: " + result.get(0));
   97
           System.out.println("It may take up to a minute for the index to leave the BUILDING status and become queryable.");
   98
           // Wait for Atlas to build the index
   99
           System.out.println("Polling to confirm the index has changed from the BUILDING status.");
   100
           waitForIndex(collection, INDEX_NAME);
   101
       }
   102
   103
       public static <T> boolean waitForIndex(final MongoCollection<T> collection, final String indexName) {
   104
           long startTime = System.nanoTime();
   105
           long timeoutNanos = TimeUnit.SECONDS.toNanos(60);
   106
           while (System.nanoTime() - startTime < timeoutNanos) {
   107
               Document indexRecord = StreamSupport.stream(collection.listSearchIndexes().spliterator(), false)
   108
                       .filter(index -> indexName.equals(index.getString("name")))
   109
                       .findAny().orElse(null);
   110
               if (indexRecord != null) {
   111
                   if ("FAILED".equals(indexRecord.getString("status"))) {
   112
                       throw new RuntimeException("Search index has FAILED status.");
   113
                   }
   114
                   if (indexRecord.getBoolean("queryable")) {
   115
                       System.out.println(indexName + " index is ready to query");
   116
                       return true;
   117
                   }
   118
               }
   119
               try {
   120
                   Thread.sleep(100); // busy-wait, avoid in production
   121
               } catch (InterruptedException e) {
   122
                   Thread.currentThread().interrupt();
   123
                   throw new RuntimeException(e);
   124
               }
   125
           }
   126
           return false;
   127
       }
   128
   }

3. Replace the following placeholder values in the code and save the file.

   MONGODB_URI	Your Atlas cluster connection string if you didn't set the environment variable.
   <INDEX-NAME>	Name of the Atlas Vector Search index for the collection.

4. Compile and run the file using your application run configuration.

   If you are using a terminal, run the following commands to compile and execute your program.

   javac UploadDataAndCreateIndex.java
   java UploadDataAndCreateIndex

   HIDE OUTPUT

   Successfully created vector index named: <INDEX_NAME>
   It may take up to a minute for the index to leave the BUILDING status and become queryable.
   Polling to confirm the index has changed from the BUILDING status.
   <INDEX_NAME> index is ready to query

5. Log in to your Atlas cluster and verify the following:

   • Data in the namespace.

   • Atlas Vector Search index for the collection.

Create and run query against the collection.

To test your embeddings, you can run a query against your collection. Use an embedding model provider to generate float, int8, and int1 embeddings for your query text. The following sample code uses Cohere's embed API to generate full-precision vectors. After generating the embeddings, use the MongoDB Java driver to convert your native vector embedding to BSON vectors and run $vectorSearch query against the collection.

1. Create a new file named CreateEmbeddingsAndRunQuery.java in your Java project.

   touch CreateEmbeddingsAndRunQuery.java

2. Copy and paste the following code in the CreateEmbeddingsAndRunQuery.java file.

   This code does the following:

   • Generates the float32, int8, and ubinary vector embeddings by using Cohere's embed API.

   • Converts the embeddings to BSON binData vectors by using MongoDB Java driver.

   • Runs the query against your collection and returns the results.

   CreateEmbeddingsAndRunQuery.java

   1
   import com.cohere.api.Cohere;
   2
   import com.cohere.api.requests.EmbedRequest;
   3
   import com.cohere.api.types.EmbedResponse;
   4
   import com.cohere.api.types.EmbedByTypeResponse;
   5
   import com.cohere.api.types.EmbedByTypeResponseEmbeddings;
   6
   import com.cohere.api.types.EmbeddingType;
   7
   import com.cohere.api.types.EmbedInputType;
   8
   import com.mongodb.client.MongoClient;
   9
   import com.mongodb.client.MongoClients;
   10
   import com.mongodb.client.MongoCollection;
   11
   import com.mongodb.client.MongoDatabase;
   12
   import org.bson.Document;
   13
   import org.bson.conversions.Bson;
   14
   import org.bson.BinaryVector;
   15
   16
   import java.util.ArrayList;
   17
   import java.util.HashMap;
   18
   import java.util.List;
   19
   import java.util.Map;
   20
   import java.util.Optional;
   21
   22
   import static com.mongodb.client.model.Aggregates.project;
   23
   import static com.mongodb.client.model.Aggregates.vectorSearch;
   24
   import static com.mongodb.client.model.Projections.fields;
   25
   import static com.mongodb.client.model.Projections.include;
   26
   import static com.mongodb.client.model.Projections.exclude;
   27
   import static com.mongodb.client.model.Projections.metaVectorSearchScore;
   28
   import static com.mongodb.client.model.search.SearchPath.fieldPath;
   29
   import static com.mongodb.client.model.search.VectorSearchOptions.approximateVectorSearchOptions;
   30
   import static java.util.Arrays.asList;
   31
   32
   public class CreateEmbeddingsAndRunQuery {
   33
       private static final String COHERE_API_KEY = System.getenv("COHERE_API_KEY");
   34
       private static final String MONGODB_URI = System.getenv("MONGODB_URI");
   35
       private static final String DB_NAME = "<DATABASE-NAME>";
   36
       private static final String COLLECTION_NAME = "<COLLECTION-NAME>";
   37
       private static final String VECTOR_INDEX_NAME = "<INDEX-NAME>";
   38
       private static final String DATA_FIELD_NAME = "<DATA-FIELD>";
   39
   40
       public static void main(String[] args) {
   41
           String queryText = "<QUERY-TEXT>";
   42
   43
           try {
   44
               CreateAndRunQuery processor = new CreateAndRunQuery();
   45
               Map<String, BinaryVector> embeddingsData = processor.generateAndConvertEmbeddings(queryText);
   46
               processor.runVectorSearchQuery(embeddingsData);
   47
           } catch (Exception e) {
   48
               e.printStackTrace();
   49
           }
   50
       }
   51
   52
       // Generate embeddings using Cohere's embed API from the query text
   53
       public Map<String, BinaryVector> generateAndConvertEmbeddings(String text) throws Exception {
   54
           if (COHERE_API_KEY == null || COHERE_API_KEY.isEmpty()) {
   55
               throw new RuntimeException("API key not found. Set COHERE_API_KEY in your environment.");
   56
           }
   57
   58
           Cohere cohere = Cohere.builder().token(COHERE_API_KEY).build();
   59
   60
           EmbedRequest request = EmbedRequest.builder()
   61
                   .model("embed-english-v3.0")
   62
                   .inputType(EmbedInputType.SEARCH_QUERY)
   63
                   .texts(List.of(text))
   64
                   .embeddingTypes(List.of(EmbeddingType.FLOAT, EmbeddingType.INT_8, EmbeddingType.UBINARY))
   65
                   .build();
   66
   67
           EmbedResponse response = cohere.embed(request);
   68
           Optional<EmbedByTypeResponse> optionalEmbeddingsWrapper = response.getEmbeddingsByType();
   69
           if (optionalEmbeddingsWrapper.isEmpty()) {
   70
               throw new RuntimeException("No embeddings found in the API response.");
   71
           }
   72
   73
           EmbedByTypeResponseEmbeddings embeddings = optionalEmbeddingsWrapper.get().getEmbeddings();
   74
           return createBinaryVectorEmbeddings(embeddings);
   75
       }
   76
   77
       // Convert embeddings to BSON binary vectors using MongoDB Java Driver
   78
       private static Map<String, BinaryVector> createBinaryVectorEmbeddings(EmbedByTypeResponseEmbeddings embeddings) {
   79
           Map<String, BinaryVector> binaryVectorEmbeddings = new HashMap<>();
   80
   81
           // Convert float embeddings
   82
           List<Double> floatList = embeddings.getFloat().orElseThrow().get(0);
   83
           if (floatList != null) {
   84
               float[] floatData = listToFloatArray(floatList);
   85
               BinaryVector floatVector = BinaryVector.floatVector(floatData);
   86
               binaryVectorEmbeddings.put("float32", floatVector);
   87
           }
   88
   89
           // Convert int8 embeddings
   90
           List<Integer> int8List = embeddings.getInt8().orElseThrow().get(0);
   91
           if (int8List != null) {
   92
               byte[] int8Data = listToByteArray(int8List);
   93
               BinaryVector int8Vector = BinaryVector.int8Vector(int8Data);
   94
               binaryVectorEmbeddings.put("int8", int8Vector);
   95
           }
   96
   97
           // Convert ubinary embeddings
   98
           List<Integer> ubinaryList = embeddings.getUbinary().orElseThrow().get(0);
   99
           if (ubinaryList != null) {
   100
               byte[] int1Data = listToByteArray(ubinaryList);
   101
               BinaryVector packedBitsVector = BinaryVector.packedBitVector(int1Data, (byte) 0);
   102
               binaryVectorEmbeddings.put("int1", packedBitsVector);
   103
           }
   104
   105
           return binaryVectorEmbeddings;
   106
       }
   107
   108
       // Define and run $vectorSearch query using the embeddings
   109
       public void runVectorSearchQuery(Map<String, BinaryVector> embeddingsData) {
   110
           if (MONGODB_URI == null || MONGODB_URI.isEmpty()) {
   111
               throw new RuntimeException("MongoDB URI not found. Set MONGODB_URI in your environment.");
   112
           }
   113
   114
           try (MongoClient mongoClient = MongoClients.create(MONGODB_URI)) {
   115
               MongoDatabase database = mongoClient.getDatabase(DB_NAME);
   116
               MongoCollection<Document> collection = database.getCollection(COLLECTION_NAME);
   117
   118
               for (String path : embeddingsData.keySet()) {
   119
                   BinaryVector queryVector = embeddingsData.get(path);
   120
   121
                   List<Bson> pipeline = asList(
   122
                           vectorSearch(
   123
                                   fieldPath("embeddings_" + path),
   124
                                   queryVector,
   125
                                   VECTOR_INDEX_NAME,
   126
                                   2,
   127
                                   approximateVectorSearchOptions(5)
   128
                           ),
   129
                           project(
   130
                                   fields(
   131
                                           exclude("_id"),
   132
                                           include(DATA_FIELD_NAME),
   133
                                           metaVectorSearchScore("vectorSearchScore")
   134
                                   )
   135
                           )
   136
                   );
   137
   138
                   List<Document> results = collection.aggregate(pipeline).into(new ArrayList<>());
   139
   140
                   System.out.println("Results from " + path + " embeddings:");
   141
                   for (Document result : results) {
   142
                       System.out.println(result.toJson());
   143
                   }
   144
               }
   145
           }
   146
       }
   147
   148
       private static float[] listToFloatArray(List<Double> list) {
   149
           float[] array = new float[list.size()];
   150
           for (int i = 0; i < list.size(); i++) {
   151
               array[i] = list.get(i).floatValue();
   152
           }
   153
           return array;
   154
       }
   155
   156
       private static byte[] listToByteArray(List<Integer> list) {
   157
           byte[] array = new byte[list.size()];
   158
           for (int i = 0; i < list.size(); i++) {
   159
               array[i] = list.get(i).byteValue();
   160
           }
   161
           return array;
   162
       }
   163
   }

3. Replace the following placeholder values in the code and save the file.

   MONGODB_URI	Your Atlas cluster connection string if you didn't set the environment variable.
   COHERE_API_KEY	You Cohere API key if you didn't set the environment variable.
   <DATABASE-NAME>	Name of the database in your Atlas cluster. For this example, use sample_airbnb.
   <COLLECTION-NAME>	Name of the collection where you ingested the data. For this example, use listingsAndReviews.
   <INDEX-NAME>	Name of the Atlas Vector Search index for the collection.
   <DATA-FIELD-NAME>	Name of the field that contain the text from which you generated embeddings. For this example, use summary.
   <QUERY-TEXT>	Text for the query. For this example, use ocean view.

4. Compile and run the file using your application run configuration.

   If you are using a terminal, run the following commands to compile and execute your program.

   javac CreateEmbeddingsAndRunQuery.java
   java CreateEmbeddingsAndRunQuery

   HIDE OUTPUT

   Results from int1 embeddings:
   {"summary": "A beautiful and comfortable 1 Bedroom Air Conditioned Condo in Makaha Valley - stunning Ocean & Mountain views All the amenities of home, suited for longer stays. Full kitchen & large bathroom.  Several gas BBQ's for all guests to use & a large heated pool surrounded by reclining chairs to sunbathe.  The Ocean you see in the pictures is not even a mile away, known as the famous Makaha Surfing Beach. Golfing, hiking,snorkeling  paddle boarding, surfing are all just minutes from the front door.", "vectorSearchScore": 0.6591796875}
   {"summary": "A short distance from Honolulu's billion dollar mall, and the same distance to Waikiki. Parking included. A great location that work perfectly for business, education, or simple visit. Experience Yacht Harbor views and 5 Star Hilton Hawaiian Village.", "vectorSearchScore": 0.6337890625}
   Results from int8 embeddings:
   {"summary": "A beautiful and comfortable 1 Bedroom Air Conditioned Condo in Makaha Valley - stunning Ocean & Mountain views All the amenities of home, suited for longer stays. Full kitchen & large bathroom.  Several gas BBQ's for all guests to use & a large heated pool surrounded by reclining chairs to sunbathe.  The Ocean you see in the pictures is not even a mile away, known as the famous Makaha Surfing Beach. Golfing, hiking,snorkeling  paddle boarding, surfing are all just minutes from the front door.", "vectorSearchScore": 0.5215557217597961}
   {"summary": "A short distance from Honolulu's billion dollar mall, and the same distance to Waikiki. Parking included. A great location that work perfectly for business, education, or simple visit. Experience Yacht Harbor views and 5 Star Hilton Hawaiian Village.", "vectorSearchScore": 0.5179016590118408}
   Results from float32 embeddings:
   {"summary": "A beautiful and comfortable 1 Bedroom Air Conditioned Condo in Makaha Valley - stunning Ocean & Mountain views All the amenities of home, suited for longer stays. Full kitchen & large bathroom.  Several gas BBQ's for all guests to use & a large heated pool surrounded by reclining chairs to sunbathe.  The Ocean you see in the pictures is not even a mile away, known as the famous Makaha Surfing Beach. Golfing, hiking,snorkeling  paddle boarding, surfing are all just minutes from the front door.", "vectorSearchScore": 0.7278661131858826}
   {"summary": "A short distance from Honolulu's billion dollar mall, and the same distance to Waikiki. Parking included. A great location that work perfectly for business, education, or simple visit. Experience Yacht Harbor views and 5 Star Hilton Hawaiian Village.", "vectorSearchScore": 0.688639760017395}

To learn more about generating embeddings and converting the embeddings to binData vectors, see How to Create Vector Embeddings.

Install the required libraries.

Run the following command to install the MongoDB Node.js Driver. This operation might take a few minutes to complete.

npm install mongodb

You must install Node.js v6.11 or later driver. If necessary, you can also install libraries from your embedding model provider. For example, to generate float32, int8, and int1 embeddings by using Cohere as demonstrated in this page, install Cohere:

npm install cohere-ai dotenv
npm show cohere-ai version

Set the environment variables in your terminal.

1. To access the embedding model provider for generating and converting embeddings, set the environment variable for the embedding model provider's API key, if necessary.

   For using embeddings from Cohere, set up the COHERE_API_KEY environment variable.

   export COHERE_API_KEY="<COHERE-API-KEY>"

   If you don't set the environment variable, replace the <COHERE-API-KEY> in the sample code with the API key before running the code.

2. To access Atlas cluster, set the MONGODB_URI environment variable.

   export MONGODB_URI="<CONNECTION-STRING>"

   Your connection string should be in the following format:

   mongodb+srv://<db_username>:<db_password>@<clusterName>.<hostname>.mongodb.net

   If you don't set the environment variable, replace the <CONNECTION-STRING> in the sample code with your connection string before running the code.

Generate the vector embeddings for your data.

1. Create a file named get-embeddings.js to generate float32, int8, and int1 vector embeddings by using Cohere's embed API.

   touch get-embeddings.js

2. Copy and paste the following code in the get-embeddings.js file.

   This code does the following:

   • Generates float32, int8, and int1 embeddings for the given data by using Cohere's embed-english-v3.0 embedding model.

   • Stores the float, int8, and int1 embeddings in fields named float, int8, and ubinary respectively.

   • Creates a file named embeddings.json and saves the embeddings in the file.

   get-embeddings.js

   1
   // Use 'require' for modules in a Node.js environment
   2
   const { CohereClient } = require('cohere-ai');
   3
   const { writeFile } = require('fs/promises');
   4
   dd:queueMicrotask
   5
   // Retrieve API key from environment variables or default placeholder
   6
   const apiKey = process.env.COHERE_API_KEY || '<COHERE-API-KEY>';
   7
   8
   if (!apiKey) {
   9
     throw new Error('API key not found. Please set COHERE_API_KEY in your environment.');
   10
   }
   11
   12
   // Instantiate the CohereClient with the API key
   13
   const cohere = new CohereClient({ token: apiKey });
   14
   15
   async function main() {
   16
     try {
   17
       // Data to embed
   18
       const data = [
   19
         "The Great Wall of China is visible from space.",
   20
         "The Eiffel Tower was completed in Paris in 1889.",
   21
         "Mount Everest is the highest peak on Earth at 8,848m.",
   22
         "Shakespeare wrote 37 plays and 154 sonnets during his lifetime.",
   23
         "The Mona Lisa was painted by Leonardo da Vinci.",
   24
       ];
   25
   26
       // Fetch embeddings for the data using the cohere API
   27
       const response = await cohere.v2.embed({
   28
         model: 'embed-english-v3.0',
   29
         inputType: 'search_document', 
   30
         texts: data,
   31
         embeddingTypes: ['float', 'int8', 'ubinary'], 
   32
       });
   33
   34
       // Extract embeddings from the API response
   35
       const { float, int8, ubinary } = response.embeddings;
   36
   37
       // Map the embeddings to the text data
   38
       const embeddingsData = data.map((text, index) => ({
   39
         text,
   40
         embeddings: {
   41
           float: float[index],
   42
           int8: int8[index],
   43
           ubinary: ubinary[index],
   44
         },
   45
       }));
   46
   47
       // Write the embeddings data to a JSON file
   48
       await writeFile('embeddings.json', JSON.stringify(embeddingsData, null, 2));
   49
       console.log('Embeddings saved to embeddings.json');
   50
     } catch (error) {
   51
       console.error('Error fetching embeddings:', error);
   52
     }
   53
   }
   54
   55
   // Execute the main function
   56
   main();

3. Replace the <COHERE_API_KEY> placeholder if you didn't set your API Key for Cohere as an environment variable and then save the file.

4. Run the code to generate embeddings.

   node get-embeddings.js

   HIDE OUTPUT

    Embeddings saved to embeddings.json

5. Verify the generated embeddings in the generated embeddings.json file.

Convert the vector embeddings to binData vectors.

1. Create a file named convert-embeddings.js to convert the float32, int8, and int1 vector embeddings from Cohere to BSON binData vectors by using the MongoDB Node.js driver.

   touch convert-embeddings.js

2. Copy and paste the following code in the convert-embeddings.js file.

   This code does the following:

   • Generates BSON binData vectors for the float32, int8, and int1 embeddings.

   • Appends the float32, int8, and ubinary BSON binData vectors to the embeddings.json file.

   convert-embeddings.js

   1
   const fs = require('fs/promises');
   2
   const { BSON } = require('mongodb');
   3
   const { Binary } = BSON;
   4
   5
   async function main() {
   6
     try {
   7
       // Read and parse the contents of 'embeddings.json' file
   8
       const fileContent = await fs.readFile('embeddings.json', 'utf8');
   9
       const embeddingsData = JSON.parse(fileContent);
   10
   11
       // Map the embeddings data to add BSON binary representations with subtype 9
   12
       const convertEmbeddingsData = embeddingsData.map(({ text, embeddings }) => {
   13
         // Create Binary for Float32Array with manual subtype 9
   14
         const bsonFloat32 = Binary.fromFloat32Array(new Float32Array(embeddings.float));
   15
   16
         // Create Binary for Int8Array with subtype 9
   17
         const bsonInt8 = Binary.fromInt8Array(new Int8Array(embeddings.int8));
   18
   19
         // Create Binary for PackedBits (Uint8Array) with subtype 9
   20
         const bsonPackedBits = Binary.fromPackedBits(new Uint8Array(embeddings.ubinary));
   21
   22
         return {
   23
           text,
   24
           embeddings: {
   25
             float: embeddings.float, // Original float data
   26
             int8: embeddings.int8, // Original int8 data
   27
             ubinary: embeddings.ubinary, // Original packed bits data
   28
           },
   29
           bsonEmbeddings: {
   30
             float32: bsonFloat32,
   31
             int8: bsonInt8,
   32
             packedBits: bsonPackedBits,
   33
           },
   34
         };
   35
       });
   36
   37
       // Serialize the updated data to EJSON for BSON compatibility
   38
       const ejsonSerializedData = BSON.EJSON.stringify(convertEmbeddingsData, null, null, { relaxed: false });
   39
   40
       // Write the serialized data to 'embeddings.json'
   41
       await fs.writeFile('embeddings.json', ejsonSerializedData);
   42
       console.log('Embeddings with BSON vectors have been saved to embeddings.json');
   43
     } catch (error) {
   44
       console.error('Error processing embeddings:', error);
   45
     }
   46
   }
   47
   48
   main();

3. Run the program to generate the BSON binData vectors.

   node convert-embeddings.js

   HIDE OUTPUT

   Embeddings with BSON vectors have been saved to embeddings.json

4. Verify the generated BSON embeddings in the embeddings.json file.

Connect to the Atlas cluster and upload the data to a collection.

1. Create a file named upload-data.js to connect to the Atlas cluster and create a collection in a database for the data in the embeddings.json file.

   touch upload-data.js

2. Copy and paste the following code in the upload-data.js file.

   This code does the following:

   • Connects to your Atlas cluster and creates a namespace with the database and collection name that you specify.

   • Uploads the data including the embeddings in the embeddings.json file to the specified namespace.

   upload-data.js

   1
   const fs = require('fs/promises'); // Use fs/promises for asynchronous operations
   2
   const { MongoClient, BSON } = require('mongodb'); // Import from the 'mongodb' package
   3
   4
   const { Binary } = BSON; // Ensure the Binary class is imported correctly
   5
   6
   async function main() {
   7
       const MONGODB_URI = process.env.MONGODB_URI || "<CONNECTION-STRING>";
   8
       const DB_NAME = "<DB-NAME>";
   9
       const COLLECTION_NAME = "<COLLECTION-NAME>";
   10
   11
       let client;
   12
       try {
   13
           client = new MongoClient(MONGODB_URI);
   14
           await client.connect();
   15
           console.log("Connected to MongoDB");
   16
   17
           const db = client.db(DB_NAME);
   18
           const collection = db.collection(COLLECTION_NAME);
   19
   20
           // Read and parse the contents of 'embeddings.json' file using EJSON
   21
           const fileContent = await fs.readFile('embeddings.json', 'utf8');
   22
           const embeddingsData = BSON.EJSON.parse(fileContent);
   23
   24
           // Map embeddings data to recreate BSON binary representations with the correct subtype
   25
           const documents = embeddingsData.map(({ text, bsonEmbeddings }) => {
   26
               return {
   27
                   text,
   28
                   bsonEmbeddings: {
   29
                       float32: bsonEmbeddings.float32,
   30
                       int8: bsonEmbeddings.int8,
   31
                       int1: bsonEmbeddings.packedBits
   32
                   }
   33
               };
   34
           });
   35
   36
           const result = await collection.insertMany(documents);
   37
           console.log(`Inserted ${result.insertedCount} documents into MongoDB`);
   38
   39
       } catch (error) {
   40
           console.error('Error storing embeddings in MongoDB:', error);
   41
       } finally {
   42
           if (client) {
   43
               await client.close();
   44
           }
   45
       }
   46
   }
   47
   48
   // Run the store function
   49
   main();

3. Replace the following settings and save the file.

   <CONNECTION-STRING>	Connection string to connect to the Atlas cluster where you want to create the database and collection. Replace this value only if you didn't set the MONGODB_URI environment variable.
   <DB-NAME>	Name of the database where you want to create the collection.
   <COLLECTION-NAME>	Name of the collection where you want to store the generated embeddings.

4. Run the following command to upload the data.

   node upload-data.js

5. Verify that the documents exist in the collection on your Atlas cluster.

Create the Atlas Vector Search index on the collection.

1. Create a file named create-index.js to define an Atlas Vector Search index on the collection.

   touch create-index.js

2. Copy and paste the following code to create the index in the create-index.js file.

   The code does the following:

   • Connects to the Atlas cluster and creates an index with the specified name for the specified namespace.

   • Indexes the bsonEmbeddings.float32 and bsonEmbeddings.int8 fields as vector type that uses the dotProduct similarity function, and the bsonEmbeddings.int1 field also as vector type that uses the euclidean function.

   create-index.js

   1
   const { MongoClient } = require("mongodb");
   2
   const { setTimeout } = require("timers/promises"); // Import from timers/promises
   3
   4
   // Connect to your Atlas deployment
   5
   const uri = process.env.MONGODB_URI || "<CONNECTION-STRING>";
   6
   7
   const client = new MongoClient(uri);
   8
   9
   async function main() {
   10
     try {
   11
       const database = client.db("<DB-NAME>");
   12
       const collection = database.collection("<COLLECTION-NAME>");
   13
   14
       // Define your Atlas Vector Search index
   15
       const index = {
   16
         name: "<INDEX-NAME>",
   17
         type: "vectorSearch",
   18
         definition: {
   19
           fields: [
   20
             {
   21
               type: "vector",
   22
               numDimensions: 1024,
   23
               path: "bsonEmbeddings.float32",
   24
               similarity: "dotProduct",
   25
             },
   26
             {
   27
               type: "vector",
   28
               numDimensions: 1024,
   29
               path: "bsonEmbeddings.int8",
   30
               similarity: "dotProduct",
   31
             },
   32
             {
   33
               type: "vector",
   34
               numDimensions: 1024,
   35
               path: "bsonEmbeddings.int1",
   36
               similarity: "euclidean",
   37
             },
   38
           ],
   39
         },
   40
       };
   41
   42
       // Run the helper method
   43
       const result = await collection.createSearchIndex(index);
   44
       console.log(`New search index named ${result} is building.`);
   45
   46
       // Wait for the index to be ready to query
   47
       console.log("Polling to check if the index is ready. This may take up to a minute.");
   48
       let isQueryable = false;
   49
   50
       // Use filtered search for index readiness
   51
       while (!isQueryable) {
   52
         const [indexData] = await collection.listSearchIndexes(index.name).toArray();
   53
   54
         if (indexData) {
   55
           isQueryable = indexData.queryable;
   56
           if (!isQueryable) {
   57
             await setTimeout(5000); // Wait for 5 seconds before checking again
   58
           }
   59
         } else {
   60
           // Handle the case where the index might not be found
   61
           console.log(`Index ${index.name} not found.`);
   62
           await setTimeout(5000); // Wait for 5 seconds before checking again
   63
         }
   64
       }
   65
   66
       console.log(`${result} is ready for querying.`);
   67
     } catch (error) {
   68
       console.error("Error:", error);
   69
     } finally {
   70
       await client.close();
   71
     }
   72
   }
   73
   74
   main().catch((err) => {
   75
     console.error("Unhandled error:", err);
   76
   });

3. Replace the following settings and save the file.

   <CONNECTION-STRING>	Connection string to connect to the Atlas cluster where you want to create the index. Replace this value only if you didn't set the MONGODB_URI environment variable.
   <DB-NAME>	Name of the database where you want to create the collection.
   <COLLECTION-NAME>	Name of the collection where you want to store the generated embeddings.
   <INDEX-NAME>	Name of the index for the collection.

4. Run the following command to create the index.

   node create-index.js

Generate the embeddings for the query text.

1. Create a file named get-query-embedding.js.

   touch get-query-embeddings.js

2. Copy and paste the code in the get-query-embedding.js file.

   The sample code does the following:

   • Generates float32, int8, and int1 embeddings for the query text by using Cohere.

   • Converts the generated embeddings to BSON binData vectors by using PyMongo.

   • Saves the generated embeddings to a file named query-embeddings.json.

   get-query-embedding.js

   1
   const { CohereClient } = require('cohere-ai');
   2
   const { BSON } = require('mongodb');
   3
   const { writeFile } = require('fs/promises');
   4
   const dotenv = require('dotenv');
   5
   const process = require('process');
   6
   7
   // Load environment variables
   8
   dotenv.config();
   9
   10
   const { Binary } = BSON;
   11
   12
   // Get the API key from environment variables or set the key here
   13
   const apiKey = process.env.COHERE_API_KEY || '<COHERE-API-KEY>';
   14
   15
   if (!apiKey) {
   16
     throw new Error('API key not found. Provide the COHERE_API_KEY.');
   17
   }
   18
   19
   // Initialize CohereClient
   20
   const cohere = new CohereClient({ token: apiKey });
   21
   22
   async function main(queryText) {
   23
     try {
   24
       if (typeof queryText !== 'string' || queryText.trim() === '') {
   25
         throw new Error('Invalid query text. It must be a non-empty string.');
   26
       }
   27
   28
       const data = [queryText];
   29
   30
       // Request embeddings from the Cohere API
   31
       const response = await cohere.v2.embed({
   32
         model: 'embed-english-v3.0',
   33
         inputType: 'search_query',
   34
         texts: data,
   35
         embeddingTypes: ['float', 'int8', 'ubinary'], // Request all required embedding types
   36
       });
   37
   38
       if (!response.embeddings) {
   39
         throw new Error('Embeddings not found in the API response.');
   40
       }
   41
   42
       const { float, int8, ubinary } = response.embeddings;
   43
   44
       const updatedEmbeddingsData = data.map((text, index) => {
   45
         // Create the BSON Binary objects using VECTOR_TYPE for all embedding types
   46
         const float32Binary = Binary.fromFloat32Array(new Float32Array(float[index])); // VECTOR_TYPE.FLOAT32
   47
         const int8Binary = Binary.fromInt8Array(new Int8Array(int8[index])); // VECTOR_TYPE.INT8
   48
         const packedBitsBinary = Binary.fromPackedBits(new Uint8Array(ubinary[index])); // VECTOR_TYPE.PACKED_BIT
   49
   50
         return {
   51
           text,
   52
           embeddings: {
   53
             float: float[index],
   54
             int8: int8[index],
   55
             ubinary: ubinary[index],
   56
           },
   57
           bsonEmbeddings: {
   58
             float32: float32Binary,
   59
             int8: int8Binary,
   60
             int1: packedBitsBinary,
   61
           },
   62
         };
   63
       });
   64
   65
       // Serialize the embeddings using BSON EJSON for BSON compatibility
   66
       const outputFileName = 'query-embeddings.json';
   67
       const ejsonSerializedData = BSON.EJSON.stringify(updatedEmbeddingsData, null, null, { relaxed: false });
   68
       await writeFile(outputFileName, ejsonSerializedData);
   69
       console.log(`Embeddings with BSON data have been saved to ${outputFileName}`);
   70
     } catch (error) {
   71
       console.error('Error processing query text:', error);
   72
     }
   73
   }
   74
   75
   // Main function that takes a query string
   76
   (async () => {
   77
     const queryText = "<QUERY-TEXT>"; // Replace with your actual query text
   78
     await main(queryText);
   79
   })();

3. Replace the following settings and save the file.

   <COHERE-API-KEY>	Your API Key for Cohere. Only replace this value if you didn't set the environment variable.
   <QUERY-TEXT>	Your query text. For this tutorial, use science fact.

4. Run the code to generate the embeddings for the query text.

   node get-query-embeddings.js

   HIDE OUTPUT

   Embeddings with BSON vectors have been saved to query-embeddings.json