Graph-Powered Recommendations

// Co-reading edges from reading sessions (maintained incrementally by the event consumer)
MATCH (s:Session)-[:VIEWED]->(a:Page), (s)-[:VIEWED]->(b:Page)
WHERE elementId(a) < elementId(b)
MERGE (a)-[r:CO_READ]-(b)
ON CREATE SET r.weight = 1 ON MATCH SET r.weight = r.weight + 1;

CALL gds.graph.project(
  'pages',
  {Page: {properties: ['embedding']}},
  {CO_READ: {orientation: 'UNDIRECTED', properties: ['weight']}}
);

CALL gds.knn.write('pages', {
  nodeProperties: {embedding: 'COSINE'},
  topK: 10,
  similarityCutoff: 0.75,
  writeRelationshipType: 'SIMILAR',
  writeProperty: 'score'
}) YIELD nodesCompared, relationshipsWritten;

CALL gds.louvain.write('pages', {
  relationshipWeightProperty: 'weight',
  writeProperty: 'community'
}) YIELD communityCount, modularity;

CALL gds.graph.drop('pages');

package com.example.docsassistant.rag.recommend;

import java.util.List;
import java.util.Map;

import org.neo4j.driver.Driver;
import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.embedding.EmbeddingModel;
import org.springframework.stereotype.Service;

@Service
public class ReaderProfileService {

    private static final String RECENT_PAGES = """
            MATCH (u:Reader {id: $readerId})-[v:VIEWED]->(p:Page)
            RETURN p.title AS title, p.summary AS summary ORDER BY v.at DESC LIMIT 10""";

    private static final String STORE = """
            MATCH (u:Reader {id: $readerId})
            SET u.intent = $intent, u.embedding = $embedding, u.profileUpdatedAt = datetime()""";

    private final ChatClient chatClient;
    private final EmbeddingModel embeddingModel;
    private final Driver driver;

    public ReaderProfileService(ChatClient.Builder builder, EmbeddingModel embeddingModel, Driver driver) {
        this.chatClient = builder.build();
        this.embeddingModel = embeddingModel;
        this.driver = driver;
    }

    public String refresh(String readerId) {
        List<String> pages = driver.executableQuery(RECENT_PAGES).withParameters(Map.of("readerId", readerId))
                .execute().records().stream()
                .map(r -> r.get("title").asString() + ": " + r.get("summary").asString(""))
                .toList();
        if (pages.isEmpty()) {
            return null;
        }
        String intent = chatClient.prompt()
                .system("In one sentence, describe what this reader is trying to achieve, based only on the pages "
                        + "they read. No names, no personal data.")
                .user(String.join("\n", pages))
                .call()
                .content();
        float[] vector = embeddingModel.embed(intent);
        driver.executableQuery(STORE)
                .withParameters(Map.of("readerId", readerId, "intent", intent, "embedding", vector))
                .execute();
        return intent;
    }
}

package com.example.docsassistant.l4j.recommend;

import java.util.List;
import java.util.Map;

import dev.langchain4j.model.chat.ChatModel;
import dev.langchain4j.model.embedding.EmbeddingModel;
import org.neo4j.driver.Driver;

public class RecommendationQueries {

    public record Recommendation(String pageId, String title, double score) {
    }

    private static final String RECOMMEND = """
            MATCH (u:Reader {id: $readerId})
            OPTIONAL MATCH (u)-[:VIEWED]->(h:Page)
            WITH u, collect(h) AS read, collect(DISTINCT h.community) AS readCommunities
            MATCH (p:Page) WHERE p.acl IN $readableAcls AND NOT p IN read AND p.deletedAt IS NULL
            OPTIONAL MATCH (h2:Page)-[k:SIMILAR]->(p) WHERE h2 IN read
            WITH p, u, readCommunities, max(coalesce(k.score, 0.0)) AS knn
            WITH p, knn,
                 CASE WHEN u.embedding IS NULL THEN 0.0 ELSE vector.similarity.cosine(u.embedding, p.embedding) END AS intent,
                 CASE WHEN p.community IN readCommunities THEN 1.0 ELSE 0.0 END AS community
            RETURN p.id AS pageId, p.title AS title, $alpha * intent + $beta * knn + $gamma * community AS score
            ORDER BY score DESC LIMIT $limit""";

    private final Driver driver;
    private final ChatModel chatModel;
    private final EmbeddingModel embeddingModel;

    public RecommendationQueries(Driver driver, ChatModel chatModel, EmbeddingModel embeddingModel) {
        this.driver = driver;
        this.chatModel = chatModel;
        this.embeddingModel = embeddingModel;
    }

    /** LangChain4j variant of the reader-intent refresh: summarise with the ChatModel, embed with the EmbeddingModel. */
    public float[] intentEmbedding(List<String> recentPageTitles) {
        String intent = chatModel.chat("In one sentence, describe what this reader is trying to achieve, based only on "
                + "these pages. No names, no personal data.\n" + String.join("\n", recentPageTitles));
        return embeddingModel.embed(intent).content().vector();
    }

    public List<Recommendation> recommend(String readerId, List<String> readableAcls, int limit) {
        return driver.executableQuery(RECOMMEND)
                .withParameters(Map.of("readerId", readerId, "readableAcls", readableAcls, "limit", limit,
                        "alpha", 0.5, "beta", 0.3, "gamma", 0.2))
                .execute().records().stream()
                .map(r -> new Recommendation(r.get("pageId").asString(), r.get("title").asString(),
                        r.get("score").asDouble()))
                .toList();
    }
}

import math
import os

from langchain.chat_models import init_chat_model
from langchain.embeddings import init_embeddings

summariser = init_chat_model(os.environ["CHAT_MODEL"], temperature=0)
embeddings = init_embeddings(os.environ["EMBEDDING_MODEL"])


def reader_intent(recent_titles: list[str]) -> tuple[str, list[float]]:
    intent = summariser.invoke(
        "In one sentence, describe what this reader is trying to achieve, based only on these pages. "
        "No names, no personal data.\n" + "\n".join(recent_titles)).text
    return intent, embeddings.embed_query(intent)


def cosine(a: list[float], b: list[float]) -> float:
    return sum(x * y for x, y in zip(a, b)) / (math.sqrt(sum(x * x for x in a)) * math.sqrt(sum(y * y for y in b)))


def blended_score(reader_vec, page_vec, knn_scores_from_read: list[float], page_community: int,
                  read_communities: set[int], alpha: float = 0.5, beta: float = 0.3, gamma: float = 0.2) -> float:
    intent = cosine(reader_vec, page_vec) if reader_vec else 0.0
    knn = max(knn_scores_from_read, default=0.0)
    community = 1.0 if page_community in read_communities else 0.0
    return alpha * intent + beta * knn + gamma * community