Terry Yao's Blog

[ai] AI 工作流自動化

閱讀時間約 25 分鐘

cover

AI 工作流自動化

當我們談到 AI 應用，多數人想到的是「問一個問題，得到一個回答」。 但真實世界的工作流程遠比這複雜——你需要多步驟串聯、條件分流、呼叫外部工具、處理例外狀況。

本文介紹 AI 工作流自動化的三個層級：No-Code（n8n）、Low-Code（LangChain） 和 Agent Framework，幫你在不同場景下選擇正確的工具。

架構概覽

flowchart LR
    Trigger["觸發 Trigger\nWebhook / 排程\nEmail / 事件"] --> Agent["AI Agent\n意圖分類\n任務規劃"]
    Agent --> Tools["工具呼叫 Tool Use\nAPI / 資料庫\n搜尋 / RAG"]
    Tools --> Review{{"人工審核\nHuman Review"}}
    Review -->|核准| Execute["執行 Execute\n發送通知\n寫入資料\n部署更新"]
    Review -->|駁回| Revise["修正 Revise\n調整參數\n重新生成"]
    Revise --> Agent

    subgraph 工具層級["自動化工具選擇"]
        direction TB
        L1["No-Code\nn8n / Zapier\n固定流程"]
        L2["Low-Code\nLangChain\nRAG / Chain"]
        L3["Agent\nCrewAI / AutoGPT\n自主決策"]
    end

    Agent -.-> 工具層級

為什麼需要工作流自動化

一次 LLM 呼叫 = 一個問題、一個回答。但真實世界的任務往往像這樣：

使用者提問 → 判斷意圖 → 查詢資料庫 → 呼叫外部 API
→ 整合多來源資料 → 生成回答 → 寫入記錄 → 發送通知
能力說明單次 LLM 能做到？
多步驟執行按順序完成 A → B → C不行
工具使用查資料庫、呼叫 API不行（需要 function calling）
條件分支根據結果走不同路線不行
錯誤處理失敗時重試或走備用路線不行
排程執行每天定時跑不行
狀態管理記住之前的步驟結果有限（context window）

你可能想寫個 Python script 把步驟串起來，但當你有 10+ 個自動化流程、需要非工程師也能修改、需要監控和錯誤通知時，手動管理就成了維護噩夢。

工作流自動化的核心價值：

  1. 減少重複工作 — 讓機器做機器擅長的事
  2. 降低人為錯誤 — 流程標準化
  3. 提升效率 — 7x24 不間斷執行
  4. 可追蹤 — 每一步都有記錄

自動化工具的層級

Level 1: No-Code (n8n, Make/Zapier)
  → 拖拽連接、視覺化流程、非技術人員可用

Level 2: Low-Code (LangChain, LlamaIndex)
  → Python/JS SDK、Chain 組合、開發者導向

Level 3: Agent Framework (AutoGPT, CrewAI, Claude Code)
  → 自主決策、工具使用、多步驟推理
維度No-CodeLow-CodeAgent
學習曲線低中高
靈活性低中高
可預測性高中低
成本控制容易中等困難
維護成本低中高
適合對象PM、行銷、營運開發者AI 工程師

核心原則：能用簡單工具解決的問題，就不要用複雜工具。

n8n 深入

什麼是 n8n

n8n 是開源的工作流自動化平台（唸作 “nodemation”），核心特色：

  • 開源 — 程式碼公開，社群活躍
  • 可自架 — 部署在自己的伺服器上，資料不離開你的環境
  • 視覺化編輯器 — 拖拽式建立工作流
  • 400+ 整合 — Slack、Email、資料庫、HTTP、Google Sheets 等
  • AI 原生支援 — 內建 AI Agent、LLM、向量儲存等節點

n8n vs Zapier/Make

功能n8nZapierMake
開源是否否
可自架是否否
免費額度無限（自架）100 tasks/月1,000 ops/月
AI 整合原生（AI nodes）基本中等
複雜度中等簡單中等
資料隱私完全掌控僅雲端僅雲端
程式碼節點支援（JS/Python）有限有限
錯誤處理靈活（Error Trigger）基本中等
Webhook原生支援付費方案原生支援

選 n8n 的理由： 在意資料隱私、需要 self-hosted、需要 AI 整合、需要自訂程式碼邏輯。

選 Zapier 的理由： 不想管伺服器、需要最簡單的體驗、自動化量很小。

n8n + AI 實務範例

範例 1：智能客服系統
[Webhook] 收到客戶訊息
    │
    ▼
[AI Agent] 分類意圖
    │
    ├── FAQ → [Vector Store] RAG 搜尋 → [AI] 生成回答 → Reply
    ├── 技術問題 → [Jira] 建 Ticket → [Slack] 通知工程師
    └── 投訴 → [Database] 記錄 → [Email] 通知主管

AI Agent 節點設定概念：

{
  "node": "AI Agent",
  "parameters": {
    "model": "gpt-4o-mini",
    "systemPrompt": "你是客服意圖分類器。回傳分類：FAQ、TECH_ISSUE、COMPLAINT。只回傳分類名稱。",
    "inputText": "={{ $json.message }}"
  }
}
範例 2：自動內容管理流水線
[RSS Feed Trigger] 抓取新聞
    → [AI] 生成摘要（300 字以內）
    → [AI] 分類（技術/商業/政治/其他）
    → [IF] 只留「技術」和「商業」
    → [AI] 翻譯成繁體中文
    → [Notion] 儲存
    → [Slack] 發送每日摘要

AI 摘要 prompt 範例：

請將以下文章摘要為 300 字以內的繁體中文。
要求：保留關鍵數字和事實、第一句話概括全文重點。

文章內容：{{ $json.content }}
範例 3：每日資料分析報表
[Cron Trigger] 每天早上 9:00
    → [PostgreSQL] 查詢昨日新訂單
    → [AI] 分析訂單模式（AOV、熱門商品、異常偵測）
    → [Google Sheets] 更新報表
    → [AI] 生成摘要報告
    → [Email] 發送給管理團隊

SELECT o.id, o.total_amount, o.created_at,
  json_agg(json_build_object('product', p.name, 'quantity', oi.quantity)) as items
FROM orders o
JOIN order_items oi ON o.id = oi.order_id
JOIN products p ON oi.product_id = p.id
WHERE o.created_at >= CURRENT_DATE - INTERVAL '1 day'
  AND o.created_at < CURRENT_DATE
GROUP BY o.id ORDER BY o.total_amount DESC;

n8n Docker 部署

基本部署
# docker-compose.yml
services:
  n8n:
    image: n8nio/n8n
    restart: always
    ports:
      - "5678:5678"
    environment:
      - N8N_BASIC_AUTH_ACTIVE=true
      - N8N_BASIC_AUTH_USER=admin
      - N8N_BASIC_AUTH_PASSWORD=changeme
      - GENERIC_TIMEZONE=Asia/Taipei
    volumes:
      - n8n-data:/home/node/.n8n
volumes:
  n8n-data:
docker compose up -d
# 開啟 http://localhost:5678
正式環境部署（含 PostgreSQL）
# docker-compose.prod.yml
services:
  n8n:
    image: n8nio/n8n
    restart: always
    ports:
      - "5678:5678"
    environment:
      - N8N_BASIC_AUTH_ACTIVE=true
      - N8N_BASIC_AUTH_USER=${N8N_USER}
      - N8N_BASIC_AUTH_PASSWORD=${N8N_PASSWORD}
      - GENERIC_TIMEZONE=Asia/Taipei
      - DB_TYPE=postgresdb
      - DB_POSTGRESDB_HOST=postgres
      - DB_POSTGRESDB_PORT=5432
      - DB_POSTGRESDB_DATABASE=n8n
      - DB_POSTGRESDB_USER=${POSTGRES_USER}
      - DB_POSTGRESDB_PASSWORD=${POSTGRES_PASSWORD}
      - WEBHOOK_URL=https://n8n.yourdomain.com/
      - EXECUTIONS_DATA_PRUNE=true
      - EXECUTIONS_DATA_MAX_AGE=168
      - N8N_METRICS=true
    volumes:
      - n8n-data:/home/node/.n8n
    depends_on:
      postgres:
        condition: service_healthy
 
  postgres:
    image: postgres:16-alpine
    restart: always
    environment:
      - POSTGRES_USER=${POSTGRES_USER}
      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD}
      - POSTGRES_DB=n8n
    volumes:
      - postgres-data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER}"]
      interval: 10s
      timeout: 5s
      retries: 5
 
volumes:
  n8n-data:
  postgres-data:

.env 檔案：

N8N_USER=admin
N8N_PASSWORD=your-secure-password-here
POSTGRES_USER=n8n
POSTGRES_PASSWORD=your-db-password-here
Nginx 反向代理
server {
    listen 443 ssl;
    server_name n8n.yourdomain.com;
 
    ssl_certificate /etc/letsencrypt/live/n8n.yourdomain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/n8n.yourdomain.com/privkey.pem;
 
    location / {
        proxy_pass http://localhost:5678;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
    }
}

LangChain 深入

什麼是 LangChain

LangChain 是 Python/JS 框架，核心理念：把 LLM 應用拆分成可組合的元件，透過 chain 串接。

核心概念

概念說明類比
LLM語言模型（GPT-4、Claude）大腦
Prompt Template結構化提示詞模板問題模板
Chain一連串操作步驟流水線
Agent自主決定使用工具的 LLM有工具的助手
Tool外部能力（搜尋、計算、API）工具箱
Memory對話歷史管理記憶
Retriever從向量儲存檢索文件圖書館員
Output ParserLLM 輸出轉結構化資料翻譯器

基礎範例：Simple Chain

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
 
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
 
prompt = ChatPromptTemplate.from_messages([
    ("system", "你是專業的技術文件撰寫者。請用繁體中文回答。"),
    ("user", "請解釋什麼是 {topic}，用 3 個重點說明。")
])
 
# LCEL (LangChain Expression Language)
chain = prompt | llm | StrOutputParser()
result = chain.invoke({"topic": "微服務架構"})

進階範例：RAG Chain

from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_community.vectorstores import Chroma
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough
from langchain_core.output_parsers import StrOutputParser
 
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
vectorstore = Chroma(persist_directory="./chroma_db", embedding_function=embeddings)
retriever = vectorstore.as_retriever(search_type="similarity", search_kwargs={"k": 5})
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
 
prompt = ChatPromptTemplate.from_messages([
    ("system", """根據以下參考資料回答問題。沒有相關資訊請誠實說明。
參考資料：{context}"""),
    ("user", "{question}")
])
 
def format_docs(docs):
    return "\n\n---\n\n".join(
        f"[來源: {doc.metadata.get('source', '未知')}]\n{doc.page_content}"
        for doc in docs
    )
 
rag_chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | prompt | llm | StrOutputParser()
)
 
answer = rag_chain.invoke("如何設定 n8n 的 webhook？")

進階範例：帶工具的 Agent

from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_openai_tools_agent
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_community.tools import DuckDuckGoSearchRun
from langchain_core.tools import tool
 
@tool
def get_weather(city: str) -> str:
    """取得指定城市的天氣資訊"""
    import requests
    response = requests.get(f"https://wttr.in/{city}?format=j1")
    if response.status_code == 200:
        current = response.json()["current_condition"][0]
        return f"{city} 溫度 {current['temp_C']}°C，{current['weatherDesc'][0]['value']}"
    return f"無法取得 {city} 的天氣資訊"
 
tools = [DuckDuckGoSearchRun(), get_weather]
 
prompt = ChatPromptTemplate.from_messages([
    ("system", "你是有用的助手，可以搜尋和查天氣。用繁體中文回答。"),
    ("user", "{input}"),
    MessagesPlaceholder(variable_name="agent_scratchpad"),
])
 
llm = ChatOpenAI(model="gpt-4o", temperature=0)
agent = create_openai_tools_agent(llm, tools, prompt)
agent_executor = AgentExecutor(
    agent=agent, tools=tools,
    verbose=True, max_iterations=10, handle_parsing_errors=True
)
 
result = agent_executor.invoke({"input": "台北現在幾度？"})

LangChain vs Direct API Calls

面向Direct APILangChain
簡單度非常簡單有學習曲線
靈活度完全控制受框架約束
可複用性手動管理內建 chain 組合
工具整合自己做大量預建工具
版本穩定API 穩定框架更新頻繁
相依性少多

何時不需要 LangChain

不需要的情況：簡單問答、單一 prompt、不需要 Memory、不需要工具。

# 直接用 OpenAI SDK 就夠了
from openai import OpenAI
client = OpenAI()
response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "system", "content": "你是翻譯助手"},
        {"role": "user", "content": "Translate to Chinese: Hello World"}
    ]
)
# 就這樣，不需要 LangChain

需要 LangChain 的信號： 串接 3+ 步驟、需要 RAG、需要 Agent、需要 Memory、需要多 LLM Provider。

LangChain 是為「編排（orchestration）」而生的，不是為「簡單呼叫」而生的。

Agent 架構

什麼是 AI Agent

AI Agent = LLM + Tools + Memory + Planning，能夠自主決策、使用工具、多步推理。

             ┌───────────────────────────┐
             │        AI Agent           │
  Input ────►│  LLM + Tools + Memory     │────► Output
             └─────────┬─────────────────┘
                 ┌─────┼─────┐
                 ▼     ▼     ▼
              搜尋   程式碼   API

Agent 遵循 ReAct（Reasoning + Acting） 模式：

User: 比較台北和東京今天的天氣

Think: 先查台北天氣
Act:   call get_weather("台北") → 32°C，晴天
Think: 再查東京
Act:   call get_weather("東京") → 28°C，多雲
Think: 可以比較了
Respond: 台北 32°C 晴天，東京 28°C 多雲，台北高 4°C。

Agent vs Workflow 的差別

面向Workflow（n8n）Agent（LangChain）
流程預先定義動態決策
可預測性高（確定的路徑）低（每次可能不同）
適合重複性任務探索性任務
錯誤處理每步定義Agent 自行判斷
成本可預測可能暴增（多次 API call）
Debug容易（看流程圖）困難（黑盒決策）
速度快（直接執行）慢（每步都要推理）
可靠性高中低

最佳實務：80% 用 Workflow，20% 用 Agent。

Agent 的常見問題

1. 無限迴圈 — Agent 反覆執行相同工具

# 解決：設定上限
AgentExecutor(agent=agent, tools=tools,
    max_iterations=10, max_execution_time=60,
    early_stopping_method="generate")

2. 成本爆炸 — 一個複雜任務可能 10-50 次 API call

Agent（GPT-4o）: 每次執行 ~$0.05-0.10 → 1000次/天 = $50-100/天
Workflow（GPT-4o-mini）: 每次執行 ~$0.001 → 1000次/天 = $1/天

3. 工具幻覺 — Agent「發明」不存在的工具，用錯參數呼叫

4. 行為不一致 — 相同輸入產生不同執行路徑。解決：temperature=0 + 明確 system prompt。

選型決策

你要自動化的是什麼？
├── 固定流程、重複執行 → n8n
├── 需要 AI 做決策分流 → n8n + AI nodes
├── 需要複雜的 LLM chain → LangChain
├── 需要自主決策和工具使用 → Agent framework
└── 需要 production-grade → 混合使用
場景推薦工具原因
Email 自動回覆n8n固定流程
客服意圖分類n8n + AI node需要 AI 但流程固定
文件問答（RAG）LangChain需要向量搜尋和 chain
每日報表生成n8n排程 + 資料查詢 + AI 摘要
程式碼審查助手Agent需要閱讀、理解、建議
資料同步n8n不需要 AI
研究報告撰寫Agent需要搜尋、閱讀、綜合

真實場景攻略：我遇到這個問題，該用什麼？

上面的比較表很好懂，但你可能會想：「所以我現在想做的那件事，到底該用什麼？」以下是一些真實的場景，附帶具體的工具選擇和流程設計。

場景 1：社群內容策展 → Blog 文章

「我在 Twitter/Facebook 上常分享 AI 相關文章，但量越來越大、重複的多、偏門的也多，想定期整理成 blog 文章。」

推薦：n8n + AI nodes

為什麼不是 LangChain？因為流程是固定的（收集 → 分類 → 去重 → 摘要 → 存檔），不需要動態決策。n8n 的視覺化編輯器讓你可以隨時調整分類規則，不用改 code。

[收集] Twitter Bookmarks Export / RSS
    → [AI node] 語意分類（model release / agent framework / tool / opinion / research）
    → [AI node] 品質評分（原創深度分析 vs 轉發新聞 vs 偏門冷門）
    → [Code node] URL + 語意去重（同一概念不同人講的也算重複）
    → [AI node] 每則產生一行中文摘要
    → [Notion] 寫入「Content Inbox」資料庫
    → [IF] 某主題累積 ≥ 5 則
        → [AI node] 聚合成 blog 文章 draft
        → [Notion] 建立 draft 頁面

重點： 收集和分類是全自動的，但最終 blog 文章還是要人看過再發。AI 產的 draft 是起點，不是終點。

場景 2：時間追蹤自動化

「我用 ActivityWatch 記錄每天在各軟體上花的時間，想自動推到 Notion 做每日覆盤。」

推薦：n8n（不需要 AI）

這是純資料同步，連 AI 都不需要。

[Cron Trigger] 每天 23:00
    → [HTTP Request] 呼叫 ActivityWatch API，拉今天的使用紀錄
    → [Code node] 整理資料格式（應用 → 時數 → 分類）
    → [Notion] 更新每日覆盤頁面

延伸：加一個 AI 節點做「今天時間分配是否健康？」的簡短分析。但這是 nice-to-have，不是核心。

場景 3：Discord Bot 自動客服

「我的 Discord 社群有人常問重複的問題，想用 bot 自動回答，回答不了的再轉給人。」

推薦：n8n + AI node + RAG

如果你的 FAQ 量小（< 50 題），n8n 內建的 AI node 就夠了。量大的話需要搭 RAG。

[Discord Trigger] 收到訊息
    → [IF] 是否 @ bot
    → [AI Agent node] 查 FAQ 向量庫 → 生成回答
    → [IF] confidence > 0.8
        → [Discord] 回覆答案
        → [Discord] 加上「這個回答有幫到你嗎？」的 reaction
    → [ELSE]
        → [Discord] 回覆「讓我幫你轉給真人」
        → [Slack/Email] 通知管理員

場景 4：PR Code Review 自動摘要

「我的團隊 PR 太多了，每個都要點進去看 diff 很花時間。能不能自動產出 PR 摘要？」

推薦：n8n + AI node

[GitHub Webhook] 新 PR 開啟
    → [GitHub] 取得 PR diff
    → [AI node] 分析 diff，產生摘要：
        - 改了什麼（哪些檔案、哪些功能）
        - 潛在風險（安全、效能、breaking change）
        - 建議的 review 重點
    → [GitHub] 將摘要 post 為 PR comment
    → [Slack] 通知 reviewer

Agent 在這裡不需要，因為流程是固定的：拿 diff → 分析 → 貼回去。不需要 Agent 「自己決定要不要去看其他檔案」。

場景 5：文件搜尋 + 問答系統

「我們有幾百頁的技術文件和 Runbook，新人找不到東西。想做一個問答系統。」

推薦：LangChain RAG

這裡 n8n 不夠用了。你需要的是：向量化所有文件 → 語意搜尋最相關的段落 → LLM 根據段落生成答案。這是 RAG 的經典場景。

[用戶提問] → [Embedding] 將問題向量化
    → [Vector DB] 搜尋最相關的 5 個文件段落
    → [LLM] 根據段落回答問題，附上來源
    → [回覆用戶]

詳見 RAG 架構實務。

場景 6：多語系翻譯管線

「我們的產品要支援多語系，Copywriter 寫完中文稿後，想自動翻譯成英文和日文，但要人工校稿。」

推薦：n8n + AI node

[Notion Trigger] 中文稿件標記為「Ready」
    → [AI node] 翻譯成英文
    → [AI node] 翻譯成日文
    → [Notion] 建立英文/日文版本頁面，標記為「待校稿」
    → [Slack] 通知翻譯人員校稿

Agent 在這裡完全多餘。流程固定、模型只需要做翻譯、人工在最後端。

場景對照總結

看到規律了嗎？

特徵→ 用什麼
流程固定、步驟明確n8n
固定流程 + 需要 AI 做分類/摘要/翻譯n8n + AI node
需要語意搜尋大量文件LangChain RAG
需要 AI 動態決定「接下來做什麼」Agent
不需要 AI，純資料同步n8n（不用 AI node）

一句話原則：如果你能畫出流程圖，就用 n8n。如果你畫不出來（因為每次路徑不同），才考慮 Agent。

混合使用架構

實務上最有效的做法是混合使用：

  外部觸發 → n8n (流程編排)
                │
     ┌──────────┼──────────┐
     ▼          ▼          ▼
  簡單 AI    LangChain    Agent
  節點        API          API
 (分類/摘要)  (RAG/Chain)  (複雜推理)

LangChain 包裝成 API 供 n8n 呼叫：

from fastapi import FastAPI
from pydantic import BaseModel
 
app = FastAPI()
 
class QueryRequest(BaseModel):
    question: str
 
@app.post("/api/rag/query")
async def query_rag(request: QueryRequest):
    answer = rag_chain.invoke(request.question)
    return {"answer": answer}
 
@app.post("/api/agent/execute")
async def execute_agent(request: QueryRequest):
    result = agent_executor.invoke({"input": request.question})
    return {"answer": result["output"]}

n8n 用 HTTP Request 節點呼叫：

{
  "node": "HTTP Request",
  "parameters": {
    "method": "POST",
    "url": "http://langchain-api:8000/api/rag/query",
    "body": { "question": "={{ $json.userMessage }}" }
  }
}

實務建議

  1. 從 n8n 開始 — 大多數自動化需求 n8n 都能搞定
  2. 只在 n8n 不夠用時才引入 LangChain — 例如 RAG 或複雜 chain
  3. Agent 是最後手段 — 強大但昂貴且不可預測
  4. 永遠保留人工介入選項 — 不要完全信任 AI 自動化決策
  5. 先用 GPT-4o-mini，不夠再升級 — 很多簡單任務不需要最強模型

安全與風險

API Key 管理

❌ 絕對不要：直接寫在程式碼或 docker-compose.yml 裡 commit

✅ 正確做法：
  - 環境變數 export OPENAI_API_KEY=sk-...
  - .env 檔案（加入 .gitignore）
  - Secret Manager（AWS Secrets Manager、HashiCorp Vault）
  - n8n 的 Credential 功能（加密儲存）

資料隱私

使用者輸入 → n8n（你的伺服器）→ OpenAI API（美國伺服器）
                                    ↑ 你的資料到了第三方！
隱私層級方案範例
低敏感度Cloud LLM（OpenAI、Anthropic）公開資訊摘要
中敏感度有 DPA 的 Cloud LLM內部文件摘要
高敏感度Self-hosted LLM（Ollama + Llama）客戶個資處理

n8n + Ollama 完全私有方案：

services:
  n8n:
    image: n8nio/n8n
    # ... n8n 設定 ...
  ollama:
    image: ollama/ollama
    volumes:
      - ollama-data:/root/.ollama
    ports:
      - "11434:11434"
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]

成本控制

# 用 LangChain callback 追蹤 token 使用
from langchain_community.callbacks import get_openai_callback
 
with get_openai_callback() as cb:
    result = chain.invoke({"question": "..."})
    print(f"Tokens: {cb.total_tokens}, Cost: ${cb.total_cost:.4f}")
 
# 快取重複查詢
from langchain.cache import InMemoryCache
from langchain.globals import set_llm_cache
set_llm_cache(InMemoryCache())

模型選用策略：分類/摘要/翻譯 → gpt-4o-mini，複雜推理 → gpt-4o。

輸出驗證

永遠不要盲目信任 AI 的輸出：

from pydantic import BaseModel, validator
from langchain_core.output_parsers import PydanticOutputParser
 
class CustomerIntent(BaseModel):
    intent: str
    confidence: float
 
    @validator('intent')
    def validate_intent(cls, v):
        allowed = ['FAQ', 'TECH_ISSUE', 'COMPLAINT', 'OTHER']
        if v not in allowed:
            raise ValueError(f'Intent must be one of {allowed}')
        return v
 
parser = PydanticOutputParser(pydantic_object=CustomerIntent)
chain = prompt | llm | parser  # 不符合 schema 會拋出錯誤

錯誤處理

n8n 的錯誤處理流程：

[Workflow] → 成功 → 繼續
           → 失敗 → [Error Trigger]
                    → 重試（最多 3 次，間隔遞增）
                    → 仍失敗 → Log + Slack 通知 + Fallback（人工處理）

常見問題與陷阱

1.「用 AI 自動化一切」 — 資料同步、格式轉換、定時備份不需要 AI。AI 適合非結構化資料處理、語意理解、分類/摘要/生成。

2. Agent 成本失控 — Agent 遇到不確定就一直搜尋，一天 50,000 次 GPT-4 call，月底帳單 $2,000+。預防：設 max_iterations、設 API budget、先用 mini 模型測試。

3. 過度複雜的 Chain — 先用最簡單的 chain，只在確實需要時才增加步驟。每增加一步都增加失敗點和延遲。

4. 忽略 Error Handling — AI 失敗了使用者收不到回覆。必須有 Retry + Fallback Reply + Error Log。

5. 沒有監控 — 必須追蹤：執行成功率、平均執行時間、API 成本、錯誤類型分佈、AI 輸出品質。n8n 支援 N8N_METRICS=true 搭配 Prometheus + Grafana。

快速上手指南

Week 1: n8n 基礎
  → 安裝 n8n（Docker）→ 建立 Webhook → Slack workflow

Week 2: n8n + AI
  → 設定 OpenAI Credential → AI 節點分類/摘要 → 完整 AI 自動化流程

Week 3: LangChain 基礎
  → pip install langchain → Simple Chain → LCEL

Week 4: 整合
  → LangChain 包裝 API → n8n 呼叫 → Error Handling + 監控

總結

工具定位最佳場景最大優勢
n8n流程自動化平台固定流程、觸發式任務開源、視覺化、400+ 整合
LangChainLLM 應用框架RAG、複雜 chain豐富元件、活躍生態
Agent自主決策系統探索性、開放式任務靈活、處理未預見情況

不要因為技術很新很酷就選它。選最適合你問題的工具。 n8n 加一個 AI 節點能解決，就不需要 LangChain。 LangChain 的 Chain 能解決，就不需要 Agent。 越簡單的方案，越容易維護、越省錢、越可靠。

延伸閱讀

外部資源：

關係圖譜

反向連結