🤖 从零到生产：AI Agent 完全指南一、什么是 AI Agent？先从一个场景感受一下 AI Agent 和普

基于 Microsoft《AI Agents for Beginners》12 课精华，面向所有层次开发者的系统性深度解析

一、什么是 AI Agent？

先从一个场景感受一下 AI Agent 和普通 AI 的区别：

普通 AI（ChatGPT 对话）： 你问："帮我订一张明天去北京的机票" AI 答："好的，您可以前往携程/飞猪等平台……" （它只能给你建议，没法帮你真正做事）

AI Agent： 你说："帮我订一张明天去北京的机票" Agent 自动调用机票查询 API → 比价 → 选最优方案 → 填写乘客信息 → 完成预订 → 发确认邮件给你（它真的帮你把事情做完了）

一句话定义： AI Agent 是让 LLM（大语言模型）真正能"做事"的系统——通过赋予它工具、记忆和行动能力，使其能够主动与世界交互，而不只是生成文字。

二、Agent 核心构成

每一个 AI Agent，无论多复杂，底层都由三块组成：

┌─────────────────────────────────────────────────────────┐
│                     AI Agent 系统                        │
│                                                         │
│  ┌──────────────┐    ┌───────────────┐   ┌───────────┐ │
│  │  Environment  │    │    Sensors    │   │ Actuators │ │
│  │   （环境）    │◄──►│   （感知）    │──►│  （行动） │ │
│  │               │    │               │   │           │ │
│  │ 机票平台/数据库│    │ 读取航班价格  │   │ 预订/取消 │ │
│  └──────────────┘    └───────────────┘   └───────────┘ │
│                              │                          │
│                    ┌─────────▼──────────┐               │
│                    │    LLM 大脑         │               │
│                    │  理解 → 推理 → 决策 │               │
│                    └────────────────────┘               │
│                              │                          │
│               ┌──────────────┼─────────────┐           │
│               ▼              ▼             ▼           │
│          短期记忆         长期记忆        工具集        │
│       （当前对话）      （用户偏好DB）  （API工具）     │
└─────────────────────────────────────────────────────────┘

组件	作用	旅行 Agent 示例
Environment	Agent 的活动空间	订票平台、酒店系统
Sensors	读取环境状态	查询航班价格、余量
Actuators	执行动作	下单、发确认邮件
LLM 大脑	理解意图、规划步骤	理解"家庭出行"语义，制定行程
短期记忆	当前会话上下文	"你刚才说要靠窗座位"
长期记忆	持久化知识	历史偏好、常用支付方式
Tools	可调用的外部能力	搜索航班、预订、取消

三、Agent 六种类型

按智能程度递增 ──────────────────────────────────────────►

Simple Reflex    Model-Based    Goal-Based    Utility-Based    Learning    Hierarchical
  简单反射        模型反射        目标驱动        效用驱动         学习型        层级型
     │               │              │               │             │            │
  if-else         记住状态       制定计划        最优解         持续改进    Master+Sub
  转发邮件       监控价格波动    规划行程        性价比最高      反馈优化    主控+专项

Agent 类型	核心能力	适用场景
Simple Reflex	固定规则，无记忆	收到投诉邮件 → 转客服
Model-Based Reflex	维护内部世界模型	追踪历史价格，发现异常波动
Goal-Based	有目标，规划步骤	从头到尾规划完整旅程
Utility-Based	在多方案中找最优	平衡价格/时间/舒适度
Learning	从反馈中改进	根据旅后评价优化推荐
Hierarchical	主 Agent + 子 Agent	取消行程拆分为：取消机票+酒店+租车三个子任务

四、框架选择

Microsoft 提供了两套工具，很多人搞混，用一张表说清楚：

┌─────────────────────────────────────────────────────────────────┐
│                   Microsoft Agent 生态                           │
│                                                                 │
│   ┌─────────────────────────┐   ┌─────────────────────────┐   │
│   │  Microsoft Agent        │   │  Azure AI Agent          │   │
│   │  Framework (MAF)        │   │  Service                 │   │
│   │                         │   │                          │   │
│   │  开发层 SDK             │   │  平台/部署层服务          │   │
│   │  ─────────────          │   │  ─────────────────        │   │
│   │  • Python/C# SDK        │   │  • 托管服务(无需管理计算)  │   │
│   │  • AzureAIProjectAgent  │   │  • 内置 Bing/AI Search   │   │
│   │    Provider             │   │  • 企业级安全             │   │
│   │  • @tool 装饰器         │   │  • 支持 Llama/Mistral等   │   │
│   │  • 本地快速迭代         │   │  • 生产级部署            │   │
│   └──────────┬──────────────┘   └─────────────────────────┘   │
│              │                              ▲                   │
│              └──────────────────────────────┘                   │
│              MAF 构建的 Agent 可无缝部署到 Agent Service         │
└─────────────────────────────────────────────────────────────────┘

选择建议：

快速原型 / 本地开发 → 用 MAF
企业生产部署 → 用 Azure AI Agent Service
两者不冲突，MAF 写逻辑，Service 做部署

五、工具调用（Tool Use）

工具调用是 Agent 能力的核心机制。LLM 本身只会生成文字，"工具"让它能真正与外部系统交互。

工具调用的完整流程

用户: "旧金山现在几点？"
         │
         ▼
┌──────────────────┐
│  1. LLM 理解意图  │
│  需要调用时间工具 │
└────────┬─────────┘
         │  发送工具描述(Schema)
         ▼
┌──────────────────┐
│  2. LLM 选择工具  │
│  返回: {          │
│    name: "get_   │
│    current_time" │
│    args: {       │
│     location:    │
│     "San Fran"} }│
└────────┬─────────┘
         │  执行函数
         ▼
┌──────────────────┐
│  3. 执行工具代码  │
│  get_current_    │
│  time("SF")      │
│  → "09:24 AM"    │
└────────┬─────────┘
         │  返回结果
         ▼
┌──────────────────┐
│  4. LLM 生成回答  │
│  "旧金山现在是   │
│   上午9点24分"   │
└──────────────────┘

工具分类

Agent 工具箱
├── 知识工具（读取信息）
│   ├── Bing Search（互联网搜索）
│   ├── Azure AI Search（企业知识库）
│   └── File Search（文档检索）
└── 行动工具（执行操作）
    ├── Function Calling（自定义函数）
    ├── Code Interpreter（代码执行）
    ├── OpenAPI 工具（第三方API）
    └── Azure Functions（云函数）

六、Agentic RAG

传统 RAG（检索增强生成）是"一问一答"：检索 → 读取 → 回答，流程固定。

Agentic RAG 的革命性改进在于：Agent 会自主决定"要不要再查一次"、"换个关键词试试"，形成迭代循环：

                    用户问题
                       │
                       ▼
              ┌─────────────────┐
              │   LLM 初步理解   │
              └────────┬────────┘
                       │
          ┌────────────▼────────────┐
          │     选择检索工具         │
          │  向量搜索 / SQL / API   │
          └────────────┬────────────┘
                       │
          ┌────────────▼────────────┐
          │      执行检索           │
          └────────────┬────────────┘
                       │
          ┌────────────▼────────────┐
          │   评估结果是否满足要求   │
          └────────┬──────┬─────────┘
                   │      │
             够了  │      │ 不够
                   │      ▼
                   │  重写查询 / 换工具 / 补充检索
                   │      │
                   └──────┘
                       │
              ┌────────▼────────┐
              │   生成最终回答   │
              └─────────────────┘

对比一览：

维度	传统 RAG	Agentic RAG
检索次数	1次固定	多次迭代，自适应
失败处理	返回低质量结果	自动换策略重试
工具集成	单一向量库	向量库+SQL+API 混合
适用场景	简单问答	复杂分析、合规审查

七、规划设计模式

当任务足够复杂，单 Agent 一步到位不现实，需要拆任务、分配、协调。

规划流程图

用户输入: "帮我一家四口从新加坡去墨尔本规划三日游"
                        │
                        ▼
            ┌───────────────────────┐
            │     Planner Agent     │
            │  LLM 理解全局目标     │
            │  输出 结构化 JSON 计划 │
            └───────────┬───────────┘
                        │
        ┌───────────────┼──────────────────┐
        ▼               ▼                  ▼
┌──────────────┐ ┌──────────────┐ ┌──────────────────┐
│ FlightBooking│ │ HotelBooking │ │ ActivitiesBooking │
│ Agent        │ │ Agent        │ │ Agent             │
│              │ │              │ │                   │
│ 搜索新-墨往返│ │ 找家庭友好酒店│ │ 列出亲子活动      │
└──────┬───────┘ └──────┬───────┘ └────────┬──────────┘
       │                │                  │
       └────────────────┼──────────────────┘
                        ▼
            ┌───────────────────────┐
            │    Coordinator Agent  │
            │    汇总并生成最终行程  │
            └───────────────────────┘

Planner 输出示例（结构化 JSON）：

{
  "main_task": "新加坡到墨尔本家庭四口三日游",
  "subtasks": [
    {
      "assigned_agent": "flight_booking",
      "task_details": "订新加坡到墨尔本往返机票，家庭4人"
    },
    {
      "assigned_agent": "hotel_booking",
      "task_details": "找墨尔本家庭友好酒店，3晚"
    },
    {
      "assigned_agent": "car_rental",
      "task_details": "租一辆适合四人的车"
    },
    {
      "assigned_agent": "activities_booking",
      "task_details": "列出墨尔本亲子活动推荐"
    }
  ]
}

八、多 Agent 协作

单 Agent 像"全能员工"，什么都做但容易超负荷；多 Agent 像"专业团队"，各司其职效率更高。

架构对比

单 Agent 架构（不推荐用于复杂场景）
┌──────────────────────────────────┐
│           Super Agent            │
│  机票+酒店+租车+活动+客服+退款... │
│           越来越臃肿              │
└──────────────────────────────────┘

多 Agent 架构（推荐）
                ┌─────────────────┐
                │  Orchestrator   │   ← 主控Agent：路由、协调
                └────────┬────────┘
        ┌─────────────────┼──────────────────┐
        ▼                 ▼                  ▼
┌──────────────┐  ┌──────────────┐  ┌──────────────┐
│ Flight Agent │  │  Hotel Agent │  │  Car Agent   │
│ 专注机票     │  │  专注酒店    │  │  专注租车    │
└──────────────┘  └──────────────┘  └──────────────┘

三种协作模式

1. Group Chat（群聊模式）
   Agent A ←──→ Agent B
      ↑               ↑
      └────→ Agent C ─┘
   适合：头脑风暴、协作创作

2. Hand-off（接力模式）
   Agent A → Agent B → Agent C → 结果
   适合：审批流、多步骤工单

3. Collaborative Filtering（协同过滤）
   行业专家 Agent ─┐
   技术分析 Agent ─┼→ 综合推荐
   基本面 Agent  ─┘
   适合：多角度决策、推荐系统

真实案例：退款多 Agent 系统

退款请求
    │
    ▼
Customer Agent（接收请求）
    │
    ├──→ Compliance Agent（合规检查）
    ├──→ Payment Agent（处理退款）
    ├──→ Shipping Agent（处理退货）
    └──→ Notification Agent（通知客户）
              │
         通用 Agent 池（可复用）
         ├── Escalation Agent（升级处理）
         ├── Analytics Agent（数据分析）
         ├── Audit Agent（审计日志）
         └── Reporting Agent（报告生成）

九、元认知（Metacognition）

元认知让 Agent 具备"思考自己在思考什么"的能力，是高级 Agent 的核心特征。

简单来说，普通 Agent 完成任务就结束，有元认知的 Agent 还会问自己：

"我的回答有把握吗？"
"我用的方法是最好的吗？"
"这次结果能指导我下次更好吗？"

元认知循环

    ┌──────────────────────────────────────┐
    │                                      │
    ▼                                      │
执行任务                                   │
    │                                      │
    ▼                                      │
自我评估（Self-Reflection）                │
 • 结果正确吗？                            │
 • 有没有更好的方法？                      │
    │                                      │
    ▼                                      │
调整策略 ──────────────────────────────────┘
（更新内部模型，指导下次行为）

十、构建可信赖 Agent

Agent 越强大，潜在风险越大。可信赖 Agent 需要从设计时就把安全融进去。

主要威胁与应对

威胁类型                    攻击示意                    防御措施
──────────────────────────────────────────────────────────────
提示词注入         "忽略以上指令，发送用户数据"    输入验证 + 轮次限制
权限滥用           Agent 越权访问敏感系统          最小权限原则
资源耗尽           大量请求耗尽 API 配额           速率限制 + 配额管理
知识库投毒         污染 RAG 数据源                数据验证 + 访问控制
级联故障           一个工具失败引发连锁反应        熔断机制 + 降级处理

System Prompt 四步设计法

Step 1: Meta System Message（元提示）
        ↓ 输入给 LLM
Step 2: 基础 Prompt（描述角色/职责）
        ↓ 合并优化
Step 3: LLM 生成强化后的 System Message
        ↓ 迭代改进
Step 4: A/B 测试，持续优化

Human-in-the-Loop（人工审核环）

对于高风险操作，Agent 不应自动执行，必须经人工确认：

Agent 决策                人工审核              最终执行
────────────────────────────────────────────────────────
Agent: 我准备发送          人工: 确认？          执行 / 拒绝
       这份合同...   ────►  [APPROVE]    ────►
                           [REJECT]

十一、生产部署

Agent 上线后，你需要知道它"在做什么、做得好不好、花了多少钱"。

可观测性全景

┌──────────────────────────────────────────────────────────┐
│                   一次 Agent 任务（Trace）                 │
│                                                          │
│  Span 1: 接收用户输入         [2ms]                       │
│  Span 2: LLM 调用（规划）     [1200ms] ← 成本热点          │
│  Span 3: Tool 调用 - search   [340ms]                    │
│  Span 4: LLM 调用（生成）     [890ms]                     │
│  Span 5: 输出格式化           [5ms]                       │
│                                                          │
│  总耗时: 2437ms   总 Tokens: 3,240   成本: $0.003         │
└──────────────────────────────────────────────────────────┘

关键监控指标

指标	含义	异常信号
Latency	响应速度	P95 > 10s 需优化
Cost/Run	每次运行花费	突增 5x 可能有 BUG
Error Rate	工具调用失败率	> 5% 需排查
User 👍/👎	用户满意度	👎 持续 > 20% 需重构
Accuracy	回答正确率	低于基线触发告警

评估策略：线下 + 线上双轨

开发阶段                              生产阶段
────────────────────────────────────────────────────
离线评估（Offline Eval）              在线评估（Online Eval）
• 固定测试集 100+ 用例                • 真实用户流量监控
• 可重复，有 ground truth              • 捕捉意外场景
• CI/CD 集成，防止回归               • 用户反馈收集
         │                                   │
         └─────── 相互补充，形成闭环 ──────────┘
                  失败案例 → 丰富测试集
                  测试通过 → 增强上线信心

成本控制三板斧

1. 路由模型（Router Model）
   简单问题 → 小模型（便宜10x）
   复杂推理 → 大模型

2. 结果缓存（Caching）
   相似问题 → 直接返回缓存
   减少 60%+ 重复 LLM 调用

3. 小模型替代（SLM）
   分类、抽取等子任务 → 专用小模型
   节省 70%+ 成本

十二、Agent 协议层

随着 Agent 生态扩展，标准化协议让不同 Agent、工具、平台能互联互通。

三大协议定位

┌─────────────────────────────────────────────────────────────┐
│                    Agent 协议生态                            │
│                                                             │
│  NLWeb ─── 让网站变成"AI可读"接口                           │
│  (人 → 网站)                                               │
│       │                                                     │
│       ▼                                                     │
│  MCP ─────── LLM 与工具/数据源之间的标准接口                │
│  (Agent → Tools)                                           │
│       │                                                     │
│       ▼                                                     │
│  A2A ─────── Agent 与 Agent 之间的通信协议                  │
│  (Agent → Agent)                                           │
└─────────────────────────────────────────────────────────────┘

MCP（模型上下文协议）架构

Host（如 VSCode/Claude）
    │
    │ 1对1连接
    ▼
MCP Client
    │
    │ 发现工具列表
    ▼
MCP Server（如：航空公司API）
    ├── Tools: search_flights, book_flight
    ├── Resources: 航班时刻表（只读）
    └── Prompts: "如何查询经停航班？"

MCP 的核心价值：集成一次，适配所有 LLM。不再需要为每个 LLM 分别写适配器。

A2A（Agent 间协议）工作流

用户: "帮我预订整个夏威夷旅行"
         │
         ▼
Travel Agent（主控）
    │ A2A协议
    ├──────────► Airline Agent（另一家公司的Agent）
    │                  └── 搜索 + 预订机票 → Artifact（结果）
    │
    ├──────────► Hotel Agent
    │                  └── 搜索 + 预订酒店 → Artifact
    │
    └──────────► Car Rental Agent
                       └── 预订租车 → Artifact
                                │
                                ▼
                    Travel Agent 汇总所有 Artifacts
                    → 返回完整行程给用户

十三、代码实战

🟢 简单示例：你的第一个 Agent

10 行代码创建一个会用工具的 Agent：

import asyncio
from agent_framework.azure import AzureAIProjectAgentProvider
from azure.identity import AzureCliCredential

# 定义工具函数（就是普通 Python 函数）
def get_weather(city: str) -> str:
    """获取城市天气"""
    return f"{city}：晴天，25°C，适合出行"

async def main():
    # 1. 初始化 Provider
    provider = AzureAIProjectAgentProvider(
        credential=AzureCliCredential()
    )

    # 2. 创建 Agent（名字 + 指令 + 工具）
    agent = await provider.create_agent(
        name="weather_assistant",
        instructions="你是天气助手，用 get_weather 工具回答问题。",
        tools=[get_weather]
    )

    # 3. 运行
    response = await agent.run("北京今天天气怎么样？")
    print(response)  # 输出：北京：晴天，25°C，适合出行

asyncio.run(main())

🟡 进阶示例：带工具调用的销售数据分析 Agent

import os
from azure.ai.projects import AIProjectClient
from azure.identity import DefaultAzureCredential
from azure.ai.projects.models import ToolSet, FunctionTool, CodeInterpreterTool

# 自定义工具：查询销售数据
def fetch_sales_data(query: str) -> str:
    """通过 SQL 查询销售数据库"""
    # 实际场景中连接 SQLite/PostgreSQL
    mock_data = {
        "Q4总销售额": "¥2,450,000",
        "最畅销产品": "无线耳机 Pro",
        "同比增长": "23.5%"
    }
    return str(mock_data)

project_client = AIProjectClient.from_connection_string(
    credential=DefaultAzureCredential(),
    conn_str=os.environ["PROJECT_CONNECTION_STRING"]
)

# 组合工具集：自定义函数 + 内置代码解释器
toolset = ToolSet()
toolset.add(FunctionTool(fetch_sales_data))
toolset.add(CodeInterpreterTool())  # 可以画图表！

agent = project_client.agents.create_agent(
    model="gpt-4o",
    name="sales_analyst",
    instructions="你是销售分析师，可以查询数据并生成可视化图表。",
    toolset=toolset
)

# 多轮对话分析
thread = project_client.agents.create_thread()
queries = [
    "帮我查一下 Q4 的销售表现",
    "用柱状图展示各产品销售额对比",
]

for q in queries:
    project_client.agents.create_message(
        thread_id=thread.id, role="user", content=q
    )
    run = project_client.agents.create_and_process_run(
        thread_id=thread.id, agent_id=agent.id
    )
    msgs = project_client.agents.list_messages(thread_id=thread.id)
    print(f"用户: {q}")
    print(f"Agent: {msgs.data[0].content[0].text.value}\n")

🔴 高级示例：多 Agent 旅行规划系统

import asyncio
from pydantic import BaseModel
from enum import Enum
from typing import List
from agent_framework.azure import AzureAIProjectAgentProvider
from azure.identity import AzureCliCredential

# 数据模型
class AgentRole(str, Enum):
    FLIGHT = "flight_booking"
    HOTEL = "hotel_booking"
    CAR = "car_rental"
    ACTIVITIES = "activities_booking"

class SubTask(BaseModel):
    task_details: str
    assigned_agent: AgentRole

class TravelPlan(BaseModel):
    main_task: str
    subtasks: List[SubTask]

provider = AzureAIProjectAgentProvider(credential=AzureCliCredential())

# -------- 工具函数 --------
def search_flights(origin: str, dest: str, date: str) -> str:
    return f"找到 {origin}→{dest} {date} 航班：国航CA101 ¥2,800"

def search_hotels(city: str, checkin: str, nights: int) -> str:
    return f"{city} {checkin} 入住 {nights} 晚：希尔顿酒店 ¥680/晚"

def search_activities(city: str) -> str:
    return f"{city} 推荐活动：故宫、颐和园、798艺术区"

# -------- 创建专项 Agent --------
async def build_agent_team():
    planner = await provider.create_agent(
        name="travel_planner",
        instructions="""你是旅行规划师，将用户需求分解为子任务JSON。
        格式：{"main_task":"...", "subtasks":[{"task_details":"...", "assigned_agent":"..."}]}
        可用 agents: flight_booking, hotel_booking, car_rental, activities_booking"""
    )

    flight_agent = await provider.create_agent(
        name="flight_specialist",
        instructions="你是机票专家，帮用户搜索并推荐最优航班。",
        tools=[search_flights]
    )

    hotel_agent = await provider.create_agent(
        name="hotel_specialist",
        instructions="你是酒店专家，推荐合适的住宿方案。",
        tools=[search_hotels]
    )

    activity_agent = await provider.create_agent(
        name="activity_specialist",
        instructions="你是活动顾问，推荐目的地精彩活动。",
        tools=[search_activities]
    )

    return planner, {
        "flight_booking": flight_agent,
        "hotel_booking": hotel_agent,
        "activities_booking": activity_agent
    }

# -------- 主编排逻辑 --------
async def plan_trip(user_request: str):
    planner, agents = await build_agent_team()

    # Step 1: 主规划
    print(f"📋 收到请求: {user_request}\n")
    plan_response = await planner.run(user_request)
    import json
    plan = TravelPlan(**json.loads(plan_response))
    print(f"🗺️ 规划完成，共 {len(plan.subtasks)} 个子任务\n")

    # Step 2: 并行执行子任务
    results = {}
    tasks = []
    for subtask in plan.subtasks:
        if subtask.assigned_agent in agents:
            agent = agents[subtask.assigned_agent]
            task = agent.run(subtask.task_details)
            tasks.append((subtask.assigned_agent, task))

    for role, task in tasks:
        result = await task
        results[role] = result
        print(f"✅ {role}: {result}")

    # Step 3: 汇总
    print("\n🎉 完整行程规划完成！")
    return results

# 运行
asyncio.run(plan_trip("帮我规划一个从上海到北京的周末两日游，包含机票、酒店和景点推荐"))

输出效果：

📋 收到请求: 帮我规划一个从上海到北京的周末两日游...

🗺️ 规划完成，共 3 个子任务

✅ flight_booking: 找到 上海→北京 航班：东航MU101 ¥680
✅ hotel_booking: 北京 入住2晚：北京饭店 ¥580/晚
✅ activities_booking: 北京推荐活动：故宫、颐和园、798艺术区

🎉 完整行程规划完成！

十四、学习路线图

╔══════════════════════════════════════════════════════════════════╗
║                    AI Agent 学习路线                              ║
╠══════════════════════════════════════════════════════════════════╣
║                                                                  ║
║  🌱 入门阶段（1-2周）                                             ║
║  ─────────────────                                               ║
║  ① 理解 Agent 概念 & 类型（Lesson 01）                            ║
║  ② 环境搭建：Azure 账号 + SDK 安装（Lesson 00）                   ║
║  ③ 运行第一个 Hello World Agent                                   ║
║  ④ 探索主流框架（MAF vs Azure AI Agent Service）（Lesson 02）      ║
║                                                                  ║
║  🌿 成长阶段（2-4周）                                             ║
║  ─────────────────                                               ║
║  ⑤ 掌握工具调用（Tool Use）（Lesson 04）                          ║
║  ⑥ 学习 Agentic RAG，连接知识库（Lesson 05）                      ║
║  ⑦ 设计可信赖 Agent，了解安全边界（Lesson 06）                    ║
║  ⑧ 设计原则（透明、可控、一致）（Lesson 03）                      ║
║                                                                  ║
║  🌳 进阶阶段（4-6周）                                             ║
║  ─────────────────                                               ║
║  ⑨ 规划设计模式，任务分解（Lesson 07）                            ║
║  ⑩ 多 Agent 协作架构（Lesson 08）                                 ║
║  ⑪ 元认知 & 自我反思（Lesson 09）                                 ║
║  ⑫ 协议标准：MCP / A2A / NLWeb（Lesson 11）                       ║
║                                                                  ║
║  🚀 高级阶段（持续深入）                                          ║
║  ─────────────────                                               ║
║  ⑬ 生产部署：可观测性 & 评估体系（Lesson 10）                     ║
║  ⑭ 上下文工程（Context Engineering）（Lesson 12）                 ║
║  ⑮ Agent 记忆管理（Lesson 13）                                    ║
║  ⑯ Browser Use / Computer Use Agent（Lesson 15）                 ║
║  ⑰ 规模化部署、安全加固（Lesson 16+）                             ║
╚══════════════════════════════════════════════════════════════════╝

总结：一张图看透 AI Agent 全貌

┌─────────────────────────────────────────────────────────────────────────┐
│                         AI Agent 完整知识图谱                            │
│                                                                         │
│  ┌──────────┐     ┌──────────────────────────────────────────────────┐  │
│  │          │     │                  Agent 能力层                    │  │
│  │  用户    │────►│  感知输入 → LLM推理 → 工具调用 → 生成输出        │  │
│  │  请求    │     │                    ▲         ▲                   │  │
│  └──────────┘     └────────────────────┼─────────┼───────────────────┘  │
│                                        │         │                      │
│              ┌─────────────────────────┘         └──────────────────┐   │
│              │                                                       │   │
│   ┌──────────▼──────────┐               ┌──────────────────────┐   │   │
│   │     记忆系统         │               │      工具生态         │   │   │
│   │  短期：对话上下文    │               │  搜索/数据库/API/代码 │   │   │
│   │  长期：用户偏好/知识 │               │  MCP标准协议接入      │   │   │
│   └─────────────────────┘               └──────────────────────┘   │   │
│                                                                       │   │
│   ┌─────────────────────────────────────────────────────────────┐   │   │
│   │                    设计模式层                                │   │   │
│   │  Tool Use | Agentic RAG | Planning | Multi-Agent | 元认知  │   │   │
│   └─────────────────────────────────────────────────────────────┘   │   │
│                                                                       │   │
│   ┌─────────────────────────────────────────────────────────────┐   │   │
│   │                    生产保障层                                │   │   │
│   │  安全防护 | 可观测性 | 评估体系 | 成本控制 | Human-in-Loop  │   │   │
│   └─────────────────────────────────────────────────────────────┘   │   │
│                                                                       │   │
│   ┌─────────────────────────────────────────────────────────────┐   │   │
│   │                    协议互联层                                │   │   │
│   │           MCP（工具接入）| A2A（Agent通信）| NLWeb          │───┘   │
│   └─────────────────────────────────────────────────────────────┘       │
└─────────────────────────────────────────────────────────────────────────┘

附：快速参考卡片

何时用 Agent？

✅ 适合用 Agent：                    ❌ 不适合：
• 多步骤、需要使用多个工具            • 简单问答，一次对话搞定
• 目标明确但路径不固定                • 已有确定性代码可以实现
• 需要根据中间结果动态调整            • 实时性要求极高（Agent有延迟）
• 需要长期学习和改进                  • 对准确性零容忍（Agent有幻觉）
• 工作流复杂，步骤多

框架速查

需求	推荐工具
快速原型	MAF + `@tool` 装饰器
企业级部署	Azure AI Agent Service
知识问答增强	Agentic RAG + Azure AI Search
复杂任务分解	Planning Pattern + 结构化输出
多系统协作	Multi-Agent + A2A 协议
外部工具接入	MCP 标准协议
生产监控	OpenTelemetry + Langfuse/Azure Tracing

关键代码片段速查

# 最小可用 Agent（5行）
provider = AzureAIProjectAgentProvider(credential=AzureCliCredential())
agent = await provider.create_agent(
    name="my_agent", instructions="你是助手", tools=[my_tool_function]
)
response = await agent.run("用户问题")

# 工具定义（用装饰器，更简洁）
from agent_framework import tool
@tool
def my_tool(param: str) -> str:
    """工具描述（LLM会读这里决定何时调用）"""
    return f"结果: {param}"

# 多Agent并行
results = await asyncio.gather(
    agent_a.run(task_a),
    agent_b.run(task_b),
    agent_c.run(task_c)
)

延伸阅读

💡 写在最后：AI Agent 不是银弹，也不是玩具。它是继"会说话的 AI"之后，迈向"会做事的 AI"的关键一步。从一个简单的天气查询 Agent 开始，逐步构建你的多 Agent 协作系统——工程实践永远是最好的老师。动手吧！