2025 Agentic AI趋势：上下文工程架构如何让智能体“更懂你”？

引言：为什么你的智能体总“答非所问”？

你有没有遇到过这样的情况？

• 用户问：“我之前说的那个红色手机，帮我查一下库存。” 智能体回复：“请问你说的是哪款红色手机？”
• 用户连续问：“北京的天气怎么样？”→“那明天适合去故宫吗？” 智能体回复：“明天北京的天气是晴，温度15-22℃。”（没意识到“明天适合去故宫”需要结合天气和故宫的开放信息）
• 用户在电商平台问：“这件衣服有没有XL码？” 智能体回复：“这件衣服的材质是棉麻。”

这些“答非所问”的问题，本质上是智能体缺乏对“上下文”的理解能力。2024年，Agentic AI（智能体AI）的爆发让我们看到了AI自主完成任务的潜力，但上下文理解能力依然是制约智能体实用性的关键瓶颈。

2025年，上下文工程架构将成为提升智能体理解能力的“必选项”。它不是简单的“记住对话历史”，而是一套系统化的上下文管理机制，能让智能体像人类一样“记住过去、理解现在、预测未来”。

本文将带你：

1. 理解上下文工程的核心逻辑（为什么它能解决“答非所问”？）；
2. 掌握上下文工程的4大核心组件（存储、检索、融合、更新）；
3. 实战搭建一个有上下文理解能力的智能体（用LangChain实现）；
4. 探索2025年上下文工程的进阶方向（多模态、个性化、性能优化）。

读完本文，你将能设计出“更懂用户”的智能体，彻底解决“答非所问”的痛点。

准备工作：你需要这些基础

在开始之前，请确保你具备以下知识和工具：

• 技术栈/知识：
  • 熟悉LLM（如GPT-4、Claude 3）的基本概念（上下文窗口、Prompt工程）；
  • 了解Agent的核心能力（工具调用、任务规划、记忆）；
  • 掌握Python编程（基础语法、函数、类）；
  • 用过至少一个Agent框架（如LangChain、AutoGPT，本文用LangChain）。
• 环境/工具：
  • Python 3.8+（推荐3.10）；
  • pip（Python包管理工具）；
  • LangChain库（pip install langchain）；
  • OpenAI API密钥（或其他LLM API，如Anthropic）；
  • Chroma向量数据库（pip install chromadb，轻量级开源）。

核心内容：上下文工程架构实战

一、先搞懂：上下文工程到底是什么？

上下文工程（Context Engineering）是一套管理智能体“上下文信息”的机制，目的是让智能体在处理当前任务时，能准确获取、融合并利用相关的历史信息、用户信息、领域知识等，从而做出更符合上下文的决策。

1. 上下文工程的4大核心组件

上下文工程的核心逻辑可以总结为“存-找-合-更”：

• 上下文存储（Context Storage）：像“记忆库”一样，存储智能体需要的所有上下文信息（对话历史、用户Profile、领域知识等）；
• 上下文检索（Context Retrieval）：从“记忆库”中快速找到与当前任务语义相关的上下文（比如用户问“红色手机有没有货”时，检索“红色手机的库存信息”）；
• 上下文融合（Context Fusion）：将检索到的上下文与当前任务结合，生成能让LLM理解的“完整Prompt”（比如“用户之前问过红色手机的价格，现在问有没有货，需要结合库存信息回答”）；
• 上下文更新（Context Update）：在任务完成后，更新“记忆库”（比如添加新的对话历史、更新用户偏好）。

2. 为什么需要这4个组件？

举个例子，当用户问“那个红色手机有没有货？”时：

• 没有上下文存储：智能体不知道“红色手机”指的是哪款（之前没记住）；
• 没有上下文检索：即使存储了库存信息，也找不到“红色手机”的库存；
• 没有上下文融合：LLM只能看到“有没有货？”，无法结合之前的“红色手机”信息；
• 没有上下文更新：下次用户再问“那个手机”，智能体还是不知道指的是什么。

这4个组件共同解决了“智能体如何理解上下文”的问题，是2025年Agentic AI的核心竞争力。

二、步骤一：设计上下文存储——给智能体建“记忆库”

上下文存储是上下文工程的“地基”，决定了智能体能“记住”多少信息。我们需要存储4类关键信息：

1. 对话历史（Conversation History）

• 作用：记住用户与智能体的交互记录（比如“用户昨天问了红色手机的价格”）；
• 存储方式：用LangChain的ConversationBufferWindowMemory（保留最近k条对话，避免占用过多上下文窗口）。

代码示例：存储对话历史

from langchain.memory import ConversationBufferWindowMemory

# 初始化对话历史存储：保留最近3条对话
memory = ConversationBufferWindowMemory(
    return_messages=True,  # 返回消息对象（包含角色：Human/AIMessage）
    k=3  # 保留最近3条对话
)

# 模拟用户交互，添加对话历史
memory.save_context(
    inputs={"input": "我想了解红色手机的价格"},
    outputs={"output": "红色手机的价格是1999元"}
)
memory.save_context(
    inputs={"input": "有没有黑色的？"},
    outputs={"output": "黑色款暂时缺货，预计下周补货"}
)

# 查看存储的对话历史（最近2条）
print(memory.load_memory_variables({}))
# 输出：
# {'history': [
#   HumanMessage(content='我想了解红色手机的价格'),
#   AIMessage(content='红色手机的价格是1999元'),
#   HumanMessage(content='有没有黑色的？'),
#   AIMessage(content='黑色款暂时缺货，预计下周补货')
# ]}

为什么用ConversationBufferWindowMemory？
它解决了ConversationBufferMemory（保留所有对话）的性能问题——当对话历史很长时，会超过LLM的上下文窗口（比如GPT-4的8k/16k tokens），导致成本上升（每token收费）和响应变慢。k=3表示只保留最近3条对话，既保证了上下文的连贯性，又控制了成本。

2. 用户Profile（User Profile）

• 作用：记住用户的固定信息（如姓名、偏好、历史行为）（比如“用户喜欢红色，之前买过手机配件”）；
• 存储方式：用字典或数据库（如SQLite）存储，关键信息包括：user_id（唯一标识）、preferences（偏好）、history_actions（历史行为）。

代码示例：存储用户Profile

# 用字典存储用户Profile（实际项目中用数据库）
user_profile = {
    "user_id": "12345",
    "name": "张三",
    "preferences": {"color": "红色", "brand": "华为"},
    "history_actions": ["2024-10-01 购买手机配件", "2024-10-05 咨询红色手机价格"]
}

# 从Profile中提取关键信息，用于后续融合
def get_user_preferences(user_id):
    return user_profile.get(user_id, {}).get("preferences", {})

# 示例：获取用户张三的偏好
print(get_user_preferences("12345"))
# 输出：{'color': '红色', 'brand': '华为'}

3. 领域知识（Domain Knowledge）

• 作用：记住智能体所在领域的专业信息（如电商中的产品库存、医疗中的疾病症状）；
• 存储方式：用向量数据库（如Chroma）存储，因为向量能捕捉语义相关性（比如“有没有货”和“库存”是语义相关的）。

代码示例：用Chroma存储领域知识
假设我们有一个product_inventory.txt文件，内容是：

产品名称：红色手机（华为）
库存：100台
仓库：北京
价格：1999元

产品名称：黑色手机（小米）
库存：0台
仓库：上海
价格：1799元

我们需要将这些内容存储到Chroma中，以便后续检索：

from langchain.document_loaders import TextLoader
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma
from langchain.text_splitter import CharacterTextSplitter

# 1. 加载领域知识文档
loader = TextLoader("product_inventory.txt", encoding="utf-8")
documents = loader.load()

# 2. 分割文档（将长文档分成短片段，便于向量存储）
text_splitter = CharacterTextSplitter(
    chunk_size=200,  # 每个片段200字符
    chunk_overlap=0  # 不重叠
)
split_docs = text_splitter.split_documents(documents)

# 3. 初始化嵌入模型（将文本转换为向量）
embeddings = OpenAIEmbeddings(openai_api_key="your-api-key")

# 4. 创建Chroma向量数据库，存储领域知识
vector_db = Chroma.from_documents(
    split_docs,
    embeddings,
    persist_directory="./chroma_db"  # 存储到本地目录
)

# 5. 测试检索：查询“红色手机的库存”
query = "红色手机的库存是多少？"
retrieved_docs = vector_db.similarity_search(query, k=1)  # 取最相关的1条
print(retrieved_docs[0].page_content)
# 输出：
# 产品名称：红色手机（华为）
# 库存：100台
# 仓库：北京
# 价格：1999元

为什么用向量数据库？
传统的关键词检索（如“库存”=“库存”）无法处理语义相关的查询（比如“有没有货”=“库存”），而向量数据库能将文本转换为高维向量，通过计算余弦相似度快速找到语义相关的文档。比如用户问“红色手机有没有货？”，向量数据库能准确检索到“红色手机的库存：100台”的文档。

三、步骤二：上下文检索——找到“最相关”的信息

上下文检索是上下文工程的“眼睛”，它决定了智能体能否找到对当前任务有用的上下文。常见的检索方式有3种：

1. 基于规则的检索（Rule-Based Retrieval）

• 逻辑：根据预先定义的规则提取上下文（比如“保留最近3条对话”“提取用户Profile中的偏好”）；
• 适用场景：对话历史、用户Profile等结构化信息。

代码示例：提取最近3条对话

# 用ConversationBufferWindowMemory提取最近3条对话
memory = ConversationBufferWindowMemory(k=3, return_messages=True)
# ...（添加对话历史）
history = memory.load_memory_variables({})["history"]
print(history)
# 输出最近3条对话

2. 基于向量的检索（Vector-Based Retrieval）

• 逻辑：将当前查询转换为向量，与向量数据库中的文档向量计算相似度，取相似度最高的文档；
• 适用场景：领域知识、非结构化文档（如产品说明书、法规）。

代码示例：用Chroma检索领域知识

# 之前创建的vector_db
query = "红色手机有没有货？"
retrieved_docs = vector_db.similarity_search(query, k=1)
print(retrieved_docs[0].page_content)
# 输出：红色手机的库存信息（100台）

3. 混合检索（Hybrid Retrieval）

• 逻辑：结合规则检索和向量检索（比如“先取最近3条对话，再检索领域知识”）；
• 适用场景：需要同时用到对话历史和领域知识的任务（如电商客服）。

代码示例：混合检索

def retrieve_context(query, memory, vector_db):
    # 1. 规则检索：取最近3条对话
    history = memory.load_memory_variables({})["history"]
    # 2. 向量检索：取领域知识
    retrieved_docs = vector_db.similarity_search(query, k=1)
    # 3. 合并上下文
    context = {
        "history": history,
        "domain_knowledge": retrieved_docs[0].page_content if retrieved_docs else ""
    }
    return context

# 测试混合检索
query = "红色手机有没有货？"
context = retrieve_context(query, memory, vector_db)
print(context)
# 输出：
# {
#   "history": [HumanMessage(...), AIMessage(...)],  # 最近3条对话
#   "domain_knowledge": "红色手机的库存：100台..."  # 检索到的领域知识
# }

四、步骤三：上下文融合——让LLM“理解”上下文

上下文融合是将检索到的上下文与当前查询结合，生成能让LLM理解的“完整Prompt”。它的核心是让LLM同时看到“过去”和“现在”。

1. 融合的核心逻辑

好的融合需要满足3个条件：

• 完整性：包含所有相关的上下文（对话历史、领域知识、用户Profile）；
• 简洁性：避免冗余（比如不要重复提到“红色手机的价格”）；
• 结构化：用清晰的格式（如Markdown、JSON）让LLM容易解析。

2. 用PromptTemplate实现融合

LangChain的PromptTemplate是实现上下文融合的利器，它允许我们将上下文变量（如history、domain_knowledge）插入到Prompt中。

代码示例：创建融合Prompt
假设我们要搭建一个电商客服智能体，需要融合对话历史、领域知识、用户Profile，我们可以这样设计Prompt：

from langchain.prompts import PromptTemplate

# 定义Prompt模板（包含上下文变量）
prompt_template = """
你是一个电商客服智能体，需要结合以下信息回答用户的问题：

1. 对话历史：{history}
2. 领域知识：{domain_knowledge}
3. 用户偏好：{user_preferences}

用户当前的问题是：{query}

请遵循以下规则回答：
- 如果用户的问题需要结合对话历史，必须提到之前的交互（比如“你之前问过红色手机的价格，现在它的库存是100台”）；
- 如果有领域知识，必须用领域知识中的信息回答（比如“根据库存信息，红色手机有100台”）；
- 如果用户有偏好，必须考虑偏好（比如“你喜欢红色，这款红色手机正好有货”）。

回答要简洁、友好，不要使用Markdown格式。
"""

# 初始化PromptTemplate
prompt = PromptTemplate(
    input_variables=["history", "domain_knowledge", "user_preferences", "query"],
    template=prompt_template
)

# 融合上下文（用之前的retrieve_context函数获取上下文）
context = retrieve_context(query, memory, vector_db)
user_preferences = get_user_preferences("12345")  # 获取用户偏好

# 生成完整Prompt
full_prompt = prompt.format(
    history=context["history"],
    domain_knowledge=context["domain_knowledge"],
    user_preferences=user_preferences,
    query=query
)

print(full_prompt)
# 输出：
# 你是一个电商客服智能体，需要结合以下信息回答用户的问题：
# 
# 1. 对话历史：[HumanMessage(content='我想了解红色手机的价格'), AIMessage(content='红色手机的价格是1999元'), HumanMessage(content='有没有黑色的？'), AIMessage(content='黑色款暂时缺货，预计下周补货')]
# 2. 领域知识：产品名称：红色手机（华为）\n库存：100台\n仓库：北京\n价格：1999元
# 3. 用户偏好：{'color': '红色', 'brand': '华为'}
# 
# 用户当前的问题是：红色手机有没有货？
# 
# 请遵循以下规则回答：
# - 如果用户的问题需要结合对话历史，必须提到之前的交互（比如“你之前问过红色手机的价格，现在它的库存是100台”）；
# - 如果有领域知识，必须用领域知识中的信息回答（比如“根据库存信息，红色手机有100台”）；
# - 如果用户有偏好，必须考虑偏好（比如“你喜欢红色，这款红色手机正好有货”）。
# 
# 回答要简洁、友好，不要使用Markdown格式。

为什么要这样设计Prompt？

• 对话历史：让LLM知道用户之前问过“红色手机的价格”，现在问“有没有货”是连贯的；
• 领域知识：让LLM知道“红色手机有100台库存”；
• 用户偏好：让LLM知道用户喜欢红色，可以强调“正好有货”。

这样的Prompt能让LLM生成更符合上下文的回答，比如：

“你之前问过红色手机的价格（1999元），根据库存信息，这款红色华为手机目前有100台库存，位于北京仓库。你喜欢红色，正好适合你！”

五、步骤四：上下文更新——保持“记忆”的新鲜度

上下文更新是在智能体回答完用户问题后，更新上下文存储（对话历史、用户Profile、领域知识），确保下次交互时能用到最新的信息。

1. 更新的时机和策略

• 对话历史更新：每次用户交互后（比如用户问完“有没有货”，智能体回答后，添加新的对话到ConversationBufferWindowMemory）；
• 用户Profile更新：当用户偏好变化时（比如用户之前喜欢红色，现在说“我更喜欢蓝色”，需要更新user_profile中的preferences）；
• 领域知识更新：当领域知识变化时（比如产品库存从100台变成50台，需要重新生成向量并更新Chroma）。

代码示例：更新对话历史

# 模拟用户交互：用户问“红色手机有没有货？”，智能体回答后更新对话历史
user_query = "红色手机有没有货？"
agent_response = "红色手机有100台库存，位于北京仓库。"

# 更新对话历史（添加新的HumanMessage和AIMessage）
memory.save_context(
    inputs={"input": user_query},
    outputs={"output": agent_response}
)

# 查看更新后的对话历史（最近3条）
print(memory.load_memory_variables({})["history"])
# 输出：
# [
#   HumanMessage(content='有没有黑色的？'),
#   AIMessage(content='黑色款暂时缺货，预计下周补货'),
#   HumanMessage(content='红色手机有没有货？'),
#   AIMessage(content='红色手机有100台库存，位于北京仓库。')
# ]

代码示例：更新用户Profile

# 假设用户现在说“我更喜欢蓝色”，需要更新用户偏好
def update_user_preferences(user_id, new_preferences):
    if user_id in user_profile:
        user_profile[user_id]["preferences"].update(new_preferences)
    else:
        user_profile[user_id] = {"preferences": new_preferences}

# 更新用户张三的偏好（从红色变成蓝色）
update_user_preferences("12345", {"color": "蓝色"})

# 查看更新后的用户Profile
print(user_profile["12345"]["preferences"])
# 输出：{'color': '蓝色', 'brand': '华为'}

代码示例：更新领域知识
假设产品库存从100台变成50台，我们需要更新Chroma中的领域知识：

# 1. 加载新的领域知识文档（product_inventory_v2.txt）
# 内容：产品名称：红色手机（华为）；库存：50台；...
new_loader = TextLoader("product_inventory_v2.txt", encoding="utf-8")
new_documents = new_loader.load()

# 2. 分割文档
new_split_docs = text_splitter.split_documents(new_documents)

# 3. 更新Chroma向量数据库（先删除旧文档，再添加新文档）
vector_db.delete_collection()  # 删除旧的集合
vector_db = Chroma.from_documents(
    new_split_docs,
    embeddings,
    persist_directory="./chroma_db"
)

# 4. 测试检索（确认库存更新）
query = "红色手机的库存是多少？"
retrieved_docs = vector_db.similarity_search(query, k=1)
print(retrieved_docs[0].page_content)
# 输出：库存：50台

六、实战：搭建一个“懂上下文”的智能体

现在，我们将前面的组件整合起来，搭建一个电商客服智能体，它能：

1. 记住对话历史（最近3条）；
2. 检索产品库存信息（用Chroma）；
3. 融合对话历史、领域知识、用户Profile回答问题；
4. 更新对话历史和用户Profile。

1. 完整代码结构

from langchain.memory import ConversationBufferWindowMemory
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma
from langchain.prompts import PromptTemplate
from langchain.llms import OpenAI
from langchain.chains import LLMChain

# 1. 初始化上下文存储
# 1.1 对话历史存储
memory = ConversationBufferWindowMemory(k=3, return_messages=True)
# 1.2 用户Profile存储（用字典）
user_profile = {
    "12345": {
        "name": "张三",
        "preferences": {"color": "红色", "brand": "华为"},
        "history_actions": ["2024-10-01 购买手机配件", "2024-10-05 咨询红色手机价格"]
    }
}
# 1.3 领域知识存储（Chroma）
# 假设已经创建了Chroma向量数据库（见前面的代码）
embeddings = OpenAIEmbeddings(openai_api_key="your-api-key")
vector_db = Chroma(persist_directory="./chroma_db", embedding_function=embeddings)

# 2. 定义上下文检索函数
def retrieve_context(query, memory, vector_db, user_id):
    # 2.1 检索对话历史
    history = memory.load_memory_variables({})["history"]
    # 2.2 检索领域知识
    retrieved_docs = vector_db.similarity_search(query, k=1)
    # 2.3 检索用户Profile
    user_preferences = user_profile.get(user_id, {}).get("preferences", {})
    # 2.4 合并上下文
    return {
        "history": history,
        "domain_knowledge": retrieved_docs[0].page_content if retrieved_docs else "",
        "user_preferences": user_preferences
    }

# 3. 定义上下文融合Prompt
prompt_template = """
你是一个电商客服智能体，需要结合以下信息回答用户的问题：

1. 对话历史：{history}
2. 产品库存信息：{domain_knowledge}
3. 用户偏好：{user_preferences}

用户当前的问题是：{query}

请遵循以下规则：
- 必须提到对话历史中的相关信息（比如用户之前问过的问题）；
- 必须用产品库存信息回答（比如库存数量、仓库位置）；
- 必须考虑用户偏好（比如用户喜欢的颜色、品牌）；
- 回答要简洁、友好，用口语化的中文。

回答示例：
用户之前问过红色手机的价格，现在问有没有货，回答应该是：
“你之前问过红色手机的价格（1999元），根据库存信息，这款红色华为手机目前有100台库存，位于北京仓库。你喜欢红色，正好适合你！”
"""

prompt = PromptTemplate(
    input_variables=["history", "domain_knowledge", "user_preferences", "query"],
    template=prompt_template
)

# 4. 初始化LLM和Chain
llm = OpenAI(
    openai_api_key="your-api-key",
    temperature=0.5  # 控制回答的随机性（0.5表示中等）
)
chain = LLMChain(
    llm=llm,
    prompt=prompt,
    memory=memory  # 自动管理对话历史（不需要手动save_context）
)

# 5. 定义智能体交互函数
def agent_interact(user_id, query):
    # 5.1 检索上下文
    context = retrieve_context(query, memory, vector_db, user_id)
    # 5.2 融合上下文并生成回答（用Chain运行）
    response = chain.run(
        history=context["history"],
        domain_knowledge=context["domain_knowledge"],
        user_preferences=context["user_preferences"],
        query=query
    )
    # 5.3 更新对话历史（Chain会自动更新memory）
    # 5.4 返回回答
    return response

# 6. 测试智能体
user_id = "12345"
# 测试1：用户问“红色手机的价格是多少？”
query1 = "红色手机的价格是多少？"
response1 = agent_interact(user_id, query1)
print(f"用户：{query1}")
print(f"智能体：{response1}")
# 输出：
# 用户：红色手机的价格是多少？
# 智能体：红色手机的价格是1999元（华为品牌），符合你的偏好（红色、华为）。

# 测试2：用户问“有没有货？”（需要结合对话历史）
query2 = "有没有货？"
response2 = agent_interact(user_id, query2)
print(f"用户：{query2}")
print(f"智能体：{response2}")
# 输出：
# 用户：有没有货？
# 智能体：你之前问过红色手机的价格（1999元），根据库存信息，这款红色华为手机目前有100台库存，位于北京仓库。你喜欢红色，正好适合你！

# 测试3：用户更新偏好（“我更喜欢蓝色”）
update_user_preferences(user_id, {"color": "蓝色"})
query3 = "有没有蓝色的手机？"
response3 = agent_interact(user_id, query3)
print(f"用户：{query3}")
print(f"智能体：{response3}")
# 输出：
# 用户：有没有蓝色的手机？
# 智能体：根据你的偏好（蓝色），目前蓝色手机（小米）的库存是0台，预计下周补货。你可以关注一下！

2. 效果说明

• 测试1：智能体结合了用户偏好（红色、华为）和领域知识（价格1999元）回答；
• 测试2：智能体结合了对话历史（之前问过价格）、领域知识（库存100台）、用户偏好（红色）回答；
• 测试3：智能体结合了更新后的用户偏好（蓝色）和领域知识（蓝色手机库存0台）回答。

这个智能体已经具备了上下文理解能力，能像人类客服一样“记住”用户的历史交互和偏好，结合专业知识回答问题。

进阶探讨：2025年上下文工程的趋势

1. 多模态上下文（Multimodal Context）

2025年，智能体将不再局限于文本交互，还会处理图片、语音、视频等多模态上下文。比如：

• 用户发送一张红色手机的图片，问“这个手机有没有货？”，智能体需要：
  1. 用计算机视觉模型（如CLIP）识别图片中的“红色手机（华为）”；
  2. 检索该产品的库存信息（用Chroma）；
  3. 融合对话历史（比如用户之前问过价格）回答。

实现思路：用多模态嵌入模型（如CLIP）将图片转换为向量，存储到Chroma中，检索时同时考虑文本和图片向量。

2. 上下文个性化（Context Personalization）

2025年，上下文工程将更强调用户个性化，比如：

• 对老用户，保留更长的对话历史（k=10）；
• 对新用户，优先展示热门产品（结合用户Profile中的“新用户”标签）；
• 根据用户的历史行为（如购买过手机配件），推荐相关产品（如“你之前买过手机配件，这款红色手机的保护壳正好适合你”）。

实现思路：在上下文检索时，给用户Profile中的关键信息（如“老用户”“历史行为”）添加权重（比如老用户的对话历史权重是1.5，新用户是0.5）。

3. 上下文压缩（Context Compression）

当对话历史很长时，即使使用ConversationBufferWindowMemory，也可能超过LLM的上下文窗口。2025年，上下文压缩将成为主流，比如：

• 用LLM总结对话历史（比如将10条对话总结成1条）；
• 用自动摘要模型（如BART）压缩领域知识（比如将1000字的产品说明书压缩成200字）。

实现思路：用LangChain的ConversationSummaryMemory（自动总结对话历史）代替ConversationBufferWindowMemory：

from langchain.memory import ConversationSummaryMemory

# 初始化总结记忆（自动总结对话历史）
memory = ConversationSummaryMemory(
    llm=llm,  # 用LLM总结
    return_messages=True
)

# 添加对话历史
memory.save_context({"input": "红色手机的价格是多少？"}, {"output": "1999元"})
memory.save_context({"input": "有没有黑色的？"}, {"output": "缺货"})

# 查看总结后的对话历史
print(memory.load_memory_variables({})["history"])
# 输出：
# [SummaryMessage(content='用户问了红色手机的价格（1999元），然后问有没有黑色的（缺货）')]

4. 上下文可解释性（Context Interpretability）

2025年，用户将更关注智能体“为什么这样回答”，上下文可解释性将成为必须。比如：

• 智能体回答后，显示“我使用了以下信息回答你的问题：1. 对话历史（你之前问过价格）；2. 领域知识（库存100台）；3. 用户偏好（红色）”；
• 用可视化工具（如Streamlit）展示上下文检索的过程（比如“红色手机的库存”的检索路径）。

实现思路：在上下文融合时，记录使用的上下文信息，然后在回答中添加解释：

def agent_interact(user_id, query):
    context = retrieve_context(query, memory, vector_db, user_id)
    response = chain.run(**context)
    # 添加解释
    explanation = f"我使用了以下信息回答你的问题：\n1. 对话历史：{context['history']}\n2. 领域知识：{context['domain_knowledge']}\n3. 用户偏好：{context['user_preferences']}"
    return {"response": response, "explanation": explanation}

# 测试解释功能
result = agent_interact(user_id, query2)
print(f"智能体回答：{result['response']}")
print(f"解释：{result['explanation']}")
# 输出：
# 智能体回答：你之前问过红色手机的价格（1999元），根据库存信息，这款红色华为手机目前有100台库存，位于北京仓库。你喜欢红色，正好适合你！
# 解释：我使用了以下信息回答你的问题：
# 1. 对话历史：[HumanMessage(...), AIMessage(...)]（最近3条）
# 2. 领域知识：红色手机的库存是100台...
# 3. 用户偏好：{'color': '红色', 'brand': '华为'}

总结：上下文工程是智能体的“理解大脑”

通过本文的学习，你应该已经掌握了上下文工程的核心逻辑：

• 存：用ConversationBufferWindowMemory存储对话历史，用Chroma存储领域知识；
• 找：用混合检索（规则+向量）找到相关上下文；
• 合：用PromptTemplate融合上下文和当前查询；
• 更：更新对话历史、用户Profile、领域知识保持新鲜度。

这些组件共同构成了智能体的“理解大脑”，能让智能体像人类一样“记住过去、理解现在、预测未来”。

2025年，上下文工程能力将成为智能体的“核心竞争力”——谁能更好地管理上下文，谁就能设计出更懂用户的智能体。

行动号召：让我们一起打造“懂你的智能体”

现在，轮到你动手实践了！你可以：

1. 修改本文的代码，将ConversationBufferWindowMemory换成ConversationSummaryMemory（测试上下文压缩）；
2. 添加多模态上下文（比如处理图片）；
3. 用Streamlit搭建一个可视化界面（展示智能体的上下文理解过程）。

如果你在实践中遇到问题，或者有更好的思路，欢迎在评论区留言讨论！让我们一起打造“懂你的智能体”，推动Agentic AI的发展！

最后，送你一句话：

智能体的“理解能力”，取决于它“记住了多少”和“如何使用这些记忆”——而上下文工程，就是让智能体“记住并正确使用记忆”的关键。

祝你在2025年的Agentic AI趋势中，成为“懂上下文”的开发者！ 🚀