1. Langchain Memory 是什么?

Langchain Memory 是 Langchain 框架中的一个关键组件，用于在交互过程中存储和管理对话历史或上下文信息。它使得语言模型能够"记住"之前的交互内容，从而实现连贯的多轮对话或保持上下文感知。

Memory 组件解决了大语言模型本身无状态的局限性，使应用能够维持长期的状态信息，记住用户之前提供的信息，并在新的交互中引用这些信息。

2. Langchain Memory 语法

Langchain Memory 的基本语法如下：

from langchain.memory import ConversationBufferMemory, ConversationSummaryMemory
from langchain.chains import ConversationChain
from langchain.llms import OpenAI

# 创建一个简单的记忆组件
memory = ConversationBufferMemory()

# 创建带有记忆功能的对话链
conversation = ConversationChain(
    llm=OpenAI(temperature=0),
    memory=memory,
    verbose=True
)

# 使用链进行对话
response = conversation.predict(input="你好！")
print(response)

# 继续对话，此时会记住上下文
response = conversation.predict(input="我的名字是Alice。")
print(response)

# 查看存储的记忆内容
print(memory.buffer)

3. Langchain Memory 使用小案例

下面是一个更完整的使用不同类型记忆组件的案例：

from langchain.llms import OpenAI
from langchain.chains import ConversationChain
from langchain.memory import (
    ConversationBufferMemory,
    ConversationSummaryMemory,
    ConversationBufferWindowMemory,
    ConversationEntityMemory
)

llm = OpenAI(temperature=0.7)

# 案例1: 使用简单缓冲记忆 - 存储完整对话历史
buffer_memory = ConversationBufferMemory()
buffer_chain = ConversationChain(
    llm=llm,
    memory=buffer_memory,
    verbose=True
)

print("=== 缓冲记忆演示 ===")
print(buffer_chain.predict(input="你好，我叫小明。"))
print(buffer_chain.predict(input="我喜欢打篮球。"))
print(buffer_chain.predict(input="你还记得我的名字吗？"))

# 案例2: 使用窗口记忆 - 只保留最近k轮对话
window_memory = ConversationBufferWindowMemory(k=2)
window_chain = ConversationChain(
    llm=llm,
    memory=window_memory,
    verbose=True
)

print("\n=== 窗口记忆演示 ===")
print(window_chain.predict(input="我是李华。"))
print(window_chain.predict(input="我住在北京。"))
print(window_chain.predict(input="我今年25岁。"))
print(window_chain.predict(input="你还记得我住在哪里吗？"))  # 应该记得
print(window_chain.predict(input="你还记得我的名字吗？"))  # 应该忘记，因为超出窗口范围

# 案例3: 使用摘要记忆 - 通过总结压缩对话历史
summary_memory = ConversationSummaryMemory(llm=llm)
summary_chain = ConversationChain(
    llm=llm,
    memory=summary_memory,
    verbose=True
)

print("\n=== 摘要记忆演示 ===")
print(summary_chain.predict(input="我叫张三，是一名软件工程师。"))
print(summary_chain.predict(input="我目前在一家科技公司工作，主要负责后端开发。"))
print(summary_chain.predict(input="我平时喜欢阅读和旅游。"))
print(summary_chain.predict(input="能总结一下你对我的了解吗？"))

# 查看摘要内容
print("\n摘要内容:")
print(summary_memory.moving_summary_buffer)

# 案例4: 使用实体记忆 - 跟踪特定实体的信息
entity_memory = ConversationEntityMemory(llm=llm)
entity_chain = ConversationChain(
    llm=llm,
    memory=entity_memory,
    verbose=True
)

print("\n=== 实体记忆演示 ===")
print(entity_chain.predict(input="我有一只叫咪咪的猫。"))
print(entity_chain.predict(input="咪咪今年3岁了，是一只橘猫。"))
print(entity_chain.predict(input="我还有一只叫旺旺的狗。"))
print(entity_chain.predict(input="你能告诉我关于咪咪的信息吗？"))

# 查看实体记忆
print("\n实体记忆内容:")
print(entity_memory.entity_store.store)

这个案例展示了四种常用的记忆类型：

  1. ConversationBufferMemory：存储完整的对话历史，适合短期对话。
  2. ConversationBufferWindowMemory：只保留最近k轮对话，控制内存使用。
  3. ConversationSummaryMemory：通过总结压缩长对话历史，适合长期对话。
  4. ConversationEntityMemory：跟踪对话中提及的特定实体信息，适合需要记住具体细节的场景。

根据应用需求的不同，可以选择合适的记忆类型或组合使用多种记忆类型。

4. Langchain Memory 项目中使用思路和技巧

记忆类型选择策略

  1. 场景匹配：

    • 短对话（<10轮）：使用 ConversationBufferMemory
    • 中等长度对话：使用 ConversationBufferWindowMemory
    • 长对话：使用 ConversationSummaryMemory 或 ConversationSummaryBufferMemory
    • 需追踪特定信息：使用 ConversationEntityMemory 或 ConversationKGMemory

  2. 混合记忆策略：针对复杂应用组合多种记忆类型

    from langchain.memory import CombinedMemory

entity_memory = ConversationEntityMemory(llm=llm, entities=["工作", "爱好"])
buffer_memory = ConversationBufferWindowMemory(k=5)

combined_memory = CombinedMemory(memories=[entity_memory, buffer_memory])

conversation = ConversationChain(
    llm=llm,
    memory=combined_memory,
    verbose=True
)

性能优化技巧

  1. 记忆压缩：对于长会话，定期压缩历史记录

    from langchain.memory import ConversationSummaryBufferMemory

memory = ConversationSummaryBufferMemory(
    llm=llm,
    max_token_limit=2000,  # 设置token上限
    return_messages=True
)

  2. 选择性记忆：只存储重要信息，过滤无关内容

    class FilteredMemory(ConversationBufferMemory):
    def save_context(self, inputs, outputs):
        # 过滤掉不需要记住的内容
        if not any(skip_word in inputs["input"] for skip_word in self.skip_words):
            super().save_context(inputs, outputs)

memory = FilteredMemory(skip_words=["你好", "谢谢", "再见"])

  3. 异步存储：将记忆存储操作异步化，避免阻塞主流程

    import asyncio

async def async_save_memory(memory, inputs, outputs):
    memory.save_context(inputs, outputs)

# 在处理响应时
asyncio.create_task(async_save_memory(memory, inputs, outputs))

持久化方案

  1. 数据库存储：将记忆持久化到数据库

    from langchain.memory import MongoDBChatMessageHistory

message_history = MongoDBChatMessageHistory(
    connection_string="mongodb://localhost:27017/",
    session_id="user_123",
    database_name="langchain",
    collection_name="conversations"
)

memory = ConversationBufferMemory(chat_memory=message_history)

  2. Redis缓存：适合高频访问的短期记忆

    from langchain.memory import RedisChatMessageHistory

message_history = RedisChatMessageHistory(
    session_id="session_123",
    url="redis://localhost:6379"
)

memory = ConversationBufferMemory(chat_memory=message_history)

  3. 会话恢复机制：实现用户会话的保存和恢复

    def load_conversation_state(user_id):
    # 从存储中加载用户会话
    history = load_history_from_database(user_id)
    memory = ConversationBufferMemory()
    
    # 重建对话历史
    for exchange in history:
        memory.save_context(
            {"input": exchange["user_message"]},
            {"output": exchange["ai_response"]}
        )
    
    return ConversationChain(llm=llm, memory=memory)

高级使用模式

  1. 上下文窗口动态调整：根据对话复杂度自动调整记忆窗口大小

    class AdaptiveWindowMemory(ConversationBufferWindowMemory):
    def __init__(self, min_k=2, max_k=10, **kwargs):
        super().__init__(**kwargs)
        self.min_k = min_k
        self.max_k = max_k
        self.complexity_threshold = 0.7
    
    def adjust_window_size(self, complexity_score):
        # 根据复杂度调整窗口大小
        new_k = int(self.min_k + (self.max_k - self.min_k) * complexity_score)
        self.k = max(self.min_k, min(new_k, self.max_k))

  2. 多角色记忆：为不同角色维护独立记忆

    class MultiPersonaMemory:
    def __init__(self, llm):
        self.llm = llm
        self.personas = {}
    
    def get_persona_memory(self, persona_id):
        if persona_id not in self.personas:
            self.personas[persona_id] = ConversationBufferMemory()
        return self.personas[persona_id]

  3. 记忆检索增强：结合向量数据库提高记忆检索效率

    from langchain.memory import VectorStoreRetrieverMemory
from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings

# 创建向量存储
embeddings = OpenAIEmbeddings()
vector_store = FAISS.from_texts([""], embeddings)
retriever = vector_store.as_retriever()

# 创建记忆检索器
memory = VectorStoreRetrieverMemory(retriever=retriever)

错误处理与监控

  1. 记忆容错机制：防止单点记忆失效导致整个对话崩溃

    class FaultTolerantMemory(ConversationBufferMemory):
    def load_memory_variables(self, inputs):
        try:
            return super().load_memory_variables(inputs)
        except Exception as e:
            print(f"Memory error: {e}")
            # 返回空记忆而非崩溃
            return {"history": ""}

  2. 记忆使用统计：跟踪记忆组件的使用情况

    class MonitoredMemory(ConversationBufferMemory):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.access_count = 0
        self.save_count = 0
    
    def load_memory_variables(self, inputs):
        self.access_count += 1
        return super().load_memory_variables(inputs)
    
    def save_context(self, inputs, outputs):
        self.save_count += 1
        super().save_context(inputs, outputs)
    
    def get_stats(self):
        return {
            "access_count": self.access_count,
            "save_count": self.save_count,
            "memory_size": len(self.buffer)
        }

这些思路和技巧可以帮助你在实际项目中更有效地利用Langchain Memory组件，构建具有持久性、高性能和健壮性的对话系统。根据具体应用场景，你可以选择性地采用这些策略，或将它们组合使用以达到最佳效果。

# java # 前端
Logo
天启AI社区

GitCode 天启AI是一款由 GitCode 团队打造的智能助手，基于先进的LLM（大语言模型）与多智能体 Agent 技术构建，致力于为用户提供高效、智能、多模态的创作与开发支持。它不仅支持自然语言对话，还具备处理文件、生成 PPT、撰写分析报告、开发 Web 应用等多项能力，真正做到“一句话，让 Al帮你完成复杂任务”。

更多推荐

cover

【感知机】感知机(perceptron)学习算法例题及详解

avatar 天启AI社区
cover

AI云原生：数智化时代AI Agent加速落地的技术基石与实践指南（THS）

avatar 天启AI社区
cover

【AI论文】设计实验室：通过迭代检测与修正来设计幻灯片

avatar 天启AI社区