Case 3 — Add Long-Term Memory to a Conversational Agent

# Case 3 — Add Long-Term Memory to a Conversational Agent > *"Your agent works within a single conversation but forgets users between sessions. Add long-term memory: facts about each user that persist and inform future conversations."* --- ## Step 1 — Define memory storage Use a database table: ```sql CREATE TABLE user_memories ( id SERIAL PRIMARY KEY, user_id TEXT NOT NULL, fact TEXT NOT NULL, category TEXT, importance INTEGER DEFAULT 5, created_at TIMESTAMP DEFAULT NOW(), last_referenced_at TIMESTAMP, INDEX idx_user_id (user_id), INDEX idx_user_category (user_id, category) ); ``` Categories: `preference`, `history`, `context`, `goal`, etc. Importance: 1-10 for retrieval priority. ## Step 2 — Memory tools ```python @tool def remember_about_user(user_id: str, fact: str, category: str = "context", importance: int = 5) -> str: '''Save a fact about the user for future conversations. Use for things like preferences, important context, decisions made, or recurring topics. Don't store every detail — focus on facts that will matter in future conversations. Args: user_id: The user's ID. fact: The fact to remember (short, declarative sentence). category: One of: preference, history, context, goal. importance: 1-10, with 10 being critical to remember. ''' db.execute( "INSERT INTO user_memories (user_id, fact, category, importance) VALUES (?, ?, ?, ?)", user_id, fact, category, importance, ) return f"Saved: {fact}" @tool def recall_about_user(user_id: str, topic: str = None, limit: int = 10) -> list: '''Recall what we know about the user, optionally filtered by topic. Args: user_id: The user's ID. topic: Optional keyword to filter facts. If None, returns most important facts. limit: Max number of facts to return. ''' if topic: # Could use FTS or vector search for better semantic matching results = db.execute( "SELECT fact, category, importance FROM user_memories " "WHERE user_id = ? AND fact LIKE ? " "ORDER BY importance DESC, last_referenced_at DESC LIMIT ?", user_id, f"%{topic}%", limit, ) else: results = db.execute( "SELECT fact, category, importance FROM user_memories " "WHERE user_id = ? ORDER BY importance DESC LIMIT ?", user_id, limit, ) # Update last_referenced_at for retrieved facts fact_ids = [r["id"] for r in results] if fact_ids: db.execute("UPDATE user_memories SET last_referenced_at = NOW() WHERE id IN ?", fact_ids) return [{"fact": r["fact"], "category": r["category"]} for r in results] @tool def update_user_memory(memory_id: int, new_fact: str = None, importance: int = None) -> str: '''Update or correct an existing memory. Use when: - User provides updated info (changed preferences, corrected name). - You learn a memory was wrong. - Importance should change. ''' updates = {} if new_fact: updates["fact"] = new_fact if importance: updates["importance"] = importance db.update("user_memories", id=memory_id, **updates) return "Updated." @tool def forget_about_user(memory_id: int) -> str: '''Delete a memory. Use for sensitive info or user-requested deletion.''' db.delete("user_memories", id=memory_id) return "Forgotten." ``` ## Step 3 — Inject memory at conversation start ```python def load_user_context_node(state): user_id = state["user_id"] memories = recall_about_user.invoke({"user_id": user_id, "limit": 10}) if not memories: return {} # No memories yet memory_summary = "\n".join([f"- [{m['category']}] {m['fact']}" for m in memories]) context_msg = SystemMessage(content=f'''Context about this user from past conversations: {memory_summary} Use this context to personalize your response. Don't explicitly mention these facts unless relevant.''') return {"messages": [context_msg]} ``` Add this node at the start of the graph, before the agent: ```python builder.add_node("load_context", load_user_context_node) builder.add_node("agent", agent_node) builder.set_entry_point("load_context") builder.add_edge("load_context", "agent") ``` ## Step 4 — Extract and save memories during conversation After each user turn, extract facts to save: ```python def extract_memories_node(state): user_id = state["user_id"] # Last few turns recent = state["messages"][-6:] extraction_prompt = '''Analyze this conversation and extract facts worth remembering about the user for future conversations. Focus on: - Preferences (e.g., "prefers concise responses", "vegetarian") - Recurring topics (e.g., "frequently asks about Python") - Important context (e.g., "works at Acme as a data scientist") - Goals (e.g., "learning ML for a career change") DO NOT extract: - Single-conversation context that won't