矢量量化

创建Java项目并安装依赖项。

1. 在 IDE 中，使用 Maven 或 Gradle 创建Java项目。

2. 根据您的包管理器，添加以下依赖项：

   Maven

   Gradle

   如果使用 Maven，请将以下依赖项添加到项目的 pom.xml文件的 dependencies大量中：

   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>

   如果您使用 Gradle，请将以下内容添加到项目 build.gradle文件的 dependencies大量中：

   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. 运行包管理器以安装项目的依赖项。

设置环境变量。

在 IDE 中，创建新的配置模板并将以下变量添加到项目中：

• 如果您使用的是 IntelliJ IDEA，则请创建一个新的 Application 运行配置模板，然后在 Environment variables 字段中将变量添加为用分号分隔的值（例如，FOO=123;BAR=456）。应用这些更改，然后单击 OK。

  要学习；了解更多信息，请参阅 IntelliJ IDEA 文档的从模板创建运行/调试配置部分。

• 如果您使用的是 Eclipse，请创建新的 Java Application 启动配置，然后将每个变量作为新的键值对添加到 Environment标签页中。 应用更改并单击 OK。

  要学习；了解更多信息，请参阅 Eclipse IDE 文档的创建Java应用程序启动配置部分。

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

用以下值更新占位符：

• 将 <api-key> 占位符值替换为您的 Cohere API密钥。

• 用 Atlas 集群的 SRV 连接字符串替换 <connection-string> 占位符值。

  连接字符串应使用以下格式：

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

从数据生成嵌入。

您可以使用嵌入模型提供商为数据生成float 、int8 和int1 嵌入，然后使用MongoDB Java驾驶员原生向量嵌入转换为BSON向量。以下示例代码使用 Cohere 的embed API生成全精度向量。

1. 在Java项目中创建一个名为 GenerateAndConvertEmbeddings.java 的新文件。

   touch GenerateAndConvertEmbeddings.java

2. 将以下代码复制并粘贴到 GenerateAndConvertEmbeddings.java 文件中。

   此代码执行以下操作：

   • 使用 Cohere 的 embed API 生成 float32、int8 和 ubinary 向量嵌入。

   • 使用MongoDB Java驾驶员将嵌入转换为BSON 向量。binData

   • 创建一个名为 embeddings.json 的文件，并将带有嵌入的数据保存在该文件中以上传到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. 如果未设立环境变量，请替换代码中的 COHERE_API_KEY 占位符值，然后保存文件。

4. 使用应用程序运行配置编译并运行该文件。

   如果使用终端，运行以下命令来编译并执行程序。

   javac GenerateAndConvertEmbeddings.java
   java GenerateAndConvertEmbeddings

   隐藏输出

   BSON embeddings saved to embeddings.json

5. 验证 embeddings.json文件中的嵌入。

要学习；了解有关生成嵌入并将嵌入转换为 binData 向量的更多信息，请参阅如何创建向量嵌入。

摄取数据并创建Atlas Vector Search索引。

您必须将数据和嵌入上传到Atlas 集群中的集合，并在数据上创建Atlas Vector Search索引，以对数据运行$vectorSearch 查询。

1. 在Java项目中创建一个名为 UploadDataAndCreateIndex.java 的新文件。

   touch UploadDataAndCreateIndex.java

2. 将以下代码复制并粘贴到 UploadDataAndCreateIndex.java 文件中。

   此代码执行以下操作：

   • 将 embeddings.json文件中的数据上传到Atlas 集群。

   • 在 embeddings_float32、embeddings_int8 和 embeddings_int1 字段上创建Atlas Vector Search索引。

   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. 替换代码中的以下占位符值并保存文件。

   MONGODB_URI	Atlas 集群连接字符串（如果您未设立环境变量）。
   <DATABASE-NAME>	Atlas 集群中数据库的名称。
   <COLLECTION-NAME>	要上传数据的集合的名称。
   <INDEX-NAME>	集合的Atlas Vector Search索引的名称。

4. 使用应用程序运行配置编译并运行该文件。

   如果使用终端，运行以下命令来编译并执行程序。

   javac UploadDataAndCreateIndex.java
   java UploadDataAndCreateIndex

   隐藏输出

   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. 登录Atlas 集群并验证以下内容：

   • 命名空间空间中的数据。

   • 集合的Atlas Vector Search索引。

创建并针对集合运行查询。

要测试嵌入，您可以对集合运行查询。使用嵌入模型提供商为查询文本生成 float、int8 和 int1 嵌入。以下示例代码使用 Cohere 的 embed API生成全精度向量。生成嵌入后，使用MongoDB Java驾驶员将原原生向量嵌入转换为BSON向量，并对集合运行$vectorSearch查询。

1. 在Java项目中创建一个名为 CreateEmbeddingsAndRunQuery.java 的新文件。

   touch CreateEmbeddingsAndRunQuery.java

2. 将以下代码复制并粘贴到 CreateEmbeddingsAndRunQuery.java 文件中。

   此代码执行以下操作：

   • 使用 Cohere 的 embed API 生成 float32、int8 和 ubinary 向量嵌入。

   • 使用MongoDB Java驾驶员将嵌入转换为BSON 向量。binData

   • 针对您的集合运行查询。

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

3. 替换代码中的以下占位符值并保存文件。

   MONGODB_URI	Atlas 集群连接字符串（如果您未设立环境变量）。
   COHERE_API_KEY	如果您未设立环境变量，则使用 Cohere API密钥。
   <DATABASE-NAME>	Atlas 集群中数据库的名称。
   <COLLECTION-NAME>	您提取数据的集合的名称。
   <INDEX-NAME>	集合的Atlas Vector Search索引的名称。
   <DATA-FIELD-NAME>	包含生成嵌入的文本的字段名称。对于本示例，请使用 text。
   <QUERY-TEXT>	查询的文本。对于本示例，请使用 science fact。

4. 使用应用程序运行配置编译并运行该文件。

   如果使用终端，运行以下命令来编译并执行程序。

   javac CreateEmbeddingsAndRunQuery.java
   java CreateEmbeddingsAndRunQuery

   隐藏输出

   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}

要学习；了解有关生成嵌入并将嵌入转换为 binData 向量的更多信息，请参阅如何创建向量嵌入。

创建Java项目并安装依赖项。

1. 在 IDE 中，使用 Maven 或 Gradle 创建Java项目。

2. 根据您的包管理器，添加以下依赖项：

   Maven

   Gradle

   如果使用 Maven，请将以下依赖项添加到项目的 pom.xml文件的 dependencies大量中：

   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>

   如果您使用 Gradle，请将以下内容添加到项目 build.gradle文件的 dependencies大量中：

   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. 运行包管理器以安装项目的依赖项。

设置环境变量。

在 IDE 中，创建新的配置模板并将以下变量添加到项目中：

• 如果您使用的是 IntelliJ IDEA，则应创建一个新的 Application 运行配置模板，然后在 Environment variables 字段中以分号分隔的值的形式来添加变量（例如，FOO=123;BAR=456）。应用这些更改并单击 OK。

  要学习；了解更多信息，请参阅 IntelliJ IDEA 文档的从模板创建运行/调试配置部分。

• 如果您使用的是 Eclipse，请创建新的 Java Application 启动配置，然后将每个变量作为新的键值对添加到 Environment标签页中。 应用更改并单击 OK。

  要学习；了解更多信息，请参阅 Eclipse IDE 文档的创建Java应用程序启动配置部分。

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

用以下值更新占位符：

• 将 <api-key> 占位符值替换为您的 Cohere API密钥。

• 用 Atlas 集群的 SRV 连接字符串替换 <connection-string> 占位符值。

  连接字符串应使用以下格式：

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

（条件）从您的数据生成嵌入。

您可以使用嵌入模型提供商为数据生成float 、int8 和int1 嵌入，然后使用MongoDB Java驾驶员原生向量嵌入转换为BSON向量。以下示例代码使用 Cohere 的embed API从 sample_airbnb.listingsAndReviews命名空间中的数据生成全精度向量。

1. 在Java项目中创建一个名为 GenerateAndConvertEmbeddings.java 的新文件。

   touch GenerateAndConvertEmbeddings.java

2. 将以下代码复制并粘贴到 GenerateAndConvertEmbeddings.java 文件中。

   此代码执行以下操作：

   • 从 sample_airbnb.listingsAndReviews命名空间中的 50 文档获取 summary字段。

   • 使用 Cohere 的 embed API 生成 float32、int8 和 ubinary 向量嵌入。

   • 使用MongoDB Java驾驶员将嵌入转换为BSON 向量。binData

   • 创建一个名为 embeddings.json 的文件，并将带有嵌入的数据保存在该文件中。

   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. 如果未设立环境变量，请替换代码中的以下占位符值并保存文件。

   MONGODB_URI	Atlas 集群连接字符串（如果您未设立环境变量）。
   COHERE_API_KEY	如果您未设立环境变量，则使用 Cohere API密钥。

4. 使用应用程序运行配置编译并运行该文件。

   如果使用终端，运行以下命令来编译并执行程序。

   javac GenerateAndConvertEmbeddings.java
   java GenerateAndConvertEmbeddings

   隐藏输出

   [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. 验证 embeddings.json文件中的嵌入。

要学习；了解有关生成嵌入并将嵌入转换为 binData 向量的更多信息，请参阅如何创建向量嵌入。

摄取数据并创建Atlas Vector Search索引。

您必须将数据和嵌入上传到Atlas 集群中的集合，并在数据上创建Atlas Vector Search索引，以对数据运行$vectorSearch 查询。

1. 在Java项目中创建一个名为 UploadDataAndCreateIndex.java 的新文件。

   touch UploadDataAndCreateIndex.java

2. 将以下代码复制并粘贴到 UploadDataAndCreateIndex.java 文件中。

   此代码执行以下操作：

   • 将 embeddings.json文件中的 float32、int8 和 int1 嵌入上传到Atlas 集群。

   • 在 embeddings.float32、embeddings.int8 和 embeddings.int1 字段上创建Atlas Vector Search索引。

   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. 替换代码中的以下占位符值并保存文件。

   MONGODB_URI	Atlas 集群连接字符串（如果您未设立环境变量）。
   <INDEX-NAME>	集合的Atlas Vector Search索引的名称。

4. 使用应用程序运行配置编译并运行该文件。

   如果使用终端，运行以下命令来编译并执行程序。

   javac UploadDataAndCreateIndex.java
   java UploadDataAndCreateIndex

   隐藏输出

   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. 登录Atlas 集群并验证以下内容：

   • 命名空间空间中的数据。

   • 集合的Atlas Vector Search索引。

创建并针对集合运行查询。

要测试嵌入，您可以对集合运行查询。使用嵌入模型提供商为查询文本生成 float、int8 和 int1 嵌入。以下示例代码使用 Cohere 的 embed API生成全精度向量。生成嵌入后，使用MongoDB Java驾驶员将原原生向量嵌入转换为BSON向量，并对集合运行$vectorSearch查询。

1. 在Java项目中创建一个名为 CreateEmbeddingsAndRunQuery.java 的新文件。

   touch CreateEmbeddingsAndRunQuery.java

2. 将以下代码复制并粘贴到 CreateEmbeddingsAndRunQuery.java 文件中。

   此代码执行以下操作：

   • 使用 Cohere 的 embed API 生成 float32、int8 和 ubinary 向量嵌入。

   • 使用MongoDB Java驾驶员将嵌入转换为BSON 向量。binData

   • 针对集合运行查询并返回结果。

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

3. 替换代码中的以下占位符值并保存文件。

   MONGODB_URI	Atlas 集群连接字符串（如果您未设立环境变量）。
   COHERE_API_KEY	如果您未设立环境变量，则使用 Cohere API密钥。
   <DATABASE-NAME>	Atlas 集群中数据库的名称。对于本示例，请使用 sample_airbnb。
   <COLLECTION-NAME>	您提取数据的集合的名称。对于本示例，请使用 listingsAndReviews。
   <INDEX-NAME>	集合的Atlas Vector Search索引的名称。
   <DATA-FIELD-NAME>	包含生成嵌入的文本的字段名称。对于本示例，请使用 summary。
   <QUERY-TEXT>	查询的文本。对于本示例，请使用 ocean view。

4. 使用应用程序运行配置编译并运行该文件。

   如果使用终端，运行以下命令来编译并执行程序。

   javac CreateEmbeddingsAndRunQuery.java
   java CreateEmbeddingsAndRunQuery

   隐藏输出

   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}

要学习；了解有关生成嵌入并将嵌入转换为 binData 向量的更多信息，请参阅如何创建向量嵌入。

安装所需的库。

运行以下命令以安装 MongoDB Node.js 驱动程序。此操作可能需要几分钟才能完成。

npm install mongodb

您必须安装 Node.js v6.11 或更高版本的驱动程序。如有必要，您还可安装来自嵌入模型提供商的库。例如，要使用 Cohere 来生成 float32、int8 与 int1 嵌入（如本页所示），请安装 Cohere：

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

在您的终端中设置环境变量。

1. 要访问嵌入模型提供商以生成和转换嵌入，请按需为嵌入模型提供商的 API 密钥设置环境变量。

   要使用 Cohere 的嵌入功能，请设置 COHERE_API_KEY 环境变量。

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

   如果您未设置环境变量，则请在运行此示例代码之前将代码中的 <COHERE-API-KEY> 替换为 API 密钥。

2. 要访问 Atlas 集群，请设置 MONGODB_URI 环境变量。

   export MONGODB_URI="<CONNECTION-STRING>"

   您的连接字符串应使用以下格式：

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

   如果您未设置该环境变量，则请在运行此示例代码之前将代码中的 <CONNECTION-STRING> 替换为您的连接字符串。

为您的数据生成向量嵌入。

1. 创建一个名为 get-embeddings.js 的文件，以使用 Cohere 的 embed API 来生成 float32、int8 与 int1 向量嵌入。

   touch get-embeddings.js

2. 将以下代码复制并粘贴到 get-embeddings.js 文件中。

   此代码执行以下操作：

   • 使用 Cohere 的 embed-english-v3.0 嵌入模型为给定数据生成 float32、int8 与 int1 嵌入。

   • 将 float、int8 和 int1 的嵌入分别存储在名为 float、int8 和 ubinary 的字段中。

   • 创建一个名为 embeddings.json 的文件，并将嵌入保存到该文件中。

   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. 如果您没有将 Cohere 的 API 密钥设为环境变量，则请替换 <COHERE_API_KEY> 占位符，然后保存该文件。

4. 运行此代码以生成嵌入。

   node get-embeddings.js

   隐藏输出

    Embeddings saved to embeddings.json

5. 验证所生成 embeddings.json 文件中的嵌入。

将这些向量嵌入转换为 binData 向量。

1. 创建一个名为 convert-embeddings.js 的文件，以使用 MongoDB Node.js 驱动程序将 Cohere 中的 float32、int8 与 int1 向量嵌入转换为 BSON binData 向量。

   touch convert-embeddings.js

2. 将以下代码复制并粘贴到 convert-embeddings.js 文件中。

   此代码执行以下操作：

   • 为 float32、int8 与 int1 嵌入生成 BSON binData 向量。

   • 将 float32、int8 与 ubinary BSON binData 向量追加到 embeddings.json 文件中。

   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. 运行此程序以生成 BSON binData 向量。

   node convert-embeddings.js

   隐藏输出

   Embeddings with BSON vectors have been saved to embeddings.json

4. 请验证 embeddings.json 文件中生成的 BSON 嵌入。

连接到 Atlas 集群并将数据上传到集合。

1. 创建一个名为 upload-data.js 的文件以连接到 Atlas 集群，并在数据库中为 embeddings.json 文件中的数据创建一个集合。

   touch upload-data.js

2. 将以下代码复制并粘贴到 upload-data.js 文件中。

   此代码执行以下操作：

   • 连接到您的 Atlas 集群，并使用您指定的数据库和集合名称创建一个命名空间。

   • 将包括嵌入在内的 embeddings.json 文件中的数据上传到指定的命名空间。

   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. 替换以下设置并保存该文件。

   <CONNECTION-STRING>	用于连接到您希望在其中创建数据库和集合的 Atlas 集群的连接字符串。 仅当您没有设置 MONGODB_URI 环境变量时，才需替换该值。
   <DB-NAME>	您要在其中创建集合的数据库的名称。
   <COLLECTION-NAME>	您要存储生成的嵌入的集合的名称。

4. 运行以下命令以上传该数据。

   node upload-data.js

5. 请确保这些文档存在于您 Atlas 集群上的集合中。

在集合上创建 Atlas Vector Search 索引。

1. 创建一个名为 create-index.js 的文件以在集合上定义 Atlas Vector Search 索引。

   touch create-index.js

2. 将以下代码复制并粘贴到 create-index.js 文件中以创建索引。

   此代码将执行以下操作：

   • 连接到 Atlas 集群，并为指定的命名空间创建一个具有指定名称的索引。

   • 将 bsonEmbeddings.float32 和 bsonEmbeddings.int8 字段索引为 vector 类型，使用 dotProduct 相似性函数，并将 bsonEmbeddings.int1 字段也索引为 vector 类型，使用 euclidean 函数。

   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. 替换以下设置并保存该文件。

   <CONNECTION-STRING>	用于连接到您要在其中创建该索引的 Atlas 集群的连接字符串。 仅当您没有设置 MONGODB_URI 环境变量时，才需替换该值。
   <DB-NAME>	您要在其中创建集合的数据库的名称。
   <COLLECTION-NAME>	您要存储生成的嵌入的集合的名称。
   <INDEX-NAME>	集合的索引名称。

4. 创建索引。

   node create-index.js

为查询文本生成嵌入。

1. 创建一个名为 get-query-embedding.js 的文件。

   touch get-query-embeddings.js

2. 将代码复制并粘贴到 get-query-embedding.js 文件中。

   示例代码执行以下操作：

   • 使用 Cohere 为查询文本生成 float32、int8 和 int1 嵌入。

   • 使用 PyMongo 将生成的嵌入转换为 BSON binData 向量。

   • 将生成的嵌入保存到名为 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. 替换以下设置并保存该文件。

   <COHERE-API-KEY>	您的 Cohere API 密钥。仅当您没有设置此环境变量时，才需替换该值。
   <QUERY-TEXT>	您的查询文本。在本教程中，使用 science fact。

4. 运行此代码以生成查询文本的嵌入。

   node get-query-embeddings.js

   隐藏输出

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