2.3 向量存储

2.3 提示词（Prompts）与上下文管理 — LangChain框架精通 Agent 核心机制

本节导读：深入掌握 LangChain Agent 的提示词工程和上下文管理，学习如何构建动态、智能的提示词系统，实现 Agent 的个性化响应和上下文感知能力。

学习目标

• 理解 Agent 提示词的核心概念和设计原则
• 掌握动态提示词生成和上下文管理的实现方法
• 学习使用 MessagesPlaceholder 和 FewShotPromptTemplate
• 熟练实现个性化提示词和记忆管理
• 掌握提示词优化和性能调优技巧
• 构建完整的 Agent 提示词系统

核心概念

Agent 提示词架构

Agent 提示词是 Agent 的"大脑"，它决定了 Agent 的行为模式、知识体系、决策逻辑和响应风格。与普通 LLM 提示词不同，Agent 提示词需要包含：

1. 系统角色定义：明确 Agent 的身份、职责和能力范围
2. 工具调用规则：定义何时调用工具、如何选择工具、工具调用的格式
3. 上下文管理：维护对话历史、管理记忆、处理多轮对话
4. 输出格式约束：确保输出的结构和内容符合预期
5. 安全约束：定义安全边界和拒绝条件

Agent vs LLM 提示词对比

环境准备 / 前置知识

基础依赖安装

# Agent 提示词核心包
pip install langchain langchain-openai langchain-community

# Agent 框架
pip install langchain-agents

# 工具和记忆
pip install langchain-tools langchain-memory
​

核心导入模块

import os
from typing import List, Dict, Any, Optional

# Agent 核心
from langchain.agents import AgentExecutor, create_openai_tools_agent
from langchain.prompts import PromptTemplate, ChatPromptTemplate
from langchain_core.prompts import MessagesPlaceholder

# 工具和记忆
from langchain.tools import Tool
from langchain.memory import ConversationBufferMemory
from langchain.schema import SystemMessage, HumanMessage, AIMessage

# 模型
from langchain_openai import ChatOpenAI
​

分步实战

步骤 1：基础 Agent 提示词配置

首先配置基础的环境和提示词结构：

import os
from langchain.agents import AgentExecutor, create_openai_tools_agent
from langchain.prompts import ChatPromptTemplate
from langchain_core.prompts import MessagesPlaceholder
from langchain.tools import Tool
from langchain_openai import ChatOpenAI
from langchain.schema import SystemMessage, HumanMessage

# 设置 API 密钥
os.environ["OPENAI_API_KEY"] = "your-openai-api-key"

# 创建基础聊天模型
llm = ChatOpenAI(
    model="gpt-4-turbo",
    temperature=0.7,
    max_tokens=2000
)

# 定义基础工具
def calculator(query: str) -> str:
    """简单的计算器工具"""
    try:
        import re
        numbers = re.findall(r'\d+', query)
        if len(numbers) >= 2 and '+' in query:
            result = int(numbers[0]) + int(numbers[1])
            return f"计算结果: {result}"
        else:
            return "请提供有效的计算表达式"
    except Exception as e:
        return f"计算错误: {str(e)}"

# 创建工具列表
tools = [
    Tool(
        name="calculator",
        description="用于数学计算的工具",
        func=calculator
    )
]

# 创建 Agent 提示词模板
agent_prompt = ChatPromptTemplate.from_messages([
    SystemMessage(content="""你是一个智能助手，具备以下能力：
1. 使用工具回答用户问题
2. 根据问题选择合适的工具
3. 提供清晰、准确的回答
4. 当无法使用工具时，直接基于知识回答"""),

    HumanMessage(content="{input}"),

    MessagesPlaceholder(variable_name="agent_scratchpad")

])

# 创建 Agent
agent = create_openai_tools_agent(
    llm=llm,
    tools=tools,
    prompt=agent_prompt
)

# 创建 Agent 执行器
agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    verbose=True,
    max_iterations=5,
    return_intermediate_steps=True
)

# 使用 Agent
print("=== 基础 Agent 测试 ===")
result = agent_executor.invoke({
    "input": "计算 15 + 28 等于多少？"
})
print("最终答案:", result['output'])
​

步骤 2：动态 Agent 提示词生成

实现能够根据对话上下文动态生成提示词的 Agent：

from langchain.memory import ConversationBufferMemory

class DynamicAgent:
    """动态 Agent 类"""
    
    def __init__(self, tools: List[Tool], llm: ChatOpenAI):
        self.tools = tools
        self.llm = llm
        self.memory = ConversationBufferMemory(
            memory_key="chat_history",
            return_messages=True
        )
        
    def create_dynamic_prompt(self, user_input: str, role: str = "general") -> ChatPromptTemplate:
        """创建动态提示词"""
        
        system_content = f"""你是一个{role}，具备以下能力：
1. 使用工具回答用户问题
2. 根据问题选择合适的工具
3. 提供清晰、准确的回答

对话历史：
{self.memory.load_memory_variables()["chat_history"]}"""
        
        prompt = ChatPromptTemplate.from_messages([
            ("system", system_content),
            ("human", "{input}"),
            ("placeholder", "{agent_scratchpad}")

        ])
        
        return prompt
    
    def chat(self, message: str, role: str = "general") -> Dict[str, Any]:
        """聊天接口"""
        template = self.create_dynamic_prompt(message, role)
        
        agent = create_openai_tools_agent(
            llm=self.llm,
            tools=self.tools,
            prompt=template
        )
        
        executor = AgentExecutor(
            agent=agent,
            tools=self.tools,
            verbose=True,
            max_iterations=5,
            memory=self.memory,
            return_intermediate_steps=True
        )
        
        result = executor.invoke({
            "input": message
        })
        
        # 添加对话到记忆
        self.memory.chat_memory.add_user_message(message)
        self.memory.chat_memory.add_ai_message(result["output"])
        
        return result

# 使用动态 Agent
dynamic_agent = DynamicAgent(tools, llm)
result = dynamic_agent.chat("我需要计算 25 + 38", role="数据分析师")
print("回答：", result['output'])
​

步骤 3：个性化 Agent 提示词

实现能够根据用户特征个性化调整的 Agent 提示词：

from typing import Dict, Any

class PersonalizedAgent:
    """个性化 Agent 类"""
    
    def __init__(self, tools: List[Tool], llm: ChatOpenAI):
        self.tools = tools
        self.llm = llm
        self.user_profiles = {}
        
    def get_user_profile(self, user_id: str) -> Dict[str, Any]:
        """获取用户配置文件"""
        if user_id not in self.user_profiles:
            self.user_profiles[user_id] = {
                "role": "general",
                "experience": "intermediate",
                "preferences": {
                    "language": "chinese",
                    "detail_level": "medium",
                    "tone": "professional"
                }
            }
        return self.user_profiles[user_id]
    
    def generate_personalized_prompt(self, user_id: str, user_input: str) -> ChatPromptTemplate:
        """生成个性化提示词"""
        
        profile = self.get_user_profile(user_id)
        
        # 根据角色调整提示词
        role_prompts = {
            "developer": "你是一个技术专家，擅长用通俗易懂的方式解释复杂的技术概念。",
            "manager": "你是一个商业分析师，擅长从商业角度分析问题。",
            "analyst": "你是一个数据分析师，擅长从数据中发现洞察。",
            "general": "你是一个智能助手，能够根据用户需求提供多角度的回答。"
        }
        
        system_content = f"""{role_prompts.get(profile["role"], role_prompts["general"])}

回答要求：
{"请使用简单易懂的语言" if profile["experience"] == "beginner" else "请使用适当的专业术语" if profile["experience"] == "intermediate" else "请使用专业的术语"}

详细程度：
{"请提供详细全面的回答" if profile["preferences"]["detail_level"] == "high" else "请提供简洁明了的回答" if profile["preferences"]["detail_level"] == "low" else "请提供适中的详细程度"}"""
        
        prompt = ChatPromptTemplate.from_messages([
            ("system", system_content),
            ("human", "{input}"),
            ("placeholder", "{agent_scratchpad}")

        ])
        
        return prompt
​

步骤 4：高级 Agent 上下文管理

实现复杂的上下文管理和记忆系统：

from langchain.memory import (
    ConversationBufferMemory,
    ConversationSummaryMemory,
    ConversationBufferWindowMemory
)

class ContextAwareAgent:
    """上下文感知 Agent 类"""
    
    def __init__(self, tools: List[Tool], llm: ChatOpenAI):
        self.tools = tools
        self.llm = llm
        self.memories = {}
        
    def create_memory_system(self, user_id: str, memory_type: str = "buffer") -> ConversationBufferMemory:
        """创建记忆系统"""
        if user_id not in self.memories:
            if memory_type == "buffer":
                memory = ConversationBufferMemory(
                    memory_key="chat_history",
                    return_messages=True
                )
            elif memory_type == "summary":
                from langchain_openai import OpenAI
                summary_llm = OpenAI(temperature=0)
                memory = ConversationSummaryMemory(
                    llm=summary_llm,
                    memory_key="chat_history",
                    return_messages=True
                )
            elif memory_type == "window":
                memory = ConversationBufferWindowMemory(
                    memory_key="chat_history",
                    return_messages=True,
                    k=5
                )
            self.memories[user_id] = memory
        
        return self.memories[user_id]
    
    def process_with_context(self, user_id: str, message: str, memory_type: str = "buffer") -> Dict[str, Any]:
        """处理消息，考虑上下文"""
        memory = self.create_memory_system(user_id, memory_type)
        
        prompt = ChatPromptTemplate.from_messages([
            ("system", "你是一个智能助手，具备以下能力：1. 使用工具回答用户问题 2. 根据问题选择合适的工具 3. 提供清晰、准确的回答"),
            ("human", "{input}"),
            ("placeholder", "{agent_scratchpad}")

        ])
        
        agent = create_openai_tools_agent(
            llm=self.llm,
            tools=self.tools,
            prompt=prompt
        )
        
        executor = AgentExecutor(
            agent=agent,
            tools=self.tools,
            verbose=True,
            max_iterations=5,
            memory=memory,
            return_intermediate_steps=True
        )
        
        result = executor.invoke({
            "input": message
        })
        
        # 添加到记忆
        memory.chat_memory.add_user_message(message)
        memory.chat_memory.add_ai_message(result["output"])
        
        return result

# 使用上下文感知 Agent
context_agent = ContextAwareAgent(tools, llm)
result = context_agent.process_with_context("user1", "你好，我想了解AI的发展趋势", "summary")
print("回答：", result['output'])
​

完整示例

完整的多功能 Agent 系统

from typing import Dict, List, Any

class MultiFunctionAgent:
    """多功能 Agent 系统"""
    
    def __init__(self):
        self.tools = []
        self.llm = None
        self.agents = {}
        
    def initialize_with_openai(self, api_key: str):
        """使用 OpenAI 初始化"""
        from langchain_openai import ChatOpenAI
        self.llm = ChatOpenAI(
            model="gpt-4-turbo",
            temperature=0.7,
            api_key=api_key
        )
        self.create_base_tools()
        
    def create_base_tools(self):
        """创建基础工具"""
        # 计算器工具
        calculator = Tool(
            name="calculator",
            description="用于数学计算的工具",
            func=self.safe_calculator
        )
        
        # 时间工具
        time_info = Tool(
            name="time_info",
            description="获取当前时间信息",
            func=self.get_current_time
        )
        
        self.tools = [calculator, time_info]
        
    def safe_calculator(self, query: str) -> str:
        """安全的计算器"""
        try:
            import re
            numbers = re.findall(r'\d+', query)
            operators = re.findall(r'[+\-*/]', query)
            
            if len(numbers) >= 2 and len(operators) >= 1:
                num1, num2 = map(int, numbers[:2])
                op = operators[0]
                
                if op == '+':
                    result = num1 + num2
                elif op == '-':
                    result = num1 - num2
                elif op == '*':
                    result = num1 * num2
                elif op == '/':
                    if num2 != 0:
                        result = num1 / num2
                    else:
                        return "错误：除数不能为零"
                
                return f"计算结果: {result}"
            else:
                return "请提供有效的计算表达式"
        except Exception as e:
            return f"计算错误: {str(e)}"
    
    def get_current_time(self) -> str:
        """获取当前时间"""
        from datetime import datetime
        now = datetime.now()
        return f"当前时间：{now.strftime('%Y-%m-%d %H:%M:%S')} {now.strftime('%A')}"
    
    def process_message(self, user_id: str, message: str, agent_type: str = "assistant") -> Dict[str, Any]:
        """处理用户消息"""
        from langchain.agents import create_openai_tools_agent
        from langchain.prompts import ChatPromptTemplate
        
        # 创建 Agent 提示词
        prompt = ChatPromptTemplate.from_messages([
            ("system", f"你是一个{agent_type}，请使用适当的工具来回答用户的问题。"),
            ("human", "{input}"),
            ("placeholder", "{agent_scratchpad}")

        ])
        
        # 创建 Agent
        agent = create_openai_tools_agent(
            llm=self.llm,
            tools=self.tools,
            prompt=prompt
        )
        
        # 创建执行器
        from langchain.agents import AgentExecutor
        from langchain.memory import ConversationBufferMemory
        
        memory = ConversationBufferMemory(
            memory_key="chat_history",
            return_messages=True
        )
        
        executor = AgentExecutor(
            agent=agent,
            tools=self.tools,
            verbose=True,
            max_iterations=5,
            memory=memory,
            return_intermediate_steps=True
        )
        
        # 执行 Agent
        result = executor.invoke({
            "input": message
        })
        
        # 存储 Agent
        self.agents[user_id] = {
            "executor": executor,
            "type": agent_type,
            "memory": memory
        }
        
        return result
​

常见问题 FAQ

Q1：Agent 提示词和普通 LLM 提示词有什么区别？

A：Agent 提示词需要包含工具调用规则、连续决策逻辑、上下文管理等内容，而普通 LLM 提示词通常是静态的、单次回答的。Agent 提示词更复杂，需要动态调整和多轮对话支持。

Q2：如何选择合适的记忆管理策略？

A：根据对话长度选择：短对话用 BufferMemory，长对话用 SummaryMemory；根据语义需求选择：需要精确上下文用 BufferMemory，需要语义检索用 VectorStoreRetrieverMemory。

Q3：如何优化 Agent 提示词性能？

A：预编译常用提示词、缓存格式化结果、避免重复创建相同模板、使用异步处理、优化工具选择逻辑。

最佳实践与避坑

最佳实践

1. 模块化设计：将提示词设计成可复用的模块
2. 参数化配置：使用参数化的提示词模板
3. 版本控制：为重要提示词建立版本管理
4. 性能监控：监控 Agent 执行时间和成功率
5. 用户反馈：收集用户反馈持续优化提示词

常见陷阱

1. 提示词过长：导致 token 消耗过多，影响性能
2. 工具调用混乱：缺乏明确的工具调用规则
3. 上下文管理不当：导致记忆泄漏或信息丢失
4. 缺乏错误处理：Agent 在异常情况下容易崩溃
5. 过度依赖单一工具：缺乏灵活性和适应性

本节小结

本节详细介绍了 LangChain Agent 提示词和上下文管理的核心概念和实现方法，包括：

• Agent 提示词原理：理解 Agent 提示词的特殊性和设计原则
• 动态提示词生成：实现能够根据上下文动态调整的提示词系统
• 个性化配置：根据用户特征定制 Agent 的行为和响应风格
• 高级上下文管理：实现复杂的记忆系统和上下文感知能力
• 完整实践：从基础配置到多功能 Agent 系统的完整实现

掌握 Agent 提示词和上下文管理是构建智能 Agent 的关键基础。在下一节中，我们将继续学习结构化输出与输出解析，进一步提升 Agent 的输出质量和可操作性。

延伸阅读

• 官方文档：LangChain Agent 模块文档
• 相关章节：本教程 2.4 节结构化输出与输出解析
• 推荐资源：《智能 Agent 设计与实现》
• 开源项目：LangChain Agent 示例库
• 技术博客：Agent 提示词优化指南

关键词：Agent提示词,LangChain,上下文管理,动态提示词,个性化Agent,记忆管理,提示词工程,Agent架构,教程,实战
难度：进阶
预计阅读：40分钟