从零构建AI智能体：基于ReAct框架的天气查询助手实战

最近在探索AI应用开发时，你是否也对“智能体（Agent）”这个概念感到既兴奋又困惑？看到各种框架和项目层出不穷，想自己动手搭建一个，却不知从何下手，面对复杂的架构图和术语感到迷茫？别担心，这正是每个开发者入门Agent领域的必经之路。本文将彻底打破这种困境，为你提供一份从零开始的、保姆级的Agent智能体搭建实战指南。我们将从一个最简单的“天气查询助手”开始，逐步深入到记忆、工具调用、多智能体协作等核心概念，手把手带你写出每一行代码，理解每一个配置项，最终构建出一个功能完整、可独立运行的AI智能体。无论你是刚接触AI的Python新手，还是想将AI能力集成到现有业务的后端开发者，都能从本文中找到清晰的路径和可直接复用的代码。

1. 什么是AI Agent？—— 从概念到落地

在开始敲代码之前，我们必须先厘清一个核心问题： Agent（智能体）到底是什么？ 它和我们常说的“大语言模型（LLM）”有什么区别？

简单来说，你可以把大语言模型（如GPT-4、Claude、DeepSeek）看作是一个 超级聪明但“四肢不勤”的大脑 。它知识渊博，能说会道，可以回答你的问题、写诗、编程。但是，它被“困”在对话窗口里，无法主动去查看今天的天气、无法帮你发送邮件、无法查询数据库。它的一切输出都基于其训练时“记忆”的知识，无法与真实世界互动。

而 Agent（智能体） ，则是给这个“大脑”装上了 感知器官、手脚和记忆系统 。它让LLM具备了以下关键能力：

1. 思考与规划 ：根据用户目标（Goal），拆解出具体的执行步骤（Plan）。
2. 使用工具 ：调用外部API、函数或系统命令（如搜索网络、查询数据库、发送邮件）来获取信息或执行动作。
3. 记忆与学习 ：记住与用户的对话历史、工具调用的结果，并在后续决策中利用这些信息。
4. 自主执行 ：在给定目标和工具集后，能够自动运行一系列步骤，直到完成任务或无法继续。

一个生动的比喻 ：LLM是坐在指挥中心的“指挥官”，它知道战略。而Agent是配备了通信设备（工具）、拥有战场记忆（记忆）并可以调动坦克、飞机（外部API）的“前线作战单元”。指挥官（LLM）负责制定“夺取A高地”的计划，而作战单元（Agent）则能自主执行“侦察敌情 -> 呼叫炮火支援 -> 步兵推进”等一系列动作。

当前热门的Agent项目与框架 ：根据网络热词，我们可以看到这个领域的活跃度，例如 Hermes Agent 、 Pi Agent 、 DeepSeek Agent 等，它们都是基于类似理念构建的具体实现或框架。而 Agent架构 、 多Agent协作 、 Agent记忆 、 Agent安全 则是构建复杂Agent系统时必须深入研究的核心课题。

理解了Agent是什么，我们就能明确本教程的目标： 不是仅仅调用LLM的API，而是构建一个能“思考-行动-观察-再思考”的循环系统。

2. 环境准备与核心工具选型

工欲善其事，必先利其器。搭建Agent需要选择合适的编程语言、框架和模型服务。为了最大化降低入门门槛并保证实战性，我们做出如下选择：

2.1 基础运行环境

• 操作系统 ：Windows 10/11, macOS, 或 Linux (如Ubuntu 20.04+)。本教程示例在macOS/Linux环境下编写，Windows用户请注意命令行的细微差别（如使用 dir 代替 ls ）。
• Python版本 ： Python 3.8 - 3.11 。这是绝大多数AI库稳定支持的版本范围。强烈建议使用 pyenv 或 conda 管理Python环境，避免包冲突。
• 包管理工具 ： pip (Python自带)。

2.2 核心库与框架选择 我们不直接使用某个庞大的完整框架（如LangChain），而是先从零构建核心逻辑，再引入轻量级框架辅助，以确保你能理解底层原理。

1. OpenAI SDK ( openai ) ：用于调用GPT系列模型，这是目前最稳定、文档最丰富的LLM接口。我们将使用它作为Agent的“大脑”。
2. LangChain Core ( langchain-core , langchain-openai ) ：LangChain是一个用于开发由语言模型驱动的应用程序的流行框架。我们主要利用其标准化的 工具（Tool）定义 、 调用方式 以及 智能体（Agent）执行器 ，这能极大简化开发，避免重复造轮子。我们只使用其核心部分，保持项目轻量。
3. Requests ( requests ) ：用于构建自定义工具，调用外部HTTP API（如天气API）。
4. Dotenv ( python-dotenv ) ：管理敏感信息（如API密钥），避免硬编码在代码中。

2.3 模型服务与API密钥

• LLM服务 ：我们将使用 OpenAI的GPT-3.5-turbo 模型。它成本低、速度快，完全满足学习需求。你也可以替换为GPT-4或其他兼容OpenAI API的模型（如DeepSeek、Ollama本地模型）。
• 如何获取 ：访问 OpenAI平台 注册并创建API Key。
• 重要提示 ：API Key是私密凭证，切勿泄露或上传至GitHub等公开仓库。

2.4 项目初始化 打开终端，跟随以下步骤创建你的第一个Agent项目：

# 1. 创建项目目录并进入
mkdir my_first_agent && cd my_first_agent

# 2. 创建虚拟环境（强烈推荐）
python -m venv venv

# 3. 激活虚拟环境
# macOS/Linux:
source venv/bin/activate
# Windows:
# venv\Scripts\activate

# 4. 安装核心依赖
pip install openai langchain-core langchain-openai requests python-dotenv

# 5. 创建项目文件
touch main.py tools.py .env

你的项目结构现在应该是这样：

my_first_agent/
├── venv/               # Python虚拟环境目录
├── main.py             # Agent主程序
├── tools.py            # 自定义工具定义
└── .env                # 环境变量配置文件（需要自己创建内容）

2.5 配置环境变量 编辑 .env 文件，填入你的OpenAI API Key。文件内容如下：

# .env
OPENAI_API_KEY=sk-your-actual-openai-api-key-here

请将 sk-your-actual-openai-api-key-here 替换为你真实的Key。

3. Agent核心架构与原理拆解

在动手编码前，我们需要在脑海中建立起Agent的核心运行循环，这通常被称为 ReAct (Reason + Act) 框架 。这是绝大多数Agent的底层逻辑。

3.1 ReAct循环：思考-行动-观察

1. 思考 (Reason) ：LLM根据用户输入和当前上下文（记忆），决定下一步该做什么。是直接回答？还是需要调用某个工具？
2. 行动 (Act) ：如果决定调用工具，LLM会生成一个格式化的工具调用请求，包含工具名和输入参数。
3. 观察 (Observe) ：系统执行指定的工具，并将工具执行的结果（成功或失败）返回给LLM。
4. 循环 ：LLM接收到观察结果，结合之前的上下文，再次进行“思考”，决定下一步是继续调用工具，还是汇总信息给出最终答案。

这个循环会一直持续，直到LLM认为任务完成，输出最终答案（Final Answer）。

3.2 关键组件详解

• LLM Core ：智能体的决策中心。我们使用 ChatOpenAI 来封装。
• Tools ：智能体的“手脚”。每个工具都是一个函数，有明确的名称、描述和参数。LLM通过描述来理解工具的功能。
• Agent Executor ：驱动整个ReAct循环的“发动机”。它负责解析LLM的输出，调用工具，收集结果，并把结果喂回给LLM进行下一轮思考。我们将使用LangChain的 AgentExecutor 。
• Memory ：智能体的“记忆”。可以是简单的对话历史（ ConversationBufferMemory ），也可以是更复杂的向量存储记忆。它保证了对话的连贯性。

下面，我们就将把这些组件一一实现。

4. 实战：搭建你的第一个天气查询Agent

我们将构建一个能理解中文、可以查询实时天气的智能体。

4.1 创建自定义工具（Tools） 首先，在 tools.py 中定义我们的“手脚”——一个天气查询工具。我们需要一个真实的天气API，这里我们使用免费的 Open-Meteo API。

# tools.py
import requests
from typing import Optional

def get_current_weather(location: str, unit: Optional[str] = "celsius") -> str:
    """
    获取指定城市的当前天气情况。

    Args:
        location: 城市名称，例如“北京”、“Shanghai”。
        unit: 温度单位，“celsius” 或 “fahrenheit”。默认为“celsius”。

    Returns:
        一个描述天气的字符串。
    """
    # 1. 构造API请求URL (使用Open-Meteo免费API)
    # 这里简单处理，实际项目可能需要更精确的地理编码
    base_url = "https://api.open-meteo.com/v1/forecast"
    params = {
        "latitude": 39.9042,  # 以北京为例，实际应根据location动态获取
        "longitude": 116.4074,
        "current_weather": "true",
        "timezone": "auto",
    }
    
    # 2. 发送HTTP请求
    try:
        response = requests.get(base_url, params=params)
        response.raise_for_status()  # 如果状态码不是200，抛出异常
        data = response.json()
    except requests.exceptions.RequestException as e:
        return f"请求天气API时出错：{e}"
    
    # 3. 解析返回数据
    current = data.get("current_weather", {})
    temperature = current.get("temperature")
    weather_code = current.get("weathercode")
    wind_speed = current.get("windspeed")
    
    # 4. 将天气代码转换为可读描述（简化版）
    weather_desc = _convert_weather_code(weather_code)
    
    # 5. 单位转换（示例中API返回即为摄氏度）
    if unit == "fahrenheit":
        temperature = temperature * 9/5 + 32
        unit_str = "华氏度"
    else:
        unit_str = "摄氏度"
    
    # 6. 返回格式化的结果
    return f"{location}的当前天气是{weather_desc}，温度{temperature:.1f}{unit_str}，风速{wind_speed} km/h。"

def _convert_weather_code(code: int) -> str:
    """将Open-Meteo的天气代码转换为中文描述。"""
    # 简化映射，完整映射请参考Open-Meteo文档
    weather_map = {
        0: "晴空",
        1: "基本晴朗",
        2:  "局部有云",
        3: "阴天",
        45: "有雾",
        48: "有雾",
        51: "小雨",
        61: "雨",
        80: "阵雨",
        95: "雷暴",
    }
    return weather_map.get(code, "未知天气")

代码解释 ：

• 我们定义了一个 get_current_weather 函数，它接受 location 和 unit 两个参数。
• 函数有详细的文档字符串（ docstring ）。 这至关重要！ LLM就是通过阅读这个描述来理解工具功能的。
• 函数内部调用真实的天气API，解析JSON数据，并返回一个格式化的字符串结果。
• 我们用一个辅助函数 _convert_weather_code 来处理天气代码。

4.2 构建主Agent程序 接下来，在 main.py 中，我们将组装所有部件。

# main.py
import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_openai_tools_agent
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain.memory import ConversationBufferMemory
from langchain.tools import Tool

# 导入我们自定义的工具函数
from tools import get_current_weather

# 1. 加载环境变量（从.env文件读取API Key）
load_dotenv()
openai_api_key = os.getenv("OPENAI_API_KEY")
if not openai_api_key:
    raise ValueError("请在 .env 文件中设置 OPENAI_API_KEY")

# 2. 初始化LLM（Agent的大脑）
# 使用gpt-3.5-turbo-1106模型，它支持工具调用功能。
llm = ChatOpenAI(
    model="gpt-3.5-turbo-1106",
    temperature=0,  # 温度设为0，使输出更确定、更稳定
    openai_api_key=openai_api_key
)

# 3. 将自定义函数包装成LangChain Tool对象
# Tool对象包含了函数、名称、描述，是LLM能识别的标准格式。
weather_tool = Tool(
    name="get_current_weather",
    func=get_current_weather,
    description="""当你需要查询某个城市的当前天气时使用此工具。
    输入应该是一个包含城市名称（例如‘北京’、‘上海’）的字符串，
    以及可选的温度单位（‘celsius’或‘fahrenheit’）。
    """
)

# 你可以在这里定义更多工具，组成一个工具列表
tools = [weather_tool]

# 4. 创建Prompt模板，指导Agent的行为
# 这是Agent的“性格”和“行为准则”设定，非常关键。
prompt = ChatPromptTemplate.from_messages([
    ("system", """你是一个乐于助人的中文AI助手。你可以使用工具来获取信息。
    请遵循以下规则：
    1. 用中文思考和回答。
    2. 如果用户的问题需要实时信息（如天气），请务必使用工具。
    3. 使用工具时，请清晰说明你将要做什么。
    4. 根据工具返回的结果，给出友好、完整的回答。
    """),
    MessagesPlaceholder(variable_name="chat_history"), # 预留位置用于插入记忆（对话历史）
    ("human", "{input}"), # 用户输入的位置
    MessagesPlaceholder(variable_name="agent_scratchpad"), # 预留位置用于Agent思考过程
])

# 5. 初始化记忆（让Agent能记住对话上下文）
memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)

# 6. 创建Agent
# `create_openai_tools_agent` 是LangChain提供的一个便捷函数，用于创建适配OpenAI工具调用格式的Agent。
agent = create_openai_tools_agent(llm=llm, tools=tools, prompt=prompt)

# 7. 创建Agent执行器
# 这是驱动整个ReAct循环的核心组件。
agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    memory=memory, # 注入记忆
    verbose=True,  # 设置为True，会在控制台打印详细的思考过程，便于调试学习
    handle_parsing_errors=True, # 处理解析错误，避免因LLM输出格式不对而崩溃
)

# 8. 与Agent交互
if __name__ == "__main__":
    print("天气助手Agent已启动！输入‘退出’或‘quit’结束对话。")
    print("-" * 50)
    
    while True:
        user_input = input("\n你: ")
        if user_input.lower() in ["退出", "quit", "exit"]:
            print("助手: 再见！")
            break
        
        # 调用执行器，传入用户输入
        try:
            response = agent_executor.invoke({"input": user_input})
            print(f"\n助手: {response['output']}")
        except Exception as e:
            print(f"\n出错啦: {e}")

4.3 运行与验证 确保你的虚拟环境已激活，并且 .env 文件已正确配置API Key。

在终端运行你的Agent：

python main.py

你应该会看到类似以下的输出， verbose=True 会让我们看到Agent内部的思考过程，这对学习至关重要：

天气助手Agent已启动！输入‘退出’或‘quit’结束对话。
--------------------------------------------------

你: 今天北京天气怎么样？

> 进入新的Agent执行链...
我可能需要查询北京的当前天气。用户问的是“今天北京天气怎么样？”，这需要实时天气信息。我应该使用天气查询工具。

Action: get_current_weather
Action Input: {"location": "北京", "unit": "celsius"}
Observation: 北京的当前天气是晴空，温度12.3摄氏度，风速15.2 km/h。

根据工具返回的结果，北京现在是晴天，温度12.3度，风速15.2 km/h。我可以把这个信息组织成友好的回答。

Thought: 我现在有足够的信息来回答用户了。
Final Answer: 今天北京天气晴朗，气温大约12.3摄氏度，风速15.2公里每小时，是个不错的日子。

助手: 今天北京天气晴朗，气温大约12.3摄氏度，风速15.2公里每小时，是个不错的日子。

恭喜！ 你已经成功运行了你的第一个AI智能体。它理解了你的中文问题，自动决定调用 get_current_weather 工具，获取结果后，组织语言给出了最终回答。这就是ReAct循环在起作用。

5. 功能进阶：为Agent添加记忆与更多工具

一个只会查天气的Agent显然不够看。让我们增强它。

5.1 增强记忆能力 上面的例子使用了 ConversationBufferMemory ，它只是简单地将所有对话历史保存在内存中。对于长对话，这可能导致上下文过长（超出LLM的Token限制）。我们可以尝试更高级的记忆方式，如 ConversationSummaryMemory ，它会自动总结历史对话。

# 在main.py中替换原来的memory初始化部分
from langchain.memory import ConversationSummaryMemory
from langchain_openai import OpenAI

# 使用一个单独的LLM来总结记忆（为了节省成本，可以用小模型，这里仍用gpt-3.5-turbo示例）
summary_llm = ChatOpenAI(model="gpt-3.5-turbo-1106", temperature=0, openai_api_key=openai_api_key)
memory = ConversationSummaryMemory(
    llm=summary_llm,
    memory_key="chat_history",
    return_messages=True
)

ConversationSummaryMemory 会在每次交互后，自动生成一个对话摘要，而不是存储所有原始消息，从而更高效地利用上下文窗口。

5.2 添加更多工具 让我们给Agent再装几个“技能”。在 tools.py 中添加新函数，并在 main.py 的 tools 列表中注册。

工具一：简单计算器

# 在 tools.py 中添加
def simple_calculator(expression: str) -> str:
    """
    执行简单的数学计算。支持加(+)、减(-)、乘(*)、除(/)。

    Args:
        expression: 数学表达式字符串，例如“3 + 5 * 2”。

    Returns:
        计算结果字符串，或错误信息。
    """
    # 警告：使用eval有安全风险，仅用于示例。生产环境应用安全解析库（如ast.literal_eval）。
    try:
        # 极其简单的安全过滤，切勿用于真实生产环境！
        if any(keyword in expression for keyword in ['import', 'os', 'sys', '__', 'open', 'eval', 'exec']):
            return "表达式包含不安全字符。"
        result = eval(expression)
        return f"{expression} = {result}"
    except Exception as e:
        return f"计算表达式‘{expression}’时出错：{e}"

工具二：获取当前时间

# 在 tools.py 中添加
from datetime import datetime

def get_current_time(timezone: str = "Asia/Shanghai") -> str:
    """
    获取指定时区的当前日期和时间。

    Args:
        timezone: 时区字符串，例如“Asia/Shanghai”、“America/New_York”。默认为“Asia/Shanghai”。

    Returns:
        格式化的日期时间字符串。
    """
    try:
        from zoneinfo import ZoneInfo
        tz = ZoneInfo(timezone)
    except ImportError:
        # Python 3.8 兼容性回退
        import pytz
        tz = pytz.timezone(timezone) # 需要安装 pip install pytz
    except Exception:
        tz = None
    
    now = datetime.now(tz) if tz else datetime.now()
    return now.strftime(f"%Y年%m月%d日 %H:%M:%S ({timezone})")

更新 main.py 中的工具列表：

# main.py (更新tools列表部分)
from tools import get_current_weather, simple_calculator, get_current_time

weather_tool = Tool(name="get_current_weather", func=get_current_weather, description="...")
calc_tool = Tool(name="simple_calculator", func=simple_calculator, description="用于执行基础数学计算，输入是一个数学表达式字符串，如‘3 + 5 * 2’。")
time_tool = Tool(name="get_current_time", func=get_current_time, description="获取指定时区的当前时间，输入是时区字符串，例如‘Asia/Shanghai’。”)

tools = [weather_tool, calc_tool, time_tool]

现在重启你的 main.py ，试试更复杂的对话：

你: 先算一下 (15 + 7) * 3 等于多少，然后告诉我现在上海的时间。

> 进入新的Agent执行链...
用户有两个请求：先计算一个表达式，然后查询上海时间。我应该按顺序使用计算器和时间工具。

Action: simple_calculator
Action Input: {"expression": "(15 + 7) * 3"}
Observation: (15 + 7) * 3 = 66

第一个任务完成，结果是66。现在需要查询上海时间。

Action: get_current_time
Action Input: {"timezone": "Asia/Shanghai"}
Observation: 2024年05月20日 14:30:25 (Asia/Shanghai)

两个工具都调用成功了。我可以把结果整合起来回答。

Thought: 我现在可以给出最终答案了。
Final Answer: 计算结果为：(15 + 7) * 3 = 66。当前上海时间是2024年05月20日 14:30:25。

助手: 计算结果为：(15 + 7) * 3 = 66。当前上海时间是2024年05月20日 14:30:25。

看，Agent已经可以 自主规划任务顺序，并连续使用多个工具 了！

6. 常见问题与深度排查指南

在搭建和运行Agent过程中，你一定会遇到各种问题。以下是典型问题及解决方案。

6.1 工具调用失败：LLM不理解或错误调用工具

• 现象 ：Agent不调用工具直接回答，或调用工具时参数格式错误。
• 原因与解决 ：
  1. 工具描述不清 ：检查Tool的 description 是否清晰、准确地描述了工具的功能、输入格式和输出。用自然语言写，就像教一个新手如何使用它。
  2. Prompt引导不足 ：在System Prompt中明确要求Agent“在需要实时信息时使用工具”。可以强化指令。
  3. 模型能力 ：GPT-3.5-turbo的工具调用能力已经很强，但如果问题复杂，可以尝试换用GPT-4。
  4. 参数格式 ：确保工具函数有类型注解（Type Hints），这能帮助LangChain更好地生成JSON Schema供LLM理解。

6.2 上下文长度超限（Token Overflow）

• 现象 ：对话进行到后面，Agent似乎“忘记”了之前的内容，或者API返回长度错误。
• 原因 ：对话历史（记忆）太长，超过了模型的最大上下文长度（如GPT-3.5-turbo的16K）。
• 解决 ：
  1. 使用摘要记忆 ：如前所述，用 ConversationSummaryMemory 代替 ConversationBufferMemory 。
  2. 滑动窗口记忆 ：只保留最近N轮对话。
  3. 向量存储记忆 ：将历史对话存入向量数据库，在需要时进行相关性检索召回。这是构建“长期记忆”的进阶方案，可使用 langchain.chat_message_histories 和 langchain.vectorstores 实现。

6.3 Agent陷入循环或执行低效

• 现象 ：Agent反复调用同一个工具，或者在不必要时调用工具，无法输出最终答案。
• 原因 ：ReAct循环没有正确终止。
• 解决 ：
  1. 设置最大迭代次数 ：在 AgentExecutor 中设置 max_iterations 和 max_execution_time 参数，强制终止长时间运行。

  agent_executor = AgentExecutor(
      agent=agent,
      tools=tools,
      memory=memory,
      verbose=True,
      max_iterations=5, # 最多思考-行动5次
      early_stopping_method="generate", # 让LLM自己决定提前结束
  )
  

  2. 优化Prompt ：在System Prompt中明确写出“当你认为已经获得足够信息来回答问题后，请输出最终答案（Final Answer）”。

6.4 API密钥或网络问题

• 现象 ： openai.error.AuthenticationError 或 网络超时。
• 解决 ：
  1. 确认 .env 文件中的 OPENAI_API_KEY 正确无误，且没有多余空格。
  2. 确认账户有余额或该API Key有访问权限。
  3. 对于国内用户，可能需要配置网络代理（请注意遵守相关法律法规，此处不展开讨论技术细节）。

7. 工程化与最佳实践

当你想要将这个小Demo升级为一个真正的项目时，需要考虑以下方面：

7.1 项目结构优化 一个标准的Agent项目可能包含以下模块：

my_agent_project/
├── app/
│   ├── __init__.py
│   ├── main.py          # 应用入口
│   ├── agent/           # Agent核心逻辑
│   │   ├── __init__.py
│   │   ├── builder.py   # 构建Agent链
│   │   └── prompts.py   # 存放各种Prompt模板
│   ├── tools/           # 工具集
│   │   ├── __init__.py
│   │   ├── weather.py
│   │   ├── calculator.py
│   │   └── web_search.py
│   ├── memory/          # 记忆管理
│   │   └── manager.py
│   └── config.py        # 配置文件
├── tests/               # 单元测试
├── requirements.txt     # 依赖列表
├── .env.example         # 环境变量示例
└── README.md

7.2 工具开发规范

• 单一职责 ：每个工具只做一件事。
• 健壮性 ：工具函数内部必须有完善的错误处理（try-except），返回明确的错误信息，避免整个Agent崩溃。
• 安全性 ： 绝对不要 在工具中直接使用 eval() 或执行未经验证的用户输入。上面的计算器示例仅用于教学，生产环境必须使用安全的数学表达式解析库（如 ast.literal_eval 限制范围，或使用 numexpr ）。
• 异步支持 ：如果工具涉及网络I/O（如调用API），考虑将其定义为异步函数（ async def ），并使用支持异步的Agent执行器以提高性能。

7.3 Prompt工程优化 Prompt是Agent的“灵魂”，直接决定其行为模式。

• 角色设定 ：在System Prompt中清晰定义Agent的角色、能力和边界。
• 输出格式约束 ：明确要求LLM以特定格式（如“Action: ...\nAction Input: ...”）进行思考，这在与自定义解析逻辑配合时很重要。
• 少样本示例（Few-Shot） ：在Prompt中提供几个“用户输入-Agent思考过程-最终输出”的完整示例，能极大地提升Agent在复杂任务上的表现。

7.4 切换与评估不同的LLM 我们的架构并不绑定OpenAI。你可以轻松替换LLM后端。

• 使用本地模型 ：通过 Ollama 或 LM Studio 运行本地大模型（如Llama 3, Qwen），并使用 ChatOllama 等LangChain集成。

  from langchain_community.chat_models import ChatOllama
  llm = ChatOllama(model="llama3:8b", base_url="http://localhost:11434")
  

• 使用其他云服务 ：LangChain支持Anthropic Claude、Google Gemini等，只需更换ChatModel类并配置相应API Key。
• 评估 ：对于生产系统，需要建立评估体系，从 准确性 、 工具调用成功率 、 响应时间 、 成本 等维度对比不同模型。

7.5 走向多智能体（Multi-Agent）协作 当单个Agent无法处理复杂任务时，就需要多Agent系统。例如：

• 编排者（Orchestrator） ：一个主管Agent，负责接收用户任务，并将其分解成子任务，分发给其他专家Agent。
• 专家Agent ：专门负责某一领域的Agent（如数据分析Agent、文案撰写Agent、代码审查Agent）。 他们之间通过共享工作区或消息队列进行通信。LangChain提供了 MultiAgentCollaboration 相关的实验性功能，社区也有 CrewAI 、 AutoGen 等专门框架。

8. 总结与学习路线

至此，你已经完成了一个功能完整的AI智能体从零到一的搭建。我们经历了： 理解Agent概念 -> 准备环境 -> 剖析ReAct原理 -> 实现自定义工具 -> 构建核心Agent循环 -> 添加记忆与多工具 -> 排查问题 -> 探讨工程化 的全过程。

你的学习路线可以继续深入 ：

1. 深入LangChain ：探索其更多的 记忆后端 （向量数据库）、 复杂Agent类型 （ReAct文档检索、Self-Ask）、**链（Chain）**的编排能力。
2. 探索其他框架 ：了解 AutoGen （微软）、 CrewAI 、 Semantic Kernel 等框架的设计哲学，拓宽视野。
3. 集成真实工具 ：将Agent与你的业务系统连接，例如连接数据库（ SQLDatabaseToolkit ）、内部API、邮件系统、办公软件等。
4. 构建Web界面 ：使用 Gradio 、 Streamlit 或 FastAPI 为你的Agent构建一个聊天机器人界面。
5. 关注安全与合规 ：深入研究 Agent安全 ，包括工具使用的权限控制、防止Prompt注入、输出内容过滤等。
6. 学习智能体评估 ：如何定量评估一个Agent的好坏，建立测试数据集和评估指标。

记住，Agent开发的核心在于 将大语言模型的推理能力与外部世界的执行能力相结合 。从今天这个小小的天气查询助手出发，你可以逐步构建出能自动处理工单、分析数据、生成报告甚至管理项目的强大智能体系统。动手去实验，遇到问题就查阅文档和社区，这才是学习AI应用开发最有效的方式。本文的所有代码都已提供，你可以直接在此基础上进行修改和扩展，祝你构建出令人惊叹的AI应用！