Hybrid Graph Retrieval-Augmented Language Agents for Collaborative Recommendation

Abstract

Recent advances in large language model (LLM) agents have shown promise for autonomous decision-making in recommender systems. However, existing approaches suffer from two fundamental limitations: flat agent memories that conflate different information modalities and prohibitive computational costs that prevent scaling beyond a few hundred users. We propose Hybrid-GraphRAG, a recommender system that integrates hierarchical agent memory structures, graph-based retrieval-augmented generation (Graph RAG), and knowledge distillation for scalable deployment. Our approach extends agent-based collaborative filtering by structuring agent memories into intrinsic, collaborative, and interaction tiers that disentangle different information types; performing multi-hop retrieval over a dynamically constructed heterogeneous interaction graph to enable relational reasoning; and distilling LLM-generated memory dynamics into efficient graph neural encoders with adaptive gating between full and efficient inference paths. Experiments on Amazon review datasets (CDs and Vinyl, Office Products) demonstrate that Hybrid-GraphRAG achieves recommendation quality comparable to full LLM-based agents while reducing computational cost by 85% and improving NDCG@10 by 12.7% over flat-memory agent baselines. Our results establish a principled bridge between semantic agent reasoning and scalable graph-based recommendation.

1. Introduction

Recommender systems serve billions of personalized recommendations daily across e-commerce, content streaming, and social media platforms [1,2]. Traditional collaborative filtering approaches, including matrix factorization [3] and neural methods [4], learn implicit user and item representations from interaction data. More recently, graph-based recommenders such as LightGCN [5] and NGCF [6] have shown that explicitly modeling the user–item interaction graph improves representation learning through higher-order connections.

Concurrently, the emergence of large language models (LLMs) has sparked interest in employing autonomous agents for recommendation tasks [7,8,9,10]. These agents leverage the reasoning capabilities of LLMs to simulate user preferences and make personalized recommendations. AgentCF [11] was the first to propose treating both users and items as language agents with memory, using collaborative reflection to optimize agent memories through simulated interactions. However, this approach faces two critical limitations. First, agents maintain flat, monolithic text memories that mix intrinsic features with collaborative patterns, limiting the precision of memory updates. Second, the approach requires expensive LLM calls for every interaction and reflection step, restricting experiments to fewer than approximately ${10}^3$ [11].

In parallel, retrieval-augmented generation (RAG) has emerged as a powerful paradigm for grounding LLM outputs in external knowledge [12]. Graph RAG extends this to structured knowledge by retrieving from generated graph databases [13], enabling multi-hop relational reasoning. Recent work has begun exploring graph-enhanced recommendation with LLMs [14,15,16], but these studies primarily use graphs for prompting rather than as dynamic memory structures for agent optimization.

We propose Hybrid-GraphRAG, a unified pipeline that combines several methodological advances: hierarchical agent memory structures with intrinsic, collaborative, and interaction components that enable internal memory updates and component-specific optimization; graph retrieval-augmented generation over a heterogeneous interaction graph that extracts multi-hop reasoning paths; and component-disentangled knowledge distillation from LLM-generated memories into efficient graph neural encoders.

Our contributions are as follows:

• We formalize hierarchical agent memory for recommender systems and demonstrate that disentangling intrinsic, collaborative, and interaction features improves both recommendation quality and memory consistency.
• We design a Graph RAG mechanism for agent-based recommendation that performs multi-hop retrieval with metapath extraction, bridging semantic similarity and collaborative patterns.
• We propose a three-phase distillation pipeline that compresses expensive LLM-generated memory dynamics into efficient graph encoders, with adaptive gating that achieves an 85% cost reduction while maintaining quality.
• We conduct extensive experiments on two real-world datasets and demonstrate the effectiveness of Hybrid-GraphRAG, with particular benefits for cold-start recommendation and computational efficiency.

2. Related Works

2.1. Graph-Based Recommender Systems

Graph neural networks have significantly advanced collaborative filtering by explicitly modeling user–item interaction graphs. NGCF [6] introduced graph convolutional networks for recommendation. LightGCN [5] simplified the architecture by removing non-linear transformations. Subsequent work on self-supervised graph learning [17,18] improved robustness through contrastive objectives. However, these methods operate on learned embeddings and lack the semantic reasoning capabilities of large language models. Our proposed method uses more deep connections (for example, user–item–user and user–user) than KGAT [19]. RippleNet [2] uses Iterative Preference Propagation and Multi-hop Reading for recommendation. But, both KGAT and RippleNet build a static graph and do not change it during training, while our graph can evolve and include additional information related to dynamic memory trajectories. In recent work, the authors of K-RAGRec [20] use a GNN to encode graph structures into embeddings that the frozen LLM can understand as input prefixes, and they use an external knowledge base. The main advantage of our proposed method is that it uses a trained student GNN to replace the LLM in most cases, while K-RAGRec uses an external knowledge graph with the LLM all the time.

2.2. LLM-Powered Agents for Recommendation

Recent research has also explored LLMs as recommendation agents. RecAgent [8] simulated user behavior in a virtual environment, while Agent4Rec [21] introduced tool-use capabilities for recommendations. AgentCF [11] treated items as agents alongside users, using collaborative reflection for mutual memory optimization. Bian et al. [22] extended agent-based recommendation to multimodal settings. However, these approaches primarily use flat text memories and require LLM calls for all operations, limiting their scalability.

2.3. Knowledge Distillation for Recommendation

Knowledge distillation has been applied to recommendations for model compression [23] and cross-modal transfer [24]. LinguGKD explores an advanced GNN training paradigm with a layer-adaptive contrastive distillation strategy [25]. The method in [26] tackles the challenge of using LLMs on Text-Attributed Graphs (TAGs) where labeled data is scarce. But most of these works distill only static user and item representations, so LLM-generated semantic trajectory evolution into graph encoders remains underexplored. On the other hand, our proposed component-disentangled method distills dynamic memory evolution trajectories, which is the key novelty compared to prior works.

2.4. Hierarchical Memory Architectures

Hierarchical memory structures have been studied in reinforcement learning [27,28] and dialogue systems [29]. In recommendation, hierarchical representations have been used for user modeling [30], but not for agent memory design. Hierarchical user interest modeling is also used in DIEN (Deep Interest Evolution Network), which uses a GRU to model a user’s behavior sequence. Then, the algorithm emphasizes the interests most relevant to a specific target item using attention mechanisms (specifically AUGRU), allowing the model to follow a specific interest evolution track [31]. At the same time, MIMN (Multi-channel User Interest Memory Network) uses a Memory Induction Unit (MIU) that captures higher-order, evolving information from the memory network itself [32]. But without graphRAG reasoning, these methods struggle with recommendation explainability, and without an LLM, they struggle with cold-start users. Following the idea of hierarchical user interest modeling, Hybrid-graphRAG also uses different user memory levels, but applies this paradigm to LLM agent memory design instead of the model itself or its hidden representations. Also, these works do not utilize a Knowledge Graph to make collaborative filtering patterns. Our three-component structure—intrinsic, collaborative, and interaction memory—is specifically designed for the demands of collaborative agent optimization, balancing stability and adaptability.

3. Materials and Methods

3.1. Datasets and Preprocessing

We conduct experiments on three text-intensive subsets of the Amazon review dataset [33]: CDs and Vinyl; Office Products; and Books. Following AgentCF [11], we sample six subsets (dense and sparse variants of each of the three domains) to explore diverse interaction scenarios.

Table 1. Statistics of experimental datasets. “Avg. Words” indicates the average word count in the item description text.

Dataset	Users	Items	Interactions	Sparsity	Avg. Words
CDs-Sparse (sampled)	100	704	800	98.86%	7.76
CDs-Dense (sampled)	100	269	800	97.03%	8.47
Office-Sparse (sampled)	100	561	600	98.93%	25.06
Office-Dense (sampled)	100	188	600	96.81%	25.48
Books-Sparse (sampled)	100	1676	800	99.23%	92.13
Books-Dense (sampled)	100	650	800	98.77%	92.54
CDs-Full (Phase 1 only)	500	5234	12,847	99.51%	8.04
Office-Full (Phase 1 only)	500	3891	9562	99.49%	25.14
Books-Full (Phase 1 only)	500	8046	17,374	99.32%	92.33

summarizes the dataset statistics.

The Amazon CDs and Vinyl dataset and Office Products dataset have a fundamental limitation for LLM-based recommendation: a lack of semantic richness, which limits user-preference reasoning and undermines Graph RAG multi-hop reasoning. To address this issue, we also employed the Amazon Books dataset, which offers much more semantic richness.

Raw Data Schema. Each review contains the following: user_id (anonymized reviewer identifier), asin (product identifier), reviewText (full review text), overall (1–5 rating), summary (review title), and timestamp (Unix time). Product metadata includes title, description, and category (subset dependent). For each user, we aggregate all reviews and sort them by timestamp to form a chronological purchase sequence. Then, we apply a Purchase Sequence Analysis for Demographic Inference. Following the established methodology [34] that uses purchase history for multi-task prediction of demographic fields such as gender and age range, we employ an inference framework. For example, for a user with the following purchase sequence: “The Hobbit” (Books > Fantasy), “Dune” (Books > Science Fiction), “Foundation” (Books > Science Fiction), purchase sequence analysis yields “age-group”: “25–34”, “gender”: “male”, “occupation-category”: “technology”. So, in that case, the intrinsic memory becomes “I am a male user aged 25–34 working in technology. I consistently prefer science fiction and fantasy epics with complex world-building, as reflected in my purchases of Dune and Foundation.” This representation remains immutable throughout collaborative optimization, preserving the user’s core identity while allowing collaborative and interaction memories to adapt. For the bootstrap phase (Phase 1), we use larger subsets of 500 users to collect sufficient reflection traces for distillation. The hybrid inference evaluation uses the 100-user subsets to enable a fair comparison with baselines that cannot scale beyond this size. Figure 1 presents the overall architecture of Hybrid-GraphRAG, which comprises three sequential phases.

3.2. Hierarchical Agent Memory Design

Each user or item agent maintains three memory components:

Intrinsic Memory $M^{\mathrm{int}}$ captures immutable features of an agent. For item agents, $M_i^{\mathrm{int}}$ includes the title, category, and description text summarized by a LLM. For user agents, $M_u^{\mathrm{int}}$ captures demographic information and explicitly stated preference constraints.

Collaborative Memory $M^{\mathrm{col}}$ aggregates preference patterns from interactions. For item agents:  

$$M_i^{\mathrm{col}}={\mathrm{LLM}}_{\mathrm{fuse}}\left(M_i^{\mathrm{col}},\{M_u^{\mathrm{pref}}:u\in {\mathcal{N}}_{\mathrm{interact}}\left(i\right)\}\right)$$

(1)

Here, ${\mathcal{N}}_{\mathrm{interact}}\left(i\right)$ denotes the users connected via interaction edges in the graph; $M_u^{\mathrm{pref}}=LL{M}_{fuse-one-user}(M_u^{\mathrm{int}},M_u^{\mathrm{col}},M_u^{\mathrm{inter}})$, $\mathcal{G}$ and ${\mathrm{LLM}}_{\mathrm{fuse}}$ denote a large language model prompted to fuse collaborative text information from items and intrinsic memory from users who interacted with the item.

Interaction Memory $M^{\mathrm{inter}}$ buffers recent k interaction traces with explanations. Each new interaction, a new instance of $\{i^{+},y_{exp}\}$, is appended at the end of $M^{\mathrm{inter}}$.

3.3. Heterogeneous Graph Construction

We construct graph $G=(V_u\cup V_i,E_{ui}\cup {\mathcal{E}}_{uu}\cup E_{ii},R)$ with four edge types $R=\{\mathrm{interact},\text{similar\_pref},\text{co\_interact},\text{similar\_pref}\}$.

3.3.1. Relation Types

The edge set contains four categories of connections, further distinguished by relation types $R=\{r_{inter},r_{similar-pref},r_{co-inter},r_{content-sim}\}$:

User–Item Interaction Edges $E_{ui}\subseteq V_u\times V_i$ with relation type $r_{inter}$:

Each edge $(u,i)\in {\mathcal{E}}_{ui}$ represents a direct interaction between user agent u and item agent i, initialized from both real-world interaction records $\mathcal{D}$ and agent-simulated interactions during optimization. Each edge carries a weight $w_{u,i}\in [0,1]$ that indicates the strength or confidence of the association:

$$w_{u,i}^{(t+1)}=\left\{\begin{array}{cc}\min (1,w_{u,i}^{\left(t\right)}+\delta )\hfill & \mathrm{if}\mathrm{agent}\mathrm{decision}{i}^0=i^{+}(\mathrm{correct}\mathrm{interaction})\hfill \\ \max (0,w_{u,i}^{\left(t\right)}-\delta )\hfill & \mathrm{if}{i}^0\ne i^{+}\mathrm{for}3+\mathrm{consecutive}\mathrm{attempts}(\mathrm{persistent}\mathrm{mismatch})\hfill \\ w_{u,i}^{\left(t\right)}\hfill & \mathrm{otherwise}\hfill \end{array}\right.$$

(2)

Here, $\delta =0.1$ controls the update rate. Edges with $w_{u,i}<ϵ=0.05$ are pruned to maintain graph sparsity. These edges are bidirectional for retrieval purposes, treating user–item affinity symmetrically.

User–User Similarity Edges $E_{uu}\subseteq V_u\times V_u$ with relation type $r_{similar-pref}$:

These edges connect user agents with semantically similar preference profiles. Similarity is computed using cosine similarity between LLM-encoded preference embeddings:

$${\mathcal{E}}_{uu}=\{(u_a,u_b):\mathrm{cox}({\mathrm{\Phi }}_{\mathrm{text}}\left(M_{u_a}^{\mathrm{pref}}\right),{\mathrm{\Phi }}_{\mathrm{text}}\left(M_{u_b}^{\mathrm{pref}}\right))>{\tau }_u\}$$

(3)

The frozen LLM text encoder ${\mathrm{\Phi }}_{\mathrm{text}}:\mathrm{Text}\to {\mathbb{R}}^d$ (text-embedding-ada-002) maps text memory to a $d=1536$ dimensional embedding vector. We set ${\tau }_u=0.7$ as the minimum similarity threshold for edge creation, tuned on the validation set. Each edge weight is the cosine similarity score itself: $w_{u_a,u_b}=\mathrm{cox}(·,·)$. These edges enable the Graph RAG mechanism to discover collaborative neighborhoods: groups of users with similar tastes who can provide relevant item recommendations to one another. They are recomputed whenever $M_u^{\mathrm{pref}}$ changes by more than ${\theta }_{\mathrm{recompute}}=0.15$ in cosine distance.

User–User Co-interaction Edges $E_{uu}^{\mathrm{co}}\subseteq V_u\times V_u$ with relation type $r_{co-inter}$:

These edges capture implicit behavioral similarity through shared item interactions, independently of semantic preference similarity:

$$E_{uu}^{\mathrm{co}}=\{(u_a,u_b):|N_{\mathrm{interact}}\left(u_a\right)\cap N_{\mathrm{interact}}\left(u_b\right)|\ge \kappa \}$$

(4)

Here, ${\mathcal{N}}_{\mathrm{interact}}\left(u\right)=\{i\in {\mathcal{V}}_i:(u,i)\in {\mathcal{E}}_{ui}\}$ is the set of items with which user u has interacted and $\kappa =3$ is the minimum number of shared interactions to create a co-interaction edge (tuned on validation data). Edge weight is the Jaccard similarity: $w_{u_a,u_b}^{\mathrm{co}}={\displaystyle \frac{|N\left(u_a\right)\cap N\left(u_b\right)|}{|N\left(u_a\right)\cup N\left(u_b\right)|}}$.

This relation type captures the classic collaborative filtering signal: users who interact with similar items often have similar tastes, even when their explicitly stated preferences in $M^{\mathrm{pref}}$ differ. This signal is particularly valuable when preference descriptions are incomplete or when users have latent tastes they have not articulated.

Item–Item Content Similarity Edges ${\mathcal{E}}_{ii}\subseteq {\mathcal{V}}_i\times {\mathcal{V}}_i$ with relation type $r_{content-sim}$:

These edges connect item agents based on intrinsic feature similarity, computed from immutable intrinsic memories:

$$E_{ii}=\{(i_a,i_b):\mathrm{cox}({\mathrm{\Phi }}_{\mathrm{text}}\left(M_{i_a}^{\mathrm{int}}\right),{\mathrm{\Phi }}_{\mathrm{text}}\left(M_{i_b}^{\mathrm{int}}\right))>{\tau }_i\}$$

(5)

Here, $M_i^{\mathrm{int}}$ is the immutable intrinsic memory tier containing title, category, and description. We set ${\tau }_i=0.6$, a lower threshold than ${\tau }_u$, to allow more connections in the sparser item space. Edge weight equals the cosine similarity: $w_{i_a,i_b}=\mathrm{cox}(·,·)$.

These edges serve two critical functions: they enable collaborative memory propagation for cold-start items, allowing new items to estimate $M^{\mathrm{col}}$ by aggregating from similar, well-established items; and they support item–item analogy paths in Graph RAG retrieval ($i_{\mathrm{candidate}}\to i_{\mathrm{similar}}\to i_{\mathrm{history}}$), grounding recommendations in content similarity while incorporating collaborative signals.

3.3.2. Dynamic Graph Evolution

Unlike static graphs used in prior Graph RAG systems [13], our graph evolves continuously during agent optimization:

1.

Edge Weight Updates: Interaction edge weights $w_{u,i}$ are updated after each collaborative reflection based on decision correctness.

2.

Edge Pruning: Edges with weight below $ϵ$ are removed, preventing the graph from accumulating noise from outdated or incorrect interaction patterns.

3.

Similarity Edge Recomputation: User–user and item–item similarity edges are recomputed when the corresponding memory tier changes significantly, defined as a cosine distance greater than ${\theta }_{\mathrm{recompute}}$, ensuring the graph reflects current agent states.

4.

New Node Integration: When new user or item agents are introduced in Phase 3, they are connected to the graph through initial similarity edges computed from their intrinsic memories, enabling immediate participation in Graph RAG retrieval even without interaction history.

This dynamic nature is central to our approach: the graph is not merely an external knowledge base but a living structure that co-evolves with agent memories and encodes the current state of collaborative knowledge.

Similarity Edges: User–user edges connect agents with cosine similarity above ${\tau }_u$ between LLM-encoded preference memories. Item–item edges connect agents with intrinsic memory similarity above ${\tau }_i$:

$$E_{uu}=\{(u_a,u_b):\mathrm{cox}({\mathrm{\Phi }}_{\mathrm{text}}\left(M_{u_a}^{\mathrm{pref}}\right),{\mathrm{\Phi }}_{\mathrm{text}}\left(M_{u_b}^{\mathrm{pref}}\right))>{\tau }_u\}$$

(6)

Dynamic Updates: Edge weights evolve with interaction outcomes:

$$w_{u,i}^{(t+1)}=\left\{\begin{array}{cc}\min (1,w_{u,i}^{\left(t\right)}+\delta )\hfill & \mathrm{if}\mathrm{interaction}\mathrm{successful}\hfill \\ \max (0,w_{u,i}^{\left(t\right)}-\delta )\hfill & \mathrm{if}\mathrm{persistent}\mathrm{mismatch}\hfill \end{array}\right.$$

(7)

Edges with weight $<ϵ$ are pruned to maintain sparsity.

3.4. Multi-Hop Graph RAG Retrieval

Given query user u and candidate items $\{c_1,\dots ,c_n\}$, we extract a context subgraph:

$$C(u,k)=\{N^{\left(1\right)}\left(u\right),\dots ,N^{\left(k\right)}\left(u\right),P(u,k)\}$$

(8)

where $\mathcal{P}(u,k)$ contains metapaths of types:

• User–Item–User: $u\to i_{\mathrm{shared}}\to u_{\mathrm{similar}}$
• User–User–Item: $u\to u_{\mathrm{similar}}\to i_{\mathrm{candidate}}$
• Item–Item Analogy: $i_{\mathrm{candidate}}\to i_{\mathrm{similar}}\to i_{\mathrm{history}}$

These paths are verbalized and injected into the LLM prompt, enabling structured relational reasoning beyond semantic similarity (the prompt template for “Graph Verbalization” is provided in Appendix A.2). The meta-path extraction Algorithm A1 is provided in Appendix A.3.

3.5. Collaborative Reflection with Graph Context

In the Hybrid-GraphRAG framework, Collaborative Reflection is the central optimization mechanism for agent learning. Its fundamental goal is to enable both user agents and item agents to adjust their memory representations through autonomous interaction and decision feedback, thereby better aligning with real-world interaction records. Unlike traditional gradient descent optimization, this “optimization” is achieved through natural language reasoning—agents revise their preference understanding by reflecting on "why my decision differed from actual behavior." We used a similar sampling strategy to that of AgentCF [11], but with the help of graph retrieval. For each training interaction $\langle u,i^{+}\rangle$, we sample a hard negative $i^{-}$ from the graph-guided distribution. The reflection process updates memories based on decision correctness:

$${\mathbf{M}}_u^{\prime }\leftarrow {\mathrm{LLM}}_{\mathrm{reflect}}({\mathbf{M}}_u,i^0,y_{\exp },{\mathbf{M}}_{i^{+}},{\mathbf{M}}_{i^{-}},C(u,2))$$

(9)

Neighborhood propagation is triggered when the accumulated signal exceeds ${\theta }_{\mathrm{propagate}}$. The reflection process is triggered whenever a user agent makes an inconsistent decision. Specifically, for each training interaction pair $\{u,i^{+}\}$ (user u with positive item $i^{+}$), the system samples a hard negative item $i^{-}$ from a graph-guided distribution, then prompts the user agent to choose between two candidate items:

• If the agent selects the correct item ($i^{+}$), the interaction is recorded and the current memory is reinforced—no full reflection is triggered.
• If the agent selects the incorrect item ($i^{-}$), the complete collaborative reflection workflow is triggered, including both user-side and item-side reflection.

3.6. Component-Disentangled Knowledge Distillation

We train a heterogeneous graph neural network with component-specific projection heads:   

$${\widehat{\mathbf{h}}}_v^{\mathrm{int}}={\mathrm{Proj}}_{\mathrm{int}}\left(\mathrm{HGNN}\left(G\right)\left[v\right]\right)$$

(10)

$${\widehat{\mathbf{h}}}_v^{\mathrm{col}}={\mathrm{Proj}}_{\mathrm{col}}\left(\mathrm{HGNN}\left(G\right)\left[v\right]\right)$$

(11)

$${\widehat{\mathbf{h}}}_v^{\mathrm{inter}}={\mathrm{Proj}}_{\mathrm{inter}}\left(\mathrm{HGNN}\left(G\right)\left[v\right]\right)$$

(12)

The multi-objective distillation loss combines component-level alignment, path-importance preservation, contrastive separation, and reconstruction terms:

$${\mathcal{L}}_{\mathrm{total}}=\underset{{\mathcal{L}}_{\mathrm{component}}}{\underbrace{{\displaystyle \sum _{v,\mathrm{component}}}{\lambda }_{\mathrm{component}}{\parallel {\widehat{\mathbf{h}}}_v^{\mathrm{component}}-{\mathbf{h}}_v^{\mathrm{component}}\parallel }_2^2}}+\alpha \underset{L_{\mathrm{path}}}{\underbrace{\mathrm{KL}({\mathrm{Attn}}_{\mathrm{HGNN}}\parallel {\mathrm{Importance}}_{\mathrm{LLM}})}}$$

(13)

$$+\beta \underset{{\mathcal{L}}_{\mathrm{contrast}}}{\underbrace{(-{\displaystyle \sum _v}{\displaystyle \sum _{a\ne b}}\log {\displaystyle \frac{\exp (\mathrm{sim}({\widehat{\mathbf{h}}}_v^a,{\widehat{\mathbf{h}}}_v^b)/\tau )}{{\sum }_{w\ne v}\exp (\dots )}})}}+\gamma \underset{{\mathcal{L}}_{\mathrm{recon}}}{\underbrace{(-\sum _v\log P_{\mathrm{\Psi }}\left(M_v\right|{\widehat{\mathbf{h}}}_v))}}$$

(14)

3.7. Adaptive Gating for Hybrid Inference

The gating function routes each decision to either the GNN path or LLM path:

$$g\left(v\right)=\sigma ({\mathbf{w}}^T·[\mathrm{conf}\left(v\right),\mathrm{density}\left(v\right),\mathrm{crit}\left({\mathcal{C}}_{\mathrm{curr}}\right),\mathrm{staleness}\left(v\right)]+b)$$

(15)

Here, $\mathrm{conf}\left(v\right)=-H\left({\widehat{\mathbf{h}}}_v^{\mathrm{col}}\right)$: GNN prediction entropy; $\mathrm{density}\left(v\right)=1-{\displaystyle \frac{\left|\mathcal{N}\right(v\left)\right|}{{\max }_w\left|\mathcal{N}\left(w\right)\right|}}$ is the normalized graph degree, $\mathrm{crit}\left({\mathcal{C}}_{\mathrm{curr}}\right)$ = 1 for user-facing decisions and 0 for backend updates, and $\mathrm{staleness}\left(v\right)=1-\exp (-\lambda ∆t_v)$ measures the time since the last text refresh.

3.8. Evaluation Metrics

We use standard ranking metrics following prior work [4,11]: NDCG@K Normalized Discounted Cumulative Gain at K $\in \{1,5,10\}$, and Hit Rate at K. To measure cost efficiency, we report LLM call ratio: $\rho ={\displaystyle \frac{\text{\#LLM calls}}{\mathrm{Total}\mathrm{decisions}}}$, and cost reduction: ${\displaystyle \frac{{\mathrm{Cost}}_{\mathrm{full}\mathrm{LLM}}-{\mathrm{Cost}}_{\mathrm{hybrid}}}{{\mathrm{Cost}}_{\mathrm{full}\mathrm{LLM}}}}$.

Following the leave-one-out protocol [5], we evaluate by ranking each test item against 99 randomly sampled negatives and averaging over three repetitions with different random seeds.

3.9. Baseline Methods

We compare against the following methods.

Traditional Recommenders:

• BPR [35]: Bayesian Personalized Ranking with matrix factorization. It is an optimization framework for implicit feedback recommendation that optimizes for ranking instead of rating prediction. The implementation follows the standard matrix factorization approach with BPR-OPT loss. The number of features was set to 128, epochs to 100, learning rate to 0.01, and L2 regularization coefficient to 0.001.
• SASRec [36]: A transformer-based sequential recommendation model that captures long-range dependencies in user interaction sequences. Parameters were set as shown in

  Table 2. Hyperparameter configuration for the SASRec model.

  Parameter	Value	Description
  hidden_units	128	Dimensionality of self-attention layers
  num_blocks	2	Number of transformer blocks
  num_heads	2	Number of attention heads
  max_len	50	Maximum sequence length
  num_negatives	1	Number of negative samples per positive
  dropout	0.2	Dropout rate for regularization
  learning_rate	0.001	Adam optimizer learning rate
  epochs	200	Maximum training epochs (with early stopping)
  early_stopping_patience	5	Patience for early stopping on validation loss

  .
• LightGCN [5]: This method uses simplified graph convolution for recommendation by removing feature transformation and nonlinear activation, keeping only neighborhood aggregation. Hyperparameters were set as shown in

  Table 3. Hyperparameter configuration for the lightGCN model.

  Parameter	Value	Description
  embedding_dim/latent_dim	128	Embedding dimension
  num_layers	3	Number of graph convolution layers
  learning_rate	0.001	Adam optimizer learning rate
  batch_size	4096	Training batch size
  epochs	1000	Maximum training epochs (with early stopping)
  reg_weight	$1\times {10}^{-5}$	L2 regularization coefficient
  node_dropout	0.0	Dropout rate for nodes (disabled in LightGCN)
  message_dropout	0.0	Dropout rate for messages (disabled in LightGCN)

  .

LLM-Based Methods:

• LLMRank [37]: It investigates the capacity of large language models as zero-shot rankers for recommender systems, using an instruction-following paradigm. It used the model gpt-3.5-turbo-16k-0613, temperature = 0.2, maximum sequence length = 50, and 20 candidate items to rank. Items are represented by their descriptive text (title), candidate items are arranged sequentially in the prompt, output is parsed with heuristic text-matching (KMP algorithm), and results are averaged over three runs to reduce randomness.
• AgentCF [11]: It treats both users and items as autonomous language agents with memory, using collaborative reflection to optimize agent memories through simulated interactions. Training agent system parameters are presented in

  Table 4. Hyperparameter configuration for the LLM-based agent framework for 100-user experiments. Parameters for 1000-user experiments are shown in brackets.

  Parameter	Value	Description
  llm	GPT-3.5-turbo	Backbone LLM for agents
  temperature	0.7	Temperature for generation
  num_reflection_rounds	3	Rounds of collaborative reflection
  max_memory_length	180 words (120 words)	Maximum memory update length
  max_item_memory_length	50 words (40 words)	Max num of words in item’s memory
  neg_sample_strategy	Popularity-based	Strategy for negative item selection

  .

Graph-Enhanced LLM Methods:

• GraphPrompt [14]: This is a graph-based prompting method for recommendation with large language models that combines graph structure information with LLM reasoning. Launch parameters are presented in

  Table 5. Hyperparameter configuration for the GraphPrompt.

  Parameter	Value	Description
  graph_encoder	LightGCN	Graph neural network backbone
  embedding_dim	64	Graph embedding dimension
  graph_layers	2	Number of GNN layers
  llm	GPT-3.5-turbo	LLM for reasoning
  num_heads	4	Attention heads in graph encoder
  dropout	0.1	Dropout rate

  .

Our Variants:

• Hybrid-GraphRAG (LLM): Bootstrap phase only (LLM path, no distillation)
• Hybrid-GraphRAG (emb): Full distillation, GNN path only (no adaptive gating)
• Hybrid-GraphRAG (full): Full three-phase pipeline with adaptive gating.

3.10. Experiment Setup

We used the following models in our pipeline: GPT-3.5 (gpt-3.5-turbo-16k-0613) as the large language model for agent memory reflection and generation, with temperature equal to 0.7 for reflection and temperature equal to 0.0 for ranking; and text-embedding-ada-002 for embeddings (frozen) with max tokens equal to 1024 for memory generation and max tokens equal to 512 for ranking.

Phase 1 (Bootstrap)

• Iterations: 3 rounds of collaborative reflection.
• Per round: 10 interactions per user.
• Warm start: Initialize from 5 random interactions per user.

Phase 2 (Distillation)

• GNN training epochs: 200.
• Batch size: 256 users + 256 items.
• Learning rate: 1e-3 (Adam optimizer).
• Learning rate decay: 0.95 per 10 epochs.
• Early stopping: patience 20 epochs on validation.
• Loss weights (Equations (13) and (14)): ${\lambda }_{intrinsic=1.0},{\lambda }_{collaborative=1.0},{\lambda }_{interaction}=0.5,\alpha =0.3,\beta =0.3,\gamma =0.1$.
• Validation split: 20% of interactions held out.

Phase 3 (Hybrid Inference)

• Gate training: MLP with 1 hidden layer (64 units, ReLU).
• Gate training epochs: 100.
• Positive labels: decisions where the LLM path would be used (cold-start, user-facing, high-entropy).
• Negative labels: decisions where the GNN path is sufficient.
• Training examples: 5000 sampled decisions from Phase 1.

All experiments were conducted on a PC with the following specifications. Memory: 64GB RAM; GPU: NVIDIA RTX Titan (24GB) × 1; and estimated total runtime: 72 h for the full experimental suite.

4. Results

4.1. Overall Recommendation Performance

Table 6. Recommendation performance comparison. The best results are shown in bold and the second-best results are underlined in the final typeset version.

Method	CDs-Dense			Office-Dense
	N@1	N@5	N@10	N@1	N@5	N@10
BPR	$0.1300\pm 0.011$	$0.3485\pm 0.008$	$0.4812\pm 0.004$	$0.1200\pm 0.008$	$0.2705\pm 0.007$	$0.4576\pm 0.010$
SASRec	$0.1300\pm 0.010$	$0.3151\pm 0.006$	$0.4676\pm 0.005$	$0.3600\pm 0.009$	$0.5027\pm 0.006$	$0.6137\pm 0.005$
LightGCN	$0.2100\pm 0.010$	$0.4120\pm 0.007$	$0.5389\pm 0.002$	$0.3100\pm 0.008$	$0.4812\pm 0.005$	$0.5890\pm 0.004$
LLMRank	$0.1333\pm 0.009$	$0.3689\pm 0.003$	$0.4946\pm 0.005$	$0.2067\pm 0.008$	$0.3881\pm 0.006$	$0.4928\pm 0.005$
GraphPrompt	$0.1867\pm 0.011$	$0.4012\pm 0.006$	$0.5278\pm 0.005$	$0.2233\pm 0.012$	$0.4145\pm 0.008$	$0.5217\pm 0.007$
AgentCF	$0.2067\pm 0.007$	$0.4078\pm 0.006$	$0.5328\pm 0.003$	$0.2067\pm 0.008$	$0.4217\pm 0.004$	$0.5335\pm 0.003$
Hybrid-GraphRAG(LLM)	$\underline{0.2433}\pm 0.007$	$\underline{0.4489}\pm 0.005$	$\underline{0.5678}\pm 0.004$	$\underline{0.2367}\pm 0.008$	$\underline{0.4512}\pm 0.004$	$\underline{0.5641}\pm 0.002$
Hybrid-GraphRAG(emb)	$0.2267\pm 0.008$	$0.4312\pm 0.006$	$0.5512\pm 0.003$	$0.2189\pm 0.010$	$0.4398\pm 0.008$	$0.5513\pm 0.002$
Hybrid-GraphRAG(full)	$\mathbf{0.2567}\pm 0.005$	$\mathbf{0.462}\pm 0.005$	$\mathbf{0.5801}\pm 0.003$	$\mathbf{0.2489}\pm 0.008$	$\mathbf{0.4623}\pm 0.005$	$\mathbf{0.5768}\pm 0.003$

presents the overall recommendation performance across all datasets.

The hybrid architecture consistently outperforms both traditional recommenders and LLM-based baselines. Notably, the full LLM-based GraphRAG-Base achieves substantial improvements over flat-memory AgentCF (+6.5% NDCG@10 on CDs-Dense), validating the benefits of hierarchical memory and graph retrieval. The GNN-only variant, GraphRAG-Emb, incurs a slight degradation (−2.9% from the LLM version) but significantly reduces computational cost. Most importantly, the hybrid variant with adaptive gating matches or exceeds full LLM performance while using only 14.7% of LLM calls on average.

Following the same experimental settings as in the format and evaluation protocol shown in Table 6, we also evaluate the model on the Amazon Books dataset. The results are shown in

Table 7. Recommendation performance on Amazon Books dense dataset comparison. The best results are shown in bold and the second-best results are underlined.

Method	NDCG@1	NDCG@5	NDCG@10
SASRec	0.0567	0.0899	0.1021
LLMRank	0.0385	0.0811	0.1123
AgentCF	0.0854	0.1125	0.1543
Hybrid-GraphRAG-Base(LLM only)	0.2564	0.4659	0.5793
Hybrid-GraphRAG-Emb(GNN only)	0.2593	0.4965	0.5952
Hybrid-GraphRAG-Hybrid	0.2651	0.5146	0.6075

.

Results on the Amazon Books dataset show that Hybrid-GraphRAG-Hybrid improves over AgentCF, SASRec, and LLMRank on Books, while exceeding the original CDs-Dense results (+7.7% and +11.2%, respectively). Amazon book attributes (author, genre, series, themes, and reading level) enable the intrinsic–collaborative–interaction memory tiers to capture fundamentally different information modalities, allowing the Graph RAG multi-hop retrieval mechanism to achieve its full potential. We additionally evaluate Hybrid-GraphRAG on 1000-user subsets.

Table 8. Recommendation performance on 1000-user subsets. NDCG@10 values, with standard deviations, are reported for LightGCN, AgentCF, and three variants of our pipeline.

Method	CDs-Dense (1K)	Office-Dense (1K)
LightGCN	$0.5213\pm 0.006$	$0.5621\pm 0.004$
AgentCF	$0.4016\pm 0.017$	$0.4154\pm 0.014$
Hybrid-GraphRAG-Base	$0.4197\pm 0.009$	$0.4429\pm 0.010$
Hybrid-GraphRAG-Emb	$0.5487\pm 0.004$	$0.5734\pm 0.002$
Hybrid-GraphRAG-Hybrid	$0.5623\pm 0.002$	$0.5845\pm 0.003$

presents the results for the extended scale.

Since we reduced AgentCF Short-term Memory Length and used a reduced total summarization word length, its performance becomes consistently lower than on 100-user sets. The proposed Hybrid-GraphRAG shows superior performance compared to its counterparts LightGCN and AgentCF.

4.2. Computational Efficiency Analysis

Figure 2 compares recommendation quality against computational cost across methods.

The adaptive gating mechanism routes 85.3% of decisions through the efficient GNN path while reserving LLM calls for cold-start agents (19.2% of decisions), user-facing explanation requests (31.5%), and high-entropy predictions (49.3%). This selective LLM usage pattern aligns with our design goal: invest computation where it matters most. We report statistical significance:

• Hybrid-GraphRAG-Hybrid vs. LightGCN: t = 6.23, p < 0.01 (CDs-Dense).
• Hybrid-GraphRAG-Hybrid vs. AgentCF: t = 5.87, p < 0.01 (CDs-Dense).

All reported improvements are statistically significant (<0.05) across datasets, with the exception of Hybrid-GraphRAG-Hybrid vs. Hybrid-GraphRAG-Base on Office-Sparse (p = 0.08, not significant).

4.3. Ablation Study

Table 9. Ablation study on CDs-Dense with 95 % confidence intervals. $∆$ indicates a change from the full GraphRAG-Hybrid model.

Variant	NDCG@10	$\mathbf{\Delta }$	95% CI	LLM Calls
Hybrid-GraphRAG (full)	0.5801	–	[0.5776, 0.5826]	124.6
- Hierarchical Memory	0.5518	−4.9%	[0.5482, 0.5554]	118.9
- Graph RAG	0.5432	−6.4%	[0.5397, 0.5467]	98.3
- Multi-hop paths	0.5612	−3.3%	[0.5581, 0.5643]	130.1
- Contrastive loss	0.5714	−1.5%	[0.5683, 0.5745]	125.2
- Path importance	0.5681	−2.1%	[0.5650, 0.5712]	124.8
- Adaptive gate	0.5653	−2.6%	[0.5622, 0.5684]	122.4

decomposes the contribution of each component on CDs-Dense.

The ablation study confirms that each component contributes positively. The largest impact come from Graph RAG retrieval, which causes a 6.4% drop when removed. The hierarchical memory structure causes the second-largest impact value—a 4.9% drop when flattened. The flat baseline was allocated the same total word budget as the hierarchical variant (intrinsic + collaborative + interaction tiers combined), with content formatted as a single concatenated text block rather than being separated into structured components. With this, we ensure a fair comparison of hierarchical and flat memory design. These results validate our core design choices. The path-importance loss and contrastive loss provide smaller but complementary gains, primarily by improving the quality of the distilled embeddings.

4.4. Cold-Start Performance

A key advantage of hierarchical memory with graph propagation is improved cold-start handling.

Table 10. Cold-start performance by item interaction frequency. The best results are shown in bold.

Method	<5 Interactions		≥10 Interactions
	NDCG@10	HR@10	NDCG@10	HR@10
LightGCN	0.2145	0.3124	0.5678	0.7134
AgentCF	0.2789	0.3845	0.5234	0.6845
Hybrid-GraphRAG(LLM only)	0.3156	0.4321	0.5512	0.7023
Hybrid-GraphRAG(full)	0.3301	0.4512	0.5745	0.7222
Improvement over AgentCF	+18.3%	+17.3%	+9.8%	+5.5%

evaluates recommendation quality stratified by item interaction count.

The hierarchical memory structure with graph-based collaborative propagation shows particular benefits for cold-start items (+18.3% over AgentCF), where intrinsic-to-collaborative memory transfer via item–item similarity edges compensates for limited interaction history. This is a direct consequence of our design: collaborative memory can be warmed up through content-based graph edges before sufficient interactions accumulate.

4.5. Memory Consistency Analysis

We evaluate whether hierarchical memory prevents the identity drift observed in flat-memory agents. We measure semantic similarity between initial and post-optimization intrinsic memories and report the results in Figure 3:

Hierarchical memory maintains significantly higher consistency (0.901 vs. 0.651 at step 50) by protecting the intrinsic component from collaborative updates, thereby preventing the identity drift that occurs when all memory content is subject to reflection-based modification.

4.6. Sensitivity to Gate Threshold

Figure 4 shows the quality–efficiency frontier as we vary the gating threshold $\eta$.

The default threshold $\eta =0.3$ achieves an optimal balance, capturing 97% of full LLM quality while reducing costs by 82.6%. More aggressive thresholds, such as 0.1, noticeably degrade quality, while more conservative thresholds of 0.5 or higher yield diminishing returns.

5. Discussion

The experimental results provide strong evidence for the effectiveness of our three-phase hybrid architecture. Several findings merit deeper discussion.

Hierarchical memory structure is critical for quality and consistency. The 4.9% performance drop when the memory hierarchy is flattened, combined with the 38.4% relative improvement in memory consistency, confirms our hypothesis that disentangling intrinsic, collaborative, and interaction information is essential for stable agent optimization. This finding aligns with work in continual learning [28], where structured memory prevents catastrophic forgetting, but our work is the first to demonstrate this principle in the context of agent-based collaborative filtering.

Graph RAG enables relational reasoning beyond semantic similarity. The 6.4% improvement from multi-hop graph retrieval over flat context demonstrates that collaborative patterns, such as users who like X also like Y, are not easily captured by semantic similarity alone. This supports the argument that Graph RAG bridges a fundamental gap between language-model semantic knowledge and collaborative filtering behavior patterns [11]. The metapath extraction mechanism makes this relational reasoning explicit, a capability absent from prior LLM-based recommenders.

Knowledge distillation achieves remarkable efficiency without quality degradation. The hybrid variant matches full LLM quality at 14.7% of the computational cost, demonstrating that LLM-generated semantic dynamics can be effectively compressed into graph neural encoders. This is a significant finding for practical deployment because it addresses the scalability barrier that has limited agent-based recommenders to academic demonstrations on small datasets. The adaptive gating mechanism is key: by learning when full reasoning is needed, such as for cold-start or high-uncertainty cases, and when efficient processing is sufficient, such as for warm agents and routine decisions, the system achieves the best of both paradigms.

Cold-start benefits emerge from graph-based memory propagation. The 18.3% improvement for items with fewer than five interactions validates our design for collaborative memory propagation. By enabling items with limited interaction history to inherit collaborative patterns from similar items via intrinsic-to-collaborative memory transfer, we address a fundamental limitation of standard collaborative filtering, which cannot leverage collaborative signals for items without interactions. This capability is uniquely enabled by the combination of hierarchical memory, which separates intrinsic and collaborative components, and graph structure, which provides similarity edges for propagation.

6. Conclusions

This paper presented Hybrid-GraphRAG, a three-phase framework that advances the state of the art in language agent-based recommender systems through the synergistic integration of hierarchical agent memory, graph retrieval-augmented generation, and knowledge distillation for scalable deployment. Our work makes the following contributions.

Methodological Innovation. We formalized hierarchical agent memory for collaborative recommendation, introducing a three-component structure—intrinsic, collaborative, and interaction memory—that disentangles different information modalities and enables targeted memory updates while preserving agent identity. We designed a Graph RAG mechanism with multi-hop metapath extraction that bridges the gap between semantic reasoning and collaborative filtering patterns, making relational structures explicit and promptable. We also proposed a component-disentangled distillation pipeline that compresses expensive LLM-generated memory dynamics into efficient graph neural encoders, with adaptive gating that intelligently routes decisions between semantic and efficient processing paths.

Empirical Validation. Comprehensive experiments on two real-world datasets demonstrated that Hybrid-GraphRAG achieves state-of-the-art recommendation quality, improving NDCG@10 by 12.7% over flat-memory agent baselines and by 7.7% over the strongest graph-based recommendation baseline. The hybrid architecture with adaptive gating matches the quality of full LLM-based inference while reducing computational cost by 85%, addressing the scalability barrier that has limited agent-based recommenders to small-scale demonstrations. The hierarchical memory structure proved particularly beneficial for cold-start recommendation, achieving an 18.3% improvement for items with limited interaction history through graph-based collaborative memory propagation.

Design Principles. Beyond the specific architecture, our work establishes several design principles for scalable language-agent systems: (1) structured, disentangled memory representations prevent the identity drift that degrades flat-memory agents during extended optimization; (2) multi-hop graph retrieval enables relational reasoning that semantic similarity alone cannot capture; (3) learned adaptive gating between full and efficient inference paths achieves superior quality-cost trade-offs compared with uniform allocation; and (4) component-disentangled distillation preserves structural properties of semantic representations in compressed form.

These contributions establish a principled bridge between semantic agent reasoning and scalable graph-based recommendation. By demonstrating that language-agent capabilities can be made computationally practical without sacrificing quality, our work opens a path toward deploying semantically rich, explainable agent-based recommenders at production scale.

7. Future Work

Looking forward, several promising research directions remain unexplored. The framework can be extended to multi-modal settings, temporal dynamics, and federated deployment scenarios. It is conceptually straightforward but requires empirical validation. Temporal dynamics and continuous learning present both challenges and opportunities for more realistic recommendation scenarios. Federated deployment would require careful privacy-preserving mechanisms for sharing collaborative memory. Finally, while our architecture supports explanation generation through the LLM reflection process, formal evaluation of explanation quality with user studies remains an open problem. We consider these directions as the natural next steps for realizing production-scale, semantically rich agent-based recommenders.