---
# System prepended metadata

title: "\U0001F916 LLM 多店客服系統：從零開始操作流程（實務版）"

---

好的，我會用繁體中文回覆，並以清晰、詳盡的方式檢視你的 LLM 多店客服系統操作流程，找出潛在錯誤、補充遺漏步驟，並整理成一份更完整、適合新手的實務文件。我也會提供更詳細的解釋，確保每一步驟的邏輯清楚，並確認是否需要圖表或資料流說明。
x ai版本
---

## 檢視與修正你的操作流程

你的指南已經涵蓋了建置多租戶繁體中文客服 LLM 系統的核心步驟，結構清晰，適合實務應用。但有些地方可以優化、修正或補充，以提升正確性、完整性與新手友善度。以下是逐段分析、問題指出、改進建議，以及最終整理的文件。

---

### **一、基礎環境建置（原始第一部分）**

**原始內容：**
- 在 Windows 11 上啟用 WSL2，安裝 Ubuntu 22.04。
- 安裝 Conda，建立 Python 3.10 虛擬環境。

**檢視與分析：**
- **正確性**：WSL2 安裝指令（`wsl --install -d Ubuntu-22.04`）正確，Conda 安裝與虛擬環境設置也是標準做法。
- **潛在問題與遺漏**：
  1. **WSL2 GPU 支援**：你提到使用 RTX 5090，但未說明如何在 WSL2 中啟用 NVIDIA GPU 支援（CUDA）。這對 LLM 訓練與推理至關重要，缺少這步驟可能導致模型無法使用 GPU。
  2. **系統更新**：Ubuntu 安裝後應更新套件清單（`apt update && apt upgrade`），以確保環境穩定。
  3. **Conda 初始化**：Conda 安裝後需初始化（如 `conda init`），否則新終端可能無法自動識別 Conda。
  4. **新手指引不足**：未說明如何檢查 WSL2 是否正確安裝，或如何確認虛擬環境是否啟用。

**改進建議**：
- 補充 WSL2 的 NVIDIA GPU 驅動與 CUDA 設置步驟。
- 加入 Ubuntu 系統更新與 Conda 初始化指令。
- 提供檢查指令（如 `nvidia-smi`、`conda info`），讓新手確認環境正確。

---

### **二、安裝依賴套件與模型準備（原始第二部分）**

**原始內容：**
- 安裝 `torch`、`transformers`、`faiss-cpu` 等套件。
- 下載 LLaMA-3-8B-Instruct 模型，啟用 int8 模式。

**檢視與分析：**
- **正確性**：列出的套件適用於 RAG 與 API 開發，int8 模式有助於降低記憶體需求。
- **潛在問題與遺漏**：
  1. **GPU 套件**：安裝 `torch` 未指定 CUDA 版本，可能導致 CPU-only 模式，無法利用 RTX 5090。應明確安裝 `torch` 的 CUDA 版本。
  2. **模型權限**：LLaMA-3 是 Meta AI 模型，需申請授權，未提及如何取得模型權限。
  3. **faiss-cpu vs faiss-gpu**：使用 `faiss-cpu` 限制向量檢索性能，RTX 5090 可支援 `faiss-gpu`，提升效率。
  4. **儲存需求**：未提醒模型下載需要大量儲存空間（LLaMA-3-8B int8 約 8-10GB）。
  5. **新手指引**：未提供如何檢查套件安裝或模型載入成功的指令。

**改進建議**：
- 明確安裝 CUDA 版 `torch` 和 `faiss-gpu`。
- 補充申請 LLaMA-3 模型權限的步驟。
- 提醒儲存空間需求，並提供檢查指令（如 `pip list`、`torch.cuda.is_available()`）。

---

### **三、撰寫 RAG 多店 API 架構（原始第三部分）**

**原始內容：**
- 介紹 RAG 原理，設計多店資料庫結構（`stores/store_001/faq.json` 等）。
- 提供 FastAPI 主程式架構。

**檢視與分析：**
- **正確性**：RAG 說明正確，資料庫結構合理，FastAPI 架構符合多租戶需求。
- **潛在問題與遺漏**：
  1. **向量庫生成**：未說明如何將 `faq.json` 轉為 `vector.index`（向量資料庫）。
  2. **FastAPI 程式碼不完整**：僅提供偽碼，未包含具體實現（如向量化、模型推理邏輯）。
  3. **閾值邏輯**：未定義「分數 > 閾值」的具體閾值或計算方式，可能讓新手困惑。
  4. **錯誤處理**：未考慮店家 ID 無效或資料庫缺失的異常處理。
  5. **效能考量**：未提到向量檢索的索引類型（如 HNSW、IVF），可能影響查詢速度。

**改進建議**：
- 補充生成向量資料庫的程式碼（使用 `sentence-transformers` 和 `faiss`）。
- 提供完整的 FastAPI 程式碼，包含向量化、檢索、模型推理。
- 說明閾值設定與異常處理邏輯。
- 介紹 FAISS 索引選項（如 HNSW），提升檢索效率。

---

### **四、模型微調（LoRA）（原始第四部分）**

**原始內容：**
- 使用 PEFT 進行 LoRA 微調，提供訓練資料格式與指令。
- 合併微調參數為 fp16 模型。

**檢視與分析：**
- **正確性**：LoRA 微調流程合理，資料格式清晰，`accelerate` 用法正確。
- **潛在問題與遺漏**：
  1. **訓練資料準備**：未說明如何收集或清洗訓練資料（`my_qa.jsonl`），新手可能不知從何開始。
  2. **訓練超參數**：未提供 `train_lora.py` 的具體內容（如學習率、epoch），可能導致訓練效果不佳。
  3. **硬體需求**：LoRA 微調仍需大量 GPU 記憶體（RTX 5090 可應付，但未提醒記憶體分配）。
  4. **合併程式碼**：`merge_adapter` 不是 PEFT 的標準函數，應使用 `peft_model.merge_and_unload()`。
  5. **驗證步驟**：未提供如何測試微調後模型效果的方法。

**改進建議**：
- 補充訓練資料準備指南（如如何從 FAQ 轉為 JSONL）。
- 提供 `train_lora.py` 範例，包含超參數設置。
- 修正合併程式碼，使用正確的 PEFT 方法。
- 加入模型驗證步驟（如測試集評估）。

---

### **五、部署為 GGUF 格式（原始第五部分）**

**原始內容：**
- 將模型轉為 int4 GGUF 格式，使用 `llama.cpp` 或 Ollama 測試。

**檢視與分析：**
- **正確性**：GGUF 是高效部署格式，`llama.cpp` 和 Ollama 是標準工具。
- **潛在問題與遺漏**：
  1. **轉換工具**：`convert.py` 不是標準工具，應使用 `llama.cpp` 的 `convert.py` 或 Hugging Face 的轉換腳本。
  2. **環境準備**：未說明如何安裝 `llama.cpp` 或 Ollama。
  3. **量化細節**：未提供 int4 量化的具體參數（如 Q4_K_M），可能影響模型質量。
  4. **測試範例不足**：僅提供簡單測試指令，未說明如何整合到 API。

**改進建議**：
- 明確使用 `llama.cpp` 的 `convert.py`，並提供安裝步驟。
- 補充 Ollama 安裝與配置指南。
- 提供量化參數建議（如 Q4_K_M）。
- 說明如何將 GGUF 模型整合到 FastAPI。

---

### **六、多租戶部署 + Docker 化（原始第六部分）**

**原始內容：**
- 介紹 Docker 優勢，概要說明容器化部署。

**檢視與分析：**
- **正確性**：Docker 化是合理建議，概要描述符合多租戶需求。
- **潛在問題與遺漏**：
  1. **Dockerfile 缺失**：未提供具體的 Dockerfile 或 docker-compose 範例。
  2. **Nginx 配置**：僅提到用 Nginx 代理，未提供配置範例。
  3. **資源管理**：未討論多容器間的 GPU 資源分配（RTX 5090 可能無法同時支援多個模型）。
  4. **部署細節**：未說明如何啟動容器或測試部署。

**改進建議**：
- 提供 Dockerfile 與 docker-compose.yml 範例。
- 補充 Nginx 配置文件範例。
- 討論 GPU 資源分配策略（如 NVIDIA Docker）。
- 提供部署測試指令。

---

### **七、後續擴充功能（原始第七部分）**

**原始內容：**
- 建議對接 LINE webhook、資料庫查詢、上下文記憶、多模態處理。

**檢視與分析：**
- **正確性**：建議的功能實用且符合客服場景。
- **潛在問題與遺漏**：
  1. **實現細節不足**：未提供如何實作 LINE webhook 或上下文記憶的指引。
  2. **多模態限制**：LLaMA-3 不支援圖片或語音，需額外模型（如 CLIP 或 Whisper）。
  3. **優先級建議**：未說明哪些功能對客服系統更重要（如 LINE webhook 優先於多模態）。

**改進建議**：
- 提供 LINE webhook 整合範例程式碼。
- 說明上下文記憶的實現方式（如 Redis 快取）。
- 澄清多模態需額外模型，並建議優先實現關鍵功能。

---

## 整理後的完整操作流程文件

以下是經過修正、補充與優化的完整操作流程，針對新手提供詳細解釋與實務指引。

---

# 🤖 LLM 多店客服系統：從零開始操作流程（實務版）

本指南詳細說明如何在 Windows 11 + WSL2 環境下，使用 NVIDIA RTX 5090 建置並部署多租戶繁體中文客服 LLM 系統。系統支援多店獨立知識庫，透過 RAG 技術提供精準回應，並使用 LoRA 微調與 GGUF 格式優化部署。適合新手學習與實務應用。

---

## 🪜 一、基礎環境建置

### **為什麼重要？**
LLM 開發通常在 Linux 環境進行。透過 WSL2，我們在 Windows 11 上模擬 Ubuntu 環境，結合 RTX 5090 的 GPU 算力，打造高效開發平台。

### **步驟**

1. **啟用 WSL2 與安裝 Ubuntu 22.04**
   - 打開 PowerShell（以管理員身份）：
     ```bash
     wsl --install -d Ubuntu-22.04
     ```
   - 安裝後重啟電腦，設置 Ubuntu 的用戶名與密碼。
   - 檢查 WSL2 是否正確安裝：
     ```bash
     wsl --version
     ```

2. **設置 NVIDIA GPU 支援**
   - 在 Windows 11 安裝最新 NVIDIA 驅動（Game Ready 或 Studio 版，支援 CUDA）。
   - 在 Ubuntu 終端檢查 GPU：
     ```bash
     nvidia-smi
     ```
   - 若無輸出，參考 [NVIDIA WSL2 官方指南](https://docs.nvidia.com/cuda/wsl-user-guide/index.html) 安裝 CUDA Toolkit。

3. **更新 Ubuntu 系統**
   ```bash
   sudo apt update && sudo apt upgrade -y
   sudo apt install build-essential -y
   ```

4. **安裝 Miniconda**
   ```bash
   wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh
   bash Miniconda3-latest-Linux-x86_64.sh
   ```
   - 按提示安裝，初始化 Conda：
     ```bash
     ~/miniconda3/bin/conda init
     ```
   - 關閉終端後重開，確認 Conda 可用：
     ```bash
     conda info
     ```

5. **建立 Python 虛擬環境**
   ```bash
   conda create -n llm python=3.10 -y
   conda activate llm
   ```

**檢查點**：
- 確認 GPU 可用：`python -c "import torch; print(torch.cuda.is_available())"`（應輸出 `True`）。
- 確認環境啟用：`which python`（應指向 Conda 環境）。

---

## 🔧 二、安裝依賴套件與模型準備

### **為什麼需要？**
這些套件支援 LLM 推理、向量檢索與 API 服務。模型下載與 int8 模式降低記憶體需求，適合 RTX 5090。

### **步驟**

1. **安裝 CUDA 版 PyTorch**
   ```bash
   pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121
   ```
   - 確認 CUDA 支援：
     ```bash
     python -c "import torch; print(torch.version.cuda)"
     ```

2. **安裝其他依賴套件**
   ```bash
   pip install transformers sentence-transformers faiss-gpu fastapi uvicorn peft bitsandbytes accelerate
   ```

3. **申請與下載 LLaMA-3-8B-Instruct**
   - 前往 [Meta AI 申請頁面](https://llama.meta.ai/) 申請模型權限。
   - 使用 Hugging Face CLI 登入：
     ```bash
     pip install huggingface_hub
     huggingface-cli login
     ```
   - 下載模型（約需 8-10GB 儲存空間）：
     ```python
     from transformers import AutoModelForCausalLM, AutoTokenizer
     model = AutoModelForCausalLM.from_pretrained(
         "meta-llama/Llama-3-8B-Instruct",
         device_map="auto",
         load_in_8bit=True
     )
     tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3-8B-Instruct")
     ```

**檢查點**：
- 確認套件安裝：`pip list | grep torch`。
- 確認模型載入：運行 `model.device`（應顯示 `cuda:0`）。

---

## 🧪 三、撰寫 RAG 多店 API 架構

### **什麼是 RAG？**
RAG（Retrieval Augmented Generation）結合向量檢索與生成模型，讓 LLM 參考店家知識庫回答問題，解決記憶不準的問題。

### **資料庫結構**
```
/stores/
  ├── store_001/
  │   ├── faq.json           # 常見問答
  │   └── vector.index       # FAISS 向量索引
  └── store_002/
      ├── faq.json
      └── vector.index
```

### **步驟**

1. **準備 FAQ 資料**
   - 範例 `faq.json`：
     ```json
     [
         {"question": "營業時間是？", "answer": "週一至週五 9:00-18:00"},
         {"question": "有沒有預約？", "answer": "請透過 LINE 預約"}
     ]
     ```

2. **生成向量資料庫**
   ```python
   from sentence_transformers import SentenceTransformer
   import faiss
   import json

   # 載入向量化模型
   embedder = SentenceTransformer("all-MiniLM-L6-v2")
   faq_path = "stores/store_001/faq.json"
   with open(faq_path, "r", encoding="utf-8") as f:
       faqs = json.load(f)

   # 向量化問題
   questions = [faq["question"] for faq in faqs]
   embeddings = embedder.encode(questions, convert_to_numpy=True)

   # 建立 FAISS 索引
   dimension = embeddings.shape[1]
   index = faiss.IndexFlatL2(dimension)  # L2 距離
   index.add(embeddings)
   faiss.write_index(index, "stores/store_001/vector.index")
   ```

3. **撰寫 FastAPI 程式**
   ```python
   from fastapi import FastAPI, HTTPException
   from pydantic import BaseModel
   from sentence_transformers import SentenceTransformer
   import faiss
   import numpy as np
   from transformers import AutoModelForCausalLM, AutoTokenizer

   app = FastAPI()
   embedder = SentenceTransformer("all-MiniLM-L6-v2")
   model = AutoModelForCausalLM.from_pretrained(
       "meta-llama/Llama-3-8B-Instruct", device_map="auto", load_in_8bit=True
   )
   tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3-8B-Instruct")

   class ChatRequest(BaseModel):
       user_input: str

   @app.post("/chat/{store_id}")
   async def chat(store_id: str, request: ChatRequest):
       # 載入店家向量索引
       index_path = f"stores/{store_id}/vector.index"
       faq_path = f"stores/{store_id}/faq.json"
       try:
           index = faiss.read_index(index_path)
           with open(faq_path, "r", encoding="utf-8") as f:
               faqs = json.load(f)
       except FileNotFoundError:
           raise HTTPException(status_code=404, detail="店家不存在")

       # 向量化用戶輸入
       user_embedding = embedder.encode([request.user_input], convert_to_numpy=True)
       distances, indices = index.search(user_embedding, k=1)
       score = distances[0][0]

       # 閾值判斷
       if score < 0.5:  # 假設 0.5 為閾值（可調）
           question = faqs[indices[0][0]]["question"]
           answer = faqs[indices[0][0]]["answer"]
           prompt = f"問題：{question}\n回答：{answer}\n用戶輸入：{request.user_input}\n請根據以上資訊回答："
           inputs = tokenizer(prompt, return_tensors="pt").to("cuda")
           outputs = model.generate(**inputs, max_length=200)
           response = tokenizer.decode(outputs[0], skip_special_tokens=True)
           return {"response": response}
       else:
           return {"response": "請聯繫客服"}

   if __name__ == "__main__":
       import uvicorn
       uvicorn.run(app, host="0.0.0.0", port=8000)
   ```

**檢查點**：
- 測試向量索引：`index.ntotal` 應等於 FAQ 數量。
- 啟動 API：`uvicorn main:app --host 0.0.0.0 --port 8000`，用 curl 測試：
  ```bash
  curl -X POST "http://localhost:8000/chat/store_001" -H "Content-Type: application/json" -d '{"user_input": "營業時間？"}'
  ```

---

## 🧠 四、模型微調（LoRA）

### **為什麼微調？**
LLaMA-3 不了解店家特定資訊（如營業時間）。LoRA 微調以少量資料讓模型適應客服場景。

### **步驟**

1. **準備訓練資料**
   - 範例 `my_qa.jsonl`：
     ```json
     {"instruction": "請問5月8號晚上有位置嗎？", "output": "5月8日晚上還有 3 位座位可預訂喔！"}
     {"instruction": "營業時間是什麼？", "output": "每日 9:00-18:00，週末休息。"}
     ```
   - 建議：收集至少 100 組問答，清洗資料確保無重複或錯誤。

2. **撰寫訓練腳本（`train_lora.py`）**
   ```python
   from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments, Trainer
   from peft import LoraConfig, get_peft_model
   import jsonlines

   model_name = "meta-llama/Llama-3-8B-Instruct"
   model = AutoModelForCausalLM.from_pretrained(model_name, device_map="auto", load_in_8bit=True)
   tokenizer = AutoTokenizer.from_pretrained(model_name)

   # 載入資料
   dataset = []
   with jsonlines.open("my_qa.jsonl") as reader:
       for obj in reader:
           dataset.append({"input": obj["instruction"], "output": obj["output"]})

   # 資料處理
   def preprocess(example):
       prompt = f"問題：{example['input']}\n回答：{example['output']}"
       return tokenizer(prompt, return_tensors="pt", padding=True, truncation=True)

   tokenized_dataset = [preprocess(ex) for ex in dataset]

   # 配置 LoRA
   lora_config = LoraConfig(
       r=8,
       lora_alpha=16,
       target_modules=["q_proj", "v_proj"],
       lora_dropout=0.1,
       bias="none"
   )
   model = get_peft_model(model, lora_config)

   # 訓練參數
   training_args = TrainingArguments(
       output_dir="lora_out",
       per_device_train_batch_size=2,
       num_train_epochs=3,
       learning_rate=2e-4,
       save_strategy="epoch"
   )

   trainer = Trainer(
       model=model,
       args=training_args,
       train_dataset=tokenized_dataset
   )
   trainer.train()
   model.save_pretrained("lora_out")
   ```

3. **執行訓練**
   ```bash
   accelerate launch train_lora.py
   ```

4. **合併 LoRA 參數**
   ```python
   from peft import PeftModel
   base_model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3-8B-Instruct")
   peft_model = PeftModel.from_pretrained(base_model, "lora_out")
   merged_model = peft_model.merge_and_unload()
   merged_model.save_pretrained("merged_model")
   tokenizer.save_pretrained("merged_model")
   ```

5. **驗證模型**
   ```python
   from transformers import pipeline
   generator = pipeline("text-generation", model="merged_model", tokenizer="merged_model")
   print(generator("問題：營業時間是什麼？", max_length=100))
   ```

**檢查點**：
- 確認訓練損失下降：檢查 `lora_out/checkpoint-*/trainer_state.json`。
- 測試微調效果：模型應正確回答 FAQ 問題。

---

## 📦 五、部署為 GGUF 格式

### **為什麼壓縮？**
GGUF（int4）格式降低記憶體需求，加快推理速度，適合多租戶部署。

### **步驟**

1. **安裝 llama.cpp**
   ```bash
   git clone https://github.com/ggerganov/llama.cpp
   cd llama.cpp
   make
   pip install -r requirements.txt
   ```

2. **轉換模型為 GGUF**
   ```bash
   python convert.py merged_model --outfile gguf_model.gguf --outtype q4_k_m
   ```

3. **測試 GGUF 模型**
   ```bash
   ./main -m gguf_model.gguf -p "今天幾點開店？"
   ```

4. **使用 Ollama（可選）**
   - 安裝 Ollama：
     ```bash
     curl -fsSL https://ollama.com/install.sh | sh
     ```
   - 導入 GGUF 模型：
     ```bash
     ollama create taide-lx8b-qa -f <(echo "FROM ./gguf_model.gguf")
     ollama run taide-lx8b-qa
     ```

5. **整合到 FastAPI**
   - 使用 `llama-cpp-python`：
     ```bash
     pip install llama-cpp-python
     ```
   - 修改 FastAPI 程式，替換 `transformers` 模型：
     ```python
     from llama_cpp import Llama
     llm = Llama(model_path="gguf_model.gguf")
     ```

**檢查點**：
- 確認 GGUF 模型大小（約 4-5GB）。
- 測試推理速度：應比原始模型快。

---

## 🚀 六、多租戶部署 + Docker 化

### **為什麼用 Docker？**
Docker 封裝環境，簡化部署，支援多實例運行。

### **步驟**

1. **撰寫 Dockerfile**
   ```dockerfile
   FROM nvidia/cuda:12.1.0-base-ubuntu22.04
   RUN apt-get update && apt-get install -y python3 pip
   COPY . /app
   WORKDIR /app
   RUN pip install -r requirements.txt
   CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]
   ```

2. **撰寫 docker-compose.yml**
   ```yaml
   version: "3.8"
   services:
     store_001:
       build: .
       ports:
         - "8001:8000"
       volumes:
         - ./stores/store_001:/app/stores/store_001
       deploy:
         resources:
           reservations:
             devices:
               - driver: nvidia
                 count: 1
                 capabilities: [gpu]
     store_002:
       build: .
       ports:
         - "8002:8000"
       volumes:
         - ./stores/store_002:/app/stores/store_002
       deploy:
         resources:
           reservations:
             devices:
               - driver: nvidia
                 count: 1
                 capabilities: [gpu]
   ```

3. **配置 Nginx**
   ```nginx
   server {
       listen 80;
       location /chat/store_001 {
           proxy_pass http://localhost:8001;
       }
       location /chat/store_002 {
           proxy_pass http://localhost:8002;
       }
   }
   ```

4. **啟動部署**
   ```bash
   docker-compose up --build
   ```

**檢查點**：
- 確認容器運行：`docker ps`。
- 測試 API：`curl http://localhost/chat/store_001`。

---

## 🧩 七、後續擴充功能

1. **對接 LINE Webhook**
   - 使用 `line-bot-sdk`：
     ```python
     from linebot import LineBotApi, WebhookHandler
     line_bot_api = LineBotApi("YOUR_CHANNEL_ACCESS_TOKEN")
     handler = WebhookHandler("YOUR_CHANNEL_SECRET")
     ```

2. **上下文記憶**
   - 使用 Redis 儲存對話歷史：
     ```bash
     docker run -d --name redis -p 6379:6379 redis
     ```

3. **資料庫查詢**
   - 整合 MySQL 查詢訂位狀態。

4. **多模態處理**
   - 圖片：使用 CLIP 模型。
   - 語音：使用 Whisper 模型。

**優先建議**：先實現 LINE webhook 與上下文記憶，確保核心客服功能穩定。

---

## 📘 資料流與圖表

若需資料流圖，我建議以下結構：
- **用戶** → LINE Webhook → Nginx（路由 store_id）→ FastAPI（店家容器）→ RAG（向量檢索 + LLM 推理）→ 回應。
- 可使用 Mermaid 繪製：
  ```mermaid
  graph TD
      A[用戶] --> B[LINE Webhook]
      B --> C[Nginx]
      C -->|store_001| D[FastAPI 容器 1]
      C -->|store_002| E[FastAPI 容器 2]
      D --> F[FAISS 向量庫]
      D --> G[GGUF 模型]
      F --> G
      G --> D --> C --> B --> A
  ```

請確認是否需要生成圖表或進一步細化某部分！

---

## 總結

- **修正與補充**：已修正 GPU 支援、模型轉換、FastAPI 程式碼等問題，補充向量庫生成、Docker 配置等步驟。
- **新手友善**：每步驟新增檢查點與詳細解釋，確保可操作。
- **遺漏步驟**：已補充 GPU 設置、向量庫生成、訓練資料準備、Docker 配置等。
- **後續建議**：優先實現 LINE 整合，考慮 Redis 上下文記憶。

若有特定部分需深入說明（如某段程式碼或部署細節），請告訴我！