某书买的PDF，感觉还不错。分享出来。
最近写了很多Skill，Agent，Prompt..怎么更快让Ai理解我的意思，做出我要的效果，真正和Ai对话，是我最近比较感兴趣的知识，我不想再许愿了，而且Ai真的好贵，精准打击，能省就省才是真的..

【AI】AI Agent 算法工程师 & 开发工程师知识相关

涵盖：Agent 架构原理、前沿论文、工程实现、Python 编程、框架实战、RAG/MCP/A2A 协议、安全对齐、部署运维等全方位面试题。

基于 2025-2-23 版本全面更新，新增 2025 下半年~2026 年 Q1 的最新技术进展。

目录

• 第一章 AI Agent 核心概念与架构
• 第二章 Agent 主流框架深度解析（2026 更新）
• 第三章 Tool Use / Function Calling 机制
• 第四章 MCP 协议与 A2A 协议（2026 最新）
• 第五章 RAG 检索增强生成（前沿进展）
• 第六章 多智能体系统（Multi-Agent）
• 第七章 Agent 记忆系统
• 第八章 Agent 科研前沿（论文 & 算法）
• 第九章 Python Agent 工程实战
• 第十章 Agent 评估基准与可观测性
• 第十一章 Agent 安全、对齐与 Guardrails
• 第十二章 Agent 部署与成本优化
• 第十三章 高频综合面试题精选
• 第十四章 2026 新增：Agent 产品化与商业落地（新章节）
• 第十五章 2026 新增：Reasoning Model 与 Agent 的融合（新章节）

第一章 AI Agent 核心概念与架构

1.1 什么是 AI Agent？与普通 LLM 应用的本质区别

Q: 请定义 AI Agent 并说明它与普通 LLM 应用（如 ChatGPT 聊天）的本质区别。

AI Agent 是一个能够自主感知环境 → 做出决策 → 采取行动 → 观察反馈 → 循环迭代以实现特定目标的 AI 系统。

核心公式：Agent = LLM + Memory + Planning + Tool Use + Action Loop

吴恩达（Andrew Ng）在 2024 年总结的四种 Agentic Design Patterns：

1. Reflection：自我反思与修正
2. Tool Use：工具调用
3. Planning：任务规划与分解
4. Multi-Agent Collaboration：多智能体协作

2026 更新：Anthropic 在 2025 年发布的《Building Effective Agents》指南中进一步将 Agent 分为两大类：Workflows（预定义代码路径编排 LLM）和 Agents（LLM 自主决定控制流）。这一分类已成为业界共识。

1.2 ReAct（Reasoning + Acting）

Q: 详细解释 ReAct 模式的工作原理、优势与局限性。

由 Yao et al. (2022) 提出，将推理（Reasoning） 和行动（Acting） 交错进行。

执行流程：

用户问题 → Thought(思考) → Action(调用工具) → Observation(观察结果) → Thought → Action → ... → Fin

转换标记 C01： 原 PDF 第 2 页此代码／流程长行到达右侧裁切边界，可能不完整；保留可提取原文，未补写。

示例：

Question: 特斯拉2024年Q4的营收是多少？

Thought: 我需要搜索特斯拉最新财报数据
Action: search("特斯拉 2024 Q4 财报 营收")
Observation: 特斯拉2024年第四季度营收为257.07亿美元...

Thought: 我已经找到了答案
Final Answer: 特斯拉2024年Q4营收为257.07亿美元。

优势：

• 相比纯 CoT，可通过 Action 获取外部真实信息，减少幻觉
• 推理过程可解释，便于调试
• 灵活适应多种任务场景

局限性：

• 顺序执行效率较低，无法并行
• 缺乏全局规划，可能陷入局部最优或死循环
• 对 LLM 的工具选择能力依赖度高
• 没有显式回溯机制，一旦走错路难以纠正

1.3 Plan-and-Execute（计划与执行）

Q: Plan-and-Execute 与 ReAct 的核心区别是什么？什么场景该用哪个？

架构：

用户任务 → Planner(生成子任务列表) → Executor(逐步执行)
      ↑                                    |
      └── Replanner(根据结果调整计划) ←┘

Replanning 触发条件：

1. 子任务执行失败
2. 获取到与预期不符的信息
3. 发现原计划不完善需要补充步骤
4. 发现更优路径

1.4 LATS（Language Agent Tree Search）

Q: LATS 如何将蒙特卡洛树搜索应用到 Agent 决策中？

LATS 将 Agent 的决策过程建模为树搜索问题，结合 MCTS 的四步循环：

1. Selection（选择）：用 UCT 策略从根节点选择最有前景的节点
2. Expansion（扩展）：LLM 生成可能的下一步动作，创建子节点
3. Evaluation（评估）：LLM 自我评估当前状态的价值或获取环境反馈
4. Backpropagation（回传）：将评估结果传播回父节点，更新统计信息

相比 ReAct 的改进： ReAct 是单路径探索，一旦犯错难以回溯。LATS 探索多条路径，能回溯到之前的状态尝试不同策略。但计算成本显著增加（需要多次 LLM 调用）。

适用场景： 复杂推理任务、代码生成（需要多次尝试）、博弈决策。

1.5 Reflexion（自我反思）

Q: Reflexion 如何实现"不更新权重的学习"？

由 Shinn et al. (2023) 提出。

工作流程：

Task → Actor(执行) → Evaluator(评估) → Self-Reflection(生成反思)
                                              ↓
                                     Memory(存储反思文本)
                                              ↓
                              Actor(利用反思重新执行) → ...

核心机制： 将自我反思结果以自然语言形式存储在情景记忆（Episodic Memory）中，在后续尝试中将这些反思作为 prompt 的一部分提供给 LLM。这是一种 in-context learning 的方式，不需要微调模型参数。

反思示例：

[第1次尝试] 我直接搜索了完整问题，得到的结果不相关。
[反思] 下次应该将问题分解为子问题，逐步搜索。
[第2次尝试] 成功——将问题分解后逐步查找。

1.6 其他重要架构

1.7 如何选择 Agent 架构？

Q: 给定一个具体任务，如何选择合适的 Agent 架构？

简单工具调用          → 基础 Function Calling Agent
需要多步推理          → ReAct
复杂任务需要全局规划    → Plan-and-Execute
需要高质量决策/回溯    → LATS (Tree Search)
需要从失败中学习       → Reflexion
需要多角色协作         → Multi-Agent (CrewAI / AutoGen / LangGraph)
需要精细流程控制       → LangGraph 自定义 StateGraph
需要自主深度研究       → Deep Research Agent（OpenAI / Anthropic）
需要操作电脑完成任务    → Computer Use Agent（Claude / Operator）

2026 更新：Anthropic 的建议是"从最简单的方案开始"。不要一上来就用复杂的多 Agent 系统，先试试增强型 LLM（带工具调用），再逐步升级到 Workflow 和 Agent。

第二章 Agent 主流框架深度解析（2026 更新）

2.1 LangGraph（LangChain 团队）

Q: LangGraph 的核心抽象是什么？相比 LangChain AgentExecutor 有什么优势？

基于有向图（Directed Graph） 的 Agent 编排框架。

核心概念：

• State：全局状态对象，在节点间传递（TypedDict 或 Pydantic Model）
• Node：图中的计算节点，接收 State 返回更新
• Edge：连接节点的边，决定执行流程
• Conditional Edge：根据状态动态选择下一个节点
• Reducer：定义状态合并策略（如 add_messages 追加消息列表）
• Checkpointer：状态持久化，支持断点续跑
• Human-in-the-Loop：关键节点暂停等待人类确认

代码示例：

from typing import TypedDict, Annotated
from langgraph.graph import StateGraph, MessagesState, START, END
from langgraph.graph.message import add_messages
from langgraph.checkpoint.memory import MemorySaver

class AgentState(TypedDict):
    messages: Annotated[list, add_messages]
    iteration_count: int

def call_model(state: AgentState):
    response = llm.invoke(state["messages"])
    return {"messages": [response], "iteration_count": state["iteration_count"] + 1}

def should_continue(state: AgentState) -> str:
    last = state["messages"][-1]
    if last.tool_calls:
        return "tools"
    return END

graph = StateGraph(AgentState)
graph.add_node("agent", call_model)
graph.add_node("tools", tool_node)
graph.add_edge(START, "agent")
graph.add_conditional_edges("agent", should_continue)
graph.add_edge("tools", "agent")

app = graph.compile(
    checkpointer=MemorySaver(),
    interrupt_before=["tools"]
)

相比 AgentExecutor 的优势：

1. 任意复杂的图拓扑（条件分支、循环、并行）
2. 内置状态持久化 → 支持长时间运行任务
3. Human-in-the-Loop 原生支持
4. 更好的可观测性和调试能力
5. 支持多 Agent 协作编排

2026 更新：LangGraph 已推出 LangGraph Platform，提供云端托管、长期记忆（cross-thread memory）、Cron 调度等企业级功能。LangGraph Studio 提供可视化调试器。

2.2 OpenAI Agents SDK（2025.3 发布）

Q: OpenAI Agents SDK 的四大原语是什么？Handoff 机制如何工作？

替代了之前的 Swarm 实验项目，面向生产级部署。

四大原语：

1. Agent：指令 + 模型 + 工具 + 可选 Guardrails
2. Handoff：Agent 间任务转交（类似客服"转接"）
3. Guardrails：输入/输出验证和安全护栏
4. Tracing：内置追踪和可观测性

from agents import Agent, Runner, function_tool, handoff

@function_tool
def search_knowledge_base(query: str) -> str:
    """搜索内部知识库"""
    return vector_db.search(query, top_k=5)

billing_agent = Agent(
    name="Billing Agent",
    instructions="处理账单和退款问题。",
    model="gpt-4o",
    tools=[search_knowledge_base],
)

triage_agent = Agent(
    name="Triage Agent",
    instructions="根据问题类型转给合适的专家。",
    handoffs=[handoff(billing_agent, description="账单和付款问题")],
)

result = await Runner.run(triage_agent, "我的账单多扣了钱")

Handoff 底层原理： Handoff 注册为特殊 function tool → LLM 决定调用 → Runner 检测到并切换 active agent → 消息历史完整传递给新 Agent。

2026 更新：OpenAI 收购了 Windsurf（原 Codeium），并开源了 Codex CLI 作为终端编码 Agent。OpenAI Agents SDK 现已支持 MCP 工具集成。

2.3 Anthropic Claude Agent SDK（2025 新增）

Q: Anthropic 的 Agent 开发生态有哪些组件？

Anthropic 在 2025 年构建了完整的 Agent 开发生态：

Claude Code 核心特点：

• 直接在终端中使用，无需 IDE
• 支持 agentic loop：读文件→理解代码→编辑→运行测试→迭代
• 内置 MCP 支持，可连接外部工具
• Hooks 机制：在工具调用前后执行自定义 shell 命令
• 支持子代理（subagent）并行执行任务

2.4 CrewAI

Q: CrewAI 的核心抽象和多 Agent 协作模式是什么？

专注于角色扮演式多智能体协作。

核心抽象：

• Agent：角色（role）+ 目标（goal）+ 背景故事（backstory）
• Task：任务定义 + 预期输出 + 指定 Agent
• Crew：团队编排 + 执行流程
• Process：Sequential（顺序）/ Hierarchical（层次化，有 Manager Agent）

from crewai import Agent, Task, Crew, Process

researcher = Agent(
    role="市场研究员",
    goal="收集AI Agent市场最新趋势数据",
    backstory="你是一位资深市场分析师...",
    tools=[search_tool, web_scraper],
)

writer = Agent(
    role="技术作家",
    goal="将研究结果整理成专业报告",
    backstory="你擅长将复杂技术概念转化为易懂文字...",
)

research_task = Task(description="调研2025年AI Agent市场", agent=researcher)
write_task = Task(description="撰写市场报告", agent=writer)

crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, write_task],
    process=Process.sequential,
)
result = crew.kickoff()

2.5 AutoGen（微软）

Q: AutoGen 0.4 的重大重构有哪些变化？

• 事件驱动架构（Event-Driven Architecture）
• 更好的可扩展性和模块化
• 支持自定义 Agent runtime
• 核心概念：ConversableAgent、GroupChat、GroupChatManager

与 CrewAI 的区别： CrewAI 更注重角色扮演和任务流程编排（像组建团队）；AutoGen 更注重 Agent 间的对话和消息传递（像多方会议）。

2.6 Google ADK（Agent Development Kit）

2025 年 Google 开源的 Agent 开发框架，内置支持 MCP 和 A2A 协议，深度集成 Gemini 模型。

2026 更新：ADK 已支持 Gemini 2.5 Pro/Flash 系列模型，并提供了完整的 A2A 互操作示例。

2.7 框架选型指南（2026 更新版）

2026 行业趋势：框架选择不再是关键决策。随着 MCP/A2A 等标准的普及，Agent 组件日趋可替换。选择框架时更应关注其与团队技术栈的匹配度。

第三章 Tool Use / Function Calling 机制

3.1 Function Calling 工作原理

Q: Function Calling 是 prompt 工程还是模型训练的结果？

完整工作流程：

1. 开发者定义工具 schema (JSON Schema)
2. LLM 判断是否需要调用工具
3. 如需要，LLM 输出结构化工具调用请求 (name + arguments)
4. 应用层实际执行工具调用
5. 将工具结果返回给 LLM
6. LLM 基于结果生成最终响应（或继续调用工具）

回答： 现代主流模型（GPT-4o、Claude Sonnet/Opus 4.6 等）都经过专门的 tool use 训练。底层实现上，tool schema 会被转化为特殊格式注入系统 prompt，但模型对这种格式的理解和生成能力是通过训练获得的，不仅仅是简单的 prompt 工程。

3.2 OpenAI vs Anthropic 工具定义格式对比

OpenAI：

{
  "tools": [{
    "type": "function",
    "function": {
      "name": "get_weather",
      "description": "获取城市天气",
      "parameters": {
        "type": "object",
        "properties": {"city": {"type": "string"}},
        "required": ["city"]
      }
    }
  }]
}

Anthropic：

{
  "tools": [{
    "name": "get_weather",
    "description": "获取城市天气",
    "input_schema": {
      "type": "object",
      "properties": {"city": {"type": "string"}},
      "required": ["city"]
    }
  }]
}

3.3 提升 Function Calling 准确性的技巧

Q: 工具太多导致 LLM 选错工具怎么办？

1. 写清晰的工具描述：description 要明确说明何时使用该工具
2. 控制工具数量：单次请求 \< 20 个工具，太多用工具路由分组
3. 使用 enum 限制参数值：减少参数填写错误
4. 设置 tool\_choice ：强制或引导工具选择
5. 工具分组 / 路由：先用小模型判断类别，再加载对应工具集
6. 在 system prompt 中给出工具使用指南和示例

2026 更新：MCP 的 Tool Annotations（如 readOnlyHint 、 destructiveHint ）为工具提供了元数据标注，帮助 Agent 更好地判断工具的安全性和使用时机。

3.4 工具调用失败处理策略

Q: 工具调用失败了怎么办？

async def execute_tool_with_retry(tool_call, max_retries=3):
    for attempt in range(max_retries):
        try:
            result = await execute_tool(tool_call)
            return {"type": "tool_result", "tool_use_id": tool_call.id, "content": result}
        except RateLimitError:
            await asyncio.sleep(2 ** attempt)  # 指数退避
        except ToolExecutionError as e:
            return {
                "type": "tool_result",
                "tool_use_id": tool_call.id,
                "content": f"工具执行失败: {str(e)}",
                "is_error": True
            }
    return {"type": "tool_result", "tool_use_id": tool_call.id,
            "content": "工具在多次重试后仍然失败", "is_error": True}

关键原则： 将错误信息返回给 LLM，让 LLM 决定是重试、换工具、还是告知用户。

第四章 MCP 协议与 A2A 协议（2026 最新）

4.1 MCP（Model Context Protocol）

Q: MCP 是什么？它解决了什么问题？

Anthropic 于 2024.11 发布的开放协议，为 LLM 应用提供连接外部数据源和工具的统一标准。

类比：MCP 之于 AI 应用 = USB-C 之于硬件设备

解决的核心问题： M 个 AI 应用 × N 个外部服务 = M×N 个集成。有了 MCP 只需 M+N 个实现。

架构：

Host (Claude Desktop / Cursor / VS Code)
  └── MCP Client（维护连接）
        └── MCP Server（暴露能力）
              └── External Resource（GitHub / 数据库 / 文件系统）

三种能力（Primitives）：

4.2 MCP 2025-2026 年重大更新

Q: MCP 在 2025-2026 年有哪些关键更新？

生态数据（截至 2026 年初）：

• 月 SDK 下载量 9700 万+
• 10,000+ 活跃 MCP Server
• ChatGPT、Claude、Cursor、Gemini、VS Code、Copilot 全部支持
• MCP 成为 AI 工具连接的事实标准

4.3 MCP Transport 层

Q: stdio 和 Streamable HTTP 两种 Transport 各适用什么场景？

2026 新增重点： Streamable HTTP 已成为远程 MCP Server 的标准传输方式，支持请求/响应模式和可选的 SSE 流。

4.4 A2A 协议（Google Agent2Agent）

Q: A2A 和 MCP 有什么区别？它们是互补还是竞争关系？

Google 于 2025.4 发布，50+ 合作伙伴共建。2025.6 捐赠给 Linux Foundation。

核心区别：

关系：互补而非竞争。 一个完整的 Agentic 应用可能同时使用 MCP（连接工具和数据）和 A2A （Agent 间协作）。

A2A 核心概念：

• Agent Card：Agent 的"名片"，描述能力和接口（ .well-known/agent.json ）
• Task：Agent 间协作的基本单元，具有生命周期
• Message / Part：通信的消息格式，支持多模态
• Artifact：任务产出物（文件、数据等）

2026 更新：ANP（Agent Network Protocol） 也值得关注，由中国社区发起，专注去中心化 Agent 网络通信，与 A2A 形成差异化互补。

4.5 MCP vs Function Calling（高频面试题）

MCP 是更高层次的抽象，Function Calling 是其底层实现机制之一。

第五章 RAG 检索增强生成（前沿进展）

5.1 RAG 基础流程

文档处理: 加载 → 分块(Chunking) → 嵌入(Embedding) → 存入向量数据库
查询处理: 用户查询 → 查询改写 → 检索 → 重排序(Reranking) → 生成回答

5.2 RAG 演进：Naive → Advanced → Agentic

Q: 什么是 Agentic RAG？与传统 RAG 有何区别？

Agentic RAG 的核心改进：

• Agent 可以动态决定是否需要检索（不是每个问题都需要）
• 检索失败时自动调整策略（换关键词、换数据源）
• 支持多轮检索和推理（先检索背景知识，再检索细节）
• 可以跨多个数据源路由检索

5.3 Graph RAG（微软）

Q: Graph RAG 解决了传统 RAG 的什么问题？

传统 RAG 擅长回答具体细节问题（如"X 的定义是什么？"），但对全局性/总结性问题（如"数据集的主要主题有哪些？"）表现差。

Graph RAG 流程：

文档 → LLM 提取实体和关系 → 构建知识图谱 → 社区检测(Leiden算法)
→ 为每个社区生成摘要 → 查询时汇总相关社区摘要 → 生成回答

优势： 在全局性问题上显著优于传统向量 RAG。代价： 索引构建成本高（大量 LLM 调用），图谱维护复杂。

5.4 其他前沿 RAG 技术

5.5 分块策略（Chunking）

Q: 不同分块策略的优缺点？

最佳实践： 大多数场景用 RecursiveCharacterTextSplitter ，chunk\_size=512，overlap=50-100。

5.6 Embedding 模型与向量数据库选型（2026 更新）

2025-2026 主流 Embedding 模型：

• OpenAI: text-embedding-3-small/large
• Cohere: embed-v4
• 开源: BGE-M3 、 Jina Embedding v3 、 GTE-Qwen2
• Voyage AI（被 Anthropic 收购）: voyage-3 系列

向量数据库选型：

5.7 RAG 评估

Q: 如何评估 RAG 系统的质量？RAGAS 评估框架有哪些指标？

5.8 RAG vs 长上下文 vs 微调

Q: 这三种方式如何选择？

实际中往往组合使用。 长上下文模型的出现并没有取代 RAG，因为 RAG 在大规模知识库、成本控制、可追溯性方面仍有优势。

2026 更新：随着 Claude Opus 4.6（1M token 上下文）等超长上下文模型的出现，"先塞进上下文试试"成为可行的首选策略。但对于企业级海量知识库，RAG 仍不可替代。

第六章 多智能体系统（Multi-Agent）

6.1 多 Agent 架构模式

Q: 列举并解释常见的多 Agent 协作模式。

6.2 多 Agent 的优势与劣势

Q: 什么时候该用多 Agent？什么时候单 Agent 更好？

优势：

• 任务分解，每个 Agent 专注特定领域
• 可并行执行提高效率
• 通过辩论/审查提升质量
• 更好的可扩展性

劣势：

• 通信开销大，token 消耗显著增加
• 协调复杂度高，可能出现死循环
• 错误传播风险
• 调试困难

经验法则： 如果单 Agent 能在 5-10 步内完成，优先用单 Agent。任务确实需要不同专业能力或并行处理时才用多 Agent。

2026 更新（Anthropic 建议）：不要为了"多 Agent"而多 Agent。很多被设计为多 Agent 的系统实际上用单 Agent + 多工具就能解决。多 Agent 的额外复杂性（通信、同步、调试）往往被低估。

6.3 防止多 Agent 死循环

Q: 多 Agent 系统如何防止无限循环？

1. 设置最大迭代/对话轮次
2. 引入终止条件判断（如任务完成检测 Agent）
3. 设置超时机制
4. 使用状态追踪检测循环模式
5. 引入裁判 Agent 决定何时终止
6. 指数退避：连续相似输出时增加终止概率

第七章 Agent 记忆系统

7.1 记忆类型分类

Q: Agent 的记忆系统有哪些类型？分别如何实现？

7.2 上下文窗口管理策略

Q: 上下文窗口有限，长对话怎么处理？

2026 更新：Claude Opus 4.6 支持 1M token 上下文窗口，大幅缓解了上下文管理压力。但即便有超长上下文，"Lost in the Middle"问题仍然存在，分层记忆策略在生产环境中仍然必要。

7.3 MemGPT / Letta

Q: MemGPT 的核心思路是什么？

将操作系统虚拟内存管理思想应用到 LLM Agent：

• 上下文窗口 = "主存"（有限）

• 外部存储 = "磁盘"（无限）
• Agent 主动执行"内存管理"：将不重要信息"换出"（page out），需要时"换入"（page in）
• 使得 Agent 能管理远超上下文窗口大小的信息

2026 更新：LangGraph 已内置 cross-thread memory 功能，允许 Agent 在不同会话间共享记忆。Claude Code 也实现了基于文件的持久化记忆系统（MEMORY.md）。记忆系统正在从学术研究走向生产标配。

第八章 Agent 科研前沿（论文 & 算法）

8.1 推理增强（Reasoning）

Q: 当前 LLM 推理能力增强的主要方法有哪些？

DeepSeek-R1 关键创新：

• 通过纯 RL（强化学习）训练出推理能力，无需监督数据
• 训练过程中自发涌现了 Chain-of-Thought 行为
• 开源模型中推理能力最强之一
• 蒸馏技术：将大模型的推理能力蒸馏到小模型

Extended Thinking（Claude）的 Agent 应用：

response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=16000,
    thinking={"type": "enabled", "budget_tokens": 10000},
    messages=[{"role": "user", "content": "分析这段代码的安全漏洞..."}]
)
# thinking block 包含内部推理过程
# text block 包含最终回答

8.2 代码生成 Agent（2026 更新）

Q: 当前代码 Agent 的前沿发展如何？

SWE-bench 指标（2026 更新）： 评估 Agent 自动修复真实 GitHub issue 的能力。2025 年顶级系统在 SWE-bench Verified 上得分已超过 70%（o3 + agent scaffolding 达到约 69.1%），2026 年预计进一步突破。

8.3 Computer Use / GUI Agent

Q: 什么是 Computer Use Agent？技术原理是什么？

让 AI Agent 像人类一样操作计算机 GUI（截图 → 理解 → 生成鼠标/键盘操作）。

技术流程：

截屏 → 多模态 LLM 理解界面 → 生成操作指令(点击坐标/输入文字)
  ↑                                         ↓
  └──────── 执行操作并再次截屏 ←────────────┘

代表工作：

• Claude Computer Use（Anthropic）：直接操作桌面
• OpenAI Operator（2025）：基于 GPT-4o 的 Web Agent 产品
• Microsoft UFO：Windows GUI 操作 Agent
• OSWorld / AndroidWorld：桌面和移动端操作基准
• Browser Use / Playwright Agent：Web 自动化

8.4 重要论文清单（2026 更新版）

8.5 Agent 学习方法

Q: Agent 如何"学习"？有哪些方法？

第九章 Python Agent 工程实战

9.1 异步编程基础

Q: 为什么 Agent 开发大量使用 async/await？

Agent 的核心操作（LLM API 调用、工具执行、数据检索）都是 I/O 密集型。asyncio 的单线程协作式并发完美适配：

import asyncio

async def agent_step(tools_to_call: list):
    """并行执行多个工具调用"""
    async with asyncio.TaskGroup() as tg:  # Python 3.11+
        tasks = {tool.name: tg.create_task(execute_tool(tool)) for tool in tools_to_call}
    return {name: task.result() for name, task in tasks.items()}

9.2 并发控制与限流

Q: 如何实现 API 调用的速率限制？

class RateLimitedLLMClient:
    def __init__(self, rpm: int = 60, tpm: int = 100000):
        self.rpm_semaphore = asyncio.Semaphore(rpm)
        self.token_bucket = TokenBucket(tpm)

    async def call(self, messages, **kwargs):
        async with self.rpm_semaphore:
            await self.token_bucket.acquire(estimated_tokens)
            for attempt in range(3):
                try:
                    return await self._raw_call(messages, **kwargs)
                except RateLimitError:
                    wait = 2 ** attempt + random.uniform(0, 1)
                    await asyncio.sleep(wait)
            raise MaxRetriesExceeded()

9.3 Agentic Loop 实现（Anthropic 风格）

Q: 手写一个完整的 Agent Loop。

import anthropic

async def agent_loop(client, system_prompt, user_message, tools, max_steps=10):
    messages = [{"role": "user", "content": user_message}]

    for step in range(max_steps):
        response = await client.messages.create(
            model="claude-sonnet-4-20250514",
            system=system_prompt,
            max_tokens=4096,
            tools=tools,
            messages=messages,
        )

        messages.append({"role": "assistant", "content": response.content})

        if response.stop_reason == "tool_use":
            tool_results = []
            for block in response.content:
                if block.type == "tool_use":
                    result = await execute_tool(block.name, block.input)
                    tool_results.append({
                        "type": "tool_result",
                        "tool_use_id": block.id,
                        "content": str(result)
                    })
            messages.append({"role": "user", "content": tool_results})
        else:
            return next(b.text for b in response.content if b.type == "text")

    return "达到最大步数限制"

9.4 流式响应处理

Q: 如何实现 Agent 的流式输出？

async def stream_agent(client, messages, tools):
    async with client.messages.stream(
        model="claude-sonnet-4-20250514",
        max_tokens=4096,
        tools=tools,
        messages=messages,
    ) as stream:
        async for event in stream:
            if event.type == "content_block_delta":
                if event.delta.type == "text_delta":
                    yield {"type": "text", "content": event.delta.text}
            elif event.type == "message_stop":
                message = await stream.get_final_message()
                if message.stop_reason == "tool_use":
                    yield {"type": "tool_call", "content": message.content}

9.5 Python GIL 对 Agent 并发的影响

Q: GIL 对 Agent 开发有什么影响？如何绕过？

import asyncio
from concurrent.futures import ProcessPoolExecutor

async def hybrid_agent():
    loop = asyncio.get_running_loop()
    embeddings = await loop.run_in_executor(
        ProcessPoolExecutor(), compute_embeddings, documents
    )
    llm_response = await async_llm_call(prompt)

Python 3.13 新特性： 实验性 Free-threaded 模式（ python3.13t ）移除 GIL，CPU 密集 Agent 任务可直接用多线程。

9.6 Pydantic 在 Agent 中的应用

Q: Pydantic 在 Agent 开发中有哪些关键用途？

from pydantic import BaseModel, Field
from typing import Literal

# 1. 结构化输出验证
class AgentAction(BaseModel):
    thought: str = Field(description="推理过程")
    action: Literal["search", "calculate", "answer"] = Field(description="动作类型")
    action_input: str = Field(description="动作参数")

# 2. 工具参数定义
class SearchParams(BaseModel):
    query: str = Field(description="搜索关键词")
    max_results: int = Field(default=5, ge=1, le=20)

# 3. Agent State 定义
class ConversationState(BaseModel):
    messages: list[dict]
    tool_results: list[str] = []
    iteration: int = 0
    class Config:
        arbitrary_types_allowed = True

第十章 Agent 评估基准与可观测性

10.1 主要基准测试（2026 更新版）

10.2 Agent 评估维度

Q: 如何全面评估一个 Agent 系统？

10.3 LLM-as-Judge

Q: LLM-as-Judge 评估方法的优缺点？

优点： 成本低、可大规模自动化、能评估开放式问题。

缺点：

• 偏好偏差（偏好更长回答）
• 自我偏好（对自身模型输出评分更高）
• 位置偏差（偏好第一个/最后一个答案）

缓解方法： 多 Judge 投票、随机化顺序、标注数据校准、使用不同模型做 Judge。

10.4 可观测性（Observability）

Q: Agent 的 Tracing 和 Observability 如何实现？

工具生态：

• LangSmith：LangChain 官方，trace 可视化
• Phoenix (Arize)：开源 LLM 可观测性
• Braintrust：评估 + 监控
• OpenTelemetry：通用可观测性标准
• Logfire（2025新增）：Pydantic 团队的可观测性平台

关键数据： 每步延迟、Token 使用量、工具调用成功率、错误率、决策路径。

第十一章 Agent 安全、对齐与 Guardrails

11.1 核心安全威胁

Q: Agent 系统面临的主要安全威胁有哪些？

11.2 间接 Prompt Injection 防御

Q: 什么是间接 Prompt Injection？如何防御？

恶意指令不在用户输入中，而隐藏在 Agent 检索/读取的外部数据中（网页、文档、邮件）。当 Agent 处理这些数据时，恶意指令可能被执行。

防御措施：

1. 数据/指令分离：对外部数据加标记，明确区分数据和指令
2. 独立检测：用独立 LLM 调用检测可疑内容
3. 权限隔离：处理外部数据后限制可用操作
4. 敏感操作强制 HITL：Human-in-the-Loop 确认
5. Instruction Hierarchy（OpenAI）：区分系统/用户/工具消息的优先级

11.3 权限控制与沙箱

Q: 如何实现 Agent 的权限控制？

工具级别: 每个工具定义所需权限，Agent 只能调用被授权的工具
参数级别: 限制参数范围（如只允许查询特定数据库表）
操作级别: 区分读/写操作，写操作需额外确认
用户级别: 不同用户角色有不同 Agent 权限
环境级别: Agent 在沙箱中运行，限制系统调用和网络

11.4 Guardrails 实现

Q: 如何实现 Agent 的输入/输出安全护栏？

# OpenAI Agents SDK 风格
from agents import Agent, GuardrailFunctionOutput, input_guardrail

@input_guardrail
async def check_injection(ctx, agent, input_data):
    """检测 prompt injection"""
    result = await classifier.classify(input_data)
    return GuardrailFunctionOutput(
        output_info={"score": result.score},
        tripwire_triggered=result.score > 0.8
    )

agent = Agent(
    name="Safe Agent",
    instructions="...",
    input_guardrails=[check_injection],
)

第十二章 Agent 部署与成本优化

12.1 Token 管理与成本优化

Q: Agent 系统如何控制 Token 消耗和 API 成本？

class ModelRouter:
    async def route(self, query: str, complexity: str) -> str:
        if complexity == "simple":
            return "claude-haiku-4-5-20251001"    # 最便宜
        elif complexity == "medium":
            return "claude-sonnet-4-20250514"
        else:
            return "claude-opus-4-20250514"       # 最强

2026 更新模型 ID：最新 Claude 模型家族为 4.5/4.6 系列：

• Opus 4.6: claude-opus-4-6
• Sonnet 4.6: claude-sonnet-4-6
• Haiku 4.5: claude-haiku-4-5-20251001

12.2 Agent 部署架构

Q: Agent 服务如何部署到生产环境？

# Docker Compose 示例
services:
  agent-api:
    build: .
    ports: ["8000:8000"]
    environment:
      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
      - REDIS_URL=redis://redis:6379
    depends_on: [redis, milvus]

  redis:
    image: redis:7-alpine
    # 用于缓存和会话管理

  milvus:
    image: milvusdb/milvus:latest
    # 向量数据库用于 RAG 和长期记忆

关键考虑：

• 无状态 API 层：Agent 状态存储在 Redis/数据库，API 层可水平扩展
• 异步任务队列：长时间运行的 Agent 任务放入 Celery/RQ
• 流式输出：用 SSE 或 WebSocket 推送中间结果
• 健康检查：监控 LLM API 连通性和响应时间

第十三章 高频综合面试题精选

Q1: 从零设计一个客服 Agent 系统，你会怎么做？

1. 需求分析
   - 支持的渠道（网页/APP/微信）
   - 业务范围（售前/售后/技术支持）
   - 是否需要多语言
2. 架构设计
   - 路由层：意图分类 → 分发到专业 Agent
   - Agent 层：每个领域一个专业 Agent（退款/物流/技术）
   - 工具层：CRM 查询、工单创建、知识库检索
   - 记忆层：短期（对话历史）+ 长期（用户画像）
   - 安全层：Guardrails + Human-in-the-Loop
3. 技术选型
   - 框架：OpenAI Agents SDK（Handoff 天然适合客服分流）
   - RAG：知识库检索 + 重排序
   - 向量数据库：Milvus（生产级）
   - 可观测性：LangSmith
4. 关键指标
   - 解决率、转人工率、平均响应时间、用户满意度
5. 迭代策略
   - 先上线单 Agent MVP
   - 收集失败案例，迭代优化
   - 逐步加入多 Agent 和高级功能

Q2: Agent 产生幻觉怎么办？

1. RAG Grounding：强制基于检索到的事实回答
2. Prompt 约束：明确指示"如果不确定请说不知道"
3. Self-Verification：让 Agent 自检回答是否有依据
4. 引用标注：要求 Agent 标注信息来源
5. Guardrails：输出检测器过滤无依据内容
6. 使用 Reasoning Model：o1/o3/DeepSeek-R1 等推理模型幻觉率更低

Q3: 如何处理 Agent 的延迟问题？

Q4: 你如何调试一个复杂的 Agent 系统？

1. Tracing 链路追踪：LangSmith / Phoenix 查看每步输入输出
2. 日志分级：Agent 决策日志、工具调用日志、错误日志分开
3. Replay 回放：保存完整消息历史，支持重放调试
4. 单步执行：在关键节点设置断点（LangGraph 的 interrupt\_before）
5. A/B 测试：对比不同 prompt / 模型 / 工具配置的效果
6. 评估套件：构建回归测试用例集，每次改动自动验证

Q5: 解释 Prompt Caching 的原理和适用场景

Anthropic Prompt Caching：

• 对于重复使用的长 prompt 前缀（如 system prompt + 工具定义），缓存其处理结果
• 后续请求只需处理变化的部分
• 缓存命中时输入 token 价格降低最高 90%
• TTL 为 5 分钟（最后使用后）

适用场景： System prompt 很长（如包含大量工具定义）、RAG 中固定的上下文前缀、多轮对话中重复的历史消息。

Q6: Agent 系统的 Token 消耗如何估算和优化？

总 Token ≈ Σ(每步的 input_tokens + output_tokens)

其中每步 input_tokens 包括:
- System prompt（固定）
- 工具定义（固定）
- 对话历史（递增！）
- 工具结果（可变）

优化关键：
1. 控制对话历史长度（摘要/截断）
2. 工具结果摘要（不要把大段原文放进上下文）
3. Prompt caching（缓存固定前缀）
4. 模型路由（小任务用小模型）
5. 提前终止（检测到答案就停止循环）

Q7: 如何实现 Agent 的"可中断 & 可恢复"？

使用 LangGraph Checkpoint：

app = graph.compile(checkpointer=SqliteSaver("agent.db"))
config = {"configurable": {"thread_id": "session-123"}}
partial_result = app.invoke(input, config)
# 后续恢复
resumed_result = app.invoke(None, config)  # 传 None 继续上次

Q8: 比较 RLHF、DPO、Constitutional AI

Q9: 设计一个 Agentic RAG 系统

class AgenticRAG:
    """自适应 RAG Agent"""

    async def answer(self, question: str) -> str:
        # Step 1: 判断是否需要检索
        need_retrieval = await self.judge_need_retrieval(question)
        if not need_retrieval:
            return await self.direct_answer(question)

        # Step 2: 查询改写
        queries = await self.rewrite_queries(question)

        # Step 3: 多源并行检索
        results = await asyncio.gather(
            self.vector_search(queries),
            self.keyword_search(queries),
            self.web_search(queries) if self.need_web else asyncio.sleep(0),
        )

        # Step 4: 重排序
        ranked = await self.rerank(question, flatten(results))

        # Step 5: 质量检查（CRAG 思想）
        if self.context_quality(ranked) < 0.5:
            web_results = await self.web_search([question])
            ranked = await self.rerank(question, ranked + web_results)

        # Step 6: 生成回答
        answer = await self.generate(question, ranked[:5])

        # Step 7: 自验证（Self-RAG 思想）
        if not await self.verify_faithfulness(answer, ranked[:5]):
            answer = await self.regenerate_with_citation(question, ranked[:5])

        return answer

Q10: Python 中 asyncio.gather vs asyncio.TaskGroup 的区别？

Q11: Agent 系统如何做灰度发布和 A/B 测试？

1. 流量分流：按用户 ID hash 分配到不同 Agent 版本
2. 指标对比：完成率、延迟、成本、用户满意度
3. 渐进放量：5% → 20% → 50% → 100%
4. 快速回滚：发现问题立即切回旧版本
5. 评估自动化：LLM-as-Judge 自动评估输出质量

第十四章 2026 新增：Agent 产品化与商业落地

14.1 Agent 产品形态演进

Q: 2025-2026 年 Agent 的主要产品形态有哪些？

14.2 从 Demo 到生产的关键挑战

Q: 把 Agent 从 Demo 带到生产需要解决什么？

1. 可靠性：Agent 决策不确定性 → 需要 Guardrails + Human-in-the-Loop
2. 成本控制：Token 消耗随步数线性增长 → 需要缓存、路由、限制
3. 延迟优化：多步 Agent 延迟累积 → 并行化、流式输出
4. 安全合规：Prompt Injection、数据泄露 → 沙箱、权限隔离
5. 可观测性：Agent 行为不透明 → Tracing、日志、评估
6. 测试：非确定性输出 → LLM-as-Judge、回归测试集

14.3 Anthropic 的 Agent 设计哲学

Q: Anthropic《Building Effective Agents》的核心建议是什么？

1. 从简单开始：先用增强型 LLM（带工具调用），不够再升级到 Workflow/Agent

2. Workflows vs Agents：

   • Workflow：代码预定义路径编排 LLM 调用（prompt chaining、routing、parallelization）
   • Agent：LLM 自主决定控制流（agentic loop）
3. 保持简单：不要过度工程化，避免不必要的多 Agent 复杂性

4. 关键模式：

   • Prompt Chaining：分步处理，上一步输出 = 下一步输入
   • Routing：分类后分发给专用处理逻辑
   • Parallelization：多个 LLM 调用并行执行
   • Orchestrator-Workers：中央 Agent 分派子任务
   • Evaluator-Optimizer：生成+评估迭代循环

第十五章 2026 新增：Reasoning Model 与 Agent 的融合

15.1 推理模型（Reasoning Model）全景

Q: 当前主要的推理模型有哪些？它们如何改变 Agent？

15.2 Reasoning + Agent 的协同

Q: 推理模型如何提升 Agent 的表现？

1. 更准确的工具选择：推理过程帮助模型"想清楚"该调用哪个工具
2. 更好的规划能力：复杂任务的分解和排序更合理
3. 减少幻觉：深度推理减少无依据的回答
4. 自我纠错：推理过程中发现并纠正错误
5. 代码 Agent 表现飞跃：SWE-bench 分数从 ~30% 提升到 \>70%

Extended Thinking 的最佳实践：

# 对于需要深度推理的 Agent 步骤，开启 extended thinking
response = client.messages.create(
    model="claude-opus-4-6",
    max_tokens=16000,
    thinking={"type": "enabled", "budget_tokens": 10000},
    tools=tools,
    messages=messages,
)

15.3 2025-2026 模型能力对比（面试高频）

Q: 如何选择 Agent 使用的模型？

参考资料

• Model Context Protocol 官方文档
• MCP 2025 年 Roadmap
• Google A2A 协议
• OpenAI Agents SDK
• LangGraph 文档
• RAGAS 评估框架
• SWE-bench 排行榜
• Anthropic Building Effective Agents
• OpenAI Codex CLI
• DeepSeek-R1 论文

更新日志：

• 2025-02-23：初版发布
• 2026-04-03：全面更新，新增第十四、十五章；更新模型信息至 Claude 4.5/4.6 系列；新增 MCP 2025-2026 生态进展；新增代码 Agent 最新发展；更新 SWE-bench 分数；新增 Anthropic Agent 设计哲学；新增推理模型与 Agent 融合内容；新增多个评估基准；更新框架选型指南。