Como criar incorporações de vetor

Inicialize seu projeto .NET.

Em uma janela de terminal, execute os seguintes comandos para inicializar seu projeto:

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

Instalar e importar dependências.

Em uma janela do terminal, execute os seguintes comandos:

dotnet add package MongoDB.Driver

Defina suas variáveis de ambiente.

Exporte suas variáveis de ambiente, set no PowerShell ou use o gerenciador de variáveis de ambiente do seu IDE para tornar a string de conexão e o token de acesso do HuggingFace disponíveis para seu projeto.

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

Substitua o valor do espaço reservado <access-token> pelo token de acesso do Abraçando a Face.

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

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

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

Defina uma função para gerar incorporações vetoriais.

Crie uma nova classe em um arquivo com o mesmo nome chamado AIService.cs e cole o código a seguir. Esse código define uma tarefa assíncrona chamada GetEmbeddingsAsync para gerar uma array de incorporações para uma array de entradas de string fornecidas. Esta função utiliza o modelo de incorporação 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;
    }
}

Inicialize seu projeto .NET.

Em uma janela de terminal, execute os seguintes comandos para inicializar seu projeto:

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

Instalar e importar dependências.

Em uma janela do terminal, execute os seguintes comandos:

dotnet add package MongoDB.Driver

Defina suas variáveis de ambiente.

Exporte suas variáveis de ambiente, set no PowerShell ou use o gerenciador de variáveis de ambiente do seu IDE para tornar a string de conexão e a chave da API Voyage AI disponíveis para o seu projeto.

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

Substitua o valor do espaço reservado <api-key> pela sua chave de API da Voyage AI.

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

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

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

Defina uma função para gerar incorporações vetoriais.

Crie uma nova classe em um arquivo com o mesmo nome chamado AIService.cs e cole o código a seguir. Esse código define uma tarefa assíncrona denominada GetEmbeddingsAsync para gerar uma matriz de incorporações para uma matriz de entradas de string fornecidas. Esta função usa o modelo voyage-3-large da Voyage AI para gerar uma incorporação para uma determinada entrada.

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; }
    }
}

Inicialize seu projeto .NET.

Em uma janela de terminal, execute os seguintes comandos para inicializar seu projeto:

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

Instalar e importar dependências.

Em uma janela do terminal, execute os seguintes comandos:

dotnet add package MongoDB.Driver
dotnet add package OpenAI

Defina suas variáveis de ambiente.

Exporte suas variáveis de ambiente, set no PowerShell ou use o gerenciador de variáveis de ambiente do seu IDE para tornar a string de conexão e o token de acesso do HuggingFace disponíveis para o seu projeto.

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

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

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

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

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

Defina uma função para gerar incorporações vetoriais.

Crie uma nova classe em um arquivo com o mesmo nome chamado AIService.cs e cole o código a seguir. Esse código define uma tarefa assíncrona chamada GetEmbeddingsAsync para gerar uma array de incorporações para uma array de entradas de string fornecidas. Essa função usa o modelo text-embedding-3-small da OpenAI para gerar uma incorporação para uma determinada entrada.

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;
    }
}

Inicialize seu projeto Go.

Em uma janela de terminal, execute os seguintes comandos para criar um novo diretório chamado my-embeddings-project e inicializar seu projeto:

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

Instalar e importar dependências.

Em uma janela do terminal, execute os seguintes comandos:

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

Crie um .env arquivo para gerenciar segredos.

Em seu projeto, crie um arquivo .env para armazenar sua string de conexão do Atlas e o token de acesso do Hugging Face.

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

Substitua o valor do espaço reservado <access-token> pelo token de acesso do Abraçando a Face.

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

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

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

Defina uma função para gerar incorporações vetoriais.

1. Crie um diretório no seu projeto chamado common para armazenar o código comum que você usará nas etapas posteriores:

   mkdir common && cd common

2. Crie um arquivo chamado get-embeddings.go e cole o código a seguir. Esse código define uma função chamada GetEmbeddings para gerar uma incorporação para uma determinada entrada. Essa função especifica:

   • A tarefa feature-extraction usando a porta Go da biblioteca do LangChain. Para saber mais, consulte a documentação das Tarefas na documentação do LangChain JavaScript.

   • O modelo de incorporação 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
   }

   Observação

   503 ao chamar modelos de Face Abraços

   Ocasionalmente, você pode receber erros 503 ao chamar modelos a partir do hub de modelos Hugging Face. Para resolver esse problema, tente novamente após um breve intervalo.

3. Volte para o diretório raiz do projeto principal.

   cd ../

Inicialize seu projeto Go.

Em uma janela de terminal, execute os seguintes comandos para criar um novo diretório chamado my-embeddings-project e inicializar seu projeto:

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

Instalar e importar dependências.

Em uma janela do terminal, execute os seguintes comandos:

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

Defina suas variáveis de ambiente.

Na janela do terminal, execute os seguintes comandos para definir as variáveis de ambiente necessárias.

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

Substitua os valores de espaço reservado <api-key> e <connection-string> pela sua chave de API da Voyage e a string de conexão SRV para o seu cluster Atlas.

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

Defina uma função para gerar incorporações vetoriais.

1. Crie um diretório em seu projeto chamado common para armazenar o código que você usará em várias etapas:

   mkdir common && cd common

2. Crie um arquivo chamado get-embeddings.go e cole o código a seguir. Este código define uma função chamada GetEmbeddings que utiliza o modelo voyage-3-large da Voyage AI para gerar uma incorporação para uma entrada específica.

   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. Volte para o diretório raiz do projeto principal.

   cd ../

Inicialize seu projeto Go.

Em uma janela de terminal, execute os seguintes comandos para criar um novo diretório chamado my-embeddings-project e inicializar seu projeto:

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

Instalar e importar dependências.

Em uma janela do terminal, execute os seguintes comandos:

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

Crie um .env arquivo para gerenciar segredos.

No seu projeto, crie um arquivo .env para armazenar sua string de conexão e o token de API OpenAI.

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

Substitua os valores de espaço reservado <api-key> e <connection-string> pela sua chave de API da OpenAI e pela string de conexão SRV do seu cluster to Atlas.

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

Defina uma função para gerar incorporações vetoriais.

1. Crie um diretório em seu projeto chamado common para armazenar o código que você usará em várias etapas:

   mkdir common && cd common

2. Crie um arquivo denominado get-embeddings.go e cole o seguinte código. Esse código define uma função chamada GetEmbeddings que usa o modelo text-embedding-3-small da OpenAI para gerar uma incorporação para uma determinada entrada.

   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. Volte para o diretório raiz do projeto principal.

   cd ../

Crie seu projeto Java e instale dependências.

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

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

   Maven

   Gradle

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

   pom.xml

   <dependencies>
      <!-- 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>

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

   build.gradle

   dependencies {
      // MongoDB Java Sync Driver v5.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. Execute seu gerenciador de pacote para instalar as dependências em seu projeto.

Defina suas variáveis de ambiente.

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

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

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

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

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

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

Atualize os espaços reservados com os seguintes valores:

• Substitua o valor do espaço reservado "<access-token>" pelo seu token de acesso do Hugging Face.

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

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

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

Defina um método para gerar incorporações vetoriais.

Crie um arquivo denominado EmbeddingProvider.java e cole o seguinte código.

Este código define dois métodos para gerar incorporações para uma determinada entrada usando o modelo de incorporação de código aberto mxbai-embed-large-v:1

• Várias Entradas: O getEmbeddings método aceita uma array de entradas de textoList<String>(), permitindo criar várias incorporações em uma única chamada de API. O método converte as arrays de floats fornecidas pela API em arrays BSON de double para armazenamento em seu Atlas cluster.

• Entrada única: o getEmbedding método aceita um String único, que representa uma query que você deseja fazer em relação aos dados vetoriais. O método converte a array de flutuantes fornecida pela API em uma array BSON de valores duplos para usar ao fazer query em sua coleção.

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());
    }
}

Crie seu projeto Java e instale dependências.

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

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

   Maven

   Gradle

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

   pom.xml

   <dependencies>
      <!-- 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>

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

   build.gradle

   dependencies {
      // MongoDB Java Sync Driver v5.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. Execute seu gerenciador de pacote para instalar as dependências em seu projeto.

Defina suas variáveis de ambiente.

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

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

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

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

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

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

Atualize os espaços reservados com os seguintes valores:

• Substitua o valor do espaço reservado <api-key> pela sua chave de API da Voyage AI.

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

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

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

Defina um método para gerar incorporações vetoriais.

Crie um arquivo denominado EmbeddingProvider.java e cole o seguinte código.

Este código define dois métodos para gerar incorporações para uma determinada entrada usando o modelo de incorporações voyage-3-large da Voyage AI:

• Várias Entradas: O getEmbeddings método aceita uma array de entradas de textoList<String>(), permitindo criar várias incorporações em uma única chamada de API. O método converte as arrays de floats fornecidas pela API em arrays BSON de double para armazenamento em seu Atlas cluster.

• Entrada única: o getEmbedding método aceita um String único, que representa uma query que você deseja fazer em relação aos dados vetoriais. O método converte a array de flutuantes fornecida pela API em uma array BSON de valores duplos para usar ao fazer query em sua coleção.

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());
    }
}

Crie seu projeto Java e instale dependências.

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

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

   Maven

   Gradle

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

   pom.xml

   <dependencies>
      <!-- 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>

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

   build.gradle

   dependencies {
      // MongoDB Java Sync Driver v5.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. Execute seu gerenciador de pacote para instalar as dependências em seu projeto.

Defina suas variáveis de ambiente.

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

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

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

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

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

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

Atualize os espaços reservados com os seguintes valores:

• Substitua o valor do espaço reservado ``<api-key>`` pela sua chave de API OpenAI.

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

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

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

Defina um método para gerar incorporações vetoriais.

Crie um arquivo denominado EmbeddingProvider.java e cole o seguinte código.

Este código define dois métodos para gerar incorporações para uma determinada entrada usando o modelo de incorporação text-embedding-3-small OpenAI:

• Várias Entradas: O getEmbeddings método aceita uma array de entradas de textoList<String>(), permitindo criar várias incorporações em uma única chamada de API. O método converte as arrays de floats fornecidas pela API em arrays BSON de double para armazenamento em seu Atlas cluster.

• Entrada única: o getEmbedding método aceita um String único, que representa uma query que você deseja fazer em relação aos dados vetoriais. O método converte a array de flutuantes fornecida pela API em uma array BSON de valores duplos para usar ao fazer query em sua coleção.

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());
    }
}

Inicialize seu projeto Node.js.

Em uma janela de terminal, execute os seguintes comandos para criar um novo diretório chamado my-embeddings-project e inicializar seu projeto:

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

Atualize seu arquivo package.json.

Configure seu projeto para usar módulos ES adicionando "type": "module" ao seu arquivo package.json e salvando-o.

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

Instalar e importar dependências.

Em uma janela de terminal, execute o seguinte comando:

npm install mongodb @xenova/transformers

Crie um arquivo .env.

1. No seu projeto, crie um arquivo .env para armazenar sua string de conexão do Atlas.

   ATLAS_CONNECTION_STRING="<connection-string>"

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

   Observação

   Requisitos mínimos de versão do Node.js

   O Node.js v20.x introduziu a opção --env-file. Se você estiver usando uma versão mais antiga do Node.js, adicione o pacote dotenv ao seu projeto ou use um método diferente para gerenciar suas variáveis de ambiente.

3. Salve o arquivo.

Defina uma função para gerar incorporações vetoriais.

1. Crie um arquivo denominado get-embeddings.js.

   touch get-embeddings.js

2. Cole o seguinte código no arquivo.

   Este código define uma função chamada getEmbedding para gerar uma incorporação para uma determinada entrada. Essa função especifica:

   • A tarefa feature-extraction da biblioteca transformers.js do Hugging Face. Para saber mais, consulte Tarefas.

   • O modelo de incorporação de1nomic-embed-text-v.

   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. Salve o arquivo.

Inicialize seu projeto Node.js.

Em uma janela de terminal, execute os seguintes comandos para criar um novo diretório chamado my-embeddings-project e inicializar seu projeto:

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

Atualize seu arquivo package.json.

Configure seu projeto para usar módulos ES adicionando "type": "module" ao seu arquivo package.json e salvando-o.

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

Instalar e importar dependências.

Em uma janela de terminal, execute o seguinte comando:

npm install mongodb voyageai

Armazenar variáveis de ambiente.

1. No seu projeto, crie um arquivo .env com o seguinte conteúdo:

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

2. Substitua <api-key> os <connection-string> valores de placeholder e pela chave da API do Voyage e pela string de conexão SRVdo Atlas cluster. Sua string de conexão deve usar o seguinte formato:

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

   Observação

   Requisitos mínimos de versão do Node.js

   O Node.js v20.x introduziu a opção --env-file. Se você estiver usando uma versão mais antiga do Node.js, adicione o pacote dotenv ao seu projeto ou use um método diferente para gerenciar suas variáveis de ambiente.

3. Salve o arquivo.

Defina uma função para gerar incorporações vetoriais.

1. Crie um arquivo denominado get-embeddings.js.

2. Cole o seguinte código. Este código define uma função denominada getEmbedding que utiliza o modelo voyage-3-large para gerar uma incorporação para uma determinada entrada de texto.

   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;
   }

   Dica

   Para saber mais, consulte Biblioteca Voyage Typescript e os modelos incorporados.

3. Salve o arquivo.

Inicialize seu projeto Node.js.

Em uma janela de terminal, execute os seguintes comandos para criar um novo diretório chamado my-embeddings-project e inicializar seu projeto:

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

Atualize seu arquivo package.json.

Configure seu projeto para usar módulos ES adicionando "type": "module" ao seu arquivo package.json e salvando-o.

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

Instalar e importar dependências.

Em uma janela de terminal, execute o seguinte comando:

npm install mongodb openai

Crie um arquivo .env.

1. Em seu projeto, crie um arquivo .env para armazenar sua string de conexão do Atlas e a chave de API da OpenAI.

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

2. Substitua os valores de espaço reservado <api-key> e <connection-string> por sua chave de API da OpenAI e a string de conexão SRV pra seu Cluster do Atlas. Sua string de conexão deve usar o seguinte formato:

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

   Observação

   Requisitos mínimos de versão do Node.js

   O Node.js v20.x introduziu a opção --env-file. Se você estiver usando uma versão mais antiga do Node.js, adicione o pacote dotenv ao seu projeto ou use um método diferente para gerenciar suas variáveis de ambiente.

3. Salve o arquivo.

Defina uma função para gerar incorporações vetoriais.

1. Crie um arquivo denominado get-embeddings.js.

2. Cole o seguinte código. Esse código define uma função chamada getEmbedding que usa o modelo text-embedding-3-small da OpenAI para gerar uma incorporação para uma determinada entrada.

   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. Salve o arquivo.

Configure o ambiente.

Crie um notebook Python interativo salvando um arquivo com a extensão .ipynb e, em seguida, execute o seguinte comando no notebook para instalar as dependências:

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

Defina e teste a função para gerar incorporações vetoriais.

Cole e execute o seguinte código no seu notebook para criar uma função que gera incorporações vetoriais usando um modelo de incorporação de código aberto da Nomic AI. Este código faz o seguinte:

• Carrega o modelo de incorporação de1nomic-embed-text-v.

• Cria uma função chamada get_embedding que usa o modelo para gerar incorporações para uma determinada entrada de texto. A precisão padrão é float32.

• Gera incorporações para a string, 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)]

Configure o ambiente.

Crie um notebook Python interativo salvando um arquivo com a extensão .ipynb e, em seguida, execute o seguinte comando no notebook para instalar as dependências:

pip install --quiet --upgrade voyageai pymongo

Defina e teste a função para gerar incorporações vetoriais.

Cole e execute o código a seguir em seu bloco de anotações para criar uma função chamada get_embedding que gera incorporações vetoriais usando um modelo de incorporação da Voyage AI. Substitua <api-key> pela sua chave API do Voyage.

A função especifica o seguinte:

• voyage-3-large como o modelo de incorporação a ser usado.

• input_type para otimizar suas incorporações para recuperação. Para saber mais, consulte a API Python da Voyage AI.

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)]

Configure o ambiente.

Crie um notebook Python interativo salvando um arquivo com a extensão .ipynb e, em seguida, execute o seguinte comando no notebook para instalar as dependências:

pip install --quiet --upgrade openai pymongo

Defina e teste uma função para gerar incorporações vetoriais.

Cole e execute o código a seguir em seu notebook para criar uma função que gere embeddings vetoriais usando um modelo de embedding proprietário da OpenAI. Substitua <api-key> pela sua chave de API OpenAI. Este código faz o seguinte:

• Especifica o modelo de incorporação text-embedding-3-small.

• Cria uma função chamada get_embedding que chama a API do modelo para gerar uma incorporação para uma determinada entrada de texto.

• Testa a função gerando uma única incorporação para a string 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'