MemRec: Collaborative Memory-Augmented Agentic Recommender System

1. Problem Statement

The paper addresses a critical limitation in the evolution of Agentic Recommender Systems (RS) powered by Large Language Models (LLMs). While modern agentic RS have moved from traditional collaborative filtering to semantic memory (using LLMs to reason over user/item narratives), they predominantly operate in isolation.

• The Gap: Existing agents maintain "siloed" memories (e.g., a user's personal history or an item's static description) without leveraging collaborative signals (user-item co-engagements, peer relationships, and community trends).
• The Consequence: This isolation limits the system's ability to uncover hidden preferences, particularly for data-sparse users (cold-start scenarios) who lack sufficient personal interaction history.
• The Challenge: Naively injecting raw collaborative data (e.g., concatenating all neighbor histories) into an agent's context causes two major issues:
  1. Cognitive Overload: The reasoning LLM is bombarded with noise and excessive context, leading to hallucinations and poor instruction adherence.
  2. Prohibitive Computational Costs: Dynamically updating the memory graph for every interaction requires redundant, independent LLM calls for every neighbor, creating an intractable bottleneck for real-time serving.

2. Methodology: The MemRec Framework

MemRec proposes a paradigm shift from isolated memory to Collaborative Memory, architecturally decoupling memory management from reasoning to solve the overload and cost issues. The framework consists of three core components:

A. Architectural Decoupling

MemRec separates the system into two distinct LLM roles:

1. LMMem (Memory Manager): A lightweight, dedicated language model responsible for managing the dynamic collaborative memory graph. It handles graph updates, curation, and synthesis.
2. LLMRec (Reasoning Core): A heavyweight language model responsible for the final recommendation and ranking. It receives only distilled, high-signal context from LMMem.

B. The Three-Stage Pipeline

1. Collaborative Memory Retrieval (Stage-R):

   • LLM-Guided Context Curation: Instead of using fixed heuristics or expensive neural scorers, MemRec uses a zero-shot LLM-as-Rule-Generator. LMMem analyzes domain statistics offline to generate specific, interpretable rules (e.g., "boost content similarity for books," "prioritize recency for movies") to prune the neighbor graph.
   • Collaborative Memory Synthesis: LMMem synthesizes the curated neighbors into a compact, structured format called Collaborative Memory ($M_{collab}$). It extracts "preference facets" (themes, confidence scores, and supporting evidence) rather than raw text, effectively acting as an Information Bottleneck to filter noise.

2. Grounded Reasoning (Stage-ReRank):

   • The reasoning agent (LLMRec) receives the user instruction, candidate items, and the synthesized $M_{collab}$.
   • It performs the ranking task, generating relevance scores and natural language rationales grounded in the community evidence provided by $M_{collab}$.

3. Asynchronous Collaborative Propagation (Stage-W):

   • To handle graph evolution without blocking online inference, MemRec uses an Asynchronous mechanism inspired by Label Propagation.
   • When a user interacts with an item, LMMem performs a single batched operation to update the user's memory, the item's memory, and propagate insights to relevant neighbors.
   • This achieves $O(1)$ interaction complexity per user interaction, avoiding the linear scaling ($O(|N|)$) of naive synchronous updates.

3. Key Contributions

• Collaborative Memory Paradigm: Introduces the concept of connecting isolated semantic memories via a dynamic graph to transfer collaborative knowledge, addressing the data sparsity problem in agentic RS.
• Architectural Decoupling: Proposes a novel separation of memory management (LMMem) and reasoning (LLMRec). This solves the "cognitive overload" problem by ensuring the reasoning agent only sees distilled, high-signal contexts.
• Zero-Shot LLM Curation: Replaces traditional graph pruning heuristics with an LLM-generated, domain-adaptive rule system that filters noise more effectively without training data.
• Asynchronous Propagation: Solves the computational bottleneck of dynamic graph updates by batching self-reflection and neighbor propagation into a single asynchronous operation, enabling real-time scalability.

4. Experimental Results

The authors evaluated MemRec on four diverse benchmarks: Amazon Books, Goodreads, MovieTV, and Yelp.

• Performance: MemRec achieved State-of-the-Art (SOTA) performance across all datasets.
  • On Goodreads, it improved Hit@1 by +28.98% over the strongest baseline (i2Agent).
  • On Yelp, it showed significant gains (+15.77% Hit@1), proving its ability to capture broad community signals.
• Ablation Studies:
  • Removing collaborative retrieval caused a 9.9% drop in performance, validating the necessity of global graph signals.
  • Replacing LLM-guided curation with generic rules caused a 5.5% drop, highlighting the importance of domain-adaptive filtering.
• Robustness: MemRec showed massive gains for data-sparse (niche) users, improving Hit@1 by +91.4% over Vanilla LLMs for low-activity users. It also demonstrated high robustness against noise injection (fake items).
• Efficiency: The framework establishes a superior Pareto frontier, balancing high reasoning quality with low online inference costs. By offloading heavy graph processing to asynchronous offline batches, it maintains sub-second online latency.

5. Significance

MemRec represents a significant advancement in Agentic Recommender Systems by bridging the gap between the robustness of traditional Collaborative Filtering (leveraging community signals) and the reasoning capabilities of LLMs (semantic understanding).

• It solves the fundamental scalability issue of integrating LLMs with dynamic knowledge graphs.
• It provides a practical solution for cold-start problems, democratizing recommendation quality for users with sparse histories.
• The framework is flexible, supporting diverse deployment scenarios from cloud-native APIs to on-premise local models, making it a viable architecture for next-generation recommendation engines.