AI Agent 开发实战教程（二）：Prompt 工程与工具调用

目录

• [1. LangChain PromptTemplate 进阶](#1. LangChain PromptTemplate 进阶)
• [2. OutputParser：结构化输出](#2. OutputParser：结构化输出)
• [3. LangChain Tools：定义工具](#3. LangChain Tools：定义工具)
• [4. LangChain Agent：工具调用 Agent](#4. LangChain Agent：工具调用 Agent)
• [5. 构建 ReAct Agent](#5. 构建 ReAct Agent)
• [6. 小结与下一步](#6. 小结与下一步)

---

1. LangChain PromptTemplate 进阶

1.1 PromptTemplate 核心概念

PromptTemplate 体系
PromptTemplate

基础模板
ChatPromptTemplate

对话模板
MessagesPlaceholder

消息占位符
FewShotPromptTemplate

少样本模板

1.2 ChatPromptTemplate 详解

"""
prompts/chat_prompts.py - ChatPromptTemplate 高级用法
"""
from langchain_core.prompts import (
    ChatPromptTemplate,
    PromptTemplate,
    MessagesPlaceholder,
    HumanMessagePromptTemplate,
    SystemMessagePromptTemplate,
)
from langchain_core.messages import HumanMessage, AIMessage, SystemMessage


# ========================
# 1. 基础用法：from_template
# ========================

def basic_prompt():
    """最简单的 Prompt 模板"""
    prompt = ChatPromptTemplate.from_template("给我讲一个关于{topic}的笑话")
    # 变量：{topic}
    
    # 格式化
    messages = prompt.format_messages(topic="程序员")
    print(messages)  # [HumanMessage(content='给我讲一个关于程序员的笑话')]


# ========================
# 2. 多角色对话：from_messages
# ========================

def multi_role_prompt():
    """定义多角色对话模板"""
    prompt = ChatPromptTemplate.from_messages([
        # 系统消息：设定角色和行为
        ("system", "你是一个专业的{role}，擅长{skill}。"),
        # 历史消息占位符
        MessagesPlaceholder(variable_name="history"),
        # 用户消息
        ("human", "{question}"),
    ])
    
    # 格式化
    history = [
        HumanMessage(content="你好"),
        AIMessage(content="你好！有什么可以帮你的？"),
    ]
    
    messages = prompt.format_messages(
        role="Python 工程师",
        skill="代码优化和调试",
        history=history,
        question="如何优化列表推导式？",
    )
    
    for msg in messages:
        print(f"[{msg.type}]: {msg.content}")


# ========================
# 3. Few-shot 示例
# ========================

def few_shot_prompt():
    """Few-shot 学习：提供示例帮助模型理解任务"""
    
    # 定义示例
    examples = [
        {"input": "开心", "output": "😊 开心是一种积极的情绪"},
        {"input": "难过", "output": "😢 难过是一种消极的情绪"},
        {"input": "愤怒", "output": "😠 愤怒是一种强烈的负面情绪"},
    ]
    
    # 定义示例模板
    example_prompt = ChatPromptTemplate.from_messages([
        ("human", "{input}"),
        ("ai", "{output}"),
    ])
    
    # 构建 Few-shot Prompt
    from langchain_core.prompts import FewShotChatMessagePromptTemplate
    
    few_shot_prompt = FewShotChatMessagePromptTemplate(
        example_prompt=example_prompt,
        examples=examples,
    )
    
    # 组合成完整 Prompt
    final_prompt = ChatPromptTemplate.from_messages([
        ("system", "你是一个情绪分析助手，分析用户输入的情绪。"),
        few_shot_prompt,
        ("human", "{input}"),
    ])
    
    messages = final_prompt.format_messages(input="焦虑")
    for msg in messages:
        print(f"[{msg.type}]: {msg.content}")


# ========================
# 4. 条件 Prompt
# ========================

def conditional_prompt():
    """根据条件选择不同的 Prompt"""
    
    # 定义两种不同的系统提示
    technical_prompt = ChatPromptTemplate.from_messages([
        ("system", "你是技术专家，用专业术语详细解释。"),
        ("human", "{question}"),
    ])
    
    simple_prompt = ChatPromptTemplate.from_messages([
        ("system", "你是友好的助手，用简单的语言解释。"),
        ("human", "{question}"),
    ])
    
    # 使用 RunnableBranch 根据条件选择
    from langchain_core.runnables import RunnableBranch
    
    branch = RunnableBranch(
        # 如果 level == "technical"，使用技术版
        (lambda x: x.get("level") == "technical", technical_prompt),
        # 默认使用简单版
        simple_prompt,
    )
    
    # 测试
    tech_result = branch.invoke({"level": "technical", "question": "什么是闭包？"})
    simple_result = branch.invoke({"level": "simple", "question": "什么是闭包？"})
    
    print("技术版:", tech_result)
    print("简单版:", simple_result)


# ========================
# 5. Pipeline Prompt（组合多个模板）
# ========================

def pipeline_prompt():
    """将多个 Prompt 组合成一个"""
    
    # 子模板
    intro = PromptTemplate.from_template("你是一个{role}。")
    context = PromptTemplate.from_template("背景信息：{context}")
    question = PromptTemplate.from_template("问题：{question}")
    
    # 组合
    full_prompt = (
        "请根据以下信息回答问题：\n\n"
        "{intro}\n\n"
        "{context}\n\n"
        "{question}"
    )
    
    # 使用 ChatPromptTemplate
    chat_prompt = ChatPromptTemplate.from_template(full_prompt)
    
    messages = chat_prompt.format_messages(
        role="数据分析师",
        context="公司2024年Q4销售额为1000万元",
        question="分析销售趋势",
    )
    
    print(messages[0].content)


# === 运行示例 ===
if __name__ == "__main__":
    print("=" * 60)
    print("1. 基础用法")
    print("=" * 60)
    basic_prompt()
    
    print("\n" + "=" * 60)
    print("2. 多角色对话")
    print("=" * 60)
    multi_role_prompt()
    
    print("\n" + "=" * 60)
    print("3. Few-shot 示例")
    print("=" * 60)
    few_shot_prompt()

1.3 Prompt 模板最佳实践

Prompt 设计原则
角色设定

Persona
任务描述

Task
输出格式

Format
示例

Examples
约束条件

Constraints

原则	说明	示例
角色设定	明确 AI 的身份和专业领域	"你是一个有10年经验的Python工程师"
任务描述	清晰说明要做什么	"请分析以下代码的性能瓶颈"
输出格式	指定输出的结构和格式	"以JSON格式返回，包含字段：..."
示例	提供输入输出示例	Few-shot learning
约束条件	明确限制和边界	"不要编造信息，只基于提供的数据回答"

---

2. OutputParser：结构化输出

2.1 为什么需要 OutputParser

LLM 输出

自由文本
OutputParser
结构化数据

JSON/Pydantic

2.2 常用 OutputParser

"""
parsers/output_parsers.py - LangChain OutputParser 使用
"""
from langchain_core.output_parsers import (
    StrOutputParser,
    JsonOutputParser,
    CommaSeparatedListOutputParser,
)
from langchain_core.prompts import ChatPromptTemplate
from pydantic import BaseModel, Field
from models import get_chat_model


# ========================
# 1. StrOutputParser：最简单
# ========================

def str_parser_example():
    """字符串输出解析器"""
    model = get_chat_model("deepseek")
    prompt = ChatPromptTemplate.from_template("讲一个关于{topic}的笑话")
    
    chain = prompt | model | StrOutputParser()
    
    result = chain.invoke({"topic": "程序员"})
    print(f"类型: {type(result)}")  # <class 'str'>
    print(f"内容: {result}")


# ========================
# 2. JsonOutputParser：JSON 输出
# ========================

def json_parser_example():
    """JSON 输出解析器"""
    
    # 定义输出结构（使用 Pydantic）
    class PersonInfo(BaseModel):
        name: str = Field(description="人物姓名")
        age: int = Field(description="人物年龄")
        occupation: str = Field(description="职业")
        skills: list[str] = Field(description="技能列表")
    
    parser = JsonOutputParser(pydantic_object=PersonInfo)
    
    prompt = ChatPromptTemplate.from_messages([
        ("system", "你是一个信息提取助手。请根据用户描述提取人物信息。\n{format_instructions}"),
        ("human", "{text}"),
    ])
    
    model = get_chat_model("deepseek", temperature=0)
    
    chain = prompt | model | parser
    
    result = chain.invoke({
        "text": "张三今年28岁，是一名Python工程师，擅长Django和FastAPI开发。",
        "format_instructions": parser.get_format_instructions(),
    })
    
    print(f"类型: {type(result)}")  # <class 'dict'>
    print(f"内容: {result}")
    # {'name': '张三', 'age': 28, 'occupation': 'Python工程师', 'skills': ['Django', 'FastAPI']}


# ========================
# 3. CommaSeparatedListOutputParser：列表输出
# ========================

def list_parser_example():
    """逗号分隔列表解析器"""
    
    parser = CommaSeparatedListOutputParser()
    
    prompt = ChatPromptTemplate.from_messages([
        ("system", "你是一个助手。请列出用户要求的内容。\n{format_instructions}"),
        ("human", "列出5种流行的编程语言"),
    ])
    
    model = get_chat_model("deepseek", temperature=0)
    
    chain = prompt | model | parser
    
    result = chain.invoke({
        "format_instructions": parser.get_format_instructions(),
    })
    
    print(f"类型: {type(result)}")  # <class 'list'>
    print(f"内容: {result}")
    # ['Python', 'JavaScript', 'Java', 'Go', 'Rust']


# ========================
# 4. PydanticOutputParser：强类型输出
# ========================

from langchain_core.output_parsers import PydanticOutputParser

def pydantic_parser_example():
    """Pydantic 强类型输出"""
    
    class AnalysisResult(BaseModel):
        """分析结果"""
        sentiment: str = Field(description="情感倾向：positive/negative/neutral")
        confidence: float = Field(description="置信度 0-1")
        keywords: list[str] = Field(description="关键词列表")
        summary: str = Field(description="一句话摘要")
    
    parser = PydanticOutputParser(pydantic_object=AnalysisResult)
    
    prompt = ChatPromptTemplate.from_messages([
        ("system", "你是一个文本分析助手。\n{format_instructions}"),
        ("human", "分析以下文本：{text}"),
    ])
    
    model = get_chat_model("deepseek", temperature=0)
    
    chain = prompt | model | parser
    
    result = chain.invoke({
        "text": "这款手机真的很棒！拍照效果超乎预期，电池续航也很给力。唯一的小缺点是价格稍贵。",
        "format_instructions": parser.get_format_instructions(),
    })
    
    print(f"类型: {type(result)}")  # <class 'AnalysisResult'>
    print(f"情感: {result.sentiment}")
    print(f"置信度: {result.confidence}")
    print(f"关键词: {result.keywords}")
    print(f"摘要: {result.summary}")


# === 运行示例 ===
if __name__ == "__main__":
    print("=" * 60)
    print("1. StrOutputParser")
    print("=" * 60)
    str_parser_example()
    
    print("\n" + "=" * 60)
    print("2. JsonOutputParser")
    print("=" * 60)
    json_parser_example()
    
    print("\n" + "=" * 60)
    print("3. CommaSeparatedListOutputParser")
    print("=" * 60)
    list_parser_example()
    
    print("\n" + "=" * 60)
    print("4. PydanticOutputParser")
    print("=" * 60)
    pydantic_parser_example()

---

3. LangChain Tools：定义工具

3.1 Tool 的核心概念

LangChain Tool 体系
BaseTool

工具基类
StructuredTool

结构化工具
tool 装饰器

函数式定义

3.2 定义工具的三种方式

"""
tools/basic_tools.py - LangChain 工具定义
"""
import json
from langchain_core.tools import tool, StructuredTool
from pydantic import BaseModel, Field


# ========================
# 方式一：@tool 装饰器（推荐）
# ========================

@tool
def get_weather(city: str) -> str:
    """
    查询指定城市的天气信息
    
    Args:
        city: 城市名称，如：北京、上海
    
    Returns:
        天气信息的JSON字符串
    """
    # 模拟天气数据
    weather_data = {
        "北京": {"weather": "晴", "temp": 25, "humidity": 40},
        "上海": {"weather": "多云", "temp": 28, "humidity": 65},
        "深圳": {"weather": "阵雨", "temp": 30, "humidity": 80},
    }
    
    data = weather_data.get(city, {"weather": "未知", "temp": "N/A"})
    return json.dumps(data, ensure_ascii=False)


@tool
def calculate(expression: str) -> str:
    """
    计算数学表达式
    
    Args:
        expression: 数学表达式，如 '2 + 3 * 4'
    
    Returns:
        计算结果
    """
    import re
    # 安全检查
    if not re.match(r'^[\d+\-*/().%\s]+$', expression):
        return "错误：不支持的表达式"
    
    try:
        result = eval(expression)
        return f"{expression} = {result}"
    except Exception as e:
        return f"计算错误: {e}"


@tool
def search_knowledge(query: str, category: str = "general") -> str:
    """
    搜索知识库
    
    Args:
        query: 搜索关键词
        category: 搜索类别（可选），如：产品、政策、FAQ
    
    Returns:
        搜索结果
    """
    # 模拟知识库
    knowledge = {
        "退货": "购买后30天内可无理由退货，需保持商品完好。",
        "保修": "所有电子产品享受一年官方保修。",
        "配送": "默认顺丰快递，一线城市次日达。",
    }
    
    for key, value in knowledge.items():
        if key in query:
            return value
    
    return f"未找到与'{query}'相关的信息。"


# ========================
# 方式二：StructuredTool（更多控制）
# ========================

class SearchInput(BaseModel):
    """搜索工具输入"""
    query: str = Field(description="搜索关键词")
    max_results: int = Field(default=5, description="最大返回结果数")


def search_web(query: str, max_results: int = 5) -> str:
    """搜索互联网"""
    # 模拟搜索结果
    return f"找到 {max_results} 条关于'{query}'的结果"


search_tool = StructuredTool.from_function(
    func=search_web,
    name="web_search",
    description="搜索互联网获取最新信息",
    args_schema=SearchInput,
)


# ========================
# 方式三：继承 BaseTool（完全自定义）
# ========================

from langchain_core.tools import BaseTool
from typing import Optional, Type


class CalculatorTool(BaseTool):
    """计算器工具"""
    
    name: str = "calculator"
    description: str = "计算数学表达式，支持加减乘除和括号"
    args_schema: Type[BaseModel] = SearchInput  # 复用
    
    def _run(self, query: str, max_results: int = 5) -> str:
        """同步执行"""
        return calculate.invoke({"expression": query})
    
    async def _arun(self, query: str, max_results: int = 5) -> str:
        """异步执行"""
        return self._run(query, max_results)


# ========================
# 工具列表
# ========================

# 获取所有工具
all_tools = [get_weather, calculate, search_knowledge, search_tool]

# 打印工具信息
def print_tool_info():
    for t in all_tools:
        print(f"工具名: {t.name}")
        print(f"描述: {t.description}")
        print(f"参数: {t.args}")
        print("-" * 40)


if __name__ == "__main__":
    print_tool_info()
    
    # 测试工具调用
    print("\n=== 测试工具 ===")
    result = get_weather.invoke({"city": "北京"})
    print(f"天气: {result}")
    
    result = calculate.invoke({"expression": "123 * 456"})
    print(f"计算: {result}")

3.3 工具调用流程

Tool LLM Agent 用户 Tool LLM Agent 用户 提问 发送消息 + 工具列表 返回工具调用请求 执行工具 返回结果 发送工具结果 返回最终回答 返回结果

---

4. LangChain Agent：工具调用 Agent

4.1 Agent 类型对比

LangChain Agent 类型
OpenAI Tools Agent

推荐，Function Calling
ReAct Agent

推理+行动
Structured Chat Agent

多输入工具
支持国产模型

OpenAI兼容接口
通用性强

需要Prompt
复杂参数

结构化输入

Agent 类型	特点	适用场景
OpenAI Tools Agent	使用 Function Calling，最稳定	推荐，支持国产模型
ReAct Agent	基于 Prompt，通用性强	不支持 Function Calling 的模型
Structured Chat Agent	支持复杂结构化输入	需要多参数工具

4.2 构建 OpenAI Tools Agent

"""
agents/tools_agent.py - 使用 LangChain 构建工具调用 Agent
"""
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain.agents import create_tool_calling_agent, AgentExecutor
from langchain.agents.openai_tools.base import create_openai_tools_agent
from tools.basic_tools import get_weather, calculate, search_knowledge


# ========================
# 1. 创建工具调用 Agent
# ========================

def create_tools_agent():
    """创建支持 Function Calling 的 Agent"""
    
    # 定义工具列表
    tools = [get_weather, calculate, search_knowledge]
    
    # 获取模型
    from models import get_chat_model
    llm = get_chat_model("deepseek", temperature=0)
    
    # 定义 Prompt
    prompt = ChatPromptTemplate.from_messages([
        ("system", "你是一个智能助手，可以使用工具来帮助用户解决问题。"),
        MessagesPlaceholder(variable_name="chat_history"),
        ("human", "{input}"),
        MessagesPlaceholder(variable_name="agent_scratchpad"),  # Agent 思考过程
    ])
    
    # 创建 Agent
    agent = create_tool_calling_agent(llm, tools, prompt)
    
    # 创建 AgentExecutor
    agent_executor = AgentExecutor(
        agent=agent,
        tools=tools,
        verbose=True,  # 打印思考过程
        handle_parsing_errors=True,  # 处理解析错误
        max_iterations=5,  # 最大迭代次数
    )
    
    return agent_executor


# ========================
# 2. 使用 Agent
# ========================

def run_agent():
    """运行 Agent"""
    agent = create_tools_agent()
    
    # 测试 1：天气查询
    print("=" * 60)
    print("测试 1：天气查询")
    print("=" * 60)
    result = agent.invoke({
        "input": "北京今天天气怎么样？",
        "chat_history": [],
    })
    print(f"结果: {result['output']}")
    
    # 测试 2：计算
    print("\n" + "=" * 60)
    print("测试 2：计算")
    print("=" * 60)
    result = agent.invoke({
        "input": "帮我算一下 123 * 456 等于多少",
        "chat_history": [],
    })
    print(f"结果: {result['output']}")
    
    # 测试 3：多工具调用
    print("\n" + "=" * 60)
    print("测试 3：多工具调用")
    print("=" * 60)
    result = agent.invoke({
        "input": "北京和上海哪个城市温度更高？差多少度？",
        "chat_history": [],
    })
    print(f"结果: {result['output']}")


# ========================
# 3. 带对话历史的 Agent
# ========================

from langchain.memory import ConversationBufferMemory
from langchain.agents.openai_tools.base import create_openai_tools_agent


def create_agent_with_memory():
    """创建带记忆的 Agent"""
    
    tools = [get_weather, calculate, search_knowledge]
    
    from models import get_chat_model
    llm = get_chat_model("deepseek", temperature=0)
    
    prompt = ChatPromptTemplate.from_messages([
        ("system", "你是一个智能助手。"),
        MessagesPlaceholder(variable_name="chat_history"),
        ("human", "{input}"),
        MessagesPlaceholder(variable_name="agent_scratchpad"),
    ])
    
    agent = create_tool_calling_agent(llm, tools, prompt)
    
    # 创建记忆组件
    memory = ConversationBufferMemory(
        memory_key="chat_history",
        return_messages=True,
    )
    
    agent_executor = AgentExecutor(
        agent=agent,
        tools=tools,
        memory=memory,
        verbose=True,
    )
    
    return agent_executor, memory


def run_agent_with_memory():
    """运行带记忆的 Agent"""
    agent, memory = create_agent_with_memory()
    
    # 第一轮对话
    print("=== 第一轮 ===")
    result = agent.invoke({"input": "我叫张三"})
    print(f"结果: {result['output']}")
    
    # 第二轮对话（测试记忆）
    print("\n=== 第二轮 ===")
    result = agent.invoke({"input": "我叫什么名字？"})
    print(f"结果: {result['output']}")


# === 运行示例 ===
if __name__ == "__main__":
    run_agent()
    # run_agent_with_memory()

---

5. 构建 ReAct Agent

5.1 ReAct 工作流程

是
否
是
否
用户输入
Thought 思考
需要工具?
Action 选择工具
执行工具
Observation 观察结果
任务完成?
Final Answer 最终回答

5.2 完整 ReAct Agent 实现

"""
agents/react_agent.py - 完整的 ReAct Agent 实现
"""
from typing import TypedDict, Annotated, List
from langchain_core.messages import HumanMessage, AIMessage, BaseMessage
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.tools import tool
from langchain.agents import create_tool_calling_agent, AgentExecutor
from models import get_chat_model
import json


# ========================
# 1. 定义工具
# ========================

@tool
def get_weather(city: str) -> str:
    """查询城市天气"""
    weather_data = {
        "北京": {"weather": "晴", "temp": 25, "humidity": 40},
        "上海": {"weather": "多云", "temp": 28, "humidity": 65},
        "深圳": {"weather": "阵雨", "temp": 30, "humidity": 80},
    }
    data = weather_data.get(city, {"weather": "未知", "temp": "N/A"})
    return json.dumps(data, ensure_ascii=False)


@tool
def calculate(expression: str) -> str:
    """计算数学表达式"""
    import re
    if not re.match(r'^[\d+\-*/().%\s]+$', expression):
        return "错误：不支持的表达式"
    try:
        return str(eval(expression))
    except Exception as e:
        return f"计算错误: {e}"


@tool
def search_knowledge(query: str) -> str:
    """搜索知识库"""
    knowledge = {
        "退货": "购买后30天内可无理由退货，需保持商品完好。",
        "保修": "所有电子产品享受一年官方保修。",
        "配送": "默认顺丰快递，一线城市次日达。",
    }
    for key, value in knowledge.items():
        if key in query:
            return value
    return f"未找到与'{query}'相关的信息。"


@tool
def query_order(order_id: str) -> str:
    """查询订单状态"""
    orders = {
        "ORD-001": {"status": "已发货", "logistics": "顺丰 SF123456"},
        "ORD-002": {"status": "待发货", "logistics": "待分配"},
        "ORD-003": {"status": "已完成", "logistics": "已签收"},
    }
    order = orders.get(order_id)
    if order:
        return json.dumps(order, ensure_ascii=False)
    return f"未找到订单 {order_id}"


# ========================
# 2. 创建 ReAct Agent
# ========================

def create_react_agent():
    """创建 ReAct Agent"""
    
    tools = [get_weather, calculate, search_knowledge, query_order]
    
    llm = get_chat_model("deepseek", temperature=0)
    
    # ReAct Prompt
    prompt = ChatPromptTemplate.from_messages([
        ("system", """你是一个智能 AI Agent，能够通过调用工具来解决用户的问题。

## 工作方式
你遵循 ReAct（Reasoning + Acting）模式：
1. **Thought（思考）**：分析用户问题，决定下一步行动
2. **Action（行动）**：调用合适的工具
3. **Observation（观察）**：分析工具返回的结果
4. 重复以上步骤，直到能够给出最终答案

## 可用工具
{tool_names}

## 规则
- 每次只调用一个工具
- 仔细分析工具返回的结果
- 如果工具返回错误，尝试调整参数或换一个工具
- 如果无法解决问题，诚实地告知用户
- 用中文回答用户的问题"""),
        MessagesPlaceholder(variable_name="chat_history"),
        ("human", "{input}"),
        MessagesPlaceholder(variable_name="agent_scratchpad"),
    ])
    
    agent = create_tool_calling_agent(llm, tools, prompt)
    
    agent_executor = AgentExecutor(
        agent=agent,
        tools=tools,
        verbose=True,
        handle_parsing_errors=True,
        max_iterations=10,
    )
    
    return agent_executor


# ========================
# 3. 交互式对话
# ========================

def interactive_chat():
    """交互式对话"""
    agent = create_react_agent()
    chat_history = []
    
    print("=" * 60)
    print("ReAct Agent 交互模式")
    print("输入 'quit' 退出，输入 'clear' 清空历史")
    print("=" * 60)
    
    while True:
        user_input = input("\n👤 你: ").strip()
        
        if not user_input:
            continue
        if user_input.lower() in ("quit", "exit", "q"):
            break
        if user_input.lower() == "clear":
            chat_history = []
            print("历史已清空")
            continue
        
        try:
            result = agent.invoke({
                "input": user_input,
                "chat_history": chat_history,
            })
            
            print(f"\n🤖 Agent: {result['output']}")
            
            # 更新历史
            chat_history.append(HumanMessage(content=user_input))
            chat_history.append(AIMessage(content=result['output']))
            
        except Exception as e:
            print(f"❌ 错误: {e}")


# ========================
# 4. 演示模式
# ========================

def demo():
    """演示模式"""
    agent = create_react_agent()
    
    questions = [
        "北京今天天气怎么样？",
        "帮我算一下 123 * 456",
        "退货政策是什么？",
        "查询订单 ORD-001 的状态",
        "北京和上海哪个城市温度更高？差多少？",
    ]
    
    for q in questions:
        print(f"\n{'='*60}")
        print(f"问题: {q}")
        print("=" * 60)
        
        result = agent.invoke({
            "input": q,
            "chat_history": [],
        })
        print(f"回答: {result['output']}")


if __name__ == "__main__":
    # demo()
    interactive_chat()

5.3 Agent 执行流程图

Tools LLM Agent AgentExecutor 用户 Tools LLM Agent AgentExecutor 用户 alt [需要调用工具] [直接回答] loop [直到完成或超时] 输入问题 调用 Agent 发送消息 + 工具列表 返回工具调用或最终回答 执行工具 返回结果 返回 AgentAction 继续执行 返回 Final Answer 返回结果

---

6. 小结与下一步

6.1 本篇回顾

本篇核心内容
PromptTemplate

Prompt 模板
OutputParser

结构化输出
Tools

工具定义
Agent

工具调用 Agent

知识点	掌握程度
ChatPromptTemplate 多角色对话	✅
Few-shot Prompt 学习	✅
JsonOutputParser / PydanticOutputParser	✅
@tool 装饰器定义工具	✅
create_tool_calling_agent	✅
AgentExecutor 执行器	✅
ReAct Agent 完整实现	✅

6.2 关键收获

1. PromptTemplate 让 Prompt 管理变得结构化和可复用
2. OutputParser 让 LLM 输出变得可预测、可解析
3. @tool 装饰器 让工具定义变得极其简单
4. AgentExecutor 自动管理 Agent 的执行循环

6.3 下一篇预告

第三篇：记忆与数据库集成 将深入讲解：

• LangChain Memory 组件
• ConversationBufferMemory / ConversationSummaryMemory
• 向量数据库集成（ChromaDB）
• 构建长期记忆系统