ベクトル埋め込みの作成方法

.NET プロジェクトを初期化します。

ターミナルウィンドウで、以下のコマンドを実行してプロジェクトを初期化します。

dotnet new console -o MyCompany.Embeddings
cd MyCompany.Embeddings

依存関係をインストールしてインポートします。

ターミナルウィンドウで、次のコマンドを実行します。

dotnet add package MongoDB.Driver

環境変数を設定します。

環境変数をエクスポートし、PowerShell で set するか、IDE の環境変数マネージャーを使用して、接続文字列と HuggingFace アクセストークンをプロジェクトで利用可能にします。

export HUGGINGFACE_ACCESS_TOKEN="<access-token>"
export ATLAS_CONNECTION_STRING="<connection-string>"

<access-token> プレースホルダー値を 1 つのドキュメント アクセス トークンに置き換えます。

<connection-string> プレースホルダー値を、Atlas クラスター SRV 接続文字列に置き換えます。

接続stringには、次の形式を使用する必要があります。

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

ベクトル埋め込みを生成する関数を定義する。

AIService.cs という名前のファイルに同じ名前の新しいクラスを作成し、次のコードを貼り付けます。このコードは、指定された文字列入力の配列に対して埋め込みの配列を生成するために、GetEmbeddingsAsync という名前の非同期タスクを定義します。この関数は、mxbai-embed-large-v1 埋め込みモデルを使用します。

namespace MyCompany.Embeddings;
using System;
using System.Net.Http;
using System.Text.Json;
using System.Threading.Tasks;
using System.Net.Http.Headers;
public class AIService
{
    private static readonly string? HuggingFaceAccessToken = Environment.GetEnvironmentVariable("HUGGINGFACE_ACCESS_TOKEN");
    private static readonly HttpClient Client = new HttpClient();
    public async Task<Dictionary<string, float[]>> GetEmbeddingsAsync(string[] texts)
    {
        const string modelName = "mixedbread-ai/mxbai-embed-large-v1";
        const string url = $"https://api-inference.huggingface.co/models/{modelName}";
        Client.DefaultRequestHeaders.Authorization 
            = new AuthenticationHeaderValue("Bearer", HuggingFaceAccessToken);
        var data = new { inputs = texts };
        var dataJson = JsonSerializer.Serialize(data);
        var content = new StringContent(dataJson,null, "application/json");
        var response = await Client.PostAsync(url, content);
        response.EnsureSuccessStatusCode();
        var responseString = await response.Content.ReadAsStringAsync();
        var embeddings = JsonSerializer.Deserialize<float[][]>(responseString);
        if (embeddings is null)
        {
            throw new ApplicationException("Failed to deserialize embeddings response to an array of floats.");
        }
        Dictionary<string, float[]> documentData = new Dictionary<string, float[]>();
        var embeddingCount = embeddings.Length;
        foreach (var value in Enumerable.Range(0, embeddingCount))
        {
            // Pair each embedding with the text used to generate it.
            documentData[texts[value]] = embeddings[value];
        }
        return documentData;
    }
}

.NET プロジェクトを初期化します。

ターミナルウィンドウで、以下のコマンドを実行してプロジェクトを初期化します。

dotnet new console -o MyCompany.Embeddings
cd MyCompany.Embeddings

依存関係をインストールしてインポートします。

ターミナルウィンドウで、次のコマンドを実行します。

dotnet add package MongoDB.Driver

環境変数を設定します。

環境変数をエクスポートし、PowerShell で set するか、IDE の環境変数マネージャーを使用して、接続文字列と Voyage AI API キーをプロジェクトで使用できるようにします。

export VOYAGE_API_KEY="<api-key>"
export ATLAS_CONNECTION_STRING="<connection-string>"

<api-key> プレースホルダーの値を Voyage AI API キーに置き換えてください。

<connection-string> プレースホルダー値を、Atlas クラスター SRV 接続文字列に置き換えます。

接続stringには、次の形式を使用する必要があります。

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

ベクトル埋め込みを生成する関数を定義する。

AIService.cs という名前のファイルに同じ名前の新しいクラスを作成し、次のコードを貼り付けます。このコードは、GetEmbeddingsAsync という名前の非同期タスクを定義して、指定された string 入力の配列に対する埋め込みの配列を生成します。この関数は、Voyage AI の voyage-3-large モデルを使用して、指定された入力の埋め込みを生成します。

namespace MyCompany.Embeddings;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Threading.Tasks;
public class AIService
{
    private static readonly string? VoyageApiKey = Environment.GetEnvironmentVariable("VOYAGE_API_KEY");
    private static readonly string EmbeddingModelName = "voyage-3-large";
    private static readonly string ApiEndpoint = "https://api.voyageai.com/v1/embeddings";
    
    public async Task<Dictionary<string, float[]>> GetEmbeddingsAsync(string[] texts)
    {
        Dictionary<string, float[]> documentData = new Dictionary<string, float[]>();
        
        try
        {
            using HttpClient client = new HttpClient();
            client.DefaultRequestHeaders.Authorization = 
                new AuthenticationHeaderValue("Bearer", VoyageApiKey);
            
            var requestBody = new
            {
                input = texts,
                model = EmbeddingModelName,
                truncation = true
            };
            
            var content = new StringContent(
                JsonSerializer.Serialize(requestBody),
                Encoding.UTF8,
                "application/json");
            
            HttpResponseMessage response = await client.PostAsync(ApiEndpoint, content);
            
            if (response.IsSuccessStatusCode)
            {
                string responseBody = await response.Content.ReadAsStringAsync();
                var embeddingResponse = JsonSerializer.Deserialize<EmbeddingResponse>(responseBody);
                
                if (embeddingResponse != null && embeddingResponse.Data != null)
                {
                    foreach (var embeddingResult in embeddingResponse.Data)
                    {
                        if (embeddingResult.Index < texts.Length)
                        {
                            documentData[texts[embeddingResult.Index]] = 
                                embeddingResult.Embedding.Select(e => (float)e).ToArray();
                        }
                    }
                }
            }
            else
            {
                throw new ApplicationException($"Error calling Voyage API: {response.ReasonPhrase}");
            }
        }
        catch (Exception e)
        {
            throw new ApplicationException(e.Message);
        }
        
        return documentData;
    }
    
    private class EmbeddingResponse
    {
        [JsonPropertyName("object")]
        public string Object { get; set; } = string.Empty;
        
        [JsonPropertyName("data")]
        public List<EmbeddingResult>? Data { get; set; }
        
        [JsonPropertyName("model")]
        public string Model { get; set; } = string.Empty;
        
        [JsonPropertyName("usage")]
        public Usage? Usage { get; set; }
    }
    
    private class EmbeddingResult
    {
        [JsonPropertyName("object")]
        public string Object { get; set; } = string.Empty;
        
        [JsonPropertyName("embedding")]
        public List<double> Embedding { get; set; } = new();
        
        [JsonPropertyName("index")]
        public int Index { get; set; }
    }
    
    private class Usage
    {
        [JsonPropertyName("total_tokens")]
        public int TotalTokens { get; set; }
    }
}

.NET プロジェクトを初期化します。

ターミナルウィンドウで、以下のコマンドを実行してプロジェクトを初期化します。

dotnet new console -o MyCompany.Embeddings
cd MyCompany.Embeddings

依存関係をインストールしてインポートします。

ターミナルウィンドウで、次のコマンドを実行します。

dotnet add package MongoDB.Driver
dotnet add package OpenAI

環境変数を設定します。

環境変数をエクスポートし、PowerShell でset するか、IDE の環境変数マネージャーを使用して、接続文字列と HuggingFace アクセス トークンをプロジェクトで使用できるようにします。

export OPENAI_API_KEY="<api-key>"
export ATLAS_CONNECTION_STRING="<connection-string>"

<api-key> プレースホルダー値を OpenAI APIキーに置き換えます。

<connection-string> プレースホルダー値を、Atlas クラスター SRV 接続文字列に置き換えます。

接続stringには、次の形式を使用する必要があります。

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

ベクトル埋め込みを生成する関数を定義する。

AIService.cs という名前のファイルに同じ名前の新しいクラスを作成し、次のコードを貼り付けます。このコードは、指定された文字列入力の配列に対して埋め込みの配列を生成するために、GetEmbeddingsAsync という名前の非同期タスクを定義します。この関数は、OpenAI の text-embedding-3-small モデルを使用して、指定された入力の埋め込みを生成します。

namespace MyCompany.Embeddings;
using OpenAI.Embeddings;
using System;
using System.Threading.Tasks;
public class AIService
{
    private static readonly string? OpenAIApiKey = Environment.GetEnvironmentVariable("OPENAI_API_KEY");
    private static readonly string EmbeddingModelName = "text-embedding-3-small";
    public async Task<Dictionary<string, float[]>> GetEmbeddingsAsync(string[] texts)
    {
        EmbeddingClient embeddingClient = new(model: EmbeddingModelName, apiKey: OpenAIApiKey);
        Dictionary<string, float[]> documentData = new Dictionary<string, float[]>();
        try
        {
            var result = await embeddingClient.GenerateEmbeddingsAsync(texts);
            var embeddingCount = result.Value.Count;
            foreach (var index in Enumerable.Range(0, embeddingCount))
            {
                // Pair each embedding with the text used to generate it.
                documentData[texts[index]] = result.Value[index].ToFloats().ToArray();
            }
        }
        catch (Exception e)
        {
            throw new ApplicationException(e.Message);
        }
        return documentData;
    }
}

Go プロジェクトを初期化します。

ターミナル ウィンドウで次のコマンドを実行して、 my-embeddings-projectという名前の新しいディレクトリを作成し、プロジェクトを初期化します。

mkdir my-embeddings-project
cd my-embeddings-project
go mod init my-embeddings-project

依存関係をインストールしてインポートします。

ターミナルウィンドウで、次のコマンドを実行します。

go get github.com/joho/godotenv
go get go.mongodb.org/mongo-driver/v2/mongo
go get github.com/tmc/langchaingo/llms

.envシークレットを管理するには、 ファイルを作成します。

プロジェクトで、 Atlas 接続文字列と Hugeface アクセス トークンを保存するための .env ファイルを作成します。

HUGGINGFACEHUB_API_TOKEN = "<access-token>"
ATLAS_CONNECTION_STRING = "<connection-string>"

<access-token> プレースホルダー値を 1 つのドキュメント アクセス トークンに置き換えます。

<connection-string> プレースホルダー値を、Atlas クラスター SRV 接続文字列に置き換えます。

接続stringには、次の形式を使用する必要があります。

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

ベクトル埋め込みを生成する関数を定義する。

1. プロジェクトに common という名前のディレクトリを作成し、後の手順で使用する共通のコードを格納します。

   mkdir common && cd common

2. get-embeddings.go というファイルを作成し、次のコードを貼り付けます。このコードでは、与えられた入力に対して埋め込みを生成する関数 GetEmbeddings を定義しています。この関数は、以下を指定します。

   • LangChain ライブラリの Go ポートを使用する feature-extraction タスク。詳細については、LangChain JavaScriptドキュメントの Tasks ドキュメントを参照してください。

   • mxbai-embed-large-v1 埋め込みモデル。

   get-embeddings.go

   package common
   import (
   	"context"
   	"log"
   	"github.com/tmc/langchaingo/embeddings/huggingface"
   )
   func GetEmbeddings(documents []string) [][]float32 {
   	hf, err := huggingface.NewHuggingface(
   		huggingface.WithModel("mixedbread-ai/mxbai-embed-large-v1"),
   		huggingface.WithTask("feature-extraction"))
   	if err != nil {
   		log.Fatalf("failed to connect to Hugging Face: %v", err)
   	}
   	embs, err := hf.EmbedDocuments(context.Background(), documents)
   	if err != nil {
   		log.Fatalf("failed to generate embeddings: %v", err)
   	}
   	return embs
   }

   注意

   は額文字モデルを呼び出す場合の 503

   Hugging Face モデル ハブ モデルを呼び出すときに、503 エラーが発生する場合があります。この問題を解決するには、少し待ってから再試行します。

3. メイン プロジェクトのルート ディレクトリに戻ります。

   cd ../

Go プロジェクトを初期化します。

ターミナル ウィンドウで次のコマンドを実行して、 my-embeddings-projectという名前の新しいディレクトリを作成し、プロジェクトを初期化します。

mkdir my-embeddings-project
cd my-embeddings-project
go mod init my-embeddings-project

依存関係をインストールしてインポートします。

ターミナルウィンドウで、次のコマンドを実行します。

go get github.com/joho/godotenv
go get go.mongodb.org/mongo-driver/v2/mongo

環境変数を設定します。

ターミナルウィンドウで次のコマンドを実行して、必要な環境変数を設定してください。

export VOYAGE_API_KEY="<api-key>"
export ATLAS_CONNECTION_STRING="<connection-string>"

<api-key> と<connection-string> のプレースホルダーの値を、Voyage API キーと Atlas クラスタのSRV接続文字列に置き換えます。

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

ベクトル埋め込みを生成する関数を定義する。

1. 複数のステップで使用するコードを保存するために、common というディレクトリをプロジェクトに作成します。

   mkdir common && cd common

2. get-embeddings.go というファイルを作成し、次のコードを貼り付けます。このコードは、Voyage AI の voyage-3-large モデルを使用して特定の入力の埋め込みを生成する GetEmbeddings という関数を定義します。

   get-embeddings.go

   package common
   import (
   	"bytes"
   	"context"
   	"encoding/json"
   	"fmt"
   	"io/ioutil"
   	"log"
   	"net/http"
   	"os"
   	"time"
   )
   var apiKey = os.Getenv("VOYAGE_API_KEY")
   // Fetch embeddings using Voyage AI REST API
   func GetEmbeddings(docs []string) [][]float32 {
   	if apiKey == "" {
   		log.Fatalf("VOYAGE_API_KEY environment variable is not set")
   		return nil
   	}
   	url := "https://api.voyageai.com/v1/embeddings"
   	// Prepare request body according to the API specification
   	requestBody := map[string]interface{}{
   		"input":            docs,
   		"model":            "voyage-3-large",
   		"output_dimension": 1024,
   	}
   	requestBytes, err := json.Marshal(requestBody)
   	if err != nil {
   		log.Fatalf("failed to marshal request body: %v", err)
   		return nil
   	}
   	// Create context with timeout
   	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
   	defer cancel()
   	req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewBuffer(requestBytes))
   	if err != nil {
   		log.Fatalf("failed to create HTTP request: %v", err)
   		return nil
   	}
   	req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", apiKey))
   	req.Header.Set("Content-Type", "application/json")
   	client := &http.Client{}
   	resp, err := client.Do(req)
   	if err != nil {
   		log.Fatalf("failed to make API request: %v", err)
   		return nil
   	}
   	defer resp.Body.Close()
   	if resp.StatusCode != http.StatusOK {
   		body, _ := ioutil.ReadAll(resp.Body)
   		log.Fatalf("unexpected status code %d: %s", resp.StatusCode, string(body))
   		return nil
   	}
   	// Response structure according to the API specification
   	var response struct {
   		Object string `json:"object"`
   		Data   []struct {
   			Object    string    `json:"object"`
   			Embedding []float32 `json:"embedding"`
   			Index     int       `json:"index"`
   		} `json:"data"`
   		Model string `json:"model"`
   		Usage struct {
   			TotalTokens int `json:"total_tokens"`
   		} `json:"usage"`
   	}
   	if err := json.NewDecoder(resp.Body).Decode(&response); err != nil {
   		log.Fatalf("failed to parse API response: %v", err)
   		return nil
   	}
   	// Extract embeddings from the response
   	embeddings := make([][]float32, len(response.Data))
   	for i, item := range response.Data {
   		embeddings[i] = item.Embedding
   	}
   	return embeddings
   }

3. メイン プロジェクトのルート ディレクトリに戻ります。

   cd ../

Go プロジェクトを初期化します。

ターミナル ウィンドウで次のコマンドを実行して、 my-embeddings-projectという名前の新しいディレクトリを作成し、プロジェクトを初期化します。

mkdir my-embeddings-project
cd my-embeddings-project
go mod init my-embeddings-project

依存関係をインストールしてインポートします。

ターミナルウィンドウで、次のコマンドを実行します。

go get github.com/joho/godotenv
go get go.mongodb.org/mongo-driver/v2/mongo
go get github.com/milosgajdos/go-embeddings/openai

.envシークレットを管理するには、 ファイルを作成します。

.envstringプロジェクトで、接続文字列と OpenAI APIトークンを保存するためのAPI ファイルを作成します。

OPENAI_API_KEY = "<api-key>"
ATLAS_CONNECTION_STRING = "<connection-string>"

<api-key> と<connection-string> のプレースホルダの値を、OpenAI API キーと Atlas クラスタのSRV 接続文字列に置き換えます。

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

ベクトル埋め込みを生成する関数を定義する。

1. 複数のステップで使用するコードを保存するために、common というディレクトリをプロジェクトに作成します。

   mkdir common && cd common

2. get-embeddings.go というファイルを作成し、次のコードを貼り付けます。このコードは、OpenAI の text-embedding-3-small モデルを使用して特定の入力の埋め込みを生成する GetEmbeddings という関数を定義します。

   get-embeddings.go

   package common
   import (
   	"context"
   	"log"
   	"github.com/milosgajdos/go-embeddings/openai"
   )
   func GetEmbeddings(docs []string) [][]float64 {
   	c := openai.NewClient()
   	embReq := &openai.EmbeddingRequest{
   		Input:          docs,
   		Model:          openai.TextSmallV3,
   		EncodingFormat: openai.EncodingFloat,
   	}
   	embs, err := c.Embed(context.Background(), embReq)
   	if err != nil {
   		log.Fatalf("failed to connect to OpenAI: %v", err)
   	}
   	var vectors [][]float64
   	for _, emb := range embs {
   		vectors = append(vectors, emb.Vector)
   	}
   	return vectors
   }

3. メイン プロジェクトのルート ディレクトリに戻ります。

   cd ../

Javaプロジェクトを作成し、依存関係をインストールします。

1. IDE から、Maven または Gradle を使用してJavaプロジェクトを作成します。

2. パッケージマネージャーに応じて、次の依存関係を追加します。

   Maven

   Gradle

   Maven を使用している場合は、プロジェクトの pom.xmlファイルの dependencies 配列に次の依存関係を追加します。

   pom.xml

   <dependencies>
      <!-- MongoDB Java Sync Driver v5.2.0 or later -->
      <dependency>
         <groupId>org.mongodb</groupId>
         <artifactId>mongodb-driver-sync</artifactId>
         <version>[5.2.0,)</version>
      </dependency>
      <!-- Java library for working with Hugging Face models -->
      <dependency>
         <groupId>dev.langchain4j</groupId>
         <artifactId>langchain4j-hugging-face</artifactId>
         <version>1.1.0-beta7</version>
      </dependency>
   </dependencies>

   Gradle を使用している場合は、プロジェクトの build.gradleファイルの dependencies 配列に以下を追加します。

   build.grouple

   dependencies {
      // MongoDB Java Sync Driver v5.2.0 or later
      implementation 'org.mongodb:mongodb-driver-sync:[5.2.0,)'
      // Java library for working with Hugging Face models
      implementation 'dev.langchain4j:langchain4j-hugging-face:1.1.0-beta7'
   }

3. パッケージマネージャーを実行して、プロジェクトに依存関係をインストールします。

環境変数を設定します。

IDE で新しい構成テンプレートを作成し、次の変数をプロジェクトに追加します 。

• IntelliJ IDEA を使用している場合は、新しい Application 実行構成テンプレートを作成し、Environment variables フィールドに変数をセミコロン区切りの値として追加します（例: FOO=123;BAR=456）。[OK] をクリックして、変更を適用します。

  詳細については、IntelliJ IDEA ドキュメントの「 テンプレートから実行/デバッグ構成を作成する 」セクションを参照してください。

• Eclipse を使用している場合は、新しい Java Application 起動構成を作成し、各変数を新しいキーと値のペアとして Environmentタブに追加します。 変更を適用し、OK をクリックします。

  詳細については、Eclipse IDE ドキュメントの「 Javaアプリケーション起動構成の作成 」セクションを参照してください。

HUGGING_FACE_ACCESS_TOKEN=<access-token>
ATLAS_CONNECTION_STRING=<connection-string>

プレースホルダーを次の値で更新します。

• <access-token>プレースホルダーの値を、Hugging Face アクセス トークンに置き換えます。

• <connection-string> プレースホルダー値を、Atlas クラスター SRV 接続文字列に置き換えます。

  接続stringには、次の形式を使用する必要があります。

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

ベクトル埋め込みを生成する方法を定義します。

EmbeddingProvider.javaという名前のファイルを作成し、次のコードを貼り付けます。

このコードでは、mxます。1

• 複数の入力:getEmbeddings メソッドはテキスト入力の配列（List<String> ）を受け入れるため、1 回のAPI呼び出しに複数の埋め込みを作成できます。このメソッドは、 API が提供する浮動小数点数の配列を、Atlas クラスターに保存するために double のBSON配列に変換します。

• 単一入力:getEmbedding メソッドは単一のString を受け入れます。これはベクトルデータに対して実行するクエリを表します。メソッドは、 APIが提供する浮動小数点数の配列を、コレクションをクエリするときに使用する double のBSON配列に変換します 。

import dev.langchain4j.data.embedding.Embedding;
import dev.langchain4j.data.segment.TextSegment;
import dev.langchain4j.model.huggingface.HuggingFaceEmbeddingModel;
import dev.langchain4j.model.output.Response;
import org.bson.BsonArray;
import org.bson.BsonDouble;
import java.util.List;
import static java.time.Duration.ofSeconds;
public class EmbeddingProvider {
    private static HuggingFaceEmbeddingModel embeddingModel;
    private static HuggingFaceEmbeddingModel getEmbeddingModel() {
        if (embeddingModel == null) {
            String accessToken = System.getenv("HUGGING_FACE_ACCESS_TOKEN");
            if (accessToken == null || accessToken.isEmpty()) {
                throw new RuntimeException("HUGGING_FACE_ACCESS_TOKEN env variable is not set or is empty.");
            }
            embeddingModel = HuggingFaceEmbeddingModel.builder()
                    .accessToken(accessToken)
                    .modelId("mixedbread-ai/mxbai-embed-large-v1")
                    .waitForModel(true)
                    .timeout(ofSeconds(60))
                    .build();
        }
        return embeddingModel;
    }
    /**
     * Takes an array of strings and returns a BSON array of embeddings to
     * store in the database.
     */
    public List<BsonArray> getEmbeddings(List<String> texts) {
        List<TextSegment> textSegments = texts.stream()
                .map(TextSegment::from)
                .toList();
        Response<List<Embedding>> response = getEmbeddingModel().embedAll(textSegments);
        return response.content().stream()
                .map(e -> new BsonArray(
                        e.vectorAsList().stream()
                                .map(BsonDouble::new)
                                .toList()))
                .toList();
    }
    /**
     * Takes a single string and returns a BSON array embedding to
     * use in a vector query.
     */
    public BsonArray getEmbedding(String text) {
        Response<Embedding> response = getEmbeddingModel().embed(text);
        return new BsonArray(
                response.content().vectorAsList().stream()
                        .map(BsonDouble::new)
                        .toList());
    }
}

Javaプロジェクトを作成し、依存関係をインストールします。

1. IDE から、Maven または Gradle を使用してJavaプロジェクトを作成します。

2. パッケージマネージャーに応じて、次の依存関係を追加します。

   Maven

   Gradle

   Maven を使用している場合は、プロジェクトの pom.xmlファイルの dependencies 配列に次の依存関係を追加します。

   pom.xml

   <dependencies>
      <!-- MongoDB Java Sync Driver v5.2.0 or later -->
      <dependency>
         <groupId>org.mongodb</groupId>
         <artifactId>mongodb-driver-sync</artifactId>
         <version>[5.2.0,)</version>
      </dependency>
      <!-- Java library for working with Voyage AI models -->
      <dependency>
         <groupId>dev.langchain4j</groupId>
         <artifactId>langchain4j-voyage-ai</artifactId>
         <version>1.1.0-beta7</version>
      </dependency>
   </dependencies>

   Gradle を使用している場合は、プロジェクトの build.gradleファイルの dependencies 配列に以下を追加します。

   build.grouple

   dependencies {
      // MongoDB Java Sync Driver v5.2.0 or later
      implementation 'org.mongodb:mongodb-driver-sync:[5.2.0,)'
      // Java library for working with Voyage AI models
      implementation 'dev.langchain4j:langchain4j-voyage-ai:1.1.0-beta7'
   }

3. パッケージマネージャーを実行して、プロジェクトに依存関係をインストールします。

環境変数を設定します。

IDE で新しい構成テンプレートを作成し、次の変数をプロジェクトに追加します 。

• IntelliJ IDEA を使用している場合は、新しい Application 実行構成テンプレートを作成し、Environment variables フィールドに変数をセミコロン区切りの値として追加してください（例: FOO=123;BAR=456）。変更を適用し、OK をクリックします。

  詳細については、IntelliJ IDEA ドキュメントの「 テンプレートから実行/デバッグ構成を作成する 」セクションを参照してください。

• Eclipse を使用している場合は、新しい Java Application 起動構成を作成し、各変数を新しいキーと値のペアとして Environmentタブに追加します。 変更を適用し、OK をクリックします。

  詳細については、Eclipse IDE ドキュメントの「 Javaアプリケーション起動構成の作成 」セクションを参照してください。

VOYAGE_AI_KEY=<api-key>
ATLAS_CONNECTION_STRING=<connection-string>

プレースホルダーを次の値で更新します。

• <api-key> プレースホルダーの値を Voyage AI API キーに置き換えてください。

• <connection-string> プレースホルダー値を、Atlas クラスター SRV 接続文字列に置き換えます。

  接続stringには、次の形式を使用する必要があります。

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

ベクトル埋め込みを生成する方法を定義します。

EmbeddingProvider.javaという名前のファイルを作成し、次のコードを貼り付けます。

このコードは、Voyage AIのvoyage-3-large 埋め込みモデルを使用して、与えられた入力に対する埋め込みを生成する以下の2つのメソッドを定義します。

• 複数の入力:getEmbeddings メソッドはテキスト入力の配列（List<String> ）を受け入れるため、1 回のAPI呼び出しに複数の埋め込みを作成できます。このメソッドは、 API が提供する浮動小数点数の配列を、Atlas クラスターに保存するために double のBSON配列に変換します。

• 単一入力:getEmbedding メソッドは単一のString を受け入れます。これはベクトルデータに対して実行するクエリを表します。メソッドは、 APIが提供する浮動小数点数の配列を、コレクションをクエリするときに使用する double のBSON配列に変換します 。

import dev.langchain4j.data.embedding.Embedding;
import dev.langchain4j.data.segment.TextSegment;
import dev.langchain4j.model.embedding.EmbeddingModel;
import dev.langchain4j.model.voyageai.VoyageAiEmbeddingModel;
import dev.langchain4j.model.output.Response;
import org.bson.BsonArray;
import org.bson.BsonDouble;
import java.util.List;
public class EmbeddingProvider {
    private static EmbeddingModel embeddingModel;
    private static EmbeddingModel getEmbeddingModel() {
        if (embeddingModel == null) {
            String apiKey = System.getenv("VOYAGE_AI_KEY");
            if (apiKey == null || apiKey.isEmpty()) {
                throw new IllegalStateException("VOYAGE_AI_KEY env variable is not set or is empty.");
            }
            return VoyageAiEmbeddingModel.builder()
                    .apiKey(apiKey)
                    .modelName("voyage-3-large")
                    .build();
        }
        return embeddingModel;
    }
    /**
     * Takes an array of strings and returns a BSON array of embeddings to
     * store in the database.
     */
    public List<BsonArray> getEmbeddings(List<String> texts) {
        List<TextSegment> textSegments = texts.stream()
                .map(TextSegment::from)
                .toList();
        Response<List<Embedding>> response = getEmbeddingModel().embedAll(textSegments);
        return response.content().stream()
                .map(e -> new BsonArray(
                        e.vectorAsList().stream()
                                .map(BsonDouble::new)
                                .toList()))
                .toList();
    }
    /**
     * Takes a single string and returns a BSON array embedding to
     * use in a vector query.
     */
    public BsonArray getEmbedding(String text) {
        Response<Embedding> response = getEmbeddingModel().embed(text);
        return new BsonArray(
                response.content().vectorAsList().stream()
                        .map(BsonDouble::new)
                        .toList());
    }
}

Javaプロジェクトを作成し、依存関係をインストールします。

1. IDE から、Maven または Gradle を使用してJavaプロジェクトを作成します。

2. パッケージマネージャーに応じて、次の依存関係を追加します。

   Maven

   Gradle

   Maven を使用している場合は、プロジェクトの pom.xmlファイルの dependencies 配列に次の依存関係を追加します。

   pom.xml

   <dependencies>
      <!-- MongoDB Java Sync Driver v5.2.0 or later -->
      <dependency>
         <groupId>org.mongodb</groupId>
         <artifactId>mongodb-driver-sync</artifactId>
         <version>[5.2.0,)</version>
      </dependency>
      <!-- Java library for working with OpenAI models -->
      <dependency>
         <groupId>dev.langchain4j</groupId>
         <artifactId>langchain4j-open-ai</artifactId>
         <version>0.35.0</version>
      </dependency>
   </dependencies>

   Gradle を使用している場合は、プロジェクトの build.gradleファイルの dependencies 配列に以下を追加します。

   build.grouple

   dependencies {
      // MongoDB Java Sync Driver v5.2.0 or later
      implementation 'org.mongodb:mongodb-driver-sync:[5.2.0,)'
      // Java library for working with OpenAI models
      implementation 'dev.langchain4j:langchain4j-open-ai:0.35.0'
   }

3. パッケージマネージャーを実行して、プロジェクトに依存関係をインストールします。

環境変数を設定します。

IDE で新しい構成テンプレートを作成し、次の変数をプロジェクトに追加します 。

• IntelliJ IDEA を使用している場合は、新しい Application 実行構成テンプレートを作成し、Environment variables フィールドに変数をセミコロン区切りの値として追加してください（例: FOO=123;BAR=456）。変更を適用し、OK をクリックします。

  詳細については、IntelliJ IDEA ドキュメントの「 テンプレートから実行/デバッグ構成を作成する 」セクションを参照してください。

• Eclipse を使用している場合は、新しい Java Application 起動構成を作成し、各変数を新しいキーと値のペアとして Environmentタブに追加します。 変更を適用し、OK をクリックします。

  詳細については、Eclipse IDE ドキュメントの「 Javaアプリケーション起動構成の作成 」セクションを参照してください。

OPEN_AI_API_KEY=<api-key>
ATLAS_CONNECTION_STRING=<connection-string>

プレースホルダーを次の値で更新します。

• ``<api-key>`` プレースホルダーの値を OpenAI API キーに置き換えてください。

• <connection-string> プレースホルダー値を、Atlas クラスター SRV 接続文字列に置き換えます。

  接続stringには、次の形式を使用する必要があります。

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

ベクトル埋め込みを生成する方法を定義します。

EmbeddingProvider.javaという名前のファイルを作成し、次のコードを貼り付けます。

このコードでは、テキスト埋め込み- 3-small OpenAI 埋め込みモデルを使用して、特定の入力の埋め込みを生成するための 2 つの方法を定義しています。

• 複数の入力:getEmbeddings メソッドはテキスト入力の配列（List<String> ）を受け入れるため、1 回のAPI呼び出しに複数の埋め込みを作成できます。このメソッドは、 API が提供する浮動小数点数の配列を、Atlas クラスターに保存するために double のBSON配列に変換します。

• 単一入力:getEmbedding メソッドは単一のString を受け入れます。これはベクトルデータに対して実行するクエリを表します。メソッドは、 APIが提供する浮動小数点数の配列を、コレクションをクエリするときに使用する double のBSON配列に変換します 。

import dev.langchain4j.data.embedding.Embedding;
import dev.langchain4j.data.segment.TextSegment;
import dev.langchain4j.model.openai.OpenAiEmbeddingModel;
import dev.langchain4j.model.output.Response;
import org.bson.BsonArray;
import org.bson.BsonDouble;
import java.util.List;
import static java.time.Duration.ofSeconds;
public class EmbeddingProvider {
    private static OpenAiEmbeddingModel embeddingModel;
    private static OpenAiEmbeddingModel getEmbeddingModel() {
        if (embeddingModel == null) {
            String apiKey = System.getenv("OPEN_AI_API_KEY");
            if (apiKey == null || apiKey.isEmpty()) {
                throw new IllegalStateException("OPEN_AI_API_KEY env variable is not set or is empty.");
            }
            return OpenAiEmbeddingModel.builder()
                    .apiKey(apiKey)
                    .modelName("text-embedding-3-small")
                    .timeout(ofSeconds(60))
                    .build();
        }
        return embeddingModel;
    }
    /**
     * Takes an array of strings and returns a BSON array of embeddings to
     * store in the database.
     */
    public List<BsonArray> getEmbeddings(List<String> texts) {
        List<TextSegment> textSegments = texts.stream()
                .map(TextSegment::from)
                .toList();
        Response<List<Embedding>> response = getEmbeddingModel().embedAll(textSegments);
        return response.content().stream()
                .map(e -> new BsonArray(
                        e.vectorAsList().stream()
                                .map(BsonDouble::new)
                                .toList()))
                .toList();
    }
    /**
     * Takes a single string and returns a BSON array embedding to
     * use in a vector query.
     */
    public BsonArray getEmbedding(String text) {
        Response<Embedding> response = getEmbeddingModel().embed(text);
        return new BsonArray(
                response.content().vectorAsList().stream()
                        .map(BsonDouble::new)
                        .toList());
    }
}

Node.js プロジェクトを初期化します。

ターミナル ウィンドウで次のコマンドを実行して、 my-embeddings-projectという名前の新しいディレクトリを作成し、プロジェクトを初期化します。

mkdir my-embeddings-project
cd my-embeddings-project
npm init -y

package.json ファイルを更新します。

ES モジュール "type": "module"package.jsonを使用するようにプロジェクトを構成する を ファイルに追加して保存する方法

{
  "type": "module",
  // other fields...
}

依存関係をインストールしてインポートします。

ターミナル ウィンドウで、次のコマンドを実行します。

npm install mongodb @xenova/transformers

.env ファイルを作成します。

1. プロジェクトに、Atlas 接続文字列を保存するための .env ファイルを作成します。

   ATLAS_CONNECTION_STRING="<connection-string>"

2. <connection-string> プレースホルダー値を、Atlas クラスター SRV 接続文字列に置き換えます。

   注意

   Node.js の最低バージョン要件

   Node.js v20.x は、--env-file オプションを導入しました。古いバージョンの Node.js を使用している場合は、dotenv パッケージをプロジェクトに追加するか、別の方法を使用して環境変数を管理します。

3. ファイルを保存します。

ベクトル埋め込みを生成する関数を定義する。

1. get-embeddings.jsという名前のファイルを作成します。

   touch get-embeddings.js

2. 次のコードをファイルに貼り付けます。

   このコードにより、入力された内容に応じて埋め込みを生成する関数「getEmbedding」が定義されます。この関数は、以下を指定します。

   • feature-extractionHuge Page の transformations.js からの タスク ライブラリ。詳しくは、「 タスク 」を参照してください。

   • noomic- embedded-text-v1 埋め込みモデル。

   get-embeddings.js

   import { pipeline } from '@xenova/transformers';
   // Function to generate embeddings for a given data source
   export async function getEmbedding(data) {
       const embedder = await pipeline(
           'feature-extraction', 
           'Xenova/nomic-embed-text-v1');
       const results = await embedder(data, { pooling: 'mean', normalize: true });
       return Array.from(results.data);
   }

3. ファイルを保存します。

Node.js プロジェクトを初期化します。

ターミナル ウィンドウで次のコマンドを実行して、 my-embeddings-projectという名前の新しいディレクトリを作成し、プロジェクトを初期化します。

mkdir my-embeddings-project
cd my-embeddings-project
npm init -y

package.json ファイルを更新します。

ES モジュール "type": "module"package.jsonを使用するようにプロジェクトを構成する を ファイルに追加して保存する方法

{
  "type": "module",
  // other fields...
}

依存関係をインストールしてインポートします。

ターミナル ウィンドウで、次のコマンドを実行します。

npm install mongodb voyageai

環境変数を保存します。

1. プロジェクトに、次の内容を持つ .envファイルを作成します。

   VOYAGE_API_KEY = "<api-key>"
   ATLAS_CONNECTION_STRING = "<connection-string>"

2. <api-key> と <connection-string> のプレースホルダー値を、Voyage APIキー と Atlas クラスターの SRV 接続文字列 に置き換えます。接続文字列には、次の形式を使用する必要があります。

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

   注意

   Node.js の最低バージョン要件

   Node.js v20.x は、--env-file オプションを導入しました。古いバージョンの Node.js を使用している場合は、dotenv パッケージをプロジェクトに追加するか、別の方法を使用して環境変数を管理します。

3. ファイルを保存します。

ベクトル埋め込みを生成する関数を定義する。

1. get-embeddings.jsという名前のファイルを作成します。

2. 次のコードを貼り付けます。このコードは、voyage-3-large モデルを使用して特定のテキスト入力の埋め込みを生成する getEmbedding という名前の関数を定義します。

   get-embeddings.js

   import { VoyageAIClient } from 'voyageai';
   // Set up Voyage AI configuration
   const client = new VoyageAIClient({apiKey: process.env.VOYAGE_API_KEY});
   // Function to generate embeddings using the Voyage AI API
   export async function getEmbedding(text) {
       const results = await client.embed({
           input: text,
           model: "voyage-3-large"
       });
       return results.data[0].embedding;
   }

   Tip

   詳細については、Voyage Typescriptライブラリと埋め込みモデルを参照してください。

3. ファイルを保存します。

Node.js プロジェクトを初期化します。

ターミナル ウィンドウで次のコマンドを実行して、 my-embeddings-projectという名前の新しいディレクトリを作成し、プロジェクトを初期化します。

mkdir my-embeddings-project
cd my-embeddings-project
npm init -y

package.json ファイルを更新します。

ES モジュール "type": "module"package.jsonを使用するようにプロジェクトを構成する を ファイルに追加して保存する方法

{
  "type": "module",
  // other fields...
}

依存関係をインストールしてインポートします。

ターミナル ウィンドウで、次のコマンドを実行します。

npm install mongodb openai

.env ファイルを作成します。

1. プロジェクトに、Atlas 接続文字列と OpenAI APIキーを保存するための .env ファイルを作成します。

   OPENAI_API_KEY = "<api-key>"
   ATLAS_CONNECTION_STRING = "<connection-string>"

2. <api-key> と<connection-string> のプレースホルダの値を、OpenAI API キーと Atlas クラスタのSRV 接続文字列に置き換えます。接続文字列には、次の形式を使用する必要があります。

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

   注意

   Node.js の最低バージョン要件

   Node.js v20.x は、--env-file オプションを導入しました。古いバージョンの Node.js を使用している場合は、dotenv パッケージをプロジェクトに追加するか、別の方法を使用して環境変数を管理します。

3. ファイルを保存します。

ベクトル埋め込みを生成する関数を定義する。

1. get-embeddings.jsという名前のファイルを作成します。

2. 次のコードを貼り付けます。このコードは、OpenAI の text-embedding-3-small モデルを使用して特定の入力の埋め込みを生成する getEmbedding という関数を定義します。

   get-embeddings.js

   import OpenAI from 'openai';
   // Set up OpenAI configuration
   const openai = new OpenAI({apiKey: process.env.OPENAI_API_KEY});
   // Function to generate embeddings using the OpenAI API
   export async function getEmbedding(text) {
       const results = await openai.embeddings.create({
           model: "text-embedding-3-small",
           input: text,
           encoding_format: "float",
       });
       return results.data[0].embedding;
   }

3. ファイルを保存します。

環境を設定します。

.ipynb拡張機能のファイルを保存してインタラクティブ Python ノートを作成し、ノート内で次のコマンドを実行して依存関係をインストールします。

pip install --quiet --upgrade sentence-transformers pymongo einops

ベクトル埋め込みを生成する関数を定義してテストします。

次のコードをノート PC に貼り付けて実行し、 Noonic AI のオープンソース埋め込みモデルを使用してベクトル埋め込みを生成する関数を作成します 。このコードでは、次の処理が行われます。

• noomic- embedded-text-v1 を ロードする 埋め込みモデル。

• 指定されたテキスト入力の埋め込みを生成するためにモデルを使用する get_embedding という名前の関数を作成します。デフォルトの精度は float32 です。

• 文字列 foo の埋め込みを生成します。

from sentence_transformers import SentenceTransformer
# Load the embedding model
model = SentenceTransformer("nomic-ai/nomic-embed-text-v1", trust_remote_code=True)
# Define a function to generate embeddings
def get_embedding(data, precision="float32"):
   return model.encode(data, precision=precision).tolist()
# Generate an embedding
embedding = get_embedding("foo")
print(embedding)

[-0.02980827  0.03841474 -0.02561123 ... -0.0532876 -0.0335409 -0.02591543]

from bson.binary import Binary 
from bson.binary import BinaryVectorDtype
# Define a function to generate BSON vectors
def generate_bson_vector(vector, vector_dtype):
   return Binary.from_vector(vector, vector_dtype)
# Generate BSON vector from the sample float32 embedding
bson_float32_embedding = generate_bson_vector(embedding, BinaryVectorDtype.FLOAT32)
# Print the converted embedding
print(f"The converted BSON embedding is: {bson_float32_embedding}")

The converted BSON embedding is: [Binary(b'\'\x00x0\xf4\ ... x9bL\xd4\xbc', 9), Binary(b'\'\x007 ... \x9e?\xe6<', 9)]

環境を設定します。

.ipynb拡張機能のファイルを保存してインタラクティブ Python ノートを作成し、ノート内で次のコマンドを実行して依存関係をインストールします。

pip install --quiet --upgrade voyageai pymongo

ベクトル埋め込みを生成する関数を定義してテストします。

次のコードをノート PC に貼り付けて実行し、Voyage AIの埋め込みモデルを使用してベクトル埋め込みを生成する get_embedding という名前の関数を作成します。<api-key> を Vyage APIキー に置き換えます。

この関数は、以下を指定します。

• voyage-3-large 使用する埋め込みモデルとして 。

• input_type パラメーターを使用して、検索用に埋め込みを最適化します。詳細については、 Vyage AI Python API を参照してください。

import os
import voyageai
# Specify your Voyage API key and embedding model
os.environ["VOYAGE_API_KEY"] = "<api-key>"
model = "voyage-3-large"
vo = voyageai.Client()
# Define a function to generate embeddings
def get_embedding(data, input_type = "document"):
  embeddings = vo.embed(
      data, model = model, input_type = input_type
  ).embeddings
  return embeddings[0]
# Generate an embedding
embedding = get_embedding("foo")
print(embedding)

[-0.016463523730635643, -0.040630217641592026, -0.026241062209010124, -0.006248823832720518, ... -0.003811582690104842, -0.01361055113375187, 0.047476209700107574, -0.0030144075863063335]

from bson.binary import Binary 
from bson.binary import BinaryVectorDtype
# Define a function to generate BSON vectors
def generate_bson_vector(vector, vector_dtype):
   return Binary.from_vector(vector, vector_dtype)
# Generate BSON vector from the sample float32 embedding
bson_float32_embedding = generate_bson_vector(embedding, BinaryVectorDtype.FLOAT32)
# Print the converted embedding
print(f"The converted BSON embedding is: {bson_float32_embedding}")

The converted BSON embedding is: [Binary(b'\'\x00x0\xf4\ ... x9bL\xd4\xbc', 9), Binary(b'\'\x007 ... \x9e?\xe6<', 9)]

環境を設定します。

.ipynb拡張機能のファイルを保存してインタラクティブ Python ノートを作成し、ノート内で次のコマンドを実行して依存関係をインストールします。

pip install --quiet --upgrade openai pymongo

ベクトル埋め込みを生成する関数を定義してテストします。

次のコードをノートに貼り付けて実行し、 OpenAI の独自の埋め込みモデルを使用してベクトル埋め込みを生成する関数を作成します 。<api-key>を OpenAI APIキーに置き換えます。 このコードでは、次の処理が行われます。

• text-embedding-3-small埋め込みモデルを指定します。

• モデルのAPIを呼び出して指定されたテキスト入力の埋め込みを生成するget_embeddingという名前の関数を作成します。

• 文字列 foo の単一の埋め込みを生成して関数をテストします。

import os
from openai import OpenAI
# Specify your OpenAI API key and embedding model
os.environ["OPENAI_API_KEY"] = "<api-key>"
model = "text-embedding-3-small"
openai_client = OpenAI()
# Define a function to generate embeddings
def get_embedding(text):
   """Generates vector embeddings for the given text."""
   embedding = openai_client.embeddings.create(input = [text], model=model).data[0].embedding
   return embedding
# Generate an embedding
embedding = get_embedding("foo")
print(embedding)

[-0.005843308754265308, -0.013111298903822899, -0.014585349708795547, 0.03580040484666824, 0.02671629749238491, ... ]

from bson.binary import Binary 
from bson.binary import BinaryVectorDtype
# Define a function to generate BSON vectors
def generate_bson_vector(vector, vector_dtype):
   return Binary.from_vector(vector, vector_dtype)
# Generate BSON vector from the sample float32 embedding
bson_float32_embedding = generate_bson_vector(embedding, BinaryVectorDtype.FLOAT32)
# Print the converted embedding
print(f"The converted BSON embedding is: {bson_float32_embedding}")

The converted BSON embedding is: b'\'\x00:y\xbf\...\xbb\xdaC\x9a\xbc'