Crie uma implementação de RAG local com o Atlas Vector Search

Inicialize seu projeto .NET.

Execute os seguintes comandos em seu terminal para criar um novo diretório chamado MyCompany.RAG.Local e inicializar seu projeto:

dotnet new console -o MyCompany.RAG.Local
cd MyCompany.RAG.Local

Instalar e importar dependências.

dotnet add package MongoDB.Driver --version 3.1.0
dotnet add package Microsoft.Extensions.AI.Ollama --prerelease

dotnet add package MongoDB.Driver --version 3.1.0
dotnet add package Microsoft.Extensions.Configuration
dotnet add package Microsoft.Extensions.Configuration.Json
dotnet add package Microsoft.Extensions.AI --prerelease
dotnet add package Microsoft.Extensions.AI.Ollama --prerelease

Defina sua string de conexão como uma variável de ambiente.

Exporte sua string de conexão, set no PowerShell, ou use o gerenciador de variáveis de ambiente do seu IDE para tornar a string de conexão disponível para o seu projeto.

export ATLAS_CONNECTION_STRING="<connection-string>"

Substitua o valor do placeholder <connection-string> pela sua string de conexão do Atlas.

export ATLAS_CONNECTION_STRING="mongodb://localhost:<port-number>/?directConnection=true"

export ATLAS_CONNECTION_STRING="<connection-string>"

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

Inicialize seu projeto Go.

Execute os seguintes comandos em seu terminal para criar um novo diretório chamado local-rag-mongodb e inicializar seu projeto:

mkdir local-rag-mongodb
cd local-rag-mongodb
go mod init local-rag-mongodb

Instalar e importar dependências.

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
go get github.com/tmc/langchaingo/llms/ollama
go get github.com/tmc/langchaingo/prompts

Crie um arquivo .env.

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

ATLAS_CONNECTION_STRING = "<connection-string>"

Substitua o valor do placeholder <connection-string> pela sua string de conexão do Atlas.

ATLAS_CONNECTION_STRING = "mongodb://localhost:<port-number>/?directConnection=true"

ATLAS_CONNECTION_STRING = "<connection-string>"

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

Crie seu projeto Java e instale dependências.

1. A partir do seu IDE, crie um projeto Java denominado local-rag-mongodb 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 Ollama -->
      <dependency>
         <groupId>dev.langchain4j</groupId>
         <artifactId>langchain4j-ollama</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 Ollama
      implementation 'dev.langchain4j:langchain4j-ollama:0.35.0'
   }

3. Execute seu gerenciador de pacote para instalar as dependências em seu projeto.

Defina sua variável 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.

ATLAS_CONNECTION_STRING = "mongodb://localhost:<port-number>/?directConnection=true"

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

Inicialize seu projeto Node.js.

Execute os seguintes comandos em seu terminal para criar um novo diretório chamado local-rag-mongodb e inicializar seu projeto:

mkdir local-rag-mongodb
cd local-rag-mongodb
npm init -y

Instalar e importar dependências.

Execute o seguinte comando:

npm install mongodb @xenova/transformers node-gyp gpt4all

Atualize seu arquivo package.json.

No arquivo package.json do seu projeto, especifique o campo type como mostrado no exemplo a seguir e salve o arquivo.

{
   "name": "local-rag-mongodb",
   "type": "module",
   ...
}

Crie um arquivo .env.

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

ATLAS_CONNECTION_STRING = "<connection-string>"

Substitua o valor do placeholder <connection-string> pela sua string de conexão do Atlas.

ATLAS_CONNECTION_STRING = "mongodb://localhost:<port-number>/?directConnection=true";

ATLAS_CONNECTION_STRING = "<connection-string>";

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

Crie um diretório para armazenar seu projeto.

Execute os seguintes comandos em seu terminal para criar um novo diretório chamado local-rag-mongodb.

mkdir local-rag-mongodb
cd local-rag-mongodb

Crie um notebook interativo do Python.

No diretório local-rag-mongodb, salve um arquivo com a extensão .ipynb. Você executará os trechos de código restantes para este tutorial em seu notebook. Você deve criar um novo bloco de código para cada snippet.

Instalar e importar dependências.

Execute o seguinte comando no seu notebook:

pip install --quiet --upgrade pymongo gpt4all sentence_transformers

Defina sua string de conexão do Atlas.

ATLAS_CONNECTION_STRING = ("mongodb://localhost:<port-number>/?directConnection=true")

ATLAS_CONNECTION_STRING = ("<connection-string>")

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

Baixe o modelo de incorporação local.

Este exemplo usa o modelo nomic-embed-text do Ollama.

Execute o seguinte comando para extrair o modelo de incorporação:

ollama pull nomic-embed-text

Gerar incorporações.

Para encapsular a lógica de cada parte da implementação, crie algumas classes para coordenar e gerenciar os serviços.

1. Crie um arquivo chamado OllamaAIService.cs, e cole o seguinte código nele:

   OllamaAIService.cs

   namespace MyCompany.RAG.Local;
   using Microsoft.Extensions.AI;
   public class OllamaAIService
   {
       private static readonly Uri OllamaUri = new("http://localhost:11434/");
       private static readonly string EmbeddingModelName = "nomic-embed-text";
       private static readonly OllamaEmbeddingGenerator EmbeddingGenerator = new OllamaEmbeddingGenerator(OllamaUri, EmbeddingModelName);
       public async Task<float[]> GetEmbedding(string text)
       {
           var embedding = await EmbeddingGenerator.GenerateEmbeddingVectorAsync(text);
           return embedding.ToArray();
       }
   }

2. Crie outro arquivo denominado MongoDBDataService.cs e cole o seguinte código nele:

   MongoDBDataService.cs

   1
   namespace MyCompany.RAG.Local;
   2
   3
   using MongoDB.Driver;
   4
   using MongoDB.Bson;
   5
   6
   public class MongoDBDataService
   7
   {
   8
       private static readonly string? ConnectionString = Environment.GetEnvironmentVariable("ATLAS_CONNECTION_STRING");
   9
       private static readonly MongoClient Client = new MongoClient(ConnectionString);
   10
       private static readonly IMongoDatabase Database = Client.GetDatabase("sample_airbnb");
   11
       private static readonly IMongoCollection<BsonDocument> Collection = Database.GetCollection<BsonDocument>("listingsAndReviews");
   12
       
   13
       public List<BsonDocument>? GetDocuments()
   14
       {
   15
           var filter = Builders<BsonDocument>.Filter.And(
   16
               Builders<BsonDocument>.Filter.And(
   17
                   Builders<BsonDocument>.Filter.Exists("summary", true),
   18
                   Builders<BsonDocument>.Filter.Ne("summary", "")
   19
               ),
   20
               Builders<BsonDocument>.Filter.Exists("embeddings", false)
   21
           );
   22
           return Collection.Find(filter).Limit(250).ToList(); 
   23
       }
   24
   25
       public async Task<string> UpdateDocuments(Dictionary<string, float[]> embeddings)
   26
       {
   27
           var listWrites = new List<WriteModel<BsonDocument>>();
   28
           foreach(var kvp in embeddings)
   29
           {
   30
               var filterForUpdate = Builders<BsonDocument>.Filter.Eq("_id", kvp.Key);
   31
               var updateDefinition = Builders<BsonDocument>.Update.Set("embeddings", kvp.Value);
   32
               listWrites.Add(new UpdateOneModel<BsonDocument>(filterForUpdate, updateDefinition));
   33
           }
   34
   35
           try
   36
           {
   37
               var result = await Collection.BulkWriteAsync(listWrites);
   38
               listWrites.Clear();
   39
               return $"{result.ModifiedCount} documents updated successfully.";
   40
           } catch (Exception e)
   41
           {
   42
               return $"Exception: {e.Message}";
   43
           }
   44
       }
   45
   }

   A geração de incorporações consome tempo e recursos computacionais. Neste exemplo, você gera embeddings para apenas 250 documentos da coleção, o que deve levar menos de alguns minutos. Se você quiser alterar o número de documentos para os quais está gerando incorporações:

   • Altere o número de documentos: ajuste o número .Limit(250) na chamada Find() na linha 21.

   • Gere embeddings para todos os documentos: omita o .Limit(250) completamente na chamada Find() na linha 21.

3. Crie outro arquivo denominado EmbeddingGenerator.cs e cole o seguinte código nele:

   EmbeddingGenerator.cs

   1
   namespace MyCompany.RAG.Local;
   2
   3
   public class EmbeddingGenerator
   4
   {
   5
       private readonly MongoDBDataService _dataService = new();
   6
       private readonly OllamaAIService _ollamaAiService = new();
   7
   8
       public async Task<string> GenerateEmbeddings()
   9
       {
   10
           // Retrieve documents from MongoDB
   11
           var documents = _dataService.GetDocuments();
   12
           if (documents != null)
   13
           {
   14
               Console.WriteLine("Generating embeddings.");
   15
               Dictionary<string, float[]> embeddings = new Dictionary<string, float[]>();
   16
               foreach (var document in documents)
   17
               {
   18
                   try
   19
                   {
   20
                       var id = document.GetValue("_id").ToString();
   21
                       var summary = document.GetValue("summary").ToString();
   22
                       if (id != null && summary != null)
   23
                       {
   24
                           // Use Ollama to generate vector embeddings for each
   25
                           // document's "summary" field
   26
                           var embedding = await _ollamaAiService.GetEmbedding(summary);
   27
                           embeddings.Add(id, embedding);
   28
                       }
   29
                   }
   30
                   catch (Exception e)
   31
                   {
   32
                       return $"Error creating embeddings for summaries: {e.Message}";
   33
                   }
   34
               }
   35
               // Add a new field to the MongoDB documents with the vector embedding
   36
               var result = await _dataService.UpdateDocuments(embeddings);
   37
               return result;
   38
           }
   39
           else
   40
           {
   41
               return "No documents found";
   42
           }
   43
       }
   44
   }

   Este código contém a lógica para:

   • Obtenha documentos do banco de dados.

   • Use o modelo de incorporação para gerar incorporações vetoriais para o campo summary de cada documento.

   • Atualize os documentos com as novas embeddings.

4. Cole o seguinte código em Program.cs:

   Program.cs

   1
   using MyCompany.RAG.Local;
   2
   3
   var embeddingGenerator = new EmbeddingGenerator();
   4
   var result = await embeddingGenerator.GenerateEmbeddings();
   5
   Console.WriteLine(result);

5. Compile e execute seu projeto para gerar embeddings:

   dotnet run MyCompany.RAG.Local.csproj

   OCULTAR SAÍDA

   Generating embeddings.
   250 documents updated successfully.

Baixe o modelo de incorporação local.

Este exemplo usa o modelo nomic-embed-text do Ollama.

Execute o seguinte comando para extrair o modelo de incorporação:

ollama pull nomic-embed-text

Gerar incorporações.

1. Crie um diretório common para armazenar o código que você reutilizará em várias etapas.

   mkdir common && cd common

2. Crie um arquivo chamado get-embeddings.go, e cole o seguinte código nele:

   get-embeddings.go

   package common
   import (
   	"context"
   	"log"
   	"github.com/tmc/langchaingo/llms/ollama"
   )
   func GetEmbeddings(documents []string) [][]float32 {
   	llm, err := ollama.New(ollama.WithModel("nomic-embed-text"))
   	if err != nil {
   		log.Fatalf("failed to connect to ollama: %v", err)
   	}
   	ctx := context.Background()
   	embs, err := llm.CreateEmbedding(ctx, documents)
   	if err != nil {
   		log.Fatalf("failed to create ollama embedding: %v", err)
   	}
   	return embs
   }

3. Para simplificar a ordenação e desordenação de documentos nesta coleção de e para o BSON, crie um arquivo chamado models.go e cole o seguinte código nele:

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

4. Retorne ao diretório raiz.

   cd ../

5. Crie outro arquivo denominado generate-embeddings.go e cole o seguinte código nele:

   generate-embeddings.go

   1
   package main
   2
   3
   import (
   4
   	"context"
   5
   	"local-rag-mongodb/common" // Module that contains the models and GetEmbeddings function
   6
   	"log"
   7
   	"os"
   8
   9
   	"github.com/joho/godotenv"
   10
   	"go.mongodb.org/mongo-driver/bson"
   11
   	"go.mongodb.org/mongo-driver/mongo"
   12
   	"go.mongodb.org/mongo-driver/mongo/options"
   13
   )
   14
   15
   func main() {
   16
   	ctx := context.Background()
   17
   18
   	if err := godotenv.Load(); err != nil {
   19
   		log.Println("no .env file found")
   20
   	}
   21
   22
   	// Connect to your Atlas cluster
   23
   	uri := os.Getenv("ATLAS_CONNECTION_STRING")
   24
   	if uri == "" {
   25
   		log.Fatal("set your 'ATLAS_CONNECTION_STRING' environment variable.")
   26
   	}
   27
   	clientOptions := options.Client().ApplyURI(uri)
   28
   	client, err := mongo.Connect(ctx, clientOptions)
   29
   	if err != nil {
   30
   		log.Fatalf("failed to connect to the server: %v", err)
   31
   	}
   32
   	defer func() { _ = client.Disconnect(ctx) }()
   33
   34
   	// Set the namespace
   35
   	coll := client.Database("sample_airbnb").Collection("listingsAndReviews")
   36
   37
   	filter := bson.D{
   38
   		{"$and",
   39
   			bson.A{
   40
   				bson.D{
   41
   					{"$and",
   42
   						bson.A{
   43
   							bson.D{{"summary", bson.D{{"$exists", true}}}},
   44
   							bson.D{{"summary", bson.D{{"$ne", ""}}}},
   45
   						},
   46
   					}},
   47
   				bson.D{{"embeddings", bson.D{{"$exists", false}}}},
   48
   			}},
   49
   	}
   50
   51
   	findOptions := options.Find().SetLimit(250)
   52
   53
   	cursor, err := coll.Find(ctx, filter, findOptions)
   54
   	if err != nil {
   55
   		log.Fatalf("failed to retrieve data from the server: %v", err)
   56
   	}
   57
   58
   	var listings []common.Listing
   59
   	if err = cursor.All(ctx, &listings); err != nil {
   60
   		log.Fatalf("failed to unmarshal retrieved docs to model objects: %v", err)
   61
   	}
   62
   63
   	var summaries []string
   64
   	for _, listing := range listings {
   65
   		summaries = append(summaries, listing.Summary)
   66
   	}
   67
   68
   	log.Println("Generating embeddings.")
   69
   	embeddings := common.GetEmbeddings(summaries)
   70
   71
   	updateDocuments := make([]mongo.WriteModel, len(listings))
   72
   	for i := range updateDocuments {
   73
   		updateDocuments[i] = mongo.NewUpdateOneModel().
   74
   			SetFilter(bson.D{{"_id", listings[i].ID}}).
   75
   			SetUpdate(bson.D{{"$set", bson.D{{"embeddings", embeddings[i]}}}})
   76
   	}
   77
   78
   	bulkWriteOptions := options.BulkWrite().SetOrdered(false)
   79
   80
   	result, err := coll.BulkWrite(ctx, updateDocuments, bulkWriteOptions)
   81
   	if err != nil {
   82
   		log.Fatalf("failed to update documents: %v", err)
   83
   	}
   84
   85
   	log.Printf("%d documents updated successfully.", result.MatchedCount)
   86
   }

   Neste exemplo, definimos um limite de 250 documentos ao gerar incorporações. O processo para gerar incorporações para mais de 5000 documentos na coleção é lento. Se você quiser alterar o número de documentos para os quais está gerando incorporações:

   • Altere o número de documentos: ajuste o número .SetLimit(250) nas Find() opções na linha 52.

   • Gere incorporações para todos os documentos: omita as opções na chamada Find() na linha 54.

6. Execute o seguinte comando para executar o código:

   go run generate-embeddings.go

   OCULTAR SAÍDA

   2024/10/10 15:49:23 Generating embeddings.
   2024/10/10 15:49:28 250 documents updated successfully.

Baixe o modelo de incorporação local.

Execute o seguinte comando para extrair o modelo nomic-embed-text do Ollama:

ollama pull nomic-embed-text

Defina seu modelo e método para gerar incorporações vetoriais.

Crie um arquivo chamado OllamaModels.java e cole o seguinte código.

Este código define os modelos locais de incorporação e bate-papo do Ollama que você usará em seu projeto. Trabalharemos com o modelo de chat em uma etapa posterior. Você pode adaptar ou criar modelos adicionais conforme necessário para a configuração de sua preferência.

Este código também define dois métodos para gerar incorporações para uma determinada entrada usando o modelo de incorporação que você baixou anteriormente:

• 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.ollama.OllamaChatModel;
import dev.langchain4j.model.ollama.OllamaEmbeddingModel;
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 OllamaModels {
    private static final String host = "http://localhost:11434";
    private static OllamaEmbeddingModel embeddingModel;
    private static OllamaChatModel chatModel;
    /**
     * Returns the Ollama embedding model used by the getEmbeddings() and getEmbedding() methods
     * to generate vector embeddings.
     */
    public static OllamaEmbeddingModel getEmbeddingModel() {
        if (embeddingModel == null) {
            embeddingModel = OllamaEmbeddingModel.builder()
                    .timeout(ofSeconds(10))
                    .modelName("nomic-embed-text")
                    .baseUrl(host)
                    .build();
        }
        return embeddingModel;
    }
    /**
     * Returns the Ollama chat model interface used by the createPrompt() method
     * to process queries and generate responses.
     */
    public static OllamaChatModel getChatModel() {
        if (chatModel == null) {
            chatModel = OllamaChatModel.builder()
                    .timeout(ofSeconds(25))
                    .modelName("mistral")
                    .baseUrl(host)
                    .build();
        }
        return chatModel;
    }
    /**
     * Takes an array of strings and returns a collection of BSON array embeddings
     * to store in the database.
     */
    public static 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 static BsonArray getEmbedding(String text) {
        Response<Embedding> response = getEmbeddingModel().embed(text);
        return new BsonArray(
                response.content().vectorAsList().stream()
                        .map(BsonDouble::new)
                        .toList());
    }
}

Defina o código para gerar incorporações a partir dos dados de amostra.

Crie um arquivo denominado EmbeddingGenerator.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 à sua implantação local do Atlas ou ao cluster Atlas .

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

   Observação

   Para fins de demonstração, definimos um limit de 250 documentos para reduzir o tempo de processamento. Você pode ajustar ou remover esse limite conforme necessário para melhor se adequar ao seu caso de uso.

3. Gere uma incorporação do campo summary de cada documento usando o método getEmbeddings definido anteriormente.

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

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.Projections;
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 EmbeddingGenerator {
    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");
            // define parameters for the find() operation
            // NOTE: this example uses a limit to reduce processing time
            Bson projectionFields = Projections.fields(
                    Projections.include("_id", "summary"));
            Bson filterSummary = Filters.ne("summary", "");
            int limit = 250;
            try (MongoCursor<Document> cursor = collection
                    .find(filterSummary)
                    .projection(projectionFields)
                    .limit(limit)
                    .iterator()) {
                List<String> summaries = new ArrayList<>();
                List<String> documentIds = new ArrayList<>();
                while (cursor.hasNext()) {
                    Document document = cursor.next();
                    String summary = document.getString("summary");
                    String id = document.get("_id").toString();
                    summaries.add(summary);
                    documentIds.add(id);
                }
                // generate embeddings for the summary in each document
                // and add to the document to the 'embeddings' array field
                System.out.println("Generating embeddings for " + summaries.size() + " documents.");
                System.out.println("This operation may take up to several minutes.");
                List<BsonArray> embeddings = OllamaModels.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);
                }
                // bulk write the updated documents to the 'listingsAndReviews' collection
                int result = performBulkWrite(updateDocuments, collection);
                System.out.println("Added embeddings successfully to " + result + " documents.");
            }
        } catch (MongoException me) {
            throw new RuntimeException("Failed to connect to MongoDB", me);
        } catch (Exception e) {
            throw new RuntimeException("Operation failed: ", e);
        }
    }
    /**
     * Performs a bulk write operation on the specified collection.
     */
    private static int performBulkWrite(List<WriteModel<Document>> updateDocuments, MongoCollection<Document> collection) {
        if (updateDocuments.isEmpty()) {
            return 0;
        }
        BulkWriteResult result;
        try {
            BulkWriteOptions options = new BulkWriteOptions().ordered(false);
            result = collection.bulkWrite(updateDocuments, options);
            return result.getModifiedCount();
        } catch (MongoException me) {
            throw new RuntimeException("Failed to insert documents", me);
        }
    }
}

Gerar incorporações.

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

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

Baixe o modelo de incorporação local.

Este exemplo usa o managed-ai/mxvai-embed-large-v1 modelo a partir do hub de modelos do Hugging Face. O método mais simples de baixar os arquivos de modelo é clonar o repositório usando o Git com o Git Large File Storage. O Hugging Face requer um token de acesso do usuário ou Git sobre SSH para autenticar sua solicitação para clonar o repositório.

git clone https://<your-hugging-face-username>:<your-hugging-face-user-access-token>@huggingface.co/mixedbread-ai/mxbai-embed-large-v1

git clone git@hf.co:mixedbread-ai/mxbai-embed-large-v1

Obtenha o caminho local para os arquivos do modelo.

Obtenha o caminho para os arquivos do modelo local na sua máquina. Esse é o diretório principal que contém o repositório git que você acabou de clonar. Se você clonou o repositório modelo dentro do diretório do projeto que criou para este tutorial, o caminho do diretório principal deve ser semelhante a:

/Users/<username>/local-rag-mongodb

Verifique o diretório do modelo e certifique-se de que contenha um diretório onnx que tenha um arquivo model_quantized.onnx:

cd mxbai-embed-large-v1/onnx
ls

model.onnx      model_fp16.onnx     model_quantized.onnx

Gerar incorporações.

1. Navegue de volta para o diretório principal local-rag-mongodb.

2. Crie um arquivo chamado get-embeddings.js, e cole o seguinte código nele:

   get-embeddings.js

   import { env, pipeline } from '@xenova/transformers';
   // Function to generate embeddings for given data
   export async function getEmbedding(data) {
       // Replace this path with the parent directory that contains the model files
       env.localModelPath = '/Users/<username>/local-rag-mongodb/';
       env.allowRemoteModels = false;
       const task = 'feature-extraction';
       const model = 'mxbai-embed-large-v1';
       const embedder = await pipeline(
           task, model);
       const results = await embedder(data, { pooling: 'mean', normalize: true });
       return Array.from(results.data);
   }

   Substitua o '/Users/<username>/local-rag-mongodb/' pelo caminho local da etapa anterior.

3. Crie outro arquivo denominado generate-embeddings.js e cole o seguinte código nele:

   generate-embeddings.js

   1
   import { MongoClient } from 'mongodb';
   2
   import { getEmbedding } from './get-embeddings.js';
   3
   4
   async function run() {
   5
   6
       // Connect to your Atlas cluster
   7
       const client = new MongoClient(process.env.ATLAS_CONNECTION_STRING);
   8
   9
       try {
   10
           // Connect to your local MongoDB deployment
   11
           await client.connect();
   12
           const db = client.db("sample_airbnb");
   13
           const collection = db.collection("listingsAndReviews");
   14
   15
           const filter = { '$and': [
   16
               { 'summary': { '$exists': true, '$ne': null } }, 
   17
               { 'embeddings': { '$exists': false } }
   18
           ]};
   19
   20
           // This is a long-running operation for all docs in the collection,
   21
           // so we limit the docs for this example
   22
           const cursor = collection.find(filter).limit(50);
   23
   24
           // To verify that you have the local embedding model configured properly,
   25
           // try generating an embedding for one document
   26
           const firstDoc = await cursor.next();
   27
           if (!firstDoc) {
   28
               console.log('No document found.');
   29
               return;
   30
           }
   31
   32
           const firstDocEmbeddings = await getEmbedding(firstDoc.summary);
   33
           console.log(firstDocEmbeddings);
   34
   35
           // After confirming that you are successfully generating embeddings,
   36
           // uncomment the following code to generate embeddings for all docs: 
   37
           /* 
   38
           cursor.rewind(); // Reset the cursor to process documents again
   39
           console.log("Generating embeddings and updating documents...");
   40
   41
           // Create embeddings from a field in the collection
   42
           const updateDocuments = [];
   43
           for await (const doc of cursor) {
   44
   45
               const embedding = await getEmbedding(doc.summary);
   46
   47
               updateDocuments.push(
   48
                   { 
   49
                       updateOne: {
   50
                           filter: { "_id": doc._id },
   51
                           update: { $set: { "embedding": embedding } }
   52
                       }
   53
                   }
   54
               )
   55
           }
   56
   57
           // Continue processing documents if an error occurs during an operation
   58
           const options = { ordered: false };
   59
   60
           // Update documents with the new embedding field
   61
           const result = await collection.bulkWrite(updateDocuments, options)
   62
           console.log("Count of documents updated: " + result.modifiedCount);
   63
           */
   64
   65
       } catch (err) {
   66
           console.log(err.stack);
   67
       }
   68
       finally {
   69
           await client.close();
   70
       }
   71
   }
   72
   run().catch(console.dir);

   Esse código inclui algumas linhas para testar se você baixou corretamente o modelo e está usando o caminho correto. Execute o seguinte comando para executar o código:

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

   VISUALIZAR SAÍDA

   Tensor {
      dims: [ 1, 1024 ],
      type: 'float32',
      data: Float32Array(1024) [
         -0.01897735893726349,  -0.001120976754464209,  -0.021224822849035263,
         -0.023649735376238823,   -0.03350808471441269, -0.0014186901971697807,
         -0.009617107920348644,    0.03344292938709259,    0.05424851179122925,
         -0.025904450565576553,   0.029770011082291603, -0.0006215018220245838,
         0.011056603863835335,  -0.018984895199537277,    0.03985185548663139,
         -0.015273082070052624,   -0.03193040192127228,   0.018376577645540237,
         -0.02236943319439888,    0.01433168537914753,    0.02085157483816147,
         -0.005689046811312437,   -0.05541415512561798,  -0.055907104164361954,
         -0.019112611189484596,    0.02196515165269375,   0.027313007041811943,
         -0.008618313819169998,   0.045496534556150436,    0.06271681934595108,
         -0.0028660669922828674,   -0.02433634363114834,    0.02016191929578781,
         -0.013882477767765522,  -0.025465600192546844,  0.0000950733374338597,
         0.018200192600488663,  -0.010413561016321182,  -0.002004098379984498,
         -0.058351870626211166,    0.01749623566865921,  -0.013926318846642971,
         -0.00278360559605062,  -0.010333008132874966,   0.004406726453453302,
         0.04118744656443596,    0.02210155501961708,  -0.016340743750333786,
         0.004163357429206371,  -0.018561601638793945,  0.0021984230261296034,
         -0.012378614395856857,   0.026662321761250496,  -0.006476820446550846,
         0.001278138137422502,  -0.010084952227771282,  -0.055993322283029556,
         -0.015850437805056572,   0.015145729295909405,    0.07512971013784409,
         -0.004111358895897865,  -0.028162647038698196,   0.023396577686071396,
         -0.01159974467009306,   0.021751703694462776,   0.006198467221111059,
         0.014084039255976677, -0.0003913900291081518,   0.006310020107775927,
         -0.04500332102179527,   0.017774192616343498,  -0.018170733004808426,
         0.026185045018792152,   -0.04488714039325714,  -0.048510149121284485,
         0.015152698382735252,   0.012136898003518581,     0.0405895821750164,
         -0.024783289059996605,   -0.05514788627624512,    0.03484730422496796,
         -0.013530988246202469,     0.0319477915763855,    0.04537525027990341,
         -0.04497901350259781,   0.009621822275221348,  -0.013845544308423996,
         0.0046155862510204315,    0.03047163411974907,  0.0058857654221355915,
         0.005858785007148981,    0.01180865429341793,    0.02734190598130226,
         0.012322399765253067,    0.03992653638124466,   0.015777742490172386,
         0.017797520384192467,    0.02265017107129097,  -0.018233606591820717,
         0.02064627595245838,
         ... 924 more items
      ],
      size: 1024
      }

4. Opcionalmente, depois de confirmar que está gerando incorporações com sucesso com o modelo local, você pode descomentar o código nas linhas 35-52 para gerar incorporações para todos os documentos na coleção. Salve o arquivo.

   Em seguida, execute o comando para executar o código:

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

   VISUALIZAR SAÍDA

   [
     Tensor {
       dims: [ 1024 ],
       type: 'float32',
       data: Float32Array(1024) [
           -0.043243519961833954,    0.01316747535020113,  -0.011639945209026337,
           -0.025046885013580322,   0.005129443947225809,   -0.02003324404358864,
            0.005245734006166458,    0.10105721652507782,    0.05425914749503136,
           -0.010824322700500488,   0.021903572604060173,   0.048009492456912994,
             0.01291663944721222,  -0.015903260558843613,  -0.008034848608076572,
           -0.003592714900150895,  -0.029337648302316666,    0.02282896265387535,
           -0.029112281277775764,   0.011099508963525295,  -0.012238143011927605,
           -0.008351574651896954,  -0.048714976757764816,   0.001015961286611855,
             0.02252192236483097,    0.04426417499780655,    0.03514830768108368,
            -0.02088250033557415,    0.06391220539808273,    0.06896235048770905,
           -0.015386332757771015,  -0.019206153228878975,   0.015263230539858341,
         -0.00019019744649995118,  -0.032121095806360245,   0.015855342149734497,
             0.05055809020996094,   0.004083932377398014,   0.026945054531097412,
             -0.0505746565759182,  -0.009507855400443077,  -0.012497996911406517,
             0.06249537691473961,   -0.04026378318667412,   0.010749109089374542,
            0.016748877242207527,    -0.0235306303948164,   -0.03941794112324715,
            0.027474915608763695,   -0.02181144617497921,  0.0026422827504575253,
            0.005104491952806711,   0.027314607053995132,   0.019283341243863106,
            0.005245842970907688,  -0.018712762743234634,   -0.08618085831403732,
            0.003314188914373517,   0.008071620017290115,    0.05356570705771446,
           -0.008000597357749939,   0.006983411032706499, -0.0070550404489040375,
           -0.043323490768671036,    0.03490140289068222,    0.03810165822505951,
              0.0406375490128994, -0.0032191979698836803,    0.01489361934363842,
            -0.01609957590699196,  -0.006372962612658739,    0.03360277786850929,
           -0.014810526743531227,   -0.00925799086689949,   -0.01885424554347992,
              0.0182492695748806,   0.009002899751067162,  -0.004713123198598623,
            -0.00846288911998272,  -0.012471121735870838,    -0.0080558517947793,
              0.0135461101308465,    0.03335557505488396, -0.0027410900220274925,
            -0.02145615592598915,    0.01378028653562069,    0.03708091005682945,
             0.03519297018647194,   0.014239554293453693,    0.02219904027879238,
           0.0015641176141798496,    0.02624501660466194,   0.022713981568813324,
           -0.004414170514792204,   0.026919621974229813,  -0.002607459668070078,
            -0.04017219692468643,  -0.003570320550352335,  -0.022905709221959114,
            0.030657364055514336,
         ... 924 more items
       ],
       size: 1024
     }
   ]
   Generating embeddings and updating documents...
   Count of documents updated: 50

Cole o código a seguir no seu notebook.

Este código executa as seguintes ações:

• Conecta-se à sua implantação local do Atlas ou ao cluster Atlas e seleciona a coleção sample_airbnb.listingsAndReviews.

• Carrega o modelo mixedbread-ai/mxbai-embed-large-v1 do hub de modelos Hugging Face e o salva localmente. Para saber mais, consulte Baixando modelos.

• Define uma função que usa o modelo para gerar incorporações vetoriais.

• Para um subconjunto de documentos na coleção:

  • Gera uma incorporação a partir do campo summary do documento.

  • Atualiza o documento criando um novo campo chamado embeddings que contém a incorporação.

  from pymongo import MongoClient
  from sentence_transformers import SentenceTransformer
  # Connect to your local Atlas deployment or Atlas Cluster
  client = MongoClient(ATLAS_CONNECTION_STRING)
  # Select the sample_airbnb.listingsAndReviews collection
  collection = client["sample_airbnb"]["listingsAndReviews"]
  # Load the embedding model (https://huggingface.co/sentence-transformers/mixedbread-ai/mxbai-embed-large-v1)
  model_path = "<model-path>"
  model = SentenceTransformer('mixedbread-ai/mxbai-embed-large-v1')
  model.save(model_path)
  model = SentenceTransformer(model_path)
  # Define function to generate embeddings
  def get_embedding(text):
      return model.encode(text).tolist()
  # Filters for only documents with a summary field and without an embeddings field
  filter = { '$and': [ { 'summary': { '$exists': True, '$ne': None } }, { 'embeddings': { '$exists': False } } ] }
  # Creates embeddings for subset of the collection
  updated_doc_count = 0
  for document in collection.find(filter).limit(50):
      text = document['summary']
      embedding = get_embedding(text)
      collection.update_one({ '_id': document['_id'] }, { "$set": { 'embeddings': embedding } }, upsert=True)
      updated_doc_count += 1
  print("Documents updated: {}".format(updated_doc_count))

  OCULTAR SAÍDA

  Documents updated: 50

Substitua <model-path> pelo caminho para o diretório do seu projeto.

Esse caminho deve ser semelhante a: /Users/<username>/local-rag-mongodb

Execute o código.

Consulte o banco de dados para obter documentos relevantes.

1. Adicione um novo método PerformVectorQuery() no arquivo chamado MongoDBDataService.cs:

   MongoDBDataService.cs

   namespace MyCompany.RAG.Local;
   using MongoDB.Driver;
   using MongoDB.Bson;
   public class MongoDBDataService
   {
       private static readonly string? ConnectionString = Environment.GetEnvironmentVariable("ATLAS_CONNECTION_STRING");
       private static readonly MongoClient Client = new MongoClient(ConnectionString);
       private static readonly IMongoDatabase Database = Client.GetDatabase("sample_airbnb");
       private static readonly IMongoCollection<BsonDocument> Collection = Database.GetCollection<BsonDocument>("listingsAndReviews");
       
       public List<BsonDocument>? GetDocuments()
       {
           // Method details...
       }
       public async Task<string> UpdateDocuments(Dictionary<string, float[]> embeddings)
       {
           // Method details...
       }
       public string CreateVectorIndex()
       {
           // Method details...
       }
       public List<BsonDocument>? PerformVectorQuery(float[] vector)
       {
           var vectorSearchStage = new BsonDocument
           {
               {
                   "$vectorSearch",
                   new BsonDocument
                   {
                       { "index", "vector_index" },
                       { "path", "embeddings" },
                       { "queryVector", new BsonArray(vector) },
                       { "exact", true },
                       { "limit", 5 }
                   }
               }
           };
           var projectStage = new BsonDocument
           {
               {
                   "$project",
                   new BsonDocument
                   {
                       { "_id", 0 },
                       { "summary", 1 },
                       { "listing_url", 1 },
                       { "score", 
                           new BsonDocument
                           {
                               { "$meta", "vectorSearchScore"}
                           }
                       }
                   }
               }
           };
           var pipeline = new[] { vectorSearchStage, projectStage };
           return Collection.Aggregate<BsonDocument>(pipeline).ToList();
       }
   }

   Este código executa uma consulta vetorial na implantação local do Atlas ou no cluster do Atlas .

2. Crie outro arquivo denominado PerformTestQuery.cs e cole o seguinte código nele:

   PerformTestQuery.cs

   1
   namespace MyCompany.RAG.Local;
   2
   3
   public class PerformTestQuery
   4
   {
   5
       private readonly MongoDBDataService _dataService = new();
   6
       private readonly OllamaAIService _ollamaAiService = new();
   7
   8
       public async Task<string> GetQueryResults(string question)
   9
       {
   10
           // Get the vector embedding for the query
   11
           var query = question;
   12
           var queryEmbedding = await _ollamaAiService.GetEmbedding(query);
   13
           // Query the vector database for applicable query results
   14
           var matchingDocuments = _dataService.PerformVectorQuery(queryEmbedding);
   15
           // Construct a string from the query results for performing QA with the LLM
   16
           var sb = new System.Text.StringBuilder();
   17
           if (matchingDocuments != null)
   18
           {
   19
               foreach (var doc in matchingDocuments)
   20
               {
   21
                   sb.AppendLine($"Summary: {doc.GetValue("summary").ToString()}");
   22
                   sb.AppendLine($"Listing URL: {doc.GetValue("listing_url").ToString()}");
   23
               }
   24
           }
   25
           else
   26
           {
   27
               return "No matching documents found.";
   28
           }
   29
           return sb.ToString();
   30
       }
   31
   }

   Este código contém a lógica para:

   • Defina uma incorporação para a query.

   • Recupere documentos correspondentes do MongoDBDataService.

   • Construa uma string contendo o "Resumo" e o "URL de Listagem" de cada documento para passar para o LLM para resumir.

3. Execute uma query de teste para confirmar se você está obtendo os resultados esperados.

   Substitua o código em Program.cs pelo código a seguir:

   Program.cs

   1
   using MyCompany.RAG.Local;
   2
   3
   var query = "beach house";
   4
   var queryCoordinator = new PerformTestQuery();
   5
   var result = await queryCoordinator.GetQueryResults(query);
   6
   Console.WriteLine(result);

4. Salve o arquivo e, em seguida, compile e execute seu projeto para testar se você obtém os resultados esperados da query:

   dotnet run MyCompany.RAG.Local.csproj

   OCULTAR SAÍDA

   Summary: "Lani Beach House" Aloha - Please do not reserve until reading about the State Tax in "Other Things to Note" section. Please do not reserve unless you agree to pay taxes to Hawaii Beach Homes directly. If you have questions, please inquire before booking.   The home has been completely redecorated in a luxurious island style: vaulted ceilings, skylights, granite counter tops, stainless steel appliances and a gourmet kitchen are just some of the the features. All bedrooms have ocean views
   Listing URL: https://www.airbnb.com/rooms/11553333
   Summary: This peaceful house in North Bondi is 300m to the beach and a minute's walk to cafes and bars. With 3 bedrooms, (can sleep up to 8) it is perfect for families, friends and pets. The kitchen was recently renovated and a new lounge and chairs installed. The house has a peaceful, airy, laidback vibe  - a perfect beach retreat. Longer-term bookings encouraged. Parking for one car. A parking permit for a second car can also be obtained on request.
   Listing URL: https://www.airbnb.com/rooms/10423504
   Summary: There are 2 bedrooms and a living room in the house. 1 Bathroom. 1 Kitchen. Friendly neighbourhood. Close to sea side and Historical places.
   Listing URL: https://www.airbnb.com/rooms/10488837
   Summary: 4 Bedroom Country Beach House w/ option to add a separate studio unit- total of 5 bedrooms/2.5 baths at an additional cost.  27 girl steps to white sand beach & infamous Alligator Pond. Private road, NO highway to cross! Safe beach for children & seniors. Convenient! For pricing to add on additional Studio unit, click on our profile pic and input your dates for quote and details!
   Listing URL: https://www.airbnb.com/rooms/12906000
   Summary: Ocean Living! Secluded Secret Beach! Less than 20 steps to the Ocean! This spacious 4 Bedroom and 4 Bath house has all you need for your family or group. Perfect for Family Vacations and executive retreats. We are in a gated beachfront estate, with lots of space for your activities.
   Listing URL: https://www.airbnb.com/rooms/10317142

Baixe o modelo LLM local.

Execute o seguinte comando para obter o modelo generativo:

ollama pull mistral

Responda perguntas sobre seus dados.

1. Adicione alguns novos membros estáticos à sua classe OllamaAIService.cs, para uso em uma nova tarefa assíncrona SummarizeAnswer:

   OllamaAIService.cs

   namespace MyCompany.RAG.Local;
   using Microsoft.Extensions.AI;
   public class OllamaAIService
   {
       private static readonly System.Uri OllamaUri = new Uri("http://localhost:11434/");
       private static readonly Uri OllamaUri = new("http://localhost:11434/");
       private static readonly string EmbeddingModelName = "nomic-embed-text";
       private static readonly OllamaEmbeddingGenerator EmbeddingGenerator = new OllamaEmbeddingGenerator(OllamaUri, EmbeddingModelName);
       private static readonly string ChatModelName = "mistral";
       private static readonly OllamaChatClient ChatClient = new OllamaChatClient(OllamaUri, ChatModelName);
       public async Task<float[]> GetEmbedding(string text)
       {
           // Method details...
       }
       public async Task<string> SummarizeAnswer(string context)
       {
           string question = "Can you recommend me a few AirBnBs that are beach houses? Include a link to the listings.";
           
           string prompt = $"""
                            Use the following pieces of context to answer the question at the end.
                            Context: {context}
                            Question: {question}
                            """;
           
           ChatCompletion response = await ChatClient.CompleteAsync(prompt, new ChatOptions { MaxOutputTokens = 400 });
           return response.ToString();
       }
   }

   Isso solicita o LLM e retorna a resposta. A resposta gerada pode variar.

2. Defina uma nova classe PerformQuestionAnswer para:

   • Defina uma incorporação para a query.

   • Recupere documentos correspondentes do MongoDBDataService.

   • Utilize o LLM para resumir a resposta.

   AIService.cs

   namespace MyCompany.RAG.Local;
   public class PerformQuestionAnswer
   {
       private readonly MongoDBDataService _dataService = new();
       private readonly OllamaAIService _ollamaAiService = new();
       public async Task<string> SummarizeResults(string question)
       {
           // Get the vector embedding for the query
           var query = question;
           var queryEmbedding = await _ollamaAiService.GetEmbedding(query);
           // Query the vector database for applicable query results
           var matchingDocuments = _dataService.PerformVectorQuery(queryEmbedding);
           // Construct a string from the query results for performing QA with the LLM
           var sb = new System.Text.StringBuilder();
           if (matchingDocuments != null)
           {
               foreach (var doc in matchingDocuments)
               {
                   sb.AppendLine($"Summary: {doc.GetValue("summary").ToString()}");
                   sb.AppendLine($"Listing URL: {doc.GetValue("listing_url").ToString()}");
               }
           }
           else
           {
               return "No matching documents found.";
           }
           return await _ollamaAiService.SummarizeAnswer(sb.ToString());
       }
   }

3. Substitua o conteúdo de Program.cs por um novo bloco para realizar a tarefa:

   Program.cs

   using MyCompany.RAG.Local;
   var qaTaskCoordinator = new PerformQuestionAnswer();
   const string query = "beach house";
   var results = await qaTaskCoordinator.SummarizeResults(query);
   Console.WriteLine(results);

4. Salve o arquivo e, em seguida, compile e execute seu projeto para concluir sua implementação de RAG:

   dotnet run MyCompany.RAG.Local.csproj

   OCULTAR SAÍDA

   Based on the context provided, here are some Airbnb listings for beach houses that you might find interesting:
   1. Lani Beach House (Hawaii) - [Link](https://www.airbnb.com/rooms/11553333)
   2. Peaceful North Bondi House (Australia) - [Link](https://www.airbnb.com/rooms/10423504)
   3. Ocean Living! Secluded Secret Beach! (Florida, USA) - [Link](https://www.airbnb.com/rooms/10317142)
   4. Gorgeous Home just off the main road (California, USA) - [Link](https://www.airbnb.com/rooms/11719579)