Agent Memory Techniques
30 runnable Jupyter notebooks teaching every major memory pattern for LLM agents — from conversation buffers to knowledge graphs and production deployment.
Least privilege: educational notebooks only read env vars/local files, no destructive defaults, 2; no explicit user-confirmation mechanisms, 1; data flow broadly traceable but no dedicated data-flow doc, 2; sensitive data handled via load_env with clear errors, 2; requirements.txt unpinned and no security audit, 1; README embeds many click-tracking links to cloud functions (opaque external calls), 1; no rollback/deletion guidance, 1; attribution limited to author name and LICENSE, no citations for third-party techniques/frameworks, 1.
CI validates notebook structure, style, and runs helper smoke tests — reasonable self-consistency, 2; unpinned requirements mean LangChain API drift risk; availability only thinly assured, 1; load_env raises a clear RuntimeError with test coverage — good failure messages, 2.
Audience and scenarios are very clear (learner to production, learning paths, decision tree), 3; boundaries described per technique but no systematic fit/no-fit labeling, 2; a notebook collection has no trigger mechanism, 1; Python 3.10+/3.11 with Jupyter/Colab stated, 2.
Excellent information architecture: 6 families, numbered 30 techniques, comparison matrix, decision tree, image fallback, 3; weak install notes — badges and dependency file only, no step-by-step env setup, 1; stable naming: directories match numbering, 3; rich examples with Colab badges, no FAQ, 2; known limitations not systematically disclosed (e.g., examples unsuited to concurrency/scale), 1; standard Apache-2.0 LICENSE, 3; no versioning or changelog, 0; maintenance rests on one individual; CONTRIBUTING exists but update commitment unverifiable, 1.
Output usability: notebooks runnable with Colab entry points, 2; marginal value: broad coverage including frameworks and evaluation, but similar teaching repos exist, 2; cost-benefit: free, structured learning paths — good, 2.
Claims traceable to concrete notebooks, 2; cross-checkable against Mem0/Letta/Zep/Graphiti docs, 2; facts and inference mostly separated (2026 ecosystem notes framed as author's view), but marketing wording ('Top 0.1% content') is unverifiable, 2.
- requirements.txt has zero version pins; fast-moving libraries (LangChain, Mem0, Letta) may break notebooks via API drift — verify versions yourself after cloning.
- README embeds numerous third-party click-tracking links (cloudfunctions.net with retargeting parameters); be aware of outbound traffic — avoid clicking if you do not wish to be tracked.
- All content is educational samples; concurrency, multi-tenancy, deletion/rollback are not shown — do not copy directly into production.
- No versioning or changelog; pin the commit hash when citing.
- Publisher identity is unverified; marketing claims (reader counts, bestseller badges) are uncorroborated.
What does this agent do, and when should you use it?
This is an open-source educational repository by Nir Diamant containing 30 independently runnable Jupyter notebooks covering six families of agent memory techniques: short-term context management, long-term storage, cognitive architectures, retrieval and multi-agent patterns, batteries-included frameworks, and evaluation and production deployment. Each technique lives in its own folder with a notebook and README, readable directly on GitHub or runnable in the cloud via Colab badges. The frameworks section provides hands-on code for Graphiti, Mem0, Letta (MemGPT), and Zep, while the evaluation section offers LoCoMo and LongMemEval benchmarks plus metrics like retrieval precision, staleness, and contradiction detection. Supporting materials include a comparison matrix, glossary, learning path guides, and a decision tree for choosing a technique by goal. It is positioned as an educational reference and cookbook; the author explicitly states the code is not production-ready software.
The repository organizes 30 memory techniques into numbered directories (all_techniques/01_conversation_buffer_memory through 30_production_memory_patterns). Short-term memory notebooks implement Conversation Buffer, Sliding Window, Summary, Summary Buffer, and Token Buffer patterns. Long-term memory covers vector store, entity, knowledge graph, episodic, semantic, and procedural memory. Cognitive architecture notebooks implement working memory with context-window management, hierarchical hot/warm/cold layers, memory consolidation, compaction, self-reflection, memory routing, temporal weighting, and forgetting with decay. Retrieval notebooks compare semantic search, recency, hybrid scoring, diversity, and re-ranking strategies, plus cross-session persistence, multi-agent shared memory, and memory-as-tools. Framework notebooks call Graphiti (Zep's time-aware knowledge graph), Mem0's managed memory layer, Letta/MemGPT's self-editing memory, and Zep's dialog classification and entity extraction. Evaluation measures retrieval precision and recall, staleness, and contradictions; benchmarks run against LoCoMo and LongMemEval; production patterns cover caching, TTLs, sharding, backups, GDPR, and observability. Execution is standard Jupyter: clone, install requirements.txt, set API keys in .env, run notebooks one by one.
- An LLM application developer choosing a memory design for a chatbot uses the decision tree and comparison matrix to shortlist techniques, then validates them in a notebook.
- A team evaluating memory frameworks (Mem0, Letta, Zep, Graphiti) runs the minimal working examples before committing to production integration.
- Educators and researchers need a systematic, citable curriculum explaining episodic memory, semantic memory, and cognitive architectures with working implementations.
- An engineer about to ship a memory-backed agent studies Technique 30 for caching, TTL, sharding, GDPR, and observability patterns.
- A multi-agent systems developer needs reference implementations of shared stores, message passing, and agreement protocols (Technique 22).
- A team that must quantify memory quality over long conversations runs the LoCoMo/LongMemEval benchmarks from Techniques 28-29.
What are this agent's strengths and limitations?
- Unusually complete coverage: 30 techniques spanning simple buffers, knowledge graphs, cognitive architectures, and four leading frameworks (Mem0, Letta, Zep, Graphiti).
- Every notebook runs independently, renders on GitHub, and runs in Colab, keeping the learning barrier low.
- A comparison matrix, glossary, decision tree, and multiple learning paths support goal-driven selection rather than sequential reading.
- Includes evaluation (Technique 28) and benchmarks (LoCoMo, LongMemEval, Technique 29) — rare in tutorial repos and enables quantitative selection.
- The disclaimer explicitly states the code is educational only, not production-ready; using it for regulated or high-stakes data requires careful review.
- Requires your own OPENAI_API_KEY or ANTHROPIC_API_KEY; running notebooks incurs API costs and depends on provider service availability.
- Thirty notebooks imply meaningful local setup and key-configuration effort, and some Python/Jupyter familiarity is expected.
- Content moves fast (it references March 2026's Anthropic 7 Layers of Memory), so notebook compatibility with current framework APIs must be verified by the user.
How do you install or deploy this agent?
git clone https://github.com/NirDiamant/Agent_Memory_Techniques.git
cd Agent_Memory_Techniques
python -m venv venv
source venv/bin/activate # On Windows: venv\Scripts\activate
pip install -r requirements.txt
cp .env.example .env
# Edit .env with your OPENAI_API_KEY and/or ANTHROPIC_API_KEYHow do you use this agent?
Launch jupyter notebook all_techniques/01_conversation_buffer_memory/ and start with the base technique; each technique has its own folder and .ipynb under all_techniques/. With no local install, read notebooks directly on GitHub or run them via the Colab badges in each table. If unsure where to start, use the README decision tree, the docs/comparison.md matrix, or the beginner learning path (01 → 02 → 03 → 05 → 06 → 21).
How does this agent compare with similar options?
The same author's companion repos form a complementary series: RAG Techniques (26k+ stars, retrieval-augmented generation), GenAI Agents (21k+ stars, agent architectures), Agents Towards Production (18k+ stars, production-grade agent deployment), and Prompt Engineering (7k+ stars). If your need is RAG or general agent architecture, those fit better; if it is specifically agent memory, this repo is the focused choice. The README also names MemOS and Memori as memory-as-infrastructure platforms, but provides no integration notebooks for them.