Short-term vs Long-term Memory

Effective agents need both types of memory: short-term for the current conversation and long-term for persistent knowledge across sessions.

Memory Types Overview

Type	Scope	Storage	Use Case
Short-term	Current session	In-memory	Conversation context
Long-term	Across sessions	Database/Vector store	User preferences, facts
Episodic	Past experiences	Vector store	Similar past situations
Semantic	Facts & concepts	Knowledge graph	Domain knowledge

Short-term Memory

Keeps track of the current conversation:

from langchain.memory import ConversationBufferMemory

# Simple buffer - stores all messages
memory = ConversationBufferMemory()
memory.save_context(
    {"input": "My name is Alice"},
    {"output": "Nice to meet you, Alice!"}
)

# Window buffer - keeps last N exchanges
from langchain.memory import ConversationBufferWindowMemory
memory = ConversationBufferWindowMemory(k=10)

# Summary memory - summarizes older messages
from langchain.memory import ConversationSummaryMemory
memory = ConversationSummaryMemory(llm=llm)

Long-term Memory

Persists information across sessions:

import json
from datetime import datetime

class LongTermMemory:
    def __init__(self, user_id, db):
        self.user_id = user_id
        self.db = db

    def remember(self, key, value, metadata=None):
        """Store a fact about the user"""
        self.db.upsert({
            "user_id": self.user_id,
            "key": key,
            "value": value,
            "metadata": metadata,
            "updated_at": datetime.now()
        })

    def recall(self, key):
        """Retrieve a stored fact"""
        return self.db.query(
            user_id=self.user_id,
            key=key
        )

    def search(self, query):
        """Semantic search through memories"""
        embedding = embed(query)
        return self.db.vector_search(
            user_id=self.user_id,
            embedding=embedding,
            top_k=5
        )

Combining Memory Types

A production agent typically uses multiple memory systems:

class AgentMemory:
    def __init__(self, user_id):
        # Short-term: current conversation
        self.conversation = ConversationBufferWindowMemory(k=20)

        # Long-term: user facts
        self.user_facts = LongTermMemory(user_id, facts_db)

        # Episodic: past conversations
        self.episodes = VectorStore(f"episodes_{user_id}")

    def get_context(self, query):
        """Build context from all memory types"""
        context = {
            "recent": self.conversation.load_memory_variables({}),
            "user_info": self.user_facts.recall("preferences"),
            "similar_past": self.episodes.search(query, k=3)
        }
        return context

    def save_interaction(self, input, output):
        """Save to both short and long-term"""
        # Short-term
        self.conversation.save_context(
            {"input": input},
            {"output": output}
        )

        # Extract and store facts
        facts = extract_facts(input, output)
        for fact in facts:
            self.user_facts.remember(fact.key, fact.value)

Memory Extraction

Automatically extract memorable information:

def extract_facts(conversation):
    """Use LLM to extract facts worth remembering"""
    prompt = """
    Extract key facts from this conversation that should be remembered:
    - User preferences
    - Important dates/events
    - Stated goals or needs

    Conversation: {conversation}

    Facts (JSON format):
    """
    return llm.generate(prompt.format(conversation=conversation))

Best Practices

Practice	Why It Matters
Scope memory appropriately	Don't store everything
Add timestamps	Know when info was learned
Enable forgetting	Remove outdated info
Respect privacy	Handle personal data carefully
Test recall accuracy	Verify memory retrieval