memory-systems

Designs agent memory architectures using vector stores, knowledge graphs, and temporal retrieval frameworks.

Updated Apr 7, 2026
One-click install
npx skills add https://github.com/NT-boop-star/BRMV-tract --skill memory-systems-nt-boop-star
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: memory-systems
Source: https://github.com/NT-boop-star/BRMV-tract/tree/main/antigravity/skills/memory-systems
Command: npx skills add https://github.com/NT-boop-star/BRMV-tract --skill memory-systems-nt-boop-star

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill requires numpy, and includes scripts (resource) and references (resource) components.

What problem does it solve? Agents lose all state when sessions end, forcing users to repeat context and preventing long-term knowledge accumulation. This Skill guides the design of layered memory architectures that persist facts, entities, and relationships across sessions with reliable retrieval. ## Core Features & Use Cases - Framework Comparison: Compares production memory frameworks (Mem0, Zep/Graphiti, Letta, LangMem, Cognee) with benchmark data from LoCoMo, LongMemEval, DMR, and HotPotQA to support selection decisions. - Layered Architecture Guidance: Provides decision tables for working, short-term, long-term, entity, and temporal knowledge graph memory layers, plus retrieval strategies (semantic, entity-based, temporal, hybrid). - Runnable Implementation: Ships a Python module with VectorStore, PropertyGraph, TemporalKnowledgeGraph, and an IntegratedMemorySystem for prototyping memory persistence before committing to a framework. - Use Case: When building a support agent that must remember user preferences and past issues across conversations, use this Skill to choose a framework, design temporal validity tracking, and prototype the storage layer. ## Quick Start Ask the agent to design a memory architecture for a chatbot that must retain user preferences across sessions and recommend a suitable framework.

Frequently Asked Questions about memory-systems

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I add long-term memory to an AI agent?

Start with file-system memory storing facts as structured JSON with timestamps, then escalate to a vector store like Mem0 when semantic search is needed. Add a temporal knowledge graph such as Zep/Graphiti only when the agent requires relationship traversal or time-travel queries.

Mem0 vs Zep vs Cognee: which agent memory framework should I choose?

Choose Mem0 for fast time-to-production with managed infrastructure, Zep/Graphiti for bi-temporal modeling and relationship reasoning, and Cognee for dense multi-layer semantic graphs with customizable ingestion pipelines. Letta fits agents needing deep self-introspection over their own memory.

What is a temporal knowledge graph for agent memory?

A temporal knowledge graph stores facts with valid_from and valid_until timestamps so agents can answer point-in-time queries like where a user lived on a specific date. It prevents stale facts from poisoning context by invalidating outdated relationships without discarding history.

Does a simple filesystem outperform specialized memory tools?

Yes, in some benchmarks. Letta's filesystem-based agents scored 74% on LoCoMo using basic file operations, beating Mem0's specialized tools at 68.5%, which shows reliable retrieval matters more than tool sophistication for many workloads.

Why does agent memory retrieval degrade over time?

Unbounded memory growth, stale facts without validity tracking, and embedding model mismatches all degrade retrieval quality. Run periodic consolidation triggered by memory count thresholds, pin one embedding model per store, and apply expiry policies to aged facts.

When should I not use a knowledge graph for agent memory?

Avoid graph structures during prototyping or when queries are simple factual lookups, since graphs add infrastructure cost and schema maintenance. Start with file-system or vector storage and add graph layers only when multi-hop reasoning or relationship traversal is demonstrably required.