視覺語言模型彙整

Nvidia DGX Spark 安裝 Holo-3.1

by Rain Chu | 6 月 13, 2026 | Agent, AI, GGUF, Hermes, OpenClaw

原本我在 Nvidia 都搭配 vLLM 啟動，這條路理論上可以發揮 NVFP4 權重的優勢，但在 DGX Spark 的 GB10 平台上，實際遇到 CUDA Kernel 與 Marlin repack 相容性問題。

最後我改採：

Hcompany/Holo-3.1-35B-A3B-GGUF

搭配 llama.cpp CUDA Build，成功啟動模型並提供 API 服務。

這篇文章記錄完整流程，也保留幾個重要的踩坑經驗。

環境

本次環境如下：

硬體：NVIDIA DGX SparkGPU：NVIDIA GB10系統：Ubuntu Linux模型儲存位置：/mnt/ai-models推論框架：llama.cpp模型格式：GGUF量化版本：Q4_K_M

DGX Spark 使用統一記憶體架構，因此 CPU、GPU 與系統服務會共用記憶體。這點對 vLLM 與 llama.cpp 都很重要。

為什麼放棄 NVFP4 + vLLM

一開始使用 vLLM 載入：

Hcompany/Holo-3.1-35B-A3B-NVFP4

後，權重其實已經完整載入：

Loading safetensors checkpoint shards: 100% Completed | 3/3Loading weights took 142.78 seconds

但載入完成後，仍然在 Marlin FP4 重新整理階段失敗：

NotImplementedError:Could not run '_C::gptq_marlin_repack'with arguments from the 'CUDA' backend

這代表模型檔案本身沒有問題，真正卡住的是 vLLM 的 CUDA Extension 在 DGX Spark GB10 上沒有完整提供所需的 Marlin CUDA Operator。

如果只是想先把 Holo 3.1 跑起來，不一定要繼續投入時間處理 NVFP4 相容性。改用 GGUF + llama.cpp 是更快、更穩定的選擇。

移除 NVFP4 模型快取

vLLM 下載的 Hugging Face 模型通常會放在：

/mnt/ai-models/huggingface/hub/

先確認路徑：

find /mnt/ai-models/huggingface \  -maxdepth 3 \  -type d \  -name 'models--Hcompany--Holo-3.1-35B-A3B-NVFP4' \  -print

確認容量：

du -sh \  /mnt/ai-models/huggingface/hub/models--Hcompany--Holo-3.1-35B-A3B-NVFP4

確認無誤後刪除：

rm -rf \  /mnt/ai-models/huggingface/hub/models--Hcompany--Holo-3.1-35B-A3B-NVFP4

安裝 llama.cpp

1. 安裝編譯工具

sudo apt update
sudo apt install -y \  git \  build-essential \  cmake \  ninja-build \  libcurl4-openssl-dev \  pkg-config

2. 確認 CUDA Toolkit

export CUDA_HOME=/usr/local/cudaexport PATH="${CUDA_HOME}/bin:${PATH}"
export LD_LIBRARY_PATH="${CUDA_HOME}/lib64:${LD_LIBRARY_PATH:-}"
nvcc --versionnvidia-smi

nvcc --version 必須能正常回傳 CUDA 版本。

3. Clone llama.cpp

mkdir -p /mnt/ai-models/srccd /mnt/ai-models/srcgit 
clone https://github.com/ggml-org/llama.cpp.gitcd 
llama.cpp

如果之前已經下載過：

cd /mnt/ai-models/src/llama.cpp
git fetch origingit switch master
git pull --ff-only origin master

4. 編譯 CUDA 版本

cd /mnt/ai-models/src/llama.cpp
rm -rf buildcmake -B build \  -DGGML_CUDA=ON \  -DCMAKE_BUILD_TYPE=Releasecmake --build build \  --config Release \  -j 4 \  --target llama-server llama-cli

確認：

./build/bin/llama-server --version
./build/bin/llama-cli --version

下載 Holo 3.1 GGUF 模型

建立模型目錄：

mkdir -p \  /mnt/ai-models/llama-models/Holo-3.1-35B-A3B-GGUF

下載主模型、視覺投影模型與 Chat Template：

hf download \  Hcompany/Holo-3.1-35B-A3B-GGUF \  q4_k_m.gguf \  mmproj.f16.gguf \  chat_template.jinja \  --local-dir \  /mnt/ai-models/llama-models/Holo-3.1-35B-A3B-GGUF

確認：

ls -lh \  /mnt/ai-models/llama-models/Holo-3.1-35B-A3B-GGUF

應該看到：

q4_k_m.ggufmmproj.f16.ggufchat_template.jinja

單模型模式啟動

先用最簡單的單模型方式確認服務能運作：

cd /mnt/ai-models/src/llama.cpp
./build/bin/llama-server \  -m /mnt/ai-models/llama-models/Holo-3.1-35B-A3B-GGUF/q4_k_m.gguf \  --mmproj /mnt/ai-models/llama-models/Holo-3.1-35B-A3B-GGUF/mmproj.f16.gguf \  --jinja \  --host 0.0.0.0 \  --port 8080 \  -c 8192 \  -np 1 \  -ngl 999

參數說明：

--mmproj     指定視覺投影模型
--jinja      使用模型附帶的 Chat Template
-c 8192      Context Length
-np 1        同時處理 1 個請求
-ngl 999     儘可能將模型層放到 GPU

測試文字 API

curl -s http://192.168.0.240:8080/v1/chat/completions \  -H "Content-Type: application/json" \  -d '{    "model": "Holo-3.1-35B-A3B-GGUF",    "messages": [      {        "role": "user",        "content": "請使用繁體中文介紹你的 UI 畫面分析能力。"      }    ],    "max_tokens": 256,    "temperature": 0.2  }' | python3 -m json.tool

在這台 DGX Spark 上，實測文字生成速度約為：

82 tokens/s

測試圖片分析 API

curl -s http://127.0.0.1:8080/v1/chat/completions \  -H "Content-Type: application/json" \  -d '{    "model": "q4_k_m.gguf",    "messages": [      {        "role": "user",        "content": [          {            "type": "text",            "text": "Describe this image in one concise English sentence."          },          {            "type": "image_url",            "image_url": {              "url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"            }          }        ]      }    ],    "thinking_budget_tokens": 64,    "max_tokens": 1024,    "temperature": 0.1  }' | python3 -m json.tool

已知問題：中文多模態輸出偶爾觸發解析錯誤

圖片推論本身可以成功，但在某些中文輸出中，llama-server 可能回傳：

Failed to parse input at pos ...

例如：

自由女神像、火炬、基座、城市天際線、高樓、水面、島嶼、樹木、旗�、船。

其中 � 是 UTF-8 無效字元替代符號。

實務上的處理方式：

1. 降低 temperature，例如 0.12. 限制輸出為簡短句子3. 提高 max_tokens，避免輸出被截斷4. Client 端遇到 500 時自動 Retry 一次5. 優先更新至最新版 llama.cpp

Router Mode：支援多模型切換

確認單模型模式正常後，可以啟用 Router Mode：

cd /mnt/ai-models/src/llama.cpp
./build/bin/llama-server \  --models-dir /mnt/ai-models/llama-models \  --models-max 1 \  --models-autoload \  --jinja \  --host 0.0.0.0 \  --port 8080 \  -c 8192 \  -np 1 \  -ngl 999

啟動後會看到：

Loaded 1 local model presets from /mnt/ai-models/llama-modelsAvailable models (1)    Holo-3.1-35B-A3B-GGUFstarting router server, no model will be loaded in this processrouter server is listening on http://0.0.0.0:8080

Router 會在 Client 第一次呼叫時才載入模型。

查看模型清單：

curl -s \  'http://127.0.0.1:8080/models?reload=1' | \  python3 -m json.tool

指定模型：

curl -s http://127.0.0.1:8080/v1/chat/completions \  -H "Content-Type: application/json" \  -d '{    "model": "Holo-3.1-35B-A3B-GGUF",    "messages": [      {        "role": "user",        "content": "請使用繁體中文簡短介紹你的功能。"      }    ],    "max_tokens": 512,    "temperature": 0.2  }' | python3 -m json.tool

Router Mode 的記憶體策略

我使用：

--models-max 1

意思是：

可以讓 Client 選擇多個模型但同一時間只保留一個模型在記憶體中

這很適合 DGX Spark。因為 Holo 35B、KV Cache、圖片 Token 與系統服務都會共用統一記憶體。

如果要同時提供 Holo 與另一個 Tool Calling 模型，建議：

Holo 35B：Context 8192 或 16384用途：UI 截圖與視覺分析較小的文字 Tool Calling 模型：Context 65536用途：Hermes Agent 預設模型

不同模型需要不同 Context Length 時，可使用 models.ini：

version = 1

[*]
jinja = true
n-gpu-layers = 999
parallel = 1

[Holo-3.1-35B-A3B-GGUF]
model = /mnt/ai-models/llama-models/Holo-3.1-35B-A3B-GGUF/q4_k_m.gguf
mmproj = /mnt/ai-models/llama-models/Holo-3.1-35B-A3B-GGUF/mmproj.f16.gguf
ctx-size = 8192

[qwen-coder]
model = /mnt/ai-models/llama-models/qwen-coder-14b-q4_k_m.gguf
ctx-size = 65536

啟動：

./build/bin/llama-server \  --models-preset /mnt/ai-models/llama-models/models.ini \  --models-max 1 \  --models-autoload \  --host 0.0.0.0 \  --port 8080

讓 llama.cpp 開機就執行

一、確認執行檔路徑

先執行：

ls -lh /mnt/ai-models/src/llama.cpp/build/bin/llama-server

再確認模型目錄：

ls -lah /mnt/ai-models/llama-models

測試版本：

/mnt/ai-models/src/llama.cpp/build/bin/llama-server --version

如果這三個指令正常，就可以建立服務。

二、建立 systemd 服務

建立服務檔：

sudo nano /etc/systemd/system/llama-router.service

貼上：

[Unit]
Description=llama.cpp Router Server
Documentation=https://github.com/ggml-org/llama.cpp
After=network-online.target local-fs.target
Wants=network-online.target
RequiresMountsFor=/mnt/ai-models

[Service]
Type=simple
User=gwoyju
Group=gwoyju
WorkingDirectory=/mnt/ai-models/src/llama.cpp

Environment="LD_LIBRARY_PATH=/usr/local/cuda/lib64"
Environment="CUDA_HOME=/usr/local/cuda"

ExecStartPre=/usr/bin/test -x /mnt/ai-models/src/llama.cpp/build/bin/llama-server
ExecStartPre=/usr/bin/test -d /mnt/ai-models/llama-models

ExecStart=/mnt/ai-models/src/llama.cpp/build/bin/llama-server \
  --models-dir /mnt/ai-models/llama-models \
  --models-max 1 \
  --models-autoload \
  --jinja \
  --host 0.0.0.0 \
  --port 8080 \
  -c 8192 \
  -np 1 \
  -ngl 999

Restart=on-failure
RestartSec=10
TimeoutStopSec=30
KillSignal=SIGTERM
LimitNOFILE=65535

[Install]
WantedBy=multi-user.target

儲存後離開：

Ctrl + O
Enter
Ctrl + X

WantedBy=multi-user.target 讓服務可以隨一般多使用者開機流程啟動；Restart=on-failure 會在程式異常退出時重新啟動服務。

為什麼需要 `RequiresMountsFor`

你的模型與程式都放在：

/mnt/ai-models

如果外接 SSD 尚未掛載完成，直接啟動 llama-server 會失敗。

這一行：

RequiresMountsFor=/mnt/ai-models

會要求 systemd 先準備好該掛載點，再啟動 Router。

三、啟用開機自動執行

重新讀取服務設定：

sudo systemctl daemon-reload

設定開機自動啟動，並立即啟動：

sudo systemctl enable --now llama-router

查看服務狀態：

systemctl status llama-router --no-pager

正常情況應該看到：

Active: active (running)

以及：

router server is listening on http://0.0.0.0:8080

四、查看即時日誌

查看最近 100 行日誌：

journalctl -u llama-router -n 100 --no-pager

持續追蹤日誌：

journalctl -u llama-router -f

離開即時日誌：

Ctrl + C

五、測試 Router API

確認 Router 已啟動：

curl -s http://127.0.0.1:8080/health

查看模型清單：

curl -s \  'http://127.0.0.1:8080/models?reload=1' | \  python3 -m json.tool

測試 Holo 3.1：

curl -s http://127.0.0.1:8080/v1/chat/completions \  -H "Content-Type: application/json" \  -d '{    "model": "Holo-3.1-35B-A3B-GGUF",    "messages": [      {        "role": "user",        "content": "請使用繁體中文簡短介紹你的功能。"      }    ],    "max_tokens": 256,    "temperature": 0.2  }' | python3 -m json.tool

第一次呼叫時會需要等待模型載入。後續請求會比較快。

六、常用管理指令

啟動服務

sudo systemctl start llama-router

停止服務

sudo systemctl stop llama-router

重新啟動

sudo systemctl restart llama-router

查看狀態

systemctl status llama-router --no-pager

取消開機自動啟動

sudo systemctl disable --now llama-router

七、確認開機後是否真的自動啟動

重新開機：

sudo reboot

重新 SSH 登入後執行：

systemctl status llama-router --no-pager

確認 Port：

ss -ltnp | grep :8080

測試模型清單：

curl -s http://127.0.0.1:8080/models | \  python3 -m json.tool

八、改用 models.ini

準備讓不同模型有不同 Context Length：

Holo 35B：8192Hermes 預設 Tool Calling 模型：65536

這種情況建議不要在服務中使用：

--models-dir-c 8192

而是改用：

--models-preset

假設設定檔位於：

/mnt/ai-models/llama-models/models.ini

服務中的 ExecStart 改成：

ExecStart=/mnt/ai-models/src/llama.cpp/build/bin/llama-server \
  --models-preset /mnt/ai-models/llama-models/models.ini \
  --models-max 1 \
  --models-autoload \
  --host 0.0.0.0 \
  --port 8080

改完後重新載入設定：

sudo systemctl daemon-reload
sudo systemctl restart llama-router

查看日誌：

journalctl -u llama-router -f

九、避免 Ollama 開機後搶占記憶體

你之前遇過記憶體不足。如果目前 DGX Spark 主要改用 llama.cpp，建議停用 Ollama 的開機自動啟動：

sudo systemctl disable --now ollama

確認：

systemctl status ollama --no-pager

未來需要恢復：

sudo systemctl enable --now ollama

十、限制只允許內網連線

目前使用：

--host 0.0.0.0

代表區域網路內其他裝置可以存取 API。Router Mode 目前仍屬於實驗性功能；llama.cpp 啟動日誌也提醒，不建議直接暴露在不受信任的網路環境。

假設區域網路是：

192.168.0.0/24

可以設定 UFW：

sudo ufw allow from 192.168.0.0/24 \  to any port 8080 proto tcp

查看規則：

sudo ufw status numbered

不要直接把 Port 8080 暴露到公網。

建議你現在直接執行的版本

建立 /etc/systemd/system/llama-router.service 後，執行：

sudo systemctl daemon-reload
sudo systemctl enable --now llama-router
systemctl status llama-router --no-pagerjournalctl -u llama-router -n 50 --no-pager

這樣 DGX Spark 每次重新開機後，llama.cpp Router Server 就會自動啟動，並等待 Hermes Agent 或其他 Client 指定要載入的模型。

參考資料

https://huggingface.co/collections/Hcompany/holo31

https://build.nvidia.com/spark/llama-cpp/instructions

Llama-3.2-90B-Vision 實戰：本地端影片偵探與多模態分析完整解析

by rainchu | 12 月 17, 2025 | AI, Llama, Ollama, 模型

前言：為什麼要做「影片偵探」？

隨著監控攝影機、行車紀錄器、門禁與智慧製造設備的大量部署，「影片」早已成為企業與政府最重要的資料來源之一。然而，影片資料無法被傳統文字搜尋系統理解，長時間的人工作業也帶來極高成本。

這正是「影片偵探（Video Detective）」的價值所在——
讓 AI 看懂影片內容、理解畫面語意、並能以自然語言回答問題。

而在 2024 年 9 月 25 日，Meta 推出的 Llama-3.2-90B-Vision（Vision 3.2 90B），正式讓「本地端、多模態、可商業應用」的影片理解系統成為可能。

Llama-3.2-90B-Vision 模型簡介

Vision 3.2 90B 是 Meta 在 Llama 3.2 系列中最強大的開源多模態模型（VLM），也是目前開源社群中少數能與封閉模型正面競爭的選擇。

核心規格與特點

模型規模：
900 億個參數（90B），為 Llama 3.2 系列最大版本
視覺處理能力：
- 圖像理解
- 圖像描述（Image Captioning）
- 視覺問答（VQA）
- 圖表與截圖解析（Excel / PDF / 監控畫面）
技術架構：
採用 Adapter Weights，將視覺編碼器整合至 Llama 3 語言模型
上下文長度：
高達 128K tokens，可處理長影片摘要與多畫面分析
效能表現：
在多模態基準測試中，接近 GPT-4o-mini、Claude 3 Haiku
硬體需求：
通常需要多張 NVIDIA A100 / H100 GPU 進行推理

官方資源：

官方介紹：https://ai.meta.com/blog/llama-3-2-connect-2024-vision-edge-mobile-devices/
HuggingFace：https://huggingface.co/meta-llama/Llama-3.2-90B-Vision

什麼是「影片偵探」？

「影片偵探」並不是單一模型，而是一套 多階段 AI 架構：

影格抽取（Frame Sampling）
物件 / 人臉偵測（YOLO / yolo face）
視覺語意理解（Llama-3.2-90B-Vision）
語意摘要與事件推論
自然語言查詢與回應

使用者可以直接詢問：

「這段影片中，有沒有可疑人物？」
「哪一段出現未授權進入？」
「請總結這 2 小時監控畫面的重點事件」

為何選擇 Llama-3.2-90B-Vision？

1️⃣ 本地端部署（On-Premise）

對於以下場景尤其重要：

政府監控系統
金融機構
工廠產線
企業內部資安影像

資料不出內網、不上雲端，符合資安與法規要求。

透過 Ollama 即可在本地部署 Vision 3.2：

👉 https://ollama.com/library/llama3.2-vision:90b

參考教學：

https://chtseng.wordpress.com/2024/11/18/何在本地端透過ollama使用llama-3-2-vision/

2️⃣ 高度客製化的影片理解流程

你可以自由設計：

先用 YOLO / yolo face 做人臉與物件偵測
再將關鍵影格丟給 Llama-3.2-90B-Vision 理解語意
根據產業需求自訂 Prompt 與規則

例如：

工地安全（是否未戴安全帽）
店面防盜（可疑行為模式）
智慧製造（異常操作流程）

3️⃣ 可合法商業應用的開源模型

與多數封閉 API 不同，Llama 3.2 系列具備商業使用條款，適合：

SaaS 影片分析平台
企業內部 AI 系統
客製化專案與整合案

同時避免：

API 呼叫成本失控
雲端延遲
資料外洩風險

架構範例：影片偵探系統設計

線上體驗與 API 使用方式

如果暫時沒有高階 GPU，也可以使用 NVIDIA 官方提供的線上版本：

線上 Demo
https://build.nvidia.com/meta/llama-3.2-90b-vision-instruct
NVIDIA API 部署
https://build.nvidia.com/meta/llama-3.2-90b-vision-instruct/deploy
教學影片
https://www.youtube.com/watch?v=rPpAShE-4I4
https://blog.stoeng.site/20240927.html

實作系統

影片偵探 Prompt 範例（可直接用）

Prompt 1：單張關鍵影格「事件描述 + 可疑度」

用途：把 YOLO 的偵測結果 + 影格一起丟給 Vision 3.2，產出可索引的敘述。
（強烈建議把 YOLO metadata 一起餵，讓 VLM 不用「瞎猜」類別與位置）

你是一個「影片偵探」AI，負責為監控影格做事件描述與風險判讀。
請根據：
1) 影格畫面內容
2) 我提供的偵測結果（物件類別、bbox、信心值）
輸出結構化 JSON，方便後續索引與查詢。

規則：
- 不要編造畫面中不存在的事物。
- 若畫面資訊不足，請在 unsure 字段說明原因。
- suspicious_score 0~100：越高越可疑，但必須用畫面線索與偵測結果解釋。
- 需同時輸出一段適合全文檢索的繁體中文摘要 summary_zh。

輸入：
timestamp: {{timestamp}}
camera_id: {{camera_id}}
detections: {{yolo_detections_json}}
image: <提供影像>

輸出 JSON 欄位：
{
  "timestamp": "...",
  "camera_id": "...",
  "scene_summary": "...",
  "entities": [
    {"type": "...", "count": 1, "notable": "..."}
  ],
  "actions": ["..."],
  "suspicious_score": 0,
  "suspicious_reasons": ["..."],
  "unsure": ["..."],
  "summary_zh": "..."
}

Prompt 2：多張影格「跨時間軸事件摘要」

用途：把同一事件的多張關鍵影格（例如 5~12 張）一次丟給 128K context，做「時間序列推論」

你是一個監控「影片偵探」AI。以下提供同一段時間序列的多張關鍵影格，
每張都有 timestamp 與偵測結果。請完成：

1) 以時間順序描述發生了什麼事（避免臆測）。
2) 是否存在可疑行為？若有，指出關鍵時間點與依據。
3) 產出適合儲存到事件資料庫的 JSON（含 event_type、start/end、關聯track_id）。

輸入格式（重複多次）：
- frame_i.timestamp: ...
- frame_i.detections: ...
- frame_i.image: <圖>

輸出：
- timeline_bullets（條列，含時間）
- event_json：
{
  "event_type": "...",
  "start_time": "...",
  "end_time": "...",
  "actors": [{"track_id":"...","type":"person/vehicle","notes":"..."}],
  "evidence": [{"timestamp":"...","what":"..."}],
  "risk_level": "low/medium/high",
  "search_keywords_zh": ["..."]
}

Prompt 3：使用者查詢「找片段 + 佐證」

用途：RAG 從索引庫找出候選事件後，叫模型做最後整合回答。

你是影片偵探助理。你會收到：
- 使用者問題
- 檢索得到的候選事件清單（含摘要、時間、相機、佐證影格描述）

請：
1) 直接回答問題（繁體中文）
2) 附上最相關的事件時間範圍（start~end）
3) 列出 1~3 個佐證點（引用候選事件的 evidence）
4) 若資訊不足，說明缺什麼

輸入：
question: {{user_question}}
candidates: {{retrieved_events_json}}

輸出：
{
  "answer_zh": "...",
  "best_matches": [
    {"camera_id":"...","time_range":"...","why":"...","evidence":["..."]}
  ],
  "missing_info": ["..."]
}

YOLO + Vision 3.2 實作流程範例

下面是一個「可落地」的最小可行流程（MVP）

Step 0：選擇部署模式

本地端（推薦）：Ollama 跑 llama3.2-vision:90b（需強 GPU/多卡）
先用線上 API 驗證流程：NVIDIA 的 Llama-3.2-90B-Vision Instruct（把 pipeline 跑通再回本地）

Step 1：影片 → 影格抽取（Frame Sampling）

策略建議：

監控：每秒 1~2 張 + 場景切分（scene change）
行車：依速度/光流變化調整取樣
事件型：偵測到人/車才加密取樣

Python（OpenCV）骨架：

import cv2
import os

def extract_frames(video_path, out_dir, fps_sample=1):
    os.makedirs(out_dir, exist_ok=True)
    cap = cv2.VideoCapture(video_path)
    fps = cap.get(cv2.CAP_PROP_FPS) or 30
    step = max(int(fps / fps_sample), 1)

    idx = 0
    frame_id = 0
    while True:
        ok, frame = cap.read()
        if not ok:
            break
        if frame_id % step == 0:
            out_path = os.path.join(out_dir, f"frame_{idx:06d}.jpg")
            cv2.imwrite(out_path, frame)
            idx += 1
        frame_id += 1

    cap.release()
    return idx

Step 2：影格 → YOLO / yolo face 偵測（產生 metadata）

可以用：

YOLOv8 / YOLOv10 做物件、人、車
yolo face（或更強的人臉模型）做臉部框
之後再加 ByteTrack/DeepSORT 形成 track_id

偵測輸出建議格式（JSON）：

[
  {"type":"person","conf":0.92,"bbox":[x1,y1,x2,y2]},
  {"type":"car","conf":0.88,"bbox":[x1,y1,x2,y2]},
  {"type":"face","conf":0.81,"bbox":[x1,y1,x2,y2]}
]

Step 3：挑關鍵影格（降低 VLM 成本）

常見挑選法：

有偵測到 person/vehicle 才送 VLM
同一 track_id 每 N 秒只取 1 張代表影格
有事件觸發（越線/闖入/停留過久）才送 VLM

Step 4：送進 Vision 3.2 做語意理解（Ollama 版本）

若你用 Ollama，本質上是：影像 + prompt +（可選）metadata → 回傳描述 JSON。

概念請長這樣：

把影格讀成 base64 或直接用 Ollama SDK 的 image 欄位
prompt 內含 timestamp、camera_id、detections
要求模型「輸出 JSON」

依你使用的 Ollama client 調整：

import json

def build_prompt(ts, cam, detections):
    return f"""
你是一個影片偵探AI。請依據影像與偵測結果輸出JSON（繁體中文）。

timestamp: {ts}
camera_id: {cam}
detections: {json.dumps(detections, ensure_ascii=False)}

輸出JSON欄位：
{{
  "timestamp": "...",
  "camera_id": "...",
  "scene_summary": "...",
  "actions": ["..."],
  "suspicious_score": 0,
  "suspicious_reasons": ["..."],
  "summary_zh": "..."
}}
"""

# 送給 Ollama 的地方，依你使用的套件/HTTP API 填上：
# response = ollama.chat(model="llama3.2-vision:90b", messages=[...], images=[...])

Step 5：事件彙整 + 建索引（讓你能「用中文搜影片」）

你至少要存三種資料：

frame-level：每張影格摘要 + detections
event-level：跨影格彙整（start/end、actors、evidence）
索引：
- 向量索引（embedding）→ 語意搜尋
- 關鍵字索引（全文）→ 精準查詢（例如「紅色帽子」「白色車」）

Step 6：查詢（RAG）→ 回答 + 佐證時間軸

流程：

使用者問：「昨天晚上 10 點到 11 點，有沒有人在後門徘徊？」
檢索 event/frame 索引找候選
把候選 evidence 丟給 Prompt 3 做最終回答
回傳：時間範圍 + 相機 + 佐證描述 +（可選）影格連結

你可以直接複製用的「最小資料結構」

frame_record

{
  "frame_id": "cam01_20251216_220501_000123",
  "camera_id": "cam01",
  "timestamp": "2025-12-16T22:05:01",
  "image_path": "/frames/cam01/frame_000123.jpg",
  "detections": [],
  "vlm_json": {},
  "summary_zh": "..."
}

event_record

{
  "event_id": "evt_20251216_cam01_0007",
  "camera_id": "cam01",
  "start_time": "2025-12-16T22:05:00",
  "end_time": "2025-12-16T22:06:30",
  "event_type": "徘徊/闖入/越線/遺留物/群聚",
  "actors": [{"track_id":"p12","type":"person"}],
  "evidence": [
    {"timestamp":"2025-12-16T22:05:15","what":"人物在後門附近停留，反覆靠近門把"}
  ],
  "risk_level": "medium",
  "search_keywords_zh": ["後門","徘徊","可疑人物"]
}

事件規則怎麼定義（越線 / 闖入 / 停留）

A. 共同前置：座標系與 ROI 設定

建議每台攝影機都做一份設定檔（JSON/YAML）：

ROI 多邊形：例如「後門區域」「禁入區」「收銀台區」
Tripwire 線段：例如「門檻線」「圍籬線」
方向向量（可選）：判斷越線方向（外→內 / 內→外）

camera_rules.json（示例）

重點：事件規則「不要靠 VLM 猜」，VLM 用在「補語意」，規則用在「可重現、可商業合規」。

B. 越線（Tripwire Crossing）

定義：同一個 track_id 的「腳點/中心點」從線段一側移動到另一側，且跨越時間在合理範圍。

實作要點

取 bbox 底部中心點（foot point）更準：
foot = ((x1+x2)/2, y2)
記錄上一幀 foot 在直線的「符號」（line side sign）
sign 改變（+ → – 或 – → +）= 可能越線
若需要方向：檢查 crossing 前後的位置落在哪個 side

事件輸出

event_type: 越線
evidence: crossing 發生的 timestamp + 當下影格 id

C. 闖入（Intrusion into Restricted Zone）

定義：目標（person/vehicle）進入「restricted_zone」ROI，且停留超過 N 幀或 N 秒（避免抖動誤判）。

實作要點

以 foot point 是否在多邊形內判斷（比中心點穩）
用 debounce：例如連續 5 幀在區域內才算「進入成立」
退出同理：連續 5 幀不在區域內才算退出

事件輸出

event_type: 闖入
start_time = 進入成立時間
end_time = 退出成立時間

D. 停留 / 徘徊（Loitering）

定義：在指定 zone 內停留超過 min_seconds，且移動速度低於門檻（或移動距離很小但在區域內反覆）。

實作要點

per track_id 維護：
- time_in_zone
- path_length（foot 點累積距離）
- avg_speed = path_length / time_in_zone
停留成立條件（示例）：
- time_in_zone >= 20s 且 avg_speed <= 15 px/s
可擴充「徘徊」：
- 在 zone 內來回穿越同一條小線段超過 K 次
- 或在 zone 內出入（進/出）頻繁

2) 追蹤器接 YOLO（track_id 穩定）

A. 建議組合

偵測：YOLO（person/vehicle/bag…）
追蹤：ByteTrack（速度快、穩）或 DeepSORT（更重但 ReID 強）
ID 穩定策略：
1. 只追固定類別：例如只追 person/vehicle（別把雜訊類也追）
2. 信心值門檻 + NMS：減少跳框
3. 遮擋容忍：追蹤器允許短暫 lost 再接回
4. ReID（選配）：若常遮擋、跨鏡頭才需要

B. 最小資料流（你系統該長這樣）

frame
  -> YOLO detections: [x1,y1,x2,y2, conf, cls]
  -> Tracker.update(detections)
  -> tracks: [track_id, bbox, cls, conf, state]
  -> event_rules.update(tracks, timestamp)

C. 追蹤輸出建議格式

[
  {"track_id":"p12","type":"person","conf":0.92,"bbox":[...],"foot":[...]}
]

關鍵：後續事件規則都以 track_id 為核心。VLM 的 actors 也引用 track_id，才能串起「時間序列」。

3) 向量索引與查詢（embedding schema、RAG prompt）

A. 你要索引什麼？（兩層：frame-level + event-level）

frame-level：細碎、量大，用於精確定位
event-level：濃縮、量小，用於查詢與回覆（最重要）

B. 建議的 Embedding Schema（event-level）

每個 event 存：

id, camera_id, start_time, end_time
event_type
actors（含 track_id、類別、特徵詞）
summary_zh（VLM + 規則融合）
evidence[]（時間戳 + 發生描述 + frame_id）
keywords_zh[]（用於 BM25）
embedding（由 summary_zh + keywords_zh 拼成）

event_embedding_text 建議組合

[事件類型] 闖入
[地點] cam01 後門 restricted_zone
[摘要] 一名人物在22:05進入禁入區，停留約35秒後離開。
[關鍵詞] 後門, 禁入區, 闖入, 可疑人物

C. 檢索策略（Hybrid Search）

關鍵字/BM25：找「後門」「白色車」「紅帽」這種明確詞
向量/語意：找「徘徊」「鬼鬼祟祟」「疑似踩點」這種抽象語意
合併 rerank：取 topK events，再丟給 LLM 做最終回答

D. RAG Prompt（查詢 → 回答 + 時間軸 + 點影格）

「可商業用」模板（配之前的 Prompt 3 進化版）：

你是影片偵探助理。你會收到：
- 使用者問題 question（繁體中文）
- 候選事件 candidates（由索引檢索得到，含 summary_zh、時間、相機、evidence、frame_link）
你的任務是產生「可行動」的答案：

要求：
1) 先用 3~6 句回答使用者，務必引用 candidates 的內容，不要臆測。
2) 產生時間軸 timeline（依時間排序），每點包含：start~end、camera、event_type、1句描述、frame_link（若有）。
3) 如果 candidates 不足以回答，回 missing_info，並說明需要補哪段時間/哪個相機/哪種事件資料。
4) 全部輸出 JSON，方便前端直接渲染。

輸入：
question: {{question}}
candidates: {{candidates_json}}

輸出 JSON：
{
  "answer_zh": "...",
  "timeline": [
    {
      "camera_id": "...",
      "time_range": "YYYY-MM-DD HH:MM:SS ~ HH:MM:SS",
      "event_type": "...",
      "description": "...",
      "evidence": ["..."],
      "frame_links": ["..."]
    }
  ],
  "missing_info": ["..."]
}

4) 簡單 Web UI（查詢 → 回傳時間軸 → 點開影格）

我給你一個最小 MVP 架構：

A. API 設計（後端）

GET /api/search?q=...&from=...&to=...&camera=...
- 回傳 RAG 結果 JSON（answer_zh + timeline）
GET /frames/<frame_id>.jpg
- 靜態提供影格圖（或簽名 URL）

回傳 JSON（示例）

{
  "answer_zh":"在 22:05~22:06 期間，cam01 後門區域出現 1 次闖入事件...",
  "timeline":[
    {
      "camera_id":"cam01",
      "time_range":"2025-12-16 22:05:00 ~ 22:06:30",
      "event_type":"闖入",
      "description":"人物 p12 進入 restricted_zone 停留約35秒後離開。",
      "evidence":["22:05:15 人物靠近門把","22:06:10 人物離開區域"],
      "frame_links":["/frames/cam01_20251216_220515_000130.jpg"]
    }
  ],
  "missing_info":[]
}

B. 前端（純 HTML+JS 就能跑）

把這段存成 index.html，指向你的 API：

<!doctype html>
<html lang="zh-Hant">
<head>
  <meta charset="utf-8" />
  <meta name="viewport" content="width=device-width,initial-scale=1" />
  <title>影片偵探 Demo</title>
  <style>
    body { font-family: system-ui, -apple-system, "Noto Sans TC", sans-serif; margin: 16px; }
    .row { display: flex; gap: 8px; flex-wrap: wrap; margin-bottom: 12px; }
    input, select, button { padding: 8px; }
    .card { border: 1px solid #ddd; border-radius: 12px; padding: 12px; margin: 10px 0; }
    .timeline-item { cursor: pointer; padding: 10px; border-radius: 10px; }
    .timeline-item:hover { background: #f5f5f5; }
    .grid { display: grid; grid-template-columns: 1fr 1fr; gap: 12px; }
    img { max-width: 100%; border-radius: 12px; border: 1px solid #eee; }
    pre { background:#fafafa; padding:10px; border-radius:10px; overflow:auto; }
  </style>
</head>
<body>
  <h1>影片偵探 Demo</h1>

  <div class="row">
    <input id="q" size="40" placeholder="例如：後門有沒有人徘徊？白色車出現在哪？" />
    <input id="from" type="datetime-local" />
    <input id="to" type="datetime-local" />
    <select id="camera">
      <option value="">全部相機</option>
      <option value="cam01">cam01</option>
      <option value="cam02">cam02</option>
    </select>
    <button id="btn">查詢</button>
  </div>

  <div class="grid">
    <div>
      <div class="card">
        <h3>答案</h3>
        <div id="answer">尚未查詢</div>
      </div>

      <div class="card">
        <h3>時間軸</h3>
        <div id="timeline"></div>
      </div>

      <div class="card">
        <h3>除錯（回傳 JSON）</h3>
        <pre id="raw">{}</pre>
      </div>
    </div>

    <div>
      <div class="card">
        <h3>影格預覽</h3>
        <div id="frameInfo">點選左側時間軸項目查看影格</div>
        <img id="frame" src="" alt="" style="display:none;" />
      </div>
    </div>
  </div>

<script>
  const $ = (id) => document.getElementById(id);

  function toISOParam(dtLocal) {
    // 直接傳給後端即可（你可在後端再轉時區）
    return dtLocal ? encodeURIComponent(dtLocal) : "";
  }

  function renderTimeline(items) {
    const root = $("timeline");
    root.innerHTML = "";
    if (!items || items.length === 0) {
      root.innerHTML = "<div>沒有找到事件</div>";
      return;
    }
    items.forEach((it, idx) => {
      const div = document.createElement("div");
      div.className = "timeline-item";
      div.innerHTML = `
        <div><b>${it.time_range}</b>｜${it.camera_id}｜${it.event_type}</div>
        <div>${it.description}</div>
      `;
      div.onclick = () => {
        const link = (it.frame_links && it.frame_links[0]) ? it.frame_links[0] : "";
        $("frameInfo").innerText = link ? `影格：${link}` : "此事件沒有影格連結";
        if (link) {
          $("frame").src = link;
          $("frame").style.display = "block";
        } else {
          $("frame").style.display = "none";
        }
      };
      root.appendChild(div);
    });
  }

  $("btn").onclick = async () => {
    const q = $("q").value.trim();
    const from = toISOParam($("from").value);
    const to = toISOParam($("to").value);
    const camera = encodeURIComponent($("camera").value);

    const url = `/api/search?q=${encodeURIComponent(q)}&from=${from}&to=${to}&camera=${camera}`;
    const res = await fetch(url);
    const data = await res.json();

    $("answer").innerText = data.answer_zh || "";
    renderTimeline(data.timeline || []);
    $("raw").innerText = JSON.stringify(data, null, 2);
  };
</script>
</body>
</html>

最小可跑的 Flask 後端實作（MVP）

最小可跑的 Flask 後端實作（MVP）：

GET /api/search：用最簡單的「關鍵字 + 語意(可選)」搜尋事件，回傳前端需要的 answer_zh + timeline JSON
GET /frames/<path>：提供影格圖片（靜態檔）
內建一份 data/events.json 假資料，讓你不用先把整個 pipeline 做完也能 Demo 起來
前端就用你前面那份 index.html（我也一起放進 static/）

你可以直接照以下檔案建立專案。

專案結構

video-detective-mvp/
  app.py
  requirements.txt
  data/
    events.json
  frames/
    cam01_20251216_220515_000130.jpg   (放你自己的影格檔)
  static/
    index.html

requirements.txt

Flask==3.0.3

data/events.json（假資料，可自行新增）

[
  {
    "event_id": "evt_20251216_cam01_0007",
    "camera_id": "cam01",
    "start_time": "2025-12-16T22:05:00",
    "end_time": "2025-12-16T22:06:30",
    "event_type": "闖入",
    "actors": [{"track_id":"p12","type":"person"}],
    "summary_zh": "一名人物進入後門禁入區，停留約35秒後離開。",
    "keywords_zh": ["後門","禁入區","闖入","可疑人物"],
    "evidence": [
      {"timestamp":"2025-12-16T22:05:15","what":"人物靠近門把並進入禁入區"},
      {"timestamp":"2025-12-16T22:06:10","what":"人物離開禁入區"}
    ],
    "frame_links": ["/frames/cam01_20251216_220515_000130.jpg"]
  },
  {
    "event_id": "evt_20251216_cam02_0011",
    "camera_id": "cam02",
    "start_time": "2025-12-16T21:40:10",
    "end_time": "2025-12-16T21:41:05",
    "event_type": "越線",
    "actors": [{"track_id":"v03","type":"vehicle"}],
    "summary_zh": "一輛車跨越門檻線由外往內進入區域。",
    "keywords_zh": ["越線","車輛","進入","門檻線"],
    "evidence": [
      {"timestamp":"2025-12-16T21:40:22","what":"車輛前輪跨越門檻線"}
    ],
    "frame_links": []
  },
  {
    "event_id": "evt_20251216_cam01_0009",
    "camera_id": "cam01",
    "start_time": "2025-12-16T23:10:00",
    "end_time": "2025-12-16T23:11:00",
    "event_type": "停留",
    "actors": [{"track_id":"p33","type":"person"}],
    "summary_zh": "一名人物在後門區域停留約60秒，移動緩慢，疑似徘徊。",
    "keywords_zh": ["後門","停留","徘徊","可疑"],
    "evidence": [
      {"timestamp":"2025-12-16T23:10:20","what":"人物在後門附近停留且來回踱步"}
    ],
    "frame_links": []
  }
]

static/index.html（直接用你前面 UI；這裡給一份可直接用的）

這份會呼叫 /api/search，點時間軸會開影格。

<!doctype html>
<html lang="zh-Hant">
<head>
  <meta charset="utf-8" />
  <meta name="viewport" content="width=device-width,initial-scale=1" />
  <title>影片偵探 Demo</title>
  <style>
    body { font-family: system-ui, -apple-system, "Noto Sans TC", sans-serif; margin: 16px; }
    .row { display: flex; gap: 8px; flex-wrap: wrap; margin-bottom: 12px; }
    input, select, button { padding: 8px; }
    .card { border: 1px solid #ddd; border-radius: 12px; padding: 12px; margin: 10px 0; }
    .timeline-item { cursor: pointer; padding: 10px; border-radius: 10px; }
    .timeline-item:hover { background: #f5f5f5; }
    .grid { display: grid; grid-template-columns: 1fr 1fr; gap: 12px; }
    img { max-width: 100%; border-radius: 12px; border: 1px solid #eee; }
    pre { background:#fafafa; padding:10px; border-radius:10px; overflow:auto; }
  </style>
</head>
<body>
  <h1>影片偵探 Demo</h1>

  <div class="row">
    <input id="q" size="42" placeholder="例如：後門有沒有人徘徊？禁入區闖入？越線？" />
    <input id="from" type="datetime-local" />
    <input id="to" type="datetime-local" />
    <select id="camera">
      <option value="">全部相機</option>
      <option value="cam01">cam01</option>
      <option value="cam02">cam02</option>
    </select>
    <button id="btn">查詢</button>
  </div>

  <div class="grid">
    <div>
      <div class="card">
        <h3>答案</h3>
        <div id="answer">尚未查詢</div>
      </div>

      <div class="card">
        <h3>時間軸</h3>
        <div id="timeline"></div>
      </div>

      <div class="card">
        <h3>除錯（回傳 JSON）</h3>
        <pre id="raw">{}</pre>
      </div>
    </div>

    <div>
      <div class="card">
        <h3>影格預覽</h3>
        <div id="frameInfo">點選左側時間軸項目查看影格</div>
        <img id="frame" src="" alt="" style="display:none;" />
      </div>
    </div>
  </div>

<script>
  const $ = (id) => document.getElementById(id);

  function renderTimeline(items) {
    const root = $("timeline");
    root.innerHTML = "";
    if (!items || items.length === 0) {
      root.innerHTML = "<div>沒有找到事件</div>";
      return;
    }
    items.forEach((it) => {
      const div = document.createElement("div");
      div.className = "timeline-item";
      div.innerHTML = `
        <div><b>${it.time_range}</b>｜${it.camera_id}｜${it.event_type}</div>
        <div>${it.description}</div>
      `;
      div.onclick = () => {
        const link = (it.frame_links && it.frame_links[0]) ? it.frame_links[0] : "";
        $("frameInfo").innerText = link ? `影格：${link}` : "此事件沒有影格連結";
        if (link) {
          $("frame").src = link;
          $("frame").style.display = "block";
        } else {
          $("frame").style.display = "none";
        }
      };
      root.appendChild(div);
    });
  }

  $("btn").onclick = async () => {
    const q = $("q").value.trim();
    const from = $("from").value;
    const to = $("to").value;
    const camera = $("camera").value;

    const url = `/api/search?q=${encodeURIComponent(q)}&from=${encodeURIComponent(from)}&to=${encodeURIComponent(to)}&camera=${encodeURIComponent(camera)}`;
    const res = await fetch(url);
    const data = await res.json();

    $("answer").innerText = data.answer_zh || "";
    renderTimeline(data.timeline || []);
    $("raw").innerText = JSON.stringify(data, null, 2);
  };
</script>
</body>
</html>

app.py（Flask 後端：搜尋 + 回傳 timeline + 靜態影格）

from __future__ import annotations

import json
import os
from dataclasses import dataclass
from datetime import datetime
from typing import Any, Dict, List, Optional, Tuple

from flask import Flask, jsonify, request, send_from_directory


BASE_DIR = os.path.dirname(os.path.abspath(__file__))
DATA_PATH = os.path.join(BASE_DIR, "data", "events.json")
FRAMES_DIR = os.path.join(BASE_DIR, "frames")


def parse_dt(s: str) -> Optional[datetime]:
    """
    Accepts:
      - "" -> None
      - HTML datetime-local: "2025-12-16T22:05"
      - ISO: "2025-12-16T22:05:00"
    """
    if not s:
        return None
    s = s.strip()
    for fmt in ("%Y-%m-%dT%H:%M", "%Y-%m-%dT%H:%M:%S"):
        try:
            return datetime.strptime(s, fmt)
        except ValueError:
            pass
    # Fallback: try fromisoformat (may accept seconds/microseconds)
    try:
        return datetime.fromisoformat(s)
    except ValueError:
        return None


def load_events() -> List[Dict[str, Any]]:
    if not os.path.exists(DATA_PATH):
        return []
    with open(DATA_PATH, "r", encoding="utf-8") as f:
        return json.load(f)


def dt_in_range(start: datetime, end: datetime, q_from: Optional[datetime], q_to: Optional[datetime]) -> bool:
    if q_from and end < q_from:
        return False
    if q_to and start > q_to:
        return False
    return True


def text_score(query_tokens: List[str], event: Dict[str, Any]) -> int:
    """
    Minimal keyword scoring:
      - match in event_type, summary_zh, keywords_zh, evidence.what
    """
    blob_parts = []
    blob_parts.append(str(event.get("event_type", "")))
    blob_parts.append(str(event.get("summary_zh", "")))
    blob_parts.extend(event.get("keywords_zh", []) or [])
    for ev in event.get("evidence", []) or []:
        blob_parts.append(str(ev.get("what", "")))

    blob = " ".join(blob_parts).lower()
    score = 0
    for t in query_tokens:
        if not t:
            continue
        if t in blob:
            score += 10
    return score


def tokenize_zh(query: str) -> List[str]:
    """
    MVP 簡化版 tokenization：
    - 以空白切
    - 再把常見關鍵詞直接保留（你可改成 jieba/ckip/hfl 分詞）
    """
    q = (query or "").strip().lower()
    if not q:
        return []
    tokens = [x for x in q.replace("，", " ").replace(",", " ").split() if x]
    # 也把一些常見事件詞補入（避免使用者只打「徘徊」但資料用「停留」）
    synonyms = {
        "徘徊": ["停留"],
        "停留": ["徘徊"],
        "闖入": ["入侵", "禁入"],
        "越線": ["跨線", "穿越"],
        "後門": ["門口"]
    }
    expanded = []
    for t in tokens:
        expanded.append(t)
        for s in synonyms.get(t, []):
            expanded.append(s)
    return expanded


def build_timeline_item(e: Dict[str, Any]) -> Dict[str, Any]:
    def fmt_range(s: str, t: str) -> str:
        try:
            sdt = datetime.fromisoformat(s)
            tdt = datetime.fromisoformat(t)
            return f"{sdt:%Y-%m-%d %H:%M:%S} ~ {tdt:%Y-%m-%d %H:%M:%S}"
        except Exception:
            return f"{s} ~ {t}"

    evidence = []
    for ev in e.get("evidence", []) or []:
        ts = ev.get("timestamp", "")
        what = ev.get("what", "")
        if ts and what:
            evidence.append(f"{ts} {what}")
        elif what:
            evidence.append(what)

    return {
        "camera_id": e.get("camera_id", ""),
        "time_range": fmt_range(e.get("start_time", ""), e.get("end_time", "")),
        "event_type": e.get("event_type", ""),
        "description": e.get("summary_zh", ""),
        "evidence": evidence[:3],
        "frame_links": e.get("frame_links", []) or [],
    }


def build_answer(query: str, matched: List[Dict[str, Any]]) -> str:
    if not query.strip():
        return "請輸入查詢內容（例如：後門 徘徊、禁入區 闖入、越線）。"
    if not matched:
        return "沒有找到符合條件的事件。你可以嘗試放寬時間範圍、改用關鍵詞（例如：後門、闖入、停留、越線）。"

    # MVP：用最前面幾筆拼一段可讀答案（之後你可接 LLM/RAG）
    top = matched[:3]
    parts = []
    parts.append(f"找到 {len(matched)} 筆候選事件，最相關的如下：")
    for e in top:
        parts.append(f"- {e.get('camera_id','')}｜{e.get('event_type','')}｜{e.get('summary_zh','')}")
    return "\n".join(parts)


app = Flask(__name__, static_folder="static", static_url_path="/")


@app.get("/")
def index():
    # 直接用 static/index.html
    return app.send_static_file("index.html")


@app.get("/frames/<path:filename>")
def frames(filename: str):
    # 提供影格圖片
    return send_from_directory(FRAMES_DIR, filename)


@app.get("/api/search")
def api_search():
    q = request.args.get("q", "")
    camera = request.args.get("camera", "").strip()
    q_from = parse_dt(request.args.get("from", ""))
    q_to = parse_dt(request.args.get("to", ""))

    events = load_events()
    tokens = tokenize_zh(q)

    # 先做基本篩選（camera + time range）
    filtered = []
    for e in events:
        if camera and e.get("camera_id") != camera:
            continue
        s = parse_dt(e.get("start_time", "")) or datetime.min
        t = parse_dt(e.get("end_time", "")) or datetime.min
        if not dt_in_range(s, t, q_from, q_to):
            continue
        filtered.append(e)

    # 關鍵字打分排序（MVP）
    scored: List[Tuple[int, Dict[str, Any]]] = []
    for e in filtered:
        score = text_score(tokens, e)
        if tokens and score <= 0:
            continue
        scored.append((score, e))

    scored.sort(key=lambda x: x[0], reverse=True)
    matched = [e for _, e in scored][:20]

    resp = {
        "answer_zh": build_answer(q, matched),
        "timeline": [build_timeline_item(e) for e in matched],
        "missing_info": [] if matched else ["建議擴大時間範圍或指定相機，並使用關鍵字：後門、闖入、停留、越線。"],
    }
    return jsonify(resp)


if __name__ == "__main__":
    os.makedirs(FRAMES_DIR, exist_ok=True)
    app.run(host="0.0.0.0", port=5000, debug=True)

啟動方式

cd video-detective-mvp
python -m venv .venv
# Windows: .venv\Scripts\activate
source .venv/bin/activate

pip install -r requirements.txt
python app.py

打開瀏覽器：http://localhost:5000/ ，MVP 已經能跑 UI + 查詢 + 時間軸 + 點影格。接下來可以逐步替換：

把 build_answer() 換成 RAG（把 topK candidates 丟給 Llama-3.2-90B-Vision / 或先用任一 LLM）

把 data/events.json 換成資料庫（SQLite / PostgreSQL）

把 text_score() 換成 Hybrid Search：

BM25（全文索引） + 向量索引（Qdrant/pgvector）

進階實用版本

✅ SQLite 儲存 events（含初始化與匯入）
✅ 向量欄位介面（先 stub，未來可無痛換 Qdrant / pgvector）
✅ 事件詳情 API（/api/event/<id>，支援多影格 / 證據）
✅ SQLite（事件資料庫）
✅ Qdrant（Hybrid：向量語意 + 關鍵字）
✅ /api/search + /api/event/<id> + /frames/...
✅ 前端 UI（查詢 → 時間軸 → 點事件 → 顯示 evidence + 多影格縮圖/預覽）
✅ ByteTrack「真正接法」我也給你兩種：可跑的簡易 IoU Tracker（保底） + ByteTrack
✅ Flask（單一服務）
✅ 影片抽幀（或直接讀 frames 資料夾）
✅ YOLO 偵測（Ultralytics）
✅ 追蹤（保底可跑 IoU Tracker；之後你只要替換 tracker 類別就能上 ByteTrack）
✅ 事件規則引擎（越線 / 闖入 / 停留）
✅ 自動寫入 SQLite（events.db）
✅ 自動重建 Qdrant 向量索引（可選：Qdrant 有開就做，沒開就跳過）
✅ 前端 UI 立刻能查到事件並點開影格

之後再補

✅ cooldown 去重機制（避免事件爆量）

✅ 事件合併（同一個 track 的闖入/停留合併成單一 event，帶 start/end）

✅ 把 VLM（Ollama Vision 90B）用於事件摘要：只對「關鍵事件」抽 1~3 張影格做語意補強（成本更可控）

結語：Vision 3.2 90B 為開源影片 AI 帶來新世代

Llama-3.2-90B-Vision 不只是「能看圖的 LLM」，而是讓：

影片搜尋
監控分析
行為理解
事件推論

真正進入 本地端、可控、可商業化 的時代，對於想打造「影片偵探」的團隊而言，它是目前開源世界中最具實力的選擇之一。

參考資料

https://mermaid.live

從監控到足球比賽追蹤-YOLO Face高速、準確、適用極端環境

Nvidia DGX Spark 安裝 Holo-3.1

環境

為什麼放棄 NVFP4 + vLLM

移除 NVFP4 模型快取

安裝 llama.cpp

1. 安裝編譯工具

2. 確認 CUDA Toolkit

3. Clone llama.cpp

4. 編譯 CUDA 版本

下載 Holo 3.1 GGUF 模型

單模型模式啟動

測試文字 API

測試圖片分析 API

已知問題：中文多模態輸出偶爾觸發解析錯誤

Router Mode：支援多模型切換

Router Mode 的記憶體策略

讓 llama.cpp 開機就執行

一、確認執行檔路徑

二、建立 systemd 服務

為什麼需要 RequiresMountsFor

三、啟用開機自動執行

四、查看即時日誌

五、測試 Router API

六、常用管理指令

啟動服務

停止服務

重新啟動

查看狀態

取消開機自動啟動

七、確認開機後是否真的自動啟動

八、改用 models.ini

九、避免 Ollama 開機後搶占記憶體

十、限制只允許內網連線

建議你現在直接執行的版本

參考資料

Llama-3.2-90B-Vision 實戰：本地端影片偵探與多模態分析完整解析

前言：為什麼要做「影片偵探」？

Llama-3.2-90B-Vision 模型簡介

核心規格與特點

什麼是「影片偵探」？

為何選擇 Llama-3.2-90B-Vision？

1️⃣ 本地端部署（On-Premise）

2️⃣ 高度客製化的影片理解流程

3️⃣ 可合法商業應用的開源模型

架構範例：影片偵探系統設計

線上體驗與 API 使用方式

實作系統

影片偵探 Prompt 範例（可直接用）

Prompt 1：單張關鍵影格「事件描述 + 可疑度」

Prompt 2：多張影格「跨時間軸事件摘要」

Prompt 3：使用者查詢「找片段 + 佐證」

YOLO + Vision 3.2 實作流程範例

Step 0：選擇部署模式

Step 1：影片 → 影格抽取（Frame Sampling）

Step 2：影格 → YOLO / yolo face 偵測（產生 metadata）

Step 3：挑關鍵影格（降低 VLM 成本）

Step 4：送進 Vision 3.2 做語意理解（Ollama 版本）

Step 5：事件彙整 + 建索引（讓你能「用中文搜影片」）

Step 6：查詢（RAG）→ 回答 + 佐證時間軸

你可以直接複製用的「最小資料結構」

frame_record

事件規則怎麼定義（越線 / 闖入 / 停留）

A. 共同前置：座標系與 ROI 設定

B. 越線（Tripwire Crossing）

C. 闖入（Intrusion into Restricted Zone）

D. 停留 / 徘徊（Loitering）

2) 追蹤器接 YOLO（track_id 穩定）

A. 建議組合

B. 最小資料流（你系統該長這樣）

3) 向量索引與查詢（embedding schema、RAG prompt）

A. 你要索引什麼？（兩層：frame-level + event-level）

B. 建議的 Embedding Schema（event-level）

C. 檢索策略（Hybrid Search）

D. RAG Prompt（查詢 → 回答 + 時間軸 + 點影格）

4) 簡單 Web UI（查詢 → 回傳時間軸 → 點開影格）

A. API 設計（後端）

B. 前端（純 HTML+JS 就能跑）

最小可跑的 Flask 後端實作（MVP）

static/index.html（直接用你前面 UI；這裡給一份可直接用的）

進階實用版本

為什麼需要 `RequiresMountsFor`