Quantização vetorial

Crie seu projeto Java e instale dependências.

1. No seu IDE, crie um projeto Java usando Maven ou Gradle.

2. Adicione as seguintes dependências, dependendo do seu gerenciador de pacotes:

   Maven

   Gradle

   Se você estiver utilizando o Maven, adicione as seguintes dependências à array dependencies no arquivo pom.xml do seu projeto:

   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>

   Se você estiver usando o Gradle, adicione o seguinte à array dependencies no arquivo build.gradle do seu projeto:

   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. Execute seu gerenciador de pacote para instalar as dependências em seu projeto.

Defina suas variáveis de ambiente.

No seu IDE, crie um novo modelo de configuração e adicione as seguintes variáveis ao seu projeto:

• Se você estiver usando o IntelliJ IDEA, crie um novo modelo de configuração de execução Application, depois adicione suas variáveis como valores separados por ponto e vírgula no campo Environment variables (por exemplo, FOO=123;BAR=456). Aplique as alterações e clique em OK.

  Para saber mais, consulte a seção Criar uma configuração de execução/depuração a partir de um modelo da documentação do IntelliJ IDEA.

• Se você estiver usando o Eclipse, crie uma nova configuração de inicialização Java Application e, em seguida, adicione cada variável como um novo par de valores-chave na guia Environment. Aplique as alterações e clique em OK.

  Para saber mais, consulte a seção Criando uma configuração de inicialização do aplicação Java da documentação do IDE do Eclipse.

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

Atualize os espaços reservados com os seguintes valores:

• Substitua o valor do espaço reservado <api-key> por sua chave de API Cohere.

• Substitua o <connection-string> valor do espaço reservado pela string de conexão SRVdo seu Atlas cluster.

  Sua string de conexão deve usar o seguinte formato:

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

(Condicional) Gere incorporações a partir de seus dados.

Você pode usar um fornecedor de modelo de incorporação para gerar incorporações float, int8 e int1 para seus dados e, em seguida, usar o driver Java do MongoDB para converter sua incorporação de vetor nativo em vetores BSON. O código de exemplo a seguir usa a API embed do Cohere para gerar vetores de precisão total a partir dos dados no namespace sample_airbnb.listingsAndReviews.

1. Crie um novo arquivo denominado GenerateAndConvertEmbeddings.java em seu projeto Java .

   touch GenerateAndConvertEmbeddings.java

2. Copie e cole o seguinte código no arquivo GenerateAndConvertEmbeddings.java.

   Este código faz o seguinte:

   • Obtém o campo summary de 50 documentos no namespace sample_airbnb.listingsAndReviews .

   • Gera as incorporações de vetor float32, int8 e ubinary usando a API embed do Cohere.

   • Converte as incorporações em vetores BSONbinData usando o driver Java do MongoDB.

   • Cria um arquivo chamado embeddings.json e salva os dados com incorporações no arquivo.

   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. Substitua os seguintes valores de espaço reservado no código se você não definiu as variáveis de ambiente e salvou o arquivo.

   MONGODB_URI	Sua string de conexão do cluster do Atlas se você não tiver definido a variável de ambiente.
   COHERE_API_KEY	Sua chave de API Cohere se não definiu a variável de ambiente.

4. Compile e execute o arquivo usando sua configuração de execução do aplicação .

   Se você estiver usando um terminal, execute os seguintes comandos para compilar e executar seu programa.

   javac GenerateAndConvertEmbeddings.java
   java GenerateAndConvertEmbeddings

   OCULTAR SAÍDA

   [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. Verifique as incorporações no arquivo embeddings.json.

Para saber mais sobre como gerar incorporações e converter as incorporações em vetores binData, consulte Como criar incorporações vetoriais.

Faça a ingestão dos dados e crie um índice do Atlas Vector Search .

Você deve fazer o upload dos seus dados e incorporações para uma collection no seu Atlas cluster e criar um índice do Atlas Vector Search nos dados para executar $vectorSearch queries nos dados.

1. Crie um novo arquivo denominado UploadDataAndCreateIndex.java em seu projeto Java .

   touch UploadDataAndCreateIndex.java

2. Copie e cole o seguinte código no arquivo UploadDataAndCreateIndex.java.

   Este código faz o seguinte:

   • Carrega as incorporações float32, int8 e int1 no arquivo embeddings.json para seu cluster do Atlas .

   • Cria um índice do Atlas Vector Search nos campos embeddings.float32, embeddings.int8 e embeddings.int1.

   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. Substitua os seguintes valores de espaço reservado no código e salve o arquivo.

   MONGODB_URI	Sua string de conexão do cluster do Atlas se você não tiver definido a variável de ambiente.
   <INDEX-NAME>	Nome do índice do Atlas Vector Search para a coleção.

4. Compile e execute o arquivo usando sua configuração de execução do aplicação .

   Se você estiver usando um terminal, execute os seguintes comandos para compilar e executar seu programa.

   javac UploadDataAndCreateIndex.java
   java UploadDataAndCreateIndex

   OCULTAR SAÍDA

   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. Inicie sessão no seu cluster do Atlas e verifique o seguinte:

   • Dados no namespace.

   • Índice do Atlas Vector Search para a coleção.

Crie e execute uma query na coleção.

Para testar suas incorporações, você pode executar uma query em sua coleção. Utilize um fornecedor de modelo de incorporação para gerar incorporações float, int8 e int1 para seu texto de query. O código de exemplo a seguir usa a API embed do Cohere para gerar vetores de precisão total. Depois de gerar as incorporações, use o driver Java do MongoDB para converter sua incorporação de vetor nativo em vetores BSON e execute a $vectorSearch query na coleção.

1. Crie um novo arquivo denominado CreateEmbeddingsAndRunQuery.java em seu projeto Java .

   touch CreateEmbeddingsAndRunQuery.java

2. Copie e cole o seguinte código no arquivo CreateEmbeddingsAndRunQuery.java.

   Este código faz o seguinte:

   • Gera as incorporações de vetor float32, int8 e ubinary usando a API embed do Cohere.

   • Converte as incorporações em vetores BSONbinData usando o driver Java do MongoDB.

   • Executa a query na sua collection e retorna os resultados.

   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. Substitua os seguintes valores de espaço reservado no código e salve o arquivo.

   MONGODB_URI	Sua string de conexão do cluster do Atlas se você não tiver definido a variável de ambiente.
   COHERE_API_KEY	Sua chave de API Cohere se não definiu a variável de ambiente.
   <DATABASE-NAME>	Nome do banco de dados em seu Atlas cluster. Para este exemplo, use sample_airbnb.
   <COLLECTION-NAME>	Nome da coleção onde você ingeriu os dados. Para este exemplo, use listingsAndReviews.
   <INDEX-NAME>	Nome do índice do Atlas Vector Search para a coleção.
   <DATA-FIELD-NAME>	Nome do campo que contém o texto a partir do qual você gerou as incorporações. Para este exemplo, use summary.
   <QUERY-TEXT>	Texto para a query. Para este exemplo, use ocean view.

4. Compile e execute o arquivo usando sua configuração de execução do aplicação .

   Se você estiver usando um terminal, execute os seguintes comandos para compilar e executar seu programa.

   javac CreateEmbeddingsAndRunQuery.java
   java CreateEmbeddingsAndRunQuery

   OCULTAR SAÍDA

   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}

Para saber mais sobre como gerar incorporações e converter as incorporações em vetores binData, consulte Como criar incorporações vetoriais.