Agent智能体：大模型的"手"和"脚"
理解AI Agent的核心原理，让大模型从"对话者"进化为"行动者"。
前言
大语言模型擅长对话和生成文本，但它能做的远不止于此。**Agent（智能体）**赋予了大模型"行动"的能力------它可以搜索网络、调用API、执行代码、操作软件。
今天，我们来探索AI Agent的奥秘，看看大模型如何获得"手"和"脚"。
一、什么是AI Agent？
从LLM到Agent的进化
arduino
LLM（大语言模型）
│
│ 能力：理解语言、生成文本、推理
│ 局限：只能输出文本，无法与外界交互
↓
Agent（智能体）
│
│ 能力：感知环境、规划任务、执行工具、记忆反思
│ 突破：可以"行动"，与环境交互
↓
自主完成任务Agent的核心组成
scss
┌─────────────────────────────────────────────────────────────┐
│ Agent架构 │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────┐ │
│ │ 大脑(LLM) │ │
│ │ 理解、规划 │ │
│ └──────┬──────┘ │
│ │ │
│ ┌──────────────┼──────────────┐ │
│ ↓ ↓ ↓ │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ 感知 │ │ 记忆 │ │ 工具 │ │
│ │ Perception│ │ Memory │ │ Tools │ │
│ └──────────┘ └──────────┘ └──────────┘ │
│ ↑ ↑ ↑ │
│ │ │ │ │
│ ┌────┴────┐ ┌────┴────┐ ┌────┴────┐ │
│ │用户输入 │ │对话历史 │ │API调用 │ │
│ │环境状态 │ │知识库 │ │代码执行 │ │
│ │工具输出 │ │长期记忆 │ │网络搜索 │ │
│ └─────────┘ └─────────┘ └─────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘Agent vs LLM对比
| 维度 | LLM | Agent |
|---|---|---|
| 输出 | 仅文本 | 文本+行动 |
| 能力边界 | 知识截止 | 可访问实时信息 |
| 任务执行 | 单轮对话 | 多步规划执行 |
| 工具使用 | 无 | 可调用多种工具 |
| 自主性 | 被动响应 | 主动规划执行 |
二、Agent的工作原理
ReAct框架
ReAct（Reasoning + Acting）是最经典的Agent框架：
python
# ReAct工作循环
"""
思考 (Thought)：分析当前状态，决定下一步
行动 (Action)：选择工具并执行
观察 (Observation)：获取执行结果
...循环...
"""
def react_loop(agent, query, max_iterations=10):
"""ReAct循环"""
history = []
for i in range(max_iterations):
# 1. 思考
thought = agent.think(query, history)
history.append({"type": "thought", "content": thought})
# 判断是否完成
if "最终答案：" in thought or "任务完成" in thought:
break
# 2. 决定行动
action = agent.decide_action(thought)
history.append({"type": "action", "content": action})
# 3. 执行行动
observation = agent.execute(action)
history.append({"type": "observation", "content": observation})
return agent.extract_answer(history)完整示例
python
import openai
import json
class ReActAgent:
def __init__(self, tools):
self.tools = tools
self.llm = openai.ChatCompletion
def run(self, query):
"""执行ReAct循环"""
messages = [
{"role": "system", "content": self._build_system_prompt()},
{"role": "user", "content": query}
]
for _ in range(10): # 最多10轮
response = self.llm.create(
model="gpt-4",
messages=messages
)
assistant_message = response.choices[0].message.content
messages.append({"role": "assistant", "content": assistant_message})
# 解析行动
action = self._parse_action(assistant_message)
if action is None:
# 没有行动，说明已经完成
return assistant_message
# 执行工具
observation = self._execute_tool(action)
# 添加观察结果
messages.append({
"role": "user",
"content": f"观察结果: {observation}"
})
return "达到最大迭代次数"
def _build_system_prompt(self):
tools_desc = "\n".join([
f"- {name}: {desc}"
for name, desc in self.tools.items()
])
return f"""你是一个能够使用工具的智能助手。
可用工具：
{tools_desc}
请按以下格式思考和行动：
思考: [分析问题，决定下一步]
行动: [工具名称]
行动输入: [工具参数]
观察结果: [系统返回]
... (重复思考-行动-观察)
思考: 我现在知道答案了
最终答案: [回答用户问题]"""
def _parse_action(self, message):
"""解析行动"""
if "行动:" not in message:
return None
lines = message.split('\n')
action_line = [l for l in lines if l.startswith("行动:")][0]
input_line = [l for l in lines if l.startswith("行动输入:")][0]
return {
"tool": action_line.replace("行动:", "").strip(),
"input": input_line.replace("行动输入:", "").strip()
}
def _execute_tool(self, action):
"""执行工具"""
tool_name = action["tool"]
tool_input = action["input"]
if tool_name in self.tools:
return self.tools[tool_name]["function"](tool_input)
return f"未知工具: {tool_name}"
# 定义工具
tools = {
"搜索": {
"description": "搜索网络获取信息",
"function": lambda q: f"搜索结果：{q}的相关信息..."
},
"计算器": {
"description": "执行数学计算",
"function": lambda expr: str(eval(expr))
},
"天气": {
"description": "查询城市天气",
"function": lambda city: f"{city}今天晴天，温度15-25°C"
}
}
# 创建并运行Agent
agent = ReActAgent(tools)
result = agent.run("北京今天的天气适合户外运动吗？")
print(result)三、工具系统
工具定义
python
from typing import Callable, Dict, Any
from pydantic import BaseModel
class Tool(BaseModel):
"""工具定义"""
name: str
description: str
parameters: Dict[str, Any] # JSON Schema
function: Callable
class Config:
arbitrary_types_allowed = True
# 工具示例
search_tool = Tool(
name="web_search",
description="搜索网络获取最新信息。适用于需要实时信息或超出模型知识范围的问题。",
parameters={
"type": "object",
"properties": {
"query": {
"type": "string",
"description": "搜索关键词"
}
},
"required": ["query"]
},
function=lambda query: f"搜索结果: {query}"
)
calculator_tool = Tool(
name="calculator",
description="执行数学计算。支持加减乘除、幂运算等。",
parameters={
"type": "object",
"properties": {
"expression": {
"type": "string",
"description": "数学表达式，如 '2+3*4'"
}
},
"required": ["expression"]
},
function=lambda expr: str(eval(expr))
)工具调用
python
def function_calling_example():
"""OpenAI Function Calling示例"""
import openai
# 定义工具（OpenAI格式）
tools = [
{
"type": "function",
"function": {
"name": "get_weather",
"description": "获取指定城市的天气信息",
"parameters": {
"type": "object",
"properties": {
"city": {
"type": "string",
"description": "城市名称"
}
},
"required": ["city"]
}
}
}
]
# 发送请求
response = openai.ChatCompletion.create(
model="gpt-4",
messages=[
{"role": "user", "content": "北京今天天气怎么样？"}
],
tools=tools
)
# 检查是否需要调用工具
message = response.choices[0].message
if message.tool_calls:
for tool_call in message.tool_calls:
function_name = tool_call.function.name
arguments = json.loads(tool_call.function.arguments)
# 执行工具
if function_name == "get_weather":
result = get_weather(arguments["city"])
print(f"工具调用: {function_name}({arguments})")
print(f"结果: {result}")四、记忆系统
记忆类型
kotlin
Agent记忆系统：
短期记忆（Working Memory）
├── 当前对话上下文
├── 最近几轮交互
└── 容量有限，实时更新
长期记忆（Long-term Memory）
├── 向量数据库存储
├── 支持语义检索
└── 容量大，持久化
工作记忆（Episodic Memory）
├── 任务执行历史
├── 成功/失败经验
└── 用于反思和改进记忆实现
python
from typing import List
import numpy as np
class AgentMemory:
"""Agent记忆系统"""
def __init__(self, max_short_term=10):
self.short_term = [] # 短期记忆（对话历史）
self.long_term = [] # 长期记忆（向量存储）
self.max_short_term = max_short_term
def add_to_short_term(self, message: str):
"""添加到短期记忆"""
self.short_term.append(message)
# 保持固定大小
if len(self.short_term) > self.max_short_term:
self.short_term.pop(0)
def add_to_long_term(self, memory: str, embedding: np.ndarray):
"""添加到长期记忆"""
self.long_term.append({
"content": memory,
"embedding": embedding
})
def retrieve_relevant(self, query_embedding: np.ndarray, k: int = 3):
"""检索相关记忆"""
if not self.long_term:
return []
# 计算相似度
similarities = [
np.dot(query_embedding, m["embedding"])
for m in self.long_term
]
# 获取top-k
top_indices = np.argsort(similarities)[-k:][::-1]
return [self.long_term[i]["content"] for i in top_indices]
def get_context(self):
"""获取当前上下文"""
return "\n".join(self.short_term)五、规划系统
任务分解
python
class TaskPlanner:
"""任务规划器"""
def plan(self, goal: str) -> List[str]:
"""将目标分解为子任务"""
prompt = f"""请将以下目标分解为具体的执行步骤：
目标：{goal}
要求：
1. 每个步骤是一个明确的行动
2. 步骤之间有逻辑顺序
3. 步骤数量适中（3-7步）
步骤列表："""
response = self.llm(prompt)
steps = self._parse_steps(response)
return steps
def _parse_steps(self, text: str) -> List[str]:
"""解析步骤"""
steps = []
for line in text.split('\n'):
line = line.strip()
if line and (line[0].isdigit() or line.startswith('-')):
# 移除编号
step = line.lstrip('0123456789.- ')
if step:
steps.append(step)
return steps
# 示例
planner = TaskPlanner()
steps = planner.plan("帮我研究2024年AI行业的发展趋势并写一份报告")
# 输出:
# 1. 搜索2024年AI行业重大事件和趋势
# 2. 整理关键技术突破和应用案例
# 3. 分析市场规模和投资情况
# 4. 总结发展趋势和未来预测
# 5. 撰写研究报告执行监控
python
class ExecutionMonitor:
"""执行监控器"""
def __init__(self):
self.task_status = {}
def start_task(self, task_id: str, description: str):
"""开始任务"""
self.task_status[task_id] = {
"description": description,
"status": "running",
"start_time": time.time(),
"attempts": 0
}
def complete_task(self, task_id: str, result: str):
"""完成任务"""
self.task_status[task_id]["status"] = "completed"
self.task_status[task_id]["result"] = result
self.task_status[task_id]["end_time"] = time.time()
def fail_task(self, task_id: str, error: str):
"""任务失败"""
self.task_status[task_id]["status"] = "failed"
self.task_status[task_id]["error"] = error
self.task_status[task_id]["attempts"] += 1
def should_retry(self, task_id: str, max_attempts: int = 3):
"""判断是否重试"""
task = self.task_status.get(task_id)
if not task:
return False
return task["attempts"] < max_attempts六、主流Agent框架
框架对比
| 框架 | 特点 | 适用场景 |
|---|---|---|
| LangChain | 生态丰富，组件完善 | 通用Agent开发 |
| AutoGPT | 自主性强，目标驱动 | 自主任务执行 |
| CrewAI | 多Agent协作 | 团队协作任务 |
| MetaGPT | 软件开发专用 | 代码生成项目 |
| AutoGen | 多Agent对话 | 复杂协作场景 |
LangChain Agent示例
python
from langchain.agents import initialize_agent, Tool
from langchain.llms import OpenAI
# 定义工具
tools = [
Tool(
name="搜索",
func=lambda q: f"搜索结果: {q}",
description="搜索网络获取信息"
),
Tool(
name="计算器",
func=lambda expr: str(eval(expr)),
description="执行数学计算"
)
]
# 创建Agent
llm = OpenAI(temperature=0)
agent = initialize_agent(
tools,
llm,
agent="zero-shot-react-description",
verbose=True
)
# 执行任务
result = agent.run("2024年世界杯在哪里举办？那里的温度怎么样？")
print(result)AutoGPT风格Agent
python
class AutoGPTAgent:
"""AutoGPT风格的自主Agent"""
def __init__(self, goal, tools):
self.goal = goal
self.tools = tools
self.memory = []
self.tasks = []
def run(self):
"""自主运行"""
# 1. 初始规划
self.tasks = self._plan_tasks()
while self.tasks:
# 2. 选择下一个任务
current_task = self.tasks.pop(0)
# 3. 执行任务
result = self._execute_task(current_task)
# 4. 反思
reflection = self._reflect(current_task, result)
# 5. 更新计划
if reflection["need_more_tasks"]:
new_tasks = self._generate_tasks(reflection["suggestion"])
self.tasks.extend(new_tasks)
# 6. 检查目标是否达成
if self._check_goal_achieved():
break
return self._final_report()
def _reflect(self, task, result):
"""反思执行结果"""
prompt = f"""
目标: {self.goal}
当前任务: {task}
执行结果: {result}
请反思：
1. 这个任务是否成功完成？
2. 是否需要更多任务？
3. 下一步建议是什么？
"""
return self._parse_reflection(self.llm(prompt))七、多Agent协作
协作模式
markdown
多Agent协作模式：
1. 顺序协作
Agent1 → Agent2 → Agent3 → 输出
2. 并行协作
┌→ Agent1 ─┐
任务 ─┼→ Agent2 ─┼→ 合并 → 输出
└→ Agent3 ─┘
3. 层级协作
┌→ Worker1
Manager ─┼→ Worker2
└→ Worker3
4. 对话协作
Agent1 ←→ Agent2 ←→ Agent3CrewAI示例
python
from crewai import Agent, Task, Crew
# 定义Agent
researcher = Agent(
role="研究员",
goal="深入研究主题，收集全面信息",
backstory="你是一位经验丰富的研究员，擅长信息收集和分析",
allow_delegation=False
)
writer = Agent(
role="作家",
goal="基于研究结果撰写高质量文章",
backstory="你是一位专业作家，擅长将复杂信息转化为易懂的文章",
allow_delegation=True
)
editor = Agent(
role="编辑",
goal="审核和改进文章质量",
backstory="你是一位严谨的编辑，确保文章准确、清晰、有吸引力",
allow_delegation=False
)
# 定义任务
research_task = Task(
description="研究AI在教育领域的最新应用",
agent=researcher
)
write_task = Task(
description="撰写一篇关于AI教育应用的科普文章",
agent=writer
)
edit_task = Task(
description="审核文章并提供修改建议",
agent=editor
)
# 创建团队并执行
crew = Crew(
agents=[researcher, writer, editor],
tasks=[research_task, write_task, edit_task]
)
result = crew.kickoff()八、Agent应用场景
markdown
Agent典型应用：
1. 个人助理
├── 日程管理
├── 信息检索
└── 任务代办
2. 数据分析
├── 数据收集
├── 分析计算
└── 报告生成
3. 软件开发
├── 代码生成
├── 测试调试
└── 文档编写
4. 研究助手
├── 文献检索
├── 信息整理
└── 总结撰写
5. 客服机器人
├── 问题理解
├── 知识检索
└── 问题解决小结
| 组件 | 功能 | 关键技术 |
|---|---|---|
| 大脑 | 理解、规划、决策 | LLM |
| 感知 | 接收环境信息 | 多模态理解 |
| 记忆 | 存储和检索信息 | 向量数据库 |
| 工具 | 与外界交互 | Function Calling |
| 规划 | 任务分解执行 | ReAct、Planning |
思考与练习
-
思考题：
- Agent和传统软件自动化有什么区别？
- 如何设计Agent的工具集？
-
动手练习：
- 使用LangChain构建一个简单的Agent
- 实现一个能够搜索网络并总结信息的Agent
-
延伸阅读：
下期预告
下一篇文章，我们将深入探讨：用LangChain构建你的第一个AI应用
会解答这些问题：
- LangChain的核心概念是什么？
- 如何使用LangChain构建完整应用？
- 有哪些最佳实践？
关注专栏，不错过后续更新！
作者：ECH00O00 本文首发于掘金专栏《AI科普实验室》 欢迎评论区交流讨论，点赞收藏就是最大的鼓励 ❤️