最近在AI圈子里，一个看似“无厘头”的项目标题火了：“when elena is hungry but i can't cook... / 当埃琳娜饿了，但我不会做饭的时候……”。初看像是一个生活求助帖，但它背后指向的，是当前AI Agent（智能体）开发领域一个非常具体且普遍的痛点： 如何让一个“不懂行”的AI，去调用一个它“不熟悉”的工具或API，来完成一个复杂的、多步骤的任务？

这个标题精准地捕捉到了一个经典场景。假设“埃琳娜”是一个AI助手，你（用户）不会做饭，但你需要它帮你解决“饿了”这个问题。一个初级的AI可能只会回复：“我很抱歉，我无法烹饪食物。” 这显然不是我们想要的。我们期望的AI，应该能主动思考：用户饿了 → 需要食物 → 获取食物的途径有哪些（点外卖、查找食谱、推荐餐厅）→ 选择最佳途径 → 执行具体操作（调用外卖API、展示菜谱步骤）。

这恰恰是构建实用AI Agent的核心挑战。它考验的不是AI的聊天能力，而是其 任务分解、工具调用和流程编排 的能力。今天，我们就以这个生动的场景为引子，深入探讨如何利用当前主流的技术框架（如LangChain、Semantic Kernel，或新兴的Agent框架），构建一个能真正“解决问题”的智能体。本文将不仅告诉你“是什么”，更会通过完整的代码示例，带你走通“环境搭建→工具定义→Agent构建→任务执行”的全流程，并揭示其中最容易踩坑的环节。

1. 这篇文章真正要解决的问题：从“聊天机器人”到“执行智能体”的跨越

很多开发者对AI Agent的理解还停留在“接入了大模型API的聊天程序”。这导致开发的“智能体”只能进行信息整合和对话，一旦遇到需要操作外部系统（如查询数据库、发送邮件、控制智能家居）或执行多步骤规划（如策划旅行、编写并运行代码）的任务时，就束手无策。

“当埃琳娜饿了，但我不会做饭的时候……”这个命题，本质上是在要求AI具备以下能力：

1. 状态感知与目标理解 ：理解“饥饿”是状态，“获得食物”是目标。
2. 知识库与工具查询 ：知道解决“饥饿”有哪些可行方案（工具），例如 search_restaurants （搜索餐厅）、 order_food （订购外卖）、 search_recipes （查找食谱）。
3. 规划与决策 ：根据上下文（用户偏好、时间、地理位置）选择最合适的方案。
4. 工具执行与迭代 ：安全地调用选中的工具，如果结果不理想（如餐厅关门），能重新规划。

本文要解决的，就是如何用代码实现上述能力。我们将构建一个名为 ElenaHungerAgent 的智能体，它能在用户表达饥饿时，自动完成从“推荐解决方案”到“执行外卖订单”的完整闭环。你会学到Agent的核心架构、工具（Tool）的定义方法、以及如何让大模型（LLM）学会在合适的时机调用合适的工具。

2. 基础概念与核心原理：Agent、Tool与规划器

在开始编码前，必须厘清几个核心概念，否则很容易在后续开发中混淆。

智能体（Agent） ： 一个可以感知环境、进行决策并执行动作以实现目标的系统。在我们的场景中， ElenaHungerAgent 就是一个智能体。它的核心是一个 大语言模型（LLM） ，负责“思考”和“决策”。

工具（Tool） ： 智能体可以调用的、用于与环境交互的具体函数或API。工具扩展了LLM的能力边界，使其不再局限于文本生成。例如：

• search_restaurants(location, cuisine) : 根据位置和菜系搜索餐厅。
• order_food(restaurant_id, items) : 向指定餐厅下单。
• get_weather(city) : 获取天气信息（可能影响外卖配送）。

规划器（Planner） ： 这是Agent的“大脑”组成部分。它负责将用户的复杂指令分解成一系列可执行的工具调用步骤。有些框架将规划能力内置于Agent的核心循环中，有些则提供独立的规划模块。

执行器（Executor） ： 负责运行规划器制定的计划，依次调用工具，并将工具执行结果返回给LLM进行下一步判断。

它们的工作流程如下图所示（概念性描述）：

用户输入：“我饿了” -> Agent接收 -> LLM（规划器）思考 -> 决定调用`search_restaurants`工具 -> 执行器调用工具 -> 获得餐厅列表 -> LLM分析结果 -> 决定调用`order_food`工具 -> 执行器下单 -> 获得订单号 -> LLM生成最终回复给用户。

当前主流的开发框架，如 LangChain 和 Microsoft Semantic Kernel ，都提供了将LLM、工具、规划与执行流程封装起来的高级抽象，让开发者能更专注于业务逻辑。

3. 环境准备与前置条件

我们将使用 Python 和 LangChain 框架来实现这个Agent，因为它生态丰富、文档完善，最适合快速理解和原型开发。同时，我们需要一个LLM作为Agent的“大脑”，这里选择 OpenAI 的 GPT 模型（也可替换为国内兼容API的模型）。

基础环境：

• 操作系统 ： Windows 10/11, macOS, 或 Linux (Ubuntu 20.04+)
• Python 版本 ： 3.8 或 3.9（推荐3.9，兼容性最好）
• 包管理工具 ： pip

核心依赖安装： 打开终端（Terminal）或命令提示符（CMD），创建一个新的项目目录，并安装以下包：

# 创建项目目录并进入
mkdir elena_hunger_agent
cd elena_hunger_agent

# 创建虚拟环境（推荐）
python -m venv venv
# 激活虚拟环境
# Windows:
venv\Scripts\activate
# macOS/Linux:
source venv/bin/activate

# 安装核心依赖
pip install langchain langchain-openai langchain-community
# 安装requests用于模拟工具调用
pip install requests
# 安装环境变量管理包（方便管理API Key）
pip install python-dotenv

获取并配置API Key： 你需要一个OpenAI的API Key。如果你使用其他兼容OpenAI API的模型服务（如Azure OpenAI、DeepSeek、Ollama本地模型），请准备相应的Endpoint和Key。

1. 在项目根目录创建 .env 文件，用于安全存储密钥。
2. 在 .env 文件中填入你的密钥：

   # .env 文件
   OPENAI_API_KEY=你的-openai-api-key-here
   # 如果使用其他服务，可能还需要
   # OPENAI_API_BASE=https://your-endpoint.com/v1
   

3. 在代码中通过 os.getenv 或 dotenv 加载。

重要提醒 ： 切勿将 .env 文件提交到Git等版本控制系统。请将其添加到 .gitignore 中。

4. 核心流程拆解：构建ElenaHungerAgent的四大步骤

我们的构建将分为四个清晰的步骤，每一步都解决一个关键问题：

步骤一：定义工具（Tool） - 赋予Agent“手和脚” 我们需要创建一些模拟的工具函数，并按照LangChain的规范将其包装成 Tool 对象。

步骤二：创建Agent执行器（Agent Executor） - 组装“大脑”和“身体” 将LLM（大脑）和我们定义的工具（身体）组合起来，形成一个可以自主运行的Agent系统。

步骤三：设计提示词（Prompt） - 设定Agent的“性格”与“目标” 通过系统提示词（System Message）告诉Agent它的角色（埃琳娜的助手）、可用工具以及行动准则。

步骤四：执行与迭代 - 让Agent跑起来并观察其推理过程 输入用户 query，观察Agent的思考链（Chain of Thought），并处理可能出现的错误或循环。

5. 完整示例与代码实现

现在，让我们开始编写 ElenaHungerAgent 的完整代码。我们将创建三个文件来组织代码。

5.1 第一步：定义工具（tools.py）

首先，我们创建 tools.py ，定义三个模拟的工具函数。

# tools.py
import requests
import json
from typing import Optional, List
from langchain.tools import tool

# 模拟工具1：搜索餐厅
@tool
def search_restaurants(location: str, cuisine: Optional[str] = None) -> str:
    """
    根据地理位置和可选菜系搜索附近的餐厅。

    Args:
        location: 地理位置，例如“北京中关村”、“上海浦东”。
        cuisine: 菜系类型，例如“中餐”、“披萨”、“素食”。默认为None，表示不限。

    Returns:
        一个格式化的餐厅列表字符串，包含ID、名称、评分和预估送达时间。
    """
    # 这里模拟一个API调用。在实际项目中，你会替换为真实的地图或外卖平台API。
    print(f"[工具调用] search_restaurants: location={location}, cuisine={cuisine}")
    
    # 模拟数据
    mock_restaurants = [
        {"id": 1, "name": "美味中餐馆", "rating": 4.5, "eta": "30分钟", "cuisine": "中餐"},
        {"id": 2, "name": "快捷披萨屋", "rating": 4.2, "eta": "25分钟", "cuisine": "披萨"},
        {"id": 3, "name": "绿色沙拉吧", "rating": 4.7, "eta": "20分钟", "cuisine": "素食"},
    ]
    
    filtered = mock_restaurants
    if cuisine:
        filtered = [r for r in mock_restaurants if cuisine in r["cuisine"]]
    
    result = "找到以下餐厅：\n"
    for r in filtered:
        result += f"- ID:{r['id']} {r['name']} (评分：{r['rating']}, 预计送达：{r['eta']})\n"
    return result if filtered else "在您指定的区域未找到符合条件的餐厅。"

# 模拟工具2：订购食物
@tool
def order_food(restaurant_id: int, items: List[str]) -> str:
    """
    向指定餐厅下单。

    Args:
        restaurant_id: 餐厅的ID，应从search_restaurants的结果中获取。
        items: 要订购的食物项目列表，例如 ["鱼香肉丝", "米饭"]。

    Returns:
        订单确认信息，包含订单号。
    """
    print(f"[工具调用] order_food: restaurant_id={restaurant_id}, items={items}")
    # 模拟下单API调用
    order_number = f"ORD{restaurant_id:03d}{len(items)}"
    return f"下单成功！订单号：{order_number}。餐厅已接单，正在准备中。"

# 模拟工具3：获取菜谱（备用方案）
@tool
def search_recipes(ingredients: List[str]) -> str:
    """
    根据现有食材搜索菜谱。

    Args:
        ingredients: 可用的食材列表，例如 ["鸡蛋", "西红柿", "面条"]。

    Returns:
        推荐的菜谱列表和简要步骤。
    """
    print(f"[工具调用] search_recipes: ingredients={ingredients}")
    # 模拟菜谱查询
    recipes = [
        {"name": "西红柿炒鸡蛋", "steps": "1. 鸡蛋打散炒熟备用 2. 西红柿炒软 3. 混合翻炒加盐"},
        {"name": "鸡蛋面", "steps": "1. 煮面条 2. 煎鸡蛋 3. 混合调味"},
    ]
    result = "根据您的食材，推荐以下菜谱：\n"
    for r in recipes:
        result += f"- {r['name']}: {r['steps']}\n"
    return result

# 导出工具列表，供主程序使用
def get_all_tools():
    return [search_restaurants, order_food, search_recipes]

if __name__ == "__main__":
    # 简单测试工具
    print(search_restaurants.run("北京中关村", "中餐"))
    print(order_food.run(1, ["鱼香肉丝", "米饭"]))

关键点解释：

• @tool 装饰器：这是LangChain提供的便捷方式，能将一个普通Python函数自动包装成LangChain可识别的 Tool 对象。
• 详细的文档字符串（Docstring）： 至关重要！ LLM（如GPT）依赖这些描述来理解工具的功能、输入参数和输出格式。描述必须清晰准确。
• 模拟实现：我们用打印语句和模拟数据代替真实API调用，这保证了示例的可运行性，也清晰地展示了工具被调用的时机。

5.2 第二步：构建Agent主程序（main.py）

接下来，创建 main.py ，这是组装和运行Agent的核心。

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

# 1. 加载环境变量（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 或 gpt-4，后者在复杂规划上表现更好
llm = ChatOpenAI(
    model="gpt-3.5-turbo-1106",
    temperature=0, # 温度设为0，使输出更确定、更倾向于使用工具
    api_key=openai_api_key,
)

# 3. 获取工具列表
tools = get_all_tools()

# 4. 构建提示词模板（设定Agent的角色和行为准则）
# 这是控制Agent行为的关键！
prompt = ChatPromptTemplate.from_messages([
    ("system", """你是一个名叫埃琳娜（Elena）的智能餐饮助手。你的目标是帮助用户解决饥饿问题。
你有以下能力（工具）可以使用：
1. `search_restaurants`: 根据用户位置和偏好搜索餐厅。
2. `order_food`: 在用户选定餐厅后，帮助用户下单。
3. `search_recipes`: 如果用户想自己做饭，提供菜谱。

请遵循以下规则：
- 首先，主动询问用户的位置和饮食偏好（例如：中餐、西餐、素食）。
- 根据用户信息，优先使用`search_restaurants`工具寻找餐厅。
- 向用户展示餐厅列表，并询问用户选择哪一家。
- 当用户选定餐厅后，询问他想点什么菜，然后使用`order_food`工具下单。
- 如果用户表示想自己做饭，再使用`search_recipes`工具。
- 每次行动前，请简要说明你的思考过程。
- 如果工具返回错误或没有结果，请向用户说明并尝试其他方案。
- 保持对话友好、有帮助。
"""),
    MessagesPlaceholder(variable_name="chat_history"), # 预留位置给对话历史
    ("human", "{input}"), # 用户当前输入
    MessagesPlaceholder(variable_name="agent_scratchpad"), # 预留位置给Agent的思考/工具调用记录
])

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

# 6. 创建Agent执行器，并传入记忆（Memory）以便进行多轮对话
memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    memory=memory,
    verbose=True, # 设为True，可以看到Agent详细的思考过程（非常重要！）
    handle_parsing_errors=True, # 优雅处理解析错误
    max_iterations=5, # 防止无限循环，限制最大迭代次数
)

# 7. 运行Agent，模拟一个多轮对话
if __name__ == "__main__":
    print("=== 埃琳娜餐饮助手已启动 ===")
    print("（输入 '退出' 或 'quit' 结束对话）\n")
    
    # 模拟对话流程
    test_conversation = [
        "我饿了。",
        "我在北京海淀区，想吃点辣的。",
        "选第一家吧，我想吃水煮鱼和米饭。",
    ]
    
    for query in test_conversation:
        print(f"\n[用户] {query}")
        print("-" * 40)
        try:
            response = agent_executor.invoke({"input": query})
            print(f"\n[埃琳娜] {response['output']}")
        except Exception as e:
            print(f"执行出错: {e}")
            break
    print("\n=== 对话结束 ===")

关键点解释：

• ChatOpenAI ： 初始化与OpenAI服务的连接。 temperature=0 使输出更稳定，更倾向于遵循指令和调用工具。
• create_openai_tools_agent ： LangChain提供的快捷函数，用于创建基于OpenAI函数调用（Function Calling）规范的Agent。这是当前最稳定、效果最好的Agent类型之一。
• 提示词（Prompt） ： 这是灵魂。我们通过System Message详细定义了Agent的角色、可用工具、行动规则和对话风格。好的提示词能极大提升Agent的可靠性和准确性。
• AgentExecutor ： 负责运行Agent的核心循环。 verbose=True 会打印出LLM的思考、工具选择、工具输入输出等详细信息，对于调试和理解Agent行为 极其重要 。 max_iterations 是安全措施，防止Agent陷入死循环。
• ConversationBufferMemory ： 为Agent添加记忆功能，使其能记住之前的对话内容，实现连贯的多轮交互。

5.3 第三步：创建环境配置文件（.env）

确保你的项目根目录下有 .env 文件。

# .env
OPENAI_API_KEY=sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

6. 运行结果与效果验证

现在，让我们运行这个程序，看看“埃琳娜”如何解决我们的饥饿问题。

1. 在终端中，确保位于项目根目录且虚拟环境已激活。
2. 运行主程序：

   python main.py
   

预期输出（verbose模式下的关键信息节选）：

=== 埃琳娜餐饮助手已启动 ===
（输入 '退出' 或 'quit' 结束对话）

[用户] 我饿了。
----------------------------------------
> 进入新的Agent执行链...
思考：用户说他饿了。我的首要任务是询问他的位置和饮食偏好，以便搜索餐厅。
行动：我将使用工具`search_restaurants`，但我需要先获取位置信息。我应该先询问用户。
【实际上，LLM会先输出一个自然语言回复，而不是直接调用工具，因为提示词要求它先询问】

[埃琳娜] 你好！我是埃琳娜，你的餐饮助手。为了帮你找到附近的美食，请告诉我你现在的位置（例如哪个城市或区域）？另外，你有什么饮食偏好吗，比如想吃中餐、西餐还是素食？

[用户] 我在北京海淀区，想吃点辣的。
----------------------------------------
> 进入新的Agent执行链...
思考：用户提供了位置（北京海淀区）和偏好（辣的）。现在我可以使用`search_restaurants`工具进行搜索了。
行动：
{
  "action": "search_restaurants",
  "action_input": {"location": "北京海淀区", "cuisine": "中餐"} # LLM可能会将“辣的”关联到“中餐”
}
[工具调用] search_restaurants: location=北京海淀区, cuisine=中餐
观察：找到以下餐厅：
- ID:1 美味中餐馆 (评分：4.5, 预计送达：30分钟)
- ID:2 快捷披萨屋 (评分：4.2, 预计送达：25分钟)
- ID:3 绿色沙拉吧 (评分：4.7, 预计送达：20分钟)

思考：我收到了三家餐厅的结果。虽然用户说想吃辣的，但我的模拟工具没有根据辣度过滤。我需要向用户展示结果并让他选择。同时，我可以提示用户中餐馆通常有辣菜。
行动：
【LLM生成回复】

[埃琳娜] 根据你的位置和偏好，我找到了三家附近的餐厅：
1. ID:1 美味中餐馆 (评分：4.5, 预计30分钟送达)
2. ID:2 快捷披萨屋 (评分：4.2, 预计25分钟送达) - 有些披萨也可以是辣的哦。
3. ID:3 绿色沙拉吧 (评分：4.7, 预计20分钟送达) - 辣味沙拉选项可能较少。

请告诉我你选择哪一家餐厅的ID（例如：1）？

[用户] 选第一家吧，我想吃水煮鱼和米饭。
----------------------------------------
> 进入新的Agent执行链...
思考：用户选择了ID为1的“美味中餐馆”，并指定了菜品“水煮鱼”和“米饭”。现在我需要使用`order_food`工具来下单。
行动：
{
  "action": "order_food",
  "action_input": {"restaurant_id": 1, "items": ["水煮鱼", "米饭"]}
}
[工具调用] order_food: restaurant_id=1, items=['水煮鱼', '米饭']
观察：下单成功！订单号：ORD0012。餐厅已接单，正在准备中。

思考：订单已成功下达，并生成了订单号。我应该将这个好消息和订单号告知用户。
行动：
【LLM生成回复】

[埃琳娜] 太好了！我已经在“美味中餐馆”为你下单了“水煮鱼”和“米饭”。你的订单号是：ORD0012。餐厅已确认接单，正在准备中，预计30分钟左右送达。请耐心等待！

=== 对话结束 ===

效果验证： 通过 verbose=True 的输出，我们可以清晰地看到Agent的“思考链”：

1. 理解目标 ：识别出“饿了”需要食物。
2. 信息收集 ：主动询问位置和偏好（遵循提示词规则）。
3. 工具选择与调用 ：在获得足够信息后，正确选择了 search_restaurants 工具。
4. 结果分析与决策 ：解析工具返回的餐厅列表，并生成用户友好的选择提示。
5. 二次工具调用 ：根据用户选择，正确调用 order_food 工具并传入正确参数。
6. 任务完成与反馈 ：将工具执行结果（订单号）整合成自然语言回复给用户。

至此，我们成功构建了一个能理解复杂意图、自主规划并调用工具完成任务的AI Agent。

7. 常见问题与排查思路

在实际开发中，你可能会遇到以下典型问题：

问题现象	可能原因	排查方式	解决方案
Agent不调用工具，总是用文字回复	1. 提示词（System Message）未明确要求使用工具。 2. 工具的描述（Docstring）不够清晰，LLM无法理解。 3. LLM的 temperature 参数过高，导致输出随机性大。	1. 检查 verbose 输出，看LLM的“思考”部分是否提及工具。 2. 仔细阅读工具函数的文档字符串，确保输入输出描述清晰。	1. 强化提示词，明确指令如“你必须使用提供的工具来解决问题”。 2. 重写工具描述，模仿OpenAI官方函数的格式。 3. 将 temperature 设为0或一个较低的值（如0.1）。
工具调用参数错误或格式不对	1. LLM未能正确解析用户输入以匹配工具参数。 2. 工具参数类型定义（如 List[str] ）让LLM困惑。	查看 verbose 输出中 action_input 的具体内容，是否与工具期望的参数结构一致。	1. 在提示词中提供更具体的例子，教LLM如何提取参数。 2. 考虑使用更简单的参数类型（如用 str 代替 List[str] ，在工具内部再分割）。 3. 使用LangChain的 StructuredTool 或Pydantic模型来定义更严格的参数模式。
Agent陷入无限循环或重复调用同一工具	1. 工具返回的结果未能让LLM推进到下一步。 2. 缺少明确的终止条件或最大迭代次数限制。	观察循环中LLM的“思考”和“观察”内容，看是否逻辑卡住。	1. 在提示词中增加对工具输出结果的解释指导。 2. 务必设置 max_iterations 参数 （如 max_iterations=5 ）。 3. 设计工具时，确保其输出能明确导向下一步行动或终止。
API密钥错误或网络问题	1. .env 文件未正确加载或变量名错误。 2. 网络连接问题或API服务不可用。	1. 在代码开头打印 os.getenv(‘OPENAI_API_KEY’) 的前几位，确认已加载。 2. 尝试用 requests 直接调用API端点测试连通性。	1. 检查 .env 文件路径和变量名拼写。 2. 检查防火墙或网络代理设置。 3. 确认OpenAI账户余额或配额。
ModuleNotFoundError: No module named ‘langchain_...’	依赖包未正确安装。	运行 `pip list	grep langchain` 检查已安装的包。

8. 最佳实践与工程建议

将原型Agent投入生产环境或复杂项目时，请考虑以下建议：

1. 工具设计的原子性与安全性 ：

   • 原子性 ：每个工具应只完成一件明确、独立的事情。避免创建“超级工具”。例如，将“搜索并下单”拆分成 search_restaurants 和 order_food 两个工具。
   • 安全性 ：对于执行写操作（如下单、发送邮件、修改数据库）的工具，必须内置权限验证和确认机制。例如， order_food 工具可以在真正调用API前，先向用户口头确认订单详情。

2. 提示词工程迭代 ：

   • 提示词是Agent的“操作系统”，需要反复调试。将长的System Message拆分成角色定义、工具描述、行动规则、输出格式等模块，便于管理。
   • 使用 LangSmith 或 Weights & Biases 等工具来跟踪、评估和比较不同提示词下Agent的表现。

3. 记忆（Memory）管理 ：

   • ConversationBufferMemory 适用于短对话，长对话会导致上下文窗口爆炸。对于长对话，考虑使用 ConversationSummaryMemory （总结历史）或 ConversationBufferWindowMemory （只保留最近N轮）。
   • 敏感信息（如地址、电话）不应长期存储在记忆里，需定期清理或做脱敏处理。

4. 错误处理与鲁棒性 ：

   • 用 try...except 包裹工具调用，并提供友好的错误信息返回给LLM，使其能调整策略。
   • 在 AgentExecutor 中设置 handle_parsing_errors=True 可以捕获LLM输出不符合工具调用格式的错误，并让LLM重试。

5. 性能与成本优化 ：

   • 为工具调用添加缓存层，避免对相同参数的重复查询（如天气、餐厅列表）。
   • 使用更便宜的模型（如 gpt-3.5-turbo ）进行简单任务，仅在需要复杂推理时切换至 gpt-4 。
   • 监控Token使用量，特别是长记忆和复杂提示词带来的消耗。

6. 测试与评估 ：

   • 为你的Agent构建一个测试集，包含各种典型和边缘的用户query。
   • 定义清晰的评估指标：任务完成率、工具调用准确率、平均对话轮次、用户满意度（模拟）。
   • 自动化测试流程，确保每次更新提示词或工具后，核心功能依然稳定。

回到我们最初的标题“当埃琳娜饿了，但我不会做饭的时候……”，我们通过一个具体的项目，揭示了现代AI Agent开发的核心： 将大语言模型的推理规划能力与外部工具的执行能力相结合 。这不再是科幻概念，而是用LangChain等框架可以快速上手的工程实践。

你构建的Agent，其价值边界完全由你赋予它的工具集决定。从点外卖到订机票，从分析数据到操控软件，只要你能将需求封装成清晰的工具函数，Agent就能成为替你执行复杂任务的数字助手。下一步，你可以尝试接入真实的API（如各大外卖平台、地图服务），引入向量数据库作为知识库来回答餐厅详情，甚至将多个Agent组合起来完成更宏大的任务。