1. 什么是 AI Agent

AI Agent（智能体）是一种能够感知环境、进行决策并执行动作的智能系统。与传统的大语言模型（LLM）不同，AI Agent 不仅仅是一个被动的文本生成器，而是一个能够自主规划、调用工具、与环境交互并完成复杂任务的主动执行者。

简单来说，LLM 回答“怎么做”，而 AI Agent 真正去“做”。它通过循环机制不断观察结果、调整策略，直到完成任务目标。

2. AI Agent 的核心组成

一个完整的 AI Agent 通常由以下核心模块组成：

• 大语言模型（LLM）：作为“大脑”，负责理解任务、推理决策和生成输出。
• 规划（Planning）：将复杂任务拆解为可执行的子步骤，并制定执行顺序。
• 记忆（Memory）：保存对话历史、中间结果和长期知识，分为短期记忆和长期记忆。
• 工具调用（Tools）：通过 API、函数或外部服务与环境交互，扩展能力边界。
• 行动与反馈循环（Action & Feedback Loop）：执行动作、观察结果、评估进展并迭代调整。

3. Agent 的工作流程

AI Agent 的核心工作流程可以概括为以下循环：

1. 接收任务：理解用户的目标和约束条件。
2. 规划拆解：将任务分解为多个子任务，并确定执行顺序。
3. 调用工具：根据子任务需求选择合适的工具并执行。
4. 观察结果：获取工具返回的结果，判断是否达到预期。
5. 迭代调整：如果结果不理想，调整策略重新执行；如果完成，则汇总输出。

这个循环会持续进行，直到任务完成或达到最大迭代次数。下面用一张流程图来直观展示：

flowchart TD
    A[接收任务] --> B[规划拆解]
    B --> C[调用工具]
    C --> D[观察结果]
    D --> E{任务完成?}
    E -- 否 --> B
    E -- 是 --> F[汇总输出]

4. 代码实战：构建一个简单的 AI Agent

下面我们使用 Python 和 OpenAI API 构建一个简单的 AI Agent，让它具备调用外部工具的能力。这个 Agent 可以查询天气和计算数学表达式。

4.1 环境准备

首先安装必要的依赖：

pip install openai python-dotenv

然后在项目根目录创建 .env 文件，填入你的 API Key：

OPENAI_API_KEY=your_api_key_here

4.2 定义工具函数

我们先定义两个简单的工具函数，模拟天气查询和数学计算：

import json
import math
def get_weather(city: str) -> str:
"""模拟查询城市天气"""
weather_data = {
"北京": "晴，25°C",
"上海": "多云，28°C",
"广州": "小雨，30°C"
}
return weather_data.get(city, f"暂无 {city} 的天气数据")
def calculate(expression: str) -> str:
"""计算数学表达式"""
try:
# 安全地计算数学表达式
result = eval(expression, {"builtins": {}}, {"math": math})
return str(result)
except Exception as e:
return f"计算错误: {str(e)}"

4.3 定义工具描述

为了让 LLM 知道有哪些工具可用，我们需要以 JSON Schema 的形式描述工具：

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "查询指定城市的当前天气",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "城市名称，如北京、上海"
                    }
                },
                "required": ["city"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "calculate",
            "description": "计算数学表达式，如 2+3*4",
            "parameters": {
                "type": "object",
                "properties": {
                    "expression": {
                        "type": "string",
                        "description": "数学表达式字符串"
                    }
                },
                "required": ["expression"]
            }
        }
    }
]

4.4 实现 Agent 主循环

接下来实现 Agent 的核心循环逻辑：

import os
from openai import OpenAI
from dotenv import load_dotenv
load_dotenv()
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
工具映射表
tool_map = {
"get_weather": get_weather,
"calculate": calculate
}
def run_agent(user_input: str, max_iterations: int = 5):
"""运行 Agent 主循环"""
messages = [{"role": "user", "content": user_input}]
for _ in range(max_iterations):
    # 调用 LLM，传入工具定义
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=messages,
        tools=tools,
        tool_choice="auto"
    )
message = response.choices[0].message
messages.append(message)
如果模型没有要求调用工具，说明任务完成
if not message.tool_calls:
return message.content
执行工具调用
for tool_call in message.tool_calls:
function_name = tool_call.function.name
arguments = json.loads(tool_call.function.arguments)
print(f"调用工具: {function_name}({arguments})")
执行对应工具函数
result = tool_mapfunction_name
将工具结果返回给模型
messages.append({
"role": "tool",
"tool_call_id": tool_call.id,
"content": result
})
return "达到最大迭代次数，任务未完成"</code></pre>
4.5 测试 Agent
现在我们来测试这个 Agent：
if name == "main":
测试天气查询
result1 = run_agent("北京今天天气怎么样？")
print("结果1:", result1)
print("---")
测试数学计算
result2 = run_agent("请计算 (15+3)*2 的结果")
print("结果2:", result2)
print("---")
测试多步任务
result3 = run_agent("先查一下上海的天气，然后计算 100/4 的结果")
print("结果3:", result3)</code></pre>
运行上述代码，你会看到 Agent 自动判断需要调用哪个工具、传入什么参数，并根据工具返回结果继续推理，最终给出完整回答。
5. 进阶：使用 LangChain 构建 Agent
LangChain 提供了更高级的 Agent 框架，内置了记忆管理、多工具编排和多种 Agent 类型。下面演示如何使用 LangChain 快速构建 Agent。
5.1 安装依赖
pip install langchain langchain-openai
5.2 构建 LangChain Agent
from langchain_openai import ChatOpenAI
from langchain.agents import create_tool_calling_agent, AgentExecutor
from langchain.tools import tool
from langchain_core.prompts import ChatPromptTemplate
@tool
def get_weather(city: str) -> str:
"""查询指定城市的当前天气"""
weather_data = {
"北京": "晴，25°C",
"上海": "多云，28°C",
"广州": "小雨，30°C"
}
return weather_data.get(city, f"暂无 {city} 的天气数据")
@tool
def calculate(expression: str) -> str:
"""计算数学表达式，如 2+34"""
try:
result = eval(expression, {"builtins": {}}, {})
return str(result)
except Exception as e:
return f"计算错误: {str(e)}"
初始化 LLM 和工具
llm = ChatOpenAI(model="gpt-4o", temperature=0)
tools = [get_weather, calculate]
创建提示模板
prompt = ChatPromptTemplate.from_messages([
("system", "你是一个智能助手，可以调用工具来完成任务。"),
("human", "{input}"),
("placeholder", "{agent_scratchpad}")
])
创建 Agent
agent = create_tool_calling_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
运行 Agent
result = agent_executor.invoke({"input": "北京天气怎么样？顺便计算 254 的结果"})
print(result["output"])
LangChain 封装了 Agent 的循环逻辑、工具调用解析和错误处理，让开发者可以更专注于业务逻辑。
6. Agent 的常见模式
在实际项目中，AI Agent 通常采用以下几种设计模式：
模式
特点
适用场景
ReAct 模式
推理与行动交替进行，先思考再行动
需要多步推理的复杂任务
Plan-and-Execute
先制定完整计划，再逐步执行
任务步骤明确、可预见的场景
多 Agent 协作
多个 Agent 分工协作，各司其职
复杂项目、需要角色分工的任务
反思模式
执行后自我评估并改进
需要高质量输出的创作类任务
7. 实战：多 Agent 协作系统
下面我们构建一个简单的多 Agent 协作系统，包含一个“研究员”Agent 和一个“写作助手”Agent，模拟团队协作完成一篇技术报告。
from langchain_openai import ChatOpenAI
from langchain.agents import create_tool_calling_agent, AgentExecutor
from langchain.tools import tool
from langchain_core.prompts import ChatPromptTemplate
@tool
def search_knowledge_base(query: str) -> str:
"""搜索知识库获取技术资料"""
knowledge = {
"AI Agent": "AI Agent 是能够自主感知、决策和行动的智能系统，核心包括规划、记忆和工具调用。",
"ReAct": "ReAct 模式将推理和行动交替进行，模型先思考下一步做什么，再执行动作并观察结果。",
"LangChain": "LangChain 是一个用于构建 LLM 应用的框架，提供了 Agent、Chain、Memory 等组件。"
}
return knowledge.get(query, f"知识库中未找到关于 {query} 的资料")
研究员 Agent
researcher_llm = ChatOpenAI(model="gpt-4o", temperature=0.3)
researcher_tools = [search_knowledge_base]
researcher_prompt = ChatPromptTemplate.from_messages([
("system", "你是一名资深技术研究员，擅长搜索资料并总结要点。"),
("human", "{input}"),
("placeholder", "{agent_scratchpad}")
])
researcher_agent = create_tool_calling_agent(researcher_llm, researcher_tools, researcher_prompt)
researcher_executor = AgentExecutor(
agent=researcher_agent,
tools=researcher_tools,
verbose=True,
max_iterations=3
)
写作助手 Agent
writer_llm = ChatOpenAI(model="gpt-4o", temperature=0.7)
writer_prompt = ChatPromptTemplate.from_messages([
("system", "你是一名技术写作专家，擅长将研究资料整理成结构清晰、通俗易懂的文章。"),
("human", "请根据以下研究资料撰写一篇技术文章：\n\n{research}"),
("placeholder", "{agent_scratchpad}")
])
writer_agent = create_tool_calling_agent(writer_llm, [], writer_prompt)
writer_executor = AgentExecutor(
agent=writer_agent,
tools=[],
verbose=True,
max_iterations=2
)
协作流程
def collaborative_writing(topic: str):
"""研究员先调研，写作助手再成文"""
print("=== 研究员 Agent 开始调研 ===")
research = researcher_executor.invoke({
"input": f"请调研关于 {topic} 的核心概念和技术要点"
})["output"]
print("\n=== 写作助手 Agent 开始写作 ===")
article = writer_executor.invoke({
"research": research
})["output"]
return article
if name == "main":
result = collaborative_writing("AI Agent")
print("\n=== 最终文章 ===")
print(result)
这个示例展示了多 Agent 协作的基本思路：每个 Agent 有独立的角色、工具和提示词，通过编排层将它们串联起来完成复杂任务。
8. Agent 的挑战与优化方向
尽管 AI Agent 能力强大，但在实际应用中仍面临一些挑战：
错误累积：多步执行中，早期错误会被放大，需要引入校验和回退机制。
成本控制：多次调用 LLM 会产生较高成本，需要合理设置迭代上限和缓存策略。
安全性：Agent 调用外部工具时可能产生不可控影响，需要权限控制和审计日志。
上下文管理：长任务会消耗大量上下文窗口，需要设计有效的记忆压缩策略。
针对这些挑战，常见的优化方向包括：引入反思机制让 Agent 自我纠错、使用结构化输出约束格式、设计更细粒度的工具权限、以及采用流式处理和并行执行提升效率。
9. 总结
AI Agent 是当前人工智能领域最热门的方向之一，它将大语言模型从“对话工具”升级为“自主行动体”。本文从核心组成、工作流程、代码实战到多 Agent 协作，系统性地介绍了 AI Agent 的原理与实践。
建议读者动手运行本文的代码示例，先跑通单 Agent 的工具调用，再尝试多 Agent 协作，逐步深入理解 Agent 的设计思想。随着工具生态和模型能力的持续进化，AI Agent 将在更多真实业务场景中发挥价值。