AI 智能体（Agent）完全入门指南
·
🤖 AI 智能体（Agent）完全入门指南
一、从最简单的概念开始
1.1 什么是智能体（Agent）？
用一句大白话说：智能体 = 一个能自己思考、自己决定下一步做什么的 AI 程序。
我们来做一个对比：
| 普通 ChatGPT 对话 | 智能体（Agent） | |
|---|---|---|
| 交互方式 | 你问一句，它答一句 | 你给一个目标，它自己拆解、执行 |
| 能否使用工具 | ❌ 不能（纯文本） | ✅ 能搜索、写代码、调API |
| 有没有记忆 | 仅当前对话 | 可以有长期记忆 |
| 能否自主决策 | ❌ 被动回答 | ✅ 主动规划下一步 |
1.2 一个生活化的比喻 🍳
想象你请了一个私人管家：
你说："帮我安排一次周末北京两日游" 管家的思考过程： 1. 🤔 思考：需要查天气、查景点、查酒店、查交通 2. 🔍 行动：先查周末北京天气 → 晴天 25°C 3. 🤔 思考：天气不错，适合户外景点 4. 🔍 行动：搜索热门户外景点 → 故宫、颐和园... 5. 🤔 思考：需要订酒店 6. 🔍 行动：在平台上搜索并预订酒店 7. 📋 输出：完整的两日游行程单
这个管家，就是一个 Agent！
二、智能体的核心架构 🧠
2.1 Agent 的四大核心组件
┌─────────────────────────────────────────────┐ │ Agent 智能体 │ │ │ │ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ │ │ 🧠 大脑 │ │ 🛠️ 技能 │ │ 💾 记忆 │ │ │ │ (LLM) │ │(Skills) │ │(Memory) │ │ │ └────┬────┘ └────┬────┘ └────┬────┘ │ │ │ │ │ │ │ └────────┬───┘────────────┘ │ │ │ │ │ ┌──────▼──────┐ │ │ │ 📋 规划能力 │ │ │ │ (Planning) │ │ │ └─────────────┘ │ └─────────────────────────────────────────────┘
| 组件 | 作用 | 类比 |
|---|---|---|
| 🧠 LLM（大脑） | 理解、推理、决策 | 管家的大脑 |
| 🛠️ Skills/Tools（技能/工具） | 执行具体操作 | 管家会用的各种工具 |
| 💾 Memory（记忆） | 记住历史信息 | 管家的笔记本 |
| 📋 Planning（规划） | 拆解任务、制定计划 | 管家的规划能力 |
三、Skills（技能）详解 🛠️
3.1 什么是 Skill？
Skill = Agent 能调用的一个具体能力/工具
就像一个人可以有很多技能：会做饭、会开车、会写代码。Agent 的 Skill 就是它能做的具体事情。
3.2 常见的 Skill 类型
# 伪代码展示 Skill 的概念 # Skill 1: 搜索引擎 def web_search(query: str) -> str: """在互联网上搜索信息""" return search_engine.search(query) # Skill 2: 执行代码 def run_code(code: str) -> str: """执行 Python 代码并返回结果""" return execute(code) # Skill 3: 读写文件 def read_file(path: str) -> str: """读取文件内容""" return open(path).read() # Skill 4: 发送邮件 def send_email(to: str, subject: str, body: str) -> bool: """发送邮件""" return email_client.send(to, subject, body) # Skill 5: 数据库查询 def query_database(sql: str) -> list: """执行 SQL 查询""" return db.execute(sql)
3.3 Skill 是怎么被调用的？
这就是著名的 ReAct（Reasoning + Acting） 模式：
用户: "帮我查一下特斯拉今天的股价，然后算一下如果买100股要多少钱"
Agent 思考过程:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🤔 Thought 1: 我需要先查特斯拉的股价
🔧 Action 1: web_search("特斯拉 今日股价")
📊 Result 1: 特斯拉(TSLA) 当前股价: $248.50
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🤔 Thought 2: 股价是 $248.50，我需要计算 100 股的总价
🔧 Action 2: run_code("print(248.50 * 100)")
📊 Result 2: 24850.0
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
🤔 Thought 3: 我已经有了所有信息，可以回答了
💬 Answer: 特斯拉今日股价 $248.50，买100股需要 $24,850。
四、Function Calling —— Skill 的底层机制 📞
4.1 LLM 是怎么知道该调用什么工具的？
核心机制叫 Function Calling。我们告诉 LLM 有哪些工具可用，LLM 自己决定调不调、怎么调。
import openai
# 第一步：定义你的工具（Skills）
tools = [
{
"type": "function",
"function": {
"name": "get_weather", # 工具名称
"description": "查询某个城市的天气", # 描述（LLM靠这个理解工具用途）
"parameters": {
"type": "object",
"properties": {
"city": {
"type": "string",
"description": "城市名称，如：北京"
}
},
"required": ["city"]
}
}
}
]
# 第二步：把工具列表一起发给 LLM
response = openai.chat.completions.create(
model="gpt-4",
messages=[{"role": "user", "content": "北京今天天气怎么样？"}],
tools=tools # 告诉LLM你有这些工具
)
# 第三步：LLM 会返回它想调用的函数和参数
# response 类似:
# {
# "tool_calls": [{
# "function": {
# "name": "get_weather",
# "arguments": '{"city": "北京"}'
# }
# }]
# }
# 第四步：你在代码里真正执行这个函数，把结果返回给 LLM
# 第五步：LLM 根据结果生成最终回答
流程图：
用户提问 ──→ LLM + 工具描述 ──→ LLM决定调用哪个工具 │ ▼ 最终回答 ◀── LLM整合结果 ◀── 你的代码执行工具并返回结果
五、记忆系统（Memory）💾
5.1 三种记忆类型
┌─────────────────────────────────────────────────────┐ │ 记忆系统 │ │ │ │ 📝 短期记忆 💿 长期记忆 🔗 工作记忆 │ │ (Short-term) (Long-term) (Working) │ │ │ │ 当前对话的 跨对话持久化的 当前任务正在 │ │ 上下文信息 知识和经验 处理的信息 │ │ │ │ 实现：对话历史 实现：向量数据库 实现：暂存区 │ │ 如 message list 如 ChromaDB 如 scratchpad │ └─────────────────────────────────────────────────────┘
5.2 简单示例
# 短期记忆：就是对话历史
short_term_memory = [
{"role": "user", "content": "我叫小明"},
{"role": "assistant", "content": "你好小明！"},
{"role": "user", "content": "我刚才说我叫什么？"},
# Agent 可以回看上面的对话 → "你叫小明"
]
# 长期记忆：通常用向量数据库存储
# 比如用户上个月说过 "我喜欢吃川菜"
# Agent 下次推荐餐厅时可以检索到这个偏好
六、规划能力（Planning）📋
6.1 常见的规划策略
┌──────────────────────────────────────────────┐ │ 规划策略 │ ├──────────────────────────────────────────────┤ │ │ │ 1️⃣ ReAct（边想边做） │ │ 思考 → 行动 → 观察 → 思考 → 行动 → ... │ │ 特点：一步一步来，灵活应变 │ │ │ │ 2️⃣ Plan-and-Execute（先规划后执行） │ │ 先列出完整计划 → 逐步执行 → 必要时调整 │ │ 特点：有全局视野，适合复杂任务 │ │ │ │ 3️⃣ Reflexion（反思型） │ │ 执行 → 检查结果 → 反思不足 → 改进重试 │ │ 特点：能从错误中学习 │ │ │ └──────────────────────────────────────────────┘
七、主流框架详解 🏗️
现在进入重点——主流框架！我按从简单到复杂的顺序介绍。
7.1 🦜 LangChain — 最经典的入门框架
定位：AI 应用开发的"瑞士军刀"，功能最全面
核心概念图：
LangChain 生态 ├── 🔗 Chains（链） —— 把多个步骤串起来 ├── 🤖 Agents（智能体） —— 让 LLM 自主决策调用工具 ├── 🛠️ Tools（工具） —— 搜索、计算、API调用等 ├── 💾 Memory（记忆） —— 对话历史、长期记忆 ├── 📄 Retrievers（检索器）—— RAG 检索增强生成 └── 📤 Output Parsers —— 结构化输出
入门示例：创建一个能搜索的 Agent
# pip install langchain langchain-openai langchain-community
from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_tool_calling_agent
from langchain_core.prompts import ChatPromptTemplate
from langchain_community.tools import DuckDuckGoSearchRun
# 1. 准备 LLM
llm = ChatOpenAI(model="gpt-4", temperature=0)
# 2. 准备工具
search = DuckDuckGoSearchRun()
tools = [search]
# 3. 准备提示词
prompt = ChatPromptTemplate.from_messages([
("system", "你是一个有用的助手，可以搜索互联网获取信息。"),
("human", "{input}"),
("placeholder", "{agent_scratchpad}") # Agent 的工作记忆
])
# 4. 创建 Agent
agent = create_tool_calling_agent(llm, tools, prompt)
# 5. 创建执行器（负责循环执行 思考→行动→观察）
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
# 6. 运行！
result = agent_executor.invoke({"input": "2024年诺贝尔物理学奖颁给了谁？"})
print(result["output"])
运行效果（verbose=True 能看到思考过程）：
> Entering new AgentExecutor chain... Thought: 我需要搜索一下这个信息 Action: duckduckgo_search Action Input: "2024 Nobel Prize Physics winner" Observation: The 2024 Nobel Prize in Physics was awarded to John Hopfield and Geoffrey Hinton... Thought: 我现在知道答案了 Final Answer: 2024年诺贝尔物理学奖授予了 John Hopfield 和 Geoffrey Hinton， 以表彰他们在机器学习领域的基础性发现... > Finished chain.
LangChain 优缺点：
| ✅ 优点 | ❌ 缺点 |
|---|---|
| 生态最丰富，集成最多 | 抽象层过多，代码有时很绕 |
| 文档全面，社区活跃 | 版本更新快，API经常变 |
| 适合快速原型 | 复杂场景下调试困难 |
7.2 🧩 LangGraph — 复杂工作流的利器
定位：LangChain 团队出品，用图（Graph）来编排复杂的 Agent 工作流
为什么需要 LangGraph？
简单任务 → LangChain 的线性 Chain 就够了 A → B → C → 结束 复杂任务 → 需要循环、分支、并行、人工介入 A → B → 判断 → 成功 → D → 结束 → 失败 → C → 回到B重试 → 不确定 → 等人工确认 → ...
核心概念：
LangGraph 三要素： ├── 📍 Nodes（节点） —— 每个节点是一个处理步骤 ├── ➡️ Edges（边） —— 节点之间的连接/流转规则 └── 📦 State（状态） —— 在节点间传递的共享数据
示例：一个带"反思"能力的写作 Agent
# pip install langgraph langchain-openai
from typing import TypedDict, Annotated
from langgraph.graph import StateGraph, START, END
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="gpt-4")
# 1. 定义状态（节点间共享的数据）
class State(TypedDict):
topic: str # 写作主题
draft: str # 草稿
feedback: str # 反馈意见
final_article: str # 最终文章
revision_count: int # 修改次数
# 2. 定义节点（每个节点是一个函数）
def write_draft(state: State) -> dict:
"""写初稿"""
response = llm.invoke(f"请写一篇关于'{state['topic']}'的短文")
return {"draft": response.content, "revision_count": state.get("revision_count", 0)}
def review(state: State) -> dict:
"""审稿，给出改进建议"""
response = llm.invoke(
f"请审阅以下文章并给出具体改进建议：\n\n{state['draft']}"
)
return {"feedback": response.content}
def revise(state: State) -> dict:
"""根据反馈修改"""
response = llm.invoke(
f"原文：\n{state['draft']}\n\n修改建议：\n{state['feedback']}\n\n请修改文章"
)
return {
"draft": response.content,
"revision_count": state["revision_count"] + 1
}
def finalize(state: State) -> dict:
"""定稿"""
return {"final_article": state["draft"]}
# 3. 定义路由（判断下一步去哪）
def should_revise(state: State) -> str:
if state["revision_count"] >= 2: # 最多修改2次
return "finalize"
return "revise"
# 4. 构建图
graph = StateGraph(State)
# 添加节点
graph.add_node("write", write_draft)
graph.add_node("review", review)
graph.add_node("revise", revise)
graph.add_node("finalize", finalize)
# 添加边（流转规则）
graph.add_edge(START, "write") # 开始 → 写草稿
graph.add_edge("write", "review") # 写草稿 → 审稿
graph.add_conditional_edges( # 审稿后 → 条件判断
"review",
should_revise,
{"revise": "revise", "finalize": "finalize"}
)
graph.add_edge("revise", "review") # 修改后 → 再审稿（循环！）
graph.add_edge("finalize", END) # 定稿 → 结束
# 5. 编译并运行
app = graph.compile()
result = app.invoke({"topic": "人工智能的未来", "revision_count": 0})
print(result["final_article"])
流程可视化：
START → [写草稿] → [审稿] → 需要修改？ ──是──→ [修改] ──→ [审稿]（循环） │ 否（或已改2次） │ ▼ [定稿] → END
7.3 🚀 CrewAI — 多智能体协作框架
定位：让多个 Agent 像一个团队一样协作完成任务
核心思想：模拟一个真实团队
CrewAI 核心概念： ├── 👤 Agent（智能体） —— 团队中的每个"人"，有角色和技能 ├── 📋 Task（任务） —— 需要完成的具体工作 ├── 👥 Crew（团队） —— 一群Agent组成的团队 └── 🔄 Process（流程） —— 团队的协作方式（顺序/层级）
示例：一个"内容创作团队"
# pip install crewai crewai-tools from crewai import Agent, Task, Crew, Process from crewai_tools import SerperDevTool search_tool = SerperDevTool() # 搜索工具 # ======== 定义团队成员 ======== # 成员1：研究员 researcher = Agent( role="资深研究员", goal="深入研究给定主题，找到最新、最准确的信息", backstory="你是一位经验丰富的研究员，擅长从海量信息中提取关键洞察。", tools=[search_tool], verbose=True ) # 成员2：作家 writer = Agent( role="内容作家", goal="基于研究结果，撰写引人入胜的文章", backstory="你是一位才华横溢的作家，擅长将复杂话题写得通俗易懂。", verbose=True ) # 成员3：编辑 editor = Agent( role="总编辑", goal="审阅文章，确保质量和准确性", backstory="你是一位严格的编辑，有20年出版经验。", verbose=True ) # ======== 定义任务 ======== research_task = Task( description="研究'2024年AI Agent发展趋势'，收集关键数据和观点", expected_output="一份包含关键发现的研究报告", agent=researcher # 分配给研究员 ) writing_task = Task( description="基于研究报告，写一篇1500字的深度文章", expected_output="一篇结构清晰、内容丰富的文章", agent=writer, # 分配给作家 context=[research_task] # 依赖研究任务的输出 ) editing_task = Task( description="审阅并优化文章，确保事实准确、逻辑通顺", expected_output="最终定稿的文章", agent=editor, context=[writing_task] ) # ======== 组建团队 ======== crew = Crew( agents=[researcher, writer, editor], tasks=[research_task, writing_task, editing_task], process=Process.sequential, # 顺序执行：研究 → 写作 → 编辑 verbose=True ) # ======== 开干！ ======== result = crew.kickoff() print(result)
执行流程：
🔬 研究员开始工作... ├── 搜索 "AI Agent 2024 trends" ├── 搜索 "AI Agent frameworks comparison" └── 输出：研究报告 ✅ 📝 作家开始工作...（接收研究报告） ├── 阅读研究报告 ├── 构思文章结构 └── 输出：1500字文章 ✅ ✏️ 编辑开始工作...（接收文章） ├── 审查事实准确性 ├── 优化语言表达 └── 输出：最终定稿 ✅
7.4 📊 框架全面对比
复杂度 ──────────────────────→ 简单 复杂 单Agent: LangChain ────→ LangGraph │ 多Agent: CrewAI ─────┤ │ 企业级: AutoGen ──────┘ ┌─────────────────────────────────────────────────────┐ │ 框架 适合场景 学习曲线 Stars │ ├─────────────────────────────────────────────────────┤ │ LangChain 通用AI应用开发 ⭐⭐⭐ 95k+ │ │ LangGraph 复杂工作流/状态管理 ⭐⭐⭐⭐ 8k+ │ │ CrewAI 多Agent角色扮演协作 ⭐⭐ 25k+ │ │ AutoGen 多Agent对话/研究 ⭐⭐⭐⭐ 35k+ │ │ Dify 低代码/可视化搭建 ⭐ 55k+ │ │ Coze 零代码/快速搭建 ⭐ - │ └─────────────────────────────────────────────────────┘
7.5 🔬 AutoGen（微软）— 多智能体对话
定位：通过 Agent 之间的多轮对话来协作解决问题
# pip install autogen-agentchat
from autogen import AssistantAgent, UserProxyAgent
# 创建一个AI助手
assistant = AssistantAgent(
name="AI助手",
llm_config={"model": "gpt-4"}
)
# 创建一个代理用户（可以自动执行代码）
user_proxy = UserProxyAgent(
name="用户代理",
human_input_mode="NEVER", # 不需要人工输入
code_execution_config={"work_dir": "coding"} # 可以执行代码
)
# 发起对话 —— 两个Agent会自动来回对话直到完成
user_proxy.initiate_chat(
assistant,
message="用Python画一个2024年各季度GDP增长率的折线图"
)
# AI助手会写代码 → 用户代理自动执行 → 如果报错 → AI助手修改 → 再执行...
7.6 🎨 Dify — 低代码可视化平台
定位：不太想写代码？拖拽式搭建 Agent 和 AI 工作流
Dify 的特点： ┌─────────────────────────────────────────┐ │ 🖱️ 可视化拖拽编排工作流 │ │ 📊 内置 RAG 知识库管理 │ │ 🔌 丰富的模型接入（OpenAI/Claude/本地） │ │ 📈 内置监控和日志 │ │ 🐳 支持 Docker 私有化部署 │ └─────────────────────────────────────────┘ 适合： ✅ 快速搭建原型 ✅ 非技术人员使用 ✅ 企业内部AI应用
八、学习路线图 🗺️
阶段一：打基础（1-2周） ━━━━━━━━━━━━━━━━━━━━ 📖 理解 LLM 基本原理 📖 学会调用 OpenAI API 📖 理解 Prompt Engineering 🔨 实践：写一个简单的对话机器人 阶段二：入门 Agent（2-3周） ━━━━━━━━━━━━━━━━━━━━━━━ 📖 理解 Function Calling 📖 理解 ReAct 模式 📖 学习 LangChain 基础 🔨 实践：做一个能搜索+计算的 Agent 阶段三：进阶（3-4周） ━━━━━━━━━━━━━━━━━━━━ 📖 学习 LangGraph 构建复杂工作流 📖 学习 RAG（检索增强生成） 📖 理解记忆系统 🔨 实践：做一个能查询知识库的客服 Agent 阶段四：高级（4-6周） ━━━━━━━━━━━━━━━━━━━━ 📖 学习多 Agent 协作（CrewAI / AutoGen） 📖 学习 Agent 评估和优化 📖 学习部署和监控 🔨 实践：做一个多Agent协作的完整项目
九、一个完整的实战示例 🎯
最后，我们用最少的代码做一个"个人研究助手"：
"""
个人研究助手 Agent
功能：搜索信息 + 执行代码 + 综合分析
"""
from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_tool_calling_agent
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_community.tools import DuckDuckGoSearchRun
from langchain_core.tools import tool
from langchain.memory import ConversationBufferMemory
# ====== 1. 定义工具/技能 ======
@tool
def calculate(expression: str) -> str:
"""计算数学表达式。输入一个Python数学表达式字符串。"""
try:
result = eval(expression) # 生产环境请用安全的沙箱
return str(result)
except Exception as e:
return f"计算错误: {e}"
@tool
def search_web(query: str) -> str:
"""在互联网上搜索信息。输入搜索关键词。"""
search = DuckDuckGoSearchRun()
return search.run(query)
tools = [calculate, search_web]
# ====== 2. 设置 LLM ======
llm = ChatOpenAI(model="gpt-4", temperature=0)
# ====== 3. 设置记忆 ======
memory = ConversationBufferMemory(
memory_key="chat_history",
return_messages=True
)
# ====== 4. 设置提示词 ======
prompt = ChatPromptTemplate.from_messages([
("system", """你是一个专业的研究助手。你可以：
1. 搜索互联网获取最新信息
2. 进行数学计算
请用中文回答，条理清晰，注明信息来源。"""),
MessagesPlaceholder(variable_name="chat_history"),
("human", "{input}"),
MessagesPlaceholder(variable_name="agent_scratchpad"),
])
# ====== 5. 组装 Agent ======
agent = create_tool_calling_agent(llm, tools, prompt)
agent_executor = AgentExecutor(
agent=agent,
tools=tools,
memory=memory,
verbose=True, # 显示思考过程
max_iterations=5 # 最多执行5轮
)
# ====== 6. 交互式对话 ======
print("🤖 研究助手已就绪！输入 'quit' 退出。\n")
while True:
user_input = input("你: ")
if user_input.lower() == 'quit':
break
response = agent_executor.invoke({"input": user_input})
print(f"\n🤖 助手: {response['output']}\n")
十、总结 ✨
┌──────────────────────────────────────────────┐ │ 核心知识点总结 │ ├──────────────────────────────────────────────┤ │ │ │ 🤖 Agent = LLM + Tools + Memory + Planning │ │ │ │ 🛠️ Skills/Tools = Agent 能调用的具体能力 │ │ │ │ 📞 Function Calling = LLM 调用工具的机制 │ │ │ │ 🔄 ReAct = 思考→行动→观察 的循环模式 │ │ │ │ 🏗️ 框架选择： │ │ 简单任务 → LangChain │ │ 复杂流程 → LangGraph │ │ 多Agent → CrewAI / AutoGen │ │ 低代码 → Dify / Coze │ │ │ └──────────────────────────────────────────────┘
💡 最重要的建议：从最简单的 Function Calling 开始动手，然后逐步尝试各个框架。理论看再多，不如写一个能跑的 Agent 收获大。
欢迎加入 MCP 技术社区！与志同道合者携手前行，一同解锁 MCP 技术的无限可能！
更多推荐
12
0- 0
已为社区贡献1条内容
所有评论(0)