Memory Systems

1from langchain_core.chat_history import InMemoryChatMessageHistory
2from langchain_core.messages import HumanMessage, AIMessage
3
4# Simple buffer - keeps ALL messages
5history = InMemoryChatMessageHistory()
6
7history.add_user_message("Tên tôi là Minh")
8history.add_ai_message("Xin chào Minh! Tôi có thể giúp gì?")
9history.add_user_message("Tôi muốn tìm laptop")
10history.add_ai_message("Bạn cần laptop cho công việc gì, Minh?")
11
12print(history.messages)
13# 4 messages stored

1class WindowMemory:
2    """Keep only the last N messages."""
3    
4    def __init__(self, window_size=10):
5        self.window_size = window_size
6        self.messages = []
7    
8    def add_message(self, role, content):
9        self.messages.append({"role": role, "content": content})
10        # Trim to window size
11        if len(self.messages) > self.window_size:
12            self.messages = self.messages[-self.window_size:]
13    
14    def get_messages(self):
15        return self.messages
16    
17    def clear(self):
18        self.messages = []
19
20memory = WindowMemory(window_size=10)
21memory.add_message("user", "Hello")
22memory.add_message("assistant", "Hi there!")

1from langchain_openai import ChatOpenAI
2from langchain_core.prompts import ChatPromptTemplate
3
4class SummaryMemory:
5    """Summarize old messages to save tokens."""
6    
7    def __init__(self, llm, max_messages=6):
8        self.llm = llm
9        self.max_messages = max_messages
10        self.summary = ""
11        self.recent_messages = []
12    
13    def add_message(self, role, content):
14        self.recent_messages.append({"role": role, "content": content})
15        
16        # When too many messages, summarize old ones
17        if len(self.recent_messages) > self.max_messages:
18            self._summarize()
19    
20    def _summarize(self):
21        """Summarize older messages."""
22        old_messages = self.recent_messages[:-4]  # Keep last 4
23        
24        prompt = ChatPromptTemplate.from_template(
25            "Summarize this conversation concisely:\n"
26            "Previous summary: {summary}\n"
27            "New messages: {messages}\n"
28            "Summary:"
29        )
30        
31        chain = prompt | self.llm
32        messages_text = "\n".join(
33            f"{m['role']}: {m['content']}" for m in old_messages
34        )
35        
36        result = chain.invoke({
37            "summary": self.summary or "None",
38            "messages": messages_text
39        })
40        
41        self.summary = result.content
42        self.recent_messages = self.recent_messages[-4:]
43    
44    def get_context(self):
45        """Get summary + recent messages for prompt."""
46        context = ""
47        if self.summary:
48            context += f"Conversation summary: {self.summary}\n\n"
49        
50        context += "Recent messages:\n"
51        for m in self.recent_messages:
52            context += f"{m['role']}: {m['content']}\n"
53        
54        return context

1from langchain_openai import OpenAIEmbeddings
2from langchain_community.vectorstores import Chroma
3from langchain_core.documents import Document
4import json
5from datetime import datetime
6
7class LongTermMemory:
8    """Persistent memory using vector store."""
9    
10    def __init__(self, user_id, persist_dir="./memory_db"):
11        self.user_id = user_id
12        self.embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
13        self.vectorstore = Chroma(
14            collection_name=f"memory_{user_id}",
15            embedding_function=self.embeddings,
16            persist_directory=persist_dir
17        )
18    
19    def store(self, content, memory_type="conversation"):
20        """Store a memory."""
21        doc = Document(
22            page_content=content,
23            metadata={
24                "user_id": self.user_id,
25                "type": memory_type,
26                "timestamp": datetime.now().isoformat()
27            }
28        )
29        self.vectorstore.add_documents([doc])
30    
31    def recall(self, query, k=5, memory_type=None):
32        """Recall relevant memories."""
33        filter_dict = {"user_id": self.user_id}
34        if memory_type:
35            filter_dict["type"] = memory_type
36        
37        results = self.vectorstore.similarity_search(
38            query, k=k, filter=filter_dict
39        )
40        
41        return [doc.page_content for doc in results]
42    
43    def store_preference(self, key, value):
44        """Store user preference."""
45        content = f"User preference: {key} = {value}"
46        self.store(content, memory_type="preference")
47    
48    def recall_preferences(self, context=""):
49        """Recall relevant user preferences."""
50        return self.recall(
51            f"user preferences {context}",
52            k=3,
53            memory_type="preference"
54        )
55
56# Usage
57memory = LongTermMemory("user_123")
58memory.store_preference("language", "Vietnamese")
59memory.store_preference("budget", "thích sản phẩm tầm trung")
60memory.store("User asked about MacBook Air and bought one", "interaction")
61
62# Later recall
63prefs = memory.recall_preferences("buying laptop")
64# Returns: ['User preference: budget = thích sản phẩm tầm trung', ...]

1import json
2import os
3
4class StructuredMemory:
5    """JSON-based structured memory for user profiles."""
6    
7    def __init__(self, filepath="user_memory.json"):
8        self.filepath = filepath
9        self.data = self._load()
10    
11    def _load(self):
12        if os.path.exists(self.filepath):
13            with open(self.filepath, "r") as f:
14                return json.load(f)
15        return {}
16    
17    def _save(self):
18        with open(self.filepath, "w") as f:
19            json.dump(self.data, f, ensure_ascii=False, indent=2)
20    
21    def set(self, user_id, key, value):
22        if user_id not in self.data:
23            self.data[user_id] = {}
24        self.data[user_id][key] = value
25        self._save()
26    
27    def get(self, user_id, key, default=None):
28        return self.data.get(user_id, {}).get(key, default)
29    
30    def get_profile(self, user_id):
31        return self.data.get(user_id, {})

1from langgraph.prebuilt import create_react_agent
2from langgraph.checkpoint.memory import MemorySaver
3from langchain_openai import ChatOpenAI
4
5# Memory saver enables conversation persistence
6memory = MemorySaver()
7
8llm = ChatOpenAI(model="gpt-4o-mini")
9tools = [search_product, get_weather]
10
11agent = create_react_agent(
12    llm,
13    tools,
14    checkpointer=memory
15)
16
17# Thread ID = conversation session
18config = {"configurable": {"thread_id": "user_123_session_1"}}
19
20# First message
21result = agent.invoke(
22    {"messages": [("user", "Tên tôi là Minh")]},
23    config=config
24)
25
26# Second message - agent remembers!
27result = agent.invoke(
28    {"messages": [("user", "Tên tôi là gì?")]},
29    config=config
30)
31# Agent: "Tên bạn là Minh!"