Como criar incorporações de vetor

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 sentence-transformers pymongo einops

Defina uma 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 uma incorporação para uma determinada entrada de texto.

• Testa a função gerando uma única incorporação para a string foo.

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

[-0.029808253049850464, 0.03841473162174225, -0.02561120130121708, -0.06707508116960526, 0.03867151960730553, ... ]

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 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, ... ]

Crie um arquivo chamado create-embeddings.go e cole o código a seguir.

Use o código a seguir para gerar incorporações a partir de uma coleção existente no Atlas.

Especificamente, este código usa a função GetEmbeddings que você definiu e o driver do MongoDB Go para gerar incorporações a partir de uma array de textos de amostra e ingeri-los na coleção sample_db.embeddings no Atlas.

package main
import (
	"context"
	"fmt"
	"log"
	"my-embeddings-project/common"
	"os"
	"github.com/joho/godotenv"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
)
var data = []string{
	"Titanic: The story of the 1912 sinking of the largest luxury liner ever built",
	"The Lion King: Lion cub and future king Simba searches for his identity",
	"Avatar: A marine is dispatched to the moon Pandora on a unique mission",
}
type TextWithEmbedding struct {
	Text      string
	Embedding []float32
}
func main() {
	ctx := context.Background()
	if err := godotenv.Load(); err != nil {
		log.Println("no .env file found")
	}
	// Connect to your Atlas cluster
	uri := os.Getenv("ATLAS_CONNECTION_STRING")
	if uri == "" {
		log.Fatal("set your 'ATLAS_CONNECTION_STRING' environment variable.")
	}
	clientOptions := options.Client().ApplyURI(uri)
	client, err := mongo.Connect(ctx, clientOptions)
	if err != nil {
		log.Fatalf("failed to connect to the server: %v", err)
	}
	defer func() { _ = client.Disconnect(ctx) }()
	// Set the namespace
	coll := client.Database("sample_db").Collection("embeddings")
	embeddings := common.GetEmbeddings(data)
	docsToInsert := make([]interface{}, len(embeddings))
	for i, string := range data {
		docsToInsert[i] = TextWithEmbedding{
			Text:      string,
			Embedding: embeddings[i],
		}
	}
	result, err := coll.InsertMany(ctx, docsToInsert)
	if err != nil {
		log.Fatalf("failed to insert documents: %v", err)
	}
	fmt.Printf("Successfully inserted %v documents into Atlas\n", len(result.InsertedIDs))
}

package main
import (
	"context"
	"fmt"
	"log"
	"my-embeddings-project/common"
	"os"
	"github.com/joho/godotenv"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
)
var data = []string{
	"Titanic: The story of the 1912 sinking of the largest luxury liner ever built",
	"The Lion King: Lion cub and future king Simba searches for his identity",
	"Avatar: A marine is dispatched to the moon Pandora on a unique mission",
}
type TextWithEmbedding struct {
	Text      string
	Embedding []float64
}
func main() {
	ctx := context.Background()
	if err := godotenv.Load(); err != nil {
		log.Println("no .env file found")
	}
	// Connect to your Atlas cluster
	uri := os.Getenv("ATLAS_CONNECTION_STRING")
	if uri == "" {
		log.Fatal("set your 'ATLAS_CONNECTION_STRING' environment variable.")
	}
	clientOptions := options.Client().ApplyURI(uri)
	client, err := mongo.Connect(ctx, clientOptions)
	if err != nil {
		log.Fatalf("failed to connect to the server: %v", err)
	}
	defer func() { _ = client.Disconnect(ctx) }()
	// Set the namespace
	coll := client.Database("sample_db").Collection("embeddings")
	embeddings := common.GetEmbeddings(data)
	docsToInsert := make([]interface{}, len(data))
	for i, movie := range data {
		docsToInsert[i] = TextWithEmbedding{
			Text:      movie,
			Embedding: embeddings[i],
		}
	}
	result, err := coll.InsertMany(ctx, docsToInsert)
	if err != nil {
		log.Fatalf("failed to insert documents: %v", err)
	}
	fmt.Printf("Successfully inserted %v documents into Atlas\n", len(result.InsertedIDs))
}

Salve e execute o arquivo.

go run create-embeddings.go

Successfully inserted 3 documents into Atlas

go run create-embeddings.go

Successfully inserted 3 documents into Atlas

Você também pode visualizar suas incorporações vetoriais na interface do Atlas navegando até a coleção sample_db.embeddings no seu cluster.

Crie um arquivo chamado create-embeddings.go e cole o código a seguir.

Use o código a seguir para gerar incorporações a partir de uma coleção existente no Atlas. Especificamente, esse código faz o seguinte:

• Conecta-se ao seu cluster do Atlas.

• Obtém um subconjunto de documentos da coleção sample_airbnb.listingsAndReviews que tem um campo summary não vazio.

• Gera incorporações do campo summary de cada documento usando a função GetEmbeddings que você definiu.

• Atualiza cada documento com um novo campo embeddings que contém o valor de incorporação usando o Go Driver do MongoDB.

package main
import (
	"context"
	"log"
	"my-embeddings-project/common"
	"os"
	"github.com/joho/godotenv"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
)
func main() {
	ctx := context.Background()
	if err := godotenv.Load(); err != nil {
		log.Println("no .env file found")
	}
	// Connect to your Atlas cluster
	uri := os.Getenv("ATLAS_CONNECTION_STRING")
	if uri == "" {
		log.Fatal("set your 'ATLAS_CONNECTION_STRING' environment variable.")
	}
	clientOptions := options.Client().ApplyURI(uri)
	client, err := mongo.Connect(ctx, clientOptions)
	if err != nil {
		log.Fatalf("failed to connect to the server: %v", err)
	}
	defer func() { _ = client.Disconnect(ctx) }()
	// Set the namespace
	coll := client.Database("sample_airbnb").Collection("listingsAndReviews")
	filter := bson.D{
		{"$and",
			bson.A{
				bson.D{
					{"$and",
						bson.A{
							bson.D{{"summary", bson.D{{"$exists", true}}}},
							bson.D{{"summary", bson.D{{"$ne", ""}}}},
						},
					}},
				bson.D{{"embeddings", bson.D{{"$exists", false}}}},
			}},
	}
	opts := options.Find().SetLimit(50)
	cursor, err := coll.Find(ctx, filter, opts)
	if err != nil {
		log.Fatalf("failed to retrieve documents: %v", err)
	}
	var listings []common.Listing
	if err = cursor.All(ctx, &listings); err != nil {
		log.Fatalf("failed to unmarshal retrieved documents to Listing object: %v", err)
	}
	var summaries []string
	for _, listing := range listings {
		summaries = append(summaries, listing.Summary)
	}
	log.Println("Generating embeddings.")
	embeddings := common.GetEmbeddings(summaries)
	docsToUpdate := make([]mongo.WriteModel, len(listings))
	for i := range listings {
		docsToUpdate[i] = mongo.NewUpdateOneModel().
			SetFilter(bson.D{{"_id", listings[i].ID}}).
			SetUpdate(bson.D{{"$set", bson.D{{"embeddings", embeddings[i]}}}})
	}
	bulkWriteOptions := options.BulkWrite().SetOrdered(false)
	result, err := coll.BulkWrite(context.Background(), docsToUpdate, bulkWriteOptions)
	if err != nil {
		log.Fatalf("failed to write embeddings to existing documents: %v", err)
	}
	log.Printf("Successfully added embeddings to %v documents", result.ModifiedCount)
}

Crie um arquivo que contenha modelos Go para a coleção.

Para simplificar a ordenação e a desordenação de objetos Go de e para o BSON, crie um arquivo que contenha modelos para os documentos nesta coleção.

1. Mover para o diretório common.

   cd common

2. Crie um arquivo denominado models.go e cole o seguinte código nele:

   Código aberto

   OpenAI

   models.go

   package common
   import (
   	"time"
   	"go.mongodb.org/mongo-driver/bson/primitive"
   )
   type Image struct {
   	ThumbnailURL string `bson:"thumbnail_url"`
   	MediumURL    string `bson:"medium_url"`
   	PictureURL   string `bson:"picture_url"`
   	XLPictureURL string `bson:"xl_picture_url"`
   }
   type Host struct {
   	ID                 string   `bson:"host_id"`
   	URL                string   `bson:"host_url"`
   	Name               string   `bson:"host_name"`
   	Location           string   `bson:"host_location"`
   	About              string   `bson:"host_about"`
   	ThumbnailURL       string   `bson:"host_thumbnail_url"`
   	PictureURL         string   `bson:"host_picture_url"`
   	Neighborhood       string   `bson:"host_neighborhood"`
   	IsSuperhost        bool     `bson:"host_is_superhost"`
   	HasProfilePic      bool     `bson:"host_has_profile_pic"`
   	IdentityVerified   bool     `bson:"host_identity_verified"`
   	ListingsCount      int32    `bson:"host_listings_count"`
   	TotalListingsCount int32    `bson:"host_total_listings_count"`
   	Verifications      []string `bson:"host_verifications"`
   }
   type Location struct {
   	Type            string    `bson:"type"`
   	Coordinates     []float64 `bson:"coordinates"`
   	IsLocationExact bool      `bson:"is_location_exact"`
   }
   type Address struct {
   	Street         string   `bson:"street"`
   	Suburb         string   `bson:"suburb"`
   	GovernmentArea string   `bson:"government_area"`
   	Market         string   `bson:"market"`
   	Country        string   `bson:"Country"`
   	CountryCode    string   `bson:"country_code"`
   	Location       Location `bson:"location"`
   }
   type Availability struct {
   	Thirty         int32 `bson:"availability_30"`
   	Sixty          int32 `bson:"availability_60"`
   	Ninety         int32 `bson:"availability_90"`
   	ThreeSixtyFive int32 `bson:"availability_365"`
   }
   type ReviewScores struct {
   	Accuracy      int32 `bson:"review_scores_accuracy"`
   	Cleanliness   int32 `bson:"review_scores_cleanliness"`
   	CheckIn       int32 `bson:"review_scores_checkin"`
   	Communication int32 `bson:"review_scores_communication"`
   	Location      int32 `bson:"review_scores_location"`
   	Value         int32 `bson:"review_scores_value"`
   	Rating        int32 `bson:"review_scores_rating"`
   }
   type Review struct {
   	ID           string    `bson:"_id"`
   	Date         time.Time `bson:"date,omitempty"`
   	ListingId    string    `bson:"listing_id"`
   	ReviewerId   string    `bson:"reviewer_id"`
   	ReviewerName string    `bson:"reviewer_name"`
   	Comments     string    `bson:"comments"`
   }
   type Listing struct {
   	ID                   string               `bson:"_id"`
   	ListingURL           string               `bson:"listing_url"`
   	Name                 string               `bson:"name"`
   	Summary              string               `bson:"summary"`
   	Space                string               `bson:"space"`
   	Description          string               `bson:"description"`
   	NeighborhoodOverview string               `bson:"neighborhood_overview"`
   	Notes                string               `bson:"notes"`
   	Transit              string               `bson:"transit"`
   	Access               string               `bson:"access"`
   	Interaction          string               `bson:"interaction"`
   	HouseRules           string               `bson:"house_rules"`
   	PropertyType         string               `bson:"property_type"`
   	RoomType             string               `bson:"room_type"`
   	BedType              string               `bson:"bed_type"`
   	MinimumNights        string               `bson:"minimum_nights"`
   	MaximumNights        string               `bson:"maximum_nights"`
   	CancellationPolicy   string               `bson:"cancellation_policy"`
   	LastScraped          time.Time            `bson:"last_scraped,omitempty"`
   	CalendarLastScraped  time.Time            `bson:"calendar_last_scraped,omitempty"`
   	FirstReview          time.Time            `bson:"first_review,omitempty"`
   	LastReview           time.Time            `bson:"last_review,omitempty"`
   	Accommodates         int32                `bson:"accommodates"`
   	Bedrooms             int32                `bson:"bedrooms"`
   	Beds                 int32                `bson:"beds"`
   	NumberOfReviews      int32                `bson:"number_of_reviews"`
   	Bathrooms            primitive.Decimal128 `bson:"bathrooms"`
   	Amenities            []string             `bson:"amenities"`
   	Price                primitive.Decimal128 `bson:"price"`
   	WeeklyPrice          primitive.Decimal128 `bson:"weekly_price"`
   	MonthlyPrice         primitive.Decimal128 `bson:"monthly_price"`
   	CleaningFee          primitive.Decimal128 `bson:"cleaning_fee"`
   	ExtraPeople          primitive.Decimal128 `bson:"extra_people"`
   	GuestsIncluded       primitive.Decimal128 `bson:"guests_included"`
   	Image                Image                `bson:"images"`
   	Host                 Host                 `bson:"host"`
   	Address              Address              `bson:"address"`
   	Availability         Availability         `bson:"availability"`
   	ReviewScores         ReviewScores         `bson:"review_scores"`
   	Reviews              []Review             `bson:"reviews"`
   	Embeddings           []float32            `bson:"embeddings,omitempty"`
   }

   models.go

   package common
   import (
   	"time"
   	"go.mongodb.org/mongo-driver/bson/primitive"
   )
   type Image struct {
   	ThumbnailURL string `bson:"thumbnail_url"`
   	MediumURL    string `bson:"medium_url"`
   	PictureURL   string `bson:"picture_url"`
   	XLPictureURL string `bson:"xl_picture_url"`
   }
   type Host struct {
   	ID                 string   `bson:"host_id"`
   	URL                string   `bson:"host_url"`
   	Name               string   `bson:"host_name"`
   	Location           string   `bson:"host_location"`
   	About              string   `bson:"host_about"`
   	ThumbnailURL       string   `bson:"host_thumbnail_url"`
   	PictureURL         string   `bson:"host_picture_url"`
   	Neighborhood       string   `bson:"host_neighborhood"`
   	IsSuperhost        bool     `bson:"host_is_superhost"`
   	HasProfilePic      bool     `bson:"host_has_profile_pic"`
   	IdentityVerified   bool     `bson:"host_identity_verified"`
   	ListingsCount      int32    `bson:"host_listings_count"`
   	TotalListingsCount int32    `bson:"host_total_listings_count"`
   	Verifications      []string `bson:"host_verifications"`
   }
   type Location struct {
   	Type            string    `bson:"type"`
   	Coordinates     []float64 `bson:"coordinates"`
   	IsLocationExact bool      `bson:"is_location_exact"`
   }
   type Address struct {
   	Street         string   `bson:"street"`
   	Suburb         string   `bson:"suburb"`
   	GovernmentArea string   `bson:"government_area"`
   	Market         string   `bson:"market"`
   	Country        string   `bson:"Country"`
   	CountryCode    string   `bson:"country_code"`
   	Location       Location `bson:"location"`
   }
   type Availability struct {
   	Thirty         int32 `bson:"availability_30"`
   	Sixty          int32 `bson:"availability_60"`
   	Ninety         int32 `bson:"availability_90"`
   	ThreeSixtyFive int32 `bson:"availability_365"`
   }
   type ReviewScores struct {
   	Accuracy      int32 `bson:"review_scores_accuracy"`
   	Cleanliness   int32 `bson:"review_scores_cleanliness"`
   	CheckIn       int32 `bson:"review_scores_checkin"`
   	Communication int32 `bson:"review_scores_communication"`
   	Location      int32 `bson:"review_scores_location"`
   	Value         int32 `bson:"review_scores_value"`
   	Rating        int32 `bson:"review_scores_rating"`
   }
   type Review struct {
   	ID           string    `bson:"_id"`
   	Date         time.Time `bson:"date,omitempty"`
   	ListingId    string    `bson:"listing_id"`
   	ReviewerId   string    `bson:"reviewer_id"`
   	ReviewerName string    `bson:"reviewer_name"`
   	Comments     string    `bson:"comments"`
   }
   type Listing struct {
   	ID                   string               `bson:"_id"`
   	ListingURL           string               `bson:"listing_url"`
   	Name                 string               `bson:"name"`
   	Summary              string               `bson:"summary"`
   	Space                string               `bson:"space"`
   	Description          string               `bson:"description"`
   	NeighborhoodOverview string               `bson:"neighborhood_overview"`
   	Notes                string               `bson:"notes"`
   	Transit              string               `bson:"transit"`
   	Access               string               `bson:"access"`
   	Interaction          string               `bson:"interaction"`
   	HouseRules           string               `bson:"house_rules"`
   	PropertyType         string               `bson:"property_type"`
   	RoomType             string               `bson:"room_type"`
   	BedType              string               `bson:"bed_type"`
   	MinimumNights        string               `bson:"minimum_nights"`
   	MaximumNights        string               `bson:"maximum_nights"`
   	CancellationPolicy   string               `bson:"cancellation_policy"`
   	LastScraped          time.Time            `bson:"last_scraped,omitempty"`
   	CalendarLastScraped  time.Time            `bson:"calendar_last_scraped,omitempty"`
   	FirstReview          time.Time            `bson:"first_review,omitempty"`
   	LastReview           time.Time            `bson:"last_review,omitempty"`
   	Accommodates         int32                `bson:"accommodates"`
   	Bedrooms             int32                `bson:"bedrooms"`
   	Beds                 int32                `bson:"beds"`
   	NumberOfReviews      int32                `bson:"number_of_reviews"`
   	Bathrooms            primitive.Decimal128 `bson:"bathrooms"`
   	Amenities            []string             `bson:"amenities"`
   	Price                primitive.Decimal128 `bson:"price"`
   	WeeklyPrice          primitive.Decimal128 `bson:"weekly_price"`
   	MonthlyPrice         primitive.Decimal128 `bson:"monthly_price"`
   	CleaningFee          primitive.Decimal128 `bson:"cleaning_fee"`
   	ExtraPeople          primitive.Decimal128 `bson:"extra_people"`
   	GuestsIncluded       primitive.Decimal128 `bson:"guests_included"`
   	Image                Image                `bson:"images"`
   	Host                 Host                 `bson:"host"`
   	Address              Address              `bson:"address"`
   	Availability         Availability         `bson:"availability"`
   	ReviewScores         ReviewScores         `bson:"review_scores"`
   	Reviews              []Review             `bson:"reviews"`
   	Embeddings           []float64            `bson:"embeddings,omitempty"`
   }

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

   cd ../

Gerar incorporações.

go run create-embeddings.go

2024/10/10 09:58:03 Generating embeddings.
2024/10/10 09:58:12 Successfully added embeddings to 50 documents

Você pode visualizar suas incorporações vetoriais conforme são geradas navegando até a coleção sample_airbnb.listingsAndReviews na IU do Atlas.

Defina o código para gerar incorporações a partir de uma coleção existente no Atlas.

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

Este código utiliza o getEmbeddings método e o MongoDB Java Sync Driver para fazer o seguinte:

1. Conecte-se ao seu cluster do Atlas.

2. Obtenha a array de textos de exemplo.

3. Gere incorporações de cada texto utilizando o método getEmbeddings que você definiu anteriormente.

4. Gerencie as incorporações na coleção sample_db.embeddings no Atlas.

import com.mongodb.MongoException;
import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.result.InsertManyResult;
import org.bson.BsonArray;
import org.bson.Document;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class CreateEmbeddings {
    static List<String> data = Arrays.asList(
            "Titanic: The story of the 1912 sinking of the largest luxury liner ever built",
            "The Lion King: Lion cub and future king Simba searches for his identity",
            "Avatar: A marine is dispatched to the moon Pandora on a unique mission"
    );
    public static void main(String[] args){
        String uri = System.getenv("ATLAS_CONNECTION_STRING");
        if (uri == null || uri.isEmpty()) {
            throw new RuntimeException("ATLAS_CONNECTION_STRING env variable is not set or is empty.");
        }
        // establish connection and set namespace
        try (MongoClient mongoClient = MongoClients.create(uri)) {
            MongoDatabase database = mongoClient.getDatabase("sample_db");
            MongoCollection<Document> collection = database.getCollection("embeddings");
            System.out.println("Creating embeddings for " + data.size() + " documents");
            EmbeddingProvider embeddingProvider = new EmbeddingProvider();
            // generate embeddings for new inputted data
            List<BsonArray> embeddings = embeddingProvider.getEmbeddings(data);
            List<Document> documents = new ArrayList<>();
            int i = 0;
            for (String text : data) {
                Document doc = new Document("text", text).append("embedding", embeddings.get(i));
                documents.add(doc);
                i++;
            }
            // insert the embeddings into the Atlas collection
            List<String> insertedIds = new ArrayList<>();
            try {
                InsertManyResult result = collection.insertMany(documents);
                result.getInsertedIds().values()
                        .forEach(doc -> insertedIds.add(doc.toString()));
                System.out.println("Inserted " + insertedIds.size() + " documents with the following ids to " + collection.getNamespace() + " collection: \n " + insertedIds);
            } catch (MongoException me) {
                throw new RuntimeException("Failed to insert documents", me);
            }
        } catch (MongoException me) {
            throw new RuntimeException("Failed to connect to MongoDB ", me);
        } catch (Exception e) {
            throw new RuntimeException("Operation failed: ", e);
        }
    }
}

Gere as incorporações.

Salve e execute o arquivo. A saída se assemelha a:

Creating embeddings for 3 documents
Inserted 3 documents with the following ids to sample_db.embeddings collection:
 [BsonObjectId{value=6735ff620d88451041f6dd40}, BsonObjectId{value=6735ff620d88451041f6dd41}, BsonObjectId{value=6735ff620d88451041f6dd42}]

Você também pode visualizar suas incorporações vetoriais na interface do Atlas navegando até a coleção sample_db.embeddings no seu cluster.

Defina o código para gerar incorporações a partir de uma coleção existente no Atlas.

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

Este código utiliza o getEmbeddings método e o MongoDB Java Sync Driver para fazer o seguinte:

1. Conecte-se ao seu cluster do Atlas.

2. Obtenha um subconjunto de documentos da coleção sample_airbnb.listingsAndReviews que possuem um campo summary não vazio.

3. Gere incorporações a partir do campo summary de cada documento usando o método getEmbeddings definido anteriormente.

4. Atualize cada documento com um novo campo embeddings que contém o valor de incorporação.

import com.mongodb.MongoException;
import com.mongodb.bulk.BulkWriteResult;
import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.model.BulkWriteOptions;
import com.mongodb.client.model.Filters;
import com.mongodb.client.model.UpdateOneModel;
import com.mongodb.client.model.Updates;
import com.mongodb.client.model.WriteModel;
import org.bson.BsonArray;
import org.bson.Document;
import org.bson.conversions.Bson;
import java.util.ArrayList;
import java.util.List;
public class CreateEmbeddings {
    public static void main(String[] args){
        String uri = System.getenv("ATLAS_CONNECTION_STRING");
        if (uri == null || uri.isEmpty()) {
            throw new RuntimeException("ATLAS_CONNECTION_STRING env variable is not set or is empty.");
        }
        // establish connection and set namespace
        try (MongoClient mongoClient = MongoClients.create(uri)) {
            MongoDatabase database = mongoClient.getDatabase("sample_airbnb");
            MongoCollection<Document> collection = database.getCollection("listingsAndReviews");
            Bson filterCriteria = Filters.and(
                    Filters.and(Filters.exists("summary"),
                            Filters.ne("summary", null),
                            Filters.ne("summary", "")),
                    Filters.exists("embeddings", false));
            try (MongoCursor<Document> cursor = collection.find(filterCriteria).limit(50).iterator()) {
                List<String> summaries = new ArrayList<>();
                List<String> documentIds = new ArrayList<>();
                int i = 0;
                while (cursor.hasNext()) {
                    Document document = cursor.next();
                    String summary = document.getString("summary");
                    String id = document.get("_id").toString();
                    summaries.add(summary);
                    documentIds.add(id);
                    i++;
                }
                System.out.println("Generating embeddings for " + summaries.size() + " documents.");
                System.out.println("This operation may take up to several minutes.");
                EmbeddingProvider embeddingProvider = new EmbeddingProvider();
                List<BsonArray> embeddings = embeddingProvider.getEmbeddings(summaries);
                List<WriteModel<Document>> updateDocuments = new ArrayList<>();
                for (int j = 0; j < summaries.size(); j++) {
                    UpdateOneModel<Document> updateDoc = new UpdateOneModel<>(
                            Filters.eq("_id", documentIds.get(j)),
                            Updates.set("embeddings", embeddings.get(j)));
                    updateDocuments.add(updateDoc);
                }
                int updatedDocsCount = 0;
                try {
                    BulkWriteOptions options = new BulkWriteOptions().ordered(false);
                    BulkWriteResult result = collection.bulkWrite(updateDocuments, options);
                    updatedDocsCount = result.getModifiedCount();
                } catch (MongoException me) {
                    throw new RuntimeException("Failed to insert documents", me);
                }
                System.out.println("Added embeddings successfully to " + updatedDocsCount + " documents.");
            }
        } catch (MongoException me) {
            throw new RuntimeException("Failed to connect to MongoDB", me);
        } catch (Exception e) {
            throw new RuntimeException("Operation failed: ", e);
        }
    }
}

Gere as incorporações.

Salve e execute o arquivo. A saída se assemelha a:

Generating embeddings for 50 documents.
This operation may take up to several minutes.
Added embeddings successfully to 50 documents.

Você também pode visualizar suas incorporações vetoriais na interface do Atlas navegando até a coleção sample_airbnb.listingsAndReviews no seu cluster.

Crie um arquivo chamado create-embeddings.js e cole o código a seguir.

Use o código a seguir para gerar incorporações a partir de uma coleção existente no Atlas.

Especificamente, este código usa a função getEmbedding que você definiu e o driver do MongoDB Node.js para gerar incorporações a partir de uma array de textos de amostra e ingeri-los na coleção sample_db.embeddings no Atlas.

import { MongoClient } from 'mongodb';
import { getEmbedding } from './get-embeddings.js';
// Data to embed
const data = [ 
    "Titanic: The story of the 1912 sinking of the largest luxury liner ever built",
    "The Lion King: Lion cub and future king Simba searches for his identity",
    "Avatar: A marine is dispatched to the moon Pandora on a unique mission"
]
async function run() {
    // Connect to your Atlas cluster
    const client = new MongoClient(process.env.ATLAS_CONNECTION_STRING);
    
    try {
        await client.connect();
        const db = client.db("sample_db");
        const collection = db.collection("embeddings");
        await Promise.all(data.map(async text => {
            // Check if the document already exists
            const existingDoc = await collection.findOne({ text: text });
            // Generate an embedding by using the function that you defined
            const embedding = await getEmbedding(text);
            // Ingest data and embedding into Atlas
            if (!existingDoc) {
                await collection.insertOne({
                    text: text,
                    embedding: embedding
                });
                console.log(embedding);
            }
        }));
    } catch (err) {
        console.log(err.stack);
    }
    finally {
        await client.close();
    }
}
run().catch(console.dir);

Salve e execute o arquivo.

node --env-file=.env create-embeddings.js

[ -0.04323853924870491, -0.008460805751383305, 0.012494648806750774, -0.013014335185289383, ... ]
[ -0.017400473356246948, 0.04922063276171684, -0.002836339408531785, -0.030395228415727615, ... ]
[ -0.016950927674770355, 0.013881809078156948, -0.022074559703469276, -0.02838018536567688, ... ]

node --env-file=.env create-embeddings.js

[ 0.031927742, -0.014192767, -0.021851597, 0.045498233, -0.0077904654, ... ]
[ -0.01664538, 0.013198251, 0.048684783, 0.014485021, -0.018121032, ... ]
[ 0.030449908, 0.046782598, 0.02126599, 0.025799986, -0.015830345, ... ]

Você também pode visualizar suas incorporações vetoriais na interface do Atlas navegando até a coleção sample_db.embeddings no seu cluster.

Crie um arquivo chamado create-embeddings.js e cole o código a seguir.

Use o código a seguir para gerar incorporações a partir de uma coleção existente no Atlas. Especificamente, esse código faz o seguinte:

• Conecta-se ao seu cluster do Atlas.

• Obtém um subconjunto de documentos da coleção sample_airbnb.listingsAndReviews que tem um campo summary não vazio.

• Gera incorporações do campo summary de cada documento usando a função getEmbedding que você definiu.

• Atualiza cada documento com um novo campo embedding que contém o valor de incorporação usando o driver Node.js do MongoDB.

import { MongoClient } from 'mongodb';
import { getEmbedding } from './get-embeddings.js';
// Connect to your Atlas cluster
const client = new MongoClient(process.env.ATLAS_CONNECTION_STRING);
async function run() {
    try {
        await client.connect();
        const db = client.db("sample_airbnb");
        const collection = db.collection("listingsAndReviews");
        // Filter to exclude null or empty summary fields
        const filter = { "summary": { "$nin": [ null, "" ] } };
        // Get a subset of documents from the collection
        const documents = await collection.find(filter).limit(50).toArray();
        // Create embeddings from a field in the collection
        let updatedDocCount = 0;
        console.log("Generating embeddings for documents...");
        await Promise.all(documents.map(async doc => {
           // Generate an embedding by using the function that you defined
           const embedding = await getEmbedding(doc.summary);
           // Update the document with a new embedding field
           await collection.updateOne({ "_id": doc._id },
               {
                   "$set": {
                       "embedding": embedding
                   }
               }
           );
           updatedDocCount += 1;
       }));
       console.log("Count of documents updated: " + updatedDocCount);
            
    } catch (err) {
        console.log(err.stack);
    }
    finally {
        await client.close();
    }
}
run().catch(console.dir);

Salve e execute o arquivo.

node --env-file=.env create-embeddings.js

Generating embeddings for documents...
Count of documents updated: 50

Você pode visualizar suas incorporações vetoriais conforme elas são geradas navegando até a sample_airbnb.listingsAndReviews coleção na interface do usuário do Atlas e expandindo os campos em um documento.

Cole o código a seguir no seu notebook.

Use o código a seguir para gerar incorporações a partir de novos dados.

Em especial, este código usa a função get_embedding que você definiu e o driver do MongoDB PyMongo para gerar incorporações a partir de uma array de textos de amostra e ingeri-los na coleção sample_db.embeddings.

import pymongo
# Connect to your Atlas cluster
mongo_client = pymongo.MongoClient("<connection-string>")
db = mongo_client["sample_db"]
collection = db["embeddings"]
# Sample data
data = [
   "Titanic: The story of the 1912 sinking of the largest luxury liner ever built",
   "The Lion King: Lion cub and future king Simba searches for his identity",
   "Avatar: A marine is dispatched to the moon Pandora on a unique mission"
]
# Ingest data into Atlas
inserted_doc_count = 0
for text in data:
   embedding = get_embedding(text)
   collection.insert_one({ "text": text, "embedding": embedding })
   inserted_doc_count += 1
print(f"Inserted {inserted_doc_count} documents.")

Inserted 3 documents.

Especifique a string de conexão.

Substitua <connection-string> pela string de conexão SRV do seu cluster do Atlas.

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

Execute o código.

Você pode verificar as incorporações vetoriais visualizando-os na IU do Atlas navegando até a coleção sample_db.embeddings em seu cluster.

Cole o código a seguir no seu notebook.

Use o código a seguir para gerar inserções de um campo em uma coleção existente. Especificamente, esse código faz o seguinte:

• Conecta-se ao seu cluster do Atlas.

• Obtém um subconjunto de documentos da coleção sample_airbnb.listingsAndReviews que tem um campo summary não vazio.

• Gera incorporações do campo summary de cada documento usando a função get_embedding que você definiu.

• Atualiza cada documento com um novo campo embedding que contém o valor de incorporação usando o MongoDB PyMongo Driver.

import pymongo
# Connect to your Atlas cluster
mongo_client = pymongo.MongoClient("<connection-string>")
db = mongo_client["sample_airbnb"]
collection = db["listingsAndReviews"]
# Filter to exclude null or empty summary fields
filter = { "summary": {"$nin": [ None, "" ]} }
# Get a subset of documents in the collection
documents = collection.find(filter).limit(50)
# Update each document with a new embedding field
updated_doc_count = 0
for doc in documents:
    embedding = get_embedding(doc["summary"])
    collection.update_one( { "_id": doc["_id"] }, { "$set": { "embedding": embedding } } )
    updated_doc_count += 1
print(f"Updated {updated_doc_count} documents.")

Updated 50 documents.

Especifique a string de conexão.

Substitua <connection-string> pela string de conexão SRV do seu cluster do Atlas.

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

Execute o código.

Você pode visualizar suas incorporações vetoriais conforme elas são geradas navegando até a sample_airbnb.listingsAndReviews coleção na interface do usuário do Atlas e expandindo os campos em um documento.