Explore o novo chatbot do Developer Center! O MongoDB AI chatbot pode ser acessado na parte superior da sua navegação para responder a todas as suas perguntas sobre o MongoDB .

Junte-se a nós no Amazon Web Services re:Invent 2024! Saiba como usar o MongoDB para casos de uso de AI .
Desenvolvedor do MongoDB
Central de desenvolvedor do MongoDBchevron-right
Produtoschevron-right
Atlaschevron-right

Impressione-se: sinônimos no Atlas Search

Nic Raboy, Anaiya Raisinghani9 min read • Published Aug 03, 2021 • Updated Feb 27, 2023
Node.jsAtlasPesquisaJavaScript
Ícone do FacebookÍcone do Twitterícone do linkedin
Avalie esse Tutorial
star-empty
star-empty
star-empty
star-empty
star-empty
Às vezes, a palavra que você procura está na ponta da linguagem, mas você não consegue entegiá-la. Por exemplo, quando você estiver tentando encontrar um tuíte muito engraçado que viu na noite passada para mostrar aos seus amigos. Se você está lendo isso e esperando: "Uau, Anaiya e Nic, você está tão certo. Eu gostaria que tivesse uma correção para isso", prepare-se! Temos a solução ideal para aqueles dias em que suas capacidades linguísticas precisas falham, mas você tem uma ideia do que está procurando: Sinônimos no Atlas Search.
Neste tutorial, mostraremos como indexar uma collection MongoDB para capturar pesquisas de palavras que significam coisas semelhantes. Para obter detalhes específicos, vamos pesquisar conteúdo escrito com gíria da Geração Z (Gen-Z). A gíria será mapeada para palavras comuns com sinônimos e, como resultado, você terá uma rápida lição da Geração Z sem precisar abrir o TikTok.
Se você estiver com disponibilidade para aprender algumas palavras novas, além de como mapeamentos de sinônimos podem ser integrados sem esforço ao Atlas Search, este é o tutorial para você.

Requisitos

Existem alguns requisitos que devem ser atendidos para ter sucesso com este tutorial:
  • Cluster do MongoDB Atlas M0 (ou superior) executando o MongoDB versão 4.4 (ou superior)
  • Node.js
  • Uma conta de programador do Twitter
Usaremos o Node.js para carregar nossos dados do Twitter, mas é necessária uma conta de programador do Twitter para acessar as APIs que contêm os Tuítes.

Carregar dados do Twitter em uma coleção do MongoDB

Exemplo de dados de Twitter para sinônimos de gíria
Exemplo de dados de Twitter para sinônimos de gíria
Antes de iniciar esta seção do tutorial, você precisará ter sua Chave de API do Twitter e Segredo de API à mão. Ambos podem ser gerados no Portal do Desenvolvedor do Twitter.
A ideia é armazenar vários tweets no MongoDB que contenham gírias da Geração Z que, posteriormente, possamos entender usando o Atlas Search e sinônimos definidos corretamente. Cada tweet será armazenado como um único documento no MongoDB e terá a seguinte aparência:
1{
2 "_id": 1420091624621629400,
3 "created_at": "Tue Jul 27 18:40:01 +0000 2021",
4 "id": 1420091624621629400,
5 "id_str": "1420091624621629443",
6 "full_text": "Don't settle for a cheugy database, choose MongoDB instead 💪",
7 "truncated": false,
8 "entities": {
9 "hashtags": [],
10 "symbols": [],
11 "user_mentions": [],
12 "urls": []
13 },
14 "metadata": {
15 "iso_language_code": "en",
16 "result_type": "recent"
17 },
18 "source": "<a href=\"https://mobile.twitter.com\" rel=\"nofollow\">Twitter Web App</a>",
19 "in_reply_to_status_id": null,
20 "in_reply_to_status_id_str": null,
21 "in_reply_to_user_id": null,
22 "in_reply_to_user_id_str": null,
23 "in_reply_to_screen_name": null,
24 "user": {
25 "id": 1400935623238643700,
26 "id_str": "1400935623238643716",
27 "name": "Anaiya Raisinghani",
28 "screen_name": "anaiyaraisin",
29 "location": "",
30 "description": "Developer Advocacy Intern @MongoDB. Opinions are my own!",
31 "url": null,
32 "entities": {
33 "description": {
34 "urls": []
35 }
36 },
37 "protected": false,
38 "followers_count": 11,
39 "friends_count": 29,
40 "listed_count": 1,
41 "created_at": "Fri Jun 04 22:01:07 +0000 2021",
42 "favourites_count": 8,
43 "utc_offset": null,
44 "time_zone": null,
45 "geo_enabled": false,
46 "verified": false,
47 "statuses_count": 7,
48 "lang": null,
49 "contributors_enabled": false,
50 "is_translator": false,
51 "is_translation_enabled": false,
52 "profile_background_color": "F5F8FA",
53 "profile_background_image_url": null,
54 "profile_background_image_url_https": null,
55 "profile_background_tile": false,
56 "profile_image_url": "http://pbs.twimg.com/profile_images/1400935746593202176/-pgS_IUo_normal.jpg",
57 "profile_image_url_https": "https://pbs.twimg.com/profile_images/1400935746593202176/-pgS_IUo_normal.jpg",
58 "profile_banner_url": "https://pbs.twimg.com/profile_banners/1400935623238643716/1622845231",
59 "profile_link_color": "1DA1F2",
60 "profile_sidebar_border_color": "C0DEED",
61 "profile_sidebar_fill_color": "DDEEF6",
62 "profile_text_color": "333333",
63 "profile_use_background_image": true,
64 "has_extended_profile": true,
65 "default_profile": true,
66 "default_profile_image": false,
67 "following": null,
68 "follow_request_sent": null,
69 "notifications": null,
70 "translator_type": "none",
71 "withheld_in_countries": []
72 },
73 "geo": null,
74 "coordinates": null,
75 "place": null,
76 "contributors": null,
77 "is_quote_status": false,
78 "retweet_count": 0,
79 "favorite_count": 1,
80 "favorited": false,
81 "retweeted": false,
82 "lang": "en"
83}
O document model acima é mais bizarro do que precisamos. Na verdade, só vamos estar atentos ao campo full_text, mas ainda é útil saber o que existe para qualquer tuíte.
Agora que sabemos como será o document model, só precisamos consumi-lo pelo Twitter.
Vamos usar duas diferentes API do Twitter com nossa chave de API e segredo de API. A primeira API é a API de autenticação e ela nos fornecerá nosso token de acesso. Com o token de acesso, podemos obter dados de tuíte com base em uma query do Twitter.
Como estamos usando o Node.js, Precisamos instalar nossas dependências. Em um novo diretório no seu computador, execute os seguintes comandos a partir da linha de comando:
1npm init -y
2npm install mongodb axios --save
Os comandos acima criarão um novo arquivopackage.json e instalarão o driver Node.js do MongoDB, bem como o Axios para fazer solicitações HTTP.
Dê uma olhada no seguinte código Node.js que pode ser adicionado a um arquivo principal.js dentro do seu projeto:
1const { MongoClient } = require("mongodb");
2const axios = require("axios");
3
4require("dotenv").config();
5
6const mongoClient = new MongoClient(process.env.MONGODB_URI);
7
8(async () => {
9 try {
10 await mongoClient.connect();
11 const tokenResponse = await axios({
12 "method": "POST",
13 "url": "https://api.twitter.com/oauth2/token",
14 "headers": {
15 "Authorization": "Basic " + Buffer.from(`${process.env.API_KEY}:${process.env.API_SECRET}`).toString("base64"),
16 "Content-Type": "application/x-www-form-urlencoded"
17 },
18 "data": "grant_type=client_credentials"
19 });
20 const tweetResponse = await axios({
21 "method": "GET",
22 "url": "https://api.twitter.com/1.1/search/tweets.json",
23 "headers": {
24 "Authorization": "Bearer " + tokenResponse.data.access_token
25 },
26 "params": {
27 "q": "mongodb -filter:retweets filter:safe (from:codeSTACKr OR from:nraboy OR from:kukicado OR from:judy2k OR from:adriennetacke OR from:anaiyaraisin OR from:lauren_schaefer)",
28 "lang": "en",
29 "count": 100,
30 "tweet_mode": "extended"
31 }
32 });
33 console.log(`Next Results: ${tweetResponse.data.search_metadata.next_results}`)
34 const collection = mongoClient.db(process.env.MONGODB_DATABASE).collection(process.env.MONGODB_COLLECTION);
35 tweetResponse.data.statuses = tweetResponse.data.statuses.map(status => {
36 status._id = status.id;
37 return status;
38 });
39 const result = await collection.insertMany(tweetResponse.data.statuses);
40 console.log(result);
41 } finally {
42 await mongoClient.close();
43 }
44})();
Há muita coisa acontecendo no código acima, então vamos detalhá-lo. No entanto, antes de detalharmos, é importante observar que estamos usando variáveis de ambiente para muitas informações confidenciais, como tokens, nomes de usuário e senhas. Por motivos de segurança, você realmente não deveria codificar esses valores.
Dentro da função assíncrona, tentamos estabelecer uma conexão com o MongoDB. Se for bem-sucedido, nenhum erro será gerado e fizermos nossa primeira solicitação HTTP.
1const tokenResponse = await axios({
2 "method": "POST",
3 "url": "https://api.twitter.com/oauth2/token",
4 "headers": {
5 "Authorization": "Basic " + Buffer.from(`${process.env.API_KEY}:${process.env.API_SECRET}`).toString("base64"),
6 "Content-Type": "application/x-www-form-urlencoded"
7 },
8 "data": "grant_type=client_credentials"
9});
Mais uma vez, nesta primeira solicitação HTTP, estamos trocando nossa Chave de API e o Segredo da API por um token de acesso a ser usado em solicitações futuras.
Usando o token de acesso da resposta, podemos fazer nossa segunda solicitação para o endpoint da API dos AWS:
1const tweetResponse = await axios({
2 "method": "GET",
3 "url": "https://api.twitter.com/1.1/search/tweets.json",
4 "headers": {
5 "Authorization": "Bearer " + tokenResponse.data.access_token
6 },
7 "params": {
8 "q": "mongodb -filter:retweets filter:safe",
9 "lang": "en",
10 "count": 100,
11 "tweet_mode": "extended"
12 }
13});
O endpoint da API de tweets espera uma consulta específica do Twitter e alguns outros parâmetros opcionais, como o idioma dos tweets ou a contagem esperada de resultados. Você pode verificar o idioma da consulta na documentação do Twitter.
Neste ponto, temos uma série de tweets para trabalhar.
A próxima etapa é escolher o banco de dados e a collection que planejamos usar e inserir a matriz de tweets como documentos. Podemos usar uma operaçãoinsertManysimples como esta:
1const result = await collection.insertMany(tweetResponse.data.statuses);
O insertMany pega um array de objetos, que já temos. Temos uma série de tweets, então cada tweet será inserido como um novo documento no banco de dados.
Se você tiver o shell MongoDB à mão, poderá validar os dados inseridos executando o seguinte:
1use("synonyms");
2db.tweets.find({ });
Agora que há dados com os quais trabalhar, podemos começar a pesquisá-los usando sinônimos de gírias.

Criando mapeamentos de sinônimos no MongoDB

Embora estejamos usando uma coleçãotweetspara nossos dados pesquisáveis reais, as informações sobre sinônimos precisam existir em uma coleção de origem separada no mesmo banco de dados.
Você tem duas opções de como deseja que seus sinônimos sejam mapeados – explícito ou equivalente. Você não está preso em escolher apenas um tipo. Você pode ter uma combinação de documentos explícitos e equivalentes como sinônimos em sua coleção. Escolha o formato explícito para quando você precisar que um conjunto de termos apareça como resultado do termo inserido e escolha equivalente se quiser que todos os termos apareçam bidirecionalmente, independentemente do termo consultado.
Por exemplo, a palavra "basic" significa "regular" ou "chato". Se decidirmos por um mapeamento explícito (unidirecional) para "basic", estamos informando à Atlas Search que, se alguém pesquisar "basic", queremos retornar todos os documentos que incluam as palavras "basic", "regular" e "chato." Mas! Se fizermos query da palavra "regular", não obteremos nenhum documento que inclua "basic" porque "regular" não está explicitamente mapeado para "basic".
Se decidirmos mapear "basic" de forma equivalente a "regular" e "boring," sempre que consultarmos qualquer uma dessas palavras, todos os documentos que contenham "basic," " regular," e "boring" serão exibidos independentemente da palavra inicialmente consultada.
Para saber mais sobre mapeamentos de sinônimos explícitos versus equivalentes, consulte a documentação oficial.
Para nossa demonstração, decidimos tornar todos os nossos sinônimos equivalentes e formatamos nossos dados de sinônimos da seguinte maneira:
1[
2 {
3 "mappingType": "equivalent",
4 "synonyms": ["basic", "regular", "boring"]
5 },
6 {
7 "mappingType": "equivalent",
8 "synonyms": ["bet", "agree", "concur"]
9 },
10 {
11 "mappingType": "equivalent",
12 "synonyms": ["yikes", "embarrassing", "bad", "awkward"]
13 },
14 {
15 "mappingType": "equivalent",
16 "synonyms": ["fam", "family", "friends"]
17 }
18]
Cada objeto na array acima existirá como um documento separado dentro do MongoDB. Cada um desses documentos contém informações para um conjunto específico de sinônimos.
Para inserir seus documentos sinônimos em sua collection MongoDB, você pode usar a função bruta 'insertMany()' do MongoDB para colocar todos os seus documentos na collection de sua escolha.
1use("synonyms");
2
3db.slang.insertMany([
4 {
5 "mappingType": "equivalent",
6 "synonyms": ["basic", "regular", "boring"]
7 },
8 {
9 "mappingType": "equivalent",
10 "synonyms": ["bet", "agree", "concur"]
11 }
12]);
A linha use("synonyms");serve para garantir que você esteja no banco de dados correto antes de inserir seus documentos. Estamos usando a coleçãoslang para armazenar nossos sinônimos e ela não precisa existir em nosso banco de dados antes de executarmos a consulta.

Crie um índice do Atlas Search que aproveita os sinônimos

Depois de ter sua collection de sinônimos à mão e carregada, é hora de criar seu índice de pesquisa! Um índice de pesquisa é crucial porque permite que você use a pesquisa de texto completo para localizar as queries inseridas nessa collection.
Incluímos capturas de tela abaixo de como será a interface de usuário do MongoDB Atlas Search para que você possa acompanhar:
A primeira etapa é clicar na aba "Pesquisar", localizada na página do cluster entre as abas "Collections" e "Profiler".
Localize a aba Atlas Search
Localize a aba Atlas Search
A segunda etapa é clicar no botão " Criar índice " no canto superior direito ou, se esse for seu primeiro índice, ele estará localizado no meio da página.
Crie um novo índice Atlas Search.
Crie um novo índice Atlas Search.
Quando chegar a essa página, clique em "Next" e continue até a página em que você nomeará seu Index e configurará tudo!
Nomear o índice do Atlas Search
Nomear o índice do Atlas Search
Clique em "Avançar" e você poderá criar seu próprio índice de pesquisa!
Finalize o índice Atlas Search
Finalize o índice Atlas Search
Depois de criar seu índice do Atlas Search, você pode Go a ele e editar sua definição de índice usando o editor JSON para incluir o que precisa. O índice que escrevemos para este tutorial está abaixo:
1{
2 "mappings": {
3 "dynamic": true
4 },
5 "synonyms": [
6 {
7 "analyzer": "lucene.standard",
8 "name": "slang",
9 "source": {
10 "collection": "slang"
11 }
12 }
13 ]
14}
Vamos executar isso!
1{
2 "mappings": {
3 "dynamic": true
4},
Você tem a opção de escolher entre dinâmico e estático para o seu índice do Atlas Search, e isso fica a seu critério. Para encontrar mais informações sobre a diferença entre mapeamentos dinâmicos e estáticos, consulte a documentação.
1"synonyms": [
2 {
3 "analyzer": "lucene.standard",
4 "name": "slang",
5 "source": {
6 "collection": "slang"
7 }
8 }
9]
Esta seção refere-se aos sinônimos associados ao índice de pesquisa. Neste exemplo, estamos dando a esse mapeamento de sinônimos o nome de "gíria" e estamos usando o analisador de índice padrão nos dados de sinônimos, que podem ser encontrados na coleção de gírias.

Pesquisando com sinônimos com o pipeline de agregação MongoDB

Nossa próxima etapa é montar a consulta de pesquisa que realmente filtrará sua collection de tweets e encontrar os tweets que você deseja usando sinônimos!
O código que usamos para esta parte está abaixo:
1use("synonyms");
2
3db.tweets.aggregate([
4 {
5 "$search": {
6 "index": "synsearch",
7 "text": {
8 "query": "throw",
9 "path": "full_text",
10 "synonyms": "slang"
11 }
12 }
13 }
14]);
Queremos pesquisar nossos tuítes e encontrar os documentos que contêm sinônimos para nossa query "throw". Este é o documento de sinônimo para "throw":
1{
2 "mappingType": "equivalent",
3 "synonyms": ["yeet", "throw", "agree"]
4},
Lembre-se de incluir o nome do seu índice do Atlas Search anterior (syncsearch). Em seguida, a consulta que estamos especificando é "throw". Isso significa que queremos ver tuítes que incluam "yet", "throw" e "agree" quando executarmos o script.
O 'caminho' representa o campo no qual queremos pesquisar e, nesse caso, estamos pesquisando " throw " somente no campo 'full_text' dos documentos e em nenhum outro campo. Por último, mas não menos importante, queremos usar sinônimos encontrados na collection que chamamos de " slang. "
Com base nessa consulta, todas as correspondências encontradas incluirão o documento inteiro no conjunto de resultados. Para simplificar isso, podemos usar um estágio de agregação$projectpara especificar os campos nos quais estamos interessados. Isso transforma nossa consulta no seguinte pipeline de agregação:
1db.tweets.aggregate([
2 {
3 "$search": {
4 "index": "synsearch",
5 "text": {
6 "query": "throw",
7 "path": "full_text",
8 "synonyms": "slang"
9 }
10 }
11 },
12 {
13 "$project": {
14 "_id": 1,
15 "full_text": 1,
16 "username": "$user.screen_name"
17 }
18 }
19]);
E estes são os nossos resultados!
1[
2 {
3 "_id": 1420084484922347500,
4 "full_text": "not to throw shade on SQL databases, but MongoDB SLAPS",
5 "username": "codeSTACKr"
6 },
7 {
8 "_id": 1420088203499884500,
9 "full_text": "Yeet all your data into a MongoDB collection and watch the magic happen! No cap, we are efficient 💪",
10 "username": "nraboy"
11 }
12]
Assim como queríamos, temos tweets que incluem a palavra "jogar" e a palavra "yeet!"

Conclusão

Fizemos muitas coisas neste tutorial e esperamos que você tenha gostado de acompanhá-lo. Agora, você tem o conhecimento necessário para carregar dados de fontes externas, criar sua lista de sinônimos explícitos ou equivalentes e inseri-la em uma coleção, além de escrever seu próprio script de pesquisa de índice. Os sinônimos podem ser úteis de várias maneiras, não apenas isolados para as gírias da geração Z. Desde descobrir variações regionais (por exemplo, soda = pop) até encontrar erros de digitação que não podem ser facilmente detectados com o preenchimento automático, a incorporação de sinônimos ajudará você a economizar tempo e um dicionário de sinônimos.
O uso de sinônimos no Atlas Search melhorará a funcionalidade de pesquisa do seu aplicativo e permitirá que você encontre os dados que procura, mesmo quando não conseguir colocar o dedo neles.
Se quiser dar uma olhada no código, nas queries e nos índices usados nesta postagem do blog, confira o projeto no GitHub. Se você quiser saber mais sobre sinônimos no Atlas Search, confira a documentação.
Se tiver dúvidas, acesse o site da nossa comunidade de desenvolvedores, no qual os engenheiros e a comunidade do MongoDB ajudarão você a desenvolver sua próxima grande ideia com o MongoDB.

Ícone do FacebookÍcone do Twitterícone do linkedin
Avalie esse Tutorial
star-empty
star-empty
star-empty
star-empty
star-empty
Relacionado
Tutorial

Como usar o PyMongo para conectar o MongoDB Atlas ao AWS Lambda


Apr 02, 2024 | 6 min read
Tutorial

Usando os embeddings mais recentes da OpenAI em um sistema RAG com o MongoDB


Jul 01, 2024 | 15 min read
Tutorial

Introdução ao MongoDB Atlas, NodeJS e o Azure App Service


Apr 02, 2024 | 5 min read
Tutorial

Automação do cluster do Atlas usando triggers agendados


Jun 25, 2024 | 11 min read
Sumário