벡터 양자화

필요한 라이브러리를 설치합니다.

다음 명령을 실행하여 MongoDB 고 (Go) 드라이버 설치합니다. 이 작업을 완료하는 데 몇 분 정도 걸릴 수 있습니다.

go get go.mongodb.org/mongo-driver/v2/mongo

고 (Go) v2.1 이상의 운전자 설치해야 합니다. 필요한 경우 임베딩 모델 제공자 로부터 라이브러리를 설치할 수도 있습니다. 예시 를 들어 이 페이지에 설명된 대로 코히어를 사용하여 float32, int8 및 int1 임베딩을 생성하려면 코히어를 설치합니다.

go get github.com/cohere-ai/cohere-go/v2/client@v2.13.0

Go 프로젝트를 초기화합니다.

터미널 창에서 다음 명령을 실행하여 ingest-binary-vectors라는 이름의 새 디렉토리를 만들고 프로젝트를 초기화합니다.

mkdir ingest-binary-vectors-project
cd ingest-binary-vectors-project
go mod init ingest-binary-vectors-project

터미널에서 환경 변수를 설정합니다.

1. 임베딩을 생성하고 변환하기 위해 임베딩 모델 제공자에 액세스하려면, 필요에 따라 임베딩 모델 제공자의 API 키에 대한 환경 변수를 설정하세요.

   Cohere의 임베딩을 사용하기 위해 COHERE_API_KEY 환경 변수를 설정하세요.

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

2. Atlas 클러스터에 액세스하려면 MONGODB_URI 환경 변수를 설정하세요.

   export MONGODB_URI="<CONNECTION-STRING>"

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

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

(조건부)데이터에서 임베딩을 생성합니다.

임베딩 모델 제공자 사용하여 데이터에 대한 float32, int8 및 int1 임베딩을 생성한 다음 MongoDB 고 (Go) 운전자 사용하여 네이티브 벡터 임베딩을 BSON 벡터로 변환할 수 있습니다. 다음 샘플 코드는 Cohere의 embed API 사용하여 완전 정밀도 벡터를 생성합니다.

1. 고 (Go) 프로젝트 에 GenerateAndConvertEmbeddings.go 이라는 새 파일 을 만듭니다.

   touch GenerateAndConvertEmbeddings.go

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

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

   • Cohere의 embed API를 사용하여 float32, int8, ubinary 벡터 임베딩을 생성합니다.

   • MongoDB 고 (Go) 운전자 사용하여 임베딩을 BSON 벡터로 변환합니다.binData

   • embeddings.json 파일을 만들고 이 파일에 데이터와 임베딩을 저장합니다.

   GenerateAndConvertEmbeddings.go

   1
   package main  
   2
     
   3
   import (  
   4
   	"context"  
   5
   	"encoding/json"  
   6
   	"fmt"  
   7
   	"log"  
   8
   	"os"  
   9
     
   10
   	cohere "github.com/cohere-ai/cohere-go/v2"  
   11
   	cohereclient "github.com/cohere-ai/cohere-go/v2/client"  
   12
   	"go.mongodb.org/mongo-driver/v2/bson"  
   13
   )  
   14
     
   15
   // Sample data for embedding  
   16
   var data = []string{  
   17
   	"The Great Wall of China is visible from space.",  
   18
   	"The Eiffel Tower was completed in Paris in 1889.",  
   19
   	"Mount Everest is the highest peak on Earth at 8,848m.",  
   20
   	"Shakespeare wrote 37 plays and 154 sonnets during his lifetime.",  
   21
   	"The Mona Lisa was painted by Leonardo da Vinci.",  
   22
   }  
   23
     
   24
   func main() {  
   25
   	apiKey := os.Getenv("COHERE_API_KEY")  
   26
   	if apiKey == "" {  
   27
   		log.Fatal("Ensure COHERE_API_KEY is set.")  
   28
   	}  
   29
     
   30
   	client := cohereclient.NewClient(cohereclient.WithToken(apiKey))  
   31
     
   32
   	embeddings, err := fetchEmbeddingsFromCohere(client)  
   33
   	if err != nil {  
   34
   		log.Fatalf("Error fetching embeddings: %v", err)  
   35
   	}  
   36
     
   37
   	documents := convertEmbeddingsToBSON(data, embeddings)  
   38
     
   39
   	err = writeJSONToFile("embeddings.json", documents)  
   40
   	if err != nil {  
   41
   		log.Fatalf("Error writing embeddings to file: %v", err)  
   42
   	}  
   43
     
   44
   	fmt.Println("Embeddings successfully stored in embeddings.json")  
   45
   }  
   46
     
   47
   // Fetch embeddings using Cohere API  
   48
   func fetchEmbeddingsFromCohere(client *cohereclient.Client) (*cohere.EmbedByTypeResponse, error) {  
   49
   	model := "embed-english-v3.0"  
   50
   	response, err := client.V2.Embed(context.TODO(), &cohere.V2EmbedRequest{  
   51
   		Texts:     data,  
   52
   		Model:     model,  
   53
   		InputType: cohere.EmbedInputTypeSearchDocument,  
   54
   		EmbeddingTypes: []cohere.EmbeddingType{  
   55
   			cohere.EmbeddingTypeFloat,  
   56
   			cohere.EmbeddingTypeInt8,  
   57
   			cohere.EmbeddingTypeUbinary,  
   58
   		},  
   59
   	})  
   60
   	if err != nil {  
   61
   		return nil, fmt.Errorf("failed to fetch embeddings: %w", err)  
   62
   	}  
   63
   	return response, nil  
   64
   }  
   65
     
   66
   // Convert embeddings to BSON binary vectors  
   67
   func convertEmbeddingsToBSON(sentences []string, embeddings *cohere.EmbedByTypeResponse) []bson.M {  
   68
   	var documents []bson.M  
   69
     
   70
   	for i, sentence := range sentences {  
   71
   		float32Emb := convertFloat64ToFloat32(embeddings.Embeddings.Float[i])  
   72
   		int8Emb := convertIntToInt8(embeddings.Embeddings.Int8[i])  
   73
   		ubinaryEmb := convertIntToBytes(embeddings.Embeddings.Ubinary[i])  
   74
     
   75
   		floatVector := bson.NewVector(float32Emb)  
   76
   		int8Vector := bson.NewVector(int8Emb)  
   77
   		ubinaryVector, err := bson.NewPackedBitVector(ubinaryEmb, 0)  
   78
   		if err != nil {  
   79
   			log.Fatalf("Error creating PackedBitVector: %v", err)  
   80
   		}  
   81
     
   82
   		document := bson.M{  
   83
   			"text":               sentence,  
   84
   			"embeddings_float32": floatVector.Binary(),  
   85
   			"embeddings_int8":    int8Vector.Binary(),  
   86
   			"embeddings_int1":    ubinaryVector.Binary(),  
   87
   		}  
   88
   		documents = append(documents, document)  
   89
   	}  
   90
     
   91
   	return documents  
   92
   }  
   93
     
   94
   // Write JSON file from in-memory BSON documents  
   95
   func writeJSONToFile(filename string, documents []bson.M) error {  
   96
   	file, err := os.Create(filename)  
   97
   	if err != nil {  
   98
   		return fmt.Errorf("failed to create file: %w", err)  
   99
   	}  
   100
   	defer file.Close()  
   101
     
   102
   	var jsonData []json.RawMessage  
   103
   	for _, document := range documents {  
   104
   		jsonBytes, err := bson.MarshalExtJSON(document, false, false)  
   105
   		if err != nil {  
   106
   			return fmt.Errorf("error marshaling BSON to JSON: %w", err)  
   107
   		}  
   108
   		jsonData = append(jsonData, jsonBytes)  
   109
   	}  
   110
     
   111
   	marshaledData, err := json.MarshalIndent(jsonData, "", "  ")  
   112
   	if err != nil {  
   113
   		return fmt.Errorf("failed to marshal JSON: %w", err)  
   114
   	}  
   115
     
   116
   	_, err = file.Write(marshaledData)  
   117
   	if err != nil {  
   118
   		return fmt.Errorf("failed to write JSON to file: %w", err)  
   119
   	}  
   120
     
   121
   	return nil  
   122
   }  
   123
     
   124
   // Convert a slice of float64 to a slice of float32  
   125
   func convertFloat64ToFloat32(f64s []float64) []float32 {  
   126
   	f32s := make([]float32, len(f64s))  
   127
   	for i, v := range f64s {  
   128
   		f32s[i] = float32(v)  
   129
   	}  
   130
   	return f32s  
   131
   }  
   132
     
   133
   // Convert a slice of int to a slice of int8  
   134
   func convertIntToInt8(ints []int) []int8 {  
   135
   	ints8 := make([]int8, len(ints))  
   136
   	for i, val := range ints {  
   137
   		ints8[i] = int8(val)  
   138
   	}  
   139
   	return ints8  
   140
   }  
   141
     
   142
   // Convert a slice of int to a slice of bytes  
   143
   func convertIntToBytes(ints []int) []byte {  
   144
   	bytes := make([]byte, len(ints))  
   145
   	for i, val := range ints {  
   146
   		bytes[i] = byte(val)  
   147
   	}  
   148
   	return bytes  
   149
   }  

3. 코드에서 다음 자리 표시자 값을 바꾸고 파일 저장합니다.

   COHERE_API_KEY	환경 변수를 설정하다 하지 않은 경우에만 Cohere API 키를 사용할 수 있습니다.

4. 다음 명령을 사용하여 프로그램을 실행합니다.

   터미널을 사용하는 경우에는 다음 명령어를 실행하여 프로그램을 컴파일하고 실행합니다.

   go run GenerateAndConvertEmbeddings.go

   출력 숨기기

   Embeddings successfully stored in embeddings.json

5. embeddings.json 파일의 임베딩을 확인합니다.

임베딩을 생성하고 임베딩을 binData 벡터로 변환하는 방법에 대한 자세한 내용은 벡터 임베딩 생성 방법을 참조하세요.

데이터를 수집하고 Atlas Vector Search 인덱스를 생성합니다.

데이터와 임베딩을 Atlas 클러스터의 컬렉션에 업로드하고 해당 데이터에 Atlas Vector Search 인덱스를 생성하여 $vectorSearch 쿼리를 실행해야 합니다.

1. 고 (Go) 프로젝트 에 UploadDataAndCreateIndex.go 이라는 새 파일 을 만듭니다.

   touch UploadDataAndCreateIndex.go

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

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

   • embeddings.json 파일의 float32, int8, int1 임베딩을 Atlas 클러스터에 업로드합니다.

   • embeddings.float32, embeddings.int8, embeddings.int1 필드에 Atlas Vector Search 인덱스를 생성합니다.

   UploadDataAndCreateIndex.go

   1
   package main
   2
   3
   import (
   4
   	"context"
   5
   	"fmt"
   6
   	"io/ioutil"
   7
   	"log"
   8
   	"time"
   9
   	"os"
   10
   11
   	"go.mongodb.org/mongo-driver/v2/bson"
   12
   	"go.mongodb.org/mongo-driver/v2/mongo"
   13
   	"go.mongodb.org/mongo-driver/v2/mongo/options"
   14
   )
   15
   16
   var (
   17
   	mongodbURI          = os.Getenv("MONGODB_URI")
   18
   	dbName              = "<DATABASE-NAME>"
   19
   	collectionName      = "<COLLECTION-NAME>"
   20
   	indexName           = "<INDEX-NAME>"
   21
   	numberOfDimensions  = 1024
   22
   	embeddingFields     = []string{"embeddings_float32", "embeddings_int8", "embeddings_int1"}
   23
   	embeddingSimilarity = []string{"dotProduct", "dotProduct", "euclidean"}
   24
   )
   25
   26
   func main() {
   27
   	clientOpts := options.Client().ApplyURI(mongodbURI)
   28
   	client, err := mongo.Connect(clientOpts)
   29
   	if err != nil {
   30
   		log.Fatalf("Failed to connect to MongoDB: %v", err)
   31
   	}
   32
   33
   	defer func() {
   34
   		if err := client.Disconnect(context.TODO()); err != nil {
   35
   			log.Fatalf("Failed to disconnect MongoDB client: %v", err)
   36
   		}
   37
   	}()
   38
   39
   	storeEmbeddings(client)
   40
   	setupVectorSearchIndex(client)
   41
   }
   42
   43
   // Reads JSON data, stores it in MongoDB
   44
   func storeEmbeddings(client *mongo.Client) {
   45
   	database := client.Database(dbName)
   46
   	collection := database.Collection(collectionName)
   47
   48
   	data, err := ioutil.ReadFile("embeddings.json")
   49
   	if err != nil {
   50
   		log.Fatalf("Failed to read file: %v", err)
   51
   	}
   52
   53
   	var documents []bson.M
   54
   	if err := bson.UnmarshalExtJSON(data, false, &documents); err != nil {
   55
   		log.Fatalf("Failed to unmarshal JSON data: %v", err)
   56
   	}
   57
   58
   	if _, err := collection.InsertMany(context.TODO(), documents); err != nil {
   59
   		log.Fatalf("Failed to insert documents: %v", err)
   60
   	}
   61
   62
   	fmt.Println("Inserted documents into MongoDB")
   63
   }
   64
   65
   // Sets up vector search index in MongoDB
   66
   func setupVectorSearchIndex(client *mongo.Client) {
   67
   	database := client.Database(dbName)
   68
   	collection := database.Collection(collectionName)
   69
   70
   	ctx := context.TODO()
   71
   72
   	type vectorDefinitionField struct {
   73
   		Type          string `bson:"type"`
   74
   		Path          string `bson:"path"`
   75
   		NumDimensions int    `bson:"numDimensions"`
   76
   		Similarity    string `bson:"similarity"`
   77
   	}
   78
   79
   	type vectorDefinition struct {
   80
   		Fields []vectorDefinitionField `bson:"fields"`
   81
   	}
   82
   83
   	fields := make([]vectorDefinitionField, len(embeddingFields))
   84
   	for i, field := range embeddingFields {
   85
   		fields[i] = vectorDefinitionField{
   86
   			Type:          "vector",
   87
   			Path:          field,
   88
   			NumDimensions: numberOfDimensions,
   89
   			Similarity:    embeddingSimilarity[i],
   90
   		}
   91
   	}
   92
   	fmt.Println(fields)
   93
   94
   	opts := options.SearchIndexes().SetName(indexName).SetType("vectorSearch")
   95
   96
   	indexModel := mongo.SearchIndexModel{
   97
   		Definition: vectorDefinition{
   98
   			Fields: fields,
   99
   		},
   100
   		Options: opts,
   101
   	}
   102
   103
   	// Create the index
   104
   	log.Println("Creating the index.")
   105
   	searchIndexName, err := collection.SearchIndexes().CreateOne(ctx, indexModel)
   106
   	if err != nil {
   107
   		log.Fatalf("Failed to create the search index: %v", err)
   108
   	}
   109
   110
   	// Polling to confirm successful index creation
   111
   	log.Println("Polling to confirm successful index creation.")
   112
   	log.Println("NOTE: This may take up to a minute.")
   113
   	searchIndexes := collection.SearchIndexes()
   114
   	var doc bson.Raw
   115
   116
   	for doc == nil {
   117
   		cursor, err := searchIndexes.List(ctx, options.SearchIndexes().SetName(searchIndexName))
   118
   		if err != nil {
   119
   			log.Fatalf("failed to list search indexes: %v", err)
   120
   		}
   121
   122
   		if !cursor.Next(ctx) {
   123
   			break
   124
   		}
   125
   126
   		name := cursor.Current.Lookup("name").StringValue()
   127
   		queryable := cursor.Current.Lookup("queryable").Boolean()
   128
   		if name == searchIndexName && queryable {
   129
   			doc = cursor.Current
   130
   		} else {
   131
   			time.Sleep(5 * time.Second)
   132
   		}
   133
   	}
   134
   135
   	log.Println("Name of Index Created: " + searchIndexName)
   136
   }

3. 다음을 코드의 유효한 값으로 바꾸고 파일 저장합니다.

   MONGODB_URI	환경 변수를 설정하지 않은 경우 Atlas 클러스터 연결 문자열입니다.
   <DATABASE-NAME>	컬렉션에 대한 Atlas Vector Search 인덱스의 이름입니다.
   <COLLECTION-NAME>	컬렉션에 대한 Atlas Vector Search 인덱스의 이름입니다.
   <INDEX-NAME>	컬렉션에 대한 Atlas Vector Search 인덱스의 이름입니다.

4. 다음 명령을 사용하여 프로그램을 실행합니다.

   터미널을 사용하는 경우에는 다음 명령어를 실행하여 프로그램을 컴파일하고 실행합니다.

   go run UploadDataAndCreateIndex.go

   출력 숨기기

   Inserted documents into MongoDB
   Creating the index.
   Polling to confirm successful index creation.
   NOTE: This may take up to a minute.
   Name of Index Created: <INDEX-NAME>

5. Atlas 클러스터에 로그인하고 다음을 확인하세요.

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

   • 컬렉션에 대한 Atlas Vector Search 인덱스입니다.

컬렉션에 대해 쿼리를 생성하고 실행합니다.

임베딩을 테스트하려면 컬렉션 에 대해 쿼리 실행 수 있습니다. 임베딩 모델 제공자 사용하여 쿼리 텍스트에 대한 float32, int8 및 int1 임베딩을 생성합니다. 다음 샘플 코드는 Cohere의 embed API 사용하여 완전 정밀도 벡터를 생성합니다. 임베딩을 생성한 후 MongoDB 고 (Go) 운전자 사용하여 네이티브 벡터 임베딩을 BSON 바이너리 벡터로 $vectorSearch 변환하고 컬렉션 에 대해 쿼리 실행 .

1. 고 (Go) 프로젝트 에 CreateEmbeddingsAndRunQuery.go 이라는 새 파일 을 만듭니다.

   touch CreateEmbeddingsAndRunQuery.go

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

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

   • Cohere의 embed API를 사용하여 float32, int8, ubinary 벡터 임베딩을 생성합니다.

   • MongoDB 고 (Go) 운전자 사용하여 임베딩을 BSON 벡터로 변환합니다.binData

   • 컬렉션에 대해 쿼리를 실행하고 결과를 반환합니다.

   CreateEmbeddingsAndRunQuery.go

   1
   package main
   2
   3
   import (
   4
           "context"
   5
           "fmt"
   6
           "log"
   7
           "os"
   8
   9
           cohere "github.com/cohere-ai/cohere-go/v2"
   10
           cohereclient "github.com/cohere-ai/cohere-go/v2/client"
   11
           "go.mongodb.org/mongo-driver/v2/bson"
   12
           "go.mongodb.org/mongo-driver/v2/mongo"
   13
           "go.mongodb.org/mongo-driver/v2/mongo/options"
   14
   )
   15
   16
   const (
   17
   	dbName          = "<DATABASE-NAME>"
   18
   	collectionName  = "<COLLECTION-NAME>"
   19
   	vectorIndexName = "<INDEX-NAME>"
   20
   	dataFieldName   = "<TEXT-FIELD-NAME>"
   21
   	queryText       = "<QUERY-TEXT>"
   22
   )
   23
   24
   func main() {
   25
   	apiKey := os.Getenv("COHERE_API_KEY")
   26
   	mongodbURI := os.Getenv("MONGODB_URI")
   27
   28
   	if apiKey == "" {
   29
   		log.Fatal("API key not found. Set COHERE_API_KEY in your environment.")
   30
   	}
   31
   	if mongodbURI == "" {
   32
   		log.Fatal("MongoDB URI not found. Set MONGODB_URI in your environment.")
   33
   	}
   34
   35
   	embeddingsData, err := generateAndConvertEmbeddings(apiKey, queryText)
   36
   	if err != nil {
   37
   		log.Fatalf("Error generating embeddings: %v", err)
   38
   	}
   39
   40
   	err = runVectorSearchQuery(mongodbURI, embeddingsData)
   41
   	if err != nil {
   42
   		log.Fatalf("Error running vector search query: %v", err)
   43
   	}
   44
   }
   45
   46
   // Generate embeddings using Cohere's embed API from the query text
   47
   func generateAndConvertEmbeddings(apiKey, text string) (map[string]bson.Binary, error) {
   48
   	client := cohereclient.NewClient(cohereclient.WithToken(apiKey))
   49
   50
   	model := "embed-english-v3.0"
   51
   	response, err := client.V2.Embed(context.TODO(), &cohere.V2EmbedRequest{
   52
   		Texts:     []string{text},
   53
   		Model:     model,
   54
   		InputType: cohere.EmbedInputTypeSearchQuery,
   55
   		EmbeddingTypes: []cohere.EmbeddingType{
   56
   			cohere.EmbeddingTypeFloat,
   57
   			cohere.EmbeddingTypeInt8,
   58
   			cohere.EmbeddingTypeUbinary,
   59
   		},
   60
   	})
   61
   	if err != nil {
   62
   		return nil, fmt.Errorf("failed to fetch embeddings: %w", err)
   63
   	}
   64
   65
   	if response.Embeddings == nil || len(response.Embeddings.Float) == 0 {
   66
   		return nil, fmt.Errorf("no embeddings found in the API response")
   67
   	}
   68
   69
   	return createBSONVectorEmbeddings(response.Embeddings), nil
   70
   }
   71
   72
   // Convert embeddings to BSON vectors using MongoDB Go Driver
   73
   func createBSONVectorEmbeddings(embeddings *cohere.EmbedByTypeResponseEmbeddings) map[string]bson.Binary {
   74
   	bsonVectorEmbeddings := make(map[string]bson.Binary)
   75
   76
   	// Convert float embeddings
   77
   	if len(embeddings.Float) > 0 {
   78
   		floatData := convertFloat64ToFloat32(embeddings.Float[0])
   79
   		floatVector := bson.NewVector(floatData) // Here, we are using bson.NewVector to create a BSON Vector.
   80
   		bsonVectorEmbeddings["float32"] = floatVector.Binary()
   81
   	}
   82
   83
   	// Convert int8 embeddings
   84
   	if len(embeddings.Int8) > 0 {
   85
   		int8Data := convertIntToInt8(embeddings.Int8[0])
   86
   		int8Vector := bson.NewVector(int8Data) // Similarly, create BSON Vector for int8 data.
   87
   		bsonVectorEmbeddings["int8"] = int8Vector.Binary()
   88
   	}
   89
   90
   	// Convert ubinary embeddings to a packed bit vector
   91
   	if len(embeddings.Ubinary) > 0 {
   92
   		int1Data := convertIntToBytes(embeddings.Ubinary[0])
   93
   		ubinaryVector, _ := bson.NewPackedBitVector(int1Data, 0) // Packed bit using bson.NewPackedBitVector
   94
   		bsonVectorEmbeddings["int1"] = ubinaryVector.Binary()
   95
   	}
   96
   97
   	return bsonVectorEmbeddings
   98
   }
   99
   100
   // Run $vectorSearch query using the embeddings
   101
   func runVectorSearchQuery(mongodbURI string, embeddingsData map[string]bson.Binary) error {
   102
   	ctx := context.Background()
   103
   	clientOptions := options.Client().ApplyURI(mongodbURI)
   104
   	client, err := mongo.Connect(clientOptions)
   105
   	if err != nil {
   106
   		return fmt.Errorf("failed to connect to MongoDB: %w", err)
   107
   	}
   108
   	defer func() { _ = client.Disconnect(ctx) }()
   109
   110
   	db := client.Database(dbName)
   111
   	collection := db.Collection(collectionName)
   112
   113
   	// Map the correct paths for embeddings
   114
   	pathMap := map[string]string{
   115
   		"float32": "embeddings_float32",
   116
   		"int8":    "embeddings_int8",
   117
   		"int1":    "embeddings_int1",
   118
   	}
   119
   120
   	for pathKey, queryVector := range embeddingsData {
   121
   		path, ok := pathMap[pathKey]
   122
   		if !ok {
   123
   			return fmt.Errorf("invalid path key: %s", pathKey)
   124
   		}
   125
   126
   		pipeline := mongo.Pipeline{
   127
   			{
   128
   				{"$vectorSearch", bson.D{
   129
   					{"queryVector", queryVector},
   130
   					{"index", vectorIndexName},
   131
   					{"path", path},
   132
   					{"numCandidates", 5},
   133
   					{"limit", 2},
   134
   				}},
   135
   			},
   136
   			{
   137
   				{"$project", bson.D{
   138
   					{"_id", 1},
   139
   					{dataFieldName, 1},
   140
   					{"score", bson.D{
   141
   						{"$meta", "vectorSearchScore"},
   142
   					}},
   143
   				}},
   144
   			},
   145
   		}
   146
   147
   		cursor, err := collection.Aggregate(context.Background(), pipeline)
   148
   		if err != nil {
   149
   			return fmt.Errorf("failed to run vector search aggregation query: %w", err)
   150
   		}
   151
   		defer cursor.Close(ctx)
   152
   153
   		var results []bson.M
   154
   		if err = cursor.All(context.Background(), &results); err != nil {
   155
   			return fmt.Errorf("failed to parse aggregation query results: %w", err)
   156
   		}
   157
   158
   		fmt.Printf("Results from %v embeddings:\n", path)
   159
   		for _, result := range results {
   160
   			fmt.Println(result)
   161
   		}
   162
   	}
   163
   164
   	return nil
   165
   }
   166
   167
   // Utility functions to handle list conversion
   168
   func convertFloat64ToFloat32(f64s []float64) []float32 {
   169
   	f32s := make([]float32, len(f64s))
   170
   	for i, v := range f64s {
   171
   		f32s[i] = float32(v)
   172
   	}
   173
   	return f32s
   174
   }
   175
   176
   func convertIntToInt8(ints []int) []int8 {
   177
   	ints8 := make([]int8, len(ints))
   178
   	for i, val := range ints {
   179
   		ints8[i] = int8(val)
   180
   	}
   181
   	return ints8
   182
   }
   183
   184
   func convertIntToBytes(ints []int) []byte {
   185
   	bytes := make([]byte, len(ints))
   186
   	for i, val := range ints {
   187
   		bytes[i] = byte(val)
   188
   	}
   189
   	return bytes
   190
   }

3. 코드에서 다음 자리 표시자 값을 바꾸고 파일을 저장합니다.

   MONGODB_URI	환경 변수를 설정하지 않은 경우 Atlas 클러스터 연결 문자열입니다.
   COHERE_API_KEY	환경 변수를 설정하다 하지 않은 경우에만 Cohere API 키를 사용할 수 있습니다.
   <DATABASE-NAME>	Atlas 클러스터에 있는 데이터베이스의 이름입니다.
   <COLLECTION-NAME>	데이터를 삽입한 컬렉션의 이름입니다.
   <INDEX-NAME>	컬렉션에 대한 Atlas Vector Search 인덱스의 이름입니다.
   <TEXT-FIELD-NAME>	임베딩을 생성한 텍스트가 포함된 필드 의 이름입니다.
   <QUERY-TEXT>	쿼리의 텍스트입니다. 이 예시에서는 science fact을(를) 사용합니다.

4. 애플리케이션 실행 구성을 사용하여 파일을 컴파일하고 실행합니다.

   터미널을 사용하는 경우에는 다음 명령어를 실행하여 프로그램을 컴파일하고 실행합니다.

   go run CreateEmbeddingsAndRunQuery.go

   출력 숨기기

   Results from embeddings_int1 embeddings:
   {"_id":{"$oid":"68129070e7f516cc19658bc9"},"text":"Mount Everest is the highest peak on Earth at 8,848m.","score":{"$numberDouble":"0.642578125"}}
   {"text":"The Great Wall of China is visible from space.","score":{"$numberDouble":"0.61328125"},"_id":{"$oid":"68129070e7f516cc19658bc7"}}
   Results from embeddings_float32 embeddings:
   {"_id":{"$oid":"68129070e7f516cc19658bc9"},"text":"Mount Everest is the highest peak on Earth at 8,848m.","score":{"$numberDouble":"0.6583383083343506"}}
   {"_id":{"$oid":"68129070e7f516cc19658bc7"},"text":"The Great Wall of China is visible from space.","score":{"$numberDouble":"0.6536108255386353"}}
   Results from embeddings_int8 embeddings:
   {"_id":{"$oid":"68129070e7f516cc19658bc9"},"text":"Mount Everest is the highest peak on Earth at 8,848m.","score":{"$numberDouble":"0.5149773359298706"}}
   {"_id":{"$oid":"68129070e7f516cc19658bc7"},"text":"The Great Wall of China is visible from space.","score":{"$numberDouble":"0.5146723985671997"}}

필요한 라이브러리를 설치합니다.

다음 명령을 실행하여 MongoDB 고 (Go) 드라이버 설치합니다. 이 작업을 완료하는 데 몇 분 정도 걸릴 수 있습니다.

go get go.mongodb.org/mongo-driver/v2/mongo

고 (Go) v2.1 이상의 운전자 설치해야 합니다. 필요한 경우 임베딩 모델 제공자 로부터 라이브러리를 설치할 수도 있습니다. 예시 를 들어 이 페이지에 설명된 대로 코히어를 사용하여 float32, int8 및 int1 임베딩을 생성하려면 코히어를 설치합니다.

go get github.com/cohere-ai/cohere-go/v2/client@v2.13.0

Go 프로젝트를 초기화합니다.

터미널 창에서 다음 명령을 실행하여 ingest-binary-vectors라는 이름의 새 디렉토리를 만들고 프로젝트를 초기화합니다.

mkdir ingest-binary-vectors-project
cd ingest-binary-vectors-project
go mod init ingest-binary-vectors-project

터미널에서 환경 변수를 설정합니다.

1. 임베딩을 생성하고 변환하기 위해 임베딩 모델 제공자에 액세스하려면, 필요에 따라 임베딩 모델 제공자의 API 키에 대한 환경 변수를 설정하세요.

   Cohere의 임베딩을 사용하기 위해 COHERE_API_KEY 환경 변수를 설정하세요.

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

2. Atlas 클러스터에 액세스하려면 MONGODB_URI 환경 변수를 설정하세요.

   export MONGODB_URI="<CONNECTION-STRING>"

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

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

(조건부)데이터에서 임베딩을 생성합니다.

임베딩 모델 제공자 사용하여 데이터에 대한 float, int8 및 int1 임베딩을 생성한 다음 MongoDB 고 (Go) 운전자 사용하여 네이티브 벡터 임베딩을 BSON 벡터로 변환할 수 있습니다. 다음 샘플 코드는 Cohere의 embed API 사용하여 sample_airbnb.listingsAndReviews 네임스페이스의 데이터에서 완전 정밀도 벡터를 생성합니다.

1. 고 (Go) 프로젝트 에 GenerateAndConvertEmbeddings.go 이라는 새 파일 을 만듭니다.

   touch GenerateAndConvertEmbeddings.go

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

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

   • sample_airbnb.listingsAndReviews 네임스페이스의 50 문서에서 summary 필드를 가져옵니다.

   • Cohere의 embed API를 사용하여 float32, int8, ubinary 벡터 임베딩을 생성합니다.

   • MongoDB 고 (Go) 운전자 사용하여 임베딩을 BSON 벡터로 변환합니다.binData

   • embeddings.json 파일을 만들고 이 파일에 데이터와 임베딩을 저장합니다.

   GenerateAndConvertEmbeddings.go

   1
   package main  
   2
     
   3
   import (  
   4
   	"context"  
   5
   	"encoding/json"  
   6
   	"fmt"  
   7
   	"log"  
   8
   	"os"  
   9
     
   10
   	cohere "github.com/cohere-ai/cohere-go/v2"  
   11
   	cohereclient "github.com/cohere-ai/cohere-go/v2/client"  
   12
   	"go.mongodb.org/mongo-driver/v2/bson"  
   13
   	"go.mongodb.org/mongo-driver/v2/mongo"  
   14
   	"go.mongodb.org/mongo-driver/v2/mongo/options"  
   15
   )  
   16
     
   17
   const (  
   18
   	batchSize  = 96  
   19
   	dbName     = "sample_airbnb"  
   20
   	collName   = "listingsAndReviews"  
   21
   	embedModel = "embed-english-v3.0"  
   22
   )  
   23
     
   24
   func main() {  
   25
   	apiKey := os.Getenv("COHERE_API_KEY")  
   26
   	mongodbURI := os.Getenv("MONGODB_URI")  
   27
     
   28
   	if apiKey == "" || mongodbURI == "" {  
   29
   		log.Fatal("Ensure COHERE_API_KEY and MONGODB_URI are set.")  
   30
   	}  
   31
     
   32
   	summaries, err := fetchSummariesFromMongoDB(mongodbURI)  
   33
   	if err != nil {  
   34
   		log.Fatalf("Error fetching summaries: %v", err)  
   35
   	}  
   36
     
   37
   	client := cohereclient.NewClient(cohereclient.WithToken(apiKey))  
   38
     
   39
   	for start := 0; start < len(summaries); start += batchSize {  
   40
   		end := start + batchSize  
   41
   		if end > len(summaries) {  
   42
   			end = len(summaries)  
   43
   		}  
   44
     
   45
   		embeddingsData, err := fetchEmbeddingsFromCohere(client, summaries[start:end])  
   46
   		if err != nil {  
   47
   			log.Fatalf("Error fetching embeddings: %v", err)  
   48
   		}  
   49
     
   50
   		if embeddingsData.Embeddings == nil {  
   51
   			continue  
   52
   		}  
   53
     
   54
   		documents := convertCohereResponseToStructs(summaries[start:end], embeddingsData)  
   55
     
   56
   		err = writeJSONToFile("embeddings.json", documents)  
   57
   		if err != nil {  
   58
   			log.Fatalf("Error writing embeddings to JSON: %v", err)  
   59
   		}  
   60
   	}  
   61
     
   62
   	fmt.Println("Embeddings successfully saved to embeddings.json")  
   63
   }  
   64
     
   65
   func fetchSummariesFromMongoDB(uri string) ([]string, error) {  
   66
   	ctx := context.TODO()  
   67
   	clientOpts := options.Client().ApplyURI(uri)  
   68
     
   69
   	client, err := mongo.Connect(clientOpts)  
   70
   	if err != nil {  
   71
   		return nil, fmt.Errorf("failed to connect to MongoDB: %w", err)  
   72
   	}  
   73
   	defer func() {  
   74
   		if err := client.Disconnect(ctx); err != nil {  
   75
   			log.Fatalf("Failed to disconnect MongoDB client: %v", err)  
   76
   		}  
   77
   	}()  
   78
     
   79
   	collection := client.Database(dbName).Collection(collName)  
   80
   	filter := bson.M{"summary": bson.M{"$nin": []interface{}{nil, ""}}}  
   81
     
   82
   	cursor, err := collection.Find(ctx, filter, options.Find().SetLimit(50))  
   83
   	if err != nil {  
   84
   		return nil, fmt.Errorf("error finding documents: %w", err)  
   85
   	}  
   86
   	defer cursor.Close(ctx)  
   87
     
   88
   	var summaries []string  
   89
   	for cursor.Next(ctx) {  
   90
   		var result struct {  
   91
   			Summary string  
   92
   		}  
   93
   		if err := cursor.Decode(&result); err != nil {  
   94
   			return nil, fmt.Errorf("error decoding document: %w", err)  
   95
   		}  
   96
   		if summary := result.Summary; summary != "" {  
   97
   			summaries = append(summaries, summary)  
   98
   		}  
   99
   	}  
   100
     
   101
   	if err := cursor.Err(); err != nil {  
   102
   		return nil, fmt.Errorf("cursor error: %w", err)  
   103
   	}  
   104
     
   105
   	return summaries, nil  
   106
   }  
   107
     
   108
   func fetchEmbeddingsFromCohere(client *cohereclient.Client, batchData []string) (*cohere.EmbedByTypeResponse, error) {  
   109
   	response, err := client.V2.Embed(context.TODO(), &cohere.V2EmbedRequest{  
   110
   		Texts:       batchData,  
   111
   		Model:       embedModel,  
   112
   		InputType:   cohere.EmbedInputTypeSearchDocument,  
   113
   		EmbeddingTypes: []cohere.EmbeddingType{  
   114
   			cohere.EmbeddingTypeFloat,  
   115
   			cohere.EmbeddingTypeInt8,  
   116
   			cohere.EmbeddingTypeUbinary,  
   117
   		},  
   118
   	})  
   119
   	if err != nil {  
   120
   		return nil, fmt.Errorf("failed to fetch embeddings: %w", err)  
   121
   	}  
   122
     
   123
   	return response, nil  
   124
   }  
   125
     
   126
   func convertCohereResponseToStructs(summaries []string, embeddings *cohere.EmbedByTypeResponse) []bson.M {  
   127
   	var documents []bson.M  
   128
     
   129
   	for i, summary := range summaries {  
   130
   		float32Emb := convertFloat64ToFloat32(embeddings.Embeddings.Float[i])  
   131
   		int8Emb := convertIntToInt8(embeddings.Embeddings.Int8[i])  
   132
   		ubinaryEmb := convertIntToBytes(embeddings.Embeddings.Ubinary[i])  
   133
     
   134
   		floatVector := bson.NewVector(float32Emb)  
   135
   		int8Vector := bson.NewVector(int8Emb)  
   136
   		ubinaryVector, err := bson.NewPackedBitVector(ubinaryEmb, 0)  
   137
   		if err != nil {  
   138
   			log.Fatalf("Error creating PackedBitVector: %v", err)  
   139
   		}  
   140
     
   141
   		document := bson.M{  
   142
   			"text":                summary,  
   143
   			"embeddings_float32":  floatVector.Binary(),  
   144
   			"embeddings_int8":     int8Vector.Binary(),  
   145
   			"embeddings_int1":     ubinaryVector.Binary(),  
   146
   		}  
   147
     
   148
   		documents = append(documents, document)  
   149
   	}  
   150
     
   151
   	return documents  
   152
   }  
   153
     
   154
   func writeJSONToFile(filename string, docs []bson.M) error {  
   155
   	file, err := os.Create(filename)  
   156
   	if err != nil {  
   157
   		return fmt.Errorf("failed to create file: %w", err)  
   158
   	}  
   159
   	defer file.Close()  
   160
     
   161
   	var jsonDocuments []json.RawMessage  
   162
   	for _, document := range docs {  
   163
   		jsonBytes, err := bson.MarshalExtJSON(document, false, false)  
   164
   		if err != nil {  
   165
   			log.Fatalf("Error: %v", err)  
   166
   		}  
   167
   		jsonDocuments = append(jsonDocuments, jsonBytes)  
   168
   	}  
   169
     
   170
   	jsonData, err := json.MarshalIndent(jsonDocuments, "", "  ")  
   171
   	if err != nil {  
   172
   		return fmt.Errorf("failed to marshal JSON: %w", err)  
   173
   	}  
   174
     
   175
   	_, err = file.Write(jsonData)  
   176
   	if err != nil {  
   177
   		return fmt.Errorf("failed to write JSON to file: %w", err)  
   178
   	}  
   179
     
   180
   	return nil  
   181
   }  
   182
     
   183
   func convertFloat64ToFloat32(f64s []float64) []float32 {  
   184
   	f32s := make([]float32, len(f64s))  
   185
   	for i, v := range f64s {  
   186
   		f32s[i] = float32(v)  
   187
   	}  
   188
   	return f32s  
   189
   }  
   190
     
   191
   func convertIntToInt8(ints []int) []int8 {  
   192
   	ints8 := make([]int8, len(ints))  
   193
   	for i, val := range ints {  
   194
   		ints8[i] = int8(val)  
   195
   	}  
   196
   	return ints8  
   197
   }  
   198
     
   199
   func convertIntToBytes(ints []int) []byte {  
   200
   	bytes := make([]byte, len(ints))  
   201
   	for i, val := range ints {  
   202
   		bytes[i] = byte(val)  
   203
   	}  
   204
   	return bytes  
   205
   }  

3. 환경 변수를 설정하지 않았다면 코드에서 다음 자리 표시자 값을 변경하고 파일을 저장합니다.

   MONGODB_URI	환경 변수를 설정하지 않은 경우 Atlas 클러스터 연결 문자열입니다.
   COHERE_API_KEY	환경 변수를 설정하지 않은 경우 Cohere API 키를 사용합니다.

4. 애플리케이션 실행 구성을 사용하여 파일을 컴파일하고 실행합니다.

   터미널을 사용하는 경우에는 다음 명령어를 실행하여 프로그램을 컴파일하고 실행합니다.

   go run GenerateAndConvertEmbeddings.go

   출력 숨기기

   Embeddings successfully saved to embeddings.json

5. embeddings.json 파일의 임베딩을 확인합니다.

임베딩을 생성하고 임베딩을 binData 벡터로 변환하는 방법에 대한 자세한 내용은 벡터 임베딩 생성 방법을 참조하세요.

데이터를 수집하고 Atlas Vector Search 인덱스를 생성합니다.

데이터와 임베딩을 Atlas 클러스터의 컬렉션에 업로드하고 해당 데이터에 Atlas Vector Search 인덱스를 생성하여 $vectorSearch 쿼리를 실행해야 합니다.

1. 고 (Go) 프로젝트 에 UploadDataAndCreateIndex.go 이라는 새 파일 을 만듭니다.

   touch UploadDataAndCreateIndex.go

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

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

   • embeddings.json 파일의 float32, int8, int1 임베딩을 Atlas 클러스터에 업로드합니다.

   • embeddings.float32, embeddings.int8, embeddings.int1 필드에 Atlas Vector Search 인덱스를 생성합니다.

   UploadDataAndCreateIndex.go

   1
   package main  
   2
     
   3
   import (  
   4
   	"context"  
   5
   	"fmt"  
   6
   	"io/ioutil"  
   7
   	"log"  
   8
       "time"
   9
   	"os"  
   10
     
   11
   	"go.mongodb.org/mongo-driver/v2/bson"  
   12
   	"go.mongodb.org/mongo-driver/v2/mongo"  
   13
   	"go.mongodb.org/mongo-driver/v2/mongo/options"  
   14
   )  
   15
     
   16
   var (  
   17
   	mongodbURI          = os.Getenv("MONGODB_URI")  
   18
   	dbName              = "sample_airbnb"  
   19
   	collectionName      = "listingsAndReviews"  
   20
   	indexName           = "<INDEX-NAME>"  
   21
   	numberOfDimensions  = 1024  
   22
   	embeddingFields     = []string{"embeddings_float32", "embeddings_int8", "embeddings_int1"}  
   23
   	embeddingSimilarity = []string{"dotProduct", "dotProduct", "euclidean"}  
   24
   )  
   25
     
   26
   func main() {  
   27
   	if mongodbURI == "" {  
   28
   		log.Fatal("MONGODB_URI environment variable not set")  
   29
   	}  
   30
     
   31
   	clientOptions := options.Client().ApplyURI(mongodbURI)  
   32
   	client, err := mongo.Connect(clientOptions)  
   33
   	if err != nil {  
   34
   		log.Fatalf("Error connecting to MongoDB: %v", err)  
   35
   	}  
   36
   	defer func() {  
   37
   		if err = client.Disconnect(context.TODO()); err != nil {  
   38
   			log.Fatal(err)  
   39
   		}  
   40
   	}()  
   41
     
   42
   	if err := uploadEmbeddingsData(client); err != nil {  
   43
   		log.Fatalf("Error uploading embeddings data: %v", err)  
   44
   	}  
   45
     
   46
   	setupVectorSearchIndex(client)  
   47
   }  
   48
     
   49
   func uploadEmbeddingsData(client *mongo.Client) error {  
   50
   	collection := client.Database(dbName).Collection(collectionName)  
   51
     
   52
   	// Load embeddings.json file  
   53
   	fileContent, err := ioutil.ReadFile("embeddings.json")  
   54
   	if err != nil {  
   55
   		return fmt.Errorf("error reading file: %w", err)  
   56
   	}  
   57
     
   58
   	// Convert JSON file content to BSON compatible format using UnmarshalExtJSON  
   59
   	var documents []bson.M  
   60
   	if err := bson.UnmarshalExtJSON(fileContent, false, &documents); err != nil {  
   61
   		return fmt.Errorf("failed to unmarshal JSON data: %w", err)  
   62
   	}  
   63
     
   64
   	// Update documents in MongoDB  
   65
   	for _, doc := range documents {  
   66
   		summary, exists := doc["text"].(string)  
   67
   		if !exists {  
   68
   			return fmt.Errorf("missing 'text' field in document")  
   69
   		}  
   70
     
   71
   		// Using bson.Binary ensures binary data is correctly interpreted  
   72
   		if float32Bin, ok := doc["embeddings_float32"].(bson.Binary); ok {  
   73
   			doc["embeddings_float32"] = float32Bin  
   74
   		}  
   75
   		if int8Bin, ok := doc["embeddings_int8"].(bson.Binary); ok {  
   76
   			doc["embeddings_int8"] = int8Bin  
   77
   		}  
   78
   		if int1Bin, ok := doc["embeddings_int1"].(bson.Binary); ok {  
   79
   			doc["embeddings_int1"] = int1Bin  
   80
   		}  
   81
     
   82
   		filter := bson.M{"summary": summary}  
   83
   		update := bson.M{  
   84
   			"$set": doc,  
   85
   		}  
   86
     
   87
   		// Set the upsert option  
   88
   		opts := options.UpdateMany().SetUpsert(true)  
   89
     
   90
   		_, err = collection.UpdateMany(context.TODO(), filter, update, opts)  
   91
   		if err != nil {  
   92
   			return fmt.Errorf("failed to update documents: %w", err)  
   93
   		}  
   94
   	}  
   95
     
   96
   	return nil  
   97
   }  
   98
     
   99
   // Sets up vector search index in MongoDB  
   100
   func setupVectorSearchIndex(client *mongo.Client) {  
   101
   	database := client.Database(dbName)  
   102
   	collection := database.Collection(collectionName)  
   103
     
   104
   	ctx := context.TODO()  
   105
     
   106
   	type vectorDefinitionField struct {  
   107
   		Type          string `bson:"type"`  
   108
   		Path          string `bson:"path"`  
   109
   		NumDimensions int    `bson:"numDimensions"`  
   110
   		Similarity    string `bson:"similarity"`  
   111
   	}  
   112
     
   113
   	type vectorDefinition struct {  
   114
   		Fields []vectorDefinitionField `bson:"fields"`  
   115
   	}  
   116
     
   117
   	fields := make([]vectorDefinitionField, len(embeddingFields))  
   118
   	for i, field := range embeddingFields {  
   119
   		fields[i] = vectorDefinitionField{  
   120
   			Type:          "vector",  
   121
   			Path:          field,  
   122
   			NumDimensions: numberOfDimensions,  
   123
   			Similarity:    embeddingSimilarity[i],  
   124
   		}  
   125
   	}  
   126
     
   127
   	opts := options.SearchIndexes().SetName(indexName).SetType("vectorSearch")  
   128
     
   129
   	indexModel := mongo.SearchIndexModel{  
   130
   		Definition: vectorDefinition{  
   131
   			Fields: fields,  
   132
   		},  
   133
   		Options: opts,  
   134
   	}  
   135
     
   136
   	// Create the index  
   137
   	log.Println("Creating the index.")  
   138
   	searchIndexName, err := collection.SearchIndexes().CreateOne(ctx, indexModel)  
   139
   	if err != nil {  
   140
   		log.Fatalf("Failed to create the search index: %v", err)  
   141
   	}  
   142
     
   143
   	// Polling to confirm successful index creation  
   144
   	log.Println("Polling to confirm successful index creation.")  
   145
   	log.Println("NOTE: This may take up to a minute.")  
   146
   	searchIndexes := collection.SearchIndexes()  
   147
   	var doc bson.Raw  
   148
     
   149
   	for doc == nil {  
   150
   		cursor, err := searchIndexes.List(ctx, options.SearchIndexes().SetName(searchIndexName))  
   151
   		if err != nil {  
   152
   			log.Fatalf("failed to list search indexes: %v", err)  
   153
   		}  
   154
     
   155
   		if !cursor.Next(ctx) {  
   156
   			break  
   157
   		}  
   158
     
   159
   		name := cursor.Current.Lookup("name").StringValue()  
   160
   		queryable := cursor.Current.Lookup("queryable").Boolean()  
   161
   		if name == searchIndexName && queryable {  
   162
   			doc = cursor.Current  
   163
   		} else {  
   164
   			time.Sleep(5 * time.Second)  
   165
   		}  
   166
   	}  
   167
     
   168
   	log.Println("Name of Index Created: " + searchIndexName)  
   169
   }  

3. 코드에서 다음 자리 표시자 값을 바꾸고 파일을 저장합니다.

   MONGODB_URI	환경 변수를 설정하지 않은 경우 Atlas 클러스터 연결 문자열입니다.
   <INDEX-NAME>	컬렉션에 대한 Atlas Vector Search 인덱스의 이름입니다.

4. 애플리케이션 실행 구성을 사용하여 파일을 컴파일하고 실행합니다.

   터미널을 사용하는 경우에는 다음 명령어를 실행하여 프로그램을 컴파일하고 실행합니다.

   go run UploadDataAndCreateIndex.go

   출력 숨기기

   Creating the index.
   Polling to confirm successful index creation.
   NOTE: This may take up to a minute.
   Name of Index Created: <INDEX-NAME>

5. Atlas 클러스터에 로그인하고 다음을 확인하세요.

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

   • 컬렉션에 대한 Atlas Vector Search 인덱스입니다.

컬렉션에 대해 쿼리를 생성하고 실행합니다.

임베딩을 테스트하려면 컬렉션 에 대해 쿼리 실행 수 있습니다. 임베딩 모델 제공자 사용하여 쿼리 텍스트에 대한 float, int8 및 int1 임베딩을 생성합니다. 다음 샘플 코드는 Cohere의 embed API 사용하여 완전 정밀도 벡터를 생성합니다. 임베딩을 생성한 후 MongoDB 고 (Go) 운전자 사용하여 네이티브 벡터 임베딩을 BSON 벡터로 $vectorSearch 변환하고 컬렉션 에 대해 쿼리 실행 .

1. 고 (Go) 프로젝트 에 CreateEmbeddingsAndRunQuery.go 이라는 새 파일 을 만듭니다.

   touch CreateEmbeddingsAndRunQuery.go

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

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

   • Cohere의 embed API를 사용하여 float32, int8, ubinary 벡터 임베딩을 생성합니다.

   • MongoDB 고 (Go) 운전자 사용하여 임베딩을 BSON 벡터로 변환합니다.binData

   • 컬렉션에 대해 쿼리를 실행하고 결과를 반환합니다.

   CreateEmbeddingsAndRunQuery.go

   1
   package main
   2
   3
   import (
   4
           "context"
   5
           "fmt"
   6
           "log"
   7
           "os"
   8
   9
           cohere "github.com/cohere-ai/cohere-go/v2"
   10
           cohereclient "github.com/cohere-ai/cohere-go/v2/client"
   11
           "go.mongodb.org/mongo-driver/v2/bson"
   12
           "go.mongodb.org/mongo-driver/v2/mongo"
   13
           "go.mongodb.org/mongo-driver/v2/mongo/options"
   14
   )
   15
   16
   const (
   17
   	dbName          = "<DATABASE-NAME>"
   18
   	collectionName  = "<COLLECTION-NAME>"
   19
   	vectorIndexName = "<INDEX-NAME>"
   20
   	dataFieldName   = "<TEXT-FIELD-NAME>"
   21
   	queryText       = "<QUERY-TEXT>"
   22
   )
   23
   24
   func main() {
   25
   	apiKey := os.Getenv("COHERE_API_KEY")
   26
   	mongodbURI := os.Getenv("MONGODB_URI")
   27
   28
   	if apiKey == "" {
   29
   		log.Fatal("API key not found. Set COHERE_API_KEY in your environment.")
   30
   	}
   31
   	if mongodbURI == "" {
   32
   		log.Fatal("MongoDB URI not found. Set MONGODB_URI in your environment.")
   33
   	}
   34
   35
   	embeddingsData, err := generateAndConvertEmbeddings(apiKey, queryText)
   36
   	if err != nil {
   37
   		log.Fatalf("Error generating embeddings: %v", err)
   38
   	}
   39
   40
   	err = runVectorSearchQuery(mongodbURI, embeddingsData)
   41
   	if err != nil {
   42
   		log.Fatalf("Error running vector search query: %v", err)
   43
   	}
   44
   }
   45
   46
   // Generate embeddings using Cohere's embed API from the query text
   47
   func generateAndConvertEmbeddings(apiKey, text string) (map[string]bson.Binary, error) {
   48
   	client := cohereclient.NewClient(cohereclient.WithToken(apiKey))
   49
   50
   	model := "embed-english-v3.0"
   51
   	response, err := client.V2.Embed(context.TODO(), &cohere.V2EmbedRequest{
   52
   		Texts:     []string{text},
   53
   		Model:     model,
   54
   		InputType: cohere.EmbedInputTypeSearchQuery,
   55
   		EmbeddingTypes: []cohere.EmbeddingType{
   56
   			cohere.EmbeddingTypeFloat,
   57
   			cohere.EmbeddingTypeInt8,
   58
   			cohere.EmbeddingTypeUbinary,
   59
   		},
   60
   	})
   61
   	if err != nil {
   62
   		return nil, fmt.Errorf("failed to fetch embeddings: %w", err)
   63
   	}
   64
   65
   	if response.Embeddings == nil || len(response.Embeddings.Float) == 0 {
   66
   		return nil, fmt.Errorf("no embeddings found in the API response")
   67
   	}
   68
   69
   	return createBSONVectorEmbeddings(response.Embeddings), nil
   70
   }
   71
   72
   // Convert embeddings to BSON vectors using MongoDB Go Driver
   73
   func createBSONVectorEmbeddings(embeddings *cohere.EmbedByTypeResponseEmbeddings) map[string]bson.Binary {
   74
   	bsonVectorEmbeddings := make(map[string]bson.Binary)
   75
   76
   	// Convert float embeddings
   77
   	if len(embeddings.Float) > 0 {
   78
   		floatData := convertFloat64ToFloat32(embeddings.Float[0])
   79
   		floatVector := bson.NewVector(floatData) // Here, we are using bson.NewVector to create a BSON Vector.
   80
   		bsonVectorEmbeddings["float32"] = floatVector.Binary()
   81
   	}
   82
   83
   	// Convert int8 embeddings
   84
   	if len(embeddings.Int8) > 0 {
   85
   		int8Data := convertIntToInt8(embeddings.Int8[0])
   86
   		int8Vector := bson.NewVector(int8Data) // Similarly, create BSON Vector for int8 data.
   87
   		bsonVectorEmbeddings["int8"] = int8Vector.Binary()
   88
   	}
   89
   90
   	// Convert ubinary embeddings to a packed bit vector
   91
   	if len(embeddings.Ubinary) > 0 {
   92
   		int1Data := convertIntToBytes(embeddings.Ubinary[0])
   93
   		ubinaryVector, _ := bson.NewPackedBitVector(int1Data, 0) // Packed bit using bson.NewPackedBitVector
   94
   		bsonVectorEmbeddings["int1"] = ubinaryVector.Binary()
   95
   	}
   96
   97
   	return bsonVectorEmbeddings
   98
   }
   99
   100
   // Run $vectorSearch query using the embeddings
   101
   func runVectorSearchQuery(mongodbURI string, embeddingsData map[string]bson.Binary) error {
   102
   	ctx := context.Background()
   103
   	clientOptions := options.Client().ApplyURI(mongodbURI)
   104
   	client, err := mongo.Connect(clientOptions)
   105
   	if err != nil {
   106
   		return fmt.Errorf("failed to connect to MongoDB: %w", err)
   107
   	}
   108
   	defer func() { _ = client.Disconnect(ctx) }()
   109
   110
   	db := client.Database(dbName)
   111
   	collection := db.Collection(collectionName)
   112
   113
   	// Map the correct paths for embeddings
   114
   	pathMap := map[string]string{
   115
   		"float32": "embeddings_float32",
   116
   		"int8":    "embeddings_int8",
   117
   		"int1":    "embeddings_int1",
   118
   	}
   119
   120
   	for pathKey, queryVector := range embeddingsData {
   121
   		path, ok := pathMap[pathKey]
   122
   		if !ok {
   123
   			return fmt.Errorf("invalid path key: %s", pathKey)
   124
   		}
   125
   126
   		pipeline := mongo.Pipeline{
   127
   			{
   128
   				{"$vectorSearch", bson.D{
   129
   					{"queryVector", queryVector},
   130
   					{"index", vectorIndexName},
   131
   					{"path", path},
   132
   					{"numCandidates", 5},
   133
   					{"limit", 2},
   134
   				}},
   135
   			},
   136
   			{
   137
   				{"$project", bson.D{
   138
   					{"_id", 1},
   139
   					{dataFieldName, 1},
   140
   					{"score", bson.D{
   141
   						{"$meta", "vectorSearchScore"},
   142
   					}},
   143
   				}},
   144
   			},
   145
   		}
   146
   147
   		cursor, err := collection.Aggregate(context.Background(), pipeline)
   148
   		if err != nil {
   149
   			return fmt.Errorf("failed to run vector search aggregation query: %w", err)
   150
   		}
   151
   		defer cursor.Close(ctx)
   152
   153
   		var results []bson.M
   154
   		if err = cursor.All(context.Background(), &results); err != nil {
   155
   			return fmt.Errorf("failed to parse aggregation query results: %w", err)
   156
   		}
   157
   158
   		fmt.Printf("Results from %v embeddings:\n", path)
   159
   		for _, result := range results {
   160
   			fmt.Println(result)
   161
   		}
   162
   	}
   163
   164
   	return nil
   165
   }
   166
   167
   // Utility functions to handle list conversion
   168
   func convertFloat64ToFloat32(f64s []float64) []float32 {
   169
   	f32s := make([]float32, len(f64s))
   170
   	for i, v := range f64s {
   171
   		f32s[i] = float32(v)
   172
   	}
   173
   	return f32s
   174
   }
   175
   176
   func convertIntToInt8(ints []int) []int8 {
   177
   	ints8 := make([]int8, len(ints))
   178
   	for i, val := range ints {
   179
   		ints8[i] = int8(val)
   180
   	}
   181
   	return ints8
   182
   }
   183
   184
   func convertIntToBytes(ints []int) []byte {
   185
   	bytes := make([]byte, len(ints))
   186
   	for i, val := range ints {
   187
   		bytes[i] = byte(val)
   188
   	}
   189
   	return bytes
   190
   }

3. 코드에서 다음 자리 표시자 값을 바꾸고 파일을 저장합니다.

   MONGODB_URI	환경 변수를 설정하지 않은 경우 Atlas 클러스터 연결 문자열입니다.
   COHERE_API_KEY	환경 변수를 설정하지 않은 경우 Cohere API 키를 사용합니다.
   <DATABASE-NAME>	Atlas 클러스터에 있는 데이터베이스의 이름입니다. 이 예시에서는 sample_airbnb을(를) 사용합니다.
   <COLLECTION-NAME>	데이터를 삽입한 컬렉션의 이름입니다. 이 예시에서는 listingsAndReviews을(를) 사용합니다.
   <INDEX-NAME>	컬렉션에 대한 Atlas Vector Search 인덱스의 이름입니다.
   <TEXT-FIELD-NAME>	임베딩을 생성한 텍스트가 포함된 필드의 이름입니다. 이 예시에서는 summary을(를) 사용합니다.
   <QUERY-TEXT>	쿼리의 텍스트입니다. 이 예시에서는 ocean view을(를) 사용합니다.

4. 애플리케이션 실행 구성을 사용하여 파일을 컴파일하고 실행합니다.

   터미널을 사용하는 경우에는 다음 명령어를 실행하여 프로그램을 컴파일하고 실행합니다.

   go run CreateEmbeddingsAndRunQuery.go

   출력 숨기기

   Results from embeddings_float32 embeddings:
   {"_id":"10266175","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.","score":{"$numberDouble":"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.","score":{"$numberDouble":"0.688639760017395"},"_id":"1001265"}
   Results from embeddings_int8 embeddings:
   {"_id":"10266175","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.","score":{"$numberDouble":"0.5215557217597961"}}
   {"_id":"1001265","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.","score":{"$numberDouble":"0.5179016590118408"}}
   Results from embeddings_int1 embeddings:
   {"_id":"10266175","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.","score":{"$numberDouble":"0.6591796875"}}
   {"_id":"1001265","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.","score":{"$numberDouble":"0.6337890625"}}

임베딩을 생성하고 임베딩을 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를 사용하여 고정밀 벡터를 생성합니다.

1. Java 프로젝트에 GenerateAndConvertEmbeddings.java(이)라는 이름의 새 파일을 만듭니다.

   touch GenerateAndConvertEmbeddings.java

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

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

   • Cohere의 embed API를 사용하여 float32, int8, ubinary 벡터 임베딩을 생성합니다.

   • MongoDB Java 드라이버를 사용하여 임베딩을 BSONbinData 벡터로 변환합니다.

   • embeddings.json 파일을 만들고, 이 파일에 데이터와 임베딩을 저장하여 Atlas에 업로드합니다.

   GenerateAndConvertEmbeddings.java

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

3. 환경 변수를 설정하지 않은 경우 코드에서 COHERE_API_KEY 자리 표시자 값을 교체한 다음 파일을 저장합니다.

4. 애플리케이션 실행 구성을 사용하여 파일을 컴파일하고 실행합니다.

   터미널을 사용하는 경우에는 다음 명령어를 실행하여 프로그램을 컴파일하고 실행합니다.

   javac GenerateAndConvertEmbeddings.java
   java GenerateAndConvertEmbeddings

   출력 숨기기

   BSON embeddings saved to embeddings.json

5. embeddings.json 파일의 임베딩을 확인합니다.

임베딩을 생성하고 임베딩을 binData 벡터로 변환하는 방법에 대한 자세한 내용은 벡터 임베딩 생성 방법을 참조하세요.

데이터를 수집하고 Atlas Vector Search 인덱스를 생성합니다.

데이터와 임베딩을 Atlas 클러스터의 컬렉션에 업로드하고 해당 데이터에 Atlas Vector Search 인덱스를 생성하여 $vectorSearch 쿼리를 실행해야 합니다.

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

   touch UploadDataAndCreateIndex.java

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

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

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

   • embeddings_float32, embeddings_int8, embeddings_int1 필드에 Atlas Vector Search 인덱스를 생성합니다.

   UploadDataAndCreateIndex.java

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

3. 코드에서 다음 자리 표시자 값을 바꾸고 파일을 저장합니다.

   MONGODB_URI	환경 변수를 설정하지 않은 경우 Atlas 클러스터 연결 문자열입니다.
   <DATABASE-NAME>	Atlas 클러스터에 있는 데이터베이스의 이름입니다.
   <COLLECTION-NAME>	데이터를 업로드할 컬렉션의 이름입니다.
   <INDEX-NAME>	컬렉션에 대한 Atlas Vector Search 인덱스의 이름입니다.

4. 애플리케이션 실행 구성을 사용하여 파일을 컴파일하고 실행합니다.

   터미널을 사용하는 경우에는 다음 명령어를 실행하여 프로그램을 컴파일하고 실행합니다.

   javac UploadDataAndCreateIndex.java
   java UploadDataAndCreateIndex

   출력 숨기기

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

5. Atlas 클러스터에 로그인하고 다음을 확인하세요.

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

   • 컬렉션에 대한 Atlas Vector Search 인덱스입니다.

컬렉션에 대한 쿼리를 생성하고 실행합니다.

임베딩을 테스트하려면 컬렉션에 대해 쿼리를 실행할 수 있습니다. 임베딩 모델 제공자를 사용하여 쿼리 텍스트에 대해 float, int8, int1 임베딩을 생성합니다. 다음 샘플 코드는 Cohere의 embed API를 사용하여 고정밀 벡터를 생성합니다. 임베딩을 생성한 후 MongoDB Java 드라이버를 사용하여 네이티브 벡터 임베딩을 BSON 벡터로 변환하고 컬렉션에 대해 $vectorSearch 쿼리를 실행합니다.

1. Java 프로젝트에 CreateEmbeddingsAndRunQuery.java(이)라는 이름의 새 파일을 만듭니다.

   touch CreateEmbeddingsAndRunQuery.java

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

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

   • Cohere의 embed API를 사용하여 float32, int8, ubinary 벡터 임베딩을 생성합니다.

   • MongoDB Java 드라이버를 사용하여 임베딩을 BSONbinData 벡터로 변환합니다.

   • 컬렉션에 대해 쿼리를 실행합니다.

   CreateEmbeddingsAndRunQuery.java

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

3. 코드에서 다음 자리 표시자 값을 바꾸고 파일을 저장합니다.

   MONGODB_URI	환경 변수를 설정하지 않은 경우 Atlas 클러스터 연결 문자열입니다.
   COHERE_API_KEY	환경 변수를 설정하지 않은 경우 Cohere API 키를 사용합니다.
   <DATABASE-NAME>	Atlas 클러스터에 있는 데이터베이스의 이름입니다.
   <COLLECTION-NAME>	데이터를 삽입한 컬렉션의 이름입니다.
   <INDEX-NAME>	컬렉션에 대한 Atlas Vector Search 인덱스의 이름입니다.
   <DATA-FIELD-NAME>	임베딩을 생성한 텍스트가 포함된 필드의 이름입니다. 이 예시에서는 text을(를) 사용합니다.
   <QUERY-TEXT>	쿼리의 텍스트입니다. 이 예시에서는 science fact을(를) 사용합니다.

4. 애플리케이션 실행 구성을 사용하여 파일을 컴파일하고 실행합니다.

   터미널을 사용하는 경우에는 다음 명령어를 실행하여 프로그램을 컴파일하고 실행합니다.

   javac CreateEmbeddingsAndRunQuery.java
   java CreateEmbeddingsAndRunQuery

   출력 숨기기

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