Paper deep dive
RankGraph-2: Lifecycle Co-Design for Billion-Node Graph Learning in Recommendation
Renzhi Wu, Zikun Cui, Junjie Yang, Tai Guo, Hong Li, Xian Chen, Li Yu, Ke Pan, Sri Reddy, Mahesh Srinivasan, Nipun Mathur, Haomin Yu, Hong Yan
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 98%
Last extracted: 6/21/2026, 2:22:52 AM
Summary
RankGraph-2 is a lifecycle co-design framework developed by Meta for billion-node scale graph-based retrieval in recommendation systems. It addresses the coupling between graph construction, representation learning, and real-time serving. The framework utilizes a three-stage approach: (1) Graph Construction, which uses edge subsampling with popularity bias correction and pre-computed multi-hop neighborhoods via Personalized PageRank (PPR) to create self-contained, edge-centric data; (2) Model Training, which performs inductive learning on standard ML infrastructure and co-learns a residual-quantization cluster index; and (3) Real-time Serving, which replaces expensive online KNN with the co-learned cluster index. This co-design achieves significant performance gains, including 3.8x higher recall than GAT + Deep Graph Infomax and 2.1x higher than PyTorch-BigGraph, while reducing serving infrastructure costs by 83%.
Entities (8)
Relation Signals (5)
RankGraph-2 â colearns â Residual-Quantization Cluster Index
confidence 100% ¡ co-learns a residual-quantization cluster index
RankGraph-2 â deployedat â Meta
confidence 100% ¡ a framework deployed at Meta
RankGraph-2 â outperforms â GAT + Deep Graph Infomax
confidence 100% ¡ achieve 3.8 x higher recall than a GAT + Deep Graph Infomax model
RankGraph-2 â outperforms â PyTorch-BigGraph
confidence 100% ¡ 2.1 x higher than PyTorch-BigGraph on item retrieval
RankGraph-2 â uses â Personalized PageRank
confidence 100% ¡ pre-computes multi-hop neighborhoods via personalized PageRank
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Graph-based retrieval at billion-node scale requires jointly solving three tightly coupled problems -- graph construction, representation learning, and real-time serving -- yet existing work addresses each in isolation. We present RankGraph-2, a framework deployed at Meta that co-designs all three lifecycle stages for similarity-based retrieval (U2U2I and U2I2I), where each stage's requirements shape the others. Serving requires a co-learned cluster index to avoid expensive online KNN -- this pushes index co-training into the training objective. Training benefits from the observation that similarity-based retrieval tolerates pre-computed neighborhoods, eliminating online graph infrastructure -- this requires construction to produce self-contained data. Construction must also support hour-level refresh for item coverage. Acting on these cascading requirements, RankGraph-2 reduces hundreds of trillions of edges to hundreds of billions via subsampling with popularity bias correction, pre-computes multi-hop neighborhoods via personalized PageRank, and co-learns a residual-quantization cluster index that reduces serving computational cost by 83%. This lifecycle co-design enables a simple architecture to achieve 3.8 x higher recall than a GAT + Deep Graph Infomax model on a bipartite graph and 2.1 x higher than PyTorch-BigGraph on item retrieval. RankGraph-2 delivers up to +0.96% CTR and +2.75% CVR, and has powered 20+ retrieval launches across major surfaces.
Tags
Links
- Source: https://arxiv.org/abs/2606.18379v1
- Canonical: https://arxiv.org/abs/2606.18379v1
Trouble viewing inline? Open PDF directly â
Full Text
53,987 characters extracted from source content.
Expand or collapse full text
RankGraph-2: Lifecycle Co-Design for Billion-Node Graph Learning in Recommendation Renzhi Wu 1 , Zikun Cui 1 , Junjie Yang 1 , Tai Guo 1 , Hong Li 1 , Xian Chen 1 , Li Yu 1 , Ke Pan 1 , Sri Reddy 1 , Mahesh Srinivasan 1 , Nipun Mathur 1 , Haomin Yu 1 , Hong Yan 1 1 Meta Platforms Graph-based retrieval at billion-node scale requires jointly solving three tightly coupled problemsâ graph construction, representation learning, and real-time servingâyet existing work addresses each in isolation. We present RankGraph-2, a framework deployed at Meta that co-designs all three lifecycle stages for similarity-based retrieval (U2U2I and U2I2I), where each stageâs requirements shape the others. Serving requires a co-learned cluster index to avoid expensive online KNNâthis pushes index co-training into the training objective. Training benefits from the observation that similarity-based retrieval tolerates pre-computed neighborhoods, eliminating online graph infrastructureâthis requires construction to produce self-contained data. Construction must also support hour-level refresh for item coverage. Acting on these cascading requirements, RankGraph-2 reduces hundreds of trillions of edges to hundreds of billions via subsampling with popularity bias correction, pre-computes multi-hop neighborhoods via personalized PageRank, and co-learns a residual-quantization cluster index that reduces serving computational cost by 83%. This lifecycle co-design enables a simple architecture to achieve 3.8Ăhigher recall than a GAT + Deep Graph Infomax model on a bipartite graph and 2.1Ăhigher than PyTorch-BigGraph on item retrieval. RankGraph-2 delivers up to +0.96% CTR and +2.75% CVR, and has powered 20+ retrieval launches across major surfaces. Date: June 18, 2026 Correspondence: Renzhi Wu at renzhiwu@meta.com Keywords: Recommendation system, graph learning, graph neural network 1 Introduction Graph-based retrievalâusing learned embeddings on user-item graphs for candidate generationâis a criti- cal component of modern recommendation systems. Deploying graph neural networks (GNNs) for this purpose at billion-node scale requires solving three tightly coupled problems: constructing the graph, learning representations on it, and serving those rep- resentations in real time. These three stages form a lifecycle, and a bottleneck in any one stage limits the entire system. Yet existing work overwhelmingly fo- cuses on a single stage in isolation. Academic GNN re- search optimizes model architectures on small, static graphs (Zhang et al., 2019; Chen et al., 2023; He et al., 2020). Industrial systems such as GiGL (Zhao et al., 2025), LiGNN (Borisyuk et al., 2024), and GraphScale (Gupta et al., 2024) advance training infrastructure but assume the input graph is given and do not address serving cost. Neither commu- nity has systematically addressed the question: how should graph construction, training, and serving be co-designed when the graph has billions of nodes and hundreds of trillions of potential edges? This gap matters for retrieval in practice. At Meta, naively constructing the full co-engagement graph is infeasible; naively training on it requires expensive online graph infrastructure; and naively serving the resulting embeddings via online KNN requires thou- sands of machines. Each stage imposes requirements on the others: graph construction determines what signals training can learn from, the training objec- tive determines what the embeddings capture, and serving cost determines whether the system can be deployed at all. Optimizing any one stage without considering the others leads to suboptimal outcomes. We present RankGraph-2, a unified framework built on the principle that lifecycle co-designâletting each stageâs requirements shape the othersâunlocks per- formance that optimizing stages independently can- not achieve. RankGraph-2 builds upon our original RankGraph system (Wu et al., 2025) and achieves 3.8Ăhigher recall than a GAT + Deep Graph In- fomax model (Velickovic et al., 2018, 2019) on a bipartite graph, and 2.1Ăhigher than PyTorch- 1 arXiv:2606.18379v1 [cs.IR] 16 Jun 2026 BigGraph (Lerer et al., 2019) on item retrieval, with a simpler architecture (Section 5). We focus on similarity-based retrievalâU2U2I (user-to-user-to- item) and U2I2I (user-to-item-to-item)âwhere we empirically find graph-based embeddings are most effective, since these retrievals rely on structural sim- ilarity rather than the real-time behavioral features that dominate direct user-to-item matching. Below, we trace how each lifecycle stage creates requirements that cascade to the others, and how co-design resolves them (Figure 1): (1) Serving: from online KNN to cluster-based re- trieval. For U2U2I, we empirically find that constrain- ing the candidate pool to recently active users (e.g., past 15 minutes) yields the best quality. Online KNN over this constantly changing pool is prohibitively expensive at our traffic scale. Pre-computed static KNN mappings are also insufficient, since the ac- tive user set changes every few minutes. We instead adopt a cluster-based approach: each user is assigned a cluster, and each cluster maintains a queue of items from its recently active members. At serving time, U2U2I reduces to reading the latest items from the target userâs cluster queueâfar cheaper than KNN. However, a naĂŻvely learned index degrades retrieval quality; the index must be co-optimized with the embedding objective to match KNN accuracy. This requires training to co-learn the index. Additionally, while the structural similarity signals that drive U2U and I2I retrieval are relatively stable, fresh item cover- age remains importantârequiring graph construction to support hour-level refresh. (2) Training: co-learning for serving, graph-infra-free by design. Training addresses two cascading require- ments. First, it co-learns a residual-quantization clus- ter index alongside the embeddings, so the model di- rectly optimizes for serving quality rather than relying on post-hoc quantization. Second, we observe that for similarity-based retrieval, the structural signals that drive U2U and I2I similarity are less time-sensitive than those used in CTR prediction, enabling us to move neighborhood computation offline. This not only eliminates online graph infrastructureâno graph storage, no distributed sampling engines (Gupta et al., 2024; Zheng et al., 2022; Zhao et al., 2025)âbut actu- ally enables higher-quality neighborhoods: offline, we can run multi-hop PPR over the full graph and ap- ply popularity bias correction, operations that would be infeasible under online latency constraints. This in turn requires graph construction to provide high- quality pre-computed neighbors in a self-contained format. (3) Graph construction: satisfying both downstream stages. Construction receives requirements from both training (high-quality self-contained edge-centric data with pre-computed neighborhoods) and serving (hour- level refresh for item coverage). At Meta, the raw co-engagement graph has hundreds of trillions of edges. We develop an edge subsampling strategy with popularity bias correction that reduces the graph by three orders of magnitude while preserving retrieval- relevant structure. The pipeline pre-computes multi- hop neighborhoods via personalized PageRank (PPR) and packages everything into an edge-centric format ready for direct ingestion (Section 4.2). The entire pipeline completes within one hour, enabling the 3- hour refresh cycle that serving requires. Graph Construction Model Training Real-time Serving edge-centric data embeddings + index Low cost: cluster-index to replace online KNN Low cost: removing graph infra High fresh item coverage Pre-computed neighbors in self-contained format Co-learned cluster index Graph rebuild in <1 hour Requirement (Upstream) Co-designed Solution (Downstream) Figure 1 Lifecycle co-design in RankGraph-2. Serving and training impose requirements (dashed red, left) on upstream stages. Each requirement is resolved by a co- designed solution (solid blue, right), creating mutual dependencies across the pipeline. Deployed across multiple surfaces at Meta, RankGraph-2 achieves up to 3.8Ăhigher offline recall than existing baselines, delivers up to +0.96% CTR and +2.75% CVR improvements in 14-day A/B tests, and reduces U2U serving infrastructure cost by 83%. Our contributions are: â˘We identify lifecycle co-designâwhere serving, training, and construction requirements cascade across stagesâas a key missing piece in billion- scale GNN systems for retrieval, and present RankGraph-2 as a concrete realization. ⢠We show that similarity-based retrieval (U2U2I, U2I2I) does not require online graph infrastructure: pre-computed neighborhoods yield quality compa- rable to online sampling, enabling GNN training on standard ML infrastructure without dedicated graph storage or sampling engines. ⢠We propose a heterogeneous co-engagement graph 2 with all three edge types (U-U, I-I, U-I) derived from engagement data alone, with popularity bias correction for I-I edges, and PPR-based neighbor pre-computation that produces self-contained edge- centric training data. â˘We develop a co-learned cluster index with novel regularization and biased code selection that pre- vents codebook collapse under continuous training, reducing serving cost by 83%. â˘We demonstrate that this co-design enables a sim- ple architecture to achieve 3.8Ăhigher recall than GAT + Deep Graph Infomax, and 2.1Ăhigher than PyTorch-BigGraph on item retrieval, with +0.96% CTR and +2.75% CVR in A/B tests. 2 Related Work GNNs for recommendation. GNN-based recommen- dation has progressed from homogeneous models (GCN (Bruna et al., 2013), GraphSAGE (Hamil- ton et al., 2017), LightGCN (He et al., 2020)) to heterogeneous architectures (HetGNN (Zhang et al., 2019), HAN (Wang et al., 2019), HGT (Hu et al., 2020)) that aggregate across node and edge types. These models are evaluated on small static graphs and focus on aggregation mechanisms. RankGraph-2 uses a simple heterogeneous aggregator but invests in lifecycle co-designâeliminating graph infrastructure and pushing serving constraints upstreamâwhich we find to be a stronger lever than model complexity at scale. We compare against a GAT + Deep Graph Infomax baseline (Velickovic et al., 2018, 2019) and PyTorch-BigGraph (Lerer et al., 2019) in Section 5. Graph construction for recommendation. Most work constructs a bipartite user-item graph from interac- tions (Zheng et al., 2018; Sharma et al., 2024; Wu et al., 2022). Some enrich it with social edges (Sala- mat et al., 2021; Yang et al., 2022) or knowledge graph relations (Tien and Van, 2020; Xia et al., 2023). RankGraph-2 instead derives all three edge types (U- U, I-I, U-I) from engagement data alone, without requiring external data sources. This ensures di- rect alignment with recommendation-relevant signals and enables popularity bias correction on I-I edgesâ a technique we find critical for preventing popular items from dominating the learned representations (Section 5.3). Scalable training and billion-scale systems. Neigh- borhood sampling methods (PinSage (Ying et al., 2018), NIA-GCN (Sun et al., 2020), ByteGNN (Zheng et al., 2022)) and distributed frameworks (Graph- Scale (Gupta et al., 2024), DGL (Wang, 2019), PyG (Fey et al., 2025), AliGraph (Zhu et al., 2019)) focus on making training efficient, but assume the graph is given. Recent billion-scale systems ad- dress deployment but make different architectural trade-offs. GiGL (Zhao et al., 2025) advocates for real-time in-memory subgraph sampling, requiring substantial infrastructure for graph storage and dis- tributed sampling engines. We find that for similarity- based retrieval, this infrastructure is unnecessary: pre-computed neighborhoods yield comparable qual- ity, allowing RankGraph-2 to train on standard ML infrastructure without dedicated graph systems. LiGNN (Borisyuk et al., 2024) effectively models tem- poral heterogeneous graphs at LinkedIn but relies en- tirely on approximate nearest neighbor search for serv- ing, which incurs substantial infrastructural overhead. RankGraph-2 introduces a co-learned cluster index to eliminate online KNN entirely. MacGNN (Liu et al., 2024) tackles neighbor explosion by clustering micro-nodes into macro-nodes. While computation- ally elegant, this inherently sacrifices micro-level rela- tional precisionâtail users and niche items are forced into generalized macro-clusters. RankGraph-2âs edge subsampling protocol preserves the exact topologi- cal location of every individual node while achieving tractability through selective edge compression with popularity bias correction. Other approaches take fundamentally different architectures: OneRec (Wang et al., 2024) replaces the retrieve-and-rank cascade with a unified generative model, and PinFM (Zhou et al., 2024) pretrains a foundation model on user ac- tivity sequences. While these sequential approaches excel at capturing short-term temporal intent, they struggle to model explicit multi-hop collaborative filtering structures. We view RankGraph-2 not as a competitor to generative models, but as a comple- mentary structural prior for downstream sequences. Embedding-based retrieval serving. Approximate KNN with index structures such as HNSW (Malkov and Yashunin, 2018), Faiss (Douze et al., 2024), and Milvus (Wang et al., 2021) is the standard serving approach. Recent work combines KNN with cluster- ing for better control (Zhang et al., 2023). However, approximate KNN still requires substantial infrastruc- ture at high traffic volumes. RankGraph-2 replaces online KNN with a co-learned cluster index, reducing serving cost by 83%. Positioning. Existing systems optimize individ- ual stages but leave cross-stage dependencies un- addressed: training-focused systems require online graph infrastructure and serve via ANN; generative models bypass graph structure entirely. RankGraph-2 co-designs all three stages so that each stageâs output is tailored to the othersâ requirements, with serving, 3 Table 1 Cross-stage design coupling in billion-scale recommendation systems. For competing systems, âCross-stage gapsâ highlights dependencies left unaddressed. For RankGraph-2, the same column shows the co-design couplings that close these gaps. SystemStages optimizedCross-stage gaps / couplings GiGL (Zhao et al., 2025)Training (in-memory sampling) Graph assumed given; requires online graph infra; serving via ANN LiGNN (Borisyuk et al., 2024) Training (adaptive multi-hop) Graph assumed given; requires online graph infra; serving via ANN MacGNN (Liu et al., 2024)Training (macro-node aggregation) Graph construction loses micro-node precision; serving via ANN RankGraph-2All three stages, jointly co-designed Construction â Training: pre-computed PPR neighbors, edge-centric format Training â Serving: co-learned index Serving â Construction: 3h refresh cycle training, and construction requirements cascading across the pipeline. Table 1 contrasts the cross-stage coupling of each system. 3 Problem Setup Given user-item interactions dataD= (user 0 ,item 0 , interaction 0 ), (user 1 ,item 1 ,interaction 1 ), ..., our objectives are: 1.To generate high-quality embeddings for all users and items present in the interaction data D; 2.To efficiently serve these embeddings for the re- trieval stage in recommendation systems, support- ing scenarios such as user-to-user-to-item (U2U2I) and user-to-item-to-item (U2I2I) retrieval. We focus on graph-based approaches: a graph con- struction modulegcreatesG=g(D), and a graph learning modelMgenerates embeddings. Each user and item is associated with real-valued features. For serving, we co-train a learned index withMto replace approximate KNN. Notations.n i denotes thei-th node,X(n i ) its fea- tures,N U (n i ) andN I (n i ) its user and item neighbors. An edge is (n i ,n j ,w n i ,n j ) with weight w n i ,n j . 4 Method 4.1 Overview The architecture of RankGraph-2 is shown in Figure 2. We focus on the common case of user and item nodes. The following subsections detail the three stages in data-flow order (constructionâtrainingâserving), each shaped by the co-design requirements described in Section 1: â˘Graph construction (Section 4.2). Receives require- ments from both downstream stages: self-contained edge-centric data with pre-computed neighbor- hoods (for training), and hour-level rebuild (for serving freshness). Builds a heterogeneous graph with U-U, I-I, and U-I edges from engagement data (Figure 2A). â˘Model training (Section 4.3). Ingests pre-computed data with no online graph access, reusing standard ML infrastructure. Co-learns a cluster index so training directly optimizes for serving quality. ⢠Learned index for serving (Section 4.4). The co- learned residual-quantization cluster index enables KNN-free U2U2I retrieval with recency filtering, reducing serving cost by 83%. 4.2 Graph Construction Graph construction receives requirements from both downstream stages: training needs self-contained edge-centric data with pre-computed neighborhoods (no online graph access), and serving needs hour-level graph refresh for item coverage. The graph must also be informative for retrieval while being compact enough to reconstruct within one hour. Graph schema and edge construction. Our graph G= (V,E) has two node types (usersV U , items V I ) and three edge types (U-I, U-U, I-I), all de- rived from engagement data (clicks, likes, shares, purchases)âno external social or knowledge graph relations. Each edge carries a scalar weight reflecting engagement strength. U-U and I-I edges are undi- rected co-engagement edges; U-I edges are directed from user to item. This schema is intentionally sim- ple: we found that a single co-engagement relation per node-type pair, combined with our subsampling 4 A Graph Construction & Subsampling U 1 U 2 U 3 I 1 I 2 Raw Interactions (âź 100 Trillion Edges) Edge Subsampling & Popularity Correction w Ⲡn i ,n j = w n i ,n j Ă w n j ,n i P k w n j ,k Îą U 1 U 2 U 3 I 1 I 2 U-I U-U I-I Extended Heterogeneous Graph Neighborhood Pre-computation Personalized PageRank (PPR) + KNN Fallback Self-contained Edge-Centric Data B Heterogeneous Graph Learning N U (u i ) u i N I (u i ) Target Node & Pre-computed Neighbors f U f U f I Multi-head User Encoder Multi-head Item Encoder Heterogeneous Aggregator (AGG U ) Final Embedding M(u i ) Negative Sampling In-batch + Out-of-batch + Augmentation Contrastive Link Prediction Objective L i,j = ÎťL margin i,j + (1â Îť)L infoNCE i,j C Index Co-Learning & Serving h = M(u i ) Residual Quant. Layer 1 k 1 = arg minâĽhâC 1,j ⼠2 Residual Quant. Layer 2 k 2 = arg minâĽh 1 âC 2,j ⼠2 Codebook C 1 Codebook C 2 residual h 1 Reconstructed Emb. h Ⲡ= P i C i,k i Code Imbalance Regularization Biased Code Selection & L reg = Ëp¡ p(C) batch Index-based Real-time U2U2I Retrieval Recency-filtered Candidates | KNN-free (-83% Cost) Co-train Index Figure 2 The RankGraph-2 system architecture for billion-node graph learning and retrieval. (A) Graph Construction transforms raw user-item interaction logs into a tractable, heterogeneous graph via popularity bias correction, edge subsampling, and Personalized PageRank (PPR) multi-hop neighbor pre-computation. (B) Model Training leverages multi-head type-aware feature encoders and a heterogeneous aggregator to optimize node representations using a contrastive link prediction objective. (C) Index Co-Learning utilizes residual quantization to jointly train a regularized cluster index, preventing codebook collapse and enabling KNN-free U2U2I retrieval that reduces serving cost by 83%. strategies, outperforms multiple fine-grained relation types which increase graph size without proportional quality gains. Unlike prior work that uses bipartite U-I graphs (Zheng et al., 2018; Sharma et al., 2024; Wu et al., 2022), we construct all three edge types: â˘User-Item (U-I) Edges: An edge is created between a user node and an item node if the user has en- gaged with the item within the pastThours. The weight is assigned based on the type of engagement, using predefined values that reflect business value. â˘User-User (U-U) Edges: LetI(n i ,n j ) denote the set of items two user nodesn i andn j have both interacted with in the pastThours. An edge is established between the two user nodesn i andn j if |I(n i ,n j )| >=C U , whereC U is a hyperparameter. The weight of the edge is defined as: w n i ,n j = ln( X eâI(n i ,n j ) w n i ,e â w n j ,e )(1) where we sum the weights induced from each item and then log normalize to keep the weights of fre- quent users and less frequent users at the same scale. ⢠Item-Item (I-I) Edges: The I-I edges are defined in a similar way as U-U edges. LetU(n i ,n j ) denote the set of users two item nodesn i andn j have both been interacted by in the pastThours. An edge is established between the two item nodesn i andn j if|U(n i ,n j )| >=C I . The weight of the edge is defined as: w n i ,n j = ln( X eâU(n i ,n j ) w e,n i â w e,n j )(2) Popularity bias correction. Popular items accumulate co-engagement edges that reflect popularity rather than genuine interest, causing over-representation. We adjust I-I edge weights as: w Ⲡn i ,n j = w n i ,n j â ( w n j ,n i P n k w n j ,n k ) Îą (3) wheren k iterates over neighbors ofn j andÎą= 0.3. Intuitively, ifn j is popular, w n j ,n i P n k w n j ,n k is small, heavily down-weighting the edge. After adjustment, (n i ,n j ) and (n j ,n i ) have different weights; we keep both. Combined with subsampling, this yields far fewer edges from popular items. Edge subsampling. The raw graph has hundreds of trillions of edges. We subsample in two steps: (1) 5 for U-U edges, we retainâź0.1B nodes prioritized by business value (refreshed daily); all nodes are retained in U-I edges; (2) for each node, we keep the topK CAP edges by weight. This reduces edges from hundreds of trillions to hundreds of billions. We call the result the extended graph. Due to edge sampling, nodes partition into two groups: Group 1 nodes have same-type neighbors in the graph; Group 2 nodes do not. Group 1 nodes and their edges form the backbone graph with com- plete neighbor information. Group 2 nodes appear only in the extended graph. Pre-computed important neighbors. Inspired by Pin- Sage (Ying et al., 2018), we use personalized PageR- ank (PPR) (Yang et al., 2024) to identify theK IMP most important user and item neighbors per node. We use a random-walk Monte Carlo approximation (Rwalks of lengthL, restart probability 0.15), which is embarrassingly parallelizable across billions of nodes. PPR neighbors are not added as graph edges; they define a fixed-size pre-computed adjacency list for training, replacing online sampling (Gupta et al., 2024; Zheng et al., 2022). Edge-type weights are normalized so no type dominates PPR output. PPR is applied on the backbone graph. For Group 2 nodes (lacking same-type neighbors), we use KNN over Group 1 embeddings from previous training runs (updated daily) to findK IMP same-type neighbors; item neighbors come from top-weight U-I edges. At training time,K ⲠIMP neighbors are randomly sampled from the K IMP pre-computed ones. Data format. The output is edge-centric: each record contains the edge (n i ,n j ,w n i ,n j ), features and sam- pled neighbors for both endpoints, partitioned by edge type. 4.3 Model Training Training addresses two co-design responsibilities: it ingests the self-contained edge-centric data from con- struction (requiring no online graph access), and it co-learns a cluster index to meet servingâs KNN-free requirement. The result is a standard supervised link prediction loop that reuses existing ML infrastructure. Our setting is inductive: nodes have real-valued fea- tures and the model learns shared encoders, general- izing to unseen nodes unlike transductive approaches (e.g., neural matrix factorization). Model architecture (Figure 2B). Letf t (t â U,I) encode raw features of typetinto embeddings. The embedding of node n i of type t is: M(n i ) = AGG t (f t (X(n i )), f U (X(e)|eâ N U (n i ), f I (X(e)|eâ N I (n i ) (4) whereAGG t aggregates user neighbor, item neigh- bor, and self embeddings. Each node has exactly Kuser andKitem neighbors (fixed during graph construction). Bothf t andAGG t use multiple heads; multi-head embeddings are used for negative augmen- tation during training and averaged at inference. Negative sampling. We generate negatives via three strategies: (1) in-batch: negatives from other edges in the same batch; (2) out-of-batch: negatives from a rolling pool across batches to approximate the global distribution; (3) negative augmentation: multi-head embeddings from different heads serve as additional negatives. For each positive edge (n i ,n j ), we sample 100 negatives of the same type as n j . Loss function. We combine margin ranking loss (Schroff et al., 2015; Dong and Shen, 2018) and infoNCE (Oord et al., 2018; Parulekar et al., 2023). For edge (n i ,n j ), lets i,j be the cosine similarity and s i,k,neg the similarity to negative n k : L margin i,j = X k max(0,s i,k,neg â s i,j + margin) (5) with margin = 0.1. The InfoNCE loss is: L infoNCE i,j =âlog e s i,j /Ď e s i,j /Ď + P k e s i,k,neg /Ď (6) with Ď = 0.06. The combined loss per edge is: L i,j = ÎťL margin i,j + (1â Îť)â L infoNCE i,j (7) Each batch contains edges from all types. We com- pute per-type lossesL U-U ,L U-I ,L I-U ,L I-I (U-I is bidirectional). The final loss is: L = β 1 L UâU + β 2 â L UâI + β 3 â L IâU + (1â β 1 â β 2 â β 3 )â L IâI (8) We adopt the uncertainty weighting method (Kendall et al., 2018) to learn the hyperparametersÎť,β 1 ,β 2 , and β 3 . Efficiency optimizations. The graph-infra-free design yields deterministic batch sizes and maximizes Model FLOPs Utilization (MFU)âin contrast to online sam- pling where multi-hop traversals cause unpredictable memory spikes. We further separate data fetching, feature preprocessing, and negative sampling on CPU, overlapping with on-GPU model training. 6 4.4 Learned Index for Efficient Serving Serving is the stage whose cost requirements drive much of the co-design. We serve embeddings for two retrieval scenarios: ⢠U2I2I: Identify a userâs engaged items, then find similar items via I2I KNN. Since item embeddings update infrequently, I2I KNN can be pre-computed offlineâserving is cheap. â˘U2U2I: Find similar users, then retrieve their en- gaged items. We empirically find that constraining the candidate pool to recently active users (e.g., past 15 minutes) yields the best quality. Online KNN over this dynamic pool requires thousands of machines. Pre-computed static KNN mappings are also insufficient, since the active user set changes every few minutes. We resolve this with a cluster-based approach (Sec- tion 1): training co-learns a cluster index that assigns each user to a cluster. Each cluster maintains a real- time queue of items from its recently active members. At serving time, U2U2I reduces to reading the latest items from the target userâs cluster queueâeffectively U2Cluster2Iâwhich is a simple lookup rather than a nearest-neighbor search. Co-Learned Index. To ensure the best cluster quality, we learn the cluster index along with the graph model. We adopt a residual quantization based approach: k i =arg min jâ[|C i |] ||h iâ1 âC i,j || 2 h i =h iâ1 âC i,k i (9) whereC i denote the code book of thei-th layer and C i,j denotes the j-th code of the i-th layer, h i is the residual embedding after thei-th layer of a node embeddingh, andk i is the code ofhat layeri-th. The reconstructed embedding forhbased on the codebook would be: h Ⲡ= X i C i,k i (10) For a good codebook, the reconstructed embedding should be close to the original embedding, so we define a reconstruction loss for a node embedding: L recon =||hâ h Ⲡ|| 2 . For each positive edge (n i ,n j ), we obtain the average reconstruction loss over node n i , noden j , and the sampled negative nodes as the reconstruction loss on the edge L recon i,j Apart from the reconstruction loss, we also use the reconstructed embedding to obtain a lossL Ⲡas in Equation 8 as the reconstructed embedding should also minimize the graph learning objective. Cluster-based U2U serving. Each useru i is assigned a hierarchical cluster codec i = (k 1 ,k 2 ) via the residual quantization above. Each cluster maintains a queue of items recently engaged by its active members. At serving time, we simply read the latest items from useru i âs cluster queueâno nearest-neighbor search is needed. Cluster size must be large enough that suf- ficient recently active users are present after recency filtering, yet small enough to maintain similarity. We tune the codebook sizes (|C 1 |Ă|C 2 |) to find the best balance. This approach reduces serving cost by 83% compared to online approximate KNN. Addressing code imbalance. One challenge in learned residual quantization is the imbalance of the learned codebook, i.e. some codes are used much more of- ten than the others (Kuai et al., 2024). Balancing the codebook and preventing codebook collapse is important in recommendation use cases as the model is always under continuous training. To address the issue, we propose two techniques: (1) Regularization loss. Ideally the frequency of each code being selected should be equal. To simplify notation, we consider the first layer in the code book. LetËpbe the empirical probability distribution of the codes in the first layer of the code book in past 1000 batches. We obtain and updateËpby maintaining a queue of code assignments of fixed size 1000. We then also obtain an estimate in the current data batch of the code selection probability. For one embeddingh, its distance to all codesCis d(h,C) =d 1 ,d 2 ,d 3 ,.... While in the residual quantization step we do hard assignment (i.e. we assign the code with the minimal distance), we per- form "soft" assignment here to obtain an approximate probability of the jth code being selected as: p(h,C)[j] = e Îś 1 /(Îś 2 +d j ) P k e Îś 1 /(Îś 2 +d k ) (11) whereÎś 1 = 10 andÎś 2 = 0.01. Then, the empirical frequency of each code being selected in the current batch can be estimated as: fre(C) batch = X h p(h,C)[0], X h p(h,C)[1],... (12) andp(C) batch is obtained by normalizingfre(C) batch . To pushËptoward uniform, we penalize the cur- rent batch for reinforcing already-frequent codes via L reg =Ëp¡p(C) batch averaged over all codebook layers. The final loss combinesL,L Ⲡ(contrastive on recon- structed embeddings),L recon , andL reg , balanced via uncertainty weighting (Kendall et al., 2018). (2) Biased code selection. Instead of selecting the 7 code that maximizes p(h iâ1 ,C i )[j], we select: k i = arg max jâ[|C i |] p(h iâ1 ,C i )[j] Ëp[j] (13) This favors underused codes and penalizes overused ones, preventing codebook collapse under continuous training. The slight dispersion acts as a beneficial exploration mechanism in discovery-oriented surfaces. 5 Experiments 5.1 Setup Application context. RankGraph-2 is deployed on multiple recommendation surfaces at Meta, and we discuss two major surfaces: Surface 1 and Surface 2, each serving billions of users. The system serves both U2I2I and U2U2I retrieval. Graph construction. The graph is constructed from 24 hours of engagement data and fully reconstructed every 3 hours (âź1 hour per build). Each graph con- tains billions of user and item nodes and hundreds of billions of edges across U-U, I-I, and U-I types. Node features. User features include demographics and a sequence of recently engaged items. Item fea- tures include content-type and id-based features. All features are encoded into dense embeddings via type- specific encoders. Model training. We train continuously with batch size 32,768, using AdaGrad (lr 0.02) for sparse and AdamW (lr 0.004) for dense parameters. Embedding dimension is 256. The co-learned index uses a two- layer codebook (5,000Ă50 = 250,000 clusters). We pre-computeK IMP =50 PPR neighbors per node and sample K ⲠIMP =10 per training edge. Embedding refresh. After each graph reconstruction, embeddings are regenerated immediately. We aggre- gate embeddings over the past week (keeping the most recent per node ID). End-to-end latency from engage- ment data to refreshed embeddings is âź2 hours. Evaluation scope. Public benchmarks (e.g., Ama- zon (Ni et al., 2019), MovieLens (Harper and Kon- stan, 2015)) are orders of magnitude smaller and do not exhibit the scalability challenges that motivate our design. We focus on production-scale evaluation with offline metrics and online A/B tests. 5.2 Embedding quality evaluation 5.2.1 Quality of user embedding We sample 100K users, retrieve their top-100 KNN neighbors, and measure Recall@Kagainst next-day engagements. Baselines: (1) GAT-DGIâa Graph Attention Network (GAT) (Velickovic et al., 2018) with Deep Graph Infomax (Velickovic et al., 2019) self-supervised pre-training on a user-item bipartite graph, representing a more complex model on a sim- pler graph; (2) HSTU (Zhai et al., 2024)âa trillion- parameter sequential foundation model with embed- dings optimized for retrieval via a contrastive objec- tive. RankGraph-2 outperforms both baselines across all thresholds (Table 2), achieving 3.8Ăhigher Recall@5 than GAT-DGI. The GAT-DGI comparison is partic- ularly informative: GAT-DGI uses a more expressive architecture (GAT + Deep Graph Infomax) but trains on a simpler bipartite graph without heterogeneous co-engagement edges or PPR-based neighbor pre- computation. This gap supports the co-design thesis: the gains come not from model complexity but from lifecycle co-designâsince similarity-based retrieval tolerates pre-computed neighborhoods, we invest in construction quality and push serving costs upstream into training. The HSTU comparison further sug- gests that sequential models, despite massive scale, capture different signals than graph-based structural similarityâconsistent with our discussion of comple- mentarity in Section 6. Table 2 Eval Recall for RankGraph-2, GAT-DGI, and HSTU on 100,000 sampled users MethodRecall@5 Recall@10 Recall@50 Recall@100 GAT-DGI0.0380.0660.1800.251 HSTU0.0130.0240.0850.135 RankGraph-2 0.1430.2090.3990.482 5.2.2 Quality of item embedding We evaluate item embeddings on predicting future I-I co-engagement using a strict temporal split: embeddings from dayN, evaluated against day N+1 edges. We sample 1,000 edges and measure Recall@Kover all pairwise distances. Baselines: (1) PBGâtranslational embeddings trained using PyTorch-BigGraph (Lerer et al., 2019) on an item co-engagement graph; (2) HSTU (Zhai et al., 2024) as above. Table 3 Eval Recall for RankGraph-2, HSTU, and PBG on 1000 sampled edges MethodRecall@5 Recall@10 Recall@50 Recall@100 PBG0.0170.0300.2440.374 HSTU0.1320.1770.3490.434 RankGraph-2 0.1470.1960.5090.775 RankGraph-2 achieves the highest recall across all 8 thresholds (Table 3). At Recall@100, RankGraph-2 achieves 0.775 compared to 0.434 for HSTU (1.8Ă) and 0.374 for PBG (2.1Ă). The improvement over PBG is notable because PyTorch-BigGraph is a well-established large-scale graph embedding sys- tem; the gap demonstrates that lifecycle co-designâ heterogeneous graph construction with PPR-based neighbor selectionâsubstantially outperforms trans- lational embedding approaches that optimize training in isolation. 5.2.3 Quality of learned index We compare original embeddings, reconstructed em- beddings (from codebook, Eq. 10), and reconstructed without regularization. Hitrate@Kmeasures whether the positive edge similarity ranks in the topKagainst negatives. Table 4 Learned index with vs without the regularization module for code imbalance MethodHitrate@1 Hitrate@5 Hitrate@10 Original embedding0.8710.9810.997 Recon-embedding0.8460.9730.994 Recon-embedding w/o reg 0.7170.8770.931 The results (Table 4) show that co-learning the index with our regularization techniques maintains high hitrates, closely matching the original embeddings (0.846 vs 0.871 at Hitrate@1). In contrast, removing regularization causes a substantial drop (0.717 at Hi- trate@1), demonstrating that codebook collapse is a real risk under continuous training. Codebook uti- lization confirms this: with regularization, utilization reaches 100%, whereas without it, utilization drops significantly. 5.3 Ablation Study We ablate key design choices using the user embed- ding evaluation protocol (Recall@K, 100K users). 5.3.1 Effect of heterogeneous edge types We compare the full heterogeneous graph against variants with subsets of edge types. Table 5 Ablation on edge types for user embedding quality Edge TypesRecall@5 Recall@10 Recall@50 Recall@100 U-I only0.0520.0810.2100.285 U-I + I-I0.0890.1340.2850.352 U-I + U-U0.1150.1700.3310.410 U-I + U-U + I-I 0.1430.2090.3990.482 The bipartite baseline provides a foundation, but I-I edges improve retrieval of long-tail items by encoding direct content similarity, and U-U edges enhance serendipitous discovery outside the userâs immediate history. The full topology yields compounding gains that validate the lifecycle investment in heterogeneous graph construction. 5.3.2 Effect of neighbor selection strategy Table 6 Ablation on neighbor selection strategy for user embedding quality Neighbor Strategy Recall@5 Recall@10 Recall@50 Recall@100 Random0.0450.0720.1900.260 Top-weight0.0980.1450.2950.370 PPR neighbors0.1430.2090.3990.482 âRandom neighborsâ randomly samplesKneighbors. âTop-weight neighborsâ selectsKneighbors with high- est edge weight (single-hop only). Random sampling introduces high variance and noise. Top-weight sam- pling captures immediate relevance but fails to reach distant, structurally important nodes. PPR captures multi-hop importance, which is critical for the life- cycle: the offline pre-computation cost is amortized across training iterations, and the richer neighbor- hoods directly improve embedding quality without added model complexity. 5.3.3 Effect of popularity bias correction We evaluate on item embedding quality (Section 5.2.2 protocol). Table 7 Ablation on popularity bias correction for item embedding quality MethodRecall@5 Recall@10 Recall@50 Recall@100 w/o correction 0.1120.1510.4150.620 w/ correction 0.1470.1960.5090.775 Without correction, embeddings over-index on glob- ally popular items, reducing personalization fidelity for tail users. The correction parameter (Îą=0.3) offsets hub-node dominance without artificially frag- menting the graph. Together, the ablation results con- firm that each lifecycle componentâheterogeneous edges, PPR neighbors, and popularity correctionâ makes a distinct and complementary contribution to retrieval quality. 5.4 Online A/B Test We conducted 14-day A/B tests on both surfaces at Meta. The treatment group adds RankGraph-2 embeddings as a retrieval source alongside the exist- ing production pipeline, which includes collaborative 9 filtering, content-based, and other embedding-based methods. We report CTR and CVR, the primary business metrics. All improvements are statistically significant (p < 0.05). Tables 8a and 8b show the A/B test results. RankGraph-2 achieves up to +0.96% CTR and +2.75% CVR for U2I2I, and consistent improvements for U2U2I. Table 8 A/B test results (14-day, statistically significant) (a) U2I2I retrieval SurfaceCTRCVR Surface 1 +0.96% +2.75% Surface 2 +0.33% +0.76% (b) U2U2I retrieval SurfaceCTRCVR Surface 1 +0.40% +1.01% Surface 2 +0.20% +0.17% Learned index vs. online KNN. For U2U2I retrieval, we compared the co-learned cluster index against the approximate KNN-based serving system. The learned index achieves comparable CTR and CVR to KNN- based serving while reducing serving infrastructure from thousands of machines to a fraction of that costâ an 83% reduction. This cost saving is important at Metaâs scale, where U2U2I retrieval serves billions of requests daily. Deployment. Based on A/B results, RankGraph-2 is deployed as a graph-based embedding system for content recommendation retrieval at Meta, and has powered 20+ retrieval launches across major surfaces. 6 Discussion Where co-design gains come from. The 3.8Ărecall gain over GAT-DGI and 2.1Ăover PBG come not from a more expressive aggregator, but from lifecycle co-design. The key mechanism is that moving neigh- borhood computation offline does not merely match online sampling qualityâit enables higher quality by unlocking operations that would be infeasible in an online setting. Specifically, offline pre-computation al- lows us to: (1) construct richer heterogeneous graphs with U-U, I-I, and U-I co-engagement edges and pop- ularity bias correction, which would be too expen- sive to maintain in an online graph store; (2) run multi-hop PPR over the full backbone graph to iden- tify structurally important neighbors, whereas online sampling is typically limited to single-hop or shal- low random walks due to latency constraints; and (3) invest the engineering effort saved from graph in- frastructure into graph construction qualityâbetter edge weighting, subsampling strategies, and neigh- bor selection. Additionally, pushing serving costs upstream allows training to co-learn a high-quality cluster index, directly optimizing for serving quality rather than relying on post-hoc quantization. For practitioners, the implication is that the con- ventional approach, i.e. investing in online graph infrastructure to serve increasingly complex GNN ar- chitectures, may be the wrong trade-off for similarity- based retrieval. Instead, investing in offline graph construction quality on standard ML infrastructure can yield both better retrieval quality and lower op- erational cost. Simpler models also offer advantages in training stability, memory efficiency, and serving latency under continuous training (Ying et al., 2018; Borisyuk et al., 2024). Complementarity withfoundation models. Graph mod- els and sequential foundation models (HSTU (Zhai et al., 2024), OneRec (Wang et al., 2024), PinFM (Zhou et al., 2024)) are complementary: the former captures global collaborative structure via multi-hop message passing, while the latter excels at temporal intent and short-term dynamics. Neither alone captures both. RankGraph-2 embeddings serve as structural prior features to downstream ranking models (including foundation models), yielding addi- tional gains beyond either paradigm alone. Tighter integration, such as initializing graph embeddings with foundation model representations, is a promis- ing future direction. Freshness and temporal dynamics. RankGraph-2 ad- dresses evolving user dynamics at two timescales. The 3-hour graph reconstruction cycle (each build completing inâź1 hour) captures shifted engagement patterns and new items within hours. For U2U2I serving, we empirically find that filtering the can- didate pool to recently active users (e.g., past 15 minutes) yields the best quality, providing real-time responsiveness without real-time graph updates. Limitations. Our co-design is optimized for similarity- based retrieval (U2U2I, U2I2I) where structural graph signals dominate; for direct user-to-item retrieval, ranking models with real-time behavioral features may be more effective. Pre-computing neighbor- hoods offline also precludes tasks requiring query- dependent neighborhood exploration. Additionally, the 3-hour refresh may be insufficient for extremely time-sensitive scenarios. 7 Conclusion We presented RankGraph-2, a framework that co- designs graph construction, training, and serving for billion-node similarity-based retrieval. Requirements cascade across stages: serving needs a co-learned 10 cluster index, training needs self-contained data with- out online graph infrastructure, and construction must satisfy both while maintaining hour-level fresh- ness. This lifecycle co-design enables a simple archi- tecture to achieve 3.8Ăhigher recall than GAT + Deep Graph Infomax and 2.1Ăhigher than PyTorch- BigGraph, while reducing serving cost by 83%. De- ployed at Meta, RankGraph-2 delivers up to +0.96% CTR and +2.75% CVR. We believe lifecycle co-design extends to other domains where graph-based systems must operate at scale under serving constraints. Acknowledgments This work would not be possible without work from the following contributors: Hang Wang, Jeff Wang, Honghao Wei, Harry Hai Nguyen, Jim Li, Tao Ju, Crystal Jin, Ye Wang, Mingda Li, Zhen Wang, Tian Tong, Pu Zhang, Keke Zhai, Emy Sun, Tao Jia, Yang Cao, Chengye Liu, Pan Chen, Jianhui Wu, Yuanyuan Ding, Haoran Wen. References Fedor Borisyuk, Shihai Zhang, Mingzhou Wang, et al. Lignn: Graph neural networks at linkedin. In Pro- ceedings of the 30th ACM SIGKDD Conference on Knowledge Discovery and Data Mining, pages 4846â 4857, 2024. Joan Bruna, Wojciech Zaremba, Arthur Szlam, and Yann LeCun. Spectral networks and locally connected net- works on graphs. arXiv preprint arXiv:1312.6203, 2013. Mengru Chen, Chao Huang, Lianghao Xia, Wei Wei, Yong Xu, and Ronghua Luo. Heterogeneous graph con- trastive learning for recommendation. In Proceedings of the sixteenth ACM international conference on web search and data mining, pages 544â552, 2023. Xingping Dong and Jianbing Shen. Triplet loss in siamese network for object tracking. In Proceedings of the Eu- ropean conference on computer vision (ECCV), pages 459â474, 2018. Matthijs Douze, Alexandr Guzhva, Chengqi Deng, Jeff Johnson, Gergely Szilvasy, Pierre-Emmanuel MazarĂŠ, Maria Lomeli, Lucas Hosseini, and HervĂŠ JĂŠgou. The faiss library. arXiv preprint arXiv:2401.08281, 2024. Matthias Fey, Jinu Sunil, Akihiro Nitta, Rishi Puri, Manan Shah, BlaĹž StojanoviÄ, Ramona Bendias, Alexandria Barghi, Vid Kocijan, Zecheng Zhang, et al. Pyg 2.0: Scalable learning on real world graphs. arXiv preprint arXiv:2507.16991, 2025. Vipul Gupta, Xin Chen, Ruoyun Huang, Fanlong Meng, Jianjun Chen, and Yujun Yan. Graphscale: A frame- work to enable machine learning over billion-node graphs. In Proceedings of the 33rd ACM International Conference on Information and Knowledge Manage- ment, pages 4514â4521, 2024. Will Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning on large graphs. Advances in neural information processing systems, 30, 2017. F Maxwell Harper and Joseph A Konstan. The movielens datasets: History and context. volume 5, pages 1â19, 2015. Xiangnan He, Kuan Deng, Xiang Wang, Yan Li, Yong- dong Zhang, and Meng Wang. Lightgcn: Simplifying and powering graph convolution network for recom- mendation. In Proceedings of the 43rd international ACM SIGIR conference on research and development in information retrieval, pages 639â648, 2020. Ziniu Hu, Yuxiao Dong, Kuansan Wang, and Yizhou Sun. Heterogeneous graph transformer. In Proceedings of the web conference 2020, pages 2704â2710, 2020. Alex Kendall, Yarin Gal, and Roberto Cipolla. Multi- task learning using uncertainty to weigh losses for scene geometry and semantics. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 7482â7491, 2018. Zhirui Kuai, Zuxu Chen, Huimu Wang, Mingming Li, Dadong Miao, Binbin Wang, Xusong Chen, Li Kuang, Yuxing Han, Jiaxing Wang, et al. Breaking the hour- glass phenomenon of residual quantization: Enhancing the upper bound of generative retrieval. arXiv preprint arXiv:2407.21488, 2024. Adam Lerer, Ledell Wu, Jiajun Shen, Timothee Lacroix, Luca Wehrstedt, Abhijit Bose, and Alex Peysakhovich. Pytorch-biggraph: A large-scale graph embedding sys- tem. In Proceedings of the 2nd SysML Conference, 2019. Hao Liu, Jianfei Qian, et al. Macgnn: Graph neural net- works for billion-scale recommendation systems. arXiv preprint arXiv:2401.14106, 2024. Yu A Malkov and Dmitry A Yashunin. Efficient and robust approximate nearest neighbor search using hier- archical navigable small world graphs. IEEE transac- tions on pattern analysis and machine intelligence, 42 (4):824â836, 2018. Jianmo Ni, Jiacheng Li, and Julian McAuley. Justify- ing recommendations using distantly-labeled reviews and fine-grained aspects. In Proceedings of the 2019 conference on empirical methods in natural language processing, pages 188â197, 2019. Aaron van den Oord, Yazhe Li, and Oriol Vinyals. Rep- resentation learning with contrastive predictive coding. arXiv preprint arXiv:1807.03748, 2018. Advait Parulekar, Liam Collins, Karthikeyan Shanmugam, Aryan Mokhtari, and Sanjay Shakkottai. Infonce loss provably learns cluster-preserving representations. In 11 The Thirty Sixth Annual Conference on Learning The- ory, pages 1914â1961. PMLR, 2023. Amirreza Salamat, Xiao Luo, and Ali Jafari. Hetero- graphrec: A heterogeneous graph-based neural net- works for social recommendations. Knowledge-Based Systems, 217:106817, 2021. Florian Schroff, Dmitry Kalenichenko, and James Philbin. Facenet: A unified embedding for face recognition and clustering. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 815â823, 2015. Kartik Sharma, Yeon-Chang Lee, Sivagami Nambi, Aditya Salian, Shlok Shah, Sang-Wook Kim, and Srijan Kumar. A survey of graph neural networks for social recommender systems. ACM Computing Surveys, 56 (10):1â34, 2024. Jianing Sun, Yingxue Zhang, Wei Guo, Huifeng Guo, Ruiming Tang, Xiuqiang He, Chen Ma, and Mark Coates. Neighbor interaction aware graph convolution networks for recommendation. In Proceedings of the 43rd international ACM SIGIR conference on research and development in information retrieval, pages 1289â 1298, 2020. Dong Nguyen Tien and Hai Pham Van. Graph neural net- work combined knowledge graph for recommendation system. In International Conference on Computational Data and Social Networks, pages 59â70. Springer, 2020. Petar Velickovic, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and Yoshua Bengio. Graph attention networks. In International Conference on Learning Representations, 2018. Petar Velickovic, William Fedus, William L Hamilton, Pietro Lio, Yoshua Bengio, and R Devon Hjelm. Deep graph infomax. In International Conference on Learn- ing Representations, 2019. Jianguo Wang, Xiaomeng Yi, Rentong Guo, Hai Jin, Peng Xu, Shengjun Li, Xiangyu Wang, Xiangzhou Guo, Chengming Li, Xiaohai Xu, et al. Milvus: A purpose- built vector data management system. In Proceedings of the 2021 international conference on management of data, pages 2614â2627, 2021. Jiaxin Wang et al. Onerec: Unifying retrieve and rank with generative recommender and iterative preference alignment. arXiv preprint arXiv:2410.19312, 2024. Minjie Yu Wang. Deep graph library: Towards efficient and scalable deep learning on graphs. In ICLR work- shop on representation learning on graphs and mani- folds, 2019. Xiao Wang, Houye Ji, Chuan Shi, Bai Wang, Yanfang Ye, Peng Cui, and Philip S Yu. Heterogeneous graph attention network. In The world wide web conference, pages 2022â2032, 2019. Renzhi Wu, Junjie Yang, Li Chen, Hong Li, Li Yu, and Hong Yan. Rankgraph: Unified heterogeneous graph learning for cross-domain recommendation, 2025.https: //arxiv.org/abs/2509.02942. Shiwen Wu, Fei Sun, Wentao Zhang, Xu Xie, and Bin Cui. Graph neural networks in recommender systems: a survey. ACM Computing Surveys, 55(5):1â37, 2022. Lianghao Xia, Yizhen Shao, Chao Huang, Yong Xu, Huance Xu, and Jian Pei. Disentangled graph social recommendation. In 2023 IEEE 39th international con- ference on data engineering (ICDE), pages 2332â2344. IEEE, 2023. Liangwei Yang, Zhiwei Liu, Yu Wang, Chen Wang, Ziwei Fan, and Philip S Yu. Large-scale personalized video game recommendation via social-aware contextualized graph neural network. In Proceedings of the ACM Web Conference 2022, pages 3376â3386, 2022. Mingji Yang, Hanzhi Wang, Zhewei Wei, Sibo Wang, and Ji-Rong Wen. Efficient algorithms for personalized pagerank computation: A survey. IEEE Transactions on Knowledge and Data Engineering, 36(9):4582â4602, 2024. Rex Ying, Ruining He, Kaifeng Chen, Pong Eksombatchai, William L Hamilton, and Jure Leskovec. Graph con- volutional neural networks for web-scale recommender systems. In Proceedings of the 24th ACM SIGKDD international conference on knowledge discovery & data mining, pages 974â983, 2018. Jiaqi Zhai, Lucy Liao, Xing Liu, Yueming Wang, Rui Li, Xuan Cao, Leon Gao, Zhaojie Gong, Fangda Gu, Michael He, et al. Actions speak louder than words: Trillion-parameter sequential transducers for generative recommendations. arXiv preprint arXiv:2402.17152, 2024. Chuxu Zhang, Dongjin Song, Chao Huang, Ananthram Swami, and Nitesh V Chawla. Heterogeneous graph neural network. In Proceedings of the 25th ACM SIGKDD international conference on knowledge dis- covery & data mining, pages 793â803, 2019. Yuan Zhang, Xue Dong, Weijie Ding, Biao Li, Peng Jiang, and Kun Gai. Divide and conquer: Towards better embedding-based retrieval for recommender systems from a multi-task perspective. In Companion Proceed- ings of the ACM Web Conference 2023, pages 366â370, 2023. Tong Zhao, Yozen Li, Ankit Sharma, Vassilis N Ioanni- dis, et al. Gigl: Large-scale graph neural networks at snapchat. In Proceedings of the ACM Web Conference 2025, 2025. Chenguang Zheng, Hongzhi Chen, Yuxuan Cheng, Zhezheng Song, Yifan Wu, Changji Li, James Cheng, Hao Yang, and Shuai Zhang. Bytegnn: efficient graph neural network training at large scale. Proceedings of the VLDB Endowment, 15(6):1228â1242, 2022. 12 Lei Zheng, Chun-Ta Lu, Fei Jiang, Jiawei Zhang, and Philip S Yu. Spectral collaborative filtering. In Pro- ceedings of the 12th ACM conference on recommender systems, pages 311â319, 2018. Haoyu Zhou et al. Pinfm: Foundation model for user activity sequences at a billion-scale visual discovery platform. In Proceedings of the ACM Web Conference 2024, 2024. Rong Zhu, Kun Zhao, Hongxia Yang, Wei Lin, Chang Zhou, Baole Ai, Yong Li, and Jingren Zhou. Aligraph: A comprehensive graph neural network platform. arXiv preprint arXiv:1902.08730, 2019. 13