Tutorial RAG dos módulos MongoDB Atlas Vector Search e AWS Bedrock

Pavel Duchovny10 min read • Published Aug 09, 2024 • Updated Aug 09, 2024

IA AWS Sem servidor JavaScript Atlas

Avalie esse Tutorial

Saiba como iniciar um fluxo de trabalho RAG totalmente gerenciado e de ponta a ponta com o MongoDB Atlas e o Amazon CamaDB.

Boas-vindas ao nosso tutorial detalhado sobre os módulos MongoDB Atlas Vector Search e AWS Cloud, personalizado para criar um assistente de banco de dados versátil para catálogos de produtos. Este tutorial irá guiá-lo através da criação de um aplicativo que simplifica as pesquisas de produtos usando diversas entradas, como produtos individuais, listas, imagens e até receitas. Imagine encontrar todos os ingredientes necessários para uma receita com apenas uma simples pesquisa. Seja você um desenvolvedor ou um gerente de produto, este guia irá equipá-lo com as habilidades para criar uma ferramenta poderosa para navegar em bancos de dados de produtos complexos. Alguns exemplos do que este aplicativo pode fazer:

Pesquisa de produto único:

Consulta de pesquisa: "Organic Almonds"

Resultado: exibe o produto de sementes de leguminosa mais bem avaliado ou mais popular no catálogo

Pesquisa baseada em lista:

Consulta de pesquisa: ["Rice", "Black Beans", "Avocado"]

Resultado: mostra uma lista de produtos, incluindo arroz, feijão preto e abacate, juntamente com suas diferentes marcas e preços

- Pesquisa baseada em imagens:

Consulta de pesquisa: [imagem de um pão integral]

Resultado: identifica e mostra a marca de pão de trigo integral mais escolhida disponível no catálogo

Pesquisa baseada em receitas:

Consulta de pesquisa: "Chocolate Chip Cookie Recipe"

Resultado: lista todos os ingredientes necessários para a receita, como farinha, gotas de chocolate, açúcar, manteiga, etc., e sugere produtos relevantes

Vamos começar!

Arquitetura de alto nível

1. Aplicativo VUE js de frontend que implementa um aplicativo de bate-papo

2. Trigger:

Um trigger que observa documentos inseridos "product " e usa uma lógica de função que define incorporações vetoriais no produto "title, " "img, " ou ambos.

3. Atlas App Services para facilitar um backend que hospeda os pontos de conexão para interagir com o banco de dados e os modelos de AI

getAtlas Search — o ponto do mecanismo de Atlas Search principal que recebe uma string de pesquisa ou imagem de base64 e gera um documento resumido
getChats — um endpoint para recuperar a matriz de bate-papos do usuário
saveChats — um endpoint para salvar o array de chats

4. Banco de dados MongoDB Atlas com um índice vetorial do Atlas Search para recuperar documentos relevantes para o RAG insira descrição da imagem aqui

Implementar um cluster gratuito.

Antes de prosseguir, certifique-se de que os seguintes pré-requisitos sejam atendidos:

Cluster do banco de dados configurado no MongoDB Atlas
Obteve o URI para seu cluster

Para obter assistência com a configuração do cluster de banco de dados e a obtenção do URI, consulte nosso guia de configuração de um cluster MongoDBe nosso guia de obtenção da connection string.

Preferencialmente, o local do banco de dados estará na mesma região do Amazon Web Services que os módulos habilitados paraBedRock.

O MongoDB Atlas tem um conjunto avançado de serviços de aplicativos que permitem a um desenvolvedor hospedar uma lógica de aplicativo inteira (autenticação, permissões, funções, Atlas Triggers, etc.) com uma camada gratuita gratuita. Aproveitaremos essa capacidade para otimizar o desenvolvimento e a integração de dados em minutos de trabalho.

Configurar serviços de aplicativo

1. Comece navegando até a guia App Services.

2. Você será solicitado a selecionar um modelo inicial. Vamos escolher a opçãoCriar seu próprio aplicativo, que já está selecionada. Clique no botãoNext (Avançar ).

3. Em seguida, você precisa configurar seu aplicativo.

Fonte de dados: Como criamos um único cluster, o Atlas já o vinculou ao nosso aplicativo.
(Opcional) Nome do aplicativo: Vamos dar ao nosso aplicativo um nome significativo, como bedrockDemo. (Esta opção pode ser escolhida para você automaticamente como "Aplicativo-0" para o primeiro aplicativo.)
(Opcional) Modelo de implantação de aplicativos: Altere a implantação para Single Region e selecione a região mais próxima de sua localização física.

4. Clique no botãoCriar App Service para criar seu primeiro aplicativo do App Services!

5. Depois que o aplicativo for criado, precisamos verificar se as fontes de dados estão vinculadas ao nosso cluster. Visite a abaFontes de Dados Vinculadas: Nosso Atlas cluster com um nome vinculado de mongodb-atlas

Segredos e trigger de configuração

Usaremos o Atlas App Services para criar um valor e um segredo para acesso à AWS e chaves secretas para acessar nossos módulos Bedrock.

Navegue até a guia Valores e clique em Criar novo valor seguindo esta configuração:

Tipo de valor	Nome	Valor
Segredo	AWS_ACCESS_KEY	`<YOUR AWS ACCESS KEY>`
Segredo	AWS_SECRET_KEY	`<YOUR AWS SECRET>`
Valor	AWS_ACCESS_KEY	Link para SECRETO: AWS_ACCESS_KEY
Valor	AWS_SECRET_KEY	Link para SECRET: AWS_SECRET_KEY

Ao final deste processo você deverá ter:

Quando terminar, pressione Review Draft & Deploy e depois Deploy.

Adicionar dependência do AWS SDK

O cliente AWS SDK Bedrock é a maneira mais fácil e conveniente de interagir com os modelos do AWS Bedrock.

1. Em seu aplicativo de serviços de aplicativo, navegue até a guiaFunções e clique na guiaDependências.

2. Clique em Adicionar dependência e adicione a seguinte dependência:

Trecho de código

3. Clique emAdicionar e aguarde que ele seja adicionado com sucesso.

4. Quando terminar, pressione Review Draft & Deploy e depois Deploy.

Criar um acionador

Navegue até a abaTriggers e crie um novo trigger:

Código do gatilho

Escolha otipo de função e, no menu suspenso, clique em Nova função. Adicione um nome como setEmbeddings em Nome da Função.

Copie e cole o seguinte código.

Trecho de código

// Header: MongoDB Atlas Function to Process Document Changes
// Inputs: MongoDB changeEvent object
// Outputs: Updates the MongoDB document with processing status and AWS model response

exports = async function(changeEvent) {
 // Connect to MongoDB service
 var serviceName = "mongodb-atlas";
 var dbName = changeEvent.ns.db;
 var collName = changeEvent.ns.coll;

try {
   var collection = context.services.get(serviceName).db(dbName).collection(collName);

// Set document status to 'pending'
   await collection.updateOne({'_id' : changeEvent.fullDocument._id}, {$set : {processing : 'pending'}});

// AWS SDK setup for invoking models
   const { BedrockRuntimeClient, InvokeModelCommand } = require("@aws-sdk/client-bedrock-runtime");
   const client = new BedrockRuntimeClient({
     region: 'us-east-1',
     credentials: {
       accessKeyId:  context.values.get('AWS_ACCESS_KEY'),
       secretAccessKey: context.values.get('AWS_SECRET_KEY')
     },
     model: "amazon.titan-embed-text-v1",
   });

// Prepare embedding input from the change event
   let embedInput = {}
   if (changeEvent.fullDocument.title) {
     embedInput['inputText'] = changeEvent.fullDocument.title
   }
   if (changeEvent.fullDocument.imgUrl) {
     const imageResponse = await context.http.get({ url: changeEvent.fullDocument.imgUrl });
     const imageBase64 = imageResponse.body.toBase64();
     embedInput['inputImage'] = imageBase64
   }

// AWS SDK call to process the embedding
   const input = {
     "modelId": "amazon.titan-embed-image-v1",
     "contentType": "application/json",
     "accept": "*/*",
     "body": JSON.stringify(embedInput)
   };

console.log(`before model invoke ${JSON.stringify(input)}`);
   const command = new InvokeModelCommand(input);
   const response = await client.send(command);
    
   // Parse and update the document with the response
   const doc = JSON.parse(Buffer.from(response.body));
   doc.processing = 'completed';
   await collection.updateOne({'_id' : changeEvent.fullDocument._id}, {$set : doc});

} catch(err) {
   // Handle any errors in the process
   console.error(err)
 }
};

Clique em Salvar e Revisar rascunho e implantar.

Agora, precisamos definir a função setEmbeddings como uma função do Sistema. Clique na aba Funções e, em seguida, clique na funçãosetEmbeddings, abaConfigurações . Altere Autenticação para Sistema e clique em Salvar.

Um trigger executado com sucesso produzirá uma collection em nosso cluster Atlas. Você pode navegar até o banco de dados Data Services >. Clique no botão Procurar collections na visualização do cluster. O nome do banco de dados é Bedrock e a collection é products.

Observe que a execução do trigger só ocorrerá quando inserirmos os dados na collectionbedrock.products e pode demorar um pouco na primeira vez. Portanto, você pode assistir à seção Registros no lado do App Services.

Crie um índice do Atlas Vector Search

Vamos voltar para as guiasData Services e Database.

Criação de índice de pesquisa do Atlas

Primeiro, navegue até a seção "Atlas Search" do seu cluster e pressione o botão Criar índice.
Clique em "criar índice de pesquisa".
Escolha o índice do Atlas Vector Search e clique em Avançar.
Selecione o banco de dados "bedRock" e a collection "products".
Cole a seguinte definição de índice:

Trecho de código

Clique em Criar e aguarde a criação do índice.
O índice Go por uma fase de construção e, eventualmente, aparecerá "Active". Agora, você está pronto para escrever agregações $search para o Atlas Search.

O endpoint HTTP getSearch implementado no Capítulo 3 já inclui uma consulta de pesquisa.

Trecho de código

Com esse código, estamos realizando uma pesquisa vetorial com o que quer que seja colocado no "doc.embedding" variável nos campos "embedding". Procuramos os resultados de apenas um documento e limitamos o conjunto para o primeiro.

Configurar a lógica de backend

Nossa principal funcionalidade dependerá de um endpoint HTTP do usuário que orquestrará a lógica da pesquisa no catálogo. A entrada do usuário será transformada em uma incorporação multimodal via AWS Tiger e será passada para o Atlas Vector Search para encontrar o documento relevante. O documento será devolvido ao usuário junto com um prompt que projetará uma resposta de um Cohere LLM.

Cohere LLM cohere.command-light-text-v14 faz parte do conjunto de modelos básicos AWS Bedrock.

Criar ponto de extremidade HTTPS de pesquisa de aplicativo

No aplicativo App Services, navegue até a seçãoHTTPS endpoints.
Crie um novo endpoint POST clicando em Adicionar um endpoint com um caminho de /getSearch.
Importante! Alterne a opção Resposta com resultado para Ativado.
A lógica desse endpoint obterá um "termo" da string de query e do Atlas Search para esse termo. Se nenhum termo for fornecido, ele retornará os primeiros 15 resultados.

5. Adicione em Função e Nova Função (nome: getProducts) a seguinte lógica de função:

Trecho de código

// Function Name : getProducts

exports = async function({ body }, response) {

// Import required SDKs and initialize AWS BedrockRuntimeClient
 const { BedrockRuntimeClient, InvokeModelCommand } = require("@aws-sdk/client-bedrock-runtime");
 const client = new BedrockRuntimeClient({
   region: 'us-east-1',
   credentials: {
     accessKeyId: context.values.get('AWS_ACCESS_KEY'),
     secretAccessKey: context.values.get('AWS_SECRET_KEY')
   }
 });

// MongoDB and AWS SDK service setup
 const serviceName = "mongodb-atlas";
 const dbName = "bedrock";
 const collName = "products";
 const collection = context.services.get(serviceName).db(dbName).collection(collName);

// Function to run AWS model command
 async function runModel(command, body) {
   command.body = JSON.stringify(body);
    console.log(`before running ${command.modelId} and prompt ${body.prompt}`)
   const listCmd = new InvokeModelCommand(command);
   console.log(`after running ${command.modelId} and prompt ${body.prompt}`)
   const listResponse = await client.send(listCmd);
   console.log('model body ret', JSON.stringify(JSON.parse(Buffer.from(listResponse.body))))
   console.log('before return from runModel')
   return JSON.parse(Buffer.from(listResponse.body));
 }

// Function to generate list query for text input
function generateListQuery(text) {
 const listDescPrompt = `Please build a json only output start with: {productList : [{"product" : "<NAME>" , "quantity" : <NUMBER>}]} stop output after json fully generated.
     The list for ${text}. Complete {productList : `;
 return {
   "prompt": listDescPrompt,
   "temperature": 0
 };
}

// Function to process list items
async function processListItems(productList, embedCmd) {
 let retDocuments = [];
 for (const product of productList) {
   console.log('product', JSON.stringify(product))
   const embedBody = { 'inputText': product.product };
   const resEmbedding = await runModel(embedCmd, embedBody);
   const items = await collection.aggregate([
     vectorSearchQuery(resEmbedding.embedding), {"$project" : {"embedding" : 0}}
   ]).toArray();
   retDocuments.push(items[0]);
 }
 return retDocuments;
}

// Function to process a single item
async function processSingleItem(doc) {
 const items = await collection.aggregate([
   vectorSearchQuery(doc.embedding), {"$project" : {"embedding" : 0}}]).toArray();
 return items;
}

// Function to create vector search query
function vectorSearchQuery(embedding) {
 return {
   "$vectorSearch": {
     "queryVector": embedding,
     "index": "vector_index",
     "path": "embedding",
     "numCandidates": 15,
     "limit": 1
   }
 };
}

// Parsing input data
 const { image, text } = JSON.parse(body.text());

try {
   let embedCmd = {
     "modelId": "amazon.titan-embed-image-v1",
     "contentType": "application/json",
     "accept": "*/*"
   };
  
   // Process text input
   if (text) {
     const genList = generateListQuery(text);
     const listResult = await runModel({ "modelId": "cohere.command-light-text-v14", "contentType": "application/json",
     "accept": "*/*" }, genList);
     const list = JSON.parse(listResult.generations[0].text);
     console.log('list', JSON.stringify(list));

let retDocuments = await processListItems(list.productList, embedCmd);
     console.log('retDocuments', JSON.stringify(retDocuments));
      let prompt, success = true;
      prompt = `In one simple sentence explain how the retrieved docs: ${JSON.stringify(retDocuments)}
      and mention the searched ingridiants from list: ${JSON.stringify(list.productList)} `;

// Generate text based on the prompt
        genQuery = {
         "prompt": prompt,
         "temperature": 0
       };
  
        textGenInput = {
         "modelId": "cohere.command-light-text-v14",
         "contentType": "application/json",
         "accept": "*/*"
       };
    
       const assistantResponse = await runModel(textGenInput, genQuery);
       console.log('assistant', JSON.stringify(assistantResponse));
        retDocuments[0].assistant = assistantResponse.generations[0].text;
    
     return retDocuments;
   }

// Process image or other inputs
   if (image) {
     const doc = await runModel(embedCmd, { inputImage: image });
     return await processSingleItem(doc);
   }

} catch (err) {
   console.error("Error: ", err);
   throw err;
 }
};

Clique em Save Draft e siga o processoReview Draft & Deploy. Certifique-se de manter o URL de retorno de chamada http, pois o usaremos em nosso capítulo final ao consumir os dados do aplicativo front-end.

TIP:

A URL geralmente será semelhante a algo como: https://us-east-1.aws.data.mongodb-api.com/app/<APP-ID>/endpoint/getSearch

Certifique-se de que a função criada (por exemplo, getProducts) esteja no privilégio "SYSTEM" para esta demonstração.

Esta página pode ser acessada acessando a abaFunções e examinando a abaConfigurações da função relevante.

Importar dados para o Atlas

Agora, importaremos os dados para o Atlas a partir do nosso repositório dogithub.

Na aba principal Serviços de Dados , clique no nome do seu cluster. Clique na aba Coleções .
Começaremos acessando o banco de dados "bedRock" e importando a collection "products".
Clique em Inserir documento ou Adicionar meus próprios dados (se houver) e alterne para a exibição de documentos. Cole o conteúdo do arquivo"products.json" da pasta "data" no repositório.
Clique em Inserir e aguarde a importação dos dados.

Crie um endpoint para salvar e recuperar chats

1. /getChats - salvará um chat no endpoint do banco de dados

Nome: getChats
Caminho: /getChats
Método: GET
Resposta com resultado: sim

Trecho de código

2. /saveChats - salvará um chat no banco de dados Ponto de extremidade

Name: saveChats
Caminho: /saveChats
Método: POST
Resposta com resultado: sim

Trecho de código

Certifique-se de que todas as funções criadas (por exemplo, registerUser) tenham o privilégio "SYSTEM" para esta demonstração.

Esta página pode ser acessada acessando a guia Funções e observando a guia Configurações da função relevante. Por fim, clique em Salvar rascunho e siga o processoRevisar rascunho e implantação.

Configuração frontend do GitHub Codespaces

É hora de testar nossos serviços de back-end e dados. Usaremos o endpoint HTTPS de pesquisa criado para mostrar uma página de pesquisa simples em nossos dados.

Você precisará obter o URL do ponto de conexão HTTPS que criamos como parte da configuração do App Services.

Brinque com o front-end

Usaremos o repositório do Github para iniciar codespaces de :

Abra o repositório no Github.
Clique no botão verdeCódigo .
Clique na guiaCodespaces e + para criar um novo codespace.

Configurar o front-end

Crie um arquivo chamado .env na raiz do projeto.
Adicione o seguinte ao arquivo:

Trecho de código

Instale o front-end

Trecho de código

Instalar o serve.

Trecho de código

Construir o front-end

Trecho de código

Execute o front-end

Trecho de código

Teste o front-end

Abra o navegador no URL fornecido pelo server em um pop-up.

Resumo

Em resumo, este tutorial forneceu a você o conhecimento técnico para aproveitar o MongoDB Atlas Vector Search e o AWS BedRock para criar um assistente de banco de dados de última geração para catálogos de produtos. Nós nos aprofundamos na criação de um aplicativo robusto capaz de lidar com uma variedade de entradas de pesquisa, desde consultas de texto simples até pesquisas mais complexas baseadas em imagens e receitas. Como desenvolvedores e gerentes de produto, as habilidades e técnicas exploradas aqui são cruciais para inovar e melhorar as funcionalidades de pesquisa de banco de dados.

A combinação do MongoDB Atlas e do AWS Bedrock oferece um poderoso kit de ferramentas para navegar e gerenciar com eficiência dados complexos de produtos. Ao integrar essas tecnologias em seus projetos, você pode melhorar significativamente a experiência do usuário e simplificar o processo de recuperação de dados, tornando cada query de pesquisa mais inteligentes e resultados mais relevantes. Adote essa fusão de tecnologia para ultrapassar os limites do que é possível fazer na pesquisa e no gerenciamento de bancos de dados.

Se você quiser explorar mais sobre MongoDB e AI, consulte nossa página de destinoprincipal.

Além disso, se você deseja se comunicar com nossa comunidade, visite https://community.mongodb.com .

Principais comentários nos fóruns

Ainda não há comentários sobre este artigo.

Iniciar a conversa

Avalie esse Tutorial

Relacionado

Tutorial

Como fazer semantic search no MongoDB utilizando o Atlas Vector Search

Sep 18, 2024 | 8 min read

Artigo

AI Shop: o poder da LangChain, OpenAI e MongoDB Atlas trabalhando juntos

Sep 18, 2024 | 7 min read

Tutorial

Como Migrar PostgreSQL para MongoDB com Confluent Kafka

Aug 30, 2024 | 10 min read

Artigo

5 Maneiras de reduzir custos com o MongoDB Atlas

Sep 11, 2024 | 3 min read

Sumário

Arquitetura de alto nível
Implementar um cluster gratuito.
Configurar serviços de aplicativo
Segredos e trigger de configuração
Crie um índice do Atlas Vector Search
Configurar a lógica de backend
Configuração frontend do GitHub Codespaces
Resumo

Atlas

Tutorial RAG dos módulos MongoDB Atlas Vector Search e AWS Bedrock

Pesquisa de produto único:

Pesquisa baseada em lista:

- Pesquisa baseada em imagens:

Pesquisa baseada em receitas:

Arquitetura de alto nível

Implementar um cluster gratuito.​

Configurar serviços de aplicativo

Segredos e trigger de configuração

Adicionar dependência do AWS SDK​

Criar um acionador

Crie um índice do Atlas Vector Search

Configurar a lógica de backend

Criar ponto de extremidade HTTPS de pesquisa de aplicativo​

Importar dados para o Atlas​

Crie um endpoint para salvar e recuperar chats​

Configuração frontend do GitHub Codespaces

Brinque com o front-end​

Configurar o front-end​

Instale o front-end​

Construir o front-end​

Execute o front-end​

Teste o front-end​

Resumo

Principais comentários nos fóruns

Relacionado

Como fazer semantic search no MongoDB utilizando o Atlas Vector Search

AI Shop: o poder da LangChain, OpenAI e MongoDB Atlas trabalhando juntos

Como Migrar PostgreSQL para MongoDB com Confluent Kafka

5 Maneiras de reduzir custos com o MongoDB Atlas

Sumário

Implementar um cluster gratuito.

Adicionar dependência do AWS SDK

Criar ponto de extremidade HTTPS de pesquisa de aplicativo

Importar dados para o Atlas

Crie um endpoint para salvar e recuperar chats

Brinque com o front-end

Configurar o front-end

Instale o front-end

Construir o front-end

Execute o front-end

Teste o front-end