一、入门：Agent 基础认知与核心概念
1.1 什么是 AI Agent
- 核心定义：AI Agent是具备“感知-决策-执行-学习”闭环能力的智能实体，其本质是由大语言模型（LLM）作为“认知核心”，联动感知模块、决策引擎、记忆系统与工具接口的“智能行动体”。与传统AI“被动响应指令”不同，它能主动理解模糊目标（如“帮我优化电商店铺运营”）、实时感知环境变化（如库存波动）、规划分步行动，并通过用户反馈或任务结果持续迭代策略，最终将抽象需求转化为具体成果。
- 关键特征：四大特征构成Agent的智能基石——①驻留性：可长期运行于服务器或终端，如工业监控Agent 7×24小时监测设备温度；②反应性：毫秒级响应外部触发，如用户发送“查快递”后立即解析订单号；③主动性：预判需求并触发行动，如会议助手提前30分钟推送会议室链接；④社会性：多Agent通过标准化协议协作，如供应链系统中“采购Agent”与“物流Agent”共享库存数据。
- 与传统程序的核心差异：传统程序依赖开发者预设的“if-else”逻辑分支，面对未编码场景（如“帮老人选易用的智能手机”）会直接失效；而Agent通过LLM的语义理解能力拆解需求，结合记忆模块存储的用户偏好（如老人视力不佳），调用电商API筛选“大字体、长续航”机型，整个过程无需硬编码所有可能性，实现“场景自适应”。
- 学习核心锚点：牢牢抓住“自主闭环”逻辑——感知模块是“五官”（获取文本、图像等信息），决策模块是“大脑”（分析信息并生成指令），执行模块是“手脚”（调用工具完成操作），记忆模块是“记事本”（存储上下文与知识）。公式“Agent = 感知 + 决策 + 执行 + 记忆”是所有开发实践的底层框架，需贯穿学习全程。
1.2 Agent 核心分类与适用场景
|
Agent类型 |
核心逻辑与技术依赖 |
适用场景与行业 |
典型案例与落地价值 |
|
简单反射Agent |
基于“关键词-行动”预设规则，无记忆能力，依赖正则表达式或简单NLP工具，开发成本极低（单人1-2天可实现），响应速度≤100ms，但仅支持固定场景。 |
高频重复、需求标准化的交互场景，如客服自动回复、APP操作引导、设备状态提醒。 |
电商平台“退款政策”自动回复（用户提“退款”即推送7天无理由规则）、快递签收短信触发（物流状态变更时发送固定模板），可降低企业80%的基础咨询成本。 |
|
基于目标的Agent |
接收明确目标后，通过LLM或规则引擎拆解为子任务序列，具备短期记忆（存储任务进度），需集成1-3种工具API，核心是“流程化执行”。 |
单目标、步骤清晰的个人或办公任务，如日程管理、会议纪要、行程预订、数据报表生成。 |
微软Outlook智能助手（目标“安排周五会议”→子任务：查参会人日程→订会议室→发邀请）、飞猪AI规划师（目标“上海3天亲子游”→子任务：订亲子酒店→选乐园门票→做行程表），提升任务完成效率40%以上。 |
|
学习型Agent |
融合监督学习（用户反馈标注）、强化学习（任务得分优化），通过历史数据训练偏好模型，依赖LLM+向量数据库，具备“越用越智能”的特性。 |
个性化需求强、需持续优化的场景，如电商推荐、内容创作、智能教育、健康管理。 |
淘宝“猜你喜欢”（根据浏览/购买记录优化推荐，点击转化率提升35%）、Grammarly写作助手（根据用户修改习惯区分“学术/邮件”场景的语法建议）、Keep健身Agent（根据运动数据调整训练计划）。 |
|
多Agent系统 |
由2个以上专业化子Agent组成，通过gRPC/JSON-RPC实现通信，有“集中式调度”（如MetaGPT的产品经理角色）或“分布式协同”两种模式，依赖框架（AutoGen/LangGraph）实现任务分配。 |
企业级复杂业务，如软件开发、供应链管理、金融风控、电商全链路运营。 |
MetaGPT开发团队（产品经理Agent写PRD→架构师Agent画流程图→开发Agent写代码→测试Agent找Bug，软件开发周期缩短50%）、京东供应链系统（采购Agent预测销量→仓储Agent调库存→物流Agent规划路线，缺货率下降22%）。 |
1.3 入门必备技术基础
- 编程语言：Python核心能力清单：AI Agent开发的“通用语言”，需重点掌握三类技能——①基础语法：字典（存储工具参数）、循环（处理多轮对话）、函数（封装工具调用），尤其要熟练用try-except捕获API调用异常；②面向对象：用类封装Agent模块（如定义`WeatherAgent`类，包含`perceive`/`decide`/`execute`方法），提升代码复用性；③生态库：requests（工具API调用）、json（解析响应数据）、datetime（处理行程日期）、pandas（简单数据统计），入门阶段无需深入机器学习库。推荐通过“天气查询Agent”实战掌握：3天内完成从用户输入解析到API调用的全流程。
- AI基础：LLM核心应用逻辑：无需啃透Transformer原理，重点掌握“LLM作为认知引擎”的使用方法——①API调用：熟悉OpenAI/Claude的`ChatCompletion`接口，理解`system`（身份定义）、`user`（用户需求）、`assistant`（历史回复）的角色分工；②Prompt工程三要素：明确身份（“你是专业电商客服，语气亲切”）、约束边界（“仅基于订单号12345回答”）、指定格式（“回复分‘问题分析’‘解决方案’两部分”）；③成本控制：简单任务用GPT-3.5-turbo（0.5美元/百万Token），复杂推理用GPT-4（10美元/百万Token），非核心模块可替换为开源模型（如Llama 3-8B，本地部署零成本）。
- 工具基础：API调用与数据存储：Agent的能力边界由工具决定，需掌握“API调用全流程”——①请求构造：用requests构造GET（查天气）/POST（提交表单）请求，设置请求头（API密钥、Content-Type）；②响应解析：从JSON结果中提取关键字段（如天气API的“temperature”），用`json.loads()`处理；③异常处理：捕获网络超时（设置`timeout=10`）、权限错误（401状态码）、数据缺失（字段为空）；④数据存储：用JSON文件存用户偏好（小量数据）、MySQL存运行日志（企业级）、Redis存短期会话（高并发场景），入门阶段先掌握JSON与MySQL基础操作。
- 入门实战：天气查询Agent开发全流程：最经典的入门项目，覆盖四大模块——①感知：接收用户输入“查上海明天天气”，用正则提取“上海”“明天”；②决策：判断需调用高德天气API，转换“明天”为具体日期（如2025-11-22）；③执行：调用API（传入城市编码110000、日期、密钥），解析返回的天气/温度；④记忆：用JSON文件存储用户查询历史（便于后续统计偏好）。核心代码需加入异常处理：用户输“火星”时提示“暂不支持”，API超时则返回“网络繁忙”，完成后可部署到Flask实现Web交互。
二、进阶：Agent 核心技术与开发实践
2.1 核心功能模块技术实现
2.1.1 感知模块：环境信息获取
- 文本感知：结构化信息提取：LLM原生支持文本理解，但直接输入易导致参数遗漏，需用“Prompt模板+格式约束”提升精度。LangChain的`PromptTemplate`是核心工具，可定义固定格式提取“槽位信息”（如时间、地点、金额），结合Few-Shot示例（给1-2个提取案例）能将准确率从70%提升至95%。实际开发中，需处理模糊表述（如“下周三”转换为具体日期），并加入参数校验（如手机号格式验证）。
from langchain.prompts import PromptTemplate
from langchain.chat_models import ChatOpenAI
import datetime
from dateutil.relativedelta import relativedelta
# 1. 定义模板（含Few-Shot示例，提升提取精度）
template = """
从用户问题中提取【城市】和【日期】，日期需转换为YYYY-MM-DD格式，输出严格为JSON，无额外内容。
示例1：用户问"北京下周一天气"，输出{"city":"北京","date":"2025-11-25"}
示例2：用户问"上海明天的温度"，输出{"city":"上海","date":"2025-11-22"}
用户问题：{user_query}
"""
prompt = PromptTemplate(template=template, input_variables=["user_query"])
# 2. 处理模糊时间（如"下周三"）
def parse_fuzzy_date(date_str, today):
if "明天" in date_str:
return (today + relativedelta(days=1)).strftime("%Y-%m-%d")
elif "下周三" in date_str:
days_to_wed = (2 - today.weekday()) % 7 + 7 # 计算距离下周三的天数
return (today + relativedelta(days=days_to_wed)).strftime("%Y-%m-%d")
return date_str
# 3. 执行提取
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
user_query = "帮我查一下广州下周三的天气"
today = datetime.datetime.now()
structured_prompt = prompt.format(user_query=user_query)
result = llm.predict(structured_prompt)
info = eval(result) # 转换为字典，实际用json.loads更安全
print("提取结果：", info) # 输出：{"city":"广州","date":"2025-11-26"}
- 多模态感知：跨模态信息融合：突破纯文本限制，实现“语音-文本-图像”的联动处理，核心技术组合为“Whisper（语音转文本）+ CLIP（图像特征提取）+ GPT-4V（多模态理解）”。适用于智能导购（用户拍商品图问价格）、家庭机器人（听指令识别物体）等场景。开发时需注意：语音文件建议用16kHz采样率（Whisper最优输入），图像转Base64传输（API交互标准），并加入模态优先级判断（如“语音指令与图像内容冲突时，以语音为准”）。
import openai
import base64
from PIL import Image
from io import BytesIO
# 1. 辅助函数：图像转Base64（API传输标准格式）
def img_to_base64(img_path):
with Image.open(img_path) as img:
buffer = BytesIO()
img.save(buffer, format="JPEG")
return base64.b64encode(buffer.getvalue()).decode()
# 2. 语音感知：Whisper转文本
audio_file = open("user_voice.wav", "rb") # 内容："这张图里的手机多少钱？"
transcript = openai.Audio.transcribe(
model="whisper-1",
file=audio_file,
response_format="json"
)
user_text = transcript["text"] # 提取语音转写结果
# 3. 图像感知：GPT-4V理解内容并关联需求
img_base64 = img_to_base64("phone.jpg") # 手机图片
response = openai.ChatCompletion.create(
model="gpt-4-vision-preview",
messages=[
{"role": "user", "content": [
{"type": "text", "text": user_text},
{"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{img_base64}"}}
]}
],
max_tokens=300
)
# 4. 多模态结果整合（可进一步调用电商API查价格）
print("感知结果：", response.choices[0].message.content)
# 输出示例："图中手机为iPhone 15，目前电商均价5999元，是否需要为你查询具体店铺报价？"
- 系统感知：运行环境监控：Agent需实时感知自身运行状态，避免因资源不足或服务异常中断任务，核心监控维度包括“本地硬件”和“远程服务”。本地用psutil库（跨平台）监控CPU/内存/磁盘，阈值建议：CPU>85%、内存>90%、磁盘>95%时触发降载；远程用云服务商API（如阿里云ECS、AWS EC2）监控服务器状态，服务异常时需自动告警（邮件/企业微信）。实际部署时，可将监控数据接入Prometheus+Grafana实现可视化。
import psutil
import requests
import json
from datetime import datetime
# 1. 本地硬件感知（CPU、内存、磁盘）
def monitor_local():
cpu_usage = psutil.cpu_percent(interval=1) # 1秒采样
mem_usage = psutil.virtual_memory().percent
disk_usage = psutil.disk_usage("/").percent
status = "normal"
if cpu_usage > 85 or mem_usage > 90 or disk_usage > 95:
status = "warning"
# 触发降载：暂停非核心任务（如日志统计）
pause_non_core_tasks()
return {"time": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
"cpu": cpu_usage, "mem": mem_usage, "disk": disk_usage, "status": status}
# 2. 远程服务感知（阿里云ECS示例）
def monitor_ecs(access_key, secret, region, instance_id):
url = "https://ecs.aliyuncs.com/"
params = {
"Action": "DescribeInstanceStatus",
"RegionId": region,
"InstanceId.1": instance_id,
"AccessKeyId": access_key,
"Format": "JSON",
"Version": "2014-05-26"
}
response = requests.get(url, params=params)
data = response.json()
status = data["InstancesStatus"]["InstanceStatus"][0]["Status"]
if status != "Running":
# 发送企业微信告警
send_wechat_alert(f"ECS异常：{status}", instance_id)
return {"instance_id": instance_id, "status": status}
# 3. 示例调用（整合监控结果）
local_status = monitor_local()
ecs_status = monitor_ecs("你的AK", "你的SK", "cn-beijing", "i-abc123")
print("系统状态：", local_status, ecs_status)
2.1.2 决策模块：核心大脑
- 规则式决策：简单场景的高效方案：适用于逻辑明确、边界清晰的业务（如客服问题分类、订单状态处理），核心是“条件组合-行动映射”，可通过决策树算法（scikit-learn）管理复杂规则，相比if-else更易维护。优势是可解释性100%（每步决策都能追溯规则）、无LLM调用成本，劣势是无法处理未定义规则的场景。实际开发中，规则可存储在JSON配置文件中，支持动态更新（无需重启Agent）。
from sklearn.tree import DecisionTreeClassifier, export_text
import json
# 1. 从配置文件加载规则（支持动态更新）
with open("decision_rules.json", "r") as f:
rule_data = json.load(f)
X = rule_data["features"] # 特征：[问题类型, 用户等级, 订单金额等级]
y = rule_data["actions"] # 行动：0=自动回复，1=优先处理，2=转接人工
# 2. 训练决策树（可视化规则，便于运维）
dt = DecisionTreeClassifier(max_depth=3) # 限制深度避免过拟合
dt.fit(X, y)
print("决策规则：\n", export_text(dt, feature_names=["问题类型", "用户等级", "订单金额"]))
# 3. 决策执行（实时场景：VIP用户+高金额退款）
def make_decision(features):
action_code = dt.predict([features])[0]
action_map = {0: "auto_reply()", 1: "priority_handle()", 2: "transfer_human()"}
return action_map[action_code]
# 示例：退款问题（1）+ VIP用户（1）+ 高金额（1）→ 优先处理
action = make_decision([1, 1, 1])
print("决策结果：", action) # 输出：priority_handle()
# 决策规则配置文件示例（decision_rules.json）
{
"features": [[0,0,0],[0,1,0],[1,0,1],[1,1,1],[2,0,0]],
"actions": [0,1,1,1,0]
}
- LLM驱动决策：复杂场景的核心方案：适用于模糊需求（如“帮我优化职场简历”）或多工具协同场景，利用LLM的逻辑推理能力生成“行动序列”。关键设计技巧有三：①明确工具清单（含名称、参数、用途），避免LLM生成无效行动；②强制结构化输出（JSON格式），便于代码解析；③加入决策约束（如“必须先查订单状态，再决定是否加急”）。开发时需处理格式错误（LLM偶尔输出非JSON），通过重试提示修正（如“请严格按JSON输出，无额外文本”）。
import openai
import json
# 1. 定义可用工具与约束规则
tool_def = """
可用工具：
1. query_resume( params: resume_text (必填) )：分析简历问题，返回优化方向
2. generate_resume( params: job_desc (必填), personal_info (必填) )：生成定制化简历
3. check_grammar( params: text (必填) )：校验语法与措辞，返回修改建议
决策规则：
1. 先调用query_resume分析用户现有简历，再生成优化方案；
2. 仅使用上述工具，不新增其他行动；
3. 输出严格为JSON，含"action"和"params"字段，无额外内容。
"""
# 2. 用户模糊需求与Prompt构造
user_question = "我有一份销售简历，想应聘互联网大厂，帮我优化得更突出业绩"
prompt = f"你的身份：职场简历优化Agent\n{tool_def}\n用户需求：{user_question}"
# 3. LLM生成决策（降低temperature确保稳定性）
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[{"role": "user", "content": prompt}],
temperature=0.1
)
# 4. 解析决策（加入异常处理）
try:
decision = json.loads(response.choices[0].message.content)
print("决策结果：", decision)
# 执行工具（后续代码根据action调用对应函数）
if decision["action"] == "query_resume":
resume_analysis = query_resume(decision["params"]["resume_text"])
except json.JSONDecodeError:
# 格式错误重试
retry_prompt = "输出格式错误，请重新输出，仅含JSON，无任何额外文本"
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[{"role": "user", "content": retry_prompt}]
)
decision = json.loads(response.choices[0].message.content)
- 强化学习决策：动态环境的优化方案：适用于需长期优化目标的场景（如游戏AI、资源调度、智能推荐），Agent通过与环境交互获得“奖励”或“惩罚”，持续调整策略。PPO（近端策略优化）是目前最成熟的算法，平衡训练稳定性与收敛速度，依赖Stable Baselines3库实现。核心是设计合理的奖励函数——如电商推荐Agent的奖励：用户点击得1分、购买得3分、跳过得-0.5分；资源调度Agent的奖励：任务完成时间缩短1秒得1分、服务器超载扣5分。
import gym
from stable_baselines3 import PPO
import matplotlib.pyplot as plt
# 1. 定义自定义环境（以“电商推荐优化”为例，简化版）
class RecommendEnv(gym.Env):
def __init__(self):
super().__init__()
self.action_space = gym.spaces.Discrete(5) # 5类商品推荐选项
self.observation_space = gym.spaces.Box(low=0, high=1, shape=(3,)) # 特征：用户活跃度、历史购买、浏览时长
self.state = [0.5, 0.3, 0.7] # 初始状态
def step(self, action):
# 模拟环境反馈：action=2（推荐数码产品）时奖励最高
reward = 3 if action == 2 else (1 if action in [1,3] else -0.5)
done = False # 持续交互，不终止
info = {}
return self.state, reward, done, info
def reset(self):
return self.state
# 2. 初始化环境与PPO模型
env = RecommendEnv()
model = PPO(
policy="MlpPolicy",
env=env,
learning_rate=3e-4,
n_steps=2048,
batch_size=64,
verbose=1
)
# 3. 训练Agent（记录奖励变化）
total_timesteps = 10000
rewards = []
obs = env.reset()
for _ in range(total_timesteps):
action, _states = model.predict(obs, deterministic=False)
obs, reward, done, info = env.step(action)
rewards.append(reward)
if done:
obs = env.reset()
# 4. 可视化训练效果（奖励提升说明策略优化）
plt.plot(rewards[:1000]) # 取前1000步可视化
plt.title("推荐Agent奖励曲线")
plt.xlabel("Step")
plt.ylabel("Reward")
plt.show()
# 5. 实际推荐决策
obs = [0.8, 0.6, 0.9] # 新用户状态：高活跃度、有购买、长浏览
action = model.predict(obs)[0]
print(f"推荐决策：推荐第{action+1}类商品")
2.1.3 记忆模块：状态与知识存储
- 短期记忆：会话级上下文管理：用于存储当前对话的上下文信息（如用户姓名、历史提问），确保多轮交互连贯，核心解决“Agent失忆”问题（如用户先问“我叫张三”，后续问“我的订单”时能关联张三的信息）。LangChain提供三类核心实现：①ConversationBufferMemory（完整存储对话，适合短会话）；②ConversationBufferWindowMemory（保留最近k轮，控制Token消耗）；③ConversationSummaryMemory（生成对话摘要，压缩冗余内容）。开发时需根据对话长度选择：短对话（<5轮）用Buffer，长对话（>10轮）用Summary或Window。
from langchain.memory import (
ConversationBufferMemory,
ConversationBufferWindowMemory,
ConversationSummaryMemory
)
from langchain.chains import ConversationChain
from langchain.chat_models import ChatOpenAI
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.7)
# 1. 基础短期记忆：完整存储（适合短对话）
buffer_mem = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
buffer_chain = ConversationChain(memory=buffer_mem, llm=llm)
# 多轮对话测试
buffer_chain.run("我叫张三，是一名Python开发工程师")
buffer_chain.run("我想开发一个能查天气的AI Agent，用LangChain框架")
# 加载记忆，验证连贯性
history = buffer_mem.load_memory_variables({})["chat_history"]
print("完整对话记忆：", [msg.content for msg in history])
# 2. 窗口记忆：保留最近2轮（控制Token成本）
window_mem = ConversationBufferWindowMemory(memory_key="chat_history", k=2)
window_chain = ConversationChain(memory=window_mem, llm=llm)
window_chain.run("我叫张三，是Python开发")
window_chain.run("我要用LangChain开发天气Agent")
window_chain.run("这个Agent需要调用高德API吗？")
# 仅保留后2轮对话
print("窗口记忆内容：", window_mem.load_memory_variables({})["chat_history"])
# 3. 摘要记忆：压缩对话（适合长会话）
summary_mem = ConversationSummaryMemory(memory_key="chat_history", llm=llm)
summary_chain = ConversationChain(memory=summary_mem, llm=llm)
summary_chain.run("我叫张三，Python开发，3年经验")
summary_chain.run("想做天气Agent，需要查天气、推荐景点功能")
summary_chain.run("用LangChain+OpenAI API，部署到Flask")
# 记忆为对话摘要，大幅减少Token
print("对话摘要记忆：", summary_mem.load_memory_variables({})["chat_history"])
- 长期记忆：用户级知识存储：用于存储用户偏好、领域知识库、历史任务记录等持久化信息，核心解决“跨会话记忆”问题（如用户上月说“喜欢经济型酒店”，本月问“北京酒店推荐”时能关联该偏好）。核心技术是“语义检索”——将文本转化为高维向量（嵌入向量），存储到向量数据库，查询时通过向量相似度匹配相关信息，相比关键词匹配更懂“语义”（如“游玩”和“出游”视为相似）。常用技术组合：①嵌入模型：OpenAI text-embedding-3-small（768维，平衡效果与成本）、开源all-MiniLM-L6-v2（本地部署）；②向量数据库：Pinecone（云服务，支持大规模）、FAISS（Facebook开源，本地小规模）、Milvus（开源分布式）。
import pinecone
import openai
import time
# 1. 初始化嵌入模型与向量数据库（Pinecone）
openai.api_key = "你的OpenAI密钥"
pinecone.init(
api_key="你的Pinecone密钥",
environment="us-west1-gcp" # 与创建的索引地域一致
)
index_name = "user-preference"
# 若索引不存在则创建（维度需与嵌入模型匹配，text-embedding-3-small为768维）
if index_name not in pinecone.list_indexes():
pinecone.create_index(index_name, dimension=768)
index = pinecone.Index(index_name)
time.sleep(1) # 等待索引就绪
# 2. 定义向量化与存储函数
def embed_text(text):
"""文本转嵌入向量"""
response = openai.Embedding.create(
input=text,
model="text-embedding-3-small"
)
return response["data"][0]["embedding"]
def save_preference(user_id, content):
"""存储用户偏好到向量库"""
embedding = embed_text(content)
# 向量ID格式：user_用户ID_时间戳，便于后续更新
vec_id = f"user_{user_id}_{int(time.time())}"
index.upsert(
vectors=[(vec_id, embedding, {"user_id": user_id, "content": content})],
namespace="preferences" # 命名空间区分数据类型
)
print(f"用户{user_id}偏好已存储，ID：{vec_id}")
# 3. 存储示例用户偏好
save_preference(
user_id="zhangsan123",
content="张三：喜欢经济型酒店（价格<300元/晚），偏好靠近地铁，避开人流密集区域，出差常用"
)
# 4. 检索函数：匹配用户偏好
def get_preference(user_id, query):
"""根据查询匹配用户偏好"""
query_emb = embed_text(query)
results = index.query(
vector=query_emb,
top_k=1, # 返回最相似的1条
namespace="preferences",
filter={"user_id": user_id}, # 仅检索该用户数据
score_threshold=0.7 # 相似度低于0.7视为无匹配
)
if results["matches"]:
return results["matches"][0]["metadata"]["content"]
return "未找到相关偏好"
# 5. 实战：结合偏好生成推荐
user_query = "帮我推荐北京朝阳区的酒店，我要出差用"
preference = get_preference(user_id="zhangsan123", query=user_query)
# 调用LLM生成个性化推荐
prompt = f"根据用户偏好：{preference}，推荐北京朝阳区符合要求的酒店，分点说明理由"
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[{"role": "user", "content": prompt}]
)
print("个性化推荐：", response.choices[0].message.content)
2.1.4 执行模块：工具与行动调用
- 工具调用协议：标准化交互核心：规范Agent与工具的通信逻辑，确保决策指令能被工具准确执行，核心解决“语义歧义”问题。目前主流协议有两种：①OpenAI Function Call：原生适配GPT系列模型，通过在API请求中定义`functions`参数，让LLM判断是否调用工具及传递参数，工具返回后LLM可继续分析生成最终结果，形成“调用-反馈-决策”闭环；②Anthropic MCP（Multimodal Control Protocol）：在Function Call基础上扩展多模态工具支持和动态工具发现能力，Agent可自动识别环境中可用工具（如本地PDF阅读器、远程API），无需硬编码工具列表。两种协议均要求“结构化参数定义”和“明确输出格式”，是企业级Agent的必备规范。
import openai
import json
import requests
# 1. 定义工具函数（高德天气查询）
def get_weather(city: str, date: str) -> str:
"""天气查询工具实现，含异常处理"""
city_code = {"北京": "110000", "广州": "440100", "上海": "310000"}
if city not in city_code:
return f"暂不支持{city}的天气查询"
url = "https://restapi.amap.com/v3/weather/weatherInfo"
params = {
"city": city_code[city],
"date": date,
"key": "你的高德API密钥"
}
try:
response = requests.get(url, params=params, timeout=10)
response.raise_for_status()
data = response.json()
if data["status"] == "1" and "forecasts" in data:
cast = data["forecasts"][0]["casts"][0]
return f"{city}{date}：{cast['dayweather']}，气温{cast['daytemp']}-{cast['nighttemp']}℃"
return f"查询失败：{data.get('info', '未知错误')}"
except Exception as e:
return f"工具调用异常：{str(e)}"
# 2. 定义Function Call格式（OpenAI协议）
functions = [
{
"name": "get_weather",
"description": "查询指定城市和日期的天气信息，日期格式必须为YYYY-MM-DD",
"parameters": {
"type": "object",
"properties": {
"city": {"type": "string", "description": "中国地级市名称，如北京、广州"},
"date": {"type": "string", "description": "查询日期，格式YYYY-MM-DD，如2025-12-01"}
},
"required": ["city", "date"] # 明确必填参数
}
}
]
# 3. 第一步：LLM生成工具调用决策
user_query = "我12月5日要去广州出差，帮我查下当天的天气，需要带外套吗？"
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[{"role": "user", "content": user_query}],
functions=functions,
function_call="auto" # 让LLM自动判断是否调用工具
)
response_msg = response.choices[0].message
# 4. 第二步：解析决策并调用工具
if response_msg.get("function_call"):
func_name = response_msg["function_call"]["name"]
func_args = json.loads(response_msg["function_call"]["arguments"])
# 执行工具调用
weather_result = get_weather(**func_args)
# 第三步：将工具结果返回LLM，生成最终回答
final_response = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[
{"role": "user", "content": user_query},
response_msg,
{"role": "function", "name": func_name, "content": weather_result}
]
)
print("Agent最终回答：", final_response.choices[0].message.content)
else:
print("Agent最终回答：", response_msg.content)
- API工具集成：扩展Agent能力边界：最核心的工具类型，涵盖天气、物流、电商、支付等几乎所有在线服务，集成关键在于“参数标准化”“异常全面处理”和“安全管控”。参数标准化：通过城市编码映射（如“北京”→“110000”）解决用户输入与API参数不一致问题；异常处理：覆盖网络超时、HTTP错误（401权限/500服务异常）、API返回错误（状态码非1）；安全管控：API密钥存储在环境变量（而非硬编码），用`os.getenv()`获取，避免泄露。示例以高德天气API为例，可扩展至物流（顺丰API）、电商（淘宝开放平台）等场景。
import requests
import os
from datetime import datetime
# 安全实践：从环境变量获取API密钥
AMAP_KEY = os.getenv("AMAP_WEATHER_KEY")
def get_weather(city, date):
"""生产级天气API调用实现，含完整异常处理"""
# 1. 城市编码映射（可扩展至全国城市，或调用高德城市查询API动态获取）
city_code = {
"北京": "110000", "上海": "310000", "广州": "440100",
"深圳": "440300", "杭州": "330100"
}
# 动态获取未收录城市编码（备选方案）
if city not in city_code:
city_code_dynamic = get_city_code(city)
if not city_code_dynamic:
return f"暂不支持{city}的天气查询，建议输入省会城市"
city_code[city] = city_code_dynamic
# 2. 日期格式校验（避免无效请求）
try:
datetime.strptime(date, "%Y-%m-%d")
except ValueError:
return f"日期格式错误，请输入YYYY-MM-DD（如2025-12-01）"
# 3. 构造API请求（加入请求头防反爬）
url = "https://restapi.amap.com/v3/weather/weatherInfo"
headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)"}
params = {
"city": city_code[city],
"date": date,
"key": AMAP_KEY,
"extensions": "all" # 获取详细天气信息（风向、风力等）
}
# 4. 发送请求（加入重试机制）
session = requests.Session()
adapter = requests.adapters.HTTPAdapter(max_retries=2) # 重试2次
session.mount("https://", adapter)
try:
response = session.get(url, params=params, headers=headers, timeout=10)
response.raise_for_status() # 触发4xx/5xx错误
data = response.json()
# 5. 解析API结果
if data["status"] != "1":
return f"查询失败：{data.get('info', 'API返回异常')}"
forecast = data["forecasts"][0]
cast = next((c for c in forecast["casts"] if c["date"] == date), None)
if not cast:
return f"未查询到{city}{date}的天气数据"
# 6. 整理为用户友好的结果
return (
f"{city} {date} 天气详情：\n"
f"- 日间：{cast['dayweather']}，{cast['daywind']}{cast['daypower']}级，{cast['daytemp']}℃\n"
f"- 夜间：{cast['nightweather']}，{cast['nightwind']}{cast['nightpower']}级，{cast['nighttemp']}℃\n"
f"- 出行建议：{forecast['advice']}"
)
except requests.exceptions.Timeout:
return "请求超时，请检查网络或稍后重试"
except requests.exceptions.HTTPError as e:
return f"服务异常（状态码：{e.response.status_code}），请联系管理员"
except Exception as e:
# 生产级：记录错误日志（便于排查）
with open("weather_api_error.log", "a", encoding="utf-8") as f:
f.write(f"{datetime.now()} | 错误：{str(e)} | 参数：{city},{date}\n")
return "查询过程中出现异常，请稍后再试"
# 辅助函数：动态获取城市编码
def get_city_code(city_name):
url = "https://restapi.amap.com/v3/config/district"
params = {"keywords": city_name, "key": AMAP_KEY, "subdistrict": 0}
response = requests.get(url, params=params, timeout=10)
data = response.json()
if data["status"] == "1" and data["districts"]:
return data["districts"][0]["adcode"]
return None
- 代码执行工具：实现数据处理与自动化：用于执行Python代码完成数据计算、文件处理、报表生成等任务，核心是“安全可控”——避免Agent执行恶意代码（如删除文件、访问敏感数据）。LangChain的`PythonREPLTool`是常用选择，支持限制执行目录；基础场景也可通过`exec`实现，但需严格隔离执行环境（如用沙箱库`restrictedpython`）。适用场景：数据分析（生成销售报表）、文件转换（CSV转Excel）、自动化脚本（批量重命名文件）。
from langchain.tools import PythonREPLTool
from restrictedpython import compile_restricted, safe_globals # 安全执行库
import pandas as pd
# 1. LangChain PythonREPLTool（适合可控场景）
repl_tool = PythonREPLTool()
# 任务：分析销售数据，计算各区域销售额占比
sales_data_code = """
import pandas as pd
import matplotlib.pyplot as plt
# 读取数据（假设数据在当前目录）
df = pd.read_csv("sales_data.csv")
# 计算各区域销售额
region_sales = df.groupby("region")["sales"].sum()
# 计算占比
region_ratio = (region_sales / region_sales.sum() * 100).round(2)
# 生成饼图并保存
plt.pie(region_ratio, labels=region_ratio.index, autopct='%1.1f%%')
plt.title("各区域销售额占比")
plt.savefig("sales_ratio.png")
# 输出结果
print("各区域销售额占比：")
print(region_ratio)
"""
# 执行代码（限制在指定目录，需配置code_execution_config）
result = repl_tool.run(sales_data_code)
print("代码执行结果：", result)
# 2. 安全执行基础代码（用restrictedpython防止恶意操作）
def safe_execute_code(code, local_vars=None):
"""安全执行Python代码，限制危险操作"""
local_vars = local_vars or {}
# 编译代码（仅允许安全操作）
byte_code = compile_restricted(code, "
2.2 主流开发框架与技术栈
|
框架 |
核心优势 |
适用场景 |
入门案例 |
|
框架 |
核心优势 |
适用场景 |
入门案例 |
|
LangChain |
1. 组件化设计：提供记忆、工具、链等100+现成组件，支持模块化组合；2. 生态完善：兼容OpenAI、Anthropic等主流LLM，集成Pinecone、FAISS等向量数据库；3. 开发高效：LCEL表达式简化工作流编排，支持快速原型开发；4. 文档丰富：官方文档含完整教程和实战案例，社区问题响应及时。 |
单Agent复杂任务开发，如文档问答、智能客服、个人助理，尤其适合需要多工具协作和记忆管理的场景，广泛应用于企业级AI应用的快速迭代。 |
构建“PDF产品手册问答Agent”：1. 用PyPDFLoader加载PDF文件；2. 用RecursiveCharacterTextSplitter分割文本；3. 用OpenAIEmbeddings生成向量；4. 存储至FAISS向量库；5. 用RetrievalQA链实现“提问-检索-回答”闭环，核心代码： |
|
AutoGen |
1. 多Agent协作：原生支持Agent间对话交互与任务分工，内置多种协作模式；2. 对话驱动：通过自然语言对话拆解复杂任务，降低开发难度；3. 代码执行优化：支持代码生成、执行与调试的全流程，适合技术类任务；4. 灵活配置：可自定义Agent角色、目标和交互规则，适配不同场景。 |
多角色协作任务，如数据分析与可视化、软件开发、市场调研，尤其适合需要“专业分工”的复杂场景，可模拟人类团队的协作模式。 |
设置“数据分析师+代码执行者”双Agent完成销售数据分析：1. 定义DataAnalyzerAgent（负责提出分析思路和代码需求）；2. 定义CodeExecutorAgent（负责执行代码并返回结果）；3. 用initiate_chat启动协作，核心代码： |
|
Rasa |
1. 企业级稳定性：支持高并发访问，提供完善的运维监控工具；2. 自定义NLU：可训练领域专属的意图识别和实体抽取模型，适配专业术语；3. 本地部署：支持私有化部署，满足数据安全需求；4. 多渠道集成：兼容微信、企业微信、电话等多种交互渠道。 |
企业级对话系统，如银行客服、政务咨询、运营商服务，尤其适合对数据隐私和定制化要求高的行业场景。 |
训练“银行客服Agent”：1. 编写nlu.yml定义意图（如查余额、转账）和实体（如金额、账户）；2. 编写stories.yml定义对话流程；3. 训练模型并测试，核心配置（nlu.yml）： |
2.3 进阶实战：工具调用Agent 开发
任务目标
核心步骤
- 定义工具与封装：注册3类核心工具，用LangChain的BaseTool封装实现统一接口：
天气查询工具：调用高德天气API，输入城市和日期，返回天气状况和温度；
- 景点推荐工具：调用马蜂窝API，传入城市、同行人员（筛选亲子景点）、天气条件（如雨天推荐室内场馆），返回景点列表及评分；
- 酒店预订工具：调用携程API，根据行程地点和日期，返回周边亲子友好型酒店及预订链接。
- 决策逻辑设计：基于GPT-3.5-turbo的Function Call能力，设计“多步决策流程”——1. 提取用户输入中的核心参数（目的地、时间、同行人员）；2. 调用天气查询工具获取每日天气；3. 根据天气结果调用景点推荐工具筛选适配景点；4. 结合景点位置调用酒店预订工具；5. 整合所有信息生成行程单。通过提示词明确决策顺序，示例：
你是旅行规划Agent，需按以下步骤完成任务：
1. 先检查用户输入是否包含目的地、出行时间、同行人员，缺失则询问补充；
2. 调用weather_query工具查询每日天气；
3. 用天气结果调用attraction_recommend工具，筛选适合同行人员的景点；
4. 调用hotel_book工具获取景点周边酒店；
5. 按日期整理行程（含天气、景点、酒店、注意事项），用自然语言输出。
- 记忆集成与优化：采用“短期记忆+长期记忆”组合方案——短期记忆用ConversationSummaryMemory存储用户输入参数和工具调用结果，避免重复询问；长期记忆用Pinecone存储用户历史旅行偏好（如“喜欢经济型酒店”“避开人流密集景点”），在推荐时优先匹配。记忆加载示例：
from langchain.memory import ConversationSummaryMemory
# 短期记忆：总结对话内容
summary_memory = ConversationSummaryMemory(llm=ChatOpenAI(), memory_key="chat_history")
# 加载历史对话（用户曾说“喜欢经济型酒店”）
summary_memory.save_context(
{"input":"我之前旅行都住经济型酒店，性价比高"},
{"output":"已记录你的偏好，规划时优先推荐经济型酒店"}
)
# 长期记忆：检索用户偏好
def get_user_preference(user_id):
# 从Pinecone检索用户偏好（略，同前文向量检索逻辑）
return "喜欢经济型酒店，避开人流密集景点"
- 异常处理与容错：设计三层容错机制——1. 参数校验：工具调用前检查参数格式（如日期是否为YYYY-MM-DD），错误则提示用户修正；2. 重试机制：API调用超时或返回错误时，自动重试2次，间隔3秒；3. 降级策略：工具不可用时，调用本地知识库（如离线景点列表）生成基础行程，示例重试逻辑：
import time
def call_api_with_retry(api_func, max_retry=2, **kwargs):
retry_count = 0
while retry_count < max_retry:
try:
return api_func(** kwargs)
except Exception as e:
retry_count += 1
print(f"API调用失败，重试第{retry_count}次，错误：{str(e)}")
time.sleep(3)
# 降级处理：返回离线数据
return get_offline_data(api_func.__name__, **kwargs)
关键代码片段
|
Plain Text |
三、高阶：Agent 系统优化与前沿方向
3.1 系统级优化技术
3.1.1 性能优化
- 上下文压缩：用LLM生成对话摘要（如LangChain的ConversationSummaryBufferMemory），减少Token消耗。
- 并行执行：多Agent任务并行（如AutoGen的parallel_agent_executor），提升复杂任务效率。
- 模型选型：简单决策用GPT-3.5-turbo，复杂推理用GPT-4，非关键模块用开源模型（如Llama 3）降低成本。
3.1.2 可靠性优化
- 指令对齐：用RLHF（基于人类反馈的强化学习）微调模型，确保Agent行为符合预期。
- 安全防护：检测提示注入攻击（如用LangChain的OutputParser校验输出格式）、限制敏感工具调用权限。
- 容错机制：工具调用失败时，自动切换备用工具（如天气API失效时用另一个数据源）。
3.2 前沿技术方向
3.2.1 多模态Agent
- 核心能力：融合文本、图像、语音、传感器数据，实现“跨模态感知-决策”。
- 技术实现：用GPT-4V（视觉）、Whisper（语音）作为感知入口，结合LangChain实现多模态信息融合。
- 应用场景：智能机器人（如家庭服务机器人）、AR/VR交互Agent。
3.2.2 具身智能Agent
- 核心定义：Agent拥有物理实体（如机器人），能在真实物理世界中行动（如抓取物体、移动）。
- 关键技术：强化学习（控制实体动作）、SLAM（环境地图构建）、运动学模型（关节控制）。
- 开发工具：PyTorch Robotics、ROS（机器人操作系统）、Mujoco（物理仿真环境）。
3.2.3 开放域多Agent协作
- 核心挑战：Agent间角色分配、任务调度、冲突解决。
- 协作机制：
集中式：有“监督Agent”分配任务（如MetaGPT的Product Manager角色）。
- 分布式：Agent通过共识算法（如Raft）自主协调（如区块链共识Agent）。
实践案例：用AutoGen构建“电商运营团队”——含“选品Agent”“推广Agent”“客服Agent”，协同完成店铺运营。
3.3 企业级Agent 落地要点
- 合规性：用户数据加密存储（符合GDPR/个人信息保护法）、明确Agent行为边界（如禁止金融欺诈）。
- 可解释性：记录Agent决策链路（如“为何推荐A景点”→“因天气晴朗且用户偏好自然景观”），用LangChain的AgentTracer实现。
- 运维监控：用Prometheus监控Agent响应延迟、成功率，用Grafana可视化指标。
扫一扫
1442
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
