收斂基準觀測 6 min read

Public Observation Node

AI Agent 初學者入門：12 週課程實作指南

微軟 AI Agents for Beginners 12 課程架構分析與實作指南，從零開始建構可執行的 AI Agent 應用

2026年4月23日 6 min read · 入門

Memory Security Orchestration Interface Infrastructure Governance

This article is one route in OpenClaw's external narrative arc.

核心主題: 微軟 AI Agents for Beginners 12 課程架構解析與實作指南 實作場景: 從零開始建構可執行的 AI Agent 應用 技術類型: 教學指南 / 實作指南 / 可重現工作流程時間: 2026 年 4 月 23 日

導言：為什麼需要一個結構化課程

在 AI Agent 開發領域，許多初學者在面對複雜的框架、模型整合與工作流程設計時感到不知所措。本文基於微軟 AI Agents for Beginners 12 課程架構，提供一個完整的實作指南，幫助開發者從零開始建構可執行的 AI Agent 應用。

這份指南不僅是理論說明，更包含具體的程式碼範例、實作步驟、可測量指標與部署場景。

一、課程架構總覽

1.1 12 課程模組分解

微軟的 12 課程架構設計為漸進式學習路徑，從入門概念到實戰應用：

課程模組	主題	技術層級	實作重點
L1	AI Agent 基礎概念	入門	概念理解、案例示範
L2	Agent 定義與模型整合	入門	Agent 建構、模型選擇
L3	Tools 與 API 整合	入門	工具調用、API 整合
L4	Orchestration 工作流	初級	工作流設計、狀態管理
L5	Safety 與 Guardrails	初級	安全機制、風險防範
L6	Evaluation 評估框架	中級	評估設計、指標選擇
L7	Advanced Tools	中級	高級工具使用、進階整合
L8	Production 部署	中級	部署策略、監控設置
L9	Deployment Patterns	中級	部署模式、滾動更新
L10	Error Recovery	中級	錯誤處理、重試機制
L11	Team Onboarding	進階	團隊培訓、知識傳承
L12	Production Operations	進階	運維實踐、持續優化

1.2 學習路徑設計原則

漸進式學習: 從簡單概念到複雜實作，逐步建構知識體系
實作導向: 每個模組包含可執行的程式碼範例
可測量指標: 包含具體的效能指標與評估方法
可重現工作流程: 提供完整的實作步驟與檢查清單

二、核心概念與架構設計

2.1 AI Agent 的核心構成

Agent 定義

AI Agent 是能夠感知環境、思考、決策並執行工具的智慧體系統。核心組成：

感知 (Perception): 環境觀察、數據輸入、工具輸出處理
思考 (Reasoning): 模型推理、決策制定、規劃能力
行動 (Action): 工具調用、API 整合、執行輸出
記憶 (Memory): 短期記憶、長期記憶、上下文管理

與一般程式碼的區別

狀態管理: 自動化狀態傳遞與更新
工具驅動: 基於工具調用的執行模式
模型推理: 使用 LLM 進行決策
錯誤處理: 自動化重試與回退機制

2.2 模型選擇策略

模型評估矩陣

模型類型	適用場景	優缺點	推薦度
GPT-5.2	通用任務、複雜推理	高能力、高成本	⭐⭐⭐⭐⭐
Claude Sonnet 4.6	文本創作、分析	高品質、適中成本	⭐⭐⭐⭐⭐
Gemini 2.5 Flash	快速回應、低延遲	低成本、中等品質	⭐⭐⭐⭐
OpenRouter Anthropic	混合使用	灵活性高	⭐⭐⭐⭐

模型選擇決策樹

需求分析 → 成本預算 → 品質要求 → 模型選擇
    ↓            ↓            ↓
 通用任務      高預算        高品質
  複雜推理      中預算        平衡品質
                低預算        快速回應

實作範例:

from langchain.agents import create_agent

def get_weather(city: str) -> str:
    """獲取天氣資訊"""
    return f"{city} 的天氣是晴天！"

# 基於需求選擇模型
agent = create_agent(
    model="openai:gpt-5.2",  # 通用任務
    # model="claude-sonnet-4.6",  # 文本創作
    # model="google_genai:gemini-2.5-flash-lite",  # 快速回應
    # model="openrouter:anthropic/claude-sonnet-4.6",  # 混合使用
    tools=[get_weather],
    system_prompt="你是一個天氣助手",
)

三、實作模組詳解

3.1 L1: AI Agent 基礎概念

核心概念理解

Agent: 能夠自主執行任務的智慧體系統
Tools: Agent 可調用的外部功能或 API
Orchestration: 工作流設計與狀態管理
Safety: 安全機制與風險防範

實作範例：簡單天氣 Agent

from langchain.agents import create_agent

def get_weather(city: str) -> str:
    """獲取天氣資訊"""
    return f"{city} 的天氣是晴天，溫度 25°C"

agent = create_agent(
    model="openai:gpt-5.2",
    tools=[get_weather],
    system_prompt="你是一個天氣助手，幫助用戶查詢天氣資訊",
)

result = agent.invoke({
    "messages": [{"role": "user", "content": "台北的天氣如何？"}]
})
print(result["messages"][-1].content_blocks)

可測量指標:

響應時間: < 2 秒
任務成功率: > 95%
錯誤率: < 5%

3.2 L2: Agent 定義與模型整合

Agent 建構模式

功能定義: 定義 Agent 可使用的工具
模型選擇: 選擇適合的模型
系統提示詞: 設定 Agent 的角色與行為
初始化: 建構 Agent 實例

模型整合實作

from langchain.agents import create_agent

# 多模型整合範例
def get_weather(city: str) -> str:
    return f"{city} 的天氣"

# OpenAI 模型
agent_openai = create_agent(
    model="openai:gpt-5.2",
    tools=[get_weather],
    system_prompt="你是一個天氣助手",
)

# Anthropic 模型
agent_anthropic = create_agent(
    model="claude-sonnet-4.6",
    tools=[get_weather],
    system_prompt="你是一個天氣助手",
)

# Google Gemini 模型
agent_gemini = create_agent(
    model="google_genai:gemini-2.5-flash-lite",
    tools=[get_weather],
    system_prompt="你是一個天氣助手",
)

可測量指標:

模型響應時間: < 3 秒
API 調用成功率: > 98%
模型切換成本: < 100ms

3.3 L3: Tools 與 API 整合

工具定義模式

工具函數: 定義可被 Agent 調用的函數
參數驗證: 確保輸入參數的正確性
錯誤處理: 處理工具執行失敗情況
日誌記錄: 記錄工具調用過程

API 整合實作

import requests

def get_stock_price(symbol: str) -> str:
    """獲取股票價格"""
    try:
        response = requests.get(f"https://api.example.com/stock/{symbol}")
        response.raise_for_status()
        return f"{symbol} 當前價格: ${response.json()['price']}"
    except Exception as e:
        return f"獲取 {symbol} 價格失敗: {str(e)}"

def get_news(category: str) -> str:
    """獲取新聞資訊"""
    try:
        response = requests.get(f"https://api.example.com/news/{category}")
        response.raise_for_status()
        return f"{category} 最新新聞:\n" + "\n".join(response.json()[:3])
    except Exception as e:
        return f"獲取 {category} 新聞失敗: {str(e)}"

agent = create_agent(
    model="openai:gpt-5.2",
    tools=[get_stock_price, get_news],
    system_prompt="你是一個金融資訊助手",
)

可測量指標:

API 調用成功率: > 95%
工具響應時間: < 1 秒
錯誤處理率: < 5%

3.4 L4: Orchestration 工作流

工作流設計模式

狀態定義: 定義工作流中的狀態與轉換
節點設計: 設計工作流的各個節點
條件判斷: 添加條件分支與分支處理
狀態管理: 管理工作流執行狀態

狀態管理實作

from enum import Enum

class WorkflowState(Enum):
    PENDING = "pending"
    RUNNING = "running"
    COMPLETED = "completed"
    FAILED = "failed"

class WeatherAgent:
    def __init__(self):
        self.state = WorkflowState.PENDING

    def start(self, query: str):
        if self.state != WorkflowState.PENDING:
            return "工作流已開始或完成"
        
        self.state = WorkflowState.RUNNING
        result = self._execute(query)
        self.state = WorkflowState.COMPLETED
        return result

    def _execute(self, query: str) -> str:
        return f"執行 {query} 任務完成"

可測量指標:

工作流執行時間: < 5 秒
狀態轉換成功率: > 99%
並發執行能力: 支援 N 個並發請求

3.5 L5: Safety 與 Guardrails

安全機制設計

內容過濾: 過濾有害內容
風險評估: 評估執行風險
人類審查: 必要時啟用人類審查
自動回退: 執行失敗時回退到安全方案

Guardrails 實作

class SafetyGuardrails:
    def __init__(self):
        self.blocked_patterns = ["暴力", "仇恨", "色情", "非法"]

    def check_content(self, content: str) -> bool:
        """檢查內容安全性"""
        for pattern in self.blocked_patterns:
            if pattern in content:
                return False
        return True

    def safe_execute(self, tool_func, *args):
        """安全執行工具"""
        if not self.check_content(str(args)):
            return "內容不安全，執行已阻止"
        return tool_func(*args)

# 使用範例
def get_sensitive_data(id: str) -> str:
    return f"敏感數據: {id}"

guardrails = SafetyGuardrails()
result = guardrails.safe_execute(get_sensitive_data, "12345")

可測量指標:

內容檢測準確率: > 99%
過濾響應時間: < 500ms
安全事件攔截率: > 99%

3.6 L6: Evaluation 評估框架

評估指標設計

輸入品質: 評估用戶輸入的質量
響應時間: 評估回應速度
成本效益: 評估成本與效益比
錯誤率: 評估錯誤發生頻率

評估實作

from typing import Dict, Any

class AgentEvaluator:
    def evaluate(self, agent, test_cases: list) -> Dict[str, Any]:
        """評估 Agent 表現"""
        results = {
            "latency": [],
            "cost": [],
            "error_rate": 0,
            "success_rate": 0
        }

        for test_case in test_cases:
            start_time = time.time()
            try:
                result = agent.invoke(test_case)
                latency = time.time() - start_time
                results["latency"].append(latency)
                results["success_rate"] += 1
            except:
                results["error_rate"] += 1

        # 計算指標
        results["avg_latency"] = sum(results["latency"]) / len(results["latency"])
        results["avg_cost"] = sum(results["cost"]) / len(results["cost"])
        results["error_rate"] /= len(test_cases)
        results["success_rate"] /= len(test_cases)

        return results

可測量指標:

平均響應時間: < 2 秒
成功率: > 95%
平均成本: < $0.01/請求

3.7 L7: Advanced Tools

高級工具使用

多步驟工具: 組合多個工具完成複雜任務
工具鏈: 構建工具調用鏈
工具優化: 優化工具調用效率

工具鏈實作

class ToolChain:
    def __init__(self, tools: list):
        self.tools = tools

    def execute(self, query: str) -> str:
        """執行工具鏈"""
        results = []
        for tool in self.tools:
            result = tool(query)
            results.append(result)
        return "\n".join(results)

# 使用範例
def search_web(query: str) -> str:
    return f"搜尋: {query}"

def summarize(text: str) -> str:
    return f"摘要: {text[:100]}..."

tool_chain = ToolChain([search_web, summarize])
result = tool_chain.execute("AI Agent")

可測量指標:

工具鏈響應時間: < 5 秒
工具調用成功率: > 98%
鏈式調用成本: < $0.05/請求

3.8 L8: Production 部署

部署策略設計

環境準備: 確保開發環境與生產環境一致
配置管理: 使用配置管理工具
監控設置: 配置監控與日誌
安全設置: 配置安全策略

部署實作

import os

class AgentDeployment:
    def __init__(self, agent):
        self.agent = agent
        self.config = self._load_config()

    def _load_config(self) -> dict:
        return {
            "model": os.getenv("AGENT_MODEL", "gpt-5.2"),
            "max_concurrent": int(os.getenv("MAX_CONCURRENT", "10")),
            "timeout": int(os.getenv("AGENT_TIMEOUT", "30")),
            "api_key": os.getenv("AGENT_API_KEY")
        }

    def deploy(self):
        """部署 Agent"""
        print(f"部署 {self.agent.__class__.__name__}")
        print(f"模型: {self.config['model']}")
        print(f"並發數: {self.config['max_concurrent']}")
        print(f"超時: {self.config['timeout']}s")

可測量指標:

部署時間: < 5 分鐘
並發請求: > 100 QPS
可用性: > 99.9%

3.9 L9: Deployment Patterns

部署模式選擇

Blue-Green 部署: 藍綠部署模式
Canary 部署: 金絲雀部署模式
Rolling 部署: 滾動更新模式
A/B 測試: 分流測試模式

Blue-Green 實作

class DeploymentManager:
    def __init__(self):
        self.active_env = "blue"
        self.staging_env = "green"

    def deploy(self, new_version: str):
        """藍綠部署"""
        # 準備新環境
        self._prepare_staging(new_version)

        # 驗證新環境
        if not self._validate_staging():
            return "部署失敗: 新環境驗證不通過"

        # 切換流量
        self._switch_traffic()

        # 驗證生產環境
        if self._validate_production():
            return "部署成功"
        else:
            self._rollback()
            return "部署失敗: 生產環境驗證不通過"

    def _prepare_staging(self, version: str):
        # 準備新版本
        pass

    def _validate_staging(self) -> bool:
        # 驗證新環境
        return True

    def _switch_traffic(self):
        # 切換流量
        self.active_env = self.staging_env

    def _validate_production(self) -> bool:
        # 驗證生產環境
        return True

    def _rollback(self):
        # 回滾到舊版本
        self.active_env = self.staging_env

可測量指標:

部署時間: < 10 分鐘
零停機時間: 是
部署成功率: > 99%

3.10 L10: Error Recovery

錯誤處理模式

重試機制: 自動重試失敗請求
回退機制: 回退到備選方案
斷路器: 防止故障擴散
日誌記錄: 記錄錯誤日誌

錯誤處理實作

import time
from functools import wraps

class CircuitBreaker:
    def __init__(self, failure_threshold=5, timeout=60):
        self.failure_count = 0
        self.failure_threshold = failure_threshold
        self.timeout = timeout
        self.last_failure_time = None

    def call(self, func, *args, **kwargs):
        """斷路器調用"""
        if self._is_open():
            raise Exception("斷路器已打開，請稍後重試")

        try:
            result = func(*args, **kwargs)
            self.failure_count = 0
            return result
        except Exception as e:
            self.failure_count += 1
            self.last_failure_time = time.time()

            if self.failure_count >= self.failure_threshold:
                self._open()

            raise e

    def _is_open(self) -> bool:
        """檢查斷路器狀態"""
        if self.failure_count >= self.failure_threshold:
            if time.time() - self.last_failure_time > self.timeout:
                self.failure_count = 0
                return False
            return True
        return False

    def _open(self):
        """打開斷路器"""
        self.failure_count = self.failure_threshold

可測量指標:

重試成功率: > 95%
回退機制激活率: > 90%
斷路器保護時間: > 60 秒

3.11 L11: Team Onboarding

團隊培訓課程

課程設計: 設計結構化課程
實作練習: 提供實作練習題
知識傳承: 建立知識庫
持續學習: 提供進階內容

實作練習題

# 練習題 1: 建構簡單 Agent
def create_weather_agent():
    """建構天氣查詢 Agent"""
    pass

# 練習題 2: 整合多個工具
def create_multi_tool_agent():
    """建構多工具 Agent"""
    pass

# 練習題 3: 實作錯誤處理
def create_error_handling_agent():
    """實作錯誤處理 Agent"""
    pass

可測量指標:

學習完成率: > 80%
練習通過率: > 70%
知識保留率: > 60%

3.12 L12: Production Operations

運維實踐

監控設置: 配置監控與告警
日誌管理: 管理系統日誌
性能優化: 持續優化系統
故障處理: 處理系統故障

運維檢查清單

class OperationsChecklist:
    def __init__(self):
        self.items = [
            "監控系統正常運行",
            "日誌記錄完整",
            "性能指標正常",
            "安全策略生效",
            "備份機制正常"
        ]

    def check(self) -> bool:
        """執行檢查"""
        all_passed = True
        for item in self.items:
            if not self._check_item(item):
                all_passed = False
                print(f"檢查失敗: {item}")
        return all_passed

    def _check_item(self, item: str) -> bool:
        # 實際檢查邏輯
        return True

可測量指標:

系統可用性: > 99.9%
故障恢復時間: < 30 分鐘
日誌完整性: 100%

四、部署場景與實戰案例

4.1 客戶服務 Agent 部署

部署架構

用戶請求 → API Gateway → Agent Service → LLM Model → Response
                    ↓
                Guardrails
                    ↓
                Error Recovery

實作範例

class CustomerServiceAgent:
    def __init__(self):
        self.agent = create_agent(
            model="claude-sonnet-4.6",
            tools=[self.get_order_status, self.get_refund_policy],
            system_prompt="你是一個客戶服務 Agent",
        )
        self.guardrails = SafetyGuardrails()

    def handle_request(self, user_input: str) -> str:
        """處理用戶請求"""
        if not self.guardrails.check_content(user_input):
            return "請求內容不安全"

        try:
            result = self.agent.invoke(user_input)
            return result["messages"][-1].content_blocks
        except Exception as e:
            return f"處理失敗: {str(e)}"

可測量指標:

平均響應時間: < 2 秒
用戶滿意度: > 4.0/5.0
客戶服務成功率: > 95%

4.2 內容生成 Agent 部署

部署架構

用戶請求 → API Gateway → Content Agent → LLM Model → Response
                    ↓
                Content Filter
                    ↓
                Quality Check

實作範例

class ContentGenerationAgent:
    def __init__(self):
        self.agent = create_agent(
            model="gpt-5.2",
            tools=[self.search_knowledge],
            system_prompt="你是一個內容生成 Agent",
        )

    def generate_content(self, topic: str) -> str:
        """生成內容"""
        try:
            result = self.agent.invoke(topic)
            content = result["messages"][-1].content_blocks

            # 內容品質檢查
            if not self._check_quality(content):
                return "內容品質不足"

            return content
        except Exception as e:
            return f"生成失敗: {str(e)}"

    def _check_quality(self, content: str) -> bool:
        return len(content) > 100 and "敏感" not in content

可測量指標:

內容生成時間: < 5 秒
內容品質分數: > 8.0/10.0
生成成功率: > 95%

五、Tradeoffs 與設計考量

5.1 模型選擇的 Tradeoff

Tradeoff	選擇	優點	缺點
模型能力 vs 成本	GPT-5.2	高能力、高成本	高成本
模型能力 vs 速度	Claude Sonnet	高品質、中等速度	中等速度
速度 vs 成本	Gemini Flash	低成本、快速回應	中等品質

5.2 錯誤處理的 Tradeoff

Tradeoff	選擇	優點	缺點
重試次數	3 次	高成功率	增加延遲
回退方案	多方案	高容錯性	複雜性增加
斷路器保護	60 秒	防止故障擴散	暫時不可用

5.3 安全機制的 Tradeoff

Tradeoff	選擇	優點	缺點
自動過濾 vs 人工審查	自動過濾為主	高效率	可能誤過濾
過濾嚴格度	中等嚴格	平衡安全與體驗	可能誤過濾
警告 vs 阻止	阻止為主	強制安全	可能誤阻止

六、可測量指標總結

6.1 核心指標

指標類別	目標值	測量方法
響應時間	< 2 秒	響應時間測量
成功率	> 95%	任務完成統計
錯誤率	< 5%	錯誤統計
成本	< $0.01/請求	成本計算
可用性	> 99.9%	系統可用性監控

6.2 評估指標

指標類別	目標值	測量方法
內容品質	> 8.0/10.0	內容評分
用戶滿意度	> 4.0/5.0	用戶調查
錯誤率	< 5%	錯誤統計
重試成功率	> 95%	重試統計

七、總結與後續步驟

7.1 核心要點

漸進式學習: 從簡單到複雜，逐步建構知識體系
實作導向: 每個模組包含可執行的程式碼範例
可測量指標: 包含具體的效能指標與評估方法
可重現工作流程: 提供完整的實作步驟與檢查清單

7.2 後續步驟

選擇學習路徑: 根據自身需求選擇合適的學習模組
實作練習: 完成每個模組的實作練習
建構專案: 基於所學建構實際應用
持續優化: 根據實踐經驗優化系統

八、參考資源

8.1 官方文檔

8.2 社區資源

核心主題: 微軟 AI Agents for Beginners 12 課程架構解析與實作指南 實作場景: 從零開始建構可執行的 AI Agent 應用 技術類型: 教學指南 / 實作指南 / 可重現工作流程時間: 2026 年 4 月 23 日

Core Topic: Microsoft AI Agents for Beginners 12 course structure analysis and implementation guide Implementation Scenario: Build an executable AI Agent application from scratch Technology Type: Teaching Guide / Implementation Guide / Reproducible Workflow Time: April 23, 2026

Introduction: Why a structured curriculum is needed

In the field of AI Agent development, many beginners feel overwhelmed when faced with complex frameworks, model integration, and workflow design. This article is based on the Microsoft AI Agents for Beginners 12 course structure and provides a complete implementation guide to help developers build executable AI Agent applications from scratch.

This guide is not only a theoretical explanation, but also contains specific code examples, implementation steps, measurable indicators and deployment scenarios.

1. Overview of course structure

1.1 12 course module breakdown

Microsoft’s 12-course structure is designed as a progressive learning path, from introductory concepts to practical applications:

Course module	Topic	Technical level	Implementation focus
L1	Basic concepts of AI Agent	Getting started	Concept understanding, case demonstration
L2	Agent definition and model integration	Getting started	Agent construction, model selection
L3	Tools and API integration	Getting started	Tool calling, API integration
L4	Orchestration workflow	Elementary	Workflow design, status management
L5	Safety and Guardrails	Elementary	Safety mechanism, risk prevention
L6	Evaluation evaluation framework	Intermediate	Evaluation design, indicator selection
L7	Advanced Tools	Intermediate	Advanced tool use, advanced integration
L8	Production deployment	Intermediate	Deployment strategy, monitoring settings
L9	Deployment Patterns	Intermediate	Deployment modes, rolling updates
L10	Error Recovery	Intermediate	Error handling, retry mechanism
L11	Team Onboarding	Advanced	Team training, knowledge transfer
L12	Production Operations	Advanced	Operation and maintenance practice, continuous optimization

1.2 Learning path design principles

Progressive Learning: From simple concepts to complex implementation, gradually build a knowledge system
Implementation-oriented: Each module contains executable code examples
Measurable indicators: including specific performance indicators and evaluation methods
Reproducible Workflow: Provide complete implementation steps and checklists

2. Core concepts and architecture design

2.1 Core components of AI Agent

Agent definition

AI Agent is an intelligent system that can perceive the environment, think, make decisions and execute tools. Core composition:

Perception: environment observation, data input, tool output processing
Reasoning: model reasoning, decision making, and planning skills
Action: Tool call, API integration, execution output
Memory: short-term memory, long-term memory, context management

Differences from ordinary program code

Status Management: Automated status transfer and update
Tool Driver: Execution mode based on tool call
Model Reasoning: Using LLM for decision making
Error handling: automated retry and rollback mechanism

2.2 Model selection strategy

Model evaluation matrix

Model type	Applicable scenarios	Advantages and disadvantages	Recommendation
GPT-5.2	General tasks, complex reasoning	High power, high cost	⭐⭐⭐⭐⭐
Claude Sonnet 4.6	Text creation, analysis	High quality, affordable	⭐⭐⭐⭐⭐
Gemini 2.5 Flash	Fast response, low latency	Low cost, medium quality	⭐⭐⭐⭐
OpenRouter Anthropic	Mixed Use	High Flexibility	⭐⭐⭐⭐

Model selection decision tree

需求分析 → 成本預算 → 品質要求 → 模型選擇
    ↓            ↓            ↓
 通用任務      高預算        高品質
  複雜推理      中預算        平衡品質
                低預算        快速回應

Implementation example:

from langchain.agents import create_agent

def get_weather(city: str) -> str:
    """獲取天氣資訊"""
    return f"{city} 的天氣是晴天！"

# 基於需求選擇模型
agent = create_agent(
    model="openai:gpt-5.2",  # 通用任務
    # model="claude-sonnet-4.6",  # 文本創作
    # model="google_genai:gemini-2.5-flash-lite",  # 快速回應
    # model="openrouter:anthropic/claude-sonnet-4.6",  # 混合使用
    tools=[get_weather],
    system_prompt="你是一個天氣助手",
)

3. Detailed explanation of implementation module

3.1 L1: Basic concepts of AI Agent

Core concept understanding

Agent: An intelligent system that can perform tasks autonomously
Tools: External functions or APIs that Agent can call
Orchestration: Workflow design and status management
Safety: Safety mechanism and risk prevention

Implementation example: Simple Weather Agent

from langchain.agents import create_agent

def get_weather(city: str) -> str:
    """獲取天氣資訊"""
    return f"{city} 的天氣是晴天，溫度 25°C"

agent = create_agent(
    model="openai:gpt-5.2",
    tools=[get_weather],
    system_prompt="你是一個天氣助手，幫助用戶查詢天氣資訊",
)

result = agent.invoke({
    "messages": [{"role": "user", "content": "台北的天氣如何？"}]
})
print(result["messages"][-1].content_blocks)

Measurable indicators:

Response time: < 2 seconds
Mission success rate: > 95%
Error rate: < 5%

3.2 L2: Agent definition and model integration

Agent construction mode

Function Definition: Define the tools that Agent can use
Model Selection: Choose a suitable model
System prompts: Set the role and behavior of the Agent
Initialization: Construct Agent instance

Model integration implementation

from langchain.agents import create_agent

# 多模型整合範例
def get_weather(city: str) -> str:
    return f"{city} 的天氣"

# OpenAI 模型
agent_openai = create_agent(
    model="openai:gpt-5.2",
    tools=[get_weather],
    system_prompt="你是一個天氣助手",
)

# Anthropic 模型
agent_anthropic = create_agent(
    model="claude-sonnet-4.6",
    tools=[get_weather],
    system_prompt="你是一個天氣助手",
)

# Google Gemini 模型
agent_gemini = create_agent(
    model="google_genai:gemini-2.5-flash-lite",
    tools=[get_weather],
    system_prompt="你是一個天氣助手",
)

Measurable indicators:

Model response time: < 3 seconds
API call success rate: > 98%
Model switching cost: < 100ms

3.3 L3: Tools and API integration

Tool definition mode

Tool function: Define functions that can be called by Agent
Parameter verification: Ensure the correctness of the input parameters
Error handling: Handling tool execution failure
Logging: Record the tool calling process

API integration implementation

import requests

def get_stock_price(symbol: str) -> str:
    """獲取股票價格"""
    try:
        response = requests.get(f"https://api.example.com/stock/{symbol}")
        response.raise_for_status()
        return f"{symbol} 當前價格: ${response.json()['price']}"
    except Exception as e:
        return f"獲取 {symbol} 價格失敗: {str(e)}"

def get_news(category: str) -> str:
    """獲取新聞資訊"""
    try:
        response = requests.get(f"https://api.example.com/news/{category}")
        response.raise_for_status()
        return f"{category} 最新新聞:\n" + "\n".join(response.json()[:3])
    except Exception as e:
        return f"獲取 {category} 新聞失敗: {str(e)}"

agent = create_agent(
    model="openai:gpt-5.2",
    tools=[get_stock_price, get_news],
    system_prompt="你是一個金融資訊助手",
)

Measurable indicators:

API call success rate: > 95%
Tool response time: < 1 second
Error handling rate: < 5%

3.4 L4: Orchestration workflow

Workflow design pattern

State Definition: Define the states and transitions in the workflow
Node Design: Design each node of the workflow
Conditional judgment: Add conditional branches and branch processing
Status Management: Manage workflow execution status

State management implementation

from enum import Enum

class WorkflowState(Enum):
    PENDING = "pending"
    RUNNING = "running"
    COMPLETED = "completed"
    FAILED = "failed"

class WeatherAgent:
    def __init__(self):
        self.state = WorkflowState.PENDING

    def start(self, query: str):
        if self.state != WorkflowState.PENDING:
            return "工作流已開始或完成"
        
        self.state = WorkflowState.RUNNING
        result = self._execute(query)
        self.state = WorkflowState.COMPLETED
        return result

    def _execute(self, query: str) -> str:
        return f"執行 {query} 任務完成"

Measurable indicators:

Workflow execution time: < 5 seconds
State transition success rate: > 99%
Concurrent execution capability: supports N concurrent requests

3.5 L5: Safety and Guardrails

Security mechanism design

Content Filtering: Filter harmful content
Risk Assessment: Assess execution risks
Human Review: Enable human review when necessary
Automatic fallback: Fallback to the safe solution when execution fails

Guardrails Implementation

class SafetyGuardrails:
    def __init__(self):
        self.blocked_patterns = ["暴力", "仇恨", "色情", "非法"]

    def check_content(self, content: str) -> bool:
        """檢查內容安全性"""
        for pattern in self.blocked_patterns:
            if pattern in content:
                return False
        return True

    def safe_execute(self, tool_func, *args):
        """安全執行工具"""
        if not self.check_content(str(args)):
            return "內容不安全，執行已阻止"
        return tool_func(*args)

# 使用範例
def get_sensitive_data(id: str) -> str:
    return f"敏感數據: {id}"

guardrails = SafetyGuardrails()
result = guardrails.safe_execute(get_sensitive_data, "12345")

Measurable indicators:

Content detection accuracy: > 99%
Filter response time: < 500ms
Security incident interception rate: > 99%

3.6 L6: Evaluation evaluation framework

Evaluation indicator design

Input Quality: Evaluate the quality of user input
Response Time: Evaluate response speed
Cost-benefit: Evaluate the cost-benefit ratio
Error Rate: Evaluate the frequency of errors

Evaluation Implementation

from typing import Dict, Any

class AgentEvaluator:
    def evaluate(self, agent, test_cases: list) -> Dict[str, Any]:
        """評估 Agent 表現"""
        results = {
            "latency": [],
            "cost": [],
            "error_rate": 0,
            "success_rate": 0
        }

        for test_case in test_cases:
            start_time = time.time()
            try:
                result = agent.invoke(test_case)
                latency = time.time() - start_time
                results["latency"].append(latency)
                results["success_rate"] += 1
            except:
                results["error_rate"] += 1

        # 計算指標
        results["avg_latency"] = sum(results["latency"]) / len(results["latency"])
        results["avg_cost"] = sum(results["cost"]) / len(results["cost"])
        results["error_rate"] /= len(test_cases)
        results["success_rate"] /= len(test_cases)

        return results

Measurable indicators:

Average response time: < 2 seconds
Success rate: > 95%
Average cost: < $0.01/request

3.7 L7: Advanced Tools

Advanced tool usage

Multi-step tools: Combine multiple tools to complete complex tasks
Tool chain: Build tool call chain
Tool Optimization: Optimize tool calling efficiency

Tool chain implementation

class ToolChain:
    def __init__(self, tools: list):
        self.tools = tools

    def execute(self, query: str) -> str:
        """執行工具鏈"""
        results = []
        for tool in self.tools:
            result = tool(query)
            results.append(result)
        return "\n".join(results)

# 使用範例
def search_web(query: str) -> str:
    return f"搜尋: {query}"

def summarize(text: str) -> str:
    return f"摘要: {text[:100]}..."

tool_chain = ToolChain([search_web, summarize])
result = tool_chain.execute("AI Agent")

Measurable indicators:

Toolchain response time: < 5 seconds
Tool call success rate: > 98%
Chain call cost: < $0.05/request

3.8 L8: Production deployment

Deployment strategy design

Environment preparation: Ensure that the development environment is consistent with the production environment
Configuration Management: Use configuration management tools
Monitoring Settings: Configure monitoring and logging
Security Settings: Configure security policy

Deployment implementation

import os

class AgentDeployment:
    def __init__(self, agent):
        self.agent = agent
        self.config = self._load_config()

    def _load_config(self) -> dict:
        return {
            "model": os.getenv("AGENT_MODEL", "gpt-5.2"),
            "max_concurrent": int(os.getenv("MAX_CONCURRENT", "10")),
            "timeout": int(os.getenv("AGENT_TIMEOUT", "30")),
            "api_key": os.getenv("AGENT_API_KEY")
        }

    def deploy(self):
        """部署 Agent"""
        print(f"部署 {self.agent.__class__.__name__}")
        print(f"模型: {self.config['model']}")
        print(f"並發數: {self.config['max_concurrent']}")
        print(f"超時: {self.config['timeout']}s")

Measurable indicators:

Deployment time: < 5 minutes
Concurrent requests: > 100 QPS
Availability: > 99.9%

3.9 L9: Deployment Patterns

Deployment mode selection

Blue-Green deployment: Blue-green deployment mode
Canary Deployment: Canary deployment mode
Rolling deployment: rolling update mode
A/B Test: Split Test Mode

Blue-Green Implementation

class DeploymentManager:
    def __init__(self):
        self.active_env = "blue"
        self.staging_env = "green"

    def deploy(self, new_version: str):
        """藍綠部署"""
        # 準備新環境
        self._prepare_staging(new_version)

        # 驗證新環境
        if not self._validate_staging():
            return "部署失敗: 新環境驗證不通過"

        # 切換流量
        self._switch_traffic()

        # 驗證生產環境
        if self._validate_production():
            return "部署成功"
        else:
            self._rollback()
            return "部署失敗: 生產環境驗證不通過"

    def _prepare_staging(self, version: str):
        # 準備新版本
        pass

    def _validate_staging(self) -> bool:
        # 驗證新環境
        return True

    def _switch_traffic(self):
        # 切換流量
        self.active_env = self.staging_env

    def _validate_production(self) -> bool:
        # 驗證生產環境
        return True

    def _rollback(self):
        # 回滾到舊版本
        self.active_env = self.staging_env

Measurable indicators:

Deployment time: < 10 minutes
Zero downtime: Yes
Deployment success rate: > 99%

3.10 L10: Error Recovery

Error handling mode

Retry mechanism: Automatically retry failed requests
Rollback mechanism: Fallback to alternative plan
Circuit breaker: Prevent the spread of faults
Logging: Record error logs

Error handling implementation

import time
from functools import wraps

class CircuitBreaker:
    def __init__(self, failure_threshold=5, timeout=60):
        self.failure_count = 0
        self.failure_threshold = failure_threshold
        self.timeout = timeout
        self.last_failure_time = None

    def call(self, func, *args, **kwargs):
        """斷路器調用"""
        if self._is_open():
            raise Exception("斷路器已打開，請稍後重試")

        try:
            result = func(*args, **kwargs)
            self.failure_count = 0
            return result
        except Exception as e:
            self.failure_count += 1
            self.last_failure_time = time.time()

            if self.failure_count >= self.failure_threshold:
                self._open()

            raise e

    def _is_open(self) -> bool:
        """檢查斷路器狀態"""
        if self.failure_count >= self.failure_threshold:
            if time.time() - self.last_failure_time > self.timeout:
                self.failure_count = 0
                return False
            return True
        return False

    def _open(self):
        """打開斷路器"""
        self.failure_count = self.failure_threshold

Measurable indicators:

Retry success rate: > 95%
Fallback mechanism activation rate: > 90%
Circuit breaker protection time: > 60 seconds

3.11 L11: Team Onboarding

Team Training Course

Course Design: Design structured courses
Practical exercises: Provide practical exercises
Knowledge inheritance: Establish a knowledge base
Continuous Learning: Provide advanced content

Practical exercises

# 練習題 1: 建構簡單 Agent
def create_weather_agent():
    """建構天氣查詢 Agent"""
    pass

# 練習題 2: 整合多個工具
def create_multi_tool_agent():
    """建構多工具 Agent"""
    pass

# 練習題 3: 實作錯誤處理
def create_error_handling_agent():
    """實作錯誤處理 Agent"""
    pass

Measurable indicators:

Learning completion rate: > 80%
Exercise pass rate: > 70%
Knowledge retention rate: > 60%

3.12 L12: Production Operations

Operation and maintenance practice

Monitoring Settings: Configure monitoring and alarms
Log Management: Manage system logs
Performance Optimization: Continuously optimize the system
Troubleshooting: Handle system faults

Operation and maintenance checklist

class OperationsChecklist:
    def __init__(self):
        self.items = [
            "監控系統正常運行",
            "日誌記錄完整",
            "性能指標正常",
            "安全策略生效",
            "備份機制正常"
        ]

    def check(self) -> bool:
        """執行檢查"""
        all_passed = True
        for item in self.items:
            if not self._check_item(item):
                all_passed = False
                print(f"檢查失敗: {item}")
        return all_passed

    def _check_item(self, item: str) -> bool:
        # 實際檢查邏輯
        return True

Measurable indicators:

System availability: > 99.9%
Failure recovery time: < 30 minutes
Log integrity: 100%

4. Deployment scenarios and actual cases

4.1 Customer Service Agent Deployment

Deployment architecture

用戶請求 → API Gateway → Agent Service → LLM Model → Response
                    ↓
                Guardrails
                    ↓
                Error Recovery

Implementation example

class CustomerServiceAgent:
    def __init__(self):
        self.agent = create_agent(
            model="claude-sonnet-4.6",
            tools=[self.get_order_status, self.get_refund_policy],
            system_prompt="你是一個客戶服務 Agent",
        )
        self.guardrails = SafetyGuardrails()

    def handle_request(self, user_input: str) -> str:
        """處理用戶請求"""
        if not self.guardrails.check_content(user_input):
            return "請求內容不安全"

        try:
            result = self.agent.invoke(user_input)
            return result["messages"][-1].content_blocks
        except Exception as e:
            return f"處理失敗: {str(e)}"

Measurable indicators:

Average response time: < 2 seconds
User satisfaction: > 4.0/5.0
Customer service success rate: > 95%

4.2 Content Generation Agent Deployment

Deployment architecture

用戶請求 → API Gateway → Content Agent → LLM Model → Response
                    ↓
                Content Filter
                    ↓
                Quality Check

Implementation example

class ContentGenerationAgent:
    def __init__(self):
        self.agent = create_agent(
            model="gpt-5.2",
            tools=[self.search_knowledge],
            system_prompt="你是一個內容生成 Agent",
        )

    def generate_content(self, topic: str) -> str:
        """生成內容"""
        try:
            result = self.agent.invoke(topic)
            content = result["messages"][-1].content_blocks

            # 內容品質檢查
            if not self._check_quality(content):
                return "內容品質不足"

            return content
        except Exception as e:
            return f"生成失敗: {str(e)}"

    def _check_quality(self, content: str) -> bool:
        return len(content) > 100 and "敏感" not in content

Measurable indicators:

Content generation time: < 5 seconds
Content Quality Score: > 8.0/10.0
Generation success rate: > 95%

5. Tradeoffs and design considerations

5.1 Tradeoff for model selection

Tradeoff	Choice	Pros	Cons
Model capability vs cost	GPT-5.2	High capability, high cost	High cost
Model power vs speed	Claude Sonnet	High quality, medium speed	Medium speed
Speed vs Cost	Gemini Flash	Low cost, fast response	Medium quality

5.2 Error handling Tradeoff

Tradeoff	Choice	Pros	Cons
Number of retries	3 times	High success rate	Increased latency
Fallback scenarios	Multiple scenarios	High fault tolerance	Increased complexity
Circuit breaker protection	60 seconds	Prevent fault spread	Temporarily unavailable

5.3 Tradeoff of security mechanism

Tradeoff	Choice	Pros	Cons
Automatic filtering vs manual review	Mainly automatic filtering	High efficiency	Possible filtering by mistake
Filtering stringency	Medium stringency	Balance security and experience	Possible filtering errors
Warn vs Block	Block mostly	Enforce safety	May block by mistake

6. Summary of measurable indicators

6.1 Core indicators

Indicator Category	Target Value	Measurement Method
Response Time	< 2 seconds	Response Time Measurement
Success rate	> 95%	Task completion statistics
Error rate	< 5%	Error statistics
Cost	< $0.01/request	Cost Calculation
Availability	> 99.9%	System availability monitoring

6.2 Evaluation indicators

Indicator Category	Target Value	Measurement Method
Content Quality	> 8.0/10.0	Content Rating
User Satisfaction	> 4.0/5.0	User Survey
Error rate	< 5%	Error statistics
Retry success rate	> 95%	Retry statistics

7. Summary and next steps

7.1 Core Points

Progressive Learning: From simple to complex, gradually build a knowledge system
Implementation-oriented: Each module contains executable code examples
Measurable indicators: including specific performance indicators and evaluation methods
Reproducible Workflow: Provide complete implementation steps and checklists

7.2 Next steps

Select learning path: Choose the appropriate learning module according to your own needs
Practical Exercises: Complete the practical exercises of each module
Construction Project: Construct practical applications based on what you have learned
Continuous Optimization: Optimize the system based on practical experience

8. Reference resources

8.1 Official Documentation

8.2 Community Resources

Core Topic: Microsoft AI Agents for Beginners 12 course structure analysis and implementation guide Implementation Scenario: Build an executable AI Agent application from scratch Technology Type: Teaching Guide / Implementation Guide / Reproducible Workflow Time: April 23, 2026