AI Agents with LangChain & Autonomous Workflows · 课时

对话缓冲记忆

实施基础对话记忆，在智能体的上下文中存储和检索过去的交互内容

对话缓冲记忆 是 CoddyKit 上的免费 AI Agents with LangChain & Autonomous Workflows 课时。这是第 2 节课，共 4 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 AI Agents with LangChain & Autonomous Workflows 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 AI Agents with LangChain & Autonomous Workflows 课程共包含 4 节课。

本课时的部分内容尚未翻译，以英文显示。

Why Agents Need Memory

Imagine having a conversation where you instantly forget everything said just a moment ago. That's what happens to an AI agent without memory!

Agents often need to recall past interactions to maintain context. Without memory, each turn is a fresh start, leading to repetitive or nonsensical conversations.

What is Buffer Memory?

ConversationBufferMemory is LangChain's simplest memory type. It stores the raw, unsummarized conversation history directly.

Think of it like keeping a full transcript of everything said, in the exact order it was said. It's straightforward and easy to use for basic conversational recall.

Initializing Buffer Memory

To use ConversationBufferMemory, you simply import it and create an instance. It's often integrated into a Chain, but we can explore it standalone first.

Let's initialize a memory object and peek at its initial (empty) state:

from langchain.memory import ConversationBufferMemory

# Initialize the memory
memory = ConversationBufferMemory()

print("Memory initialized!")

# You can see its content (it will be empty at first)
print(memory.load_memory_variables({}))

Saving Conversation Context

The save_context method is how you add new user inputs and AI outputs to the memory. It takes two dictionaries: one for inputs and one for outputs.

This method is crucial because it's how the memory 'learns' from the ongoing conversation and builds its history.

Code Demo: Saving Context

Let's add a simple interaction to our memory object and see how it stores the conversation turn.

Notice how the 'input' and 'output' are paired and stored as 'Human' and 'AI' messages.

from langchain.memory import ConversationBufferMemory

memory = ConversationBufferMemory()

# Simulate a user input and an AI response
memory.save_context(
    {"input": "Hi there!"},
    {"output": "Hello! How can I help you?"}
)

print("Memory after one turn:")
print(memory.load_memory_variables({}))

Retrieving Stored History

To access the stored conversation history, you use the load_memory_variables method. It returns a dictionary containing the memory content.

By default, the conversation history is stored under the key 'history'. This key is what you'll typically pass into your LLM's prompt template.

Customizing the Memory Key

By default, ConversationBufferMemory stores history under the key 'history'. However, your prompt template might expect a different variable name, like 'chat_history'.

You can change this using the memory_key parameter during initialization:

from langchain.memory import ConversationBufferMemory

# Initialize with a custom memory_key
memory = ConversationBufferMemory(memory_key="my_chat_history")

memory.save_context(
    {"input": "What's up?"},
    {"output": "Not much, just coding!"}
)

print("Memory with custom key:")
print(memory.load_memory_variables({}))

Integrating with an LLM Chain

Here's how you integrate ConversationBufferMemory into an LLMChain. The memory_key in the ConversationBufferMemory must match the variable name in your PromptTemplate (e.g., chat_history).

Remember to replace 'YOUR_API_KEY' with your actual OpenAI key if you want to run this example fully.

from langchain.memory import ConversationBufferMemory
from langchain.chains import LLMChain
from langchain_openai import OpenAI
from langchain.prompts import PromptTemplate
import os

# Set your OpenAI API key (replace with your actual key or env var)
# os.environ["OPENAI_API_KEY"] = "YOUR_API_KEY"

# Initialize LLM (using a dummy if API key not set)
llm = OpenAI(temperature=0) # You might need to set openai_api_key=os.environ.get("OPENAI_API_KEY")

# Initialize memory with a key matching the prompt template
memory = ConversationBufferMemory(memory_key="chat_history")

# Define a prompt template that expects 'chat_history'
template = """You are a friendly chatbot.
{chat_history}
Human: {human_input}
AI:"""

prompt = PromptTemplate(
    input_variables=["chat_history", "human_input"],
    template=template
)

# Create an LLMChain with the memory
conversation = LLMChain(
    llm=llm,
    prompt=prompt,
    verbose=False,
    memory=memory
)

# First turn
print("Human: What is your capital?")
response1 = conversation.predict(human_input="What is your capital?")
print(f"AI: {response1}")

# Second turn - the AI should remember the context
print("\nHuman: And what about its population?")
response2 = conversation.predict(human_input="And what about its population?")
print(f"AI: {response2}")

When to Use Buffer Memory

ConversationBufferMemory is excellent for short, direct conversations where you need exact recall of recent turns.

Pros: Simple to implement, stores full, unedited conversation details.
Cons: Can quickly exceed the LLM's context window for longer chats, no summarization or filtering, leading to higher token usage and costs.

Quick Check

Let's test your understanding of ConversationBufferMemory.

Buffer Memory Summary

We've successfully explored ConversationBufferMemory, LangChain's simplest way to give agents a basic form of memory:

It stores raw conversation history.
You use save_context to add turns and load_memory_variables to retrieve them.
It's ideal for short, direct conversations but can quickly hit LLM context limits with longer chats.
Remember to set memory_key if your prompt expects a different variable name for history.

Next, we'll dive into more advanced memory solutions that handle longer conversations better!

常见问题解答

「对话缓冲记忆」课时是免费的吗？

是的 — 「对话缓冲记忆」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 AI Agents with LangChain & Autonomous Workflows 课程的其余内容，请升级到 CoddyKit PRO。 AI Agents with LangChain & Autonomous Workflows 课程共包含 4 节课。

「对话缓冲记忆」这节课中我会学到什么？

实施基础对话记忆，在智能体的上下文中存储和检索过去的交互内容你通过在浏览器中直接运行的动手代码来练习 AI Agents with LangChain & Autonomous Workflows，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 AI Agents with LangChain & Autonomous Workflows 需要有经验吗？

无需任何先前经验。CoddyKit 上的 AI Agents with LangChain & Autonomous Workflows 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 2 节课，共 4 节。

「对话缓冲记忆」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 AI Agents with LangChain & Autonomous Workflows 课中编写并运行代码吗？

能。每节 AI Agents with LangChain & Autonomous Workflows 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 AI Agents with LangChain & Autonomous Workflows