Memoria: A Scalable Agentic Memory Framework for Personalized Conversational AI

📝 Paper Summary

Agentic Memory Personalization

Memoria augments LLMs with persistent memory by combining dynamic session summarization and a recency-weighted knowledge graph to maintain user context and persona across distinct conversations without fine-tuning.

Core Problem

Standard LLM chat systems are stateless, treating each interaction in isolation and failing to retain user preferences or context across different sessions.

Why it matters:

Lack of memory forces users to repeatedly introduce themselves or restate preferences, increasing interaction friction
Current vector-only memory systems lack interpretability and conflict resolution, while graph-based systems often struggle with scalability and recency
Business applications like financial advisory or customer support require maintaining long-term continuity to build user trust and personalization

Concrete Example: If a user previously identified as an equity trader in a past session, a standard stateless agent will forget this context in a new session. Memoria retains this via a Knowledge Graph, allowing the agent to personalize future financial updates immediately without re-prompting.

Key Novelty

Hybrid Memory Architecture with Recency-Weighted Knowledge Graph

Combines two memory types: SQL-based structured logs for raw history/summaries (short-term) and a dynamic Knowledge Graph for user persona (long-term)
Introduces a 'weighted' KG engine that applies exponential decay to memory triplets, prioritizing recent interactions to resolve conflicts in user preferences over time

Architecture

Operational scenarios for Memoria: differentiating between New Users (no context) and Repeat Users (context retrieval).

Breakthrough Assessment

7/10

A strong architectural framework addressing the specific gap of combining short-term coherence (summaries) with long-term personalization (KG) in a modular, model-agnostic way.

⚙️ Technical Details

Problem Definition

Setting: Enhancing conversational agents with persistent episodic and semantic memory to enable long-term personalization

Inputs: User message and system prompt (plus optional Session ID)

Outputs: Context-aware LLM response based on retrieved history and user persona

Pipeline Flow

Group: Retrieval
Check User/Session Status → Retrieve Session Summary (if ongoing) → Retrieve Top-K Weighted Triplets (if repeat user)
Group: Generation
Augment Prompt with Context → Generate LLM Response
Group: Memory Update
Extract Triplets from Input → Update Vector DB & SQL → Generate/Update Session Summary

System Modules

Structured Conversation Logger

Persistently stores raw messages, timestamps, session IDs, and token usage in a SQL database

Model or implementation: SQL Database

User Modeling Engine (Memory Update)

Extracts knowledge triplets from user messages to build a dynamic user persona

Model or implementation: LLM (for extraction) + Vector Database

Session Summarizer (Memory Update)

Generates real-time summaries of the current dialogue to maintain short-term continuity

Model or implementation: LLM

Context Retriever

Fuses structured history and KG triplets to provide relevant context for the current prompt

Model or implementation: Vector Search + Heuristic Weighting

Novel Architectural Elements

Dual-memory retrieval mechanism fusing SQL-based session summaries with a vector-backed Knowledge Graph
Recency-aware weighting system for KG triplets that uses exponential decay to prioritize new information over old contradictions

Modeling

Base Model: Model-agnostic (Designed to integrate into any LLM-driven chat interface)

Training Method: Inference-time memory augmentation (No fine-tuning involved)

Comparison to Prior Work

vs. Vector Stores: Memoria adds interpretability via structured Knowledge Graphs and handles conflict resolution better
vs. Standard Graph Systems: Memoria integrates a specific recency-based weighting (exponential decay) to handle evolving user states, addressing the 'stale data' problem in static graphs
vs. Stateless LLMs: Adds persistent cross-session memory without requiring model fine-tuning

Limitations

No quantitative experiments or performance metrics were included in the provided text excerpt
Relies on the underlying LLM's ability to accurately extract triplets; extraction errors propagate to the memory
Does not enhance parametric memory (model weights remain static)

📊 Experiments & Results

Evaluation Setup

Not reported in the provided text

Metrics:

Statistical methodology: Not explicitly reported in the paper

Main Takeaways

The paper presents a framework rather than a specific model trained on a benchmark.
Qualitative benefit: Enables 'agentic persistence' where the system retains user preferences (e.g., being a trader) across sessions without re-prompting.
Qualitative benefit: Reduces token usage by injecting only relevant summaries and triplets rather than full conversation history.

📚 Prerequisite Knowledge

Prerequisites

Large Language Models (LLMs)
Knowledge Graphs (KG)
Retrieval-Augmented Generation (RAG)
Vector Embeddings

Key Terms

Agentic memory: The capacity of an LLM to recall, adapt to, and reason over past interactions to simulate a coherent, goal-directed identity

Knowledge Graph (KG): A structured representation of data using entities (nodes) and relationships (edges), stored here as triplets

Triplets: The fundamental unit of data in a Knowledge Graph, consisting of (Subject, Predicate, Object), e.g., (User, Is, Trader)

Episodic Memory: Memory of specific past interactions or events, mirroring human autobiographical memory

Semantic Memory: Structured, factual knowledge about the world or domain (e.g., definitions, historical data)

Working Memory: Short-term memory capacity for ongoing reasoning and maintaining context within a current task

Parametric Memory: Static knowledge encoded in the model's pre-trained weights, which cannot adapt to new user interactions

Exponential decay: A mathematical function used here to weight memory triplets, giving higher importance to more recent information to handle changing user preferences