HingeMem: Boundary Guided Long-Term Memory with Query Adaptive Retrieval for Scalable Dialogues

1. Problem Statement

Long-term memory is essential for dialogue systems to support continuous, personalized, and sustainable interactions. However, existing approaches face two critical limitations:

• Inefficient Memory Construction: Current methods rely on continuous summarization or OpenIE-based graph construction. These often fail to capture fine-grained event dynamics, leading to redundant operations, high computational overhead, and the loss of salient details.
• Rigid Retrieval Strategies: Most systems use fixed Top-k retrieval (e.g., always retrieving the top 5 or 30 items) based on semantic similarity. This approach lacks adaptability:
  • Some queries (e.g., "How many meetings did we hold?") require retrieving all relevant segments (high recall).
  • Others (e.g., "What was I doing at 12:00?") require only one precise segment (high precision).
  • Fixed-k strategies introduce noise (irrelevant memories) or miss critical evidence, causing performance drops of ~30% when query categories are unspecified.

2. Methodology: HingeMem

HingeMem is a neuro-inspired framework that simulates hippocampal-cortical interactions and Event Segmentation Theory (EST). It consists of two core components:

A. Boundary-Guided Long-Term Memory (Construction)

Instead of continuous writing, HingeMem triggers memory updates only when specific event boundaries occur.

• Boundary Detection: The system monitors four key elements: Person, Time, Location, and Topic. When any of these elements change within a dialogue session, a "boundary" is drawn.
• Hyperedge Construction:
  • Nodes: Key elements are extracted and organized into nodes (e.g., specific people, timestamps, locations).
  • Hyperedges: A segment of dialogue between two boundaries is encapsulated as a hyperedge connecting the relevant nodes with a semantic description.
  • Merging: Hyperedges are merged recursively if they share high similarity (Jaccard Score > 0.8) to reduce redundancy.
  • Salience Scoring: Nodes are assigned salience scores based on Frequency, Centrality, and Diversity to prioritize important information.
• Outcome: This creates an interpretable, structured index that preserves fine-grained details while minimizing storage overhead.

B. Query-Adaptive Retrieval

HingeMem generates a dynamic retrieval plan for each query, deciding what to retrieve and how much to retrieve, rather than using a fixed Top-k.

• Query Analysis: The system classifies queries into three types:
  1. Recall-Priority: Requires retrieving as many relevant hyperedges as possible (e.g., counting events).
  2. Precision-Priority: Requires the single most relevant hyperedge (e.g., specific facts).
  3. Judgment: Requires identifying any relevant piece of evidence to make a decision (e.g., "Did X happen?").
• Reranking Mechanism:
  • Salience Weighting: Scores are adjusted based on the priority of elements (e.g., Time > Person for "When did...").
  • Topic Penalty: A penalty term is applied to balance common vs. rare topics, ensuring rare but critical memories are not overshadowed by frequent ones.
• Adaptive Stopping:
  • Recall: Stops when the score drop indicates an inflection point (elbow method).
  • Precision: Stops when scores fall below 80% of the maximum score.
  • Judgment: Stops once a hyperedge with a high softmax score is found.

3. Key Contributions

1. Boundary-Guided Memory Architecture: Introduces a method to operationalize Event Segmentation Theory by writing memory segments only at element changes (Person, Time, Location, Topic), creating interpretable hyperedges that reduce redundancy.
2. Query-Adaptive Retrieval: Proposes a mechanism that dynamically determines retrieval depth and content based on query type (Recall, Precision, Judgment), overcoming the limitations of fixed Top-k strategies.
3. Template-Free Adaptability: Unlike previous methods that require category-specific templates, HingeMem works robustly without explicit query category specification.
4. Scalability: Demonstrates effectiveness across a wide range of LLM scales (from 0.6B to production-tier models like Qwen-Flash).

4. Experimental Results

The system was evaluated on the LOCOMO dataset (ultra-long dialogues with diverse question types) and compared against strong baselines like HippoRAG2, Mem0, LangMem, and standard RAG.

• Performance:
  • Achieved a ~20% relative improvement over strong baselines (e.g., HippoRAG2) in overall F1 scores without using category-specific templates.
  • Showed significant gains in Multi-hop (+10%+) and Temporal reasoning tasks.
  • Maintained stable performance across different LLM sizes (0.6B to Flash), whereas baselines often fluctuated or degraded with smaller models.
• Efficiency:
  • Token Cost: Reduced question-answering token costs by 68% compared to HippoRAG2.
  • Noise Reduction: By adaptively stopping retrieval, it avoids feeding irrelevant context to the LLM, improving both accuracy and inference speed.
• Ablation Studies: Confirmed that both the boundary-guided memory structure and the adaptive retrieval strategy are essential for the observed performance gains.

5. Significance

HingeMem addresses the scalability and efficiency bottlenecks in long-term dialogue memory. By mimicking human cognitive processes (event segmentation and adaptive retrieval), it offers a practical solution for:

• Web Applications: Enabling efficient, trustworthy memory over extended interactions without prohibitive computational costs.
• Edge Deployment: Its robustness across small and large models makes it suitable for deployment on resource-constrained mobile devices.
• Future Research: It establishes a new paradigm for memory design that moves beyond static summarization toward dynamic, event-driven, and query-aware memory management.