01.Agent（智能体）

• 在企业应用中的典型用法（以知识库问答为例）

步骤	执行组件	说明
用户提问	输入
意图理解	LLM	理解这是一个涉及公司、RAG、行业场景的问题
工具选择	LLM → Agent	判断需要调用 search_docs 或 query_knowledgebase 工具
工具调用	RAG Tool（Retrieval）	检索企业内金融行业相关案例、文档等
结果整合	LLM	将用户问题和检索结果结合，生成带上下文的回答
最终响应	Agent 输出	一次完成带文档依据的企业问答

1、Agent概述

• Agent执行流程

 用户输入问题
     ▼
┌─────────────┐
│1.Prompt 模板 │    任务规划的“剧本”, 告诉 LLM “你是谁、你要做什么、你怎么做”
└────┬────────┘    例：你是一个客服角色，给咨询商品用户讲解商品                          
     ▼      
┌─────────────┐               
│2.LLM 调用    │    解析问题，识别任务→ 思考、决定调用哪个工具  
└────┬────────┘    Prompt 模板中list了说有工具，并在 Tool docstring 描述                                        
     ▼                                       
┌─────────────┐                             
│3.Tools 工具  │ ←──调用工具（根据 LLM 指令）       
└────┬────────┘      真正执行任务，如调用接口、查数据库
     │               由 LLM 决定要调用哪个工具，传什么参数
     │               会作为 Observation 回传给 LLM
     ▼             RAG也是 可调用的检索工具 被集成到 Agent                     
┌─────────────┐                               
│ 4.Memory    │ ←────记录工具返回结果 + 思考链条    
└────┬────────┘                             
     ▼                                         
┌─────────────┐               任务规划策略，解析 LLM 意图并 orchestrate 工具调用过程，是智能体核心                 
│ 5. Agent    │ ←── 负责 orchestrate 执行链逻辑、处理结果等→
└────┬────────┘       1.拿用户输入传给 LLM
     │                2.从 LLM 输出中提取 Action、Input
     │                3.调用对应工具 Tools
     │                4.把 Observation 回传给 LLM，继续推理
     │                5.直到返回 Final Answer
     ▼             中大型业务，通常需要定制 Agent（任务规划策略）
     
┌────────────────┐   
│6.AgentExecutor │ ←─ 最外层协调器，循环调用 Agent，直到完成任务
└────────────────┘   中大型业务，通常需要定制 AgentExecutor（执行调度策略）
     │
     ▼
✅ 最终结果返回给用户

• Agent各层说明

2、天气预报查询Agent

from langchain_openai import ChatOpenAI
from langchain.agents import tool, AgentExecutor
from langchain.agents import create_react_agent
from langchain_core.prompts import ChatPromptTemplate

# 1. 定义工具（Agent可调用的功能）
@tool
def get_weather(city: str) -> str:
    """查询指定城市的实时天气"""
    weather_data = {
        "北京": "晴，25°C",
        "上海": "多云，28°C",
        "广州": "雷阵雨，30°C",
        city: "晴，-1°C",  # 蔚来简化匹配，这里直接匹配上
    }
    return weather_data.get(city, "未知城市")

# 2. 初始化DeepSeek模型
agent_llm = ChatOpenAI(
    base_url="https://api.deepseek.com/v1",
    api_key="sk-xxx",  # 替换为实际Key
    model="deepseek-chat"
)

# 3. 使用LangChain内置的React提示模板（避免手动写模板）
from langchain import hub
prompt = hub.pull("hwchase17/react")  # 官方标准模板

# 4. 创建Agent
tools = [get_weather]
agent = create_react_agent(agent_llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# 5. 运行Agent
response = agent_executor.invoke({
    "input": "上海今天适合穿短袖吗？"
})
print(response["output"])  
# 上海今天天气晴朗，气温高达35°C，非常适合穿短袖，但要注意防晒和补水
# 上海今天气温为-1°C，天气寒冷，不适合穿短袖，建议穿厚外套或羽绒服保暖

02.Agent 架构

• LangChain Agent 组件本质上是一种 **多步决策系统（Multi-step Reasoning Agent）
• 通过以下关键要素实现智能行为

组件	作用说明
LLM	大语言模型，负责根据提示（Prompt）生成下一步思路和行动
Prompt 模板	提示词模板，用于引导模型执行推理和决策
Tools（工具）	可调用的函数或接口，用于执行 Agent 决策中的“动作”
Agent	核心逻辑，协调 LLM、Prompt、Tools 的使用，实现“观察-思考-行动”
Memory（记忆）	保存历史对话，支持上下文推理与长期记忆
AgentExecutor	封装调度器，串联以上组件，负责循环执行智能体行为

0、智能体案例

1）案例代码

• memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
  

• memory_key="chat_history"：这个 key 会传递到 prompt 中，LangChain 的 agent 会自动识别

• return_messages=True：表示记忆内容会以 ChatMessage 形式传递，而不是字符串

from langchain_openai import ChatOpenAI
from langchain.agents import tool, AgentExecutor, create_react_agent
from langchain_core.prompts import ChatPromptTemplate
from langchain import hub
from langchain.memory import ConversationBufferMemory

# 1. 定义工具
@tool
def get_weather(city: str) -> str:
    """查询指定城市的实时天气"""
    weather_data = {
        "北京": "晴，25°C",
        "上海": "多云，28°C",
        "广州": "雷阵雨，30°C",
        city: "晴，-1°C",
    }
    return weather_data.get(city, "未知城市")

# 2. 初始化模型
agent_llm = ChatOpenAI(
    base_url="https://api.deepseek.com/v1",
    api_key="sk-xxx",
    model="deepseek-chat"
)

# 3. 加载React提示模板
prompt = hub.pull("hwchase17/react")

# 4. 创建Agent + Memory
tools = [get_weather]
agent = create_react_agent(agent_llm, tools, prompt)
# 最基础的，只记录历史对话
memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
agent_executor = AgentExecutor(agent=agent, tools=tools, memory=memory, verbose=True)

# 5. 连续对话示例
agent_executor.invoke({"input": "广州天气如何？"})
agent_executor.invoke({"input": "那我今天可以穿T恤吗？"})

2）组件关系图

1、Prompt 模板

• Prompt 是 LLM 的“说明书”，告诉它要按如下格式回答

• Answer the following questions as best you can. You have access to the following tools:
  
  get_weather: 查询指定城市的实时天气
  
  Use the following format:
  
  Question: 上海今天适合穿短袖吗？
  Thought: 我需要知道今天上海的天气
  Action: get_weather
  Action Input: 上海
  

2、LLM（大语言模型）

• LLM 是整个智能体的“大脑”，根据输入（Prompt）决定

  • 我该思考什么？

  • 是否需要行动？行动是什么？

  • 工具调用后如何继续推理？

  • 最终怎么回答用户？

• 假设你说

  • 上海今天适合穿短袖吗？

• 模型在 Prompt 引导下会生成如下思路

  • Thought: 我需要知道今天上海的天气
    Action: get_weather
    Action Input: 上海
    

• 然后等待工具返回 Observation 后继续

  • Observation: 多云，28°C
    Thought: 今天气温较高，适合穿短袖
    Final Answer: 上海今天气温为28°C，多云，适合穿短袖
    

3、Tools（工具）

• Tools（工具）是 Agent 执行某些动作的“手臂”，比如

  • 调接口

  • 查询数据库

  • 调用函数（如 get_weather）

• ① 你注册了一个函数

  • @tool
    def get_weather(city: str) -> str:
        weather_data = {
            "北京": "晴，25°C",
            "上海": "多云，28°C",
        }
        return weather_data.get(city, "未知城市")
    

• ② 在 Prompt 中提到

  • Action: get_weather
    Action Input: 上海
    

• ③ LangChain 解析这部分后，会 自动调用你的函数

  • get_weather("上海")  # 返回 “多云，28°C”
    

4、Memory（记忆）

• Memory 保存历史对话，自动注入到 Prompt 中，以支持上下文推理

  • 用户说：广州天气如何？

  • 下次用户问：我可以穿T恤吗？

• 智能体会利用 Memory 把之前对话插入 Prompt

  • Previous conversation:
    Human: 广州天气如何？
    AI: 广州天气为雷阵雨，30°C
    Human: 那我今天可以穿T恤吗？
    

• 于是 LLM 就知道“你现在说的是广州”，可以继续回答你是否能穿T恤

• 示例代码

  • memory = ConversationBufferMemory(
        memory_key="chat_history",
        return_messages=True
    )
    

5、Agent

• Agent 是 LangChain 的核心机制，负责：

  • 组合 Prompt

  • 调用 LLM

  • 解析 LLM 的输出（是否有 Action）

  • 调用对应 Tool 并填充 Observation

  • 再次构造 Prompt 继续循环

  • 直到 LLM 输出 Final Answer

• Agent 执行的是一个“思考 → 行动 → 观察 → 思考”的 ReAct 推理链

• ① 用户输入：上海今天适合穿短袖吗？

• ② Agent 构造 Prompt 并传入 LLM

• ③ LLM 返回

  Thought: 我需要查询天气
  Action: get_weather
  Action Input: 上海
  

• ④ Agent 调用工具 get_weather("上海") → 得到 "多云，28°C"

• ⑤ Agent 构造新 Prompt（加入 Observation），继续调用 LLM

• ⑥ LLM 返回

  Thought: 天气温暖适合穿短袖
  Final Answer: 上海今天多云，28°C，适合穿短袖
  

6、AgentExecutor

• AgentExecutor 是 LangChain 中的“运行控制器”，负责

  • 把 Agent、Tools、Memory 组装起来

  • 接收用户输入

  • 控制 LLM 推理+Tool调用+Prompt重组+多轮循环

  • 直到输出 Final Answer

• 示例执行

  • agent_executor = AgentExecutor(
        agent=agent,
        tools=[get_weather],
        memory=memory,
        verbose=True
    )
    
    agent_executor.invoke({"input": "广州天气如何？"})
    agent_executor.invoke({"input": "那我今天能穿短袖吗？"})
    

• 底层执行逻辑（你只需调用 agent_executor.invoke()，一切自动完成）

  • 初始化 Agent + Prompt
  • 调用 LLM → 得到 Action
  • 执行 Tool → 得到 Observation
  • 拼接新 Prompt → 再次调用 LLM
  • 直到输出 Final Answer

7、Agent执行闭环流程图

0）流程图

• 用户输入："上海适合穿短袖吗？"
• Agent 决策：
  • LLM 生成 "需要查询上海天气 → Action: get_weather"
  • 调用 get_weather("上海") → 返回 "多云，28°C"
  • LLM 生成 "28°C适合短袖 → Final Answer: 适合"
• 输出结果："上海今天多云28°C，建议穿短袖。"

1）步骤1：初始化阶段

• 加载 LLM（大语言模型）
  • 连接 DeepSeek 或其他模型 API，设置参数（如 temperature、max_tokens）
• 注册 Tools（工具）
  • 定义可调用的外部函数（如 get_weather），并绑定到 Agent
• 设置 Prompt 模板
  • 定义 Agent 的决策逻辑，通常包括：
    • 工具列表（{tool_names}）
    • 用户输入（{input}）
    • 历史记忆（{chat_history}）
    • 中间步骤记录（{agent_scratchpad}）
• 初始化 Memory（记忆）
  • 如果是多轮对话，加载历史记录（如 Redis/SQLite 存储）
• 创建 AgentExecutor
  • 封装以上组件，管理执行流程（如超时控制、错误处理）

2）输入处理阶段

• 目标：接收用户输入，并格式化为 Agent 可处理的请求

• 步骤：

  • 用户提交问题（如 "上海今天适合穿短袖吗？"）

  • AgentExecutor 触发执行

    • 检查输入是否合法（如非空、无敏感词）

  • 注入上下文

    • 如果启用了 Memory，加载相关历史对话
    • 将输入和记忆合并为完整的 Prompt

3）思考-行动循环

• 目标：通过多轮“思考→行动→观察”逐步解决问题（核心决策阶段）

一、决策生成（LLM 推理）

• Agent 将格式化后的 Prompt 发送给 LLM
• LLM 返回下一步决策，可能是：
  • 直接回答（如 "Final Answer: ..."）
  • 调用工具（如 "Action: get_weather"）

二、工具执行

• 如果 LLM 决定调用工具（如 get_weather）：
  • Agent 解析工具名称和输入参数（如 {"city": "上海"}）
  • 执行工具函数，获取结果（如 "多云，28°C"）

三、状态更新

• 将当前步骤（工具调用 + 结果）保存到 Memory
• 检查是否满足终止条件：
  • 继续循环：如果 LLM 返回 Thought: ...，进入下一轮决策
  • 终止循环：如果 LLM 返回 Final Answer: ...，跳转到步骤 4

4）结果返回阶段

• 目标：生成最终响应并更新系统状态。

• 格式化输出

  • 将 LLM 的 Final Answer 转换为用户友好的文本（如 "上海今天多云28°C，适合穿短袖。"）

• 更新 Memory

  • 将本轮完整的输入输出保存到记忆库（用于后续对话）

• 返回结果给用户

  • 通过 AgentExecutor 输出最终答案

03.Agent智能体演示

功能目标

• Agent 任务链路管理器：ReAct 思考 + 工具调用执行流程
• 知识库封装（工具抽象）：行业 API / 知识检索工具封装
• Memory（上下文记忆）：可支持多轮追问和状态记忆
• RAG 检索模块：结合外部文档知识回答
• 多工具调用：工具列表包含静态模拟和真实行为（天气、数据库查询、知识库等）

0、项目结构概览

• 项目结构概览

  • industry_agent_demo/
    ├── setup_vectorstore.py        # 初始化向量库（用于RAG）
    
    ├── tools/
    │   ├── weather_tool.py         # 示例工具：天气查询
    │   ├── sql_query_tool.py       # 示例工具：数据库查询（模拟）
    │   └── rag_knowledge_tool.py   # RAG知识检索封装（向量库）
    ├── memory/
    │   └── memory_store.py         # 会话记忆组件（使用 BufferMemory）
    ├── agent_runner.py             # 主执行入口
    ├── data/
    │   └── knowledge_docs/         # 存放RAG文档
    └── requirements.txt
    

• 运行前准备

  • 将你的知识文档放入 data/knowledge_docs/ 中，支持 .txt, .md, .pdf

  • 运行 setup_vectorstore.py 构建 RAG 向量库

  • 设置你的 OpenAI 或 DeepSeek Key

  • 执行 agent_runner.py，开始对话！

• 示例对话效果

  • 用户输入：
    我想知道上海天气，还有介绍下 LLM 在金融行业的应用
    
    Agent 执行链路：
    → 检测关键词“上海天气” → 调用 get_weather("上海")
    → 检测“金融行业 LLM” → 调用 search_docs("金融 LLM 应用")
    → 整合两个结果 → 回复
    
    输出：
    上海今日多云，气温30°C。根据行业知识，LLM 在金融中主要应用于智能投顾、合规风控与客户支持……
    

1、向量库构建查询

1）FAISS 向量库构建（RAG）

# setup_vectorstore.py
from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings
from langchain.document_loaders import DirectoryLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter

loader = DirectoryLoader("./data/knowledge_docs", glob="**/*.txt")
docs = loader.load()

splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50)
splits = splitter.split_documents(docs)

db = FAISS.from_documents(splits, OpenAIEmbeddings())
db.save_local("rag_index")

2、Agent 构建与运行

1）agent_runner.py

# agent_runner.py
from langchain_openai import ChatOpenAI
from langchain.agents import create_react_agent, AgentExecutor
from langchain import hub

# 导入工具
from tools.weather_tool import get_weather
from tools.rag_knowledge_tool import search_docs
from memory.memory_store import memory

# 初始化模型
llm = ChatOpenAI(api_key="sk-xxx", base_url="https://api.deepseek.com/v1", model="deepseek-chat")

# Prompt 模板
prompt = hub.pull("hwchase17/react")

# Agent & 工具注册
tools = [get_weather, search_docs]
agent = create_react_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools, memory=memory, verbose=True)

# 用户输入测试
if __name__ == "__main__":
    result = executor.invoke({
        "input": "我想知道上海天气，还有介绍下 LLM 在金融行业的应用"
    })
    print(result["output"])

3、tools工具

1）tools/weather_tool.py 天气查询

# tools/weather_tool.py
from langchain.agents import tool

@tool
def get_weather(city: str) -> str:
    """查询指定城市的天气（模拟数据）"""
    data = {"北京": "晴 26°C", "上海": "多云 30°C", "广州": "雷雨 28°C"}
    return data.get(city, f"{city}天气信息未知")

2）rag_knowledge_tool.py RAG

# rag_knowledge_tool.py
from langchain.agents import tool
from langchain.vectorstores import FAISS
from langchain.embeddings import OpenAIEmbeddings

# 初始化向量库
db = FAISS.load_local("rag_index", OpenAIEmbeddings())

@tool
def search_docs(query: str) -> str:
    """从行业知识库中检索信息"""
    docs = db.similarity_search(query, k=2)
    return "\n".join([d.page_content for d in docs])

4、Memory 组件

1）memory/memory_store.py

# memory/memory_store.py
from langchain.memory import ConversationBufferMemory

memory = ConversationBufferMemory(
    memory_key="chat_history",
    return_messages=True
)

10、如何选择和编排 Tool

0）Agent 执行链路

• Agent 执行链路（推理过程）

  • 步骤	动作	谁完成的	说明
    用户输入	“上海今天适合穿短袖吗？我还想了解金融行业的大模型应用”	用户	一个多任务、多意图的问题
    Prompt 提供	提示词里告诉 LLM：“你可以用 get_weather、search_docs 工具”	Prompt（人写的）	提供规则和工具清单，但不主动触发工具
    LLM 推理	分析输入语义，发现包含两个子问题	LLM	理解语义，识别意图，拆解任务
    LLM 决定调用	① get_weather("上海")，② search_docs("金融行业 LLM 应用")	LLM	选择要用的工具、构造输入参数，并按顺序调用
    LangChain 执行	依据 LLM 输出的 Action 执行工具并返回 Observation	LangChain 执行器	把 LLM 的决策变为真实调用
    LLM 整合 Observation	接收天气结果 + 文档搜索结果 → 整理成回答

• 执行顺序

  • 步骤	说明
    ✅ prompt	构建一个包含“工具介绍 + 历史对话 + 当前输入”的完整上下文
    ✅ llm	接收 prompt，输出 Thought + Action + Action Input（例如调用 get_weather("上海")）
    ✅ tool	被 Agent 执行器（AgentExecutor）调用，拿到结果后再插回给 llm
    ✅ 循环	如果 LLM 推理认为还需继续调用工具，则继续上述流程，直到返回 Final Answer

1） Tool docstring 描述

• 选择和编排 Tool，主要 依据 Tool 的 docstring，描述了当前 Tool 的能力

• 每个 Tool 的 docstring 会被写入提示模板

  • @tool
    def get_weather(city: str) -> str:
        """查询指定城市的实时天气"""
    

• Agent Prompt 模板会自动包含这些工具的功能描述，如

  • You have access to the following tools:
    
    get_weather: 查询指定城市的实时天气
    search_docs: 在知识库中检索
    

• 这使得 LLM 能“知道”有哪些工具、能做什么

2）Prompt 模板确定 调用工具

• Prompt 模板示例告诉它怎么调用工具（ReAct）

• prompt = hub.pull("hwchase17/react") 加载的模板中包含调用示例，例如

Thought: I need to know the weather in Beijing.
Action: get_weather
Action Input: "北京"

Observation: 晴，25°C
Thought: Now I can answer the user.
Final Answer: 今天天气不错，适合出门。