---
title: Recall Router in MemoCue
url: https://www.emergentmind.com/topics/recall-router
type: topic
---

# Recall Router in MemoCue

Recall Router denotes, in MemoCue, a framework for **strategy-guided agent-assisted memory recall** in which an agent does not merely retrieve information from an external memory module, but instead transforms an original user query into a **cue-rich** query intended to activate the person’s own relevant memory [2507.23633]. The framework addresses two explicit problems: choosing an appropriate recall strategy for diverse forgetting scenarios, and generating high-quality strategy responses from abstract strategy patterns. Its solution is a two-stage architecture consisting of a **5W Recall Map** for scenario routing and a **hierarchical recall tree** combined with **Monte Carlo Tree Search (MCTS)** for strategy selection and cue-query generation, and it is used to construct the instruction-tuned system MemoCue [2507.23633].

## 1. Concept and problem setting

Recall Router is introduced for the **Strategy-Guided Recall (SGR)** setting, where the agent is expected to help a person reconstruct incomplete or vague memories by asking better questions rather than only retrieving stored content. The motivating claim is that conventional memory agents are constrained by the limited size of their memory module, which hinders acquisition of complete memories and affects practical recall performance. MemoCue therefore treats memory assistance as a routing problem over **recall strategies** rather than as direct answer extraction alone [2507.23633].

The framework formalizes two challenges. The first is **strategy selection**: queries such as “Where are my keys?”, “Who was that person?”, “When did I take my medication?”, and “Why did I choose this option?” require different forms of cueing. The second is **response realization**: the strategy inventory is grounded in memory theory, but the system must still translate abstract strategy descriptions into concrete, useful prompts. Recall Router addresses the first by classifying the query into one of five forgetting scenarios and the second by searching over strategy-conditioned cue queries with a hierarchical decision process [2507.23633].

A recurring misconception is to treat the framework as a conventional retrieval pipeline. The paper explicitly distinguishes it from that view: the agent is designed to **transform** the original query into a cue-rich one, so that the person’s own memory can be proactively activated. This suggests that Recall Router is better characterized as a **strategy router over memory cues** than as a pure retriever [2507.23633].

## 2. The 5W Recall Map

The first routing stage is the **5W Recall Map**, inspired by Lasswell’s 5W communication model. It classifies a user query into five scenarios: **Event (What)**, **Person (Who)**, **Location (Where)**, **Temporal (When)**, and **Decision (Why)** [2507.23633]. The routing target is the type of forgetfulness rather than surface wording alone.

The paper states that the classification module is a **fine-tuned RoBERTa model**. For training, **GPT-3.5-turbo** is used with few-shot prompting to annotate **2,000 samples**, these annotations are manually verified, and the resulting classifier is trained on an **A100-80GB GPU** for **500 epochs** with **batch size 32** [2507.23633]. The output of this classifier determines which strategy family the router may search over.

The five scenarios correspond to distinct cue sources. Event queries target forgotten actions or episodes; Person queries target identity, relation, or appearance; Location queries target spatial context; Temporal queries target timing, sequence, or routines; and Decision queries target motives, preferences, or decision logic [2507.23633]. This classification is the framework’s primary “routing” decision.

## 3. Strategy inventory and hierarchical recall tree

Recall Router defines **15 recall strategy patterns**, grouped three per scenario. These strategies are explicitly described as cognitively grounded cueing patterns rather than generic prompt templates [2507.23633].

| Scenario | Strategies | Primary cue basis |
|---|---|---|
| Event (What) | Scenario Reconstruction; Interpersonal Interaction; Sensory Activation | Context, social context, sensory traces |
| Person (Who) | Appearance Clues; Role Connection; Emotion Trigger | Appearance, relation, emotional association |
| Location (Where) | Multiple Associations; Immersive Recall; Spatial Cues | Associations, scene/path, spatial layout |
| Temporal (When) | Timeline Rewind; Key Milestones; Routine Pattern | Sequence, anchor times, habits |
| Decision (Why) | Background Motivation; Option Comparison; Experience Support | Motives, trade-offs, prior experience |

The framework models strategy use as a **hierarchical Markov Decision Process** with a **hierarchical recall tree** [2507.23633]. At the high level, the state is
$$
s_t^h = (Q_u, H_t, M_t),
$$
where \(Q_u\) is the original user query, \(H_t\) is dialogue history, and \(M_t\) is retrieved relevant memory from the memory bank up to turn \(t\). The high-level action space is the 15-strategy pool, and the selected action is a strategy pattern.

At the low level, the state becomes
$$
s_t^l = (s_t^h, a_t^h),
$$
and the action is a concrete cue query \(Q_c\). The paper writes the low-level generation rule as
$$
a_t^l \sim \mathcal{P}(a \mid s_t^l), \qquad \mathcal{P}(a \mid s_t^l) = \operatorname{LM}(Q_c \mid s_t^l),
$$
with best-response selection
$$
a_t^l = \arg\max_{Q_c \in \mathcal{A}^l} \mathcal{P}(Q_c \mid s_t^l).
$$
This separates **which strategy to use** from **how to phrase the cue** [2507.23633].

The transformation objective is summarized in the paper as
$$
Q_c = \mathcal{T}(Q_u, S),
$$
where the cue query is derived from the original query and the chosen strategy. In effect, the tree stores strategy-conditioned dialogue states, previous cueing attempts, and memory evidence, making strategy search adaptive across turns rather than static [2507.23633].

## 4. SGR-MCTS optimization

The search procedure is **SGR-MCTS**, which applies **selection**, **expansion**, **simulation**, and **backpropagation** to the hierarchical recall tree [2507.23633]. The root node is the original user query, and each rollout searches for a high-reward strategy-response path.

During **selection**, child nodes are chosen by **UCT**:
$$
a = \arg\max_{a \in \mathcal{A}^h} \left( \widehat{Q}_i + c \cdot \sqrt{\frac{\ln N(p)}{N(i)}} \right),
$$
where \(\widehat{Q}_i\) is the average reward of node \(i\), \(N(p)\) is the parent visit count, \(N(i)\) is the node visit count, and \(c\) is the exploration constant [2507.23633]. Expansion then uses the LLM to generate a cue query
$$
Q_c = f(s_t, a_t),
$$
followed by a simulated user response and state update.

The rollout stops when either sufficient response quality is reached or the dialogue-turn limit is exceeded:
$$
s_{end} =
\begin{cases}
\text{Success, if } \text{acc}(r_t, r_{\text{ans}}) \ge \theta_{\text{acc}} \\
\text{Failure, if } n_t \ge N_{\text{max}}
\end{cases}
$$
Here \(\text{acc}(\cdot)\) is a **BERTScore-based** similarity measure and \(r_{\text{ans}}\) is the true answer [2507.23633].

The reward is decomposed into three parts. **Recall Accuracy** \(R_{ra}\) is measured by BERTScore similarity between simulated response and true answer. **Recall Focus** uses Jaccard similarity,
$$
R_{rf} = \frac{|r_t \cap r_{\text{ans}}|}{|r_t \cup r_{\text{ans}}|},
$$
and **Recall Depth** counts recovered memory-element types,
$$
R_{rd} = \sum_{i=1}^{n} \mathbb{1}(e_i \in r_t),
$$
where the element set includes Event, Person, Location, Temporal, and Decision [2507.23633]. The paper states that Recall Depth is evaluated using **Qwen2.5-32B-Instruct**.

To avoid local optima, simulation uses an \(\varepsilon\)-greedy exploration factor, initialized at **1** and decreased by **0.05** during simulation [2507.23633]. After reaching a terminal state, backpropagation updates node value and visit count:
$$
Q(s_t) \leftarrow Q(s_t) + \left( \gamma^{T-t} \cdot R_{\text{end}} \right),
$$
$$
N(s_t) \gets N(s_t) + 1.
$$
The search budget is reported as **\(T=120\) iterations**, and the system retains the **top-\(k\)** paths with **\(k=5\)** for downstream dataset construction [2507.23633].

## 5. MemoStrategy dataset and MemoCue

The outputs of Recall Router are used to build the instruction-tuning dataset **MemoStrategy** [2507.23633]. Each sample contains the original user query \(Q_u\), a selected recall strategy \(s_i\), and a cue query \(Q_c\). The instruction-tuning format has three fields: **Instruction**, which includes task description and brief strategy definitions; **Input**, containing the original query; and **Output**, containing the recommended strategy and cue-query response.

Dataset construction follows the router’s search pipeline: analyze the user query, classify the forgetting scenario, select candidate strategies, generate cue queries, simulate user responses, and keep only effective samples. The paper also specifies quality filtering rules: invalid samples are removed when the response is unclear, fails to reveal valid recalled information, or lacks key details such as people or dates [2507.23633].

The paper contains an explicit inconsistency in dataset size. One description reports **5805 samples** split into **5200 train / 605 test**, while another reports **4805 samples** split into **4500 train / 305 test** [2507.23633]. Both descriptions refer to the same MemoStrategy construction pipeline.

MemoCue is then obtained by fine-tuning multiple open-source LLMs on MemoStrategy, including **Qwen2.5-14B-Instruct**, **Qwen2.5-7B-Instruct**, **Llama-3-8B-Instruct**, **Mistral-7B-Instruct**, and **Yi-9B** [2507.23633]. The reported training configuration uses **LoRA**, **batch size 8 per GPU**, **learning rate \(2 \times 10^{-5}\)**, **5 epochs**, and **8 Nvidia Tesla A100-80GB GPUs**. The resulting agent is designed to produce **strategy-aware** and **cue-rich** responses rather than generic prompts.

## 6. Evaluation, metrics, and related routing formulations

MemoCue is evaluated on **PerLTQA**, **LoCoMo**, and **MemoryBank** [2507.23633]. The paper describes PerLTQA as containing **141 user memory banks**, **8,593 QA pairs**, and **35,179 memory streams**; LoCoMo as containing **50 ultra-long conversations** of around **300 turns** and **9,000 tokens** each; and MemoryBank as containing **15 virtual users over 10 days** with **194 probing questions**. Baselines include multiple prompting variants of open-source models, as well as **gpt-3.5-turbo**, **gpt-4**, **gpt-4o**, and **o1-preview** [2507.23633].

The central automatic metric is **Balance of Recall Score (BRS)**,
$$
\text{BRS} = \frac{\text{Acc}(r_{res,i}, r_{ans,i})}{1 + \alpha \cdot \text{Sim}(Q_{u,i}, Q_{c,i})},
$$
with \(\alpha = 0.3\) [2507.23633]. The numerator rewards accurate recall through **BERTScore**, while the denominator penalizes cue queries that remain too similar to the original query. This metric encodes the framework’s central trade-off: the cue query should remain relevant, but it should not merely restate the user’s input.

The main experimental claim is that MemoCue surpasses LLM-based methods by **17.74% in recall inspiration** [2507.23633]. The strongest reported MemoCue configuration, based on **Qwen2.5-14B-Instruct**, achieves **78.15** on PerLTQA, **77.89** on LoCoMo, **72.42** on MemoryBank, and **76.15** on average [2507.23633]. Human evaluation further reports win rates of **83%** against GPT-4, **85%** against GPT-4o, and **78%** against o1-preview on dimensions including recall inspiration, response intelligence, and cue consistency [2507.23633].

In the broader literature, the Recall Router of MemoCue occupies one position within a larger family of **recall-oriented routing** systems. **SelRoute** routes memory-retrieval queries among lexical, semantic, hybrid, and vocabulary-enriched pipelines, achieving **Recall@5 of 0.800** on LongMemEval_M with **bge-base-en-v1.5** and a zero-ML **SQLite FTS5** baseline with **NDCG@5 of 0.692** [2604.02431]. **MemRouter** instead routes **write-side memory admission** in long-term conversational agents, training only **~12M trainable parameters** and reporting **overall F1 52.0 vs 45.6** against an LLM-based memory manager under a matched LoCoMo harness [2605.00356]. These systems do not define Recall Router in the MemoCue sense, but they show that contemporary routing research treats recall not as a single operation, but as a sequence of routing decisions over memory access, admission, and retrieval.

Source: https://www.emergentmind.com/topics/recall-router