LangChain 完整教學 2026：從零構建企業級 LLM 應用

TL;DR — LangChain 係 2026 年最主流嘅 LLM 應用開發框架，GitHub 135K+ stars，35% Fortune 500 企業用緊。本文由零開始，帶你用 Python 構建 Chain → RAG → Agent → LangGraph 工作流，最後部署上線。

1. 什麼是 LangChain？

一句話定義

LangChain 係一個 Python 開源框架，幫你用大語言模型（LLM）構建實際應用。

佢唔係一個 LLM 模型本身，而係一個中間層框架——將 LLM（GPT-4、Claude、Gemini 等）同你嘅業務邏輯、外部數據、工具 API 串埋一齊。

┌─────────────────────────────────────┐
│          你嘅業務應用                  │
│   （客服機器人 / 文檔問答 / 數據分析）  │
├─────────────────────────────────────┤
│          LangChain 框架              │
│   Prompt │ Chain │ Agent │ Memory    │
├─────────────────────────────────────┤
│          LLM + 外部資源              │
│   OpenAI │ Claude │ 數據庫 │ API     │
└─────────────────────────────────────┘

為什麼需要 LangChain？

直接調用 LLM API 只能做到單輪問答。但實際業務需要：

需求	直接調 API	用 LangChain
單輪問答	✅	✅
多步驟推理鏈	❌ 要自己寫	✅ Chain 組合
讀取公司文檔回答	❌ 要自己建 RAG	✅ 內建 RAG 組件
自主選擇工具	❌ 要自己寫邏輯	✅ Agent 框架
記住對話歷史	❌ 要自己管理	✅ Memory 模塊
切換不同 LLM	❌ 要改代碼	✅ 統一接口
調試追蹤	❌ 要自己加 log	✅ LangSmith 整合

關鍵數據（2026）

GitHub Stars: 135,000+
支持模型: 80+ 供應商（OpenAI / Anthropic / Google / 本地模型）
生產採用: 35% Fortune 500 企業
v1.0 發布: 2025 年 10 月（架構穩定化）
Klarna / LinkedIn / Uber / Replit 都用 LangChain 做 Agent 工作流

2. 核心架構：七大組件

LangChain 嘅設計哲學係可組合嘅積木。你唔需要用晒全部七個，但每個都有明確用途：

組件總覽

┌──────────────────────────────────────────────────┐
│                 LangChain 七大組件                  │
├──────────────────────────────────────────────────┤
│                                                  │
│  ① Chat Models ──── 統一接口調用唔同 LLM           │
│  ② Prompt Templates ── 參數化提示詞模板             │
│  ③ Chains (LCEL) ──── 用 pipe | 組合多步驟         │
│  ④ Retrievers ─────── RAG 檢索外部文檔              │
│  ⑤ Tools ──────────── 畀 Agent 調用外部工具         │
│  ⑥ Agents ─────────── 自主決策工作流                │
│  ⑦ Memory ─────────── 對話記憶管理                  │
│                                                  │
└──────────────────────────────────────────────────┘

① Chat Models — 統一模型接口

# 一行切換模型供應商
from langchain_openai import ChatOpenAI
from langchain_anthropic import ChatAnthropic

# OpenAI
gpt = ChatOpenAI(model="gpt-4o", temperature=0)

# Anthropic
claude = ChatAnthropic(model="claude-sonnet-4-20250514", temperature=0)

# 接口完全一樣
response = gpt.invoke("你好")
response = claude.invoke("你好")

② Prompt Templates — 參數化提示詞

from langchain_core.prompts import ChatPromptTemplate

# 定義模板
prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一個專業的{role}，用{language}回答問題。"),
    ("human", "{question}"),
])

# 填入參數
formatted = prompt.invoke({
    "role": "金融分析師",
    "language": "繁體中文",
    "question": "解釋什麼是 DCF 估值"
})

③ Chains (LCEL) — 管道組合

LCEL（LangChain Expression Language）係 2026 年唯一推薦嘅組合方式。用 | pipe 運算符將組件串成鏈：

from langchain_core.output_parsers import StrOutputParser

# Prompt → Model → Parser = 一條 Chain
chain = prompt | gpt | StrOutputParser()

# 調用
result = chain.invoke({
    "role": "金融分析師",
    "language": "繁體中文",
    "question": "解釋什麼是 DCF 估值"
})
print(result)

④ Retrievers — RAG 文檔檢索

# 從向量數據庫檢索相關文檔
retriever = vectorstore.as_retriever(search_kwargs={"k": 3})
docs = retriever.invoke("什麼是併購？")

⑤ Tools — 外部工具

from langchain.tools import tool

@tool
def search_stock_price(stock_code: str) -> str:
    """查詢港股即時股價"""
    # 你的 API 調用邏輯
    return f"{stock_code} 現價 HK$128.50"

⑥ Agents — 自主決策

from langchain.agents import create_agent

agent = create_agent(
    model="openai:gpt-4o",
    tools=[search_stock_price],
    system_prompt="你是一個港股分析助手"
)

⑦ Memory — 對話記憶

# Agent 自動記住對話歷史
result = agent.invoke({
    "messages": [{"role": "user", "content": "騰訊股價幾多？"}]
})
# 下一次調用時，Agent 記得之前問過騰訊

3. 安裝與環境設置

基礎安裝

# 核心庫
pip install langchain langchain-core

# 模型供應商（按需要安裝）
pip install langchain-openai      # OpenAI / GPT
pip install langchain-anthropic   # Anthropic / Claude
pip install langchain-google-genai # Google / Gemini

# 向量數據庫（RAG 用）
pip install langchain-community chromadb faiss-cpu

# 文檔加載器
pip install unstructured beautifulsoup4

# LangSmith 調試（可選但強烈推薦）
pip install langsmith

環境變量

# .env 文件
OPENAI_API_KEY=sk-xxxxxxxxxxxxxxxx
ANTHROPIC_API_KEY=sk-ant-xxxxxxxx
LANGSMITH_API_KEY=lsv2_pt_xxxxxxxx
LANGSMITH_TRACING=true

# 載入環境變量
from dotenv import load_dotenv
load_dotenv()

驗證安裝

from langchain_openai import ChatOpenAI

model = ChatOpenAI(model="gpt-4o-mini")
response = model.invoke("說一句話證明你係 GPT")
print(response.content)
# 如果正常輸出，安裝成功 ✅

4. 第一個 Chain：LCEL 入門

概念：LCEL 係咩？

LCEL（LangChain Expression Language）係用 | pipe 運算符組合組件嘅語法。類似 Unix pipe：

輸入 → Prompt Template → LLM → Output Parser → 輸出

實戰：翻譯器

from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
from langchain_core.output_parsers import StrOutputParser

# 1. 定義 Prompt
prompt = ChatPromptTemplate.from_template(
    "將以下文字翻譯成{target_language}，只輸出翻譯結果，不要解釋：\n\n{text}"
)

# 2. 初始化模型
model = ChatOpenAI(model="gpt-4o-mini", temperature=0)

# 3. 輸出解析器
parser = StrOutputParser()

# 4. 組合成 Chain
chain = prompt | model | parser

# 5. 調用
result = chain.invoke({
    "target_language": "英文",
    "text": "今日天氣真好，適合出去行下。"
})

print(result)
# 輸出: The weather is really nice today, perfect for going out for a walk.

進階：串聯多條 Chain

# Chain 1: 翻譯
translate_chain = prompt | model | parser

# Chain 2: 摘要
summarize_prompt = ChatPromptTemplate.from_template(
    "用一句話總結以下內容：\n\n{text}"
)
summary_chain = summarize_prompt | model | parser

# 組合：翻譯 → 摘要
full_chain = (
    {"text": translate_chain, "original": lambda x: x["text"]}
    | summarize_prompt
    | model
    | parser
)

Streaming 串流輸出

# 所有 Chain 都支持 streaming
for chunk in chain.stream({"target_language": "日文", "text": "你好世界"}):
    print(chunk, end="", flush=True)

5. RAG：文檔問答系統

RAG（Retrieval-Augmented Generation）係 LangChain 最常見嘅用途。原理：

用戶提問
  ↓
從向量數據庫檢索相關文檔片段
  ↓
將文檔 + 問題一起餵畀 LLM
  ↓
LLM 基於文檔內容生成答案

完整 RAG Pipeline

from langchain_community.document_loaders import TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain_community.vectorstores import FAISS
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough
from langchain_core.output_parsers import StrOutputParser

# ═══════════════════════════════════════
# Step 1: 加載文檔
# ═══════════════════════════════════════
loader = TextLoader("company_handbook.txt")
docs = loader.load()

# ═══════════════════════════════════════
# Step 2: 分割成小塊（chunk）
# ═══════════════════════════════════════
splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,     # 每塊 500 字符
    chunk_overlap=50    # 重疊 50 字符（保持上下文連貫）
)
chunks = splitter.split_documents(docs)

print(f"文檔已分割為 {len(chunks)} 個片段")

# ═══════════════════════════════════════
# Step 3: 向量化並存入數據庫
# ═══════════════════════════════════════
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
vectorstore = FAISS.from_documents(chunks, embeddings)
retriever = vectorstore.as_retriever(search_kwargs={"k": 3})

# ═══════════════════════════════════════
# Step 4: 構建 RAG Chain
# ═══════════════════════════════════════
prompt = ChatPromptTemplate.from_template("""
根據以下參考資料回答問題。如果資料中冇相關信息，請說「資料中未找到相關內容」。

參考資料：
{context}

問題：{question}
""")

def format_docs(docs):
    """將檢索到的文檔格式化為字串"""
    return "\n\n".join(doc.page_content for doc in docs)

rag_chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | prompt
    | ChatOpenAI(model="gpt-4o-mini", temperature=0)
    | StrOutputParser()
)

# ═══════════════════════════════════════
# Step 5: 提問！
# ═══════════════════════════════════════
answer = rag_chain.invoke("公司嘅年假政策係點？")
print(answer)

RAG 進階：支持 PDF / Word / 網頁

# PDF
from langchain_community.document_loaders import PyPDFLoader
loader = PyPDFLoader("contract.pdf")
docs = loader.load()

# Word
from langchain_community.document_loaders import Docx2txtLoader
loader = Docx2txtLoader("report.docx")

# 網頁
from langchain_community.document_loaders import WebBaseLoader
loader = WebBaseLoader("https://example.com/about")
docs = loader.load()

RAG 進階：Agentic RAG

將 RAG 包裝成 Agent 工具，讓 Agent 自己決定幾時檢索：

from langchain.tools import tool
from langchain.agents import create_agent

@tool
def retrieve_context(query: str) -> str:
    """從公司知識庫檢索相關信息來回答問題"""
    docs = vectorstore.similarity_search(query, k=3)
    return "\n\n".join(doc.page_content for doc in docs)

agent = create_agent(
    model="openai:gpt-4o",
    tools=[retrieve_context],
    system_prompt="你是一個企業知識助手。使用 retrieve_context 工具查詢公司文檔。"
)

result = agent.invoke({
    "messages": [{"role": "user", "content": "請假制度係點？"}]
})
# Agent 會自動調用 retrieve_context 工具

6. Agent：自主決策智能體

Agent 係 LLM + 工具 + 決策循環。Agent 自己決定用邊個工具、用幾多次。

最簡 Agent

from langchain.agents import create_agent
from langchain.tools import tool

# 定義工具
@tool
def get_weather(city: str) -> str:
    """查詢城市天氣"""
    return f"{city} 今日晴朗，28°C，濕度 65%"

@tool
def calculate(expression: str) -> str:
    """計算數學表達式"""
    return str(eval(expression))

# 創建 Agent
agent = create_agent(
    model="openai:gpt-4o",
    tools=[get_weather, calculate],
    system_prompt="你是一個有用的助手，可以查天氣和做計算。"
)

# 運行
result = agent.invoke({
    "messages": [{"role": "user", "content": "香港今日幾度？如果將溫度乘以 2 係幾多？"}]
})
# Agent 會：
# 1. 調用 get_weather("香港") → 28°C
# 2. 調用 calculate("28 * 2") → 56
# 3. 回答「香港今日 28°C，乘以 2 係 56」

自定義工具：連接數據庫

@tool
def query_database(sql: str) -> str:
    """執行 SQL 查詢公司數據庫"""
    import sqlite3
    conn = sqlite3.connect("company.db")
    cursor = conn.execute(sql)
    results = cursor.fetchall()
    conn.close()
    return str(results)

# Agent 可以自動生成 SQL 查詢
agent = create_agent(
    model="openai:gpt-4o",
    tools=[query_database],
    system_prompt="你是一個數據分析助手。使用 query_database 工具查詢數據。"
)

result = agent.invoke({
    "messages": [{"role": "user", "content": "上個月銷售額最高的 3 個產品係咩？"}]
})

自定義工具：調用外部 API

import requests

@tool
def search_hkex_news(stock_code: str) -> str:
    """搜索 HKEX 披露易最新公告"""
    url = f"https://www1.hkexnews.hk/search/titlesearch.xhtml?lang=zh"
    # ... API 調用邏輯
    return "最新公告內容..."

@tool
def get_stock_quote(stock_code: str) -> str:
    """獲取港股即時報價"""
    # ... API 調用邏輯
    return f"{stock_code} 現價 HK$128.50，升 1.2%"

7. LangGraph：狀態化工作流

什麼時候需要 LangGraph？

LangChain Agent 係一個簡單循環：LLM → 工具 → LLM → 工具 → 回答。

但實際業務需要更複雜嘅工作流：

需求	LangChain Agent	LangGraph
簡單工具調用循環	✅	✅
條件分支（如果 A 做 X，否則做 Y）	❌	✅
並行執行多個任務	❌	✅
暫停等人工審批	❌	✅
中斷後恢復	❌	✅
持久化狀態	❌	✅

LangGraph 核心概念

┌────────────────────────────────────────┐
│           LangGraph 核心概念             │
├────────────────────────────────────────┤
│                                        │
│  State ──── 共享狀態（所有節點讀寫）      │
│  Node ───── 執行邏輯嘅函數              │
│  Edge ───── 節點之間嘅連接              │
│  Conditional Edge ── 條件路由           │
│  Checkpointer ──── 狀態持久化           │
│                                        │
└────────────────────────────────────────┘

實戰：帶人工審批嘅工作流

from langgraph.graph import StateGraph, START, END
from langgraph.checkpoint.memory import MemorySaver
from typing import TypedDict, Annotated
from langchain_core.messages import HumanMessage, AIMessage
import operator

# 1. 定義狀態
class AgentState(TypedDict):
    messages: Annotated[list, operator.add]
    approved: bool

# 2. 定義節點
def agent_node(state: AgentState):
    """LLM 決定下一步"""
    from langchain_openai import ChatOpenAI
    model = ChatOpenAI(model="gpt-4o")
    response = model.invoke(state["messages"])
    return {"messages": [response]}

def tool_node(state: AgentState):
    """執行工具"""
    # ... 工具執行邏輯
    return {"messages": [HumanMessage(content="工具執行結果：...")]}

def human_approval_node(state: AgentState):
    """等待人工審批"""
    # 實際應用中會暫停等用戶確認
    return {"approved": True}

# 3. 定義路由邏輯
def should_continue(state: AgentState):
    last_message = state["messages"][-1]
    if hasattr(last_message, "tool_calls") and last_message.tool_calls:
        return "human_approval"
    return END

# 4. 構建圖
workflow = StateGraph(AgentState)

workflow.add_node("agent", agent_node)
workflow.add_node("tools", tool_node)
workflow.add_node("human_approval", human_approval_node)

workflow.add_edge(START, "agent")
workflow.add_conditional_edges("agent", should_continue, {
    "human_approval": "human_approval",
    END: END
})
workflow.add_edge("human_approval", "tools")
workflow.add_edge("tools", "agent")

# 5. 編譯（加入 Checkpointer）
checkpointer = MemorySaver()
app = workflow.compile(
    checkpointer=checkpointer,
    interrupt_before=["human_approval"]  # 在審批前暫停
)

# 6. 運行
config = {"configurable": {"thread_id": "user-123"}}
result = app.invoke(
    {"messages": [HumanMessage(content="幫我查詢騰訊最新股價")]},
    config=config
)

LangGraph 五大工作流模式

模式	說明	適用場景
Prompt Chaining	順序執行，上一步輸出做下一步輸入	翻譯→摘要→發送
Parallelization	並行執行多個節點，合併結果	同時搜索多個數據源
Routing	根據輸入路由到不同處理路徑	客戶投訴 vs 產品查詢
Orchestrator-Worker	主 Agent 分配任務畀子 Agent	複雜研究任務
Evaluator-Optimizer	生成→評估→優化循環	代碼生成+測試

Checkpointer：狀態持久化

# 開發階段：記憶體存儲
from langgraph.checkpoint.memory import MemorySaver
checkpointer = MemorySaver()

# 測試階段：SQLite
from langgraph.checkpoint.sqlite import SqliteSaver
checkpointer = SqliteSaver.from_conn_string("checkpoints.db")

# 生產階段：PostgreSQL
from langgraph.checkpoint.postgres import PostgresSaver
checkpointer = PostgresSaver.from_conn_string("postgresql://...")

8. LangSmith：調試與監控

為什麼需要 LangSmith？

當你嘅 Agent 做咗 10 步先得出答案，你點知邊步出錯？LangSmith 幫你：

Trace 追蹤：每一步嘅輸入/輸出/延遲
Debug 調試：視覺化 Agent 決策過程
Evaluate 評估：批量測試 Agent 質量
Monitor 監控：生產環境實時告警

設置 LangSmith

# 1. 註冊 https://smith.langchain.com
# 2. 設置環境變量
export LANGSMITH_TRACING=true
export LANGSMITH_API_KEY=lsv2_pt_xxxxxxxx

# 代碼完全唔使改！LangSmith 自動追蹤
from langchain_openai import ChatOpenAI

model = ChatOpenAI(model="gpt-4o")
response = model.invoke("你好")
# 這次調用已經自動記錄到 LangSmith ✅

LangSmith 界面功能

Trace 視圖：
├── Agent 調用（總耗時 3.2s）
│   ├── LLM Call #1（選擇工具）── 0.8s
│   ├── Tool: search_stock（API 調用）── 1.5s
│   ├── LLM Call #2（處理結果）── 0.6s
│   └── Tool: calculate（計算）── 0.3s
└── Final Answer

9. 生態系統全景

LangChain 家族產品

┌─────────────────────────────────────────────────────────────┐
│                    LangChain 生態系統                         │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────┐ │
│  │  LangChain   │  │  LangGraph  │  │   Deep Agents SDK   │ │
│  │  (高層框架)   │  │  (低層編排)  │  │   (全功能 Agent)    │ │
│  │             │  │             │  │                     │ │
│  │ create_agent│  │ StateGraph  │  │ 內建規劃+子Agent    │ │
│  │ LCEL Chain  │  │ Checkpoint  │  │ +文件系統+記憶      │ │
│  │ RAG 組件    │  │ Human-in-   │  │                     │ │
│  │             │  │ the-loop    │  │                     │ │
│  └─────────────┘  └─────────────┘  └─────────────────────┘ │
│         │                 │                    │            │
│         └─────────────────┼────────────────────┘            │
│                           │                                 │
│                    ┌──────┴──────┐                          │
│                    │  LangSmith  │                          │
│                    │  (調試監控)  │                          │
│                    │             │                          │
│                    │ Trace       │                          │
│                    │ Evaluate    │                          │
│                    │ Monitor     │                          │
│                    └─────────────┘                          │
│                                                             │
│                    ┌─────────────┐                          │
│                    │  LangServe  │                          │
│                    │  (API 部署)  │                          │
│                    └─────────────┘                          │
│                                                             │
└─────────────────────────────────────────────────────────────┘

選擇指南

你的需求	推薦產品
快速構建簡單 Agent	LangChain `create_agent`
需要 RAG 文檔問答	LangChain RAG 組件
複雜工作流（分支/循環/並行）	LangGraph
需要人工審批流程	LangGraph + Checkpointer
全功能 Agent（規劃+子Agent）	Deep Agents SDK
調試同監控	LangSmith
部署為 REST API	LangServe

10. 生產部署最佳實踐

架構建議

┌─────────────────────────────────────────────┐
│              生產環境架構                      │
├─────────────────────────────────────────────┤
│                                             │
│  Frontend (React/Next.js)                   │
│       │                                     │
│       ▼                                     │
│  LangServe (FastAPI)                        │
│       │                                     │
│       ▼                                     │
│  LangGraph Agent                            │
│       │                                     │
│       ├── LLM (GPT-4o / Claude)            │
│       ├── Vector DB (Pinecone / Weaviate)   │
│       ├── Checkpointer (PostgreSQL)         │
│       └── Tools (APIs / DBs)               │
│                                             │
│  LangSmith (監控 + 告警)                     │
│                                             │
└─────────────────────────────────────────────┘

性能優化清單

優化項	做法	效果
模型選擇	簡單任務用 gpt-4o-mini，複雜用 gpt-4o	成本降 90%
向量檢索	chunk_size=500, k=3-5	平衡精度同速度
Streaming	用 `.stream()` 而非 `.invoke()`	用戶體驗大幅提升
快取	相同問題快取答案	減少 LLM 調用
並行	多個獨立檢索並行執行	延遲降 50%
重試	LLM 調用加重試邏輯	提高穩定性

安全清單

# ✅ 永遠唔好將 API Key 硬編碼
# ✅ 用環境變量或 secret manager
# ✅ 限制 Agent 可用嘅工具範圍
# ✅ 對用戶輸入做 sanitize
# ✅ 設置 token 使用上限
# ✅ 記錄所有 Agent 操作（LangSmith）
# ✅ 對敏感操作加人工審批

# ❌ 唔好畀 Agent 直接執行任意 SQL
# ❌ 唔好畀 Agent 訪問唔需要嘅工具
# ❌ 唔好信任 LLM 輸出（要做驗證）

成本估算

場景	模型	每次調用成本	每月成本（1000次/日）
簡單問答	gpt-4o-mini	~$0.001	~$30
RAG 問答	gpt-4o	~$0.01	~$300
複雜 Agent（5步）	gpt-4o	~$0.05	~$1,500
混合策略	mini + 4o	~$0.005	~$150

💡 建議：80% 請求用 mini 模型，只有複雜任務先路由到 gpt-4o。

11. LangChain vs 競品對比

特性	LangChain	LlamaIndex	CrewAI	AutoGen	Pydantic AI
定位	通用 LLM 框架	數據檢索	多 Agent	多 Agent 對話	類型安全
RAG	✅ 強	✅ 最強	⚠️ 一般	⚠️ 一般	⚠️ 基本
Agent	✅ 強	⚠️ 一般	✅ 強	✅ 強	⚠️ 基本
工作流編排	✅ LangGraph	❌	⚠️ 線性	⚠️ 對話式	❌
模型支持	80+	50+	30+	20+	10+
學習曲線	中	中	低	中	低
生產就緒	✅	✅	⚠️	⚠️	⚠️
社區活躍度	⭐⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐	⭐⭐⭐	⭐⭐

選擇建議

通用 LLM 應用 → LangChain
純 RAG / 知識庫 → LlamaIndex（更專注）
多 Agent 協作 → CrewAI（最簡單）或 LangGraph（最靈活）
需要類型安全 → Pydantic AI
快速原型 → CrewAI 或 LangChain

12. 常見問題 FAQ

Q: LangChain 係咪太重了？簡單應用唔想用？

A: 如果只係簡單調一次 API，直接用官方 SDK 就夠。LangChain 嘅價值在於：多步驟 Chain、RAG、Agent、模型切換。如果你需要呢啲，LangChain 幫你慳大量開發時間。

Q: LCEL 同舊版 Chain 有咩分別？

A: 舊版 LLMChain / SequentialChain 已 deprecated。LCEL 用 | pipe 語法，更直觀、支持 streaming、async、batch。新項目應該只用 LCEL。

Q: LangChain 支持本地模型嗎？

A: 支持。用 langchain-ollama 接入 Ollama 本地模型：

from langchain_ollama import ChatOllama
model = ChatOllama(model="llama3")

Q: 點樣處理 Agent 幻覺？

A: 三個策略：

RAG：強制 Agent 基於檢索文檔回答
Guardrails：用 middleware 檢查輸出
LangSmith：監控異常輸出

Q: LangChain vs 直接用 OpenAI API？

A: 如果你只需要單輪問答，直接用 API。如果你需要 RAG / Agent / 多步驟 / 模型切換 / 調試追蹤，LangChain 幫你慳幾百行代碼。

總結：學習路線圖

Week 1: 基礎
├── 安裝 LangChain
├── 寫第一個 LCEL Chain
└── 理解 Prompt Template + Output Parser

Week 2: RAG
├── 文檔加載 + 分割
├── 向量數據庫（FAISS / Chroma）
└── 構建 RAG Chain

Week 3: Agent
├── 定義自定義 Tool
├── create_agent 構建 Agent
└── 接入 LangSmith 調試

Week 4: 進階
├── LangGraph 工作流
├── Checkpointer 持久化
└── 生產部署

參考資源

本文寫於 2026 年 6 月，基於 LangChain v1.0+ / LangGraph v1.2.0。框架更新快，建議定期查閱官方文檔。