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 elas no PowerShell ou use o gerenciador de variáveis de ambiente do seu IDE para disponibilizar a string de conexão e o token de acesso do HuggingFace 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 do mesmo nome denominado AIService.cs e cole o seguinte código. Este 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 de incorporação mxbai-embed-large-v.1

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
dotnet add package OpenAI

Defina suas variáveis de ambiente.

Exporte suas variáveis de ambienteset para o PowerShell ou use o gerenciador de variáveis de ambiente do seu IDE para disponibilizar a string de conexão e o token de acesso do HuggingFace para 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 do mesmo nome denominado AIService.cs e cole o seguinte código. Este 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 usa o modelo text-embedding-3-small do 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/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/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> 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

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 pacote :

   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>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 Hugging Face models
      implementation 'dev.langchain4j:langchain4j-hugging-face: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 do Application e 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 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 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 texto (List<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 pacote :

   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 do Application e 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>`` 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 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 texto (List<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.

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

ATLAS_CONNECTION_STRING = "<connection-string>"

Substitua o valor de espaço reservado <connection-string> pela string de conexão SRV do seu cluster Atlas. 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 um arquivo chamado get-embeddings.js e cole o código a seguir. Esse código define uma função denominada 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.

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

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.

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>"

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

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

Crie um arquivo denominado get-embeddings.js e 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.

import OpenAI from 'openai';
// Setup OpenAI configuration
const openai = new OpenAI({apiKey: process.env.OPENAI_API_KEY});
// Function to get the 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;
}

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

Installing collected packages: dnspython, pymongo
Successfully installed dnspython-2.7.0 pymongo-4.10.1

Defina 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 denominada get_embedding que utiliza o modelo para gerar float32, que é configurado como a precisão padrão, int8 ou int1 incorporações para uma determinada entrada de texto.

from sentence_transformers import SentenceTransformer
from sentence_transformers.quantization import quantize_embeddings
# Load the embedding model
model = SentenceTransformer("nomic-ai/nomic-embed-text-v1", trust_remote_code=True)
# Define a function to generate embeddings in multiple precisions
def get_embedding(data, precision="float32"):
    return model.encode(data, precision=precision)

Defina a função para converter incorporações vetoriais.

Cole e execute o código a seguir em seu bloco de anotações para criar uma função que converta incorporações vetoriais usando o driver do PyMongo . A função chamada generate_bson_vector para converter as incorporações de fidelidade total float32 nosint8 int1 vector subtipos BSON, e para processamento eficiente dos dados vetoriais.

from bson.binary import Binary
# Generate BSON vector using `BinaryVectorDtype`
def generate_bson_vector(vector, vector_dtype):
    return Binary.from_vector(vector, vector_dtype)

Defina a função para criar documentos com os embeddings.

Cole e execute o seguinte código no seu bloco de anotações para criar uma função chamada create_docs_with_bson_vector_embeddings que cria documentos com os embeddings.

from bson.binary import Binary
# Function to create documents with BSON vector embeddings
def create_docs_with_bson_vector_embeddings(bson_float32, bson_int8, bson_int1, data):
  docs = []
  for i, (bson_f32_emb, bson_int8_emb, bson_int1_emb, text) in enumerate(zip(bson_float32, bson_int8, bson_int1, data)):
        doc = {
            "_id": i,
            "data": text,
            "BSON-Float32-Embedding": bson_f32_emb,
            "BSON-Int8-Embedding": bson_int8_emb,
            "BSON-Int1-Embedding": bson_int1_emb,
        }
        docs.append(doc)
  return docs

Teste a função para gerar incorporações.

Cole e execute o seguinte código em seu bloco de anotações para testar a função de gerar incorporações usando a IA Nomic.

Este código gera embeddings float32, int8, int1 para as strings foo e bar.

# Example generating embeddings for the strings "foo" and "bar"
data = ["foo", "bar"]
float32_embeddings = get_embedding(data, "float32")
int8_embeddings = get_embedding(data, "int8")
int1_embeddings = get_embedding(data, "ubinary")
print("Float32 Embedding:", float32_embeddings)
print("Int8 Embedding:", int8_embeddings)
print("Int1 Embedding (binary representation):", int1_embeddings)

Float32 Embedding: [
   [-0.02980827  0.03841474 -0.02561123 ... -0.0532876
   -0.0335409 -0.02591543]
   [-0.02748881  0.03717749 -0.03104552 ...  0.02413219 -0.02402252 0.02810651]
]
Int8 Embedding: [
   [-128  127  127 ... -128 -128 -128]
   [ 126 -128 -128 ...  127  126  127]
]
Int1 Embedding (binary representation): [
   [ 77  30   4 131  15 123 146 ... 159 142 205  23 119 120]
   [ 79  82 208 180  45  79 209 ... 158 100 141 189 166 173]
]

Teste a função para converter incorporações em vetores BSON.

Cole e execute o código a seguir em seu bloco de anotações para testar a função de conversão de incorporações em vetores BSON usando o driver PyMongo.

Este código quantiza suas incorporações float32, int8 e int1 para as strings foo e bar.

from bson.binary import Binary, BinaryVectorDtype
bson_float32_embeddings = []
bson_int8_embeddings = []
bson_int1_embeddings = []
for (f32_emb, int8_emb, int1_emb) in zip(float32_embeddings, int8_embeddings, int1_embeddings):
    bson_float32_embeddings.append(generate_bson_vector(f32_emb, BinaryVectorDtype.FLOAT32))
    bson_int8_embeddings.append(generate_bson_vector(int8_emb, BinaryVectorDtype.INT8))
    bson_int1_embeddings.append(generate_bson_vector(int1_emb, BinaryVectorDtype.PACKED_BIT))
# Print the embeddings
print(f"The converted bson_float32_new_embedding is: {bson_float32_embeddings}")
print(f"The converted bson_int8_new_embedding is: {bson_int8_embeddings}")
print(f"The converted bson_int1_new_embedding is: {bson_int1_embeddings}")

The converted bson_float32_new_embedding is: [Binary(b'\'\x00x0\xf4\ ... x9bL\xd4\xbc', 9), Binary(b'\'\x007 ... \x9e?\xe6<', 9)]
The converted bson_int8_new_embedding is: [Binary(b'\x03\x00\x80\x7f\ ... x80\x80', 9), Binary(b'\x03\x00~\x80 ... \x7f', 9)]
The converted bson_int1_new_embedding is: [Binary(b'\x10\x00M\x1e\ ... 7wx', 9), Binary(b'\x10\x00OR\ ... \xa6\xad', 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 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
get_embedding("foo")

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