Memory is the foundation of truly intelligent AI agents. Without it, agents are stateless, reactive systems that treat every interaction as if it\u2019s the first. With proper memory architecture, agents become context-aware<\/strong>, personalized<\/strong>, and continuously improving<\/strong>\u2014transforming from simple chatbots into sophisticated autonomous systems .<\/p>\n\n\n\n As AI agents evolve from experimental tools to enterprise-critical systems, memory has emerged as one of the most important architectural decisions. According to Anthropic\u2019s engineering blog, \u201cA well-implemented memory system is the difference between an agent that feels like a tool and one that feels like a teammate\u201d .<\/p>\n\n\n\n In this comprehensive guide, you\u2019ll learn:<\/p>\n\n\n\n AI agent memory refers to the mechanisms that enable agents to store, retrieve, and utilize information across interactions<\/strong>. Unlike traditional software that relies on simple session variables, AI agent memory must handle unstructured data, contextual relevance, and dynamic retrieval .<\/p>\n\n\n\n *Figure 1: Multi-layered AI agent memory architecture*<\/p>\n\n\n\n *Source: *<\/p>\n\n\n\n AI researchers classify agent memory along several dimensions:<\/p>\n\n\n\n Short-term memory<\/strong> (also called working memory) holds information relevant to the current interaction or session. It includes conversation history, current task context, and immediate goals . This memory is typically ephemeral<\/strong>\u2014cleared when the session ends.<\/p>\n\n\n\n *Figure 2: Short-term memory management flow*<\/p>\n\n\n\n The simplest approach\u2014store messages and include them in context:<\/p>\n\n\n\n python<\/p>\n\n\n\n Pros<\/strong>: Simple, preserves exact history Keep only the last N messages:<\/p>\n\n\n\n python<\/p>\n\n\n\n Pros<\/strong>: Token-efficient, focuses on recent context For long conversations, summarize older parts and keep recent messages intact:<\/p>\n\n\n\n python<\/p>\n\n\n\n Pros<\/strong>: Preserves key information, token-efficient Smart truncation based on actual token counts:<\/p>\n\n\n\n python<\/p>\n\n\n\n Long-term memory<\/strong> stores information across sessions, enabling agents to remember user preferences, past interactions, learned facts, and accumulated knowledge . This is what transforms an agent from a session-based tool into a persistent digital companion.<\/p>\n\n\n\n *Figure 3: Long-term memory architecture with multiple storage types*<\/p>\n\n\n\n Vector databases enable semantic search\u2014finding relevant memories based on meaning, not exact keywords .<\/p>\n\n\n\n Step 1: Choose a Vector Database<\/strong><\/p>\n\n\n\n Step 2: Create Embeddings<\/strong><\/p>\n\n\n\n python<\/p>\n\n\n\n Step 3: Store and Retrieve Memories<\/strong><\/p>\n\n\n\n python<\/p>\n\n\n\n Store structured user preferences and facts:<\/p>\n\n\n\n python<\/p>\n\n\n\n Store experiences with temporal context:<\/p>\n\n\n\n python<\/p>\n\n\n\n Combine multiple memory types for comprehensive intelligence:<\/p>\n\n\n\n python<\/p>\n\n\n\n MemGPT<\/strong> introduces a recursive memory architecture inspired by operating system virtual memory . It treats the LLM\u2019s context window as \u201cfast memory\u201d and external storage as \u201cslow memory,\u201d managing data movement between them.<\/p>\n\n\n\n python<\/p>\n\n\n\n For complex tasks, maintain a structured working memory:<\/p>\n\n\n\n python<\/p>\n\n\n\n LangChain provides built-in memory modules :<\/p>\n\n\n\n python<\/p>\n\n\n\n AG2 supports memory through its python<\/p>\n\n\n\n python<\/p>\n\n\n\n Not all memories stay relevant forever. Implement decay mechanisms:<\/p>\n\n\n\n python<\/p>\n\n\n\n python<\/p>\n\n\n\n At MHTECHIN<\/strong>, we specialize in building sophisticated memory systems for AI agents that enable truly intelligent, context-aware applications. Our expertise spans:<\/p>\n\n\n\n MHTECHIN\u2019s solutions leverage state-of-the-art techniques including MemGPT recursive memory<\/strong>, hybrid semantic-keyword retrieval<\/strong>, and adaptive memory decay<\/strong> to deliver production-ready memory systems.<\/p>\n\n\n\n Memory is the foundation of intelligent AI agents. Without it, agents are stateless tools. With it, they become persistent, personalized, and continuously improving teammates.<\/p>\n\n\n\n Key Takeaways:<\/strong><\/p>\n\n\n\n As AI agents evolve from experimental tools to enterprise-critical systems, memory architecture will increasingly determine their intelligence, reliability, and user experience. Organizations that invest in robust memory systems today will build the most capable and trusted AI agents tomorrow.<\/p>\n\n\n\n AI agent memory refers to the mechanisms that enable agents to store, retrieve, and utilize information across interactions. It includes short-term memory (session context), long-term memory (persistent knowledge), and episodic memory (past experiences) .<\/p>\n\n\n\n Short-term memory holds information relevant to the current interaction. Implementations include conversation buffers (storing recent messages), buffer windows (keeping last N messages), and conversation summarization (compressing older context) .<\/p>\n\n\n\n Long-term memory is typically implemented using vector databases for semantic search (ChromaDB, Pinecone, Weaviate), key-value stores for user profiles (Redis), and time-series databases for episodic memory .<\/p>\n\n\n\n The main types are: Short-term<\/strong> (session context), Long-term<\/strong> (persistent knowledge), Semantic<\/strong> (facts and concepts), Episodic<\/strong> (past experiences), and Procedural<\/strong> (skills and patterns) .<\/p>\n\n\n\n Choose conversation buffer for simple interactions, buffer window for token efficiency, summarization for long sessions, vector stores for semantic retrieval, and hybrid approaches for comprehensive intelligence .<\/p>\n\n\n\n MemGPT is a recursive memory architecture inspired by operating system virtual memory. It treats the LLM\u2019s context window as \u201cfast memory\u201d and external storage as \u201cslow memory,\u201d managing data movement between them .<\/p>\n\n\n\n Implement token-aware truncation, relevance scoring to prioritize important memories, and decay mechanisms to retire outdated information. Always reserve tokens for system prompts and instructions .<\/p>\n\n\n\n Implement data minimization (store only essential information), encryption at rest and in transit, user deletion rights (GDPR\/CCPA compliance), access controls, and PII redaction .<\/p>\n","protected":false},"excerpt":{"rendered":" Introduction Imagine having a conversation with a customer service agent who forgets what you said two minutes ago. Frustrating, right? Now imagine that agent remembers every interaction you\u2019ve ever had\u2014your preferences, past issues, and even your tone\u2014and uses that knowledge to serve you better. This is the power of AI agent memory. Memory is the foundation […]<\/p>\n","protected":false},"author":64,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[],"class_list":["post-2940","post","type-post","status-publish","format-standard","hentry","category-support"],"_links":{"self":[{"href":"https:\/\/www.mhtechin.com\/support\/wp-json\/wp\/v2\/posts\/2940","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.mhtechin.com\/support\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.mhtechin.com\/support\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.mhtechin.com\/support\/wp-json\/wp\/v2\/users\/64"}],"replies":[{"embeddable":true,"href":"https:\/\/www.mhtechin.com\/support\/wp-json\/wp\/v2\/comments?post=2940"}],"version-history":[{"count":8,"href":"https:\/\/www.mhtechin.com\/support\/wp-json\/wp\/v2\/posts\/2940\/revisions"}],"predecessor-version":[{"id":2952,"href":"https:\/\/www.mhtechin.com\/support\/wp-json\/wp\/v2\/posts\/2940\/revisions\/2952"}],"wp:attachment":[{"href":"https:\/\/www.mhtechin.com\/support\/wp-json\/wp\/v2\/media?parent=2940"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.mhtechin.com\/support\/wp-json\/wp\/v2\/categories?post=2940"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.mhtechin.com\/support\/wp-json\/wp\/v2\/tags?post=2940"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}\n
\n\n\n\nPart 1: Understanding AI Agent Memory<\/h3>\n\n\n\n
What Is AI Agent Memory?<\/h4>\n\n\n\n
![\"\"](\"https:\/\/www.mhtechin.com\/support\/wp-content\/uploads\/2026\/03\/Gemini_Generated_Image_c88i8sc88i8sc88i-1024x426.png\")
<\/figure>\n\n\n\nWhy Memory Matters<\/h4>\n\n\n\n
Without Memory<\/th> With Memory<\/th><\/tr><\/thead> Each interaction starts fresh<\/td> Continuity across conversations<\/td><\/tr> No personalization<\/td> Tailored responses based on history<\/td><\/tr> Repetitive questions<\/td> Learned preferences<\/td><\/tr> Cannot learn from mistakes<\/td> Improvement over time<\/td><\/tr> Simple question-answering<\/td> Complex, multi-step workflows<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n Memory Taxonomies in AI Agents<\/h4>\n\n\n\n
Taxonomy Dimension<\/th> Types<\/th><\/tr><\/thead> Time Horizon<\/strong><\/td> Short-term, long-term, episodic<\/td><\/tr> Content Type<\/strong><\/td> Semantic (facts), procedural (skills), episodic (experiences)<\/td><\/tr> Access Pattern<\/strong><\/td> Explicit (user-provided), implicit (learned), associative (context-triggered)<\/td><\/tr> Storage Mechanism<\/strong><\/td> In-memory, database, vector store, knowledge graph<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
\n\n\n\nPart 2: Short-Term Memory \u2013 The Working Context<\/h3>\n\n\n\n
What Is Short-Term Memory?<\/h4>\n\n\n\n
![\"\"](\"https:\/\/www.mhtechin.com\/support\/wp-content\/uploads\/2026\/03\/Gemini_Generated_Image_qznuihqznuihqznu-425x1024.png\")
<\/figure>\n\n\n\nImplementation Techniques<\/h3>\n\n\n\n
Technique 1: Conversation Buffer<\/h4>\n\n\n\n
class ConversationBuffer:\n def __init__(self, max_messages=20):\n self.messages = []\n self.max_messages = max_messages\n \n def add_message(self, role, content):\n self.messages.append({\"role\": role, \"content\": content})\n if len(self.messages) > self.max_messages:\n self.messages.pop(0) # Remove oldest\n \n def get_context(self):\n return self.messages<\/pre>\n\n\n\n
Cons<\/strong>: Can exceed token limits, no summarization<\/p>\n\n\n\nTechnique 2: Conversational Buffer Window<\/h4>\n\n\n\n
class BufferWindow:\n def __init__(self, window_size=10):\n self.window = []\n self.window_size = window_size\n \n def add_message(self, role, content):\n self.window.append({\"role\": role, \"content\": content})\n if len(self.window) > self.window_size:\n self.window.pop(0)<\/pre>\n\n\n\n
Cons<\/strong>: Loses earlier context entirely<\/p>\n\n\n\nTechnique 3: Conversation Summary<\/h4>\n\n\n\n
class SummarizingMemory:\n def __init__(self, summarizer_model, max_tokens=4000):\n self.summary = \"\"\n self.recent = []\n self.max_tokens = max_tokens\n self.summarizer = summarizer_model\n \n def add_message(self, role, content):\n self.recent.append({\"role\": role, \"content\": content})\n \n # If recent exceeds threshold, summarize\n if self.estimate_tokens(self.recent) > self.max_tokens:\n self._summarize()\n \n def _summarize(self):\n conversation_text = \"\\n\".join([f\"{m['role']}: {m['content']}\" for m in self.recent])\n \n prompt = f\"Summarize this conversation concisely:\\n{conversation_text}\"\n new_summary = self.summarizer.generate(prompt)\n \n # Merge with existing summary\n self.summary = self.summary + \"\\n\" + new_summary if self.summary else new_summary\n self.recent = [] # Clear recent after summarization\n \n def get_context(self):\n context = []\n if self.summary:\n context.append({\"role\": \"system\", \"content\": f\"Previous conversation summary: {self.summary}\"})\n context.extend(self.recent)\n return context<\/pre>\n\n\n\n
Cons<\/strong>: Loses nuance, requires LLM calls<\/p>\n\n\n\nTechnique 4: Token-Based Truncation<\/h4>\n\n\n\n
import tiktoken\n\nclass TokenAwareMemory:\n def __init__(self, model=\"gpt-4\", max_tokens=6000):\n self.encoder = tiktoken.encoding_for_model(model)\n self.messages = []\n self.max_tokens = max_tokens\n self.system_tokens = 0\n \n def add_message(self, role, content):\n self.messages.append({\"role\": role, \"content\": content})\n self._trim_if_needed()\n \n def _trim_if_needed(self):\n total_tokens = self._count_tokens()\n while total_tokens > self.max_tokens and len(self.messages) > 1:\n # Remove oldest non-system message\n for i, msg in enumerate(self.messages):\n if msg[\"role\"] != \"system\":\n removed = self.messages.pop(i)\n total_tokens -= self._count_message_tokens(removed)\n break\n \n def _count_tokens(self):\n return sum(self._count_message_tokens(msg) for msg in self.messages)\n \n def _count_message_tokens(self, message):\n return len(self.encoder.encode(message[\"content\"]))<\/pre>\n\n\n\nShort-Term Memory Comparison<\/h4>\n\n\n\n
Technique<\/th> Complexity<\/th> Token Efficiency<\/th> Context Preservation<\/th> Best For<\/th><\/tr><\/thead> Conversation Buffer<\/td> Low<\/td> Low<\/td> High<\/td> Simple conversations<\/td><\/tr> Buffer Window<\/td> Low<\/td> High<\/td> Medium<\/td> Short interactions<\/td><\/tr> Conversation Summary<\/td> Medium<\/td> Medium<\/td> Medium<\/td> Long sessions<\/td><\/tr> Token-Aware Truncation<\/td> Medium<\/td> High<\/td> High<\/td> Production systems<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
\n\n\n\nPart 3: Long-Term Memory \u2013 Persistent Knowledge<\/h3>\n\n\n\n
What Is Long-Term Memory?<\/h4>\n\n\n\n
![\"\"](\"https:\/\/www.mhtechin.com\/support\/wp-content\/uploads\/2026\/03\/Gemini_Generated_Image_7c3uom7c3uom7c3u-1024x244.png\")
<\/figure>\n\n\n\nImplementation Techniques<\/h4>\n\n\n\n
Technique 1: Vector Database for Semantic Memory<\/h4>\n\n\n\n
Database<\/th> Best For<\/th> Features<\/th><\/tr><\/thead> ChromaDB<\/strong><\/td> Development, lightweight<\/td> Open-source, Python-native<\/td><\/tr> Pinecone<\/strong><\/td> Production, scale<\/td> Managed, high performance<\/td><\/tr> Weaviate<\/strong><\/td> Hybrid search<\/td> Open-source, GraphQL API<\/td><\/tr> Qdrant<\/strong><\/td> High performance<\/td> Rust-based, filtering<\/td><\/tr> pgvector<\/strong><\/td> PostgreSQL users<\/td> Extension, ACID compliance<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n from openai import OpenAI\nimport chromadb\nfrom chromadb.utils import embedding_functions\n\nclient = OpenAI(api_key=os.environ[\"OPENAI_API_KEY\"])\n\ndef create_embedding(text):\n response = client.embeddings.create(\n model=\"text-embedding-3-small\",\n input=text\n )\n return response.data[0].embedding<\/pre>\n\n\n\n
class VectorMemory:\n def __init__(self, collection_name=\"agent_memory\"):\n self.client = chromadb.Client()\n self.collection = self.client.create_collection(\n name=collection_name,\n embedding_function=embedding_functions.OpenAIEmbeddingFunction(\n api_key=os.environ[\"OPENAI_API_KEY\"],\n model_name=\"text-embedding-3-small\"\n )\n )\n \n def add_memory(self, text, metadata=None):\n \"\"\"Store a memory with metadata.\"\"\"\n self.collection.add(\n documents=[text],\n metadatas=[metadata or {}],\n ids=[str(hash(text + str(metadata)))]\n )\n \n def retrieve_memories(self, query, n_results=5, filter=None):\n \"\"\"Retrieve relevant memories based on query.\"\"\"\n results = self.collection.query(\n query_texts=[query],\n n_results=n_results,\n where=filter\n )\n return results['documents'][0] if results['documents'] else []\n \n def retrieve_with_relevance(self, query, threshold=0.7):\n \"\"\"Retrieve only highly relevant memories.\"\"\"\n results = self.collection.query(\n query_texts=[query],\n n_results=10\n )\n # Filter by relevance score\n relevant = []\n for doc, dist in zip(results['documents'][0], results['distances'][0]):\n similarity = 1 - dist # Convert distance to similarity\n if similarity > threshold:\n relevant.append(doc)\n return relevant<\/pre>\n\n\n\nTechnique 2: User Profile Storage<\/h4>\n\n\n\n
import redis\nimport json\n\nclass UserProfileMemory:\n def __init__(self, redis_client):\n self.redis = redis_client\n \n def update_profile(self, user_id, key, value):\n \"\"\"Update a user profile field.\"\"\"\n profile = self.get_profile(user_id)\n profile[key] = value\n self.redis.set(f\"user:{user_id}:profile\", json.dumps(profile))\n \n def get_profile(self, user_id):\n \"\"\"Retrieve full user profile.\"\"\"\n data = self.redis.get(f\"user:{user_id}:profile\")\n return json.loads(data) if data else {}\n \n def add_preference(self, user_id, category, value):\n \"\"\"Add a user preference.\"\"\"\n preferences = self.get_profile(user_id).get(\"preferences\", {})\n if category not in preferences:\n preferences[category] = []\n if value not in preferences[category]:\n preferences[category].append(value)\n self.update_profile(user_id, \"preferences\", preferences)\n \n def get_relevant_preferences(self, user_id, context):\n \"\"\"Get preferences relevant to current context.\"\"\"\n profile = self.get_profile(user_id)\n # Could use embedding similarity to match preferences with context\n return profile.get(\"preferences\", {})<\/pre>\n\n\n\nTechnique 3: Episodic Memory with Time-Series<\/h4>\n\n\n\n
from datetime import datetime\nimport sqlite3\n\nclass EpisodicMemory:\n def __init__(self, db_path=\"episodic.db\"):\n self.conn = sqlite3.connect(db_path)\n self._create_tables()\n \n def _create_tables(self):\n self.conn.execute(\"\"\"\n CREATE TABLE IF NOT EXISTS episodes (\n id INTEGER PRIMARY KEY AUTOINCREMENT,\n user_id TEXT,\n timestamp DATETIME,\n event_type TEXT,\n summary TEXT,\n details TEXT,\n outcome TEXT,\n embedding BLOB\n )\n \"\"\")\n \n def store_episode(self, user_id, event_type, summary, details, outcome):\n \"\"\"Store an interaction episode.\"\"\"\n self.conn.execute(\n \"INSERT INTO episodes (user_id, timestamp, event_type, summary, details, outcome) VALUES (?, ?, ?, ?, ?, ?)\",\n (user_id, datetime.now(), event_type, summary, details, outcome)\n )\n self.conn.commit()\n \n def retrieve_episodes(self, user_id, limit=10, event_type=None):\n \"\"\"Retrieve recent episodes.\"\"\"\n query = \"SELECT * FROM episodes WHERE user_id = ?\"\n params = [user_id]\n \n if event_type:\n query += \" AND event_type = ?\"\n params.append(event_type)\n \n query += \" ORDER BY timestamp DESC LIMIT ?\"\n params.append(limit)\n \n cursor = self.conn.execute(query, params)\n return cursor.fetchall()\n \n def analyze_patterns(self, user_id):\n \"\"\"Identify patterns from episodic memory.\"\"\"\n episodes = self.retrieve_episodes(user_id, limit=100)\n # Use LLM to analyze patterns\n return analyze_episodes_with_llm(episodes)<\/pre>\n\n\n\n
Long-Term Memory Comparison<\/h4>\n\n\n\n
Type<\/th> Storage<\/th> Retrieval<\/th> Update Frequency<\/th> Best For<\/th><\/tr><\/thead> Semantic (Vector)<\/strong><\/td> Vector DB<\/td> Semantic search<\/td> Batch\/Real-time<\/td> Facts, knowledge<\/td><\/tr> User Profile<\/strong><\/td> Key-Value DB<\/td> Exact match<\/td> Real-time<\/td> Preferences<\/td><\/tr> Episodic<\/strong><\/td> Time-series<\/td> Chronological<\/td> Real-time<\/td> Experiences, patterns<\/td><\/tr> Procedural<\/strong><\/td> Model weights<\/td> Implicit<\/td> Periodic<\/td> Skills, behaviors<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
\n\n\n\nPart 4: Advanced Memory Patterns<\/h3>\n\n\n\n
Pattern 1: Hybrid Memory Architecture<\/h4>\n\n\n\n
class HybridMemory:\n \"\"\"Combine short-term, semantic, and episodic memory.\"\"\"\n \n def __init__(self):\n self.short_term = ConversationBuffer(max_messages=20)\n self.semantic = VectorMemory()\n self.episodic = EpisodicMemory()\n \n def add_interaction(self, user_id, user_input, agent_response, outcome):\n \"\"\"Store a complete interaction across memory systems.\"\"\"\n # Short-term\n self.short_term.add_message(\"user\", user_input)\n self.short_term.add_message(\"assistant\", agent_response)\n \n # Semantic (extract facts)\n facts = self._extract_facts(user_input, agent_response)\n for fact in facts:\n self.semantic.add_memory(fact, {\"user_id\": user_id})\n \n # Episodic\n self.episodic.store_episode(\n user_id=user_id,\n event_type=\"interaction\",\n summary=f\"User asked: {user_input[:100]}\",\n details=agent_response,\n outcome=outcome\n )\n \n def get_context(self, user_id, query):\n \"\"\"Build comprehensive context for an interaction.\"\"\"\n context = []\n \n # Add short-term context\n context.extend(self.short_term.get_context())\n \n # Add relevant semantic memories\n relevant_facts = self.semantic.retrieve_memories(query, n_results=3)\n if relevant_facts:\n context.append({\n \"role\": \"system\",\n \"content\": f\"Relevant facts from previous interactions: {', '.join(relevant_facts)}\"\n })\n \n # Add recent episodes\n recent_episodes = self.episodic.retrieve_episodes(user_id, limit=2)\n if recent_episodes:\n episode_summaries = [e[4] for e in recent_episodes] # summary field\n context.append({\n \"role\": \"system\",\n \"content\": f\"Recent interactions: {', '.join(episode_summaries)}\"\n })\n \n return context<\/pre>\n\n\n\nPattern 2: Recursive Memory (MemGPT)<\/h4>\n\n\n\n
class RecursiveMemory:\n \"\"\"MemGPT-style recursive memory management.\"\"\"\n \n def __init__(self, core_context_size=8000, external_store=None):\n self.core = [] # Active in context window\n self.archive = external_store or []\n self.core_size = core_context_size\n \n def add_to_context(self, content, importance=0.5):\n \"\"\"Add content with importance scoring.\"\"\"\n item = {\"content\": content, \"importance\": importance, \"timestamp\": datetime.now()}\n self.core.append(item)\n self._manage_core()\n \n def _manage_core(self):\n \"\"\"Move less important items to archive.\"\"\"\n total_tokens = self._count_tokens()\n while total_tokens > self.core_size and self.core:\n # Find least important item\n least_important = min(self.core, key=lambda x: x[\"importance\"])\n # Move to archive\n self.archive.append(least_important)\n self.core.remove(least_important)\n total_tokens = self._count_tokens()\n \n def recall(self, query):\n \"\"\"Retrieve from both core and archive.\"\"\"\n # Check core first\n relevant = [item for item in self.core if query in item[\"content\"]]\n \n # If not enough, check archive with semantic search\n if len(relevant) < 3:\n archive_results = self._search_archive(query)\n relevant.extend(archive_results)\n \n return relevant<\/pre>\n\n\n\nPattern 3: Working Memory for Multi-Step Tasks<\/h4>\n\n\n\n
class WorkingMemory:\n \"\"\"Structured memory for multi-step tasks.\"\"\"\n \n def __init__(self):\n self.task_plan = []\n self.current_step = 0\n self.step_results = {}\n self.variables = {}\n \n def initialize_plan(self, steps):\n \"\"\"Initialize a task plan.\"\"\"\n self.task_plan = steps\n self.current_step = 0\n self.step_results = {}\n \n def get_current_step(self):\n \"\"\"Get the current step.\"\"\"\n if self.current_step < len(self.task_plan):\n return self.task_plan[self.current_step]\n return None\n \n def record_step_result(self, step_id, result):\n \"\"\"Record result of a completed step.\"\"\"\n self.step_results[step_id] = result\n self.current_step += 1\n \n def set_variable(self, name, value):\n \"\"\"Set a variable for later use.\"\"\"\n self.variables[name] = value\n \n def get_variable(self, name):\n \"\"\"Retrieve a variable.\"\"\"\n return self.variables.get(name)\n \n def get_context_prompt(self):\n \"\"\"Generate context for LLM.\"\"\"\n context = \"## Current Task Progress\\n\"\n context += f\"Plan: {len(self.task_plan)} steps total\\n\"\n context += f\"Completed: {self.current_step} steps\\n\"\n \n if self.variables:\n context += f\"Variables: {self.variables}\\n\"\n \n if self.step_results:\n context += \"Step Results:\\n\"\n for step, result in list(self.step_results.items())[-3:]:\n context += f\"- {step}: {result[:100]}\\n\"\n \n return context<\/pre>\n\n\n\n
\n\n\n\nPart 5: Memory Integration with Agent Frameworks<\/h3>\n\n\n\n
LangChain Memory Components<\/h4>\n\n\n\n
from langchain.memory import (\n ConversationBufferMemory,\n ConversationSummaryMemory,\n VectorStoreRetrieverMemory,\n CombinedMemory\n)\n\n# Buffer memory for short-term\nbuffer_memory = ConversationBufferMemory(\n memory_key=\"chat_history\",\n return_messages=True\n)\n\n# Vector store for long-term\nfrom langchain.vectorstores import Chroma\nfrom langchain.embeddings import OpenAIEmbeddings\n\nvectorstore = Chroma(embedding_function=OpenAIEmbeddings())\nretriever = vectorstore.as_retriever(search_kwargs={\"k\": 3})\n\nlong_term_memory = VectorStoreRetrieverMemory(\n retriever=retriever,\n memory_key=\"relevant_facts\"\n)\n\n# Combine memories\ncombined = CombinedMemory(\n memories=[buffer_memory, long_term_memory]\n)<\/pre>\n\n\n\nAG2 Memory Integration<\/h4>\n\n\n\n
Memory<\/code> module :<\/p>\n\n\n\nfrom autogen import ConversableAgent, LLMConfig\nfrom autogen.memory import Memory\n\nclass CustomMemory(Memory):\n def __init__(self):\n self.short_term = []\n self.long_term = {}\n \n def add(self, content, type=\"conversation\"):\n self.short_term.append({\"content\": content, \"type\": type})\n if len(self.short_term) > 10:\n self._archive()\n \n def retrieve(self, query):\n # Return relevant memories\n return [m for m in self.short_term if query in m[\"content\"]]\n\n# Attach to agent\nmemory = CustomMemory()\nagent = ConversableAgent(\n name=\"MemoryAgent\",\n memory=memory,\n llm_config=llm_config\n)<\/pre>\n\n\n\n
\n\n\n\nPart 6: Best Practices for Memory Implementation<\/h3>\n\n\n\n
1. Prioritize Retrieval Quality<\/h4>\n\n\n\n
Strategy<\/th> Description<\/th> Impact<\/th><\/tr><\/thead> Semantic Search<\/strong><\/td> Use embeddings, not keyword matching<\/td> +40% relevance<\/td><\/tr> Hybrid Search<\/strong><\/td> Combine semantic + keyword + filters<\/td> +25% accuracy<\/td><\/tr> Relevance Thresholds<\/strong><\/td> Only include high-confidence matches<\/td> Reduces noise<\/td><\/tr> Contextual Retrieval<\/strong><\/td> Include surrounding context<\/td> Better understanding<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n 2. Manage Token Budgets<\/h4>\n\n\n\n
class TokenBudgetManager:\n def __init__(self, total_budget=8000, system_reserve=1000):\n self.total_budget = total_budget\n self.system_reserve = system_reserve\n self.used = 0\n \n def can_add(self, memory_item, tokens):\n return (self.used + tokens) <= (self.total_budget - self.system_reserve)\n \n def prioritize_memories(self, memories, query):\n \"\"\"Score and rank memories for inclusion.\"\"\"\n scored = []\n for memory in memories:\n score = self._calculate_relevance(memory, query)\n scored.append((score, memory))\n \n # Sort by relevance\n scored.sort(reverse=True, key=lambda x: x[0])\n \n # Add until budget exhausted\n result = []\n for score, memory in scored:\n tokens = self._estimate_tokens(memory)\n if self.can_add(memory, tokens):\n result.append(memory)\n self.used += tokens\n else:\n break\n \n return result<\/pre>\n\n\n\n
3. Implement Memory Decay<\/h4>\n\n\n\n
class DecayingMemory:\n def __init__(self, half_life_days=30):\n self.half_life = half_life_days\n self.memories = []\n \n def add_memory(self, content, importance=1.0):\n self.memories.append({\n \"content\": content,\n \"importance\": importance,\n \"timestamp\": datetime.now()\n })\n \n def get_relevant_memories(self, query, current_time):\n relevant = []\n for memory in self.memories:\n age_days = (current_time - memory[\"timestamp\"]).days\n decay = 0.5 ** (age_days \/ self.half_life)\n current_importance = memory[\"importance\"] * decay\n \n if current_importance > 0.1: # Threshold\n relevant.append((current_importance, memory))\n \n # Sort by current importance\n relevant.sort(reverse=True, key=lambda x: x[0])\n return [m[1][\"content\"] for m in relevant[:5]]<\/pre>\n\n\n\n4. Privacy and Compliance<\/h4>\n\n\n\n
Requirement<\/th> Implementation<\/th><\/tr><\/thead> Data Minimization<\/strong><\/td> Store only essential information<\/td><\/tr> Right to be Forgotten<\/strong><\/td> Implement deletion endpoints<\/td><\/tr> Data Localization<\/strong><\/td> Region-specific storage<\/td><\/tr> Access Controls<\/strong><\/td> Role-based memory access<\/td><\/tr> Encryption<\/strong><\/td> Encrypt at rest and in transit<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n class PrivacyCompliantMemory:\n def __init__(self, pii_detector=None):\n self.pii_detector = pii_detector\n self.storage = {}\n \n def store_memory(self, user_id, content, metadata=None):\n # Detect and redact PII\n if self.pii_detector:\n content = self.pii_detector.redact(content)\n \n # Encrypt before storage\n encrypted = self._encrypt(content)\n \n # Store with retention policy\n self.storage[user_id] = {\n \"content\": encrypted,\n \"created_at\": datetime.now(),\n \"expires_at\": datetime.now() + timedelta(days=90),\n \"metadata\": metadata\n }\n \n def delete_user_data(self, user_id):\n \"\"\"GDPR-compliant deletion.\"\"\"\n if user_id in self.storage:\n del self.storage[user_id]\n return True\n return False<\/pre>\n\n\n\n
\n\n\n\nPart 7: MHTECHIN\u2019s Expertise in AI Memory Systems<\/h3>\n\n\n\n
\n
\n\n\n\nConclusion<\/h3>\n\n\n\n
\n
\n\n\n\nFrequently Asked Questions (FAQ)<\/h3>\n\n\n\n
Q1: What is AI agent memory?<\/h4>\n\n\n\n
Q2: How does short-term memory work in AI agents?<\/h4>\n\n\n\n
Q3: How do I implement long-term memory?<\/h4>\n\n\n\n
Q4: What are the different types of AI memory?<\/h4>\n\n\n\n
Q5: How do I choose between different memory implementations?<\/h4>\n\n\n\n
Q6: What is MemGPT?<\/h4>\n\n\n\n
Q7: How do I manage token budgets with memory?<\/h4>\n\n\n\n
Q8: What privacy considerations exist for AI memory?<\/h4>\n\n\n\n