CORONA: A Coarse-to-Fine Framework for Graph-based Recommendation with Large Language Models

📝 Paper Summary

LLM-enhanced Recommendation Graph-based Recommendation

CORONA improves graph-based recommendation by using LLMs to reason about user preferences and intents, progressively filtering the candidate graph before final GNN scoring.

Core Problem

Existing methods limit LLMs to either re-ranking small candidate sets or static data augmentation, failing to utilize LLM reasoning capabilities during the critical candidate filtering process.

Why it matters:

Re-ranking methods are constrained by the quality of the initial candidate set generated by traditional models
Data augmentation methods cannot adapt to dynamically changing user intents during inference
Traditional GNNs struggle to capture semantic reasoning behind user choices, while LLMs struggle with large-scale collaborative filtering signals

Concrete Example: In current pipelines, if a traditional retriever misses 'French movies' for a user because of sparse interaction history, the LLM re-ranker never sees them. CORONA's LLM infers this preference from the profile ('User is from France') and actively retrieves relevant French movie subgraphs for the GNN to score.

Key Novelty

Coarse-to-Fine Retrieval Chain on Graphs

Decomposes retrieval into three progressive stages: Preference-Assisted (profile-based), Intent-Assisted (history-based), and GNN-Enhanced (collaborative signal-based)
Transforms LLM textual reasoning (about preferences/intents) into dense query embeddings to dynamically slice the interaction graph into relevant subgraphs
Summarizes retrieved subgraph information into natural language to guide the LLM's subsequent intent reasoning step

Architecture

The three-stage CORONA framework: Preference-assisted retrieval, Intent-assisted retrieval, and GNN-enhanced retrieval.

Evaluation Highlights

+18.6% relative improvement in Recall on average across three datasets compared to state-of-the-art baselines
+18.4% relative improvement in NDCG on average across three datasets
Significantly outperforms both traditional GNNs (LightGCN) and recent LLM-enhanced methods (LLMRec, RLMRec)

Breakthrough Assessment

7/10

Strong integration of LLM reasoning directly into the retrieval loop (subgraph construction) rather than just re-ranking. Significant metric gains, though the core components (LLMs, GNNs) are standard.

⚙️ Technical Details

Problem Definition

Setting: Top-N Recommendation on a user-item bipartite graph with textual attributes

Inputs: Interaction graph G=(U,V,A), user profiles P, item texts T, user interaction history L

Outputs: Ranked list of items v likely to be purchased next by target user u

Pipeline Flow

Stage 1: Preference-Assisted Retrieval (Profile → LLM → Subgraph)
Stage 2: Intent-Assisted Retrieval (History + Summary → LLM → Refined Subgraph)
Stage 3: GNN-Enhanced Retrieval (Refined Subgraph → GNN → Scores)

System Modules

Preference Reasoner (Stage 1: Preference Retrieval)

Infer general user preferences from static profiles to generate a search query

Model or implementation: LLM (Specific model not detailed in text, likely generic Instruction-tuned LLM)

Subgraph Retriever (Preference) (Stage 1: Preference Retrieval)

Select similar users based on LLM query to form an initial subgraph

Model or implementation: Distance-aware Attention Mechanism

Intent Reasoner (Stage 2: Intent Retrieval)

Infer specific short-term intent based on history and summary of previously retrieved items

Model or implementation: LLM

Subgraph Retriever (Intent) (Stage 2: Intent Retrieval)

Refine the subgraph by selecting users aligning with specific intent

Model or implementation: Distance-aware Attention Mechanism

Graph Encoder & Scorer

Capture collaborative signals on the refined subgraph to rank items

Model or implementation: GNN (e.g., LightGCN architecture)

Novel Architectural Elements

Three-stage cascade retrieval where LLM reasoning outputs (text) are converted to query embeddings to dynamically slice the graph
Distance-encoding attention mechanism that fuses graph topology (hop distance) with semantic similarity for retrieval
Feedback loop where statistical summaries of Stage 1 retrieval are fed back into Stage 2 LLM prompting

Modeling

Base Model: GNN backbone (implied LightGCN-like) + Unspecified LLM for reasoning

Training Method: Multi-task Optimization

Objective Functions:

Purpose: Train the subgraph retriever parameters to find users who interacted with the ground truth item.

Formally: Contrastive-like loss maximizing similarity between query E_Q and users N_v (neighbors of ground truth item v).
Purpose: Train the GNN to rank positive items higher than negatives.

Formally: BPR Loss L_BPR = sum(-ln(sigmoid(y_ui - y_uj)))

Compute: Not reported in the paper

Comparison to Prior Work

vs. Chat-REC/TALLRec: CORONA uses LLMs for candidate filtering/retrieval, not just re-ranking pre-selected sets
vs. LLMRec/RLMRec: CORONA employs dynamic inference-time reasoning for graph slicing, whereas augmentation methods are static pre-processing steps
vs. TIGER [not cited in paper]: TIGER quantizes items for generative retrieval; CORONA retains the graph structure and filters it via reasoning

Limitations

Reliance on LLM inference latency during the retrieval stages (multiple calls per user)
Performance depends on the quality of textual profiles and item descriptions available
Distance-encoding assumes locality (up to 2 hops) is sufficient, potentially missing serendipitous long-range connections

Reproducibility

Code: https://github.com/BUPT-GAMMA/CORONA

Code is publicly available at https://github.com/BUPT-GAMMA/CORONA. The paper provides prompt templates and mathematical formulations. Specific LLM model version (e.g., GPT-3.5, Llama-2) and hardware details are not explicitly listed in the provided text.

📊 Experiments & Results

Evaluation Setup

Top-N Recommendation on three datasets (likely MovieLens, Netflix, etc., implied by text)

Benchmarks:

Not explicitly named in text (Top-N Item Recommendation)

Metrics:

Recall
NDCG
Statistical methodology: Not explicitly reported in the paper

Key Results

Benchmark	Metric	Baseline	This Paper	Δ
Overall performance comparison showing significant improvements over baselines.
Average across 3 datasets	Recall	Not reported in the paper	Not reported in the paper	+18.6% (relative)
Average across 3 datasets	NDCG	Not reported in the paper	Not reported in the paper	+18.4% (relative)

Main Takeaways

Consistent double-digit relative improvements (+18.6% Recall) suggest that filtering the graph via LLM reasoning is superior to using the full noisy graph.
The coarse-to-fine strategy (Preference → Intent → GNN) effectively narrows the search space without losing relevant collaborative signals.
The approach effectively bridges semantic reasoning (LLMs) and signal propagation (GNNs) by using the former to construct the topology for the latter.

📚 Prerequisite Knowledge

Prerequisites

Graph Neural Networks (GNNs) for recommendation (e.g., LightGCN)
Collaborative Filtering principles
Large Language Models (LLMs) for reasoning and embedding generation

Key Terms

GNN: Graph Neural Network—a deep learning architecture that processes data represented as graphs to capture relationships between nodes (users and items)

Collaborative Filtering (CF): A recommendation technique that predicts user interests by collecting preferences from many users (e.g., 'users who bought X also bought Y')

Bipartite Graph: A graph where nodes are divided into two disjoint sets (users and items) and every edge connects a node in one set to one in the other

LightGCN: A simplified Graph Convolutional Network designed for recommendation that linearly propagates embeddings without non-linear activation functions

NDCG: Normalized Discounted Cumulative Gain—a measure of ranking quality that accounts for the position of relevant items in the recommendation list

Recall: The fraction of relevant items that are successfully retrieved by the system

BPR loss: Bayesian Personalized Ranking loss—an optimization objective that tries to rank observed (positive) items higher than unobserved (negative) items

Embedding: A dense vector representation of data (text, users, items) where similar items are closer in vector space

Zero-shot: The ability of a model to perform a task without having seen any specific training examples for that task

In-context learning (ICL): Prompting an LLM with examples or instructions within the input context to guide its output without updating model weights