Modeling Preference Dependencies with Directed Acyclic Graphs for Narrative-Driven Recommendation

Introduction

Relevance to Web. Traditional recommender systems on Web platforms largely rely on historical interactions or structured profiles to approximate user intent [1, 19]. However, these signals often fall short as modern Web users increasingly turn to free-form natural language narratives [14, 17, 21]. While the emergence of large language models (LLMs) offers new opportunities to interpret such narratives [12, 27, 31], retrieving candidates from open Web resources and evaluating their suitability require preserving how users’ preferences condition and constrain one another. Against this backdrop, we study narrative-driven recommendation (NDR) in open-web environments, aiming to provide personalized recommendations by deciphering rich, unstructured user requests [2, 4].

Existing efforts have explored different paradigms to transform narratives into recommendation evidence. Early work primarily relied on explicit clues. For example, Boger and Koolen [5] combined example items with narrative context. Eberhard et al. [10] used annotated genres and keywords for post-filtering. Subsequent work further explored automated element extraction to reduce manual annotation [7]. Another line explores semantic matching between narratives and items through embedding representations [9]. Recent work further explores the potential of directly generating recommendations from narratives with LLMs [8, 13]. To further empower LLMs with external evidence, Zhu et al. [32] introduce collaborative retrieval to provide behavioral signals. Shi et al. [28] apply open-domain retrieval and attribution generation to rank candidates. Kanchi et al. [16] utilize generated plot tags for fine-grained reranking. However, preferences expressed in narratives often mutually qualify each other [24], a dimension still insufficiently modeled in existing methods.

User preferences in narratives are not merely flat collections of independent elements, but rather hierarchical and dependency structures formed through conditional qualifications. Consider the following movie recommendation request:

“I’d like fantasy with romance as a subplot, rather than the main attraction. […] I need believable individual characters and a relationship shown through conversation, humour, and handling disagreements, not mostly sex.”

In this query, “subplot” constrains the prominence of romance within the overarching narrative, while conversation, humour, and handling disagreements further qualify the specific manner in which this relationship unfolds. Neglecting such qualifying dependencies can easily cause a film that superficially covers fantasy, romance, and humor to be falsely identified as a match, such as The Lord of the Rings. Yet the humor belongs to camaraderie instead of romance, failing the qualification. In contrast, Howl’s Moving Castle develops the romance through bickering and everyday interaction, satisfying the requested dynamic. This contrast reveals the necessity of explicitly modeling qualification and dependency structures among narrative preferences to guide the retrieval and evaluation of Web evidence for recommendation.

We propose PDG-F (Preference Dependency Graph Framework), a narrative-driven recommendation framework comprising a graph construction agent, directed path retrieval, and topological path ranking. Specifically, the graph construction agent, PDG-A, extracts diverse elements from the narrative description and unfolds them into discrete nodes through a two-layer structure of perspective and instantiation. On this basis, PDG-A evaluates the qualification relationships between node pairs within the context of the entire narrative to form directed edges. After resolving cycles, it generates the concrete preference for each current node in topological order conditioned on the preference context of its ancestral nodes, allowing downstream preferences to be progressively refined with each additional qualification to complete the preference dependency graph (PDG). Relying on this PDG, we first acquire candidates and their associated evidence from the open Web via directed path retrieval, and then compute candidate scores through topological path ranking, ultimately delivering recommendation results that better fit the specific preferences of the user.

The main contributions of this work are summarized as follows.

• We propose PDG-F (Preference Dependency Graph Framework), a narrative-driven recommendation framework that organizes user qualifying constraints into a progressively refined directed dependency structure, providing a principled structural representation for complex composite preferences.

• We develop a structure-guided decision mechanism built directly upon the constructed PDG (Preference Dependency Graph), comprising directed path retrieval to acquire candidate evidence from the Web under specific qualification constraints and topological path ranking to compute candidate scores, thereby unifying evidence gathering and final recommendation under a coherent structure.

• We conduct comprehensive experiments across three distinct domains encompassing movies, books, and anime in both English and Chinese contexts, demonstrating that PDG-F consistently achieves state-of-the-art performance against competitive baselines as well as modern commercial retrieval engines alongside frontier models and LLM agents, with ablations and diagnostic analyses verifying the efficacy of dependency modeling.

Related Work

Translating natural narratives into accurate item recommendations hinges on effectively understanding and operationalizing the multifaceted needs woven into unstructured text. Guided by varying depths of textual interpretation and representation paradigms, existing efforts have broadly evolved across three paradigms: explicit feature matching, representation learning, and LLM-based recommendation with evidence augmentation.

Explicit feature matching focuses on distilling concrete recommendation signals from unstructured narratives through signal integration, request element extraction, and narrative trope generation. Early work by Bogers and Koolen [5] combined narrative context with referenced example items to exploit the complementarity between explicit exemplars and descriptive intent. To obtain more specific recommendation cues, Eberhard et al. [7] automated the extraction of request elements into discrete recommendation cues, while Kanchi et al. [16] generated narrative trope tags from book descriptions to incorporate specific story patterns into candidate reranking. However, these methods primarily organize recommendation around feature matching, still lacking explicit representations for the modifier and qualification relationships among preference elements.

Representation learning approaches compute relevance by learning semantic correspondences between narrative requests and items, expanding from embedding-based matching [18, 26] to task adaptation, data augmentation, and general-purpose representation transfer. Early work by Eberhard et al. [9] leveraged embedding representations to analyze the predictive utility of distinct request elements, while Chaganty et al. [6] adopted contrastive learning to train dual-encoder retrieval models between conversational context and songs. Addressing the sparsity of narrative supervision, Mysore et al. [23] utilized LLMs to synthesize narrative queries from user interactions, providing supervision for dense retrieval models. To better capture domain semantics, Eppure et al. [11] fine-tuned models to align natural language requests with high-level track descriptions. Broadening the scope to general recommendation and search, Attimonelli et al. [3] validated the zero-shot capabilities of general-purpose text embeddings. Although these efforts substantially advance semantic relevance modeling, they still lack explicit characterization of the qualification scope and inter-dependencies among diverse preference criteria.

LLM-based methods leverage powerful language understanding and reasoning capabilities to interpret narrative intents, evolving from direct generation relying on internal parametric knowledge toward evidence-augmented paradigms that integrate external retrieval and structured attributes [20]. Eberhard et al. [8] systematically evaluated different models and prompting strategies, benchmarking the feasibility and boundaries of directly generating recommendations from parametric memory. To alleviate the limitations of static parametric knowledge, subsequent efforts focus on equipping LLMs with external grounding evidence: Zhu et al. [32] integrated collaborative retrieval into conversational recommendation to inject behavioral signals for candidate generation, while Shi et al. [28] utilized dynamic attribute templates, open-domain retrieval, and attribute completion to construct structured profiles for fine-grained candidate comparison. Despite enriching the grounding evidence for candidates, these approaches still do not explicitly leverage preference dependencies to coordinate retrieval and candidate evaluation.

Methodology

Problem Formulation

Given a user’s natural language narrative request $q$, narrative-driven recommendation aims to return a ranked list of top-$K$ items from the item space $\mathcal{I}$ that satisfy the articulated needs. The request $q$ can incorporate descriptions of the target item, reference items, and user evaluations. The system output is an ordered recommendation list:

Notably, NDR does not presuppose a fixed candidate item pool; candidates are typically derived from web retrieval or the parametric knowledge of LLMs. Given the request $q$, the system first acquires a candidate set $C_q \subseteq\mathcal{I}$ along with its supporting evidence $\mathcal{E}_q$, and subsequently ranks the candidates:

where $\operatorname{Acquire}(\cdot)$ denotes the process of obtaining candidate items and associated evidence from the aforementioned sources, and $S(i \mid q, \mathcal{E}_q)$ evaluates the extent to which candidate item $i$ satisfies request $q$ based on evidence $\mathcal{E}_q$.

Preference Graph Construction

PDG-A, an autonomous decision-making agent, first determines interpretive perspectives and their concrete instantiations based on narrative $q$, expanding the user’s preference descriptions into a discrete node set $V_q$, where each node $v$ has an initial representation $c_v^0$. It then identifies qualification relationships between nodes within the narrative context to construct directed edges $(u,v) \in E_q$. Finally, it resolves cycles and generates a concrete preference description $f_v$ for each node in topological order, conditioned on the preferences expressed by ancestor nodes, completing the node representation as $c_v = (c_v^0, f_v)$. This yields a request-specific preference dependency graph $G_q = (V_q,E_q,\mathcal{F}_q)$, where $\mathcal{F}_q = \{f_v\}_{v\in V_q}$.

Node: Preference Instantiation

A user narrative $q$ typically intertwines referenced items, subjective feedback, and explicit criteria for recommendations. PDG-A first distills these into a set of preference atoms $\mathcal{A}_q = \{a_i\}_{i=1}^{M}$, and subsequently decomposes each atom along a two-tiered hierarchy comprising interpretive perspectives and their concrete instantiations. Formally, for each atom $a_i \in\mathcal{A}_q$:

• An interpretive perspective $p \in\mathcal{P}_i$ specifies the semantic dimension along which the atom is interpreted (e.g., genre, director, or cast);

• A concrete instantiation $z \in\mathcal{J}_{i,p}$ anchors the specific realization within that perspective.

Each admissible tuple $(a_i,p,z)$ instantiates a distinct preference node $v \in V_q$. The initial state of node $v$ is formalized as a quadruplet:

Here, the feature field is initialized to $\varnothing$, reserved for the context-aware preference description generated later via topological propagation over ancestral constraints.

For example, given the raw user input: “I am looking for a movie similar to Harry Potter…”, PDG-A extracts the preference atom $a_i = \textit{Harry Potter}$. Conditioned on this atom, the interpretive perspectives determined by the agent can include genre, director, or actor, among others. Taking the perspective $p = \text{actor}$ as an example, the concrete instantiation can be $z = \text{Emma Watson}$, which forms distinct nodes alongside other instances such as Daniel Radcliffe and Rupert Grint. Both the perspective set $\mathcal{P}_i$ and instantiation set $\mathcal{J}_{i,p}$ are dynamically determined by PDG-A conditioned on the current atom and the full narrative context, ultimately yielding

nodes.

Edge: Qualification Dependencies

Independent node representations do not yet determine their semantics in a compositional context, where the same element may qualify different preference targets. To explicitly capture such relationships, we define a directed edge $(u,v)$ indicating that node $v$ imposes a concrete qualification upon the base preference expressed by node $u$. The edge direction is determined by the semantic structure of narrative $q$, reflecting a dependency directed from a foundational interpretation toward further refinement.

For any two distinct nodes, PDG-A jointly considers the complete narrative $q$, the initial representations $c_u^0,c_v^0$, and their original atoms to determine whether one node qualifies the preference target, presentation manner, or applicability conditions of the other:

where $(u,v)$ indicates that $v$ further qualifies $u$, $(v,u)$ indicates qualification in the reverse direction, and $\varnothing$ denotes the absence of any qualification dependency. The full narrative provides the overarching context, while the two nodes specify the concrete preference interpretations under examination.

For example, if $q$ involves “romance gradually develops through conflict”, let $u$ denote the romance node and $v$ the conflict interaction node; then $d_q(u,v)=(u,v)$, establishing the dependency $u \to v$ to signify how the conflict interactions further qualify how the romance unfolds. Conversely, if $q$ merely demands romance and conflict as independent requirements, then $d_q(u,v)=\varnothing$, and no edge is created.

PDG-A evaluates all unordered node pairs and aggregates the non-empty decisions into the initial edge set:

This yields the initial directed graph $G_q^0=(V_q,E_q^0)$. A node can possess multiple successors, representing divergent refinement branches of the same preference, as well as multiple predecessors, preserving its dependencies across multiple upstream contexts.

Graph: Cycle Resolution

Local judgments between node pairs may produce directed cycles, creating circular qualifications that prevent preferences from being progressively refined in a consistent order. PDG-A therefore revisits cyclic dependencies within the complete narrative context to resolve conflicts among local judgments.

Given the current edge set $E^t_q$, we identify a strongly connected component $S_t$ containing a directed cycle. Based on narrative $q$, the relevant nodes and their original atoms, the internal dependencies, and the external connections of the component, PDG-A selects the internal edge $e_t$ least supported by the narrative for removal:

Strongly connected components are recomputed after each removal until no directed cycle remains.

For example, suppose $q$ expresses that “romance gradually develops through conflict and deepens through subsequent reconciliation.” Let $u = \text{romance}$, $v = \text{conflict interactions}$, and $w = \text{reconciliation after conflict}$. If local judgments establish dependencies $d_q(u,v)$, $d_q(v,w)$, and $d_q(w,u)$, they form a directed cycle $u \to v \to w \to u$. Within the narrative context, the first two dependencies progressively qualify how the romance develops, whereas $(w,u)$ returns from reconciliation to the broader romantic preference. PDG-A therefore removes $e_t = (w,u)$, retaining the refinement path $u \to v \to w$.

Once the graph is acyclic, we apply transitive reduction. If an indirect path $u \to\cdots\to v$ already exists, the direct shortcut edge $(u,v)$ is removed, eliminating transitive redundancy while preserving reachability and direct refinement dependencies. This yields the final edge set $E_q$ and a valid topological ordering $\pi_q$ satisfying $\pi_q(u) < \pi_q(v)$ for all $(u,v) \in E_q$, providing a dependency-consistent order for subsequent preference propagation.

Preference: Contextual Refinement

The initial node representation $c^0_v$ specifies a concrete direction for interpreting a preference, while the dependency structure determines its meaning within the compositional context. PDG-A completes node representations in topological order $\pi_q$, using upstream preferences as context and incorporating the current node’s qualification to generate a concrete preference description.

For node $v$, let $\operatorname{Anc}(v)$ denote its ancestor set. PDG-A jointly considers the complete narrative $q$, the current representation $c^0_v$, the preference descriptions already generated for ancestor nodes in $\operatorname{Anc}(v)$, and the dependencies among these nodes to generate $f_v$. This description fills the reserved field, yielding $c_v = c^0_v[\text{feature} \leftarrow f_v]$. The topological order ensures that all ancestor descriptions are determined prior to generating $f_v$. For nodes without ancestors, the description is determined by their own initial representations and the original narrative.

For example, node $u$ represents “a concealed motive to evade accountability behind an appearance of innocence,” while node $v$ represents “a lawyer’s loyalty to a client and the associated moral dilemma.” Along $u \to v$, PDG-A refines the preference at $v$ into $f_v =$ “the lawyer’s duty to protect a client may instead enable the client to evade accountability.” The upstream concealed motive thus reshapes the interpretation of professional loyalty, explicitly manifesting the moral conflict between professional responsibility and its actual consequences.

When multiple dependency paths converge at a node, PDG-A synthesizes the path structure and the original narrative to capture the corresponding compositional or alternative relations within a single $f_v$. The resulting preference descriptions across all nodes yield the complete preference dependency graph:

providing concrete preference criteria for subsequent retrieval and candidate evaluation.

Directed Path Retrieval

Rewriter

Preference dependencies represent user needs as structural relationships between nodes, whereas Web retrieval requires concrete search expressions capable of capturing these compositional qualifications. Accordingly, for each retained dependency edge $(u,v) \in E_q$, PDG-A jointly examines the complete narrative $q$ and the initial endpoint representations $c^0_u,c^0_v$ to interpret the base preference under the qualification imposed by the target node, reformulating it into an effective search query $r_{uv}$ following Google Search query syntax. Each query aligns with the language of the user narrative and translates the qualification relationship into targeted keywords and search operators, steering retrieval toward the composed preference semantics.

For a node $v$ without predecessors, its search intent is governed independently by the narrative $q$ and its own initial representation $c^0_v$. To unify query formulation, we introduce a virtual root node ROOT and generate an entry query $r_{\mathrm{ROOT},v}$ for each such predecessor-free node. Let $E^+_q$ denote the edge set augmented with these virtual entry edges. The resulting queries collectively constitute the retrieval query set:

Query

We execute the query set $Q_q$ through the Serper API and collect URLs from the returned organic search results. We filter these URLs by resource type, removing invalid URLs, social media websites, PDF documents, videos, and other excluded resource types.

Let $U(r_{uv})$ denote the filtered URL set returned for query $r_{uv}$. Through the dependency edge $(u,v) \in E^+_q$, these URLs are associated with the target node $v$, providing sources for subsequent candidate recall under its specific preference. Each node aggregates and deduplicates the URLs returned by all its incoming-edge queries:

The same URL may be associated with multiple nodes, allowing candidate items and relevant descriptions to be extracted separately according to each node’s preference.

Recall

For the URL set $\mathcal{U}_v$ associated with node $v$, we fetch the webpage text, resolve redirection targets, and inspect MIME resource types, pruning failed requests, empty bodies, and exceptionally large pages exceeding 200,000 characters. For each node, we then select at most the top 3 pages sorted by text length in descending order, and segment the contents into chunks of up to 12,000 characters with a 2,000-character overlap between adjacent passages, forming the text corpus $\mathcal{B}_v$. When identical URLs are shared across multiple nodes, the parsed text and chunks are reused while preserving their individual node assignments.

For each chunk $b \in\mathcal{B}_v$, the model extracts candidate items $i$ along with their associated textual evidence $x_{v,i}^{(b)}$, guided by the node’s refined preference description $f_v$. Each extracted entry is formalized as $\langle\text{name},\text{year},x_{v,i}^{(b)}\rangle$, recording the item name, release year if explicitly mentioned (or empty otherwise), and concrete descriptions pertinent to the active preference. A candidate record is formed only when a chunk simultaneously provides both unambiguous item identification and substantive content. Crucially, the extraction faithfully retains statements whether they support or contradict the preference, decoupling evidence extraction from subsequent preference verification. Because extraction is strictly conditioned on node $v$, extracted candidates and their evidence naturally inherit node provenance, allowing a single text chunk to yield distinct records under different node specifications $f_v$.

Following extraction, we identify and exclude reference items already mentioned in the initial request $q$ using name and year metadata, and then deduplicate candidates within each node. For the same item, identical descriptions are removed, and distinct descriptions are sequentially concatenated into a consolidated text $x_{v,i}$, with their source URLs retained, yielding the node candidate set $C_v$. Cross-node descriptions are maintained independently to ensure that the factual evidence for an item across different preference facets remains unentangled. This produces the global candidate set and the node-grounded evidence set for the narrative request:

where $x_{v,i}$ encapsulates the web-grounded descriptions aligned with preference $f_v$, providing fine-grained evidence for candidate evaluation along the preference dependency paths.

Topological Path Ranking

Initial Scoring

We collect the preference descriptions of the current node $v$ and all its ancestors into $F_v = \{f_u \mid u \in\operatorname{Anc}(v) \cup\{v\}\}$, where $\operatorname{Anc}(v)$ denotes the ancestor set of $v$, and $f_u$ is the concrete preference description of node $u$. For each item $i$ recalled at node $v$, we hold its retrieved description $x_{v,i}$ fixed and compare it against every preference description $f_u \in F_v$, assessing how the same textual evidence supports the active and upstream preferences. PDG-A assigns a relation label based solely on the text pair $(x_{v,i},f_u)$, which the system then maps to an initial score:

The judgment respects the qualification scope, preference strength, and permitted alternatives expressed in $f_u$. Missing details alone do not establish an explicit contradiction, and permitted alternatives need not hold simultaneously. An explicit contradiction assigns zero only to the current pairwise comparison, without removing the candidate or altering its other comparison scores. These initial scores provide the foundation for subsequent dependency-path computation.

Topological Path Computation

The initial scores quantify how an item description supports individual node preferences. We further aggregate these scores along dependency paths to assess how the same description supports progressively refined preferences. For an item $i$ recalled at node $v$, we hold its retrieved description $x_{v,i}$ fixed and traverse the subgraph induced by node $v$ and all its ancestors $\operatorname{Anc}(v)$ according to the topological order in the DAG. Let $\operatorname{Pa}(u)=\{p\mid(p,u)\in E_q\}$ denote the immediate predecessor set of node $u$, and let $H(x_{v,i},u)$ denote the optimal path score ending at $u$, computed using this fixed description. The recurrence is defined as:

where $s(x_{v,i},f_u)$ is the initial score defined in Eq. (11), and $\gamma\in[0,1]$ is a discount factor (set to 0.7 in our implementation). A node without predecessors initializes its path score with its own initial score. For a node with predecessors, its initial score is combined with the discounted optimal path score from its predecessors. The topological order guarantees that all predecessor path scores are determined before evaluating node $u$.

When multiple predecessors converge at a node, the maximum operator isolates the highest-scoring refinement path. Along this trajectory, each additional edge traced upstream introduces an extra factor of $\gamma$, exponentially decaying the contribution of more distant ancestors while prioritizing preferences proximal to the current node. The recurrence consistently evaluates the identical evidence $x_{v,i}$ and ultimately yields $H(x_{v,i},v)$, the path score for item $i$ under node $v$. The virtual root used for retrieval is excluded from scoring.

The same candidate item may be recalled across multiple nodes with distinct node-specific descriptions. Let $V_i=\{v\in V_q\mid i\in C_v\}$ denote the set of nodes where item $i$ is retained. We aggregate its path scores across these nodes and apply a logarithmic compression to obtain the final graph-grounded score:

Each node evaluates its path score independently using its own extracted description, and evidence from multiple webpages mapped to the same node is consolidated to contribute only once. An ancestor preference participating in the path computation of a descendant candidate does not spuriously introduce an extra candidate record at that ancestor node.

Experiment

Experimental Setup

Datasets. Following the experimental setup of OCG-Agent [28], we first adopt Reddit MovieSuggestions, a widely used benchmark for narrative-driven recommendation [7, 8, 9, 10, 28]. We seek to further validate the capability of PDG-F across diverse tasks. Given that the proprietary education [28] dataset is not publicly accessible, we instead collect two datasets from public online communities, namely Book with 30 English queries from Reddit and Anime with 30 Chinese queries from Xiaohongshu and Zhihu.

We adapt the curation methodology of Reddit MovieSuggestions [10] to construct these two benchmarks. For each sample, the input query is obtained by faithfully summarizing an informative recommendation post while preserving user preferences, constraints, and contextual details. The ground-truth items are scored based on community support, defined by the peak engagement achieved across recommending replies, namely the net vote score on Reddit or the like count on Xiaohongshu and Zhihu. When reliable engagement scores are unavailable for a query, we quantify community support by recommendation frequency within the collected replies.

Evaluation. We evaluate recommendation performance using Precision@10, Recall@10, and NDCG@10 [15, 22]. For each query, we follow the original setting of OCG-Agent [28] by performing retrieval once and running RankGPT reranking [29] three times, reporting the averaged results. For our method, PDG-F, ranking scores are computed deterministically from the constructed graph and collected evidence, so a single ranking run is sufficient.

Baselines. Given the continuing improvements in LLM capabilities, we rerun experiments with frontier models, including three leading Chinese models, Qwen-3.8-27B, DeepSeek-V4-Pro, and MiniMax-M3, as well as GPT-6-Astra, a leading international model. We also include Perplexity, a widely used commercial AI search engine. We set the reasoning effort to high for all models except GPT-6-Astra, which uses xhigh. For OCG-Agent [28], we reproduce its pipeline using Qwen-3.8-27B as the LLM backbone. Our method, PDG-F, uses the same Qwen-3.8-27B backbone, which we deploy locally on four H20 GPUs with 140 GB of memory each. Since the remaining model API calls and search services incur monetary costs, we follow OCG-Agent [28] and randomly sample 100 Movie queries for evaluation.

Result Analysis

Overall Performance. Table 1 summarizes the performance comparison across the three benchmark datasets. Overall, our proposed PDG-F (+Year) achieves the best performance on all three datasets across all evaluation metrics. Specifically, on the Movie dataset, PDG-F (+Year) outperforms the strongest competing baselines by 13.7%, 14.1%, and 19.6% in P@10, R@10, and NDCG@10, respectively. The gains are even larger on the Book and Anime benchmarks, where PDG-F (+Year) achieves a 92.4% improvement in P@10 on Book and a 60.9% gain in R@10 on Anime over the best competing methods. These consistent improvements across diverse domains substantiate the value of explicitly modeling preference dependencies and integrating supporting evidence for narrative-driven recommendation.

Method	Movie			Book			Anime
	P@10	R@10	NDCG@10	P@10	R@10	NDCG@10	P@10	R@10	NDCG@10
qwen3.8-27B	0.2730	0.1645	0.3280	0.1100	0.0989	0.1492	0.0267	0.0383	0.0429
minimax-m3	0.3070	0.1885	0.3647	0.1900	0.1589	0.2606	0.0633	0.0791	0.0979
deepseek-v4-pro	0.3170	0.1954	0.3753	0.1867	0.1648	0.2526	0.0567	0.0736	0.0884
OCG-Agent	0.2410	0.1448	0.2647	0.2200	0.2299	0.3264	0.1133	0.1356	0.1901
OCG-Agent (+Year)	0.2880	0.1693	0.3284	0.2200	0.2299	0.3264	0.1167	0.1389	0.1922
Perplexity AI	0.2700	0.1656	0.3206	0.1733	0.1396	0.2182	0.1667	0.1692	0.2028
GPT-6-Astra (Codex)	0.3210	0.1938	0.3771	0.1800	0.1410	0.2078	0.1467	0.1411	0.1888
Ours	0.3010	0.1865	0.3631	0.4233	0.3480	0.5101	0.2467	0.2722	0.3025
Ours (+Year)	0.3650	0.2229	0.4511	0.4233	0.3480	0.5101	0.2467	0.2722	0.3085

Further Analysis. The performance disparities across domains and model variants may partly reflect temporal retrieval biases and differences in knowledge coverage. First, web search often favors recent and popular content, whereas the Movie benchmark frequently targets historical or classic titles. Accordingly, the (+Year) variant applies rule-based temporal comparison and filtering using the extracted release year metadata to exclude candidates that violate temporal constraints. Incorporating year information helps counter this mismatch by reducing the prominence of newer candidates, yielding substantial gains on Movie while gains on Anime remain more limited. Second, classic movie plots and item profiles are likely well represented in LLM pretraining corpora, helping direct prompting remain competitive on Movie. Newer or less documented content in Book and Anime may be less well covered by parametric knowledge, making external retrieval more valuable in these domains.

Ablation Study

Candidate Recall Analysis

We compare the candidate acquisition of PDG-F and OCG-Agent across overall pool coverage, relevant item overlap, and ranking-level Recall@$k$.

Candidate Coverage

Table 2 compares candidate acquisition against the strongest retrieval baseline, OCG-Agent. Across the three datasets, PDG-F constructs substantially broader candidate pools, averaging roughly 250 to 690 items per request, compared with around 20 for OCG-Agent. Crucially, this expansion does not merely introduce noise, as pool recall approximately doubles or more across the three domains, increasing from 0.2102 to 0.4858 on Movie, from 0.2854 to 0.5481 on Book, and nearly tripling from 0.1672 to 0.4734 on Anime. This confirms that decomposing narrative preferences across dependency nodes effectively retrieves diverse, high-utility ground-truth items, establishing a much stronger candidate foundation for subsequent topological ranking. Importantly, because PDG-F scores candidates through deterministic graph accumulation rather than prompting-based listwise rerankers such as RankGPT, such candidate pool expansion avoids the pitfalls of context window limits [25], position bias [30], and prohibitive inference latency.

Dataset	Method	Avg. candidates	Pool recall
Movie	PDG-F (+Year)	251.84	0.4858
Movie	OCG-Agent	22.52	0.2102
Book	PDG-F (+Year)	687.33	0.5481
Book	OCG-Agent	17.63	0.2854
Anime	PDG-F (+Year)	366.30	0.4734
Anime	OCG-Agent	17.33	0.1672

Recall across Recommendation Lengths

Figure 2 illustrates how broader candidate acquisition translates into ranking recall across varying recommendation lengths. As $k$ grows from 1 to 50, the recall trajectories exhibit markedly different saturation behaviors. Due to its constrained candidate pool, OCG-Agent rapidly plateaus around $k = 20$ across all datasets, yielding minimal gains as the list extends further. In contrast, PDG-F with year maintains a continuous upward trajectory, consistently surfacing additional relevant items throughout longer lists. Remarkably, its Recall@10 alone surpasses the entire complete-pool recall of OCG-Agent across all three benchmarks. On Anime, OCG-Agent exhibits a slight advantage at the extreme top position, with a Recall@1 of

0.0492 versus 0.0359 for PDG-F with year, yet PDG-F rapidly overtakes it as $k$ reaches 10 and beyond. This demonstrates that the candidate coverage advantages of PDG-F become increasingly pronounced when presenting multi-item recommendation lists.

Complementarity of Retrieved Items

Figure 3 further examines where the additional coverage comes from. Relevant items found exclusively by PDG-F account for 30.41%, 33.57%, and 38.85% of all ground-truth items on Movie, Book, and Anime, respectively, while those found exclusively by OCG-Agent account for 2.86%, 7.29%, and 8.24%. These proportions are computed per query and then macro-averaged. Thus, PDG-F’s coverage advantage includes a substantial number of relevant works absent from the baseline pools, illustrating the additional coverage obtained from candidate acquisition under different preference perspectives. OCG-Agent also retrieves some relevant items missed by PDG-F, indicating that the candidate sources remain partially complementary.

Ranking Analysis

We analyze node aggregation strategies, score discriminability, oracle performance gaps, and the role of dependency modeling.

Ranking Strategy Comparison

Table 3 compares node aggregation strategies on identical candidate pools against a random ranking baseline. Mean aggregation degrades severely across all datasets because averaging dilutes decisive signals across nodes. Taking the maximum node score provides a viable baseline, confirming that prominent local matches offer useful discrimination. Notably, this maximum node score already benefits from our propagation strategy by inheriting contextual preference constraints from ancestor nodes. Even with this contextual advantage, the full additive strategy consistently achieves higher NDCG@10 across all domains, and even more notably, it more than doubles the performance on Book and Anime, demonstrating the effectiveness of our cumulative evidence design.

Strategy	Movie	Book	Anime
Random	0.0641	0.0163	0.0242
Mean node	0.1506	0.0178	0.0667
Max node	0.3205	0.1997	0.1255
Full strategy	0.4511	0.5101	0.3085

Graph Scores and Relevance

Figure 4 evaluates the discriminative power of the computed graph scores within the expanded candidate pools. Partitioning candidates into score deciles reveals that ground-truth relevant items are heavily concentrated in the top decile, achieving relevance rates of 17.97%, 8.01%, and 7.92% on Movie, Book, and Anime, respectively, compared with only 1.87%, 0.10%, and 0.18% in the bottom decile. This sharp separation directly reflects the scoring quality because candidates assigned high graph scores are significantly more likely to be truly relevant, whereas irrelevant candidates are successfully suppressed into lower deciles. The cross-domain consistency of this trend confirms that the graph score functions as a reliable relevance indicator, validating that evaluating evidence along interdependent preference paths effectively captures whether an item satisfies the user’s composite needs.

Candidate Acquisition and Ranking Gaps

We finally examine Figure 5 to decompose the gap to ideal NDCG@10 into candidate-pool coverage and within-pool ranking accuracy. Across all domains, PDG-F achieves markedly higher pool-oracle upper bounds than OCG-Agent, confirming that multi-path acquisition builds a far stronger candidate foundation. At the same time, the visible ranking gaps highlight that while candidate retrieval raises the performance ceiling, ranking retrieved relevant items into top positions remains the primary bottleneck and leaves substantial room for future improvement.

Dependency Modeling Analysis

The empirical comparison between PDG-F and OCG-Agent naturally constitutes an ablation over dependency modeling. Specifically, our preference nodes refine the dynamic attribute representations of OCG-Agent through redesigned extraction sources and field specifications, while the overarching innovation lies in establishing directed qualification graphs. In the absence of directional dependency edges, candidate acquisition reduces to uncoordinated retrieval across isolated preference nodes. Furthermore, lacking the underlying graph structure precludes our topological path ranking, forcing candidate evaluation to revert to standard prompting-based reranking via RankGPT. Under this double degradation, the framework essentially degenerates into the baseline pipeline of OCG-Agent. The substantial performance margins across all evaluation domains, as shown in Table 1, therefore confirm that directional qualification modeling serves as the decisive driver for enhanced candidate acquisition and relevance discrimination.

Conclusion

We presented PDG-F, a framework for narrative-driven recommendation that captures how user preferences qualify one another through directed acyclic graphs. By carrying these qualification relationships into candidate acquisition and topological evidence accumulation, the framework connects narrative understanding with evidence-based recommendation. Experiments across three domains demonstrate broader relevant-item coverage and improved recommendation performance over competitive baselines. Oracle analysis further shows that this broader coverage raises the attainable performance ceiling, while the remaining ranking gap motivates more accurate evidence scoring to realize that potential.

References