標籤: AI 工具

  • Plurality:在家自架你的 AI 中控台

    Plurality:在家自架你的 AI 中控台

    📌 本文重點

    • Plurality 是本地可自架的 AI 中控台
    • 同一介面整合聊天、腳本自動化與多代理協作
    • 透過沙盒與 MCP 打造安全可控的 AI Runbook 系統

    一句話定位:Plurality 是一個裝在你自己電腦或局域網裡的 AI 中控台,用同一個介面處理聊天、腳本自動化和多代理協作,而且完全開源、可本地部署。

    專案連結:https://github.com/azukaar/plurality (建議邊看文邊打開)


    核心功能:把「聊天 + 自動化 + 安全執行」塞進一個面板

    1. 一個介面同時管「聊天」和「背景自動化」

    Plurality 的定位很像「你自己架的 Slack + Jira + Runbook 執行器」,但全部交給 AI 來動。

    你可以在同一個 Web 介面裡:

    • 和 AI 助理聊天
    • 建立長期存在的 Agent(例如「專案助手」「報表助手」)
    • 為每個 Agent 配好自動化流程(Automation Flow),讓它在背景持續跑

    你可以這樣用:

    • 先在 Plurality 裡創一個「專案助理」Agent
    • 在聊天裡下達指令:「幫我建立一個每日 build 檢查流程」
    • 再把這段需求轉成 automation flow:每天定時跑腳本、整理結果、回報到同一個對話 Thread

    實際效果:你不再需要切來切去——一樣是在「跟 AI 聊天」,但對話可以變成「可重複、自動執行的任務」。

    💡 關鍵: 將常用對話轉成 automation flow,可把「會話」變成每天自動跑的固定任務,減少大量手動重複操作。

    行動建議:想像一下你現在最常對 ChatGPT 說的其中一件事(例如「整理日報」「幫我跑某個腳本」),這會是你在 Plurality 裡第一個要做成 Automation 的任務。


    2. 安全的 CLI + 檔案系統沙盒

    Plurality 支援讓代理在「沙盒環境」裡跑 CLI 命令、操作檔案,但重點是:

    • 可控制範圍:你可以只把某個專案資料夾掛載給該 Agent
    • 可審核:代理要執行敏感命令前,可以設成需要你點擊確認
    • 可記錄:所有命令和檔案操作都在介面裡看得到 log

    這意味著:

    • 開發者可以讓 Agent 幫忙跑測試、打包、整理 log
    • 知識工作者可以讓 Agent 在限定資料夾裡整理檔案、產出報告
    • 家用伺服器使用者可以讓 Agent 只碰 backup 資料夾,不碰其他東西

    你可以這樣設定:

    1. 在 Plurality 的設定中,新增一個「Project」或「Workspace」
    2. /home/你/某個專案 或 NAS 的某個共享資料夾掛載給這個 Workspace
    3. 建立 Agent 並指定它只能使用這個 Workspace
    4. 開啟「命令前需要確認」(如果你怕它亂改東西)

    行動建議:先選一個「就算搞壞也不會心痛」的資料夾,當作 Agent 測試用沙盒,把 CLI 操作和檔案操作都限制在這裡。


    3. 搭配 MCP、多代理協作,變成你的「個人 Jira + Runbook 執行器」

    Plurality 支援 MCP(Model Context Protocol)等多代理協作生態,你可以把它當成一個統一入口,接上:

    • 不同工具的 MCP 伺服器(例如資料庫查詢、Issue 管理、監控系統)
    • 多個 Agent 各自負責不同任務

    用白話來說:

    • 「像 Jira 一樣」:你可以把每個自動化流程當成一個 Ticket / 任務
    • 「像 Runbook 一樣」:每個任務裡,是具體的步驟(腳本、API調用、檔案處理)
    • Plurality 的 Agent 負責:讀任務 → 選工具 → 執行 → 回報結果

    實際用法例子:

    • 一個「監控 Agent」:定時讀監控 API → 判斷是否異常 → 若異常就呼叫「Runbook Agent」
    • 「Runbook Agent」:按你寫好的流程,連線伺服器、跑腳本、紀錄在一個對話 Thread 裡

    行動建議:先想一個你現在「寫在 Notion / Wiki 的 Runbook」,例如「網站掛掉怎麼檢查」,把它拆成步驟,交給 Plurality Agent 來執行一次看看。


    適合誰用?三個具體場景

    1. 開發者:用 Plurality 管專案腳本

    適合這樣的人:

    • 手上有一堆 npm script / Makefile / shell script
    • 常常要:跑測試、打包、部署、整理 log

    實際流程可以長這樣:

    • 在 Plurality 裡建立一個「專案 Dev Agent
    • 掛載你的專案資料夾(例如 /projects/my-app
    • 讓 Agent:
    • 用 CLI 跑 npm test,把錯誤訊息整理貼回聊天
    • 根據你的指示修改設定檔或產出新腳本(在沙盒裡)
    • 定時跑 lint + test 並生成報告

    你每天要做的事情,就變成:開 Plurality → 問「今天 CI 有沒有紅?」→ 讓 Agent 調出 log 給你看。

    💡 關鍵: 讓 Agent 接管 npm testlint 等例行腳本,可把日常 CI/開發檢查集中在單一對話介面完成。


    2. 知識工作者:整理檔案 + 做定時報告

    適合這樣的人:

    • 每週要交固定報告(營運簡報、數據摘要、內容整理)
    • 桌面 / NAS 上堆滿 PDF、Word、報表 CSV

    你可以這樣設計一個 Agent:

    • 掛載「報表資料夾」給它(例如 Reports/Weekly
    • 每天或每週固定時間:
    • 掃描新檔案
    • 自動分類命名(根據檔名、內容)
    • 生成一份文字摘要(例如本週營運重點、會議紀錄整理)
    • 寄出 Email 或貼到公司內網

    整套流程變成:你只要把資料丟進資料夾,其它交給 Plurality。


    3. 自架家用伺服器:備份 + 監控

    如果你有自己的 NAS 或家用伺服器(例如和 Livinity 這種 homeserver OS 類似的架構),Plurality 很適合當成「AI 管家」。

    可以做的事情:

    • 每天半夜:
    • 檢查共享資料夾是否有新檔
    • 壓縮後備份到另一顆硬碟或雲端
    • 寫 log + 總結備份結果
    • 每小時:
    • 跑監控腳本(例如檢查 Docker 容器、硬碟空間)
    • 若異常,透過 Email / Telegram 通知你

    這些都可以用 Plurality 的 automation flow + CLI 沙盒來完成,而且所有設定都留在你自己的網路裡。

    💡 關鍵: 把備份與監控自動化放進局域網,能在不依賴外部服務的前提下,建立可審計又可控的「AI 管家」流程。


    15 分鐘入門:從 clone 到第一個 Automation Flow

    下面用一個具體目標來帶你:每天抓 RSS → 總結 → 寄信

    步驟 0:準備環境(2 分鐘)

    需求:

    • 一台可以跑 Docker 的機器(你的電腦、NAS 或家用伺服器)
    • 至少一個可用的模型:
    • 本地:Ollama / LM Studio / 其他本地 LLM 伺服器
    • 雲端:OpenAI / Claude 等(有 API key)

    行動:先確認你有 Docker 和一個模型 API(或已裝好 Ollama)。


    步驟 1:拉 GitHub repo + 啟動(5 分鐘)

    1. 開啟 GitHub 專案:https://github.com/azukaar/plurality
    2. 在你的機器上:
    git clone https://github.com/azukaar/plurality
    cd plurality
    
    1. 使用 Docker(以官方 README 為準,但大致會是):
    docker compose up -d
    
    1. 打開瀏覽器,進入 http://你的機器 IP:PORT(通常 README 會寫預設 port)

    行動:先確認你能看到 Plurality 的 Web 介面,並完成初次設定帳號。


    步驟 2:連上本地或雲端模型(3 分鐘)

    在 Plurality 介面的設定裡(通常是「Models」「LLM Providers」之類):

    • 如果你用本地模型(例如 Ollama):
    • 填入 Ollama 的 URL(例如 http://host.docker.internal:11434
    • 選一個模型(llama3 等)
    • 如果你用雲端模型:
    • 選 OpenAI / Anthropic 等
    • 貼入 API key

    接著:

    • 建立一個「預設 Agent」
    • 開一個新聊天,隨便問一個問題,確認模型回應正常

    行動:測一次聊天,確定模型接上沒問題,再往下做自動化。


    步驟 3:設定第一個 Automation Flow:RSS → 總結 → 寄信(5 分鐘)

    以概念步驟為主,實際操作依 Plurality 當前 UI 為準(版本更新可能略有差異):

    1. 建立一個 Agent(例如叫 RSS Reporter):
    2. 權限:允許網路請求(抓 RSS)
    3. 若需要寄信,先在設定裡填好 SMTP 或 Webhook(視官方檔案支援的方式)

    4. 建立 Automation Flow

    5. 觸發條件:每日某個時間(例如 09:00
    6. 步驟設計(可用自然語言描述給 Agent,再微調):

      1. 抓取指定 RSS(例如科技新聞、公司部落格)
      2. 解析最近 24 小時的新文章
      3. 用模型生成摘要:
        • 列出 3-5 則重點
        • 每則一段話說明「為什麼重要」
      4. 把摘要整理成一封 Email 內容
      5. 呼叫 SMTP/Email 工具寄給你
    7. 測試一次

    8. 不用等明天,先在介面裡手動 Run 這個 Flow
    9. 檢查 log 和 Email 是否如預期

    行動:先用你最常看的其中一個 RSS 做範例,例如你公司部落格或常看的技術網站。


    小結:把「雜事」搬進你自己的局域網裡

    Plurality 的核心價值在於:

    • 一個介面聚合聊天 + 自動化 + 多代理
    • 可以讓 AI 真正「動手」跑 CLI、操作檔案,但仍在你可控的沙盒裡
    • 搭配 MCP、多代理協作,把原本散在各處的腳本、Runbook 和任務,集中到一個你自己掌控的中控台

    如果你本來就有自架 NAS、家用伺服器,或公司內網伺服器,Plurality 很適合直接變成「AI 操作台」;如果你只是想找個比 ChatGPT 更能「實際做事」的工具,也可以先在自己電腦上跑一個 Plurality,從那個 RSS → 總結 → 寄信的 Flow 開始。

    下一步行動:打開 https://github.com/azukaar/plurality,照本文的 15 分鐘流程做出你的第一個 Automation Flow,之後再慢慢把日常重複工作移進去。

    🚀 你現在可以做的事

    • 打開 Plurality 專案頁,用 git clone 把專案拉到本機或 NAS
    • 準備好一個可用模型(例如設定好 Ollama 或貼入 OpenAI / Claude API key),完成第一次聊天測試
    • 挑一個你每天重複做的流程(如 RSS 摘要、報表整理),在 Plurality 裡實作成第一個 Automation Flow
  • OmniRoute:一個 Endpoint 玩遍 200+ 模型

    OmniRoute:一個 Endpoint 玩遍 200+ 模型

    📌 本文重點

    • OmniRoute 用一個 Endpoint 串接 200+ 模型供應商
    • 內建 RTK + Caveman 壓縮,可節省 15–95% token 成本
    • 支援 MCP / A2A、多代理、多模態 Workflow
    • 適合多模型整合與成本優化的開發者

    用一句話先說清楚:OmniRoute 是一個多雲、多模型的一站式 AI 總機,讓你用同一個 API Endpoint,同時接上 Claude、GPT、Cursor、Copilot 等 200+ 家模型供應商,還順手幫你壓縮 token、自動跳備援模型。

    官方開源庫:https://github.com/diegosouzapw/OmniRoute


    核心功能 1:一個 Endpoint 管理多供應商+自動備援

    傳統做法是:每接一個模型,就要再接一個 SDK / API Key / Base URL。結果是:

    • 前端要切換模型,就得改環境變數
    • 後端要做 fallback,要自己寫 retry + 陣痛的錯誤處理

    OmniRoute 的做法是:所有模型統一走一個 OmniRoute Endpoint,後面怎麼分流、切換供應商、失敗改用誰,全都在 OmniRoute 的設定檔完成。

    💡 關鍵: 把所有模型統一進一個 Endpoint,可以一次解決多家供應商整合與備援問題,前後端只維護單一接點。

    你可以怎麼用

    以「同一個 Code Agent,要能在 Claude / GPT / 本地模型之間切換」為例:

    1. 在 OmniRoute 設定三個 provider:
    2. anthropic/claude-3.5(主力)
    3. openai/gpt-4.1(備援)
    4. local/deepseek(成本最低版)
    5. 設定路由策略:
    6. 主 Endpoint:先走 Claude
    7. 當 Claude timeout 或額度用完,自動 fallback 到 GPT
    8. 夜間批量任務改走本地模型
    9. 在你的程式碼中,只保留一個 OMNIROUTE_API_URL

    ts
    const response = await fetch(process.env.OMNIROUTE_API_URL, {
    method: "POST",
    headers: {
    "Content-Type": "application/json",
    "Authorization": `Bearer ${process.env.OMNIROUTE_API_KEY}`,
    },
    body: JSON.stringify({
    model: "code-agent", // 這是 OmniRoute 裡定義的邏輯模型名
    messages,
    }),
    });

    可行動建議

    • 手上的專案如果同時接了 Anthropic + OpenAI + 本地模型,可以先挑一個 API Call 練手,把三個 Base URL 改成一個 OmniRoute URL,測試 auto-fallback 是否生效。

    核心功能 2:RTK + Caveman 壓縮,節省 15–95% token 成本

    OmniRoute 內建兩種壓縮:

    • RTK(Reversible Tokenization Kernel):對常見 prompt 做結構化壓縮,適合長系統提示、多輪聊天歷史
    • Caveman 壓縮:偏「野蠻」但更激進,會重寫聊天記錄,把冗長表述變成精簡語句

    效果:

    • 系統長 prompt:省 15–40% token
    • 帶大量上下文(如文檔 QA):最高可到 95% token 減少

    💡 關鍵: 啟用 RTK 與 Caveman 壓縮後,長上下文任務可大幅降低 15–95% token 成本,直接反映在帳單與模型限額上。

    你可以怎麼用

    以「把整份 API 文檔塞給模型當『長期記憶』」為例:

    1. 在 OmniRoute 後台或設定檔,為 doc-assistant 這條路由開啟壓縮:

    yaml
    routes:
    - id: doc-assistant
    model: anthropic/claude-3.5
    compression:
    rtk: true
    caveman: true

    1. 程式端依然用原本的 messages 結構呼叫,不用自己壓縮:

    jsonc
    {
    "model": "doc-assistant",
    "messages": [
    {"role": "system", "content": "你是某某專案的文檔助手..."},
    {"role": "user", "content": "請根據附件 API 文檔..."}
    ]
    }

    1. OmniRoute 會在轉給底層模型前自動壓縮,再在輸出時解壓(對你來說是透明的)。

    可行動建議

    • 先挑「最長」的那支 API(例如:聊天歷史超長、帶多篇 PDF 的 QA),在 OmniRoute 上開 RTK+獵人模式(Caveman),觀察一次請求的 token 使用量與帳單變化。

    核心功能 3:MCP / A2A、多代理、多模態 Workflow

    OmniRoute 支援:

    • MCP(Model Context Protocol):讓不同工具 / 代理共享同一套上下文與工具列表
    • A2A(Agent-to-Agent):代理之間可互相呼叫,形成多步驟協作
    • 多模態 API:文字 + 圖片(甚至影音)混合輸入

    這讓你可以把原本散落在不同工具的能力,集中到一條 Workflow 裡。例如:

    • Code Agent 負責寫程式
    • Doc Agent 負責查文件、對比版本
    • Vision Agent 負責讀錯誤截圖

    💡 關鍵: 利用 MCP 與 A2A,可以把多個專職 Agent 串成一條 Workflow,讓 Code、Doc、Vision 等能力在同一上下文中協作。

    你可以怎麼用

    以「Side Project 的 Code Agent + 文檔助手」為例:

    • Code Agent:
    • 模型:Claude 3.5 Sonnet
    • 任務:生成程式碼、重構
    • 文檔助手:
    • 模型:GPT-4.1 / Gemini
    • 任務:閱讀 API 文檔、產生說明
    • 多模態:
    • 模型:如 Gemini / GPT-4o
    • 任務:讀錯誤截圖

    在 OmniRoute 裡定義三條路由,讓 Code Agent 能直接「轉接」給 Doc Agent:

    routes:
      - id: code-agent
        model: anthropic/claude-3.5
        a2a:
          doc-agent: true
          vision-agent: true
      - id: doc-agent
        model: openai/gpt-4.1
      - id: vision-agent
        model: google/gemini-1.5
    

    可行動建議

    • 先只做兩個代理(Code + Doc),在 OmniRoute 設定 A2A,讓 Code Agent 遇到「不知道 API 用法」時,把問題轉給 Doc Agent,再把結果回傳給使用者。

    實作示範:Side Project 串三家模型的 Code Agent + 文檔助手

    來做一個具體場景:

    需求:在同一個 Side Project 裡,整合三家模型,做一個簡單的「程式碼助理 + 文檔助手」,前端只有一個 Chat UI,後端只有一個 OmniRoute Endpoint。

    架構示意

    • 前端(Next.js / React):
    • 單一聊天框
    • 輸入模式按鈕:寫程式 / 問文檔
    • 後端:
    • 全部請求送到 OMNIROUTE_URL
    • model 欄位用來指定走哪個 logical route(code-agent or doc-assistant
    • OmniRoute:
    • code-agent → Claude(主)+ GPT(備)
    • doc-assistant → GPT + Caveman 壓縮
    • vision-agentGemini,多模態

    前端呼叫範例(TypeScript):

    async function callAgent(mode: "code" | "doc", messages) {
      const model = mode === "code" ? "code-agent" : "doc-assistant";
    
      const resp = await fetch(process.env.NEXT_PUBLIC_OMNIROUTE_URL!, {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          Authorization: `Bearer ${process.env.NEXT_PUBLIC_OMNIROUTE_KEY}`,
        },
        body: JSON.stringify({ model, messages }),
      });
    
      return resp.json();
    }
    

    後端與前端都不用知道「底下到底是 Claude 還是 GPT」,只認 model: "code-agent"model: "doc-assistant" 兩種邏輯角色即可。


    10 分鐘開箱:從零到第一條 OmniRoute

    以下是一條「最短路徑」,讓你在 10 分鐘內把現有專案換成 OmniRoute。

    1. 註冊與安裝(3 分鐘)

    1. 打開 GitHub 專案:https://github.com/diegosouzapw/OmniRoute
    2. repo 拉下來:

    bash
    git clone https://github.com/diegosouzapw/OmniRoute
    cd OmniRoute
    pnpm install # 或 yarn / npm

    1. README 建一個 .env,填入你現有的 OpenAI / AnthropicAPI Key

    2. 啟動 OmniRoute Server(2 分鐘)

    pnpm dev # 或對應的 start 指令
    

    啟動後會有一個本地 URL,例如:http://localhost:8787/v1/chat/completions,這就是你的「總機 Endpoint」。

    3. 設定第一個路由 + 壓縮策略(3 分鐘)

    config/routes.yaml(實際以專案為準)中:

    routes:
      - id: code-agent
        model: anthropic/claude-3.5
        fallback:
          - openai/gpt-4.1
        compression:
          rtk: true
          caveman: false
    
      - id: doc-assistant
        model: openai/gpt-4.1
        compression:
          rtk: true
          caveman: true
    

    完成後重新啟動 OmniRoute(若需要)。

    4. 把前端 / 後端改成單一 OmniRoute URL(2 分鐘)

    無論你原本用什麼 SDKOpenAI, Anthropic, Cursor plugin):

    • baseURL 改成你的 OMNIROUTE_URL
    • model 改成 OmniRoute 裡定義的 id(例如 code-agent

    以 OpenAI SDK 為例:

    import OpenAI from "openai";
    
    const client = new OpenAI({
      baseURL: process.env.OMNIROUTE_URL,
      apiKey: process.env.OMNIROUTE_KEY,
    });
    
    await client.chat.completions.create({
      model: "code-agent",
      messages,
    });
    

    到這一步,你已經:

    • 用一個 Endpoint 串起至少兩家模型
    • 開啟 basic 的 token 壓縮
    • 為之後加上更多 provider / 代理 / 模態預留位置

    適合誰用?

    使用者類型 具體場景
    獨立開發者 Side Project 同時想用 Claude + GPT + 免費模型,又懶得寫一堆整合
    小團隊 / Startups 想 A/B 測試不同供應商,控制成本,還要有 auto-fallback 防止掛點
    AI Agent Builder 需要多代理協作(Code + Doc + Vision),又希望前端只接一個 Endpoint
    教學 / 實驗環境 需要一鍵切換教學用模型、控制學生 token 使用量

    如果你符合其中一項,可以先把 OmniRoute 當成:

    「把所有 AI 模型集中管理的一支 API Gateway」,再視需要逐步開啟壓縮、A2A、多模態。


    OmniRoute 與其他多模型工具比較

    名稱 核心功能 免費方案 適合誰
    OmniRoute 多供應商整合、auto-fallback、RTK/Caveman 壓縮、MCP/A2A、多模態 開源,支援 50+ 免費供應商 想統一管理多家模型、做複雜 Workflow 的開發者
    直接用 OpenAI 單供應商模型 API 有免費試用額度 只用 GPT 系列、需求簡單的專案
    直接用 Anthropic 單供應商 Claude 模型 有免費試用額度 只想專注 Claude Code / Sonnet

    如果你只接一個模型供應商,OmniRoute 可以先當「統一壓縮 + 路由層」;當你的模型越來越多,它就自然變成你的多雲總機。


    🚀 你現在可以做的事

    • 打開 OmniRoute GitHub 專案,依照 README 在本地啟動一個測試伺服器
    • 挑一支現有的 API 呼叫,將 baseURL 改成 OMNIROUTE_URL,並在 routes.yaml 設好對應的 model id
    • 在同一條路由上開啟 RTKCaveman 壓縮,對比啟用前後的 token 使用量與費用差異
  • 開源 ATS 開箱:先讓機器 HR 幫你看履歷

    開源 ATS 開箱:先讓機器 HR 幫你看履歷

    📌 本文重點

    • 用開源 ATS 在本機跑出「機器 HR」打分
    • 依關鍵字與技能結構優化履歷匹配度
    • 求職者與小團隊都能部署透明可調的初篩系統
    • 先用機器視角迭代履歷再正式投遞

    只要幾行指令,就能在自己電腦跑一套「機器 HR」,用 HackerRank 開源 ATS 先幫你打分履歷,再送出求職申請。

    HackerRank 把自家 ATS 開源的故事原文在這裡,我們直接站在求職者和小團隊 HR 的角度,拆解它怎麼打分,和怎麼自己動手部署。


    核心功能:機器 HR 怎麼看你的履歷

    先弄清楚這套 ATS 的「腦袋」在想什麼,才知道怎麼改履歷讓分數往上。

    1. 關鍵字與職缺匹配

    它會做的事:
    – 把履歷和職缺描述切成一堆 token(關鍵字、詞組)
    – 比較兩邊出現的技能、職稱、技術名詞的重疊程度
    – 依照權重算出一個匹配分數(例如:核心技能比軟性能力更重)

    💡 關鍵: ATS 核心是「關鍵字重疊+權重」,沒有寫出來的技能就等於不存在。

    你可以馬上做的事:
    – 打開你常投的職缺 JD,列出 10–20 個明顯關鍵字(如 ReactKubernetesCFA
    – 確認這些詞真的出現在履歷裡,而且出現在工作經驗技能欄位,不是藏在自我介紹
    – 同一樣技能最好在不同段落被提到 2 次以上(職稱+專案細節),讓匹配度更高

    2. 技能欄位結構化

    它會做的事:
    – 嘗試從履歷中識別「專業技能」「工具」「程式語言」等區塊
    – 把識別出的技能映射到內建或自訂的技能字典
    – 根據技能的完整度和與職缺關聯度加分

    你可以馬上做的事:
    – 把零散的技能文字改成明確的「Skills」區塊,用條列式呈現:
    – Programming: Python, Go, TypeScript
    – Data: SQL, Pandas, Airflow
    – DevOps: Docker, Kubernetes, GitHub Actions
    – 避免寫成長句:「熟悉各種前端技術如 React、Vue 等」改成獨立列出每一項

    3. 格式與可解析度

    它會做的事:
    – 先把 PDF 或 DOCX 轉成純文字
    – 檢查是否有標題層級(Education、Experience、Skills 等)
    – 看日期、公司名稱、職稱是否容易被解析出來

    你可以馬上做的事:
    – 優先使用 簡單排版的 PDF(少用圖表和多欄版面)
    – 每段工作經驗保持統一格式,例如:
    公司名稱 | 職稱 | 2020-01 – 2023-06
    – 標題請明寫 Work ExperienceEducationProjects,不要用太創意的命名


    適合誰用:兩個典型場景

    場景 1:求職者自己跑 ATS,迭代履歷

    適合你如果:
    – 正在密集投履歷,但不知道為何常被系統一輪刷掉
    – 想在投出去前,先用「機器 HR」視角檢查履歷

    具體可以這樣用:
    1. 在本機或雲端部署 HackerRank 開源 ATS
    2. 匯入你目前版本的履歷 + 目標職缺描述
    3. 看系統產出的匹配分數與分析報告(常見會有:技能命中率、關鍵字缺漏、段落可讀性)
    4. 依照缺漏項目,調整履歷內容:補技能、重寫專案描述
    5. 重跑一次,看分數是否明顯提升

    這種「跑分 → 改履歷 → 再跑分」的迭代,能讓你迅速找出哪些描述是 ATS 看不懂的,避免被系統誤殺。

    💡 關鍵: 把 ATS 當「迭代工具」而不是一次性評分,才能持續拉高履歷表現。

    場景 2:小團隊 / 初創接到自家招聘網站

    適合你如果:
    – 公司還沒預算買商用 ATS,但已經有基本招聘網站或表單
    – 想要自動化「履歷初篩」,又希望演算法透明可調整

    具體可以這樣用:
    1. 把開源 ATS 部署在公司雲端(例如一個獨立的 VM 或 Kubernetes namespace)
    2. 在招募網站的投遞表單,增加一個後端步驟:
    – 收到履歷檔案 -> 呼叫 ATS API -> 存分數與解析結果到資料庫
    3. 對 HR 顯示:
    – 依分數排序的候選人列表
    – 每人的技能命中明細(例如:符合 8/10 必備技能)
    4. HR 可以手動調整各職缺的權重設定,例如:某職缺重視 Python 多於 Java,再重跑分數

    這套流程的好處是:你可以完全看到打分邏輯,調整職缺與技能字典,不會被黑盒演算法綁死。


    怎麼開始:從 GitHub 到第一份跑分履歷

    以下以一般開源 ATS 專案為例,示範本機快速部署與基本操作。實際路徑請以 HackerRank 公佈的 GitHub repo 為準(可以從原文 danunparsed 的文章 追過去)。

    步驟 1:取得程式碼(GitHub)

    1. 確認電腦已安裝:
    2. Git
    3. Docker 或至少 Python 3.9+
    4. 從 GitHub 取得程式碼:

    bash
    git clone https://github.com/hackerrank/open-ats.git
    cd open-ats

    1. 用檔案總管打開專案,先看 README.md,通常會列出:
    2. 必備環境
    3. 快速啟動指令
    4. API 說明

    步驟 2:快速部署(本地或雲端)

    選項 A:本機 Docker 一鍵跑起

    如果 README 提供 Docker Compose:

    docker compose up -d
    

    然後打開瀏覽器到 http://localhost:8000(實際 port 依專案設定),通常會看到:
    – 簡單的 Web 介面可以上傳履歷
    – 或至少有 API 文檔(Swagger / OpenAPI)

    選項 B:雲端輕量部署

    如果想在雲端跑,方便給 HR 或朋友共用:

    1. 在 Render / Railway / Fly.io 之類平台建立新服務
    2. 連接你的 GitHub repo
    3. 在設定中填入:
    4. Build command:如 docker build .pip install -r requirements.txt
    5. Start command:如 uvicorn main:app --host 0.0.0.0 --port 8000
    6. 部署完成後,平台會給你一個公共 URL,當作 ATS API 入口

    💡 關鍵: 雲端部署加一個公共 URL,就能立刻變成多人共用的履歷初篩服務。

    步驟 3:丟入第一份履歷測試

    假設 ATS 提供一個 /score API,可以這樣測試(具體路徑依專案為準):

    curl -X POST \
      https://your-ats-url/score \
      -F "resume=@/path/to/resume.pdf" \
      -F "job_description=@/path/to/jd.txt"
    

    你會拿到一個 JSON 回應,常見欄位可能是:

    {
      "total_score": 82,
      "keyword_match": {
        "required": 10,
        "matched": 8
      },
      "skills": {
        "python": true,
        "docker": false,
        "react": true
      },
      "notes": [
        "Missing keyword: Kubernetes",
        "No explicit mention of SQL",
        "Work experience dates parsed successfully"
      ]
    }
    

    步驟 4:看懂分數,對症調整

    拿到分數後,重點不是「幾分」,而是怎麼據此改履歷:

    1. 先看缺漏的技能與關鍵字
    2. 每個 falsemissing 的技能,對照職缺 JD 是不是你真的會但沒寫
    3. 能做到的就明確寫進「Skills」或「工作成果」段落
    4. 再看解析失敗的欄位
    5. 如果 notes 提到日期無法解析,調整成標準格式
    6. 公司名、職稱盡量獨立成一行,不要混在長句
    7. 最後看總分變化
    8. 每次改完重跑,記錄分數變化和修改內容
    9. 找到「加分效率最高」的修改方式,往那個方向優化

    總結:先學會用機器 HR 的語言說話

    HackerRank 把自家 ATS 開源,等於把機器 HR 的打分標準攤在你面前。你可以:
    – 當求職者:在本機或雲端跑一套 ATS,先自測履歷再投遞
    – 當小團隊 HR:把 ATS 接到自家網站,建立透明可調整的初篩機制

    真正有用的做法不是「迎合演算法」,而是讓履歷把你的能力說清楚,並且用機器看得懂的結構寫出來。先跑幾次分數,你很快就會掌握那套語言。

    🚀 你現在可以做的事

    • 打開常投職缺 JD,整理出 10–20 個關鍵字,對照並重寫自己的履歷結構
    • 到 GitHub 搜尋 HackerRank 開源 ATS 專案,依 README.md 在本機或雲端部署測試
    • 跑一輪「改履歷 → 用 /score API 重測 → 比較分數變化」,記錄哪類修改最有效
  • 讓費曼幫你開會:高智議會實戰

    讓費曼幫你開會:高智議會實戰

    📌 本文重點

    • 18 位 AI 專家人格協作,幫你拆解困難決策
    • 支援多家 LLM,多模型協同辯論與決策
    • 結構化多輪會議流程,適合產品、工程與職涯抉擇
    • 10 分鐘內可在本機跑起第一個 /council

    一句話定位:Council of High Intelligence 是一個「多人格、多模型的開源決策助手」,讓亞里斯多德、費曼、卡尼曼、Torvalds 等 18 位 AI 專家分工辯論,幫你把困難決策拆開分析。

    GitHub 專案連結:https://github.com/0xNyk/council-of-high-intelligence


    核心功能:它到底幫你做什麼?

    1. 18 位 AI 專家人格,替你「開會」

    這個專案內建 18 個 AI persona,例如:

    • 費曼:擅長把複雜問題拆小,用白話解釋
    • 卡尼曼:偏向風險、決策偏誤、心理學角度
    • Torvalds:工程實作與系統設計視角
    • 亞里斯多德:偏向邏輯與倫理推理

    💡 關鍵: 18 位專家人格讓同一個問題從多角度被拆解與辯論,比單一模型更接近真實開會決策。

    你只需要:

    1. 想好你要決策的問題(例如:「我要選哪個前端框架?」)
    2. 用一行指令 /council + 問題
    3. 看不同人格怎麼辯論、反駁、收斂結論

    可行動點:先在腦中列出你最近最卡的一個決策,用一句話描述,等會在「怎麼開始」裡直接拿來當第一條指令。


    2. 多家 LLM 供應商,真正「多模型」討論

    官方描述:

    18 AI personas deliberate your hardest decisions across multiple LLM providers.

    意思是:你可以把不同角色綁到不同家模型,例如:

    • 深度推理角色 → 使用 OpenAI / Claude / DeepSeek
    • 技術細節角色 → 使用本地 Qwen / LLaMA
    • 檢查與總結角色 → 使用另一家 API

    這樣比起「一個模型演完全部人格」,更接近多人開會:不同模型偏好不同風格、推理路線也不同。

    可行動點:先決定你要用哪幾種 LLM 來源:

    • 沒有 GPU:先用雲端(OpenAI、Anthropic、DeepSeek 等)
    • 有本地 GPU:用本地模型 + 雲端模型混用

    .env 裡填 API key 即可(下文會示範)。


    3. 結構化多輪討論,不是單次回答

    這不是「問一次、回一段」的聊天,而是預設有多輪辯論流程

    1. 第一輪:各專家給出初步立場
    2. 中間:互相質疑、補充證據、提出 alternative
    3. 最後:整合成具體建議 + 原因拆解

    你可以把它想成一個腳本化的「會議流程模版」,每次 /council 就是啟動一次完整會議。

    可行動點:在準備問題時,用「決策問題」的格式描述:

    • A vs B 的選擇(框架、技術、工作)
    • 有限制條件(時間、預算、人力)
    • 希望輸出形式(表格、清單、分階段建議)

    適合誰用?三個典型場景

    💡 關鍵: 產品經理、工程師與個人職涯決策者,都可以用同一套會議流程模版,快速得到結構化建議。

    1. 產品經理:產品選型 / 路線決策

    情境

    • 要在「先做 Web 還是先做 App」中選一個
    • 要評估「自研 vs 採用 SaaS」

    你可以這樣用:

    /council 幫我評估:我們是一個 B2B SaaS,新功能是「客戶成功儀表板」。
    選項 A:在現有產品裡做一個輕量 dashboard。
    選項 B:做成獨立子產品,單獨收費。
    
    條件:
    1. 團隊 6 人,前端 2、後端 2、產品 1、設計 1
    2. 期望 3 個月內能驗證市場
    3. 優先考慮現有客戶的 adoption 風險
    
    請從產品策略、商業模式、技術風險三個角度辯論,最後給一個推薦選項與 roadmap。
    

    行動建議:把你手上的下一個 roadmap 爭議點,寫成「A vs B + 條件」格式,直接餵給 /council


    2. 工程師:技術方案比較 / 架構選擇

    情境

    • 要決定「單體服務 vs 微服務」
    • 比較「使用 Rust / Go / Java 實作」

    例如:

    /council 我要設計一個高併發 API 服務, QPS 目標 5k,
    選項 A:使用 Go + Gin + Redis
    選項 B:使用 Rust + Axum + Redis
    
    約束:
    - 團隊目前主要會 Go,沒人寫過 Rust
    - 上線時間壓力大,希望 2 個月內可上線 MVP
    
    請從開發效率、長期維護成本、性能需求三個角度辯論,
    最後給出推薦技術棧與風險清單。
    

    行動建議:先把你準備寫在技術設計文檔裡的「方案對比」,丟給高智議會,看看它會怎麼拆解風險與權衡因素。


    3. 個人:職涯抉擇 / 學習路線

    情境

    • 「要不要跳槽?」
    • 「要走管理還是繼續寫程式?」

    使用示例:

    /council 我現在是一名 5 年資歷的後端工程師,
    手上有兩個選擇:
    A:留在現在公司,穩定但成長有限
    B:加入一間早期 AI 新創,薪水略高但不確定性大
    
    條件:
    - 已婚,有小孩,家庭支出固定
    - 想在 3 年內成為資深工程師或 Tech Lead
    
    請從職涯風險、技能成長、財務安全三個角度辯論,
    給我具體建議與行動計畫。
    

    行動建議:把你最近在朋友群裡反覆抱怨的那個職涯問題,寫成 A/B 選擇 + 三個條件,讓「高智議會」幫你理一次。


    怎麼開始:從 GitHub clone 到第一個 /council

    以下以一般開發者環境(macOS / Linux)為例,步驟盡量壓縮到 10 分鐘內能跑起來。


    步驟 0:準備環境

    先確認:

    • 已安裝 git
    • 已安裝 Python 3.10+ 或專案要求版本(請以 repo README 為準)
    • 有一組可用的 LLM API key(例如 OpenAI / DeepSeek)

    行動:如果沒有 Python,可以先裝 pyenv 或用你習慣的版本管理工具準備一個環境。


    步驟 1:Clone 專案

    git clone https://github.com/0xNyk/council-of-high-intelligence.git
    cd council-of-high-intelligence
    

    行動:在你常用的開發目錄執行上述指令,打開專案資料夾準備配置。


    步驟 2:建立虛擬環境並安裝依賴

    python -m venv .venv
    source .venv/bin/activate  # Windows 使用 .venv\Scripts\activate
    pip install -r requirements.txt
    

    如果 README 有指定使用 poetry 或其他工具,請以官方文件為準。

    行動:成功後,執行 python -V 確認你現在在虛擬環境內。


    步驟 3:設定 LLM 提供商(API key)

    專案通常會有範例環境檔,例如 .env.exampleconfig.example.yaml

    1. 複製範例檔:
    cp .env.example .env
    
    1. 打開 .env,填入你的 API key,例如:
    OPENAI_API_KEY=sk-xxxx
    # 或使用其他提供商
    DEEPSEEK_API_KEY=xxxx
    ANTHROPIC_API_KEY=xxxx
    
    1. 若專案支援多模型,你可以在設定檔裡定義:

    2. 哪個 persona 用哪個 provider

    3. 模型名稱(例如 gpt-4.1, deepseek-chat 等)

    行動:至少先填一組你最熟悉的 API key,確保可以跑通第一個會議。


    步驟 4:啟動「高智議會」

    依專案設計,啟動方式可能是 CLI 或 TUI,常見格式如下(請對照 README):

    python main.py
    # 或
    council
    

    啟動後,終端可能會顯示類似:

    Welcome to the Council of High Intelligence.
    Type /council to start a new deliberation.
    

    行動:如果啟動失敗,先檢查:

    • Python 版本是否符合
    • requirements.txt 是否安裝完整
    • .env 是否存在且變數名稱拼寫正確

    步驟 5:發出你的第一條決策指令

    在終端中輸入:

    /council 幫我決定,接下來三個月我要把下班時間花在什麼事情上:
    A:寫 side project,目標是做一個小型 SaaS
    B:準備跳槽,用來刷 LeetCode 和整理履歷
    
    條件:
    - 每天大約只有 1.5 小時可用
    - 希望一年後收入有明顯提升
    請從時間投入風險、學習成長、現金回報三個角度辯論,最後給具體計畫。
    

    你應該會看到:

    • 多個角色輪流發言
    • 中間互相質疑、補充
    • 最後一位「主持人」整合結論與行動步驟

    行動:把這次輸出的結論,轉成你今天可以實際做的一件小事(例如:「今晚先列出三個 side project 題目」)。


    延伸:和多代理系統、雙 GPU 的連結

    如果你手上有多 GPU,或對 multi-agent 有興趣,可以參考這兩個方向:

    • 多 GPU 並行推理(參考 r/LocalLLaMA 貼文):
    • 用一個較大模型當 orchestrator,
    • 多個小模型當子代理,平行處理不同 persona。
    • 安全領域應用:像 VulnClaw 這類多代理滲透測試框架,將「多角色協作」搬到資安自動化場景。

    如果你本來就在玩多代理框架(如 MCP、各種 agent 工具),高智議會可以作為「決策模組」,專門負責:

    • 需求澄清與任務拆解
    • 方案比較與風險評估
    • 最後做出一個「可執行決策」交給其他 agent 落地

    最後的可行動點

    1. 先 clone 下來跑一次 /council
    2. 把你日常最常卡的那種決策(技術選型 / 職涯 / 產品路線),固定丟進去
    3. 觀察 1–2 週,看它是否幫你減少「反覆糾結」的時間

    把開會交給費曼們,你多一點時間去執行。


    🚀 你現在可以做的事

    • 到 GitHub clone 下來 council-of-high-intelligence,依照文中步驟跑起第一個 /council
    • 挑一個你現在最卡的 A/B 決策,照範例格式寫好丟進議會讓它辯論一次
    • 如果你有在用多代理框架,嘗試把「高智議會」當成決策模組接入現有工作流
  • 用瀏覽器跑自己的 AI Agent:peerd 實戰

    用瀏覽器跑自己的 AI Agent:peerd 實戰

    📌 本文重點

    • peerd 把瀏覽器變成本機 AI Agent 執行環境
    • 純前端運作,API Key 不經過第三方伺服器
    • 多 Agent 隔離與瀏覽器自動化,適合個人工作流與 QA 腳本

    用一句話講清楚:peerd 就是把「瀏覽器」變成你的 AI Agent 執行環境,所有腳本、代理邏輯都在本機瀏覽器裡跑,不經過第三方伺服器。

    連結先給你:
    – GitHub / 官方介紹:https://github.com/NotASithLord/peerd
    – Demo / 官網入口:https://peerd.ai


    核心功能:瀏覽器就是沙盒 + 多 Agent 控制台

    1. 純前端 JS,API Key 只在你機器裡

    peerd 是一個瀏覽器擴充套件,用原生 JavaScript 寫成,執行邏輯都在前端:

    • 你自己輸入 OpenAIAnthropicGemini 等 API Key
    • 請求直接從瀏覽器送出,不經過 peerd 的伺服器
    • 不需要額外安裝「AI 瀏覽器」或開一個本地 server

    💡 關鍵: API 呼叫完全在本機瀏覽器完成,你的金鑰與請求內容不會經過第三方後端服務。

    你可以立刻做的事
    1. 打開 https://peerd.ai,依照說明安裝瀏覽器擴充套件(目前以 Chromium / Chrome 系列最佳)。
    2. 安裝後,在擴充圖示裡找到 peerd,開啟設定頁,填入你現有的 OpenAI / Anthropic / Gemini API Key。
    3. 測試呼叫一次簡單指令(例如:讓 Agent 幫你總結目前開啟頁面的內容),確認 Key 有效。

    2. 多 Agent,彼此隔離在不同 sandbox / worker

    peerd 的設計重點是:一個瀏覽器,多個 Agent,各自有自己的工作空間

    它利用:

    • 多分頁 / 多視窗
    • Web Worker / Service Worker

    來把不同 Agent 隔離,例如:

    • Agent A:專門抓資料,跑在一個 Worker
    • Agent B:負責整理與寫摘要,跑在另一個 Worker
    • Agent C:只負責觸發 UI 操作

    彼此透過訊息溝通,但記憶體與腳本隔離,減少互相干擾。

    💡 關鍵: 每個 Agent 在獨立的 worker/sandbox 裡執行,降低互相干擾與權限混用風險。

    你可以立刻做的事
    1. 在 peerd 的控制面板中,建立兩個 Agent:例如「資料收集 Agent」「摘要整理 Agent」。
    2. 設定:「資料收集 Agent」負責打開網站、擷取內容;完成後把文字丟給「摘要整理 Agent」。
    3. 觀察兩個 Agent 的 log(通常 peerd 會有 console / log 面板),確認任務是分開跑的。

    3. 自動化瀏覽、跑 JS 腳本,甚至開 WebAssembly VM

    peerd 不只有「叫模型寫文字」這一招,它可以:

    • 控制瀏覽器行為:
    • 自動打開指定網址
    • 在頁面中執行 DOM 查詢、抓元素文字
    • 觸發按鈕點擊、輸入框填寫
    • 執行 JavaScript 腳本:在 sandbox 內跑程式邏輯,像一個本地化的「Agent 腳本引擎」
    • 啟動 WebAssemblyWASM)虛擬機:甚至可在瀏覽器裡跑一個簡化版的 Linux VM + 網路堆疊

    這代表:

    • 你不用額外架 server 就能做「自動化 QA 腳本」
    • 可以把實驗性 side project 完整關在瀏覽器裡玩,不動你的主機環境

    你可以立刻做的事
    1. 用 peerd 新增一個「任務腳本」,讓它在分頁裡執行以下行為:
    – 打開一個新聞網站
    – 用 document.querySelectorAll('h1, h2') 抓標題
    – 把標題串成一段文字
    2. 把這段文字交給 LLM,請它生成摘要,顯示在 peerd 的面板中。
    3. 如果你熟 JS,可以把這個流程包成一個可重複執行的腳本,日後一鍵跑。


    適合誰用:三種具體場景

    1. 個人資訊整理 / 研究助手

    使用情境:

    • 你每天會看固定幾個新聞網站或技術部落格
    • 想要「早上開機 → 一鍵跑 → 自動抓標題 → 整理成 一頁摘要」

    可以這樣設計一個 peerd Agent:

    1. 設定一個 URL 清單(例如:三個新聞站 + 一個技術站)。
    2. Agent 依序打開每個網站,抓取首頁標題(或特定區塊)。
    3. 把所有標題與小段落交給 LLM,產出:
    4. 一份今日重點摘要
    5. 分類(國際 / 本地 / 技術 / 商業)
    6. 把結果顯示在 peerd 面板,或存成一段 Markdown,傳回你的筆記系統。

    適合:

    • 喜歡自己控制流程、但不想寫一堆後端程式的人
    • 不想讓瀏覽紀錄、研究內容經過第三方服務的人

    2. 產品 / 網頁 QA 腳本、互動 Demo

    peerd 可以把「瀏覽器自動操作 + LLM」組成 QA 工作流:

    範例:

    1. 定義一組 QA 腳本:
    2. 打開測試環境網址
    3. 自動登入測試帳號
    4. 點幾個主要流程(新增、編輯、刪除),截取畫面文字
    5. Agent 檢查:
    6. 是否有錯誤訊息
    7. 版面文字是否符合規格(例如:翻譯是否正確)
    8. 把結果整理成一份 QA 報告,直接在瀏覽器下載或複製。

    適合:

    • 前端工程師、PM、設計師,想要簡單重複測試
    • 需要做互動 Demo,讓 Agent 自動「操作產品給觀眾看」

    3. 不想碰 DevOps 的 side project / workflow 原型

    如果你平常:

    • 有很多「想做個小工具」的點子
    • 但一想到要架 server、部署,就懶了

    peerd 提供一種做法:全部寫成瀏覽器 Agent 腳本

    • 把流程寫在 JS 裡(在 peerd 提供的 sandbox 中)
    • 需要呼叫 LLM,就用自己的 Key
    • 存資料可以暫時放在 LocalStorage、下載檔案、或手動貼回 Notion / Obsidian

    適合:

    • 想先驗證「這個工作流值不值得做成正式產品」的人
    • 想建立個人專用工作流,但不想管理伺服器的人

    怎麼開始:從「自動抓新聞標題摘要」實作一路到客製 Agent

    以下是一條最快速的上手路徑,你可以照做一次,確認 peerd 的使用感覺。

    步驟 1:安裝 peerd 擴充 & 準備 API Key

    1. 打開 https://peerd.ai,找到瀏覽器擴充安裝連結(多為 Chrome Web Store 或手動載入)。
    2. 安裝完成後,點右上角擴充圖示 → 找到 peerd → 打開控制面板。
    3. 準備至少一個 LLM 服務:
    4. OpenAI(或相容 API)
    5. Anthropic
    6. Gemini
    7. 在 peerd 設定頁,填入你的 API Key,並測試一個簡單 prompt(例如:「請用 50 字說明你是誰」)。

    💡 關鍵: 先用簡單 prompt 驗證 API Key 設定無誤,可以避免後續腳本除錯時間。

    步驟 2:建立一個「新聞摘要 Agent」

    目標:自動打開幾個新聞站,抓首頁標題,總結成一段簡報。

    可以照以下邏輯:

    1. 在 peerd 新建一個 Agent,命名為 NewsSummarizer
    2. 設定任務腳本(概念上類似 pseudo-code):

    “`js
    const sites = [
    ‘https://news.ycombinator.com’,
    ‘https://www.bbc.com/news’,
    ‘https://www.ft.com’
    ];

    async function run() {
    const allHeadlines = [];

     for (const url of sites) {
       const page = await openTab(url); // peerd 提供的抽象 API(實際名稱依文件)
       const titles = await page.eval(() => {
         return Array.from(document.querySelectorAll('h1, h2'))
           .map(el => el.innerText)
           .filter(Boolean);
       });
       allHeadlines.push({ url, titles });
     }
    
     const prompt = `請根據以下新聞標題,用繁體中文整理出今日重點摘要,分段列出:\n\n${
       JSON.stringify(allHeadlines, null, 2)
     }`;
    
     const summary = await callLLM(prompt); // 依照你選的 provider
     output(summary);
    

    }

    run();
    “`

    1. 儲存腳本後,按「執行」:
    2. peerd 會依序開啟那些網站
    3. 抓取標題
    4. 呼叫 LLM 總結
    5. 在側邊面板或 console 顯示結果

    你可以依照自己的需求修改:

    • 換成台灣 / 香港 / 日本新聞網站
    • 加上「只保留包含特定關鍵字的標題」
    • summary 轉成 Markdown,方便貼到筆記

    步驟 3:客製自己的 Agent 腳本

    當你跑過一次「新聞摘要 Agent」後,可以開始做這幾件事:

    1. 抽出共用邏輯:例如「開頁+抓標題」寫成一個可重用的 function,日後換站台不用重寫。
    2. 加入排程或手動檔案輸出
    3. 每次執行後自動下載一個 .md.txt
    4. 或直接在 peerd 面板顯示,手動複製
    5. 改成其他任務
    6. 產品價格比價(抓不同電商同一商品)
    7. 技術文章整理(從多個 blog 抓標題+摘要)

    步驟 4:注意權限與安全設定

    雖然 peerd 是純前端、API Key 在你機器上,但仍有幾個安全重點:

    1. 網站權限
    2. 當瀏覽器問「是否允許此擴充存取某些網站」時,只開啟你真的需要的網域。
    3. API Key 保護
    4. 不要在共享電腦上使用 peerd,或至少不要留下儲存的 Key
    5. 若用公用電腦,建議使用臨時 Key,使用完立刻 revoke
    6. 腳本來源
    7. 只執行你自己寫的,或來自可信來源的腳本
    8. 不要隨便貼「網友分享的完整腳本」就直接跑,避免讀寫你不想暴露的資料

    peerd 在 AI Agent 工具裡的位置

    目前市面上有不少「Agent 平台」或「AI 瀏覽器」,peerd 的定位比較特別:

    名稱 核心功能 免費方案 適合誰
    peerd 瀏覽器內純前端多 Agent、自動化操作 開源專案,可自架 不想碰後端,只想用瀏覽器的人
    AutoGen 多 Agent Python 框架 開源 已有後端環境的開發者
    AgentHub 類 雲端 Agent 編排平台 多提供免費額度 喜歡 GUI、無法自管 API Key 的人

    如果你的重點是:「所有東西都在我瀏覽器裡跑,不想任何 A2A(Agent-to-Agent)中介干預」,那 peerd 很值得試一次。


    結論:

    • 想要一個「不碰後端、不開伺服器」的 AI Agent 沙盒,peerd 是目前少見的純瀏覽器方案。
    • 它最適合拿來做:個人資訊整理、簡易 QA 腳本、side project 原型。
    • 你可以從一個「新聞標題摘要 Agent」開始,熟悉後再把自己的工作流程慢慢搬進瀏覽器裡。

    🚀 你現在可以做的事

    • peerd 官網 安裝擴充,填入自己的 OpenAI / Anthropic / Gemini API Key 並跑一次測試 prompt
    • 依照文中的範例,建立一個 NewsSummarizer Agent,實作「自動抓新聞標題+摘要」工作流
    • 把現有的一項重複性瀏覽器流程(例如 QA 點測、價格比價),改寫成 peerd Agent 腳本並在本機瀏覽器中試跑
  • MinerU 把爛 PDF 變 AI 神隊友

    MinerU 把爛 PDF 變 AI 神隊友

    📌 本文重點

    • MinerU 專門把 PDF/Office 轉成乾淨結構化文本
    • 讓表格、圖片、公式都能友善餵給 RAG / Agent
    • 開源可本地部署,易嵌入各種 LLM / Agent workflow

    一句話先說結論:MinerU 就是一台「給 LLM / Agent 吃的文件清洗機」——丟 PDF、Word、PPT 進去,吐出乾淨的 Markdown / JSON,直接給 RAG、Chatbot、Agent 用。

    👉 專案連結:https://github.com/opendatalab/MinerU


    核心功能:讓 AI 真的「看懂」你的文件

    1. 直接吃 PDF / Office,多欄位也能拆乾淨

    多數 RAG 失敗,不是模型太笨,而是原始 PDF 太亂。MinerU 的重點是:

    • 支援:PDF、Word、PPT 等常見文件
    • 能處理的麻煩版面:
    • 多欄位排版(例如期刊論文、報表)
    • 頁首/頁尾、頁碼、註腳
    • 混合字型、大小標題、清單

    你可以這樣用:

    1. 把公司內部 PDF / Word 全部放進一個資料夾,例如 ./docs_raw
    2. 用 MinerU 批次轉成 Markdown,輸出到 ./docs_md
    3. 接著再用你熟悉的向量庫(如 MilvusQdrantWeaviate)去吃 docs_md

    這樣做的好處:後面所有 LLM / Agent pipeline,都只面對格式一致的純文字,而不是千奇百怪的 PDF。

    💡 關鍵: 先把所有文件標準化成一致的 Markdown / JSON,可以大幅降低 RAG 出錯率與後續維護成本。


    2. 表格 / 圖片 / 公式抽取,輸出 Markdown / JSON

    對技術文件來說,表格、圖表、公式往往是重點。MinerU 的輸出設計就是「給 LLM 用」:

    • 表格:轉成 Markdown table 或 JSON 結構,便於查詢與切 chunk。
    • 圖片:支援抽圖路徑(搭配 OCR / 圖像模型再處理)。
    • 公式:儘量轉成可讀的文字或 LaTeX 形式,減少重要信息消失。

    你可以依專案需求選擇:

    • Markdown 模式:適合直接塞進向量庫、做長文閱讀、摘要。
    • JSON 模式:適合需要欄位結構的 Agent workflow,例如:
    • 表格 → JSON → 丟給 Agent 做統計、比對
    • 報表 → JSON → 自動生成指標報表

    💡 關鍵: 把表格、公式這類結構化資訊轉成 JSON,可讓 Agent 做統計、比對、生成報表時更精準可控。


    3. 天然適合多代理 / 本地 LLM Workflow

    MinerU 的定位不是一個「雲端 SaaS」,而是一段你可以塞進自己 pipeline 的工具

    典型的用法是這樣:

    1. 資料前處理 Agent:監控新文件,觸發 MinerU 解析。
    2. 知識庫建置 Agent:把 MinerU 輸出的 Markdown / JSON 切 chunk + 嵌入向量庫。
    3. 問答 / 任務 Agent:收到問題時,到向量庫檢索相關片段,再交給 LLM 回答。

    因為 MinerU 是開源、可本地部署,你可以:

    • 把它丟進 Docker Compose 裡,和本地 LLM(如 Ollama)一起跑。
    • 讓 CI/CD 在文件更新時,自動重新解析。

    💡 關鍵: 開源且可本地部署,意味著你可以在私有環境中標準化所有文件處理流程,符合安全與合規需求。


    適合誰用?三個具體場景

    1. 企業內部文件知識庫、客服 / 內訓 FAQ

    場景:

    • 公司有大量 SOP、內規、產品說明、培訓教材,多數是 PDF / Word。
    • 你想做一個內部 Chatbot,讓同事問問題時,直接查這些文件。

    可實作流程:

    1. 把所有內部文件收集到 ./company_docs
    2. 用 MinerU 批次轉成 Markdown:
    3. 標記檔案來源(檔名、類別),方便之後做權限或分類。
    4. 把 Markdown 丟進向量庫,接上你選的 LLM(本地或雲端)。
    5. 在公司 Portal 放一個簡單的 Chat UI,查詢時帶出「原文片段」。

    行動建議:先挑 20 份最常被問的文件,跑一次 MinerU,做一個最小可用版本(MVP)給團隊試用。


    2. 技術文件、論文、報表餵給 RAG / Chatbot

    場景:

    • 需要讓模型理解 API 文件、產品白皮書、學術論文。
    • 想要一個「專門讀某份規格書」的 Chatbot。

    可實作流程:

    1. 用 MinerU 把每份技術文件解析成 Markdown:
    2. 確保目錄、標題層級清楚,可用來分段。
    3. 切 chunk 時,可以以「段落 + 小節標題」為單位,而不是固定字數。
    4. 建立索引:保留檔名 + 小節名稱,方便回答時引用。

    行動建議

    • 先選一份技術文件(例如某 API Reference PDF),用 MinerU 解析後,和「直接用 PDF OCR」比較效果,你會很快看出閱讀品質差異。

    3. 結合本地 LLM / Agent 做長文閱讀、摘要、自動標註

    場景:

    • 想在本地跑 LLM(例如 Ollama + Qwen / Llama),處理長報告、會議紀錄。
    • 希望自動產生標籤、重點整理、摘要。

    可實作流程:

    1. 本地部署 MinerU,解析文件成 Markdown。
    2. 用一個小腳本:
    3. 讀 Markdown → 切段 → 按段落送到本地 LLM。
    4. 讓 LLM 回傳:摘要、關鍵字、分類。
    5. 把結果寫回另一個 JSON 檔,或直接寫入 ElasticSearch / 你用的 DB。

    行動建議:先挑一份 50 頁以上的 PDF,跑 MinerU + 本地 LLM,實測「從原始 PDF 到摘要 JSON」全流程,測時間 & 品質,再決定要不要全量導入。


    怎麼開始:本地快速跑起 MinerU

    以下示範兩種上手方式:Docker 與 pip。使用前建議先看 GitHub 專案 README(隨版本更新):https://github.com/opendatalab/MinerU

    注意:實際指令可能會隨版本更新,請以官方文件為準。下面是典型用法思路,幫你掌握大方向。

    方式一:用 Docker 跑一個典型 PDF Pipeline

    1. 安裝 Docker(Windows / macOS / Linux 都可以)。
    2. 下載專案或直接拉鏡像(以官方 README 為主):
    docker pull opendatalab/mineru:latest
    
    1. 在本機建立兩個資料夾:
    mkdir -p ~/mineru/input ~/mineru/output
    # 把 PDF 放進 input
    cp your.pdf ~/mineru/input/
    
    1. 跑容器:
    docker run --rm \
      -v ~/mineru/input:/data/input \
      -v ~/mineru/output:/data/output \
      opendatalab/mineru \
      mineru \
      --input_dir /data/input \
      --output_dir /data/output \
      --format markdown
    
    1. 檢查輸出:

    2. ~/mineru/output 裡,你會看到對應的 .md.json 檔。

    接下來,你只要把這些 Markdown:

    • Python 讀進來 → 切 chunk → 打 embeddings → 塞進向量庫。
    • 或者直接丟給 Agent 當上下文。

    方式二:用 pip 安裝,嵌入自己的 Python 專案

    如果你想把 MinerU 當成專案的一部分(例如在 FastAPIDjango 裡叫用),可以這樣做:

    1. 建議先建立虛擬環境:
    python -m venv .venv
    source .venv/bin/activate  # Windows 用 .venv\Scripts\activate
    
    1. 安裝 MinerU(以 README 為準):
    pip install mineru
    
    1. 在 Python 裡呼叫(示意):
    from mineru import DocumentParser
    
    parser = DocumentParser(
        output_format="markdown",  # 或 "json"
        lang="zh",                 # 主要語言
    )
    
    parser.parse_dir(
        input_dir="./docs_raw",
        output_dir="./docs_md",
    )
    
    1. 接上你的 RAG pipeline,例如:
    from your_vector_store import add_markdown_docs
    
    add_markdown_docs("./docs_md")
    

    幾個實用配置建議

    1. 語言設定

    • 如果大多數文件是中文,建議在配置中指定 lang=zh,有助於:
    • 正確切段
    • 標題與正文的判斷
    • 混合語言文件(中英夾雜)可先用 MinerU 預設配置,實際跑一份看看效果再微調。

    2. 版面複雜度:先從「最難的」文件測試

    不同文件可能需要不同策略:

    • 多欄位期刊論文
    • 含大量表格的財報
    • 圖片 + 文字混排的簡報

    建議流程:

    1. 先挑 3 種最重要、也最難處理的 PDF 各一份。
    2. 用 MinerU 跑一遍,目視檢查輸出的 Markdown 是否:
    3. 段落順序正確
    4. 表格完整
    5. 標題層級清楚
    6. 再決定是否需要額外的後處理腳本(例如正則清除多餘頁碼)。

    3. 批次處理:一次跑大量文件

    當你要處理成百上千份文件:

    • 使用 --input_dir / parse_dir 直接對整個資料夾處理。
    • 可搭配簡單的排程工具(如 cronAirflowPrefect):
    • 每天檢查新文件 → 觸發 MinerU → 更新向量庫。
    • 建議保留:
    • 原始 PDF 路徑
    • 解析時間
    • 解析版本(方便之後換版本重跑)

    小結:MinerU = 文件進 AI 系統前的「洗版」必備

    如果你正為這些事頭痛:

    • PDF 抽不出好用的文字
    • RAG 回答總是抓錯重點
    • Agent Workflow 每次都被「前處理」拖累

    那 MinerU 是值得花一個下午試跑的工具。把它想像成:

    所有文件進 AI 系統前,先經過的一台「格式清洗機」。

    一旦你把這個「洗版」步驟標準化,後續不論是企業知識庫、技術文件 Chatbot,還是本地 LLM 長文閱讀,都會變得穩定許多。



    🚀 你現在可以做的事

    • 到 GitHub 查看 MinerU 專案 README,確認最新安裝與使用方式
    • 選 10–20 份關鍵 PDF/Word,實際跑一次「PDF → Markdown → 向量庫」流程
    • 在你現有的 RAG / Chatbot 專案中,插入 MinerU 作為前處理步驟,評估回答品質提升幅度
  • Haystack 實戰:一天做出公司 AI 助理

    Haystack 實戰:一天做出公司 AI 助理

    📌 本文重點

    • Haystack 把 RAG + Agent 流程統一成框架
    • 少寫檔案處理與檢索 script,快速做公司助理
    • 用範本與工具擴展成可連公司系統的 Agent
    • 一天內跑出第一個可給同事用的 QA 助理

    用 Haystack,你可以少寫一堆 RAG script,把「文件檢索、LLM 調用、Agent 流程管理」統一交給一個開源框架處理。

    官方網站:https://haystack.deepset.ai/


    為什麼不要再自己拼 RAG script?

    多數人做公司內部 AI 助理,走的流程都是:

    1. 自己寫檔案讀取、切 chunk、丟向量庫
    2. 自己串 LLM API,處理 history、retrieval 邏輯
    3. 想加一點工具(查 DB、叫 REST API)又多一支 script

    問題是:
    – 每新增一個資料源或工具,都要重構流程
    – 很難部署成穩定 API 給同事用

    Haystack 的定位很直接:把 RAG + Agent 的骨架先幫你做好,你只需要選模型、選向量庫、加自己工具,就能變成一個可上線的 AI 助理。

    💡 關鍵: 用框架統一 RAG + Agent 流程,可以讓你只專注在選模型、選向量庫與設計工具,少掉大量重複的整合工作。


    核心功能:你可以少寫的三件事

    1. 文件管線:多資料源 + 多向量庫

    Haystack 幫你處理「資料→文件→向量」的整條管線:

    你可以:
    – 選擇資料源:檔案夾、PDF、Markdown、Confluence、Notion 等
    – 選擇向量庫:FAISSWeaviateQdrantElasticsearch
    – 用同一套 API 建 index、更新文件,避免 N 種自訂 script

    實際行動:先在本地建一個簡單文件管線

    pip install haystack-ai
    

    範例(Python):

    from haystack import Pipeline
    from haystack.document_stores import FAISSDocumentStore
    from haystack.nodes import PDFToTextConverter, TextSplitter, EmbeddingRetriever
    
    # 建立向量庫
    doc_store = FAISSDocumentStore(faiss_index_factory_str="Flat")
    
    # 文件處理節點
    converter = PDFToTextConverter()
    splitter = TextSplitter(chunk_size=500, chunk_overlap=50)
    retriever = EmbeddingRetriever(document_store=doc_store, embedding_model="sentence-transformers/all-MiniLM-L6-v2")
    
    indexing = Pipeline()
    indexing.add_node(converter, name="converter", inputs=["File"])
    indexing.add_node(splitter, name="splitter", inputs=["converter"])
    indexing.add_node(retriever, name="retriever", inputs=["splitter"])
    
    indexing.run({"File": {"paths": ["./docs/handbook.pdf"]}})
    

    跑完,你就有一個可檢索的公司文件向量庫。


    2. 問答 / ChatBot 範本:已幫你處理 history + retrieval

    Haystack 內建多種 QA / ChatBot 範本,你不用自己寫:
    – 如何把 user 問題拿去檢索文件
    – 如何把檢索結果塞進 prompt
    – 如何處理多輪對話的 history

    你只要:
    1. 選用哪一個 LLM(雲端或本地)
    2. 綁定上一步建立好的向量庫

    範例:最小 QA API(搭配 Docker 跑一個 stack)

    docker run -p 8000:8000 deepset/haystack:latest
    

    在 Python 中寫一個簡單 QA pipeline:

    from haystack import Pipeline
    from haystack.nodes import PromptNode
    from haystack.document_stores import FAISSDocumentStore
    from haystack.nodes import EmbeddingRetriever
    
    # 連到既有向量庫
    doc_store = FAISSDocumentStore(faiss_index_path="faiss_index")
    retriever = EmbeddingRetriever(document_store=doc_store, embedding_model="sentence-transformers/all-MiniLM-L6-v2")
    
    # LLM(可改成你的雲端 / 本地模型)
    prompt_node = PromptNode("gpt-4o", api_key="YOUR_OPENAI_KEY")
    
    qa = Pipeline()
    qa.add_node(retriever, name="retriever", inputs=["Query"])
    qa.add_node(prompt_node, name="llm", inputs=["retriever"])
    
    result = qa.run({"Query": "我們的休假制度怎麼規定?"})
    print(result["results"][0])
    

    這樣就有一個最小的「公司文件 QA API」,可以包成 FastAPI / Flask 給同事使用。


    3. Agent 範本:多工具呼叫 + 任務分解

    當你想讓助理不只回答文件內容,還能查系統資料或叫內部 API,Haystack 的 Agent 範本就派上用場。

    你可以:
    – 定義多個工具(例如:查工時系統 REST API、查 CRM 客戶資料)
    – 讓 Agent 自己決定何時呼叫哪個工具,並把結果融入回答

    範例:加一個「查內部 REST API」工具

    from haystack.agents import Tool, Agent
    import requests
    
    # 定義工具
    def get_user_vacation(user_id: str) -> str:
        r = requests.get(f"https://internal-api.company.com/vacation/{user_id}")
        return r.json()["summary"]
    
    vacation_tool = Tool(
        name="vacation_lookup",
        func=get_user_vacation,
        description="查詢員工剩餘休假與最近申請紀錄。輸入 user_id。",
    )
    
    agent = Agent(tools=[vacation_tool], model="gpt-4o")
    
    answer = agent.run("幫我查一下員工 1234 的休假狀態,再用中文整理給我。")
    print(answer)
    

    到這一步,你已經從「純 QA 助理」升級成「簡單 Agent」,可以真正接公司系統工作流程。

    💡 關鍵: 一旦把公司內部 REST API 或 DB 封成工具交給 Agent,你的助理就能從「只會看文件」變成「真的能查系統、執行工作」的實用工具。


    適合誰用?兩個具體場景

    1. 公司內部文件助理(Confluence / PDF / Notion)

    目標:讓同事問「新人入職流程」「出差報帳規則」時,直接跟 AI 聊天,不必翻 Confluence / PDF。

    你可以這樣做:
    1. 把公司手冊、流程文件、政策 PDF 匯出到一個資料夾
    2. 用 Haystack 文件管線建立向量庫
    3. 用 QA 範本 + LLM 做一個 /ask-docs API
    4. 用簡單前端(React / internal tool)做一個聊天頁面給同事用


    2. 客戶 FAQ 機器人(網站 / LINE / Web Chat)

    目標:把客服中心常見問題、產品 FAQ 集中到一個聊天介面,讓客戶自助查詢。

    你可以:
    1. 用 Haystack 把 FAQ CSV / 網站內容抓下來做 index
    2. QA pipeline 對接你的 LLM(可以選較便宜模型,參考 AI 成本問題:https://blog.dshr.org/2026/06/ais-affordability-crisis.html
    3. 透過 Agent 工具連到訂單查詢 API,讓客戶問「我的訂單現在在哪?」時能真的查到資料


    怎麼開始:一天內跑出第一個可用助理

    步驟 1:本地快速上手

    1. 建環境

    bash
    python -m venv venv
    source venv/bin/activate # Windows 用 venv\Scripts\activate
    pip install haystack-ai

    1. 選模型
    2. 想省錢、保留隱私:用本地開源模型(例如 DeepSeek 輕量版,部署教學可參考:https://pub.towardsai.net/how-to-run-deepseek-locally-on-your-own-computer-and-the-catch-most-guides-skip-60517629d00d
    3. 想先跑順:用雲端 OpenAI / Anthropic 等

    步驟 2:選一個向量庫

    開發階段,可以先用:
    FAISS:本地測試快速、安裝簡單
    Qdrant / Weaviate:要多機部署再考慮

    把向量庫實例塞到 Haystack document_store,就能用同一套 pipeline 程式碼。


    步驟 3:照官方範例跑出第一個 QA API

    官方入門範例在:https://haystack.deepset.ai/tutorials

    你可以:
    1. 先照「Quickstart RAG」跑一遍(約 30 分鐘)
    2. 把示範資料換成公司文件
    3. 用 FastAPI 包一層 HTTP API:

    from fastapi import FastAPI
    from pydantic import BaseModel
    
    app = FastAPI()
    
    class Query(BaseModel):
        question: str
    
    @app.post("/qa")
    async def qa_endpoint(q: Query):
        result = qa.run({"Query": q.question})
        return {"answer": result["results"][0]}
    

    部署與實戰小訣竅

    1. 用環境變數切換雲端 / 本地模型

    實務上你會想在:
    – 開發:用本地開源模型省錢
    – 上線:用雲端模型提高穩定性

    可以這樣設計:

    import os
    from haystack.nodes import PromptNode
    
    MODEL_NAME = os.getenv("LLM_MODEL", "gpt-4o")
    MODEL_ENDPOINT = os.getenv("LLM_ENDPOINT")  # 本地時填自己的伺服器 URL
    
    prompt_node = PromptNode(MODEL_NAME, api_key=os.getenv("LLM_API_KEY"), url=MODEL_ENDPOINT)
    

    只要在部署時改環境變數,就能切換不同模型和推理後端。


    2. Prompt logging:先看清楚 Agent 在幹嘛

    Haystack 支援把 pipeline 執行資訊輸出,你可以:
    – 把每次 prompt、檢索結果、工具呼叫記錄到 DB / Log 文件
    – 用這些紀錄回頭調整 prompt、優化 Agent 行為

    簡單做法:
    – 在 FastAPI 層加 middleware,把 qa.run() 的輸入輸出存進 DB
    – 固定每週 review 一次錯誤回答,調整資料和 prompt


    3. 評估:不要只看「感覺」,要看準確率

    Haystack 有基礎評估工具,你可以:
    1. 準備 20-50 題真實問題 + 正確回答
    2. 用這些問題跑 pipeline,計算命中率、是否有 hallucination
    3. 調整 chunk 大小、retriever top-k、模型種類

    💡 關鍵: 用 20–50 題標註資料做簡單評估,比只看「用起來感覺不錯」更能掌握準確率與幻覺問題。


    總結:先用框架,把精力留給「你自己的工具」

    如果你已經寫過一次 RAG pipeline,就知道真正麻煩的不是 LLM,而是:文件流程、檢索、上下文管理、工具呼叫。Haystack 把這些基礎骨架收斂成一套可重複使用的框架,你可以把力氣放在:

    • 接公司內部系統(REST API / DB / CRM)
    • 整理與更新文件資料
    • 設計合乎業務邏輯的 Agent 行為

    照本文步驟,一天內做出第一個「真的可以丟給同事用」的公司 AI 助理,之後再慢慢疊功能,而不是每次都從一堆 RAG script 重寫。


    🚀 你現在可以做的事

    • Haystack 官方教學 跑一遍 Quickstart RAG,並把示範資料換成公司文件
    • 在本地用 FAISS + 一個你熟悉的 LLM(如 gpt-4o 或本地 DeepSeek)建立第一個 QA pipeline
    • 為公司內一個具體場景(例如新人入職或客服 FAQ)做出 /qa HTTP API,丟給 2–3 位同事試用並收集回饋
  • Claude 進 Slack:讓 @Claude 變成常駐隊友

    Claude 進 Slack:讓 @Claude 變成常駐隊友

    📌 本文重點

    • Claude Tag 把 AI 帶進 Slack 工作流
    • 可讀取頻道與文件成為常駐 AI 隊友
    • 產品與工程團隊可用來改 code、寫 spec、整理決策
    • 使用時要重視權限與資料留存設定

    Claude Tag 解決的問題很簡單:把「開瀏覽器問 AI」變成「在 Slack 裡直接叫一個懂你團隊脈絡的 AI 隊友」,接招、改稿、寫 code 都在原本的工作流裡完成。

    官方介紹與申請入口:Anthropic — Introducing Claude Tag


    Claude Tag 是什麼?先用一張心智圖說清楚

    先釐清一個觀念:@Claude 在 Slack 裡不是單獨一個聊天機器人,而是「常駐 AI 隊友」

    你可以這樣想:

    • Slack 工作區 = 你們的辦公室
    • 各個頻道、DM = 會議室、部門群組
    • @Claude Tag = 一位一直待在辦公室的 AI 同事,可以:
    • 讀你開放給它的頻道歷史
    • 看你丟進 Slack 的文件、PR 連結、會議紀錄
    • 參與日常討論,幫忙把「長聊」轉成「可執行的產出」

    接下來所有操作,都圍繞一件事:在需要的地方標註 @Claude,讓它補位。


    核心功能:3 種你今天就能用起來的玩法

    1. 在任意頻道標註 @Claude 做即席協作

    Claude Tag 的第一個重點:不用開新聊天視窗,直接在任何頻道叫它一起工作。

    可以直接抄下面幾種用法:

    • 改 code / 寫 PR 說明
    • #backend 頻道貼出 PR 連結或片段 code,接著:
    • @Claude 幫我檢查這段改動有沒有潛在效能問題,順便寫一段 PR 說明,給 reviewer 看。
    • 寫 spec / 補文件
    • 把討論串貼給 Claude:
    • @Claude 根據這整串對話,幫我寫一份 API 變更簡要 spec,用條列整理:背景 / 改動 / 風險 / TODO。
    • 整理會議紀要
    • 開完會直接把 Zoom transcript 或重點丟進頻道,然後:
    • @Claude 把這份紀錄整理成:決策摘要 + 待辦事項(標註負責人與期限)。

    這種用法的關鍵:把「輸出格式」講清楚(例如「用條列」、「幫我變成 Jira ticket」),Claude 就會照你們現有習慣產出。


    2. 讓 Claude 漸進學會公司內部知識

    第二個重點,是很多人忽略的:Claude Tag 會累積你們的上下文,但你可以控制它「看到什麼」。

    實際可以做的事:

    1. 設定 Claude 可以進的頻道範圍
    2. 第一次啟用時,由 workspace admin 選擇:哪些 team space、哪些公開頻道可以 @Claude
    3. 建議做法:先選擇一兩個「資訊集中但不含敏感資料」的頻道當試驗場,例如:

      • #product(功能討論)
      • #eng-help(技術問答)
    4. 有意識地「餵」它公司知識
      每當有重要內部文件,直接在對應頻道讓 Claude 讀:

    5. @Claude 這是我們最新的工程 onboarding docs,幫我整理成 10 個 FAQ,以後新人問類似問題時你可以用。
    6. @Claude 這是 2025 Q4 的產品 roadmap,請記住。之後我問你優先順序時,優先以這份 roadmap 為準。

    7. 隱私與權限注意

    8. 只讓 Claude 加入你願意被 AI 閱讀的頻道。
    9. 對高度機密(薪資、法律糾紛)頻道:不要加入 Claude,也不要貼內容給它看。
    10. 與管理者討論資料留存策略:是否讓 Claude 長期記住對話,還是關鍵討論後再以整理版文件餵給它。

    可行動建議:先選一個「試點 team space」,明確宣告什麼可以給 Claude 看、什麼不行,讓團隊放心試用。


    💡 關鍵: 透過精選頻道與文件餵養,Claude 能逐步成為懂你公司脈絡的專屬知識助理,同時兼顧隱私與安全。

    3. 高價值產品開發場景:開發團隊可以這樣用

    根據 Anthropic 對外說法,內部產品團隊已有約 65% 的程式碼由 Claude 協助生成(來源:The Decoder 報導)。

    💡 關鍵: 有約 65% 內部程式碼由 Claude 參與,代表把 AI 納入日常開發流程已經能帶來實質產能提升。

    這裡整理幾個實際可套用場景:

    1. Code Review 草稿
    2. 在 PR 頻道標註:
    3. @Claude 幫我做這個 PR 的初步 code review,列出:風險點 / 可改善的地方 / 要特別測的情境。
    4. reviewer 只要從 Claude 草稿開始調整,比從零寫 review 快很多。

    5. PR 說明生成

    6. 開 PR 前,把改動片段貼到 Slack:
    7. @Claude 根據這些改動,幫我寫一段清楚的 PR 說明,包含:變更內容 / 為什麼要改 / 影響範圍。

    8. 設計文件摘要與追蹤決策

    9. 設計師在 #product 貼 Figma 連結與說明後:
    10. @Claude 幫我寫一份設計摘要,給工程團隊看,重點放在互動邏輯與 API 需求。
    11. 長期討論串快結束時:
    12. @Claude 把這整串討論變成一份「決策紀錄」,包含:我們決定做什麼、不做什麼、理由是什麼。

    從 0 到能用:5 個步驟完成初始設定

    以下是一個可以直接照做的「從 0 到能用」流程:

    步驟 1:確認資格與安裝入口

    1. 聯絡你們的 Slack workspace admin。
    2. 到 Anthropic 官方頁面申請 Claude Tag:https://www.anthropic.com/news/introducing-claude-tag
    3. 安裝 Slack App(通常由 admin 在 Slack App Directory 點選「Add to Slack」,授權 Claude 進入工作區)。

    步驟 2:建立第一個 team space

    推薦先建立一個「試驗場」:

    • 例:建立一個 #claude-pilot 或選擇現有的 #product 當 Claude 的主要 team space。
    • 在頻道 topic 寫清楚:
    • 這裡允許 @Claude 參與討論
    • 這裡不貼敏感資訊(財務、個資、合約原文)

    步驟 3:設定權限與資料留存

    與 admin 做三件事:

    1. 決定 Claude 可加入的頻道清單(只選跟產品/工程相關的公開頻道開始)。
    2. 確認公司對 AI 工具的資料政策:是否允許對話被用於模型微調或分析;如果不允許,要在管理後台關閉相關選項。
    3. 建立審核機制:例如約定「所有由 Claude 產生的 code,一定要由人類 reviewer 看過再 merge」。

    步驟 4:準備 2~3 個可抄的 Prompt 範本

    直接貼在頻道 pinned messages,讓大家複製使用:

    1. 把對話整理成 Jira ticket

    text
    @Claude 請把上面這整串對話整理成 1 張 Jira ticket:
    - 題目:用一句話描述主要需求
    - 描述:背景 / 使用者故事 / 驗收標準
    - 子任務:列出需要的開發與測試任務
    請用我們平常 Jira 的格式回覆。

    1. 從 PR 線索寫測試案例

    text
    @Claude 根據這個 PR 的改動內容,幫我想出 5 個具體的測試案例:
    - 每個案例要包含:前置條件 / 操作步驟 / 預期結果
    - 優先涵蓋邊界情況與錯誤處理。

    1. 會議後產出決策紀錄

    text
    @Claude 請把這份會議紀錄整理成:
    - 決策摘要(3 行以內)
    - 已決定事項(列點)
    - 尚待釐清的問題(列點,加上提議負責人)


    步驟 5:讓團隊先用一週,再回頭調整

    一週後可以檢視:

    • 哪些 prompt 用得最多?考慮做成 Slack shortcut 或範本文檔。
    • 哪些頻道真的需要 Claude?誰覺得被打擾?再微調頻道清單。
    • 是否需要再開一個「只給 Claude 看整理版文件」的頻道,避免原始對話太雜亂。

    適合誰用?幾個具體場景

    產品與工程團隊

    • 每天在 Slack 上討論需求、看 PR、改 spec 的團隊。
    • 想要減少「會後沒人寫紀錄」、「PR 說明草草帶過」的情況。

    Startup 創辦人與 PM

    • 希望把散落在 Slack 的決策,變成結構化文件或任務。
    • 想要有一個懂公司脈絡的 AI,可以問「我們之前討論過 X 嗎?」並整理出來。

    跨部門協作團隊

    • 法務、行銷、營運共同在 Slack 協作,常有長串討論。
    • 需要有人幫忙把「雜訊」整理成可以丟進 Notion、Confluence 的精簡版本。

    和傳統「開瀏覽器問 ChatGPT」的差異

    最後一個關鍵差異:Claude Tag 會記得你們團隊的上下文。

    與在瀏覽器開 ChatGPT 相比:

    • 你不用每次重新貼背景;Claude 已經在頻道裡看過之前的討論。
    • 它知道你們常用的詞(內部代號、專案名稱),輸出更符合團隊習慣。
    • 它可以把散落在 Slack 的訊息,慢慢累積成組織知識。

    但這也意味著你要更在意資料留存與權限設定

    • 只讓 Claude 進入你願意被 AI 看見的頻道。
    • 在公司內部文件中說明:哪些類型資料不貼給 Claude。
    • 為 AI 產出的內容訂定審核流程,避免「AI 說的」直接變成正式決策或上線 code。

    如果你已經習慣用 ChatGPT / Claude 網頁版,下一步可以嘗試的是:選一個團隊、選一個 Slack 頻道,把上面 3 個 prompt 貼上去,讓 @Claude 真正變成你們的常駐 AI 隊友。


    🚀 你現在可以做的事

    • Anthropic 官方頁面 申請並安裝 Claude Tag 到你的 Slack workspace
    • 建立一個 #claude-pilot 試驗頻道,貼上文中的 3 個 prompt 範本讓團隊開始使用
    • 與 workspace admin 討論並設定 Claude 可加入的頻道與資料政策,確保權限與留存策略清楚明確
  • 用 HTML 寫腳本做影片:Hyperframes 實戰

    用 HTML 寫腳本做影片:Hyperframes 實戰

    📌 本文重點

    • 用 HTML/TypeScript 把影片當「程式」來維護
    • Hyperframes 將腳本轉成可由 Agent 操控的影片時間軸
    • 適合 PRD/demo、教學文件與 SaaS 行銷影片自動化

    用 TypeScript/HTML 寫「腳本」,讓 Hyperframes 自動渲染成影片時間軸,工程師和產品團隊可以把影片當程式一樣維護、生成、版本控管。

    專案連結:heygen-com/hyperframes on GitHub


    核心功能:把 HTML 當「影片腳本」來寫

    Hyperframes 的一句話定位,就寫在專案首頁:Write HTML. Render video. Built for agents.

    💡 關鍵: 用你已熟悉的 HTML/TypeScript 寫腳本,就能直接生成可維護、可版本控管的影片時間軸。

    1. 用 HTML/TypeScript 描述「場景」

    你不需要學一套新語言,只要會寫基本 HTML + 一點 TypeScript 就能描述影片:

    • 文字:標題、段落、註解
    • 圖片:產品截圖、Logo、示意圖
    • 版面:位置、大小、對齊、動畫時間

    概念有點像「React for video」,只是畫面不是立刻出現在瀏覽器,而是被轉成可渲染的影片時間軸。

    你可以馬上做的事

    • 想像你平常寫的 landing page,把那套 HTML 思維搬到「影片畫面描述」上
    • 打開一個 PRD 或 Markdown 文件,先用 HTML 把幾個關鍵畫面(標題 + 截圖 + 說明文字)寫成簡單的段落

    2. Hyperframes 轉成時間軸,可被 Agent 動態更新

    Hyperframes 負責兩件事:

    1. 解析你的 HTML/TypeScript 標記
    2. 把它轉成一個「每一秒要顯示什麼」的時間軸,供後端渲染成影片

    因為是程式化的時間軸,AI Agent 可以:

    • 根據使用者輸入,動態生成新的 HTML 段落
    • 修改某段文案 / 圖片,重算時間軸,只重渲染需要改的片段
    • 大量生成「同版面、不同內容」的客製化影片

    你可以馬上做的事

    • 在腦中把「Premiere 的時間軸」換成「一個可被 AI 修改的 JSON」
    • 思考:你手上的哪類影片,其實只是在不同客戶之間改幾行字、改幾張圖?那些都可以交給 Agent + Hyperframes 自動跑

    3. 為多代理系統設計的「影片引擎」

    Hyperframes 是純 TypeScript 開源專案,設計上就是給 Agent / workflow 用:

    • 可在 Node.js 環境跑,方便接各家 LLM API(包含 Gemini Interactions API、Claude、OpenAI 等)
    • HTML 腳本可存 Git 版本控管,配合 CI/CD 產生最新版本影片資產
    • 適合作為「一個工具節點」,掛在你原有的多代理系統後面

    你可以馬上做的事

    • 把 Hyperframes 想成「你的 AI pipeline 裡的一個 render-video step」
    • 在系統設計圖上加一個方塊:Agent → 產生 HTML → Hyperframes → 影片檔

    適合誰用:3 個具體場景

    1. 產品 demo 腳本自動化(從 PRD 產生影片)

    場景:你有詳細的 PRD / feature spec,現在要做:

    • 版本更新介紹影片
    • 產品 demo 給內部/客戶

    做法:

    1. 用 LLM 讀 PRD(例如 Gemini Interactions API / Claude),生成一份 HTML 腳本:
    2. 每個 section = 一個場景
    3. 為每個場景標註標題、說明文字、要顯示的截圖檔名
    4. 把這份 HTML 餵給 Hyperframes 轉成影片時間軸
    5. 配合螢幕錄影或靜態截圖,渲染出完整 demo 影片

    可以立刻行動:先選一份最常更新的產品功能說明,試著寫一版最陽春的 HTML 腳本(只有標題 + 一段文字),跑通「文字 → 影片」流程。


    2. 教學 / 文件影片化(Markdown → HTML → 影片)

    場景:你有大量技術文件或教學文章,只停留在文字。

    做法:

    1. 先把 Markdown 轉成 HTML(用現成工具或自己寫 parser 都可以)
    2. 用程式規則把特定標題階層變成影片「章節」
    3. Hyperframes 把每一章節變成一個場景,搭配插圖或 code snippet 截圖

    這樣,你就能:

    • 一鍵更新「教學影片」:只要 Markdown 更新,重新跑 pipeline 即可
    • 給客戶或新同事一份「看得懂」的版本

    可以立刻行動:挑一篇 README 或 API 文件,先用任何 Markdown → HTML 工具轉出 HTML,作為 Hyperframes 的 input 範例。


    3. SaaS 行銷頁 A/B 測試影片 + 客製化影片批量生成

    場景:你有 SaaS 產品,要測試不同文案 / 不同主打功能的影片版本,甚至為不同產業客戶客製化介紹。

    做法:

    • 固定版面:Logo 位置、背景、CTA 位置等寫死在 HTML 模板
    • 動態部分:標題、優點列表、案例截圖由 Agent 依據「產業 / Persona」填入
    • Hyperframes 讀模板 + 動態內容,批量生成 N 支影片

    可以立刻行動:先寫一份「固定版面 + placeholder 文案」的 HTML 模板,想好幾種 Persona,讓 Agent 幫你填字,再交給 Hyperframes 渲染。

    💡 關鍵: 把版面固定、內容變數化,可以穩定批量生成多版本影片,適合 A/B 測試和客製化行銷。


    怎麼開始:從 clone 專案到跑出第一支影片

    以下示範的是一條最小可用 pipeline:手寫 HTML → Hyperframes → 影片檔

    1. 安裝與跑官方範例

    1. 先 clone 專案:

    bash
    git clone https://github.com/heygen-com/hyperframes.git
    cd hyperframes

    1. 安裝依賴(專案使用 pnpm,可改用 npm/yarnREADME 說明):

    bash
    pnpm install

    1. 跑官方範例(實際 script 名稱請以 repo README 為準,大致會類似):

    bash
    pnpm demo
    # 或
    pnpm examples:simple

    執行成功後,你應該會在 output/ 或指定目錄下看到一支簡單的 mp4 影片。這一步的目標只有一個:先確認環境能渲染出影片


    2. 寫一個最小 HTML → 影片 pipeline

    建立一個新檔 scripts/simple.ts,示範概念(示意程式碼,實際 API 以官方文件為準):

    import { render } from "hyperframes";
    import fs from "node:fs";
    
    const html = `
      <scene duration="5">
        <layer>
          <text x="50" y="80" fontSize="42" align="center">
            用 HTML 寫腳本做影片
          </text>
          <text x="50" y="55" fontSize="24" align="center">
            這支影片是 Hyperframes 渲染出來的
          </text>
        </layer>
      </scene>
    `;
    
    async function main() {
      const videoBuffer = await render({
        html,
        width: 1920,
        height: 1080,
        fps: 30,
      });
    
      fs.writeFileSync("output/simple.mp4", videoBuffer);
    }
    
    main();
    

    然後在 package.json 新增指令:

    {
      "scripts": {
        "simple": "ts-node scripts/simple.ts"
      }
    }
    

    執行:

    pnpm simple
    

    目標:確認自己可以從一段自訂 HTML,產生一支 mp4,並理解 HTML 每一行大概對應到畫面什麼東西。


    3. 接上自己的 LLM / Agent

    接下來,把「寫 HTML 腳本」交給 LLM 或 Agent:

    1. 準備一份輸入:PRD、Markdown、網站 HTML 等
    2. 在程式裡呼叫任意 LLM(本地模型或雲端 API 皆可):

    ``ts
    async function generateHtmlFromPrd(prdText: string): Promise<string> {
    const prompt =
    請根據以下 PRD 產生一段 Hyperframes 用的 HTML 腳本,
    拆成多個 ,每個 scene 3-5 秒,場景中包含主標題和一句說明:\n\n${prdText}`;

     const res = await callYourLLM(prompt); // 可接 Gemini Interactions API / Claude / OpenAI
     return res.html; // 規劃好讓模型回傳一整段 HTML
    

    }
    “`

    1. html 換成 LLM 輸出的內容,其他 render 流程不變。

    建議實作順序

    1. 先用手寫 HTML 確認渲染流程 OK
    2. 再加上 LLM 生 HTML
    3. 最後才整合到完整 Agent / workflow 中

    💡 關鍵: 先跑通「手寫 HTML → 影片」再接 LLM,可以把問題範圍縮小在腳本品質,而不是整條 pipeline。


    實戰 workflow 範例:網站 → 腳本 → 影片

    假設你已經有一個「website cloner」Agent(或直接用 Gemini/Claude 爬一個網址),可以這樣串:

    1. 抓網站內容
    2. 把目標 landing page HTML 抓回來
    3. 抽出主要標題、副標、幾個關鍵區塊文字
    4. LLM 產生影片腳本 HTML
    5. prompt:
      > 幫我把下面網站內容濃縮成 60 秒產品介紹影片腳本,輸出 Hyperframes HTML,拆成 4-5 個 scene,依序介紹痛點、解法、功能、CTA。
    6. Hyperframes 渲染影片
    7. 把上一段產出的 HTML 餵給 Hyperframes
    8. 輸出一支 mp4,直接用在:
      • A/B 測試新版本 landing page
      • 業務寄給潛在客戶的「快速介紹影片」

    這整條線只要串完一次,以後對任何網址都能做到「自動 clone 成一支介紹影片」,只需要調整 prompt 和場景模板。


    小結:把影片當程式來維護

    Hyperframes 的價值在於:讓影片變成一個可以被 HTML / TypeScript、LLM、Agent 操控的「程式」,而不是一次性輸出的二進位檔。

    如果你身在工程或產品團隊,習慣用 Git 管規格、用 CI/CD 部署後端,Hyperframes 讓你用同樣思維管理影片資產,從文字文件一路自動化輸出可用的影片成果。

    🚀 你現在可以做的事

    • clone Hyperframes 專案並跑一次官方範例,確認能成功輸出 mp4
    • 手寫一份最小 HTML 腳本,跑通「HTML → Hyperframes → 影片」流程
    • 挑一份 PRD 或 README,嘗試讓你的 LLM 產生第一版影片腳本 HTML 並渲染出影片
  • 一行指令複製網站?這個開源 AI 超會抄

    一行指令複製網站?這個開源 AI 超會抄

    📌 本文重點

    • 一行指令即可把任意網站拆成 React/Next.js 專案骨架
    • 同步抽離樣式與資源,變成可重用 UI 樣板庫
    • 可自訂 AI 模型與 Agent 流程,嵌入既有開發工作流

    只要一行指令,ai-website-cloner-template 就能幫前端 / 全端工程師,把任意網站抓下來、拆成 React/Next.js 專案骨架,當成你的下一個模板起點。

    專案連結:https://github.com/JCodesMore/ai-website-cloner-template


    核心功能:AI Agent 幫你做的 3 件事

    1. 自動爬 DOM,拆出乾淨的前端骨架

    它做的事可以想成「把你平常手動切版的流程自動化」:

    1. 你輸入目標網址
    2. AI coding agents 會:
    3. 爬取 DOM 結構(HTML 標籤、階層關係)
    4. 抽離文字內容、圖片連結等資源
    5. 判斷哪些區塊可以抽成 React component
    6. 最後輸出一個前端專案:
    7. 支援 React / Next.js 等現代框架骨架
    8. 檔案結構已拆好(components/, pages/, styles/

    你可以做的事

    • 把原站當「免費設計稿」,快速得到一個可維護的 React/Next.js 專案,而不是一大包雜亂的 index.html

    💡 關鍵: 自動切出 components/, pages/, styles/ 結構,讓你一開始就站在「可維護專案」而非雜亂單檔的起跑點。


    2. 抽離樣式與資源,變成可重用的樣板庫

    除了 DOM,它還會幫你拆:

    • CSS / Tailwind class:重構成可讀的樣式檔
    • 圖片 / icon / 字型:整理成資源目錄
    • 結構化內容:方便之後換成你的文案或接 API

    實際效果

    • 原本你可能要開 DevTools 一個區塊一個區塊 copy style,現在交給 Agent 自動做
    • 把「別人網站」變成「自己的 UI 元件庫」,拿來之後快速組頁

    你可以做的事

    • 針對常見區塊(Hero、Pricing、Footer)提取成自己團隊的內部 UI Library
    • 搭配設計系統,把色票、字體替換掉,長得像你家產品而不是完全 copy

    3. 與你習慣的 AI 模型 / Agent 框架串在一起

    專案本身是 TypeScript 寫的模板,重點是:

    • AI 模型可替換:支援你自己設定的 API Key(如 OpenAI、Claude 等)
    • Workflow 可客製:你可以改「Agent 該跑哪些步驟」
    • 先爬 sitemap 再挑幾頁複製
    • 只抓特定 path(例如 /pricing/blog
    • 複製完自動開 PR 到既有 mono-repo

    你可以做的事

    • 把它嵌進既有的 AI 代理框架(AutoGen、LangGraph 等),當成「網站拆解模組」
    • 做一個公司內部的「一鍵起站」CLI:輸入競品網址 → 自動產出分析專案 + Demo 站

    💡 關鍵: 可替換模型與自訂 workflow,讓它不只是單一工具,而是能融入你整套 AI 開發流水線的「模組積木」。


    適合誰用?4 個很實際的情境

    1. 競品分析:看懂別人怎麼設計,而不是偷他內容

    「Vibecoding」的概念現在已經被拿來做軟體併購評估,Bain & Company 就會用 AI 把標的產品重現一次,看它到底有沒有護城河。

    你可以用同樣的思路:

    • 把競品的主要頁面 clone 成 Next.js 專案
    • 在程式層級看:
    • 資訊架構怎麼切
    • 互動細節放在哪些 component
    • 如何安排轉換漏斗上的 CTA

    採取行動

    • 選 1 個競品主頁 → 跑一遍 AI Cloner → 用 VS Code 開專案,直接在 component 結構裡做 UX/IA 分析筆記。

    2. 重構老專案:把舊 jQuery 站拉進現代框架

    很多公司還有:

    • jQuery + 雜 CSS
    • Server-side render 的混雜模板

    你可以:

    1. 在內網或 staging 架一份舊站
    2. 用 AI Cloner 指向這個 URL
    3. 拿到一個 React/Next.js 骨架
    4. 再慢慢把舊的業務邏輯搬過去

    採取行動

    • 挑公司裡一個「大家都嫌舊但沒時間重寫」的小工具頁面,試著用這個流程生一個新骨架,看看重構成本能不能壓下來。

    3. 設計稿 → 靜態樣板:省去第一輪切版

    設計師常丟來:

    • Figma Prototype 已經掛在公開 URL
    • 或用工具輸出成靜態 demo 站

    以前:你從零切版。現在:

    • 把這個 demo URL 丟給 AI Cloner
    • 得到一個可編輯的前端專案
    • 再按需求調整 class 命名、拆 component

    採取行動

    • 和設計師約好:先用 No-code / Figma plugin 做出可瀏覽 demo → 丟給 Cloner → 工程師直接在生成專案上改,而不是從白板開始。

    4. POC / 黑客松:一晚搞定 Landing Page + 互動畫面

    黑客松、內部 POC 最常卡在:

    • 「找不到設計」
    • 「前端做不完,最後只剩 API Demo」

    這時可以:

    • 找一個你喜歡的公開 Landing Page
    • 用 AI Cloner 生成前端專案
    • 把文案、Logo、配色改成自己的
    • 接上你做的 API / 後端

    採取行動

    • 下次 Hackathon 前先準備好一個 starter repo:裡面就是你常用的 clone 模板,換文案 + 功能就能 demo。

    怎麼開始:本機安裝到第一行指令

    以下以本機開發為例,假設你已經有 Node.js 基本經驗。

    1. 環境需求

    • Node.js:建議 18+(node -v 確認)
    • npm 或 pnpm
    • Git
    • 一組可用的 AI API Key(例如 OpenAI)

    採取行動


    2. 下載專案 & 安裝依賴

    在終端機裡:

    # 1. Clone 專案
    git clone https://github.com/JCodesMore/ai-website-cloner-template.git
    cd ai-website-cloner-template
    
    # 2. 安裝依賴
    npm install   # 或 pnpm install / yarn
    

    3. 設定 AI API Key

    通常專案會使用環境變數(.env)。以 OpenAI 為例:

    1. 在專案根目錄建立 .env
    2. 寫入類似:
    OPENAI_API_KEY=你的_API_Key
    MODEL_NAME=gpt-4.1-mini  # 或你想用的模型
    

    實際變數名稱以 repo 文件為準,請對照 GitHub README。

    採取行動


    4. 下第一個指令:輸入網址 → 生成專案

    安裝完成後,專案通常會提供一個 CLI script,例如(實際命令以 README 為準):

    # 假設提供 npx 方式
    npx ai-website-cloner clone \
      --url "https://example.com" \
      --framework "next" \
      --out-dir "./cloned-example"
    

    執行流程會大致經過:

    1. 檢查能不能連到目標網站
    2. 由 AI Agents 爬 DOM、解析樣式
    3. 生成 React/Next.js 專案骨架到指定資料夾

    完成後:

    cd cloned-example
    npm install
    npm run dev   # Next.js 開發伺服器
    

    打開 http://localhost:3000,你就會看到一個「長得很像原站」的本地版本。

    採取行動

    • 先找一個你自己做的公開測試站(或公司內部測試環境),拿來當第一個目標,熟悉流程再碰競品網站。

    5. 客製自己的 workflow:換模型、改 Agent 流程

    因為專案是 TypeScript 寫的,你可以:

    • src/agents(假設路徑)裡修改:
    • 要爬哪些路徑
    • 怎麼決定哪些 DOM 要抽成 component
    • 在設定檔裡替換成你愛用的模型:
    // pseudo example
    const client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY })
    const modelName = process.env.MODEL_NAME ?? "gpt-4.1-mini"
    

    或改成你自己的 Agent Framework,讓它在 Clone 完後:

    • 自動開 issue 給團隊
    • 自動寫一份「前端結構說明」Markdown

    採取行動

    • 挑一個最常用的模型,先固定下來(例如 gpt-4.1-mini 或 Claude 的中小模型),避免每次切專案都要改設定。

    風險與界線:這工具能做什麼、不能做什麼?

    1. 版權與服務條款:不要直接商用 clone 別人站

    AI Cloner 本質上是在「重現別人網站的設計與結構」,這很容易踩到:

    • 著作權(UI 設計、文案、圖片)
    • 服務條款(很多網站禁止自動抓取內容)

    建議用法

    • 用在:
    • 內部學習與研究架構
    • 重構自家系統(針對自己擁有的網站)
    • 內部工具、POC、Prototype
    • 避免:
    • 直接把 clone 出來的站上線做商業服務
    • 完整複製競品的 UI、文案、圖片

    採取行動

    • 在專案 README 或公司內部使用規範裡寫清楚:此工具僅用於「學習 / 內部開發」,禁止直接部署 clone 來對外營利。

    2. 安全性:vibe coding 不是免責牌

    The Verge 曾經寫過一個案例,工程師用 vibe coding 快速做站,結果留下 SQL Injection 洞。AI 幫你省的是「切版、搬磚」,不是「安全檢查」。

    使用這種工具時,記得:

    • 不要盲信生成的程式碼
    • 一律跑:
    • Lint / Type check
    • 基本安全檢查(尤其是你接上自己 API 後)
    • 對任何「用戶輸入 → 資料庫 / API」的路徑,重新檢查:
    • 有沒有做輸入驗證
    • 有沒有用參數化查詢

    採取行動

    • 把你既有的 ESLint / Prettier / 安全掃描(如 npm audit、SAST 工具)加入這個 clone 專案的 CI流程,要求「生成完也要過一輪檢查」。

    💡 關鍵: 把它當自動切版工具而非完整工程師,安全與品質檢查仍然要照表操課。


    小結:把它當「前端樣板生成器」,而不是抄襲機器

    ai-website-cloner-template 最適合的定位是:

    • 前端 / 全端工程師的 AI 起站工具
    • 幫你:
    • 把「你看到的網站」拆成「你看得懂、改得動的 React/Next.js 專案」
    • 在競品分析、系統重構、黑客松裡省下大段切版時間

    只要守住版權與安全紅線,它會是一個很好用的「AI 助手」,幫你把時間留給真正有價值的程式設計與產品決策。

    🚀 你現在可以做的事

    • 打開 https://github.com/JCodesMore/ai-website-cloner-template,clone 專案並依 README 完成第一次跑 CLI
    • 挑一個自己的舊頁面或 side project,實測從 URL → Next.js 骨架的完整流程
    • 在團隊內部 Git repo 建一個 starter 分支,把客製後的 Cloner flow 當作共用起站模板