Agent 入门10题 + 主流Agent框架入门10题

目录

Agent 入门10题

关于主流 Agent 框架的10个入门题


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 数
(衡量成本效益)

端到端延迟 = 任务开始 → 最终结果的总时间

③ 准确性与可靠性

  • 幻觉率:输出中包含事实错误的比例
  • 工具调用准确率:正确选择工具并生成有效参数的比例
  • 一致性:相同任务多次执行结果的稳定程度

④ 安全性指标

  • 安全违规率:在对抗测试中执行不安全操作的比例
  • 越狱成功率:被攻击者绕过安全限制的频率(越低越好)

主流评测基准

基准评测维度特点
AgentBenchWeb/代码/DB/OS 多场景综合全面
WebArena真实网页操作任务贴近实际
SWE-benchGitHub 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)
EmbeddingBioBERT 或 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、文档问答
LangChainAgent 编排、工具链、记忆管理多步骤 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 的对比

维度BabyAGIAutoGPT
核心抽象任务队列管理命令循环
代码量极少(~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

维度CrewAIAutoGenLangChain
多 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题的完整解答。