Usando os MongoDB Atlas Triggers para resumir as avaliações do Airbnb com OpenAI

Pavel Duchovny4 min read • Published Oct 31, 2023 • Updated Oct 31, 2023

IA Node.js Fluxos de alterações JavaScript MongoDB

Avalie esse Tutorial

No domínio do aluguel de propriedades, as avaliações executam um papel fundamental. Ostriggers do MongoDB Atlas, combinados com o poder dos modelos do OpenAI, podem ajudar a resumir e analisar essas avaliações em tempo real. Neste artigo, exploraremos como utilizar os triggers do MongoDB Atlas para processar avaliações do Airbnb, gerando resumos concisos e marcações relevantes.

Este artigo é um recurso adicional adicionado ao aplicativo de pesquisa de sentimentos de hotéis e apartamentos desenvolvido em Leveraging OpenAI e MongoDB Atlas para melhoria da funcionalidade de pesquisa.

Introdução

Os triggers do MongoDB Atlas permitem que os usuários definam funções que são executadas em tempo real em resposta a operações de banco de dados. Esses triggers podem ser aproveitados para aprimorar os recursos de processamento e análise de dados. Neste exemplo, pretendemos gerar avaliações resumidas e marcações para um conjunto dedados de amostra do Airbnb.

Nosso modelo de dados original tem cada avaliação incorporada no documento de listagem como uma array:

Trecho de código

Pré-requisitos

Aplicativo App Services (por exemplo, aplicativo -0). Garanta a vinculação ao cluster com os dados do Airbnb.
Conta OpenAI com acesso API.

Segredos e valores

Navegue até seu aplicativo App Services.
Em "Values (Valores de )," crie um segredo chamado openAIKey com sua chave de API da OPEN AI .
Crie um valor vinculado chamado OpenAIKey e vincule ao segredo.

O código de trigger

O trigger fornecido escuta alterações na collection sample_airbnb.listingsAndReviews. Ao detectar uma nova revisão, ele faz uma amostra de até 50 avaliações, as envia para a API do OpenAI para resumo e atualiza o documento original com o conteúdo resumido e as tags.

Observe que o trigger reage a atualizações que foram marcadas com o sinalizador "process" : false. Este campo indica que ainda não foi criado nenhum resumo para este lote de revisões.

Exemplo de uma operação de atualização de revisão que acionará este trigger:

Trecho de código

Função de avaliações de amostra

Para evitar a sobrecarga da API com um grande número de avaliações, uma função sampleReviews é definida para amostrar aleatoriamente até 50 avaliações:

Trecho de código

Lógica principal do trigger

A lógica de trigger principal é invocada quando um evento de alteração de atualização é detectado com um campo"process" : false.

Trecho de código

exports = async function(changeEvent) {
  // A Database Trigger will always call a function with a changeEvent.
  // Documentation on ChangeEvents: https://www.mongodb.com/pt-br/docs/manual/reference/change-events

// This sample function will listen for events and replicate them to a collection in a different Database
function sampleReviews(reviews) {
// Logic above...
   if (reviews.length <= 50) {
        return reviews;
    }
    const sampledReviews = [];
    const seenIndices = new Set();

while (sampledReviews.length < 50) {
        const randomIndex = Math.floor(Math.random() * reviews.length);
        if (!seenIndices.has(randomIndex)) {
            seenIndices.add(randomIndex);
            sampledReviews.push(reviews[randomIndex]);
        }
    }

return sampledReviews;
}

// Access the _id of the changed document:
  const docId = changeEvent.documentKey._id;
  const doc= changeEvent.fullDocument;

// Get the MongoDB service you want to use (see "Linked Data Sources" tab)
  const serviceName = "mongodb-atlas";
  const databaseName = "sample_airbnb";
  const collection = context.services.get(serviceName).db(databaseName).collection(changeEvent.ns.coll);

// This function is the endpoint's request handler. 
    // URL to make the request to the OpenAI API.
    const url = 'https://api.openai.com/v1/chat/completions';

// Fetch the OpenAI key stored in the context values.
    const openai_key = context.values.get("openAIKey");

const reviews = doc.reviews.map((review) => {return {"comments" : review.comments}});
    
    const sampledReviews= sampleReviews(reviews);

// Prepare the request string for the OpenAI API.
    const reqString = `Summerize the reviews provided here: ${JSON.stringify(sampledReviews)} | instructions example:\n\n [{"comment" : "Very Good bed"} ,{"comment" : "Very bad smell"} ] \nOutput: {"overall_review": "Overall good beds and bad smell" , "neg_tags" : ["bad smell"], pos_tags : ["good bed"]}. No explanation. No 'Output:' string in response. Valid JSON. `;
    console.log(`reqString: ${reqString}`);

// Call OpenAI API to get the response.
    
    let resp = await context.http.post({
        url: url,
        headers: {
            'Authorization': [`Bearer ${openai_key}`],
            'Content-Type': ['application/json']
        },
        body: JSON.stringify({
            model: "gpt-4",
            temperature: 0,
            messages: [
                {
                    "role": "system",
                    "content": "Output json generator follow only provided example on the current reviews"
                },
                {
                    "role": "user",
                    "content": reqString
                }
            ]
        })
    });

// Parse the JSON response
    let responseData = JSON.parse(resp.body.text());

// Check the response status.
    if(resp.statusCode === 200) {
        console.log("Successfully received code.");
        console.log(JSON.stringify(responseData));

const code = responseData.choices[0].message.content;
        // Get the required data to be added into the document
        const updateDoc = JSON.parse(code)
        // Set a flag that this document does not need further re-processing 
        updateDoc.process = true
        await collection.updateOne({_id : docId}, {$set : updateDoc});

} else {
        console.error("Failed to generate filter JSON.");
        console.log(JSON.stringify(responseData));
        return {};
    }
};

As principais etapas incluem:

Preparação de solicitação de API: as avaliações do documento alterado são amostradas e preparadas em uma string para a API OpenAI. O formato e as instruções são personalizados para garantir que a API retorne um JSON válido com conteúdo e tags resumidos.
Interação da API: usando o context.http.post método, o trigger envia os dados preparados para a API OpenAI.
Atualizando o documento original: após uma resposta bem-sucedida da API, o trigger atualiza o documento original com o conteúdo resumido, tags negativas (neg_tags), tags positivos (pos_tags) e um sinalizador de processo definido como true.

Aqui está um exemplo de resultado que é adicionado ao documento de listagem processado:

Trecho de código

Depois que os dados são adicionados aos nossos documentos, fornecer essas informações em nosso aplicativo VUE é tão simples quanto adicionar esse modelo HTML:

Trecho de código

Conclusão

Ao integrar os triggers do MongoDB Atlas com os modelos poderosos da OpenAI, podemos processar e analisar com eficiência grandes volumes de avaliações em tempo real. Essa configuração não apenas fornece resumos concisos das avaliações, mas também as categoriza em etiquetas positivas e negativas, oferecendo informações valiosas para anfitriões e possíveis locatários.

Dúvidas? Comentários? Vamos continuar a conversa em nossos fóruns da comunidade.

Avalie esse Tutorial

Relacionado

Início rápido

Java - Mapeamento de POJOs

Mar 01, 2024 | 5 min read

Tutorial

Análise de moeda com coleções de séries temporais #2 — Cálculo da média móvel simples e da média móvel exponencial

May 16, 2022 | 7 min read

Início rápido

Operações básicas do MongoDB em Python

Sep 23, 2022 | 11 min read

Artigo

Paginações 1.0: Coleções de séries temporais em cinco minutos

May 19, 2022 | 4 min read