Criando Mecanismos de Recomendação
Compreenda como o Neo4j alimenta sistemas sofisticados de recomendação aproveitando as conexões entre usuários e itens.
Criando Mecanismos de Recomendação é uma aula grátis de Neo4j Graph Database Fundamentals no CoddyKit. Esta é a aula 1 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 Neo4j Graph Database Fundamentals, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Neo4j Graph Database Fundamentals inclui 4 aulas no total.
Partes desta aula ainda não foram traduzidas e aparecem em inglês.
What are Recommendations?
Have you ever noticed how streaming services suggest your next show, or online stores recommend products you might like? This magic comes from recommendation engines.
These systems analyze user behavior and item attributes to predict what a user will be interested in. Their goal is to enhance user experience and drive engagement.
Graphs & Recommendations
Graph databases like Neo4j are uniquely suited for building recommendation engines because they excel at modeling and querying connections.
Recommendations are all about relationships: users like items, users are similar to other users, items are related to other items. A graph naturally represents these connections.
Modeling User-Item Data
In Neo4j, we model users and items as nodes, and their interactions as relationships.
- User Nodes: Represent individuals (e.g.,
(:User {name: 'Alice'})). - Item Nodes: Represent products, movies, articles (e.g.,
(:Movie {title: 'The Matrix'})). - Interaction Relationships: Connect users and items (e.g.,
-[:LIKES]->,-[:BOUGHT]->,-[:RATED {score: 5}]->).
Initial Recs Data
Let's create a small graph to demonstrate. We'll have users, movies, and LIKES relationships.
This simple model allows us to easily traverse connections to find recommendations.
CREATE (:User {name: 'Alice'})-[:LIKES]->(:Movie {title: 'Inception'})
CREATE (:User {name: 'Alice'})-[:LIKES]->(:Movie {title: 'The Matrix'})
CREATE (:User {name: 'Bob'})-[:LIKES]->(:Movie {title: 'The Matrix'})
CREATE (:User {name: 'Bob'})-[:LIKES]->(:Movie {title: 'Interstellar'})
CREATE (:User {name: 'Charlie'})-[:LIKES]->(:Movie {title: 'Inception'})
CREATE (:User {name: 'Charlie'})-[:LIKES]->(:Movie {title: 'Interstellar'})Item-Based Recommendations
An item-based recommendation suggests items that are similar to what a user already likes. The idea is: 'users who liked this item, also liked that item.'
We find items frequently liked together by the same users. This is great for suggesting related products or content.
Cypher: Item-Based Recs
Let's find movies similar to 'The Matrix' based on other users' likes.
We look for users who liked 'The Matrix', and then see what other movies *those same users* liked.
MATCH (m1:Movie {title: 'The Matrix'})<-[:LIKES]-(u:User)-[:LIKES]->(m2:Movie)
WHERE m1 <> m2
RETURN m2.title AS RecommendedMovie, count(DISTINCT u) AS LikedBySameUsers
ORDER BY LikedBySameUsers DESC
LIMIT 3User-Based Recommendations
User-based recommendation suggests items that similar users have liked. The core idea is: 'people like you liked these items.'
We first identify users with similar tastes, and then recommend items that those similar users liked but the current user hasn't seen yet.
Cypher: User-Based Recs
Let's find movies 'Alice' might like, based on users similar to her.
We find users who liked movies Alice liked, then recommend movies *they* liked but Alice hasn't.
MATCH (alice:User {name: 'Alice'})-[:LIKES]->(m:Movie)<-[:LIKES]-(otherUser:User)
WHERE alice <> otherUser
WITH otherUser, collect(m) AS commonMovies
MATCH (otherUser)-[:LIKES]->(recommendedMovie:Movie)
WHERE NOT (alice)-[:LIKES]->(recommendedMovie)
RETURN recommendedMovie.title AS RecommendedMovie, count(DISTINCT otherUser) AS LikedBySimilarUsers
ORDER BY LikedBySimilarUsers DESC
LIMIT 3Enhancing Recommendations
Recommendation engines can be made more sophisticated by incorporating more data:
- Ratings: Use
-[:RATED {score: 4}]->to capture preference intensity. - Content Attributes: Link movies by
-[:HAS_GENRE]->or products by-[:IS_CATEGORY]->. - Timestamps: Factor in recent interactions for freshness.
These enrich the graph for more relevant suggestions.
Recommendation Query Check
Consider a graph with (:User)-[:WATCHED]->(:Movie) relationships. Which of the following Cypher patterns could be part of a query to find movies watched by users similar to 'Bob', but not yet watched by 'Bob'?
Recap: Recommendation Engines
In this lesson, you learned how Neo4j is ideal for building recommendation engines due to its relationship-first nature.
- We modeled users, items, and their interactions as nodes and relationships.
- You explored both item-based and user-based recommendation strategies using practical Cypher queries.
- You also saw how to enrich your graph model for more sophisticated recommendations.
Graph databases simplify complex recommendation logic, making it intuitive and performant!
Aprenda Neo4j Graph Database Fundamentals 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
- 12
- Aulas
- 48
Perguntas Frequentes
A aula “Criando Mecanismos de Recomendação” é grátis?
Sim — o texto completo de “Criando Mecanismos de Recomendação” é 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 Neo4j Graph Database Fundamentals, atualize para CoddyKit PRO. O curso de Neo4j Graph Database Fundamentals inclui 4 aulas no total.
O que vou aprender em “Criando Mecanismos de Recomendação”?
Compreenda como o Neo4j alimenta sistemas sofisticados de recomendação aproveitando as conexões entre usuários e itens. Você pratica Neo4j Graph Database Fundamentals 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 Neo4j Graph Database Fundamentals?
Nenhuma experiência prévia é necessária. Neo4j Graph Database Fundamentals 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 1 de 4.
Quanto tempo leva a aula “Criando Mecanismos de Recomendação”?
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 Neo4j Graph Database Fundamentals?
Sim. Cada aula de Neo4j Graph Database Fundamentals 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
- Criando Mecanismos de Recomendação
- Detecção e Investigação de Fraudes
- G داردrafos de Conhecimento e Dados Mestres
- Grafos de Rede e Operações de IT