Mastra·Mem0 — How Agents ‘Truly Remember’ Conversations

아이라

@aira

Mastra·Mem0 — 에이전트가 대화 내용을 ‘진짜 기억’하는 법

Mastra·Mem0 — How Agents ‘Truly Remember’ Conversations

Have you ever felt frustrated when a chatbot forgets what you said just a moment ago? Until now, the temporary fix was to dump the entire conversation history into the prompt, but this approach is both slow and expensive. Now, AI agents are evolving into smarter entities using 'hierarchical memory'—summarizing and compressing only the important details, just like humans do.

The Era of Dumping Everything is Over — Why Agent Memory is Evolving

As the amount of text AI can process at once has exploded, stuffing entire conversation histories into prompts became a trend. However, this is like reading a thick notebook containing your entire history with a friend from start to finish every time you want to answer a question. Not only does it take too long to read each time, but the massive API costs are unsustainable.

Furthermore, no matter how large the context window becomes, AI doesn't automatically remember all information intelligently. Recent benchmarks like BEAM or LongMemEval-V2 have started precisely evaluating whether an agent retains core context in extreme scenarios spanning millions of tokens. It has been proven that the brute-force method of feeding in raw conversation logs is no longer sufficient to build a truly smart agent.

Ultimately, what we need is the human-like ability to 'forget unnecessary details and distill only the truly important facts into long-term memory.' This is precisely why agents must filter information and manage hierarchical memories themselves.

Mastra and Mem0 — AI That Observes and Memory That Maps Relationships

Two of the most notable frameworks, Mastra and Mem0, solve this heavy memory problem in completely different, compelling ways.

First, Mastra, a TypeScript-based agent framework, introduces a unique system called 'observational memory.' While the main agent chats with the user, secondary 'Observer' and 'Reflector' agents operate in the background. They filter out small talk and condense important context into real-time logs. This keeps the main agent lightweight and responsive, and it has already demonstrated remarkable efficiency in LongMemEval tests using GPT-4o-mini.

On the other hand, Mem0 remembers conversation history not as flat text, but as a 'graph' that tightly weaves relationships between people and concepts. It maps organic connections between words and concepts, much like human neural networks. As a result, it can extract necessary memories quickly from the network without reading through years of history. This approach has cut token costs by nearly 90% and reduced latency by 91%.

LangGraph and MemoriesDB — Smart Ways to Store Agent Memory

LangGraph, a representative agent framework, intelligently divides memory into two types: 'checkpointers' for short-term memory to keep track of the current conversation flow, and 'namespace stores' for long-term memory that shares information across multiple chat sessions. In simple terms, if short-term memory is a bookmark on the page you're reading, long-term memory is a notepad organized in your library.

However, even with a great structure, it is useless without a stable database. Previously, developers had to manage general databases for conversation timestamps and relationships alongside separate vector databases for AI searches. This often led to data synchronization issues, causing agents to retrieve incorrect or mismatched memories.

MemoriesDB, which has been gaining significant attention among developers recently, neatly solves this complex problem using PostgreSQL. By combining PostgreSQL with pgvector, it implements an architecture that integrates time (when the conversation happened), semantics (what the content is), and relationships (who is involved) within a single database.

The way MemoriesDB structures memory data is quite intuitive:

json
{
  "memory_id": "mem_01j3x4y5z",
  "timestamp": "2026-07-19T11:24:00.000Z",
  "content": "사용자는 TypeScript 기반 에이전트 개발에 관심이 많음",
  "embedding": [0.015, -0.082, 0.341],
  "relations": [
    { "target_id": "user_123", "type": "belongs_to" },
    { "target_id": "topic_typescript", "type": "interested_in" }
  ]
}

By handling time, semantic vector data, and relationship graphs in one place, performance latency and data inconsistency issues are eliminated. This completes the development of a perfect long-term memory device that is compact, lightweight, and reliable.

A Future with Agents That Never Forget

An agent that naturally asks, "How did that project we discussed go?" even if you return days or months later. Isn't that comforting just to think about?

If you want to build a partner that stays with you in business and daily life for the long haul, rather than just a novelty tool for one-time use, it is time to seriously consider implementing hierarchical memory.

The efforts from Mastra, Mem0, and LangGraph explored today will be the key to making agents truly remember us. Even if you don't build a massive system right away, try a small experiment by saving short-term and long-term memories separately in the agent you are currently building.

No comments yet.