벡터 양자화

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 키로 바꿉니다.

• 자리 <connection-string> 표시자 값을 Atlas cluster 의 SRV 연결 문자열 로 바꿉니다.

  연결 문자열은 다음 형식을 사용해야 합니다.

  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 인덱스 생성합니다.

데이터에 대해 $vectorSearch 쿼리를 실행 하려면 데이터와 임베딩을 Atlas cluster 의 컬렉션 에 업로드하고 데이터에 Atlas Vector Search 인덱스 만들어야 합니다.

1. Java 프로젝트 에 UploadDataAndCreateIndex.java 이라는 새 파일 을 만듭니다.

   touch UploadDataAndCreateIndex.java

2. 다음 코드를 복사하여 UploadDataAndCreateIndex.java 파일에 붙여넣습니다.

   이 코드는 다음을 수행합니다.

   • embeddings.json 파일 의 데이터를 Atlas cluster 에 업로드합니다.

   • 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 cluster 연결 문자열 입니다.
   <DATABASE-NAME>	Atlas cluster 에 있는 데이터베이스 의 이름입니다.
   <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 cluster 에 로그인하고 다음을 확인합니다.

   • 네임스페이스 의 데이터입니다.

   • 컬렉션 에 대한 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 cluster 연결 문자열 입니다.
   COHERE_API_KEY	환경 변수를 설정하다 하지 않은 경우 Cohere API 키가 필요합니다.
   <DATABASE-NAME>	Atlas cluster 에 있는 데이터베이스 의 이름입니다.
   <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 키로 바꿉니다.

• 자리 <connection-string> 표시자 값을 Atlas cluster 의 SRV 연결 문자열 로 바꿉니다.

  연결 문자열은 다음 형식을 사용해야 합니다.

  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 cluster 연결 문자열 입니다.
   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 인덱스 생성합니다.

데이터에 대해 $vectorSearch 쿼리를 실행 하려면 데이터와 임베딩을 Atlas cluster 의 컬렉션 에 업로드하고 데이터에 Atlas Vector Search 인덱스 만들어야 합니다.

1. Java 프로젝트 에 UploadDataAndCreateIndex.java 이라는 새 파일 을 만듭니다.

   touch UploadDataAndCreateIndex.java

2. 다음 코드를 복사하여 UploadDataAndCreateIndex.java 파일에 붙여넣습니다.

   이 코드는 다음을 수행합니다.

   • embeddings.json 파일 의 float32, int8 및 int1 임베딩을 Atlas cluster 에 업로드합니다.

   • 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 cluster 연결 문자열 입니다.
   <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 cluster 에 로그인하고 다음을 확인합니다.

   • 네임스페이스 의 데이터입니다.

   • 컬렉션 에 대한 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 cluster 연결 문자열 입니다.
   COHERE_API_KEY	환경 변수를 설정하다 하지 않은 경우 Cohere API 키가 필요합니다.
   <DATABASE-NAME>	Atlas cluster 에 있는 데이터베이스 의 이름입니다. 이 예시 에서는 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. Cohere의 embed API를 사용하여 float32, int8 및 int1 벡터 임베딩을 생성하기 위해 get-embeddings.js 파일을 만듭니다.

   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. MongoDB Node.js 드라이버를 사용하여 Cohere의 float32, int8 및 int1 벡터 임베딩을 BSON binData 벡터로 변환하기 위해 convert-embeddings.js 파일을 만듭니다.

   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. 컬렉션에 Atlas Vector Search 인덱스를 정의하기 위해 create-index.js 파일을 생성합니다.

   touch create-index.js

2. create-index.js 파일에 인덱스를 생성하기 위해 다음 코드를 복사하여 붙여넣습니다.

   이 코드는 다음을 수행합니다.

   • Atlas 클러스터에 연결하고 지정된 네임스페이스에 대해 지정된 이름으로 인덱스를 생성합니다.

   • bsonEmbeddings.float32 및 bsonEmbeddings.int8 필드를 dotProduct 유사성 함수를 사용하는 vector 유형으로 인덱싱하고, bsonEmbeddings.int1 필드를 euclidean 함수를 사용하는 vector 유형으로 인덱싱합니다.

   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