Types of Memory in LangChain

Without memory:
User: "What is warfarin?"
Bot: "Warfarin is an anticoagulant..."
User: "What dose should I use?"   ← which drug? model has no context
Bot: "What dose for which medication?"  ← lost context

With memory:
User: "What is warfarin?"
Bot: "Warfarin is an anticoagulant..."
[Memory stores: Q: warfarin, A: anticoagulant...]
User: "What dose should I use?"
[Memory retrieves: previous Q&A about warfarin]
Bot: "The warfarin dose is typically 2-10mg daily..."  ← maintained context

from langchain.memory import ConversationBufferMemory

memory = ConversationBufferMemory()

# 1. save_context(): called after each turn to store Q&A
memory.save_context(
    inputs={"input": "What is warfarin?"},
    outputs={"output": "Warfarin is an anticoagulant that inhibits vitamin K recycling..."},
)

# 2. load_memory_variables(): called before each turn to retrieve history
loaded = memory.load_memory_variables({})
print(loaded)
# {"history": "Human: What is warfarin?\nAI: Warfarin is an anticoagulant..."}

from langchain.memory import ConversationBufferMemory
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder

memory = ConversationBufferMemory(
    memory_key="chat_history",          # Variable name in prompt template
    return_messages=True,               # Return list of Message objects (vs string)
)

# Use with a conversational chain
from langchain.chains import ConversationChain

llm = ChatOpenAI(model="gpt-4o", temperature=0)
conversation = ConversationChain(llm=llm, memory=memory)

# Have a conversation
r1 = conversation.predict(input="What is warfarin?")
r2 = conversation.predict(input="What dose should I use for AFib?")  # Has context
r3 = conversation.predict(input="What about monitoring requirements?")

# Memory now holds all 3 turns
print(memory.load_memory_variables({}))

# Manually inspect history
for msg in memory.chat_memory.messages:
    print(f"{msg.type}: {msg.content[:80]}")

from langchain.memory import ConversationBufferWindowMemory

# Keep only the last 5 exchanges (10 messages: 5 human + 5 AI)
windowed_memory = ConversationBufferWindowMemory(
    k=5,
    memory_key="chat_history",
    return_messages=True,
)

# After 10 turns, only turns 6-10 remain
# Turns 1-5 are silently dropped

from langchain.memory import ConversationSummaryMemory

summary_memory = ConversationSummaryMemory(
    llm=ChatOpenAI(model="gpt-4o-mini"),  # Cheap model for summarization
    memory_key="chat_history",
    return_messages=True,
)

# As conversation grows, older turns are replaced by an LLM summary
# Recent turns stay verbatim

# After 3 turns:
# history = [Human: What is warfarin?, AI: Anticoagulant..., Human: Dose?, AI: 2-5mg...]

# After summarization trigger (internal logic):
# history = [SystemMessage("Summary: User asked about warfarin, learned it's anticoagulant, dose 2-5mg"), 
#             HumanMessage("What monitoring?"), AIMessage("INR weekly...")]

from langchain.memory import ConversationSummaryBufferMemory

hybrid_memory = ConversationSummaryBufferMemory(
    llm=ChatOpenAI(model="gpt-4o-mini"),
    max_token_limit=2000,       # When history exceeds 2000 tokens, summarize older turns
    memory_key="chat_history",
    return_messages=True,
)

# Behavior:
# - Recent turns (within token limit): verbatim
# - Older turns (exceeds limit): summarized into a SystemMessage
# - Best of both worlds

from langchain.memory import ConversationEntityMemory

entity_memory = ConversationEntityMemory(
    llm=ChatOpenAI(model="gpt-4o-mini"),
    memory_key="chat_history",
)

# Internal entity store tracks what was said about each named entity
# After conversation about warfarin:
# entities = {
#   "warfarin": "Anticoagulant discussed. Dose: 2-5mg. User asked about AFib indication.",
#   "patient": "Starting warfarin for AFib. Age not mentioned.",
# }

# Retrieves entity context relevant to current query

from langchain.memory import VectorStoreRetrieverMemory
from langchain_openai import OpenAIEmbeddings
from langchain_chroma import Chroma

embedding = OpenAIEmbeddings(model="text-embedding-3-small")
vectorstore = Chroma(embedding_function=embedding)
retriever = vectorstore.as_retriever(search_kwargs={"k": 3})

vector_memory = VectorStoreRetrieverMemory(
    retriever=retriever,
    memory_key="chat_history",
)

# Stores every exchange as an embedding
# At query time: retrieves the 3 most semantically similar past exchanges
# Useful for: "You mentioned warfarin earlier" even if it was 50 turns ago