Agent 入门10题 + 主流Agent框架入门10题
目录
Agent 入门10题
- Q1. 什么是大模型 Agent?它与传统的 AI 系统有什么不同?
- Q2. LLM Agent 的基本架构有哪些组成部分?
- Q3. LLM Agent 如何进行决策?能否使用具体的方法解释?
- Q4. 如何让 LLM Agent 具备长期记忆能力?
- Q5. LLM Agent 如何进行动态 API 调用?
- Q6. LLM Agent 在多模态任务中如何执行推理?
- Q7. LLM Agent 要有哪些局限性?
- Q8. 如何衡量 LLM Agent 的性能?
- Q9. 未来 LLM Agent 可能有哪些技术突破?
- Q10. 请你设计一个 LLM Agent,用于医学问答,它需要具备哪些能力?
关于主流 Agent 框架的10个入门题
- Q2. LangChain 的核心组件有哪些?
- Q3. LangChain Agent 的主要类型有哪些?
- Q4. LlamaIndex 如何与 LangChain 结合?
- Q5. AutoGPT 如何实现自主决策?
- Q6. BabyAGI 如何进行任务管理?
- Q7. CrewAI 如何管理多个 Agent 之间的协作?
- Q8. LangChain 如何支持 API 调用?
- Q9. 如何优化 LLM Agent 的性能?
- Q10. LLM Agent 在企业应用中的典型场景有哪些?
Agent 入门10题
Q1. 什么是大模型 Agent?它与传统的 AI 系统有什么不同?
什么是大模型 Agent
大模型 Agent(LLM Agent)是以大型语言模型为核心推理引擎,能够自主感知环境、规划任务、调用工具并执行行动,以实现特定目标的智能系统。它不只是被动地”问答”,而是能主动地”做事”。
一句话概括:传统 AI 告诉你答案,Agent 帮你把事情做完。
与传统 AI 系统的核心区别
| 维度 | 传统 AI 系统 | 大模型 Agent |
|---|---|---|
| 任务模式 | 单轮输入→输出 | 多轮循环,自主规划执行 |
| 目标导向 | 完成固定功能 | 以目标为导向,动态决策 |
| 工具使用 | 功能预先硬编码 | 动态调用外部工具(搜索、代码、API) |
| 规划能力 | 无规划,直接映射 | 任务分解、多步骤规划 |
| 记忆能力 | 通常无状态 | 短期上下文 + 长期持久记忆 |
| 适应性 | 对未见情况无能为力 | 能感知反馈并调整策略 |
| 自主性 | 完全被动 | 主动探索、主动决策 |
| 知识来源 | 训练数据固定 | 可实时检索外部知识 |
形象比喻
- 传统 AI:像一本百科全书,你问什么它答什么,但它不会主动帮你查资料、写邮件、订机票。
- 大模型 Agent:像一位有能力的助理,你告诉他”帮我安排明天的出差”,他会自动查航班、预订酒店、发邮件给相关人员,全程自主完成。
大模型 Agent 的核心要素
感知(Perception) → 规划(Planning) → 行动(Action)
↑ ↓
└─────────── 反馈(Feedback) ←────────────┘
Q2. LLM Agent 的基本架构有哪些组成部分?
LLM Agent 的架构通常由以下五个核心组件构成:
① 大脑/推理核心(LLM Core)
大语言模型(如 GPT-4、Claude、Llama)是 Agent 的核心,负责:
- 理解用户意图
- 规划执行步骤
- 生成工具调用指令
- 综合信息得出最终答案
② 记忆系统(Memory)
短期记忆(Short-term Memory)
└── 当前对话的上下文窗口(Context Window)
存储当前会话的所有信息
长期记忆(Long-term Memory)
└── 向量数据库(Pinecone、Chroma、Weaviate)
跨会话持久化存储,通过语义检索按需读取
③ 工具集(Tools / Plugins)
Agent 可调用的外部能力,常见工具包括:
- 搜索工具:Google Search、Bing、Tavily
- 代码执行:Python REPL、Jupyter Kernel
- 数据库查询:SQL 工具、向量检索
- API 调用:天气、地图、支付、CRM 等
- 文件操作:读写 PDF、Excel、文本文件
- 浏览器控制:Playwright、Selenium
④ 规划与决策模块(Planning)
将复杂任务分解为可执行子步骤的机制:
- ReAct:Reasoning + Acting 交替循环
- Chain-of-Thought:逐步推理
- Plan-and-Execute:先规划全程,再逐步执行
⑤ 行动执行层(Action Executor)
将规划模块的决策转化为实际操作:
- 解析 LLM 输出的工具调用指令(JSON 格式)
- 路由到对应工具执行
- 将执行结果返回给 LLM 进行下一轮推理
完整架构图
用户输入
↓
┌─────────────────────────────────────┐
│ LLM 推理核心 │
│ ┌─────────┐ ┌─────────────────┐ │
│ │ 短期记忆 │ │ 规划 / ReAct │ │
│ └─────────┘ └─────────────────┘ │
└────────────────────┬────────────────┘
↓
工具调用决策
┌────────────────────┐
↓ ↓ ↓
搜索工具 代码执行 数据库查询 ...
└────────────────────┘
↓
执行结果返回
↓
LLM 综合回答
↓
最终输出
Q3. LLM Agent 如何进行决策?能否使用具体的方法解释?
LLM Agent 的决策核心是推理-行动循环,目前最主流的方法是 ReAct 框架,此外还有 CoT、ToT 等多种方法。
方法一:ReAct(Reasoning + Acting)
原理: 交替进行”推理(Thought)→ 行动(Action)→ 观察(Observation)“三步循环,直到任务完成。
实际运行示例:
用户问题:北京今天的天气怎么样?适合出行吗?
Thought 1: 我需要获取北京今天的实时天气信息,应该调用天气查询工具。
Action 1: weather_tool(city="北京", date="today")
Observation 1: 北京今日晴,气温 18-26°C,空气质量优,微风。
Thought 2: 天气信息已获取,天气晴好,气温适宜,空气质量好,非常适合出行。
Final Answer: 北京今天晴天,气温 18-26°C,空气质量优,非常适合出行!
建议穿薄外套,注意防晒。
方法二:Chain-of-Thought(思维链)
通过”让我一步步思考”的方式引导模型展示推理过程,提升复杂推理准确性:
问题:一个工厂每天生产 500 件产品,其中 3% 是次品,
工厂想在一周内积累 2000 件合格品,需要几天?
CoT 推理:
Step 1: 每天合格品数量 = 500 × (1 - 3%) = 500 × 0.97 = 485 件
Step 2: 需要天数 = 2000 ÷ 485 ≈ 4.12 天
Step 3: 向上取整,需要 5 天才能积累 2000 件以上合格品
Answer: 5 天
方法三:Tree of Thoughts(思维树)
将推理扩展为树状搜索,探索多条路径:
问题(根节点)
├── 路径 A(推理方向一)→ 中间结果 A1 → A2 → 评分:0.8
├── 路径 B(推理方向二)→ 中间结果 B1 → 失败,回溯
└── 路径 C(推理方向三)→ 中间结果 C1 → C2 → 评分:0.95 ✓
适合需要探索和回溯的复杂问题(如数学证明、策略规划)。
方法四:Plan-and-Execute
先生成完整计划,再逐步执行——适合结构清晰的长任务:
Plan:
Step 1: 搜索竞品信息
Step 2: 分析竞品优劣势
Step 3: 生成分析报告
Step 4: 制作 PPT
Execute Step 1 → Execute Step 2 → ...(按计划依次执行)
决策方法选择建议
| 场景 | 推荐方法 |
|---|---|
| 通用问答 + 工具调用 | ReAct |
| 数学/逻辑推理 | CoT / Self-Consistency |
| 复杂策略问题 | Tree of Thoughts |
| 长流程确定性任务 | Plan-and-Execute |
Q4. 如何让 LLM Agent 具备长期记忆能力?
LLM 的上下文窗口是有限的,一旦会话结束,对话历史全部消失。要让 Agent 跨会话”记住”用户,需要外部长期记忆机制。
长期记忆的核心架构:RAG(检索增强生成)
写入流程:
新信息 → Embedding 模型 → 向量化 → 存入向量数据库
读取流程:
用户输入 → Embedding → 向量检索(相似度匹配)→ 召回相关记忆 → 注入 Prompt
实现方式详解
① 向量数据库存储(最主流)
from langchain.vectorstores import Chroma
from langchain.embeddings import OpenAIEmbeddings
# 初始化向量数据库
vectorstore = Chroma(embedding_function=OpenAIEmbeddings())
# 存储记忆
def save_memory(user_id: str, content: str):
vectorstore.add_texts(
texts=[content],
metadatas=[{"user_id": user_id, "timestamp": time.time()}]
)
# 检索相关记忆
def retrieve_memory(user_id: str, query: str, k: int = 5):
results = vectorstore.similarity_search(
query=query,
k=k,
filter={"user_id": user_id} # 只检索该用户的记忆
)
return [doc.page_content for doc in results]② 结构化存储(用户偏好/固定信息)
# 用 JSON/数据库存储用户的固定属性
user_profile = {
"user_id": "u_001",
"name": "张三",
"profession": "后端工程师",
"preferred_language": "Python",
"communication_style": "简洁直接",
"past_topics": ["Redis优化", "Kubernetes部署", "性能调优"]
}③ 对话摘要压缩(节省空间)
# 定期将历史对话压缩为摘要,存入长期记忆
summary_prompt = f"""
请将以下对话历史压缩为一段简短摘要,保留关键信息和用户偏好:
{conversation_history}
"""
summary = llm.generate(summary_prompt)
save_memory(user_id, summary)④ 记忆注入 Prompt
def build_prompt_with_memory(user_id, current_query):
# 检索相关历史记忆
memories = retrieve_memory(user_id, current_query, k=3)
memory_context = "\n".join([f"- {m}" for m in memories])
return f"""
你是用户的个人助理。以下是关于该用户的历史信息:
{memory_context}
当前问题:{current_query}
请结合用户背景,给出个性化的回答。
"""不同记忆类型对比
| 记忆类型 | 存储位置 | 持久性 | 检索方式 | 适用场景 |
|---|---|---|---|---|
| 工作记忆 | Context Window | 会话级 | 直接读取 | 当前对话 |
| 情景记忆 | 向量数据库 | 持久化 | 语义检索 | 历史对话摘要 |
| 语义记忆 | 向量 + 结构化 DB | 持久化 | 精确/语义 | 用户偏好/知识 |
| 程序记忆 | 代码/配置 | 永久 | 规则匹配 | 固定操作流程 |
Q5. LLM Agent 如何进行动态 API 调用?
动态 API 调用是指 Agent 根据任务需求,在运行时自主决定调用哪个 API、传入什么参数,而非预先硬编码。
核心机制:Function Calling / Tool Use
OpenAI、Anthropic 等主流模型都支持 Function Calling,将 API 描述注册给模型,模型自动判断何时调用并生成参数。
① 工具注册(告诉模型有哪些 API 可用)
tools = [
{
"type": "function",
"function": {
"name": "get_weather",
"description": "获取指定城市的实时天气信息",
"parameters": {
"type": "object",
"properties": {
"city": {
"type": "string",
"description": "城市名称,如'北京'、'上海'"
},
"unit": {
"type": "string",
"enum": ["celsius", "fahrenheit"],
"description": "温度单位"
}
},
"required": ["city"]
}
}
},
{
"type": "function",
"function": {
"name": "search_web",
"description": "在互联网上搜索实时信息",
"parameters": {
"type": "object",
"properties": {
"query": {"type": "string", "description": "搜索关键词"}
},
"required": ["query"]
}
}
}
]② 模型自主决策调用
import openai
import json
def run_agent_with_tools(user_message: str):
messages = [{"role": "user", "content": user_message}]
while True:
# 1. 调用 LLM,传入工具列表
response = openai.chat.completions.create(
model="gpt-4o",
messages=messages,
tools=tools,
tool_choice="auto" # 让模型自主决定是否调用工具
)
assistant_msg = response.choices[0].message
# 2. 检查模型是否决定调用工具
if assistant_msg.tool_calls:
messages.append(assistant_msg) # 加入消息历史
for tool_call in assistant_msg.tool_calls:
func_name = tool_call.function.name
func_args = json.loads(tool_call.function.arguments)
# 3. 执行对应的 API
if func_name == "get_weather":
result = get_weather(**func_args)
elif func_name == "search_web":
result = search_web(**func_args)
# 4. 将 API 结果加入消息
messages.append({
"role": "tool",
"tool_call_id": tool_call.id,
"content": json.dumps(result, ensure_ascii=False)
})
else:
# 5. 模型不再调用工具,返回最终答案
return assistant_msg.content动态 API 调用的关键能力
自动参数生成: 根据用户意图自动构造 API 参数
用户:"帮我查一下明天上海的天气"
模型自动生成:{"city": "上海", "date": "tomorrow"}
多工具串联: 自动决策工具调用顺序
用户:"帮我找一家北京评分最高的米其林餐厅并查询今晚是否有空位"
Step 1: search_restaurant(city="北京", type="米其林")
Step 2: check_availability(restaurant_id="xxx", date="tonight")
错误重试: 调用失败时自动调整参数重试或切换备用工具。
Q6. LLM Agent 在多模态任务中如何执行推理?
多模态推理是指 Agent 能够同时处理文本、图像、音频、视频等多种类型的输入,并进行综合理解和推理。
多模态输入处理流程
图像输入 ──→ 视觉编码器(ViT / CLIP)────┐
音频输入 ──→ 语音识别(ASR / Whisper)───┤
文本输入 ──→ 文本 Tokenizer ───────────→ LLM 统一推理 → 输出
视频输入 ──→ 视频帧采样 + 视觉编码器 ───┘
主要实现方式
① 视觉语言模型(VLM)
代表模型:GPT-4V、Claude 3、Gemini、LLaVA、Qwen-VL
import openai
import base64
def analyze_image_with_agent(image_path: str, question: str):
# 将图片编码为 base64
with open(image_path, "rb") as f:
image_data = base64.b64encode(f.read()).decode()
response = openai.chat.completions.create(
model="gpt-4o",
messages=[{
"role": "user",
"content": [
{
"type": "image_url",
"image_url": {
"url": f"data:image/jpeg;base64,{image_data}"
}
},
{
"type": "text",
"text": question
}
]
}]
)
return response.choices[0].message.content
# 使用示例
result = analyze_image_with_agent(
"product_image.jpg",
"请分析这张图片中的产品,描述其特点并预估价格区间"
)② 多模态 ReAct 推理
Agent 在推理过程中动态决定需要处理哪种模态的信息:
用户上传:一张合同截图 + 文字"帮我分析这份合同有没有风险条款"
Thought 1: 用户上传了图片,我需要先识别图片中的文字内容
Action 1: ocr_tool(image="contract.jpg")
Observation 1: [合同文字内容]
Thought 2: 已获取合同文字,现在分析风险条款
Action 2: legal_analysis_tool(text="[合同内容]", focus="风险条款")
Observation 2: 发现3处潜在风险条款...
Thought 3: 分析完成,整理输出
Final Answer: 该合同存在以下3处风险条款...
③ 多模态输出
Agent 不只能接收多模态输入,还能生成多模态输出:
- 文字 + 图表(调用代码执行器生成可视化)
- 文字 + 语音(TTS 合成)
- 文字 + 结构化文档(生成 PDF/PPT)
多模态推理的挑战
| 挑战 | 说明 |
|---|---|
| 跨模态对齐 | 确保视觉理解与文本推理保持一致性 |
| 幻觉问题 | VLM 可能”看到”实际不存在的内容 |
| 长视频理解 | 视频帧数量大,Token 消耗极高 |
| 实时性 | 多模态处理延迟高于纯文本 |
Q7. LLM Agent 要有哪些局限性?
了解局限性是避免过度期望、合理部署的前提。LLM Agent 的主要局限性如下:
① 幻觉问题(Hallucination)
LLM 可能自信地生成错误信息,在 Agent 中危害更大——错误的工具调用参数、错误的事实推理会导致任务失败甚至产生损失。
表现: 编造不存在的 API 参数、给出错误的数据库查询结果解读、捏造引用来源。
② 上下文窗口限制
即使最新模型支持 128K 甚至百万 Token 的上下文,长文档处理、长时间会话仍面临”注意力稀释”——关键信息被淹没在大量内容中,模型表现下降。
③ 推理延迟高
每次 LLM 调用需要数秒,复杂任务需要多轮 ReAct 循环,累积延迟可达数十秒甚至分钟级,不适合强实时性场景(如高频交易、实时控制)。
④ 成本高昂
每次 LLM 调用消耗大量 Token,多步骤 Agent 的 Token 消耗是单次问答的数倍到数十倍,大规模部署时运营成本显著。
⑤ 规划能力上限
对于需要数十步甚至数百步的超长任务,Agent 容易在中途迷失目标、偏离计划、陷入循环,当前 LLM 的长程规划能力仍有明显上限。
⑥ 工具调用不稳定
模型可能选错工具、构造错误的参数、无法正确解析工具返回的结果,特别是在工具数量多、描述不清晰时更为明显。
⑦ 缺乏真正的学习能力
当前 LLM Agent 在推理阶段无法更新模型权重,每次对话都是独立的(除非有外部记忆)。它不像人类一样能从经验中真正”学习”和”成长”。
⑧ 安全与可控性挑战
- Prompt Injection:外部内容(网页、文档)中可能隐藏恶意指令
- 越权操作:Agent 可能被诱导执行超出授权范围的操作
- 不可预测行为:在复杂环境中,Agent 的行为难以完全预判
⑨ 知识时效性
LLM 的训练数据有截止日期,对最新事件、最新技术的了解需要依赖外部工具(搜索、RAG)弥补。
局限性应对策略汇总
| 局限性 | 应对方案 |
|---|---|
| 幻觉 | 工具验证 + RAG + 自我反思 |
| 上下文限制 | 记忆摘要 + 向量检索 |
| 高延迟 | 并行工具调用 + 小模型分流 |
| 高成本 | 缓存 + 模型蒸馏 + 路由 |
| 规划弱 | Plan-and-Execute + 人工检查点 |
| 安全风险 | 输入净化 + 权限最小化 + 审计日志 |
Q8. 如何衡量 LLM Agent 的性能?
衡量 Agent 性能需要从多个维度综合评估,单一指标容易被”刷榜”。
核心指标
① 任务成功率(Task Success Rate)
最核心的指标——Agent 最终是否完成了用户交代的任务。
成功率 = 成功完成的任务数 / 总任务数 × 100%
细化:
- 完全成功:结果完全正确
- 部分成功:完成关键步骤但细节有误
- 失败:未能完成任务
② 效率指标
步骤效率 = 最优步骤数 / 实际步骤数
(越接近1越高效,Agent 没走弯路)
Token 效率 = 任务价值 / 消耗 Token 数
(衡量成本效益)
端到端延迟 = 任务开始 → 最终结果的总时间
③ 准确性与可靠性
- 幻觉率:输出中包含事实错误的比例
- 工具调用准确率:正确选择工具并生成有效参数的比例
- 一致性:相同任务多次执行结果的稳定程度
④ 安全性指标
- 安全违规率:在对抗测试中执行不安全操作的比例
- 越狱成功率:被攻击者绕过安全限制的频率(越低越好)
主流评测基准
| 基准 | 评测维度 | 特点 |
|---|---|---|
| AgentBench | Web/代码/DB/OS 多场景 | 综合全面 |
| WebArena | 真实网页操作任务 | 贴近实际 |
| SWE-bench | GitHub Issue 修复 | 代码能力 |
| GAIA | 现实世界复杂问题 | 高难度 |
| ToolBench | 工具调用能力 | 工具使用 |
| HotpotQA | 多跳推理 | 推理链 |
评测方法
自动评测: 对于有明确正确答案的任务(代码执行结果、数据库查询结果),自动比对。
LLM-as-Judge: 用更强的 LLM(如 GPT-4)对 Agent 的开放性输出打分,适合无唯一正确答案的任务。
人工评测: 对于高质量要求的场景,邀请领域专家或目标用户进行评估,是最可靠但成本最高的方式。
Q9. 未来 LLM Agent 可能有哪些技术突破?
① 无限上下文与真正的长期记忆
当前最大上下文约 100 万 Token,但仍有衰减问题。未来方向:
- 真正”无损”的无限上下文处理
- 与外部记忆深度融合,像人类一样自然地”记住”任何事
- 主动遗忘机制:像人类记忆一样,对不重要信息自动淡化
② 自主工具创建与自我扩展
当前 Agent 只能用预定义工具。未来:
- Agent 自主编写并测试新工具
- 自动爬取 API 文档并学会使用陌生 API
- 工具能力的自我进化和版本管理
③ 多 Agent 协作的规模化
从当前 3-5 个 Agent 协作,扩展到数百个专业化 Agent 组成的”AI 组织”:
- 自动化的任务分工与招募
- Agent 之间的信任评估与协作规范
- 涌现性的集体智慧
④ 持续学习与在线适应
当前 Agent 在推理时无法更新模型权重。未来:
- 从每次任务执行中在线学习
- 低开销的持续微调(无灾难性遗忘)
- 个性化 Agent 随用户使用时间增长而持续进化
⑤ 可验证推理
将神经网络的”直觉”与符号逻辑的”严谨”结合:
- Agent 的关键推理步骤附带形式化证明
- 在医疗、法律、金融等高风险领域实现可信 Agent
⑥ 具身与物理世界融合
Agent 走出数字世界,控制机器人在物理世界行动:
- VLA(视觉语言行动)模型统一感知与控制
- 家庭服务机器人、工厂自动化、手术辅助
⑦ 超低能耗的边缘 Agent
将 Agent 能力压缩到手机/IoT 设备:
- 1-bit 量化模型(BitNet)
- 神经形态芯片(毫瓦级推理)
- 无处不在的个人 AI 助理
Q10. 请你设计一个 LLM Agent,用于医学问答,它需要具备哪些能力?
设计背景与挑战
医学领域是 AI Agent 应用的高风险场景,要求:
- 准确性极高:错误的医学建议可能危及生命
- 知识时效性:医学指南、药物说明持续更新
- 合规性:不能替代医生诊断,必须规范引导
- 安全性:需防止被滥用(如获取处方药信息)
核心能力设计
① 专业知识库(Medical RAG)
medical_knowledge_sources = {
"临床指南": ["中国临床肿瘤学会指南", "WHO 治疗指南", "UpToDate"],
"药品数据库": ["FDA 药品说明书", "中国药典", "药物相互作用数据库"],
"医学文献": ["PubMed 论文库", "Cochrane 系统综述"],
"症状百科": ["MedlinePlus", "默克诊疗手册"],
}
# 分层检索策略
def medical_rag_search(query, level="general"):
if level == "professional": # 医生用户
return search_clinical_guidelines(query) + search_pubmed(query)
else: # 普通患者
return search_medline(query) + search_drug_database(query)② 意图识别与安全分级
INTENT_SAFETY_MAP = {
"症状查询": {"level": "safe", "action": "提供信息 + 建议就医"},
"用药咨询": {"level": "caution", "action": "提供基础信息 + 强烈建议医生指导"},
"自我诊断": {"level": "warning", "action": "提供参考 + 明确说明不能替代诊断"},
"急救情况": {"level": "urgent", "action": "立即提供急救步骤 + 催促拨打120"},
"处方药获取": {"level": "refuse", "action": "拒绝 + 引导正规就医"},
"心理危机": {"level": "critical","action": "立即提供危机热线 + 陪伴对话"},
}③ 核心工具集
medical_agent_tools = [
symptom_checker_tool, # 症状初步分析(基于症状→可能疾病映射)
drug_info_tool, # 药品说明书查询(成分、用法、禁忌、副作用)
drug_interaction_checker, # 药物相互作用检查(多药联用安全性)
medical_literature_search, # PubMed 文献检索
hospital_finder, # 附近医院/专科查询
triage_tool, # 病情分诊(判断是否需要急诊)
icd_code_lookup, # 疾病分类编码查询(供专业人员使用)
]④ 分层用户权限
USER_ROLES = {
"patient": # 患者:症状查询、用药基础信息、就医引导
"nurse": # 护士:增加护理操作指南
"doctor": # 医生:全量临床指南、处方信息、文献检索
"researcher": # 研究人员:文献数据库全量访问
}⑤ 必须包含的安全机制
免责声明(每次回答末尾):
"本回答仅供健康参考,不构成医疗诊断或治疗建议。
如有健康问题,请及时咨询专业医生。"
紧急情况识别:
检测到以下关键词 → 立即提供急救指导 + 推送急救热线
["心跳骤停", "大量出血", "严重过敏", "不省人事", "呼吸困难"...]
自杀/自伤识别:
检测到相关意向 → 立即切换到心理危机干预模式
推送:北京心理危机热线 010-82951332 / 全国 400-161-9995
完整系统架构
用户输入
↓
安全意图分类(拒绝/警告/通过)
↓
用户身份识别(患者/医生/研究员)
↓
医学知识 RAG 检索(分层知识库)
↓
LLM 推理(GPT-4 / 医学专用微调模型)
↓
工具调用(症状分析/药品查询/文献检索)
↓
答案生成 + 安全审核
↓
输出:[专业回答] + [免责声明] + [就医建议]
技术选型建议
| 组件 | 推荐方案 |
|---|---|
| 基础模型 | GPT-4o 或医学微调模型(BioMistral、Med-PaLM 2) |
| 向量数据库 | Weaviate(支持医学本体 SNOMED CT) |
| Embedding | BioBERT 或 text-embedding-3-large |
| 框架 | LangChain + LangSmith(可观测性) |
| 合规审核 | 独立的安全分类模型(双重防护) |
关于主流 Agent 框架的10个入门题
F2. LangChain 的核心组件有哪些?
LangChain 是目前最主流的 LLM 应用开发框架,其核心组件构成了完整的 Agent 开发生态。
六大核心组件
① Model I/O(模型输入输出)
统一封装不同 LLM 提供商的接口,一套代码切换任意模型:
from langchain.chat_models import ChatOpenAI, ChatAnthropic
# 切换模型只需修改这一行
llm = ChatOpenAI(model="gpt-4o", temperature=0)
# llm = ChatAnthropic(model="claude-3-5-sonnet")
# Prompt 模板
from langchain.prompts import ChatPromptTemplate
prompt = ChatPromptTemplate.from_messages([
("system", "你是一个专业的{role}"),
("human", "{question}")
])
chain = prompt | llm # 用管道符组合② Data Connection(数据连接)
RAG 的核心组件,将外部文档接入 LLM:
from langchain.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.vectorstores import Chroma
from langchain.embeddings import OpenAIEmbeddings
# 完整 RAG 流程
loader = PyPDFLoader("document.pdf") # 1. 加载文档
docs = loader.load()
splitter = RecursiveCharacterTextSplitter( # 2. 分块
chunk_size=1000, chunk_overlap=200
)
chunks = splitter.split_documents(docs)
vectorstore = Chroma.from_documents( # 3. 向量化存储
chunks, OpenAIEmbeddings()
)
retriever = vectorstore.as_retriever(k=5) # 4. 检索器③ Chains(链)
将多个 LLM 调用和工具调用串联成工作流:
from langchain.chains import RetrievalQA
# RAG 问答链
qa_chain = RetrievalQA.from_chain_type(
llm=llm,
retriever=retriever,
chain_type="stuff" # stuff / map_reduce / refine
)
answer = qa_chain.run("这份文档的主要结论是什么?")④ Agents(智能体)
让 LLM 自主决策使用哪些工具:
from langchain.agents import initialize_agent, AgentType
from langchain.tools import Tool
tools = [search_tool, calculator_tool, weather_tool]
agent = initialize_agent(
tools=tools, llm=llm,
agent=AgentType.OPENAI_FUNCTIONS,
verbose=True
)
agent.run("今天北京天气如何?加上华氏度是多少?")⑤ Memory(记忆)
管理对话上下文和历史:
from langchain.memory import (
ConversationBufferMemory, # 保留全部历史
ConversationSummaryMemory, # 摘要压缩历史
ConversationBufferWindowMemory, # 滑动窗口
VectorStoreRetrieverMemory, # 向量检索历史
)⑥ Callbacks(回调)
监控和追踪 Agent 的执行过程:
from langchain.callbacks import LangChainTracer
# 对接 LangSmith,可视化追踪每一步的输入输出
tracer = LangChainTracer(project_name="my_agent")
agent.run("问题", callbacks=[tracer])F3. LangChain Agent 的主要类型有哪些?
LangChain 提供了多种 Agent 类型,适用于不同场景:
主要 Agent 类型
① ZERO_SHOT_REACT_DESCRIPTION(最常用)
无需示例,基于工具的描述(description)自主决定何时调用哪个工具。
agent = initialize_agent(
tools, llm,
agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
verbose=True
)适用场景:通用任务,工具描述清晰的场景。
② OPENAI_FUNCTIONS / OPENAI_TOOLS
利用 OpenAI 的 Function Calling 原生能力,比 ReAct 更稳定,输出结构化。
agent = initialize_agent(
tools, llm,
agent=AgentType.OPENAI_FUNCTIONS
)适用场景:使用 OpenAI 模型的生产场景,稳定性要求高。
③ CONVERSATIONAL_REACT_DESCRIPTION
在 ReAct 基础上加入对话历史管理,支持多轮对话中的上下文追踪。
memory = ConversationBufferMemory(memory_key="chat_history")
agent = initialize_agent(
tools, llm,
agent=AgentType.CONVERSATIONAL_REACT_DESCRIPTION,
memory=memory
)④ STRUCTURED_CHAT_ZERO_SHOT_REACT_DESCRIPTION
支持多参数结构化工具调用,当工具需要复杂的多字段输入时使用。
⑤ PLAN_AND_EXECUTE(规划-执行型)
先完整生成任务计划,再逐步执行——适合长流程、确定性任务:
from langchain_experimental.plan_and_execute import (
PlanAndExecute, load_agent_executor, load_chat_planner
)
planner = load_chat_planner(llm)
executor = load_agent_executor(llm, tools)
agent = PlanAndExecute(planner=planner, executor=executor)Agent 类型选择指南
| 场景 | 推荐类型 |
|---|---|
| 通用工具调用,快速原型 | ZERO_SHOT_REACT |
| OpenAI 模型,生产环境 | OPENAI_FUNCTIONS |
| 多轮对话机器人 | CONVERSATIONAL_REACT |
| 长流程、结构化任务 | PLAN_AND_EXECUTE |
| 复杂多参数工具 | STRUCTURED_CHAT |
F4. LlamaIndex 如何与 LangChain 结合?
LlamaIndex(原名 GPT Index)专注于数据索引与检索,LangChain 专注于应用流程编排,两者结合能取长补短。
各自的核心优势
| 框架 | 核心优势 | 适合场景 |
|---|---|---|
| LlamaIndex | 复杂文档索引、层级检索、知识图谱 | RAG、文档问答 |
| LangChain | Agent 编排、工具链、记忆管理 | 多步骤 Agent、对话系统 |
结合方式
① 将 LlamaIndex 索引作为 LangChain 的检索工具
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
from langchain.tools import Tool
# 1. 用 LlamaIndex 构建高质量索引
documents = SimpleDirectoryReader("./docs").load_data()
index = VectorStoreIndex.from_documents(documents)
query_engine = index.as_query_engine()
# 2. 封装为 LangChain Tool
llamaindex_tool = Tool(
name="document_search",
func=lambda q: str(query_engine.query(q)),
description="用于搜索公司内部文档,回答基于文档的问题"
)
# 3. 注入 LangChain Agent
agent = initialize_agent(
tools=[llamaindex_tool, search_tool, calculator_tool],
llm=llm,
agent=AgentType.OPENAI_FUNCTIONS
)② LlamaIndex SubQuestion Query Engine(复杂问题分解)
LlamaIndex 的子问题引擎将复杂问题自动分解为多个子查询,分别检索后综合:
from llama_index.core.query_engine import SubQuestionQueryEngine
from llama_index.core.tools import QueryEngineTool
# 多个专属文档的查询引擎
tools = [
QueryEngineTool.from_defaults(query_engine=q1, name="财务报告"),
QueryEngineTool.from_defaults(query_engine=q2, name="市场分析"),
]
# 子问题引擎自动分解并并行查询
sub_question_engine = SubQuestionQueryEngine.from_defaults(query_engine_tools=tools)
response = sub_question_engine.query("对比2023年和2024年的财务表现和市场份额变化")最佳实践
在实际项目中,推荐的组合方式:LlamaIndex 负责数据层(文档加载、分块、索引、检索),LangChain 负责应用层(Agent 编排、记忆、工具调用、输出处理)。
F5. AutoGPT 如何实现自主决策?
AutoGPT 是早期最具影响力的自主 Agent 项目,展示了 LLM Agent 自主完成长期任务的可能性。
AutoGPT 的核心架构
目标设定(用户提供高层目标)
↓
┌─────────────────────────────────┐
│ AutoGPT 决策循环 │
│ │
│ Prompt 构建: │
│ - AI 角色定义 │
│ - 长期目标 │
│ - 短期记忆(最近行动) │
│ - 长期记忆(向量检索) │
│ - 可用命令列表 │
│ ↓ │
│ LLM 推理(GPT-4) │
│ 输出:thoughts + command │
│ ↓ │
│ 命令执行(工具调用) │
│ ↓ │
│ 结果反馈 → 下一轮循环 │
└─────────────────────────────────┘
AutoGPT 的决策机制
① 结构化 Thought 输出
每次推理,AutoGPT 要求 LLM 输出结构化的思考过程:
{
"thoughts": {
"text": "当前分析:需要先研究竞品,再制定策略",
"reasoning": "没有竞品信息就无法制定有效策略",
"plan": "- 搜索竞品信息\n- 分析优劣势\n- 生成报告",
"criticism": "搜索结果可能不全面,需要多个来源交叉验证",
"speak": "我将开始搜索竞品信息"
},
"command": {
"name": "web_search",
"args": {"query": "竞品A 2024年产品功能分析"}
}
}② 自我批评(Self-Criticism)
在每次行动前,AutoGPT 会生成”criticism”字段,对自己的计划提出质疑,减少错误决策。
③ 长短期记忆协同
- 短期记忆:最近 N 次行动的摘要,放入 Prompt
- 长期记忆:所有历史信息存入向量数据库,检索时按相关性召回
AutoGPT 的局限性
AutoGPT 作为早期探索,暴露了自主 Agent 的核心问题:
- 容易陷入无限循环(反复执行相同操作)
- 任务漂移(偏离原始目标)
- 成本高昂(每次决策循环消耗大量 Token)
- 缺乏有效的任务终止机制
这些问题推动了后续更成熟框架(LangGraph、AutoGen、CrewAI)的诞生。
F6. BabyAGI 如何进行任务管理?
BabyAGI 是一个轻量但极具启发性的自主 Agent 框架,以任务队列 + 优先级调度为核心,展示了 AGI 的雏形。
BabyAGI 的三个核心 Agent
┌──────────────────────────────────────────┐
│ BabyAGI │
│ │
│ ┌──────────┐ ┌──────────┐ │
│ │ Task │ │ Execution│ │
│ │ Creation │ │ Agent │ │
│ │ Agent │ │ (执行) │ │
│ └────┬─────┘ └────┬─────┘ │
│ │ │ │
│ ┌────▼───────────────▼──────┐ │
│ │ Task Prioritization │ │
│ │ Agent(优先级排序) │ │
│ └───────────────────────────┘ │
│ │ │
│ ┌───────▼────────┐ │
│ │ Task Queue │ │
│ │ (任务队列) │ │
│ └────────────────┘ │
└──────────────────────────────────────────┘
任务管理流程
# BabyAGI 核心循环(简化版)
def baby_agi_loop(objective, initial_task):
task_list = deque([{"task_id": 1, "task_name": initial_task}])
task_id_counter = 1
while task_list:
# 1. 取出最高优先级任务
task = task_list.popleft()
print(f"执行任务: {task['task_name']}")
# 2. 执行任务(调用 LLM + 工具)
result = execution_agent(objective, task["task_name"])
# 3. 将结果存入向量数据库
vectorstore.add_texts([result], metadatas=[{"task": task["task_name"]}])
# 4. 创建新任务(基于执行结果和目标)
new_tasks = task_creation_agent(
objective=objective,
result=result,
task_description=task["task_name"],
incomplete_tasks=[t["task_name"] for t in task_list]
)
# 5. 将新任务加入队列
for new_task in new_tasks:
task_id_counter += 1
task_list.append({"task_id": task_id_counter, "task_name": new_task})
# 6. 重新排列任务优先级
task_list = deque(prioritization_agent(objective, task_id_counter, task_list))BabyAGI 的创新点
- 任务自我生成:执行任务后自动生成后续任务,无需人工干预
- 优先级动态调整:根据目标和已有结果,持续调整任务队列顺序
- 结果积累:每次执行结果存入向量数据库,后续任务可检索利用
BabyAGI 与 AutoGPT 的对比
| 维度 | BabyAGI | AutoGPT |
|---|---|---|
| 核心抽象 | 任务队列管理 | 命令循环 |
| 代码量 | 极少(~200行) | 较多 |
| 架构清晰度 | 高(三个明确 Agent) | 中 |
| 扩展性 | 良好 | 一般 |
| 适合学习 | 非常适合 | 适合 |
F7. CrewAI 如何管理多个 Agent 之间的协作?
CrewAI 是专门为多 Agent 协作设计的框架,以”团队(Crew)+ 角色(Role)+ 任务(Task)“为核心抽象。
核心概念
① Agent(智能体)
每个 Agent 有明确的角色、目标和背景故事,LLM 会在这个角色框架内行动:
from crewai import Agent
researcher = Agent(
role="市场研究员",
goal="收集和分析目标市场的最新趋势和竞品信息",
backstory="""你是一位有10年经验的市场研究专家,
擅长通过多种渠道收集数据并识别关键市场信号。""",
tools=[search_tool, web_scraper_tool],
llm=llm,
verbose=True
)
writer = Agent(
role="内容撰写专家",
goal="将研究结果转化为清晰、有说服力的市场报告",
backstory="你是一位专业的商业写作专家,擅长将复杂数据转化为易懂的报告。",
tools=[],
llm=llm
)② Task(任务)
定义每个 Agent 需要完成的具体工作,以及预期输出:
from crewai import Task
research_task = Task(
description="""研究2024年AI Agent市场的最新趋势:
1. 主要玩家和市场份额
2. 技术发展方向
3. 主要客户需求变化""",
expected_output="包含数据支撑的市场趋势分析报告(1000字以上)",
agent=researcher, # 指定执行的 Agent
)
writing_task = Task(
description="基于研究员的分析报告,撰写一份面向高管的简报(不超过500字)",
expected_output="结构清晰的高管简报,包含关键发现和行动建议",
agent=writer,
context=[research_task] # 依赖 research_task 的输出
)③ Crew(团队)
将多个 Agent 和任务组合成协作团队,定义执行流程:
from crewai import Crew, Process
crew = Crew(
agents=[researcher, writer],
tasks=[research_task, writing_task],
process=Process.sequential, # 顺序执行(也支持 hierarchical 层级模式)
verbose=True
)
result = crew.kickoff()两种协作流程
顺序模式(Sequential): 任务按顺序依次执行,前一个任务的输出自动传递给下一个。
层级模式(Hierarchical): 由一个 Manager Agent 统筹协调,根据情况动态分配任务给其他 Agent:
manager = Agent(
role="项目经理",
goal="协调团队完成整体目标",
allow_delegation=True # 允许将任务委托给其他 Agent
)
crew = Crew(
agents=[manager, researcher, analyst, writer],
tasks=[complex_task],
process=Process.hierarchical,
manager_llm=llm
)CrewAI vs AutoGen vs LangChain
| 维度 | CrewAI | AutoGen | LangChain |
|---|---|---|---|
| 多 Agent 支持 | 原生核心能力 | 原生支持(对话驱动) | 需手动编排 |
| 角色定义 | 角色+目标+背景故事 | 系统消息自定义 | 工具描述 |
| 协作模式 | 顺序/层级 | 对话/群聊 | 链式 |
| 上手难度 | 低 | 中 | 中 |
| 适用场景 | 内容生成、研究报告 | 代码开发、复杂推理 | 通用工具链 |
F8. LangChain 如何支持 API 调用?
LangChain 提供了多种方式将外部 API 集成到 Agent 工作流中。
方式一:自定义 Tool 封装
最灵活的方式,将任意 API 封装为 LangChain Tool:
from langchain.tools import tool
import requests
@tool
def get_stock_price(symbol: str) -> str:
"""
获取指定股票的实时价格。
参数 symbol:股票代码,如 'AAPL'、'TSLA'、'BIDU'
"""
url = f"https://api.example.com/stock/{symbol}"
response = requests.get(url, headers={"Authorization": f"Bearer {API_KEY}"})
data = response.json()
return f"{symbol} 当前价格:${data['price']},涨跌幅:{data['change_percent']}%"
# 直接在 Agent 中使用
agent = initialize_agent(
tools=[get_stock_price],
llm=llm,
agent=AgentType.OPENAI_FUNCTIONS
)
agent.run("苹果公司今天股价是多少?")方式二:Requests 工具包(通用 HTTP)
from langchain.tools import RequestsGetTool, RequestsPostTool
from langchain.utilities import TextRequestsWrapper
# GET 请求工具
get_tool = RequestsGetTool(requests_wrapper=TextRequestsWrapper())
# POST 请求工具(如调用 Webhook、提交数据)
post_tool = RequestsPostTool(requests_wrapper=TextRequestsWrapper())方式三:内置集成工具包
LangChain 内置了大量主流 API 的集成:
# 搜索 API
from langchain.tools import TavilySearchResults, GoogleSerperAPIWrapper
# 天气 API
from langchain_community.tools.openweathermap import OpenWeatherMapQueryRun
# 金融数据
from langchain_community.tools.yahoo_finance_news import YahooFinanceNewsTool
# 数据库查询
from langchain.utilities import SQLDatabase
from langchain_community.agent_toolkits import SQLDatabaseToolkit
# Wolfram Alpha 计算
from langchain_community.utilities import WolframAlphaAPIWrapper方式四:OpenAPI 规范自动解析
给定 API 的 OpenAPI/Swagger 文档,自动生成工具集:
from langchain_community.agent_toolkits.openapi import create_openapi_agent
from langchain_community.agent_toolkits.openapi.toolkit import OpenAPIToolkit
from langchain_community.utilities.requests import RequestsWrapper
import yaml
# 读取 OpenAPI 规范
with open("api_spec.yaml") as f:
spec = yaml.safe_load(f)
toolkit = OpenAPIToolkit.from_llm(
llm=llm,
json_spec=spec,
requests_wrapper=RequestsWrapper()
)
agent = create_openapi_agent(llm=llm, toolkit=toolkit)
agent.run("创建一个新用户,邮箱是 test@example.com")API 调用最佳实践
# 1. 错误处理:避免 API 错误导致 Agent 崩溃
@tool
def safe_api_call(query: str) -> str:
"""安全的 API 调用工具"""
try:
result = api_client.call(query)
return result
except requests.Timeout:
return "API 调用超时,请稍后重试"
except requests.HTTPError as e:
return f"API 调用失败:{str(e)}"
# 2. 结果缓存:避免重复调用
from functools import lru_cache
@lru_cache(maxsize=100)
def cached_api_call(query: str) -> str:
return expensive_api.call(query)F9. 如何优化 LLM Agent 的性能?
性能优化需要从速度、成本、准确性三个维度综合考量。
① 减少不必要的 LLM 调用
智能路由: 对于简单问题,用小模型或规则直接回答,只有复杂任务才调用大模型:
def smart_router(query: str) -> str:
complexity = estimate_complexity(query) # 评估问题复杂度
if complexity < 0.3:
return small_model.generate(query) # 简单问题:3B 模型
elif complexity < 0.7:
return medium_model.generate(query) # 中等问题:7B 模型
else:
return large_model.generate(query) # 复杂问题:GPT-4缓存重复查询: 对相同或语义相近的问题直接返回缓存结果:
from langchain.cache import RedisSemanticCache
import langchain
langchain.llm_cache = RedisSemanticCache(
redis_url="redis://localhost:6379",
embedding=OpenAIEmbeddings(),
score_threshold=0.95 # 相似度超过 0.95 直接命中缓存
)② 并行化工具调用
import asyncio
async def parallel_tool_execution(tools_and_args):
"""并行执行无依赖关系的工具调用"""
tasks = [tool.execute_async(**args) for tool, args in tools_and_args]
results = await asyncio.gather(*tasks)
return results
# 串行:总时间 = 500 + 300 + 200 = 1000ms
# 并行:总时间 = max(500, 300, 200) = 500ms(节省 50%)③ Prompt 优化
# ❌ 低效 Prompt:信息冗余,Token 浪费
system_prompt = """
你是一个非常聪明的、经验丰富的、专业的AI助理,你非常擅长回答各种各样的问题,
你拥有广博的知识,可以帮助用户解决任何他们遇到的问题...(300字废话)
"""
# ✅ 高效 Prompt:简洁精准
system_prompt = """你是专业助理。工具:{tools}。格式:Thought/Action/Observation。"""④ RAG 检索优化
# 混合检索:语义 + 关键词,提升召回率
from langchain.retrievers import EnsembleRetriever
from langchain.retrievers import BM25Retriever
semantic_retriever = vectorstore.as_retriever(k=5)
keyword_retriever = BM25Retriever.from_documents(docs)
# 混合检索,自动融合两种结果
ensemble_retriever = EnsembleRetriever(
retrievers=[semantic_retriever, keyword_retriever],
weights=[0.6, 0.4] # 语义权重更高
)⑤ 流式输出(Streaming)
让用户感知到 Agent 在”思考”,改善等待体验:
from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
llm = ChatOpenAI(
streaming=True,
callbacks=[StreamingStdOutCallbackHandler()]
)综合优化效果
| 优化手段 | 预期收益 |
|---|---|
| 智能路由 | 成本降低 60-80% |
| 语义缓存 | 重复查询延迟降低 95% |
| 并行工具调用 | 延迟降低 40-60% |
| Prompt 精简 | Token 消耗降低 20-30% |
| 流式输出 | 感知延迟降低 80%(TTFT) |
F10. LLM Agent 在企业应用中的典型场景有哪些?
① 智能客服与售前导购
场景: 电商、保险、金融等行业的售前咨询
能力: 多轮对话理解意图 → 查询商品/产品库 → 对比推荐 → 处理复杂询问 → 转人工
价值: 7×24 小时服务,处理 70-80% 的常见咨询,人工专注处理复杂高价值客户
② 企业知识库问答(Internal Knowledge Base QA)
场景: HR 政策问答、IT 支持、法务合规查询
能力: RAG 检索内部文档(规章制度、技术文档、合同模板)→ 精准引用来源回答
价值: 新员工入职成本降低,减少重复性问答,知识沉淀和传承
③ 代码助手与开发自动化
场景: IDE 插件、CI/CD 流程、代码审查
能力: 代码生成 → 单元测试 → Bug 定位 → 代码解释 → PR 审查
价值: GitHub Copilot 数据显示开发效率提升 55%,新人上手时间缩短 40%
④ 数据分析与报告自动化
场景: 财务报告、运营周报、市场分析
能力: 自然语言 → SQL 查询数据库 → Python 数据分析 → 自动生成可视化图表 → 撰写报告
# Text-to-SQL + 数据分析 Agent
agent.run("""
分析过去3个月各产品线的销售趋势,
找出增长最快的品类,并预测下季度业绩,
生成包含图表的分析报告
""")⑤ 流程自动化(RPA + AI)
场景: 发票处理、合同审查、采购审批
能力: 文档 OCR 识别 → 信息提取 → 规则校验 → 自动提交系统 → 异常报警
价值: 将人工操作从数小时压缩到分钟级,准确率超过人工
⑥ 销售与 CRM 增强
场景: 销售跟进、客户画像分析、商机识别
能力: 分析客户沟通记录 → 生成跟进建议 → 起草个性化邮件 → 预测成交概率
⑦ 安全运营(SecOps)
场景: 威胁检测、事件响应、漏洞分析
能力: 分析安全日志 → 识别异常行为模式 → 生成事件报告 → 推荐修复措施
企业落地建议
| 落地阶段 | 建议 |
|---|---|
| 试点选择 | 选择数据质量高、任务边界清晰的场景 |
| 安全合规 | 确保敏感数据不泄露给外部 LLM API |
| 效果评估 | 建立量化指标(准确率、处理时长、成本对比) |
| 人机协同 | 保留人工审核环节,逐步提升自动化比例 |
| 持续迭代 | 收集失败案例,持续优化知识库和 Prompt |
以上为 Agent 入门10题 + 主流 Agent 框架入门10题的完整解答。