MongoDB Academy · Aula

Quando usar um banco de dados de grafos como o Neo4j

Aula 4 de 413 etapas

Quando usar um banco de dados de grafos como o Neo4j é uma aula grátis de MongoDB Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de MongoDB Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de MongoDB Academy inclui 4 aulas no total.

O que é um banco de dados de grafos?

Um banco de dados de grafos representa os dados como nós (entidades) e arestas (relacionamentos entre entidades). Cada aresta é um objeto de primeira classe, com um tipo e suas próprias propriedades. Ao contrário dos bancos de dados relacionais ou de documentos, nos quais os relacionamentos são implícitos por chaves estrangeiras ou referências incorporadas, os bancos de dados de grafos armazenam os relacionamentos como conexões explícitas, com travessia O(1) por salto — seguir um relacionamento leva tempo constante, independentemente do tamanho do banco de dados.

O problema da travessia de relacionamentos

Bancos de dados de documentos e relacionais são otimizados para encontrar entidades — buscar um usuário por ID, consultar pedidos por status. Eles têm dificuldade para percorrer relacionamentos — “encontrar todos os amigos dos amigos de Alice que compraram o mesmo produto que Alice no último mês”. Cada salto exige um $lookup ou JOIN. Três saltos de profundidade significam três junções aninhadas. Em 10 saltos por milhões de nós, o desempenho do MongoDB se degrada exponencialmente, enquanto o do Neo4j permanece estável.

// MongoDB: 3-hop traversal — three nested $lookup stages
db.users.aggregate([
  { $match: { _id: aliceId } },
  { $lookup: { from: 'follows', localField: '_id', foreignField: 'followerId', as: 'following' } },
  { $unwind: '$following' },
  { $lookup: { from: 'follows', localField: 'following.followeeId', foreignField: 'followerId', as: 'followingOfFollowing' } },
  // Expensive and increasingly slow with scale
])

Neo4j e a linguagem de consulta Cypher

O Neo4j é o banco de dados de grafos mais popular e usa a linguagem de consulta Cypher — uma linguagem declarativa e baseada em padrões para percorrer grafos. Uma consulta Cypher descreve o padrão do grafo que você procura usando uma notação de arte ASCII: nós em () e relacionamentos em -[]->. O mecanismo de consulta encontra com eficiência todos os subgrafos que correspondem ao padrão, usando adjacência nativa sem índices.

// Cypher: find Alice's second-degree connections (friends of friends)
MATCH (alice:User { name: 'Alice' })
      -[:FOLLOWS]->(:User)
      -[:FOLLOWS]->(foaf:User)
WHERE NOT (alice)-[:FOLLOWS]->(foaf)
  AND foaf <> alice
RETURN DISTINCT foaf.name, foaf.email
LIMIT 50

// This is O(connections traversed), not O(total users in DB)

Caso clássico de uso de grafos: mecanismos de recomendação

Os sistemas de recomendação dependem da travessia de redes de relacionamentos: “usuários que compraram o que você comprou também compraram X”. Em um grafo, cada compra é uma aresta entre um nó de usuário e um nó de produto. Encontrar recomendações por filtragem colaborativa é uma travessia de 2 saltos: Usuário → Produto → (outros usuários que compraram esse produto) → (outros produtos comprados por esses usuários). O Neo4j lida com milhões dessas travessias por segundo. O $graphLookup do MongoDB pode fazer isso, mas seu desempenho se degrada em grande escala.

// Cypher: collaborative filtering recommendation
MATCH (me:User { _id: 'alice123' })
      -[:PURCHASED]->(p:Product)
      <-[:PURCHASED]-(other:User)
      -[:PURCHASED]->(rec:Product)
WHERE NOT (me)-[:PURCHASED]->(rec)
RETURN rec.name, COUNT(other) AS score
ORDER BY score DESC
LIMIT 10

Detecção de fraude com análise de grafos

As redes de fraude geralmente envolvem informações de identidade compartilhadas: várias contas que compartilham o mesmo ID de dispositivo, número de telefone, endereço IP ou endereço de cobrança. Os bancos de dados de grafos são excelentes para detectar essas redes percorrendo os relacionamentos: “encontrar todas as contas conectadas a esta conta suspeita por meio de atributos compartilhados em até 3 saltos”. A pontuação de fraude em tempo real no momento da transação — consultando um grafo com milhões de entidades relacionadas em milissegundos — é uma vantagem nativa do Neo4j que o MongoDB não consegue igualar.

// Cypher: find fraud ring (accounts sharing device/phone/address)
MATCH (suspect:Account { id: 'acc-999' })
      -[:SHARES_DEVICE|SHARES_PHONE|SHARES_ADDRESS*1..3]-(related:Account)
WHERE related.status = 'active'
RETURN related.id, related.email
LIMIT 100

Grafo de conhecimento

Um grafo de conhecimento modela entidades e seus relacionamentos semânticos — como as informações da Wikipédia estruturadas em um grafo. Os grafos de conhecimento alimentam o reconhecimento de entidades em mecanismos de pesquisa, as respostas factuais de assistentes de IA e as ontologias empresariais. O modelo de grafo se encaixa naturalmente: Pessoa conhece Pessoa, Pessoa worksAt Empresa, Empresa isLocatedIn Cidade, Cidade isCapitalOf País. Percorrer essas cadeias semânticas é exatamente para o que os bancos de dados de grafos foram criados.

Quando o $graphLookup do MongoDB é suficiente

Nem todo problema de grafos precisa do Neo4j. O $graphLookup do MongoDB lida razoavelmente bem com travessias de árvores e grafos nos seguintes casos: hierarquias rasas (menos de 5–6 saltos); grafos de tamanho moderado (milhares a poucos milhões de nós); e consultas de travessia esporádicas que podem tolerar maior latência. Se as consultas de grafos forem um recurso secundário de uma aplicação baseada principalmente em dados de documentos, manter tudo no MongoDB simplifica consideravelmente a pilha.

// MongoDB $graphLookup: category hierarchy traversal
db.categories.aggregate([
  { $match: { _id: 1 } },
  {
    $graphLookup: {
      from: 'categories',
      startWith: '$_id',
      connectFromField: '_id',
      connectToField: 'parentId',
      as: 'descendants',
      maxDepth: 5
    }
  }
])

Quando escolher o Neo4j em vez do MongoDB

Escolha o Neo4j (ou outro banco de dados de grafos) quando: travessias profundas com vários saltos forem um recurso central (redes sociais, grafos de conhecimento, detecção de fraude); o próprio relacionamento tiver propriedades avançadas (por exemplo, uma aresta FOLLOWS que armazene quando o seguimento ocorreu e se é mútuo); as consultas de grafos precisarem retornar resultados em tempo real sob alta concorrência; ou o domínio inteiro for centrado em relacionamentos, e não em entidades. Para redes sociais, grafos de identidade, topologias de rede e grafos de dependências, escolha o Neo4j.

Persistência poliglota: usando ambos

Muitos sistemas de grande porte usam persistência poliglota — bancos de dados diferentes para finalidades diferentes. Uma plataforma social pode armazenar perfis de usuários e publicações no MongoDB (consultas avançadas de documentos), grafos de amizades e interesses no Neo4j (travessia rápida), dados de sessão no Redis (consulta em menos de um milissegundo) e análises em um armazenamento colunar. Cada banco de dados faz aquilo em que é melhor. A complexidade está em gerenciar a consistência entre os sistemas, mas os ganhos de desempenho e escalabilidade frequentemente justificam isso.

Comparação dos modelos de dados do MongoDB e do Neo4j

No MongoDB, um relacionamento social é modelado como um documento em uma coleção follows, com os campos followerId e followeeId. No Neo4j, ele é uma aresta FOLLOWS que conecta diretamente dois nós User. O modelo de grafo elimina a coleção intermediária e permite a travessia direta baseada em ponteiros. O modelo de documentos é melhor para buscar os dados do perfil do usuário; o modelo de grafo é melhor para percorrer suas conexões sociais.

// MongoDB: relationships as documents
{ _id: ObjectId(), followerId: ObjectId('alice'), followeeId: ObjectId('bob'), createdAt: new Date() }

// Neo4j Cypher equivalent:
// (alice:User)-[:FOLLOWS { createdAt: datetime() }]->(bob:User)
// Stored as direct pointer — no intermediate collection needed

Propriedades dos grafos e tipos de relacionamento

As arestas dos grafos no Neo4j têm um tipo (como um rótulo) e podem ter propriedades. Um grafo social pode ter tipos de aresta FOLLOWS, LIKES, PURCHASED e REVIEWED — cada um com suas próprias propriedades. As consultas Cypher podem corresponder ao tipo de aresta e filtrar pelas propriedades da aresta, permitindo consultas avançadas de relacionamentos. Isso é muito mais natural do que armazenar um campo type em uma coleção relationships no MongoDB e fazer uma junção por esse campo.

// Cypher: find products purchased within the last 7 days by connections
MATCH (me:User { id: 'alice' })
      -[:FOLLOWS*1..2]->(friend:User)
      -[p:PURCHASED]->(prod:Product)
WHERE p.purchasedAt >= datetime() - duration('P7D')
RETURN prod.name, COUNT(friend) AS friendsBought
ORDER BY friendsBought DESC
LIMIT 5

Verificação rápida

Teste sua compreensão dos conceitos de MongoDB e bancos de dados NoSQL desta lição.

Responda na aula interativa

Recapitulação da lição

Nesta lição, você aprendeu: bancos de dados de grafos como o Neo4j são excelentes em travessias profundas de relacionamentos com vários saltos — mecanismos de recomendação, detecção de fraudes e grafos de conhecimento — nas quais as cadeias de $lookup do MongoDB se degradam exponencialmente; a linguagem Cypher do Neo4j expressa padrões de grafos de forma declarativa, de um modo que nenhuma linguagem de consulta de documentos consegue igualar; e a persistência poliglota, usando MongoDB para dados de documentos e Neo4j para a travessia de relacionamentos, é um padrão comum em produção. A seguir, abordaremos o projeto final: criar a arquitetura de uma aplicação MongoDB pronta para produção.

Grátis para começar

Aprenda JavaScript com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 30
Aulas: 120

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “Quando usar um banco de dados de grafos como o Neo4j” é grátis?

Sim — o texto completo de “Quando usar um banco de dados de grafos como o Neo4j” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de MongoDB Academy, atualize para CoddyKit PRO. O curso de MongoDB Academy inclui 4 aulas no total.

O que vou aprender em “Quando usar um banco de dados de grafos como o Neo4j”?

Os alunos identificarão problemas estruturados como grafos — mecanismos de recomendação, detecção de fraudes e grafos de conhecimento — nos quais a travessia nativa do Neo4j supera cadeias de $lookup… Você pratica MongoDB Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar MongoDB Academy?

Nenhuma experiência prévia é necessária. MongoDB Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Quando usar um banco de dados de grafos como o Neo4j”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de MongoDB Academy?

Sim. Cada aula de MongoDB Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

MongoDB versus Redis: documentos versus cache de chave-valor
MongoDB versus Cassandra: gravações em escala planetária
MongoDB versus DynamoDB: compromissos nativos da nuvem
Quando usar um banco de dados de grafos como o Neo4j

← Voltar para MongoDB Academy