作者: kerwin77106

  • 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 等
    – 選擇向量庫:FAISS、Weaviate、Qdrant、Elasticsearch…
    – 用同一套 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 可加入的頻道與資料政策,確保權限與留存策略清楚明確
  • Fugu 式多模型協作實戰拆解

    Fugu 式多模型協作實戰拆解

    📌 本文重點

    • 單一 LLM 容易遇到成本與供應商風險問題
    • Fugu 用任務類型與路由實現多模型協作
    • 多模型需要良好編排、仲裁與可觀測性
    • 建議從抽象 Task 與 adapter 漸進導入

    單一 LLM 做所有事情的痛點很明確:成本不可控、供應商風險高、效能無法對應不同任務類型。Sakana 的 Fugu 路線給了一個很務實的答案:用一層編排(orchestration)把多個模型(雲端 + 本地 + 專用 code model)協作起來,把「選模型、聚合結果、錯誤控制」變成一套可維護的工程結構,而不是散落在業務程式碼裡的 if-else。


    重點說明

    1. Fugu 式類型系統:先定「任務類型」,再談選哪個模型

    Fugu 的關鍵不是多模型本身,而是任務類型(task types)+ 類型安全的輸入輸出:

    • 每個任務明確定義:
    • input schema(如 QueryTask, CodeGenTask, LongFormTask)
    • output schema(如 Answer, CodePatch, SearchPlan)
    • 路由層只依賴任務類型與 metadata(長度、成本上限、延遲 SLA),不直接寫死「如果是寫程式就用 XXX」。

    範例(TypeScript 風格的 pseudo code):

    // 1. 任務類型定義
    interface BaseTaskMeta {
      maxLatencyMs: number;
      maxCostUSD: number;
      priority: 'low' | 'normal' | 'high';
    }
    
    interface QueryTask {
      type: 'query';
      input: { question: string; context?: string };
      meta: BaseTaskMeta & { allowWebSearch: boolean };
    }
    
    interface CodeGenTask {
      type: 'codegen';
      input: { spec: string; language: string };
      meta: BaseTaskMeta & { needTests: boolean };
    }
    
    interface LongFormTask {
      type: 'longform';
      input: { topic: string; minWords: number };
      meta: BaseTaskMeta & { allowStreaming: boolean };
    }
    
    type Task = QueryTask | CodeGenTask | LongFormTask;
    

    好處:

    • 模型路由只看 Task,不看業務細節,方便之後替換模型 / 供應商。
    • 不同模型可以有不同的 prompt / tool schema,但在編排層都被包成同一個 Task 抽象。

    💡 關鍵: 先用類型把任務抽象好,之後換模型或換供應商就變成「改路由」而不是「重寫業務程式碼」。


    2. 模型路由:任務類型 × 長度 × 成本

    一個實用的路由策略通常只靠幾個欄位就夠了:

    • 任務類型:
    • codegen → 專用 code model(如 o3-mini、DeepSeek-Coder、本地 Qwen code)
    • query → 一般對話模型(OpenAI / Anthropic / 本地)
    • longform → 長 context 模型(如 200k+ context),或拆段 + 聚合
    • 長度估計:預估輸入 token + 預計輸出 token,超過本地模型 context 就路由到雲端長上下文模型。
    • 成本與延遲:
    • maxCostUSD 控制是否可以打貴模型
    • maxLatencyMs 決定是否啟用並行查詢 + 快速仲裁

    簡化版路由器:

    function routeModel(task: Task): 'openai:gpt-4.1-mini' | 'local:qwen' | 'openai:o3-mini' {
      const estTokens = estimateTokens(task.input);
    
      if (task.type === 'codegen') {
        // code 任務預設走專用 code model
        return task.meta.maxCostUSD < 0.05 ? 'local:qwen' : 'openai:o3-mini';
      }
    
      if (task.type === 'longform') {
        if (estTokens > 120_000) return 'openai:gpt-4.1-mini';
        return 'local:qwen';
      }
    
      // query 一般問答
      if (task.meta.maxLatencyMs < 3000) {
        // 低延遲預算 → 本地或較小雲端模型
        return 'local:qwen';
      }
    
      return 'openai:gpt-4.1-mini';
    }
    

    這類路由就是 Fugu 類型系統在工程上的落地:先把任務分型,路由邏輯就自然長出來。

    💡 關鍵: 用 maxLatencyMs、maxCostUSD 這類 metadata 控制路由,可以在同一套架構裡同時優化成本與延遲。


    3. 回覆聚合與仲裁:多模型輸出怎麼合成一個答案

    多模型協作的價值在於:

    • 一部分模型擅長查(search / recall),一部分擅長寫(rewrite / explain)
    • 或同一任務交給兩個模型,透過仲裁降低幻覺

    典型做法:

    1. 並行呼叫 2–3 個模型:如本地 Qwen + 雲端 GPT
    2. 用一個「仲裁模型」來閱讀所有候選答案,輸出最終回覆與信心分數

    仲裁 prompt 示意:

    const arbiterPrompt = `你是仲裁模型。你會看到多個模型的回答,請:
    1. 比較其一致性與是否自相矛盾。
    2. 檢查是否有推理錯誤或明顯幻覺。
    3. 選出最可信的一個,並在有疑慮時標記「不確定」。
    
    輸出 JSON:
    {
      "winner": "model_a" | "model_b",
      "confidence": 0-1,
      "final_answer": "...",
      "notes": "..."
    }`;
    

    好處:

    • 提高可靠性(特別是檢索或工具調用密集場景)
    • 可以把仲裁結果記錄下來,用於後續離線分析各模型表現

    成本上升是必然,常見做法是:

    • 只在 高價值任務 / 有風險的 domain(法律、醫療) 開啟仲裁
    • 其他場景靠單模型 + tool verification 解決

    4. 單一 LLM vs 多 LLM 編排:實際取捨

    單一 LLM:

    • 優點:實作簡單、debug 容易、觀測鏈短
    • 缺點:
    • 價格彈性差:所有任務都用貴模型
    • 供應商風險:價格調整、限額、區域封鎖都直接影響產品
    • 難以對應極端需求(超長上下文、線下敏感數據)

    多 LLM 編排(Fugu 路線):

    • 優點:
    • 不同任務用最合適的模型 → 可靠性與成本可同時優化
    • 可以把敏感任務 route 到本地模型,降低隱私風險
    • 雲端服務掛了可以 fallback 到次佳方案
    • 缺點:
    • 觀測與 debug 變複雜(誰的錯?哪一層出問題?)
    • 延遲可能放大(串聯多步、多模型仲裁)
    • 各家 API、tool schema、系統提示格式不一致,需要一層 adapter

    對多數專案來說:

    • MVP 階段 → 單一 LLM + 清楚的 abstraction
    • 成本 / 隱私壓力出現後 → 漸進式導入多模型編排,而不是一次重寫

    💡 關鍵: 多模型不是為了「酷」,而是為了在成本、可靠性、隱私之間取得更穩定的折衷。


    實作範例:OpenAI + 本地 Qwen + 專用 code model

    以下給出一個可自建的最小多模型編排骨架(Node/TypeScript 風格,但概念可套任何語言)。

    1. API 介面設計

    對前端/上游只暴露一個 API:POST /v1/ai/execute,輸入統一的 Task 結構。

    // express / fastify handler
    app.post('/v1/ai/execute', async (req, res) => {
      const task: Task = req.body;
    
      const modelId = routeModel(task);
    
      const controller = new AbortController();
      const timeout = setTimeout(() => controller.abort(), task.meta.maxLatencyMs);
    
      try {
        const rawResponse = await callModel(modelId, task, { signal: controller.signal });
        const parsed = normalizeOutput(task, rawResponse);
    
        await logTask({ task, modelId, rawResponse: parsed });
    
        res.json(parsed);
      } catch (e) {
        const fallback = await tryFallback(task, modelId);
        res.json(fallback);
      } finally {
        clearTimeout(timeout);
      }
    });
    

    2. 模型 adapter:解決不同 API / token 格式

    常見坑是:

    • 系統訊令格式不同(OpenAI messages vs 本地單純 prompt)
    • tool / function call schema 不同

    用 adapter 隔離差異:

    async function callModel(modelId: string, task: Task, opts: { signal: AbortSignal }) {
      switch (modelId) {
        case 'openai:gpt-4.1-mini':
          return callOpenAI(task, opts);
        case 'openai:o3-mini':
          return callOpenAICode(task, opts);
        case 'local:qwen':
          return callLocalQwen(task, opts);
        default:
          throw new Error(`Unknown model ${modelId}`);
      }
    }
    
    async function callOpenAI(task: Task, { signal }: { signal: AbortSignal }) {
      const messages = buildMessagesFromTask(task);
      const resp = await openai.chat.completions.create({
        model: 'gpt-4.1-mini',
        messages,
        temperature: 0.2,
        response_format: { type: 'json_object' },
        signal,
      });
      return resp.choices[0].message.content;
    }
    
    async function callLocalQwen(task: Task, { signal }: { signal: AbortSignal }) {
      const prompt = buildPromptFromTask(task); // 單一 string
      const resp = await fetch('http://localhost:8000/v1/completions', {
        method: 'POST',
        body: JSON.stringify({
          model: 'qwen-32b-instruct',
          prompt,
          max_tokens: 2048,
          temperature: 0.1,
        }),
        signal,
      }).then(r => r.json());
      return resp.choices[0].text;
    }
    

    只要嚴格把「怎麼跟模型講話」鎖在 adapter 裡,上層就可以只面對 Task。


    3. 超時與 fallback 策略

    簡單可行的策略:

    1. 以延遲為主的 fallback:

    2. 本地模型超時 → fallback 到雲端小模型

    3. 雲端模型錯誤/超時 → fallback 到本地(或退化版回答)
    async function tryFallback(task: Task, failedModelId: string) {
      const fallbackId = pickFallbackModel(task, failedModelId);
      if (!fallbackId) throw new Error('No fallback model');
    
      const raw = await callModel(fallbackId, task, { signal: AbortSignal.timeout(2000) });
      return normalizeOutput(task, raw, { degraded: true, usedFallback: true, fallbackId });
    }
    
    1. 回應標註退化狀態:在 normalizeOutput 中加入:
    {
      "answer": "...",
      "meta": {
        "modelId": "local:qwen",
        "usedFallback": true,
        "fallbackFrom": "openai:gpt-4.1-mini",
        "degraded": true
      }
    }
    

    讓前端可以決定是否顯示「此回答為備援模型生成」。


    4. 觀測與日誌結構:解決「昨晚 agent 到底做了什麼」

    多模型編排很容易變成黑箱。建議最少做到:

    • 每個 Task 一個 traceId
    • log 中至少包含:
    • traceId, task.type, task.meta
    • 選擇的 modelId、fallback 情況
    • 每步 latency、token 使用量
    • 仲裁結果(如果有)

    示意:

    interface TaskLog {
      traceId: string;
      taskType: Task['type'];
      modelId: string;
      fallbackFrom?: string;
      latencyMs: number;
      inputTokens: number;
      outputTokens: number;
      success: boolean;
      error?: string;
    }
    
    async function logTask(log: TaskLog) {
      // 可寫入 ClickHouse / BigQuery / Elastic
      console.log(JSON.stringify({ kind: 'taskLog', ...log }));
    }
    

    這類結構化 log 是後續做「loop engineering」(自動 self-correct / regression test)與成本優化的基石。


    建議與注意事項

    1. 延遲放大:多模型 ≠ 多倍延遲

    • 儘量並行呼叫可獨立的模型,再用仲裁合併。
    • 嚴格設定 per-model timeout,避免某個模型拖垮整個請求。
    • 對長任務(如自動寫測試、長時間 agent loop)要分段 log,避免只看到「跑了一小時,掛了」。

    2. 工具 / 系統 prompt 不一致

    • 不同家模型對 system / tools / function calling 的支援度不同。
    • 最好的做法:
    • 定義自己的 工具層 schema(如 JSON Tool 定義)
    • 在 adapter 把它映射成各模型需要的格式
    • 千萬避免在業務邏輯裡到處寫 if (model === 'gpt-4.1-mini') 這種分支。

    3. 責任歸屬與 debug 困難

    多模型編排容易出現:

    • prompt 沒設好 → 模型亂回答
    • 路由策略不合理 → 小模型被丟去做艱難任務
    • 仲裁錯誤 → 明明較好的答案被丟掉

    實務上建議:

    • 為每一層定義清楚的「契約」:
    • 路由層:輸入 Task,輸出 modelId,不關心內容
    • adapter:保證把 Task 翻譯成該模型最佳格式
    • 仲裁層:對模型輸出負責,不對業務邏輯負責
    • 做回溯時先問:錯在路由、adapter、模型本身、還是仲裁?

    4. 不要一開始就 over-engineer

    • 若你現在是:一個雲端 LLM + 少數工具,建議只先做:
    • 抽出 Task 類型
    • 寫好 model adapter(即使目前只有一個模型)
    • 之後要引入本地 Qwen、專用 code model、Fugu 式仲裁機制,就只是替換實作,而不是重寫整個系統。

    核心結論: 多模型協作不是把更多模型硬塞進系統,而是用 清晰的任務類型 + 路由 + 仲裁 + 可觀測性,把「哪個模型做什麼」變成一個可以演進的工程決策。從這個角度看,你可以在自己的專案裡做一個「迷你 Fugu」,用極少的代碼換來更好的成本控制、可靠性與供應商彈性。


    🚀 你現在可以做的事

    • 在現有專案中抽出一層 Task 類型與 routeModel(),把模型選擇邏輯從業務程式碼移出來
    • 寫一個簡單的 model adapter(例如包一層 callModel()),即使目前只支援單一 gpt-4.1-mini
    • 為每次模型呼叫加上 traceId 與結構化 log,開始累積日後做成本與可靠性優化所需的資料
  • 用 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/yarn 依 README 說明):

    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 當作共用起站模板
  • Anthropic 與政府開戰:錯殺安全,放生風險

    Anthropic 與政府開戰:錯殺安全,放生風險

    📌 本文重點

    • 事後出口管制只會把高階攻防 AI 趕進黑箱
    • 安全即服務比純攻防研究更合監管胃口
    • 應建立能力分級與安全 sandbox,而非臨時封殺

    用出口管制去兜 AI 安全,是把「國安恐慌」當成總開關,卻沒有任何清晰的電路圖。在 Anthropic–美國政府圍繞 Mythos/Fable 的衝突裡,真正被按下暫停鍵的,不只是某個模型,而是整個產業對「高階攻防 AI」能否在陽光下發展的信心。從開發者和公司角度看,臨時拍板封模型,只會推動更隱蔽、更不透明的攻擊性研究。


    一、從 Mythos 到出口禁令:高階 code model 被當作軍規武器的那一刻

    時間線先拉直:

    • 4 月:Anthropic 對外承認打造了一個名為 Mythos 的模型——內部評估「強到可能構成全球級網安威脅」,先只開給少數資安專家測試,性質明確是「對手模擬」與安全研究。
    • 之後公司推出經過「去武器化」的版本 Fable,對外公開,宣稱已壓抑最敏感的攻擊能力。
    • 6 月 9 日:Fable 對外開放。
    • 6 月 13 日左右:美國聯邦政府迅速出手,以國家安全和出口管制為由要求 Anthropic 撤回外部訪問,實際上等於把 Fable/Mythos 推回黑箱(參考 MIT Tech Review 報導)。

    💡 關鍵: 政府在 Fable 已開放 4 天後緊急封殺,凸顯的是「事後管制」而非預先明確規則,直接打擊產業對公開攻防 AI 的信心。

    同一時間,Five Eyes 聯盟對外放話:

    「足以癱瘓政府與企業的前沿 AI 攻擊模型,可能只差數月。」

    這把 Mythos/Fable 的定位,直接拉到「準軍事級攻擊工具」:

    • 不是一般 code assistant,而是能系統性探索、利用漏洞的 offensive cyber ops 力量倍增器。
    • 在這個敘事下,高階 code model 不再只是開發者工具,而是可被出口管制、等同武器的技術項目。

    問題在於:政府出手的節點,是「模型已經做出來、已經短暫開放之後」,靠一紙命令緊急踩煞車。這種「事後封殺」的監管節奏,對產業的扭曲效果,遠比一開始就訂清楚規則還要糟。


    二、「事後封殺」的三重副作用:自我閹割、研究灰色化、競爭外溢

    1. 對大模型公司:被迫安全自殘,真正危險的東西改到陰影裡做

    從 Anthropic 的角度,Mythos 原本就是一種 紅隊工具:讓自己與合作夥伴看清「下一代攻擊者」到底能做到什麼。這種模型若被直接視為「不能出口的軍規品」,大廠自然會得到一個非常清晰的訊號:

    「你越誠實展示攻擊能力,就越有可能被政府鎖喉。」

    結果會是:

    • 公司在公版模型上刻意弱化 offensive 能力,避免被盯上。
    • 真正前沿、帶攻擊性能力的模型,轉入內部、合作軍方或特定客戶的封閉專案,甚至乾脆不公告存在。

    換句話說,政府成功讓自己看不到最危險的模型——因為誰還會主動舉手說「我這裡有顆可能會被你封殺的彈頭」?

    2. 對開發者與資安社群:從開源攻防回到黑箱試爆

    出口管制直指的是「模型的跨境提供」,但心理寒蟬效應會一路蔓延到:

    • 資安研究團隊:開始猶豫是否要公開使用 Mythos/Fable 類模型的實驗結果,怕被解讀成「促進攻擊技術擴散」。
    • 開發者:不確定什麼樣的 code model API 使用場景會構成「出口」或「協助敵對方」。

    結果是:

    • 合法安全研究被擠壓到灰色地帶,大家改用更模糊、不具體的方式描述攻擊路徑,避免被貼標。
    • 攻防能力從「開源 + 公開基準」退回「黑箱 + 內部測試」——以前你可以在 GitHub、CTF write‑up 看到清楚的 PoC 和工具,未來關鍵方法可能只存在於特定企業、政府部門的內部 repo。

    安全社群最怕的不是「沒有風險」,而是風險存在、卻無法公開討論和共測。出口管制如果逼得大家少講一點、少分享一點,實質上就是幫攻擊者做資訊不對稱。

    3. 對全球競局:美國鎖住自己,卻沒鎖住世界

    從國際視角來看,出口管制的約束力主要落在美國及其盟友企業,但:

    • 監管較鬆的國家可以照樣追逐高攻擊性的 AI 模型,甚至更大方與軍事、情報部門深度整合。
    • 非民主政體根本不需要顧慮「開放測試」或「社群責任」,專心追求可用的 offensive 能力即可。

    於是形成一個怪異局面:

    美國把自家公司最前沿的 offensively-capable 模型「封在內部」、限縮外放,等於把研發外溢紅利拱手讓給管得比較鬆的競爭對手。

    若缺乏透明規則,美國公司為了避免觸法,會走向最保守路徑;而那些最不在乎人權與戰爭法的 regime,反而能在沒有公共審視壓力下,肆意武器化 AI。


    三、兩條路線的分叉:Security‑as‑a‑Service vs. Security Research‑as‑Risk

    對比 Anthropic 被迫關門,OpenAI 在同一時間選擇的是另一種策略:

    • 推出 GPT‑5.5‑Cyber,專門強化網路安全場景。
    • 上線 Daybreak 工具套件(含 Codex Security、GPT‑5.5‑Cyber),鎖定「幫企業自動找洞、驗洞、補洞」。
    • 發起 「Patch the Planet」 計畫,直接切入開源維護者生態,用 AI + 專家審核,去整理、修補開源軟體的漏洞。

    本質上,OpenAI 做的是:

    把模型的攻擊理解力包裝成「防禦服務」,以 B2B / B2G 安全方案的形式交付,而不是裸露的攻擊工具。

    於是產業正在形成 兩條路線:

    1. 安全即服務(Security‑as‑a‑Service)
    2. 模型的 offensive 能力被「鎖」進一套完整的流程:資產盤點、漏洞掃描、驗證、修補建議。
    3. 對政府而言,這比較容易被接受:我買的是防禦產品,不是直接賣武器。

    4. 研究即風險(Security Research‑as‑Risk)

    5. 像 Mythos/Fable 這樣,直接提供強攻防能力給研究社群測試。
    6. 在目前的政治氣氛下,任何沒有明確「防禦產品包裝」的高階攻防模型,都會被預設為國安風險。

    💡 關鍵: 同樣的攻防能力,包成企業安全服務就較易被接受,直接以研究形式釋出則被視為國安風險,決定性差別在「交付形式」而非能力本身。

    從短期現實來看,OpenAI 這套「安全能力商品化」的路線,顯然比 Anthropic 的「攻防能力研究優先」更符合監管胃口。但如果整個產業都被迫往 Security‑as‑a‑Service 收斂,開放式安全研究將被邊緣化,攻擊面的系統性理解會落在少數大廠與政府手中,整體社群的防禦韌性反而難以提升。


    四、我們真正需要的:分級規則、測試 sandbox、跨國紅線

    從產業與開發者角度,問題不在於政府要不要管,而在於「怎麼管」。現在這種「模型先做出來 → 公司開始小心測試 → 政府後知後覺 → 用出口管制一鍵封殺」的流程,只會製造更多黑箱。

    💡 關鍵: 如果管制流程仍停留在「先做後封」,企業只會學會隱匿能力而非降低風險,長期反而削弱整體安全。

    更務實的方向應該是:

    1. 以能力分級,而非品牌、單一事件分級
    2. 制定清楚的 capability‑based 分級框架:例如在自動化漏洞挖掘、利用程式生成、跨步驟攻擊鏈構造方面的能力指標與等級。
    3. 公司只要模型達到某級別,就需申報與履行特定義務,而不是等媒體爆出某個「危險模型」才臨時動刀。

    4. 建立可預期的安全測試 sandbox 機制

    5. 允許企業在受監管的環境裡,向合格資安研究者開放高風險模型,前提是資料、使用範圍、審核流程透明可查。
    6. 政府要做的是 認證與協調 sandbox,而不是把所有「危險模型」直接關進地牢。

    7. 推動跨國紅線共識,而不是單邊出口懲罰

    8. 至少在 Five Eyes 及主要技術國家間,針對「不可接受的攻擊用例」畫出共同紅線,例如關鍵基礎設施攻擊自動化。
    9. 將違反紅線的行為與制裁、刑責綁在一起,而不是只對模型本身動刀。

    對開發者與企業的實際建議是:

    • 把「安全能力」產品化,而不是孤立地展示模型能多會攻擊。 在現階段監管環境下,純攻防能力展示只會替自己引火上身。
    • 主動參與、甚至自建透明測試框架,為未來的 capability‑based 管制預做準備,避免在規則成形後被動挨打。
    • 堅持公開防禦知識與工具標準(測試基準、漏洞分類、修補流程),即便不能完全公開模型,也要確保防禦側的共享不斷線。

    如果我們把「危險 AI」的標準交給臨時起意的出口禁令,最後只會得到一個更危險、更不透明的攻防 AI 世界。產業真正需要做的,不是躲避監管,而是逼迫監管走向可預期、可對話、可驗證的分級與 sandbox。否則,下個被關進黑箱的,不會只有 Mythos,而是整個 AI 安全研究的未來。

    🚀 你現在可以做的事

    • 檢視自家或團隊的攻防 AI 研究,將純攻擊展示改為附帶清楚的防禦與修補流程
    • 規劃一套內部 capability‑based 能力分級與審查表,預先對照可能的未來監管要求
    • 參與或發起公開的安全測試 sandbox 計畫,與其他團隊共享防禦基準與最佳實務
  • GLM‑5.2:開源 Agent 新天花板?

    GLM‑5.2:開源 Agent 新天花板?

    📌 本文重點

    • GLM‑5.2 是 MIT 授權且接近前沿商模的 Agent 中樞
    • 透過蒸餾子模型可在本地/私有雲低成本部署
    • 適合作為規劃與工具調用的 Agent orchestrator
    • 企業可用三種架構落地並建立自有 Agent benchmark

    GLM‑5.2 對開發者最直接的價值是:在完全開源 MIT 授權下,給你一個接近前沿商業模型的 Agent 中樞。它在 Terminal-Bench >80%、在 AA‑Briefcase / Agentic Benchmark 中與 Claude Fable 等前沿模型同梯,代表實際做工具調用、長鏈規劃、知識工作時,不用一定綁在雲端閉源 API。

    💡 關鍵: Terminal-Bench 超過 80% 且與 Claude Fable 同梯,代表在實際工具調用與長鏈任務中,GLM‑5.2 的能力已達前沿商用水準。

    對專案的具體好處:

    • 做公司級多工具 Agent(RPA、內部 API、自動報表)時,可以用 GLM‑5.2 做規劃 + 蒸餾子模型做執行,成本與隱私更可控。
    • 在本地/私有雲部署高能力 Agent 中樞,少一層雲廠商依賴,合規與資料主權好談很多。
    • 透過官方與社群蒸餾的小模型,在 Mac / 單機 GPU 就能享受接近前沿的推理與工具調用策略。

    重點說明

    1. 模型尺度、MoE / 蒸餾與長上下文:怎麼影響推理與工具調用

    1. 巨型主模型 + 蒸餾路線

    2. 主模型約 753B 參數,不適合直接上普通伺服器,但它的角色更像是:

      • 產生高質量 reasoning / tool use 數據
      • 蒸餾到 8B / 70B 級別子模型
    3. 實務上:你大多會用的是 GLM‑5.2-XXB / Q 量化版 或社群蒸餾模型,而不是原始 753B。

    💡 關鍵: 753B 主模型主要作為教師模型,用來蒸餾出 8B–70B 可實際部署的子模型,將前沿能力壓縮到可負擔硬體。

    1. (推測的)MoE / 稀疏結構與 Agent 表現

    類似 Laguna M.1 這種 225B total / 23B active MoE,GLM‑5.2 也走大模型 + 高效推理的設計路線:

    • 好處:推理時啟用的參數較少,對工具調用多輪推理比較友善(成本不會爆炸)。
    • 對 Agent 的具體影響:在長鏈工具調用(多步規劃 + 多次函數呼叫)時,維持較穩的推理品質,減少「中途變笨」或指令漂移。

    • 長上下文設計與工具調用 / RAG

    GLM‑5.2 支援長 context(官方數據仍在演進,但已對標 128k 級別),實務上:

    • 可以把 任務規格 / SOP / API 文檔 全塞 context,而不是零碎分片。
    • 支援 多輪工具調用結果 + 原始文件 一起放入 context 作決策。
    • 對 AA‑Briefcase 這種知識工作型 Agent 基準,長 context 是重要加分點:能在一個 session 內完成完整專案級任務,而不是「記憶斷層」。

    結論: GLM‑5.2 的設計路線,讓它更適合作為 Agent 中樞(planner / orchestrator),而不是單純的聊天模型。


    2. 從新 Agent 基準看實際能力:AA‑Briefcase / Agentic Benchmark

    Artificial Analysis 的 AA‑Briefcase 與 Agentic Benchmark 主要測:

    • 任務分解與規劃(多步 Subtask)
    • 工具選擇與參數填寫
    • 長鏈任務中 保持目標一致性
    • 知識工作(報告撰寫、資料整理)的完整度

    GLM‑5.2 在這些基準中:

    • AA‑Briefcase 得分高於 GPT‑5.5(根據社群分享),表示:
    • 在企業知識型場景(報表、合約分析、研究)中,全開源模型已能與部分 frontier 商用模型打平甚至略勝。
    • 與 Claude Fable 一起在 Agentic Benchmark 站前排,意味著:
    • 規劃能力 + 執行一致性 足以支撐多工具工作流。

    對你的專案直接影響:

    • 如果你在做 AA/BI 報表自動化、程式碼 refactor pipeline、資料處理流程(ETL + LLM),GLM‑5.2 作 orchestrator 可以大幅減少「hallucinated step」、「工具選錯」這類瑣碎 bug。

    3. 典型落地架構:雲端 / 本地蒸餾 / 混合推理

    以下給三種常見架構,對應不同企業或個人場景。

    3.1 全雲端:GLM‑5.2 作 Agent 中樞

    適合:中小團隊、不想維護 GPU 叢集。

    架構:

    • 雲端 GLM‑5.2:負責任務理解、規劃、工具路由。
    • 工具層:雲端 Functions / 內部 API(需透過 API Gateway 暴露)。

    呼叫模式示意(以假想 REST API 為例):

    import requests
    
    API_KEY = "<your_key>"
    
    payload = {
      "model": "glm-5.2-agent",
      "messages": [
        {"role": "system", "content": "You are an AI agent orchestrator."},
        {"role": "user", "content": "為我生成一份銷售數據分析報告,並畫出月度趨勢圖。"}
      ],
      "tools": [
        {
          "name": "get_sales_data",
          "description": "Fetch sales data from BI system",
          "parameters": {
            "type": "object",
            "properties": {
              "start_date": {"type": "string"},
              "end_date": {"type": "string"}
            },
            "required": ["start_date", "end_date"]
          }
        }
      ],
      "tool_choice": "auto"
    }
    
    resp = requests.post(
      "https://api.your-llm-provider.com/v1/chat/completions",
      headers={"Authorization": f"Bearer {API_KEY}"},
      json=payload,
    )
    
    print(resp.json())
    

    重點:

    • 保持 tools schema 明確,讓模型容易選工具與填參數。
    • 使用 tool_choice="auto" 讓 GLM‑5.2 自主決定是否調用。

    3.2 本地蒸餾子模型:Mac / 單機 GPU 友善方案

    適合:

    • 個人開發者 / 團隊想要 完全離線 或高隱私場景。
    • CPU + 單張高 VRAM GPU(24–48G)或 Apple Silicon。

    常見作法:

    • 選擇社群已蒸餾的 GLM‑5.2-8B / 12B / 70B Q 量化版。
    • 使用 vLLM / llama.cpp / Ollama 啟動本地服務。

    vLLM 啟動範例(虛構 CLI):

    python -m vllm.entrypoints.openai.api_server \
      --model THUDM/glm-5.2-8b-instruct \
      --dtype bfloat16 \
      --max-model-len 65536 \
      --gpu-memory-utilization 0.9
    

    客戶端程式碼(走 OpenAI 兼容 API):

    from openai import OpenAI
    
    client = OpenAI(base_url="http://localhost:8000/v1", api_key="dummy")
    
    resp = client.chat.completions.create(
      model="THUDM/glm-5.2-8b-instruct",
      messages=[
        {"role": "system", "content": "You are a local coding assistant."},
        {"role": "user", "content": "幫我寫一個 FastAPI endpoint,調用本地 sqlite 並回傳 JSON。"}
      ]
    )
    
    print(resp.choices[0].message.content)
    

    好處:

    • 所有程式碼 / 資料留在本地,企業內網可直接部署。
    • 透過蒸餾模型,保持相當一部分 GLM‑5.2 的推理與工具調用策略。

    3.3 混合推理:Frontier 規劃 + 本地執行

    適合:

    • 需要 高質量規劃 + 嚴格資料邊界 的企業(例如金融、醫療)。

    典型流程:

    1. 使用雲端 GLM‑5.2(或其它 frontier 模型)做 高層規劃:
    2. 任務分解
    3. 工具調用序列設計
    4. 校驗條件(風控檢查、審批流程)
    5. 將規劃結果(純文本 JSON)送到 本地蒸餾模型 + 工具執行器。

    簡化 pseudo-code:

    # Step 1: 雲端 GLM-5.2 規劃
    plan = glm_cloud.plan_task(
      goal="整理本季度客戶交易,產出風險報告並寄給風控部門",
      tools=["fetch_trades", "calc_risk_score", "email_sender"],
    )
    
    # plan 內容示意
    # {
    #   "steps": [
    #     {"id": 1, "tool": "fetch_trades", "params": {...}},
    #     {"id": 2, "tool": "calc_risk_score", "depends_on": [1]},
    #     {"id": 3, "tool": "email_sender", "depends_on": [2]}
    #   ]
    # }
    
    # Step 2: 本地執行
    result = local_agent_executor.execute(plan)
    

    關鍵:

    • 雲端只處理 抽象任務描述與工具名稱,不直接接觸敏感原始資料。
    • 本地 Executor 透過 ID mapping + 最少必要字段 執行,避免計畫內容帶出敏感信息。

    實作範例:簡單 Agent Orchestrator

    以下是一個極簡 Python Agent orchestrator,使用 OpenAI 相容接口,換成 GLM‑5.2 只要換 base_url / model 名稱。

    from openai import OpenAI
    import json
    
    client = OpenAI(base_url="http://localhost:8000/v1", api_key="dummy")
    
    TOOLS = {
      "search_docs": lambda q: f"[mock] search result for: {q}",
      "calc_sum": lambda a, b: a + b,
    }
    
    SYSTEM_PROMPT = """
    You are an agent that decides when to call tools.
    Always return in JSON with either {"type":"tool_call", ...} or {"type":"answer", ...}.
    """
    
    
    def call_llm(messages):
      resp = client.chat.completions.create(
        model="THUDM/glm-5.2-8b-instruct",
        messages=messages,
        temperature=0.2,
      )
      return resp.choices[0].message.content
    
    
    def run_agent(user_query: str):
      messages = [
        {"role": "system", "content": SYSTEM_PROMPT},
        {"role": "user", "content": user_query},
      ]
    
      while True:
        output = call_llm(messages)
        try:
          obj = json.loads(output)
        except json.JSONDecodeError:
          return output
    
        if obj["type"] == "answer":
          return obj["content"]
    
        if obj["type"] == "tool_call":
          tool_name = obj["tool_name"]
          args = obj.get("args", {})
          if tool_name not in TOOLS:
            tool_result = f"Unknown tool: {tool_name}"
          else:
            tool_result = TOOLS[tool_name](**args)
    
          messages.append({"role": "assistant", "content": output})
          messages.append({"role": "tool", "name": tool_name, "content": str(tool_result)})
    
    
    if __name__ == "__main__":
      ans = run_agent("幫我計算 123+456,並解釋計算過程。")
      print(ans)
    

    重點:

    • 用 SYSTEM_PROMPT 約束輸出為 JSON,避免處理自然語言結果時的 parsing 地獄。
    • 用一個迴圈模擬 工具調用 – 回傳 – 再判斷是否繼續,與多數 Agent 框架原理相同,方便日後接到 LangGraph / AgentScope 等框架。

    建議與注意事項

    1. 硬體門檻與量化選型

    • 原始 GLM‑5.2 753B 幾乎肯定需要 多卡 H100 / A100 叢集,個人/中小企業不建議直接考慮。
    • 實務上,請優先:
    • 選擇 8B–70B 蒸餾版 + Q4/Q5 量化。
    • 避免 Q2 極端量化在 Agent 場景,容易在工具調用邏輯上變得不穩定。

    2. 延遲與吞吐調優

    • 長上下文 + Agent 多輪對話 會迅速拉高 latency:
    • 推薦開啟 streaming,前端先渲染 partial response。
    • 在伺服器端設 max_tokens / max_model_len,避免單次調用耗盡 GPU 記憶體。

    伺服器設定範例(vLLM):

    --max-model-len 65536 \
    --gpu-memory-utilization 0.9 \
    --enforce-eager \
    --max-num-seqs 32
    
    • max-num-seqs 可以控制同時併發的 request,減少 tail latency。

    3. Agent 行為的評測與監控

    建議:

    • 針對 Agent 工作流建立 自有 benchmark(類似 AA‑Briefcase):
    • 固定輸入任務,檢查:步驟數量、工具選擇、結果正確性。

    • 實作簡單 事件日誌:

    • 記錄每一次 tools 調用、參數、執行時間、錯誤。
    • 可用 ELK / OpenTelemetry 打通觀測。

    示意工具 Log 結構:

    {
      "trace_id": "...",
      "step": 3,
      "tool": "fetch_trades",
      "args": {"account_id": "123"},
      "latency_ms": 230,
      "status": "success"
    }
    

    4. 用開源模型接企業資料與工具的安全實務

    • 權限邊界:
    • 工具層要設好 RBAC,例如:email_sender 只能寄給 whitelist 網域。

    • 輸入/輸出過濾:

    • 輸入前做敏感資訊 masking(客戶姓名、證號)。
    • 對輸出做 正則 / policy check(避免輸出 SQL DROP 等危險指令)。

    • 模型更新流程:

    • 新版蒸餾模型上線前,先跑一次你自家 benchmark,避免能力回退。

    總結:GLM‑5.2 目前看起來是 開源 Agent 智能的新天花板之一,特別是在規劃與知識工作場景。實務上最值得做的是:

    • 把 GLM‑5.2 當成 策略教師(teacher),讓蒸餾子模型跑在你能負擔的硬體上;
    • 在三種架構(全雲端 / 本地蒸餾 / 混合)中選一個落地;
    • 及早建立自己的 Agent benchmark 與監控,把能力提升變成可觀測、可迭代的工程流程。

    🚀 你現在可以做的事

    • 在 Hugging Face 或 GitHub 搜尋並下載一個 THUDM/glm-5.2 系列蒸餾模型,嘗試用 vLLM 或 Ollama 本地啟動
    • 依照文中示例程式碼,改成指向你的 GLM‑5.2 服務,實作一個最小可用的 Agent orchestrator
    • 針對你現有的報表或資料處理流程,設計 3–5 個固定測試任務,建立簡單的內部 Agent benchmark 與日誌監控
  • 一句話搞定 PS+Premiere 重工活

    一句話搞定 PS+Premiere 重工活

    📌 本文重點

    • Adobe 推出可用中文聊天操作的 AI 創意代理
    • Photoshop / Premiere 能一口氣完成多步驟編修流程
    • 可與 ChatGPT / Claude 串接,從腳本到成品一條龍
    • 非專業設計/剪輯者也能快速產出「有水準的粗剪」

    你只要打一句「幫我做一支 30 秒 IG Reels,從這支素材裡挑片段、加中文字幕、用品牌色做開場動畫」,Adobe 新的 AI 代理就會在 Photoshop、Premiere 裡自動跑完一串操作,省掉過去要拆成 N 個步驟的苦工。

    參考消息來源:The Decoder 報導、The Verge 報導


    核心功能:兩塊要先搞懂

    1. 在 Photoshop / Premiere 裡,用中文聊天就能跑一串編輯流程

    現在 Photoshop、Premiere 裡多了一個類似聊天視窗的 AI 助理 / 代理(creative agent)。你打文字指令,它會自己串起多個步驟,而不是只做單一功能。

    能做什麼?(Photoshop 範例)

    在 Photoshop 裡,你可以直接對 AI 助理說:

    • 「把這張產品照背景換成淺灰漸層,幫我多生 3 個構圖版本,適合 IG 正方形貼文。」
    • 「幫我把人物膚色調自然、去雜物、再輸出 1080×1350 解析度。」

    💡 關鍵: 一句指令就能完成「選取主體 → 換背景 → 修圖 → 調尺寸」的整套流程,大幅減少重複操作時間

    AI 代理會依序:

    1. 自動選取主體
    2. 生出新背景(用 Firefly 模型)
    3. 做基本修圖(膚色、瑕疵)
    4. 幫你調整尺寸與構圖

    能做什麼?(Premiere 範例)

    在 Premiere 裡,你可以說:

    • 「從這 5 支原始影片裡挑出最順的一段 30 秒,適合 IG Reels,幫我加中文字幕和簡單 BGM。」
    • 「把這段 3 分鐘訪談剪成 3 支 20 秒的短片,每支要有開場標題和結尾 CTA。」

    AI 代理會:

    1. 自動分析語音與內容節奏
    2. 把重點段落剪出來,放上時間軸
    3. 自動產生逐字稿與中文字幕
    4. 套用你預先設定好的標題樣板、字幕樣式與 BGM

    做得好的地方

    • 重複、機械的工作(切片段、對字幕時間、套版型)可以一口氣交給 AI 跑完
    • 對不熟 Premiere 的人,只要先選好樣板,以後就用一句話叫它套用

    仍然需要人手修的地方

    • 影片節奏:AI 剪出來的片段「不難看」,但你要的是「好看」──節奏、表情卡點最好手動再調
    • 品牌細節:LOGO 尺寸、字體微調、音樂音量比例,AI 會給出「合理值」,但真正的品牌一致性還是要人盯

    行動建議:

    • 下次開 Photoshop / Premiere,直接打開 AI 助理面板,先丟一個「懶人指令」給它,讓它跑完一個 end-to-end 流程,再決定你要在哪裡人工接手。

    2. 串接 ChatGPT / Claude:先聊腳本,再叫 Adobe 幫你「落地製作」

    Adobe 把這個 AI 代理開到第三方平台,像 ChatGPT 和 Claude。簡單講:

    • 在 ChatGPT / Claude 裡,你先用對話方式討論腳本、標題、分鏡
    • 確定後,一句話把結果交給 Adobe 代理去做實體的 PSD / Premiere 專案

    💡 關鍵: 把「構思與溝通」留在 ChatGPT / Claude,把「具體製作」交給 Adobe,能清楚區分腦力與體力工作

    實際工作流示意

    以一支新品介紹短片為例:

    1. 在 ChatGPT 裡:
    2. 輸入:「請幫我寫一支 30 秒 IG Reels 的腳本,產品是 XXX,對象是 YYY,用三段式:問題 → 解決方案 → 行動呼籲。」
    3. 再要求:「把這個腳本拆成分鏡腳本,列出每一鏡需要的畫面說明和字幕。」

    4. 想好腳本後:

    5. 對 ChatGPT 說:「把這個分鏡交給 Adobe Premiere AI 代理,幫我建立一個剪輯專案:用我指定的素材資料夾,按分鏡放上時間軸,預留字幕軌。」

    6. 開啟 Premiere:

    7. 你會看到一個已經排好粗剪、加好字幕框架的專案,只要做細修和套品牌樣式。

    同樣的流程也可以用在圖片:

    • 先在 ChatGPT 想好一週社群貼文主題、文案
    • 再叫 Adobe 代理批量建立多張 PSD:每張自動套用布局、顏色、標題位置

    行動建議:

    • 習慣先在 ChatGPT / Claude 把文字、腳本想清楚,再交給 Adobe 處理「體力活」,你會更清楚 AI 做到哪裡、人要接手哪裡。

    適合誰用?四種典型場景

    1. 短影音剪輯:一人小編做出「有水準的粗剪」

    如果你是:IG / TikTok / YouTube Shorts 小編或個人創作者。

    可以怎麼用:

    • 直接在 Premiere 對 AI 說:「把這支長影片變成 5 支 20 秒直式短影片,每支要有吸睛開場 3 秒。」
    • 讓 AI 先幫你做粗剪與字幕,你只要專心調整前 3 秒和結尾 CTA。

    2. 社群素材批量產出:同一主題多版變化

    如果你是:品牌社群、內容行銷。

    可以怎麼用:

    • 在 Photoshop:「幫我用這個版型,生成 10 張不同文案與背景的社群貼圖,尺寸固定 1080×1080。」
    • 搭配 ChatGPT 生好 10 則貼文文案,再給 Adobe 代理做排版、換色。

    💡 關鍵: 利用固定版型搭配批次文案,可在短時間內產出多份風格一致的社群素材

    3. 行銷企劃做 demo:先有「能看」的草稿再找設計

    如果你是:PM、行銷、業務,要做提案或內部 demo。

    可以怎麼用:

    • 在 Premiere:「幫我做一支 45 秒的提案 demo 影片,用這些截圖和產品錄屏,配上簡單字幕和背景音樂。」
    • 把 AI 做出的初版拿去開會,確認方向後再交給設計師精修,而不是一開始就寫長長需求信。

    4. 工程師做產品 demo 視覺:節省跟設計來回溝通時間

    如果你是:工程師或創業團隊早期開發。

    可以怎麼用:

    • 在 Photoshop:「把這些產品畫面排成一張簡報封面,右邊是截圖拼貼,左邊留大標題區。」
    • 在 Premiere:「用這段操作錄屏,幫我做一支 20 秒『功能亮點』短片,加三個關鍵字做浮水印文字。」

    三步驟開始玩:從更新到貼上第一句指令

    步驟一:更新到支援版本

    1. 打開 Adobe Creative Cloud 桌面程式。
    2. 在「應用程式」頁籤中,找到 Photoshop、Premiere Pro。
    3. 確認已更新到最新版本(通常會標註有 Beta 或顯示 AI 助理更新說明)。
    4. 若看到「加入 Beta 公開測試」也可以優先安裝 Beta 版,較快用到 AI 助理。

    版本與開放情況會隨區域調整,詳細可看 Adobe 官方頁面:https://www.adobe.com/creativecloud.html

    步驟二:在哪裡開啟 AI 代理 / 助理面板

    以目前公開資訊為基準,位置大致如下:

    • Photoshop:
    • 開啟 PS 後,在右側面板或上方工具列,尋找「AI Assistant」或「Assistant」按鈕
    • 點開後會出現聊天視窗,可以直接輸入中文

    • Premiere Pro:

    • 在工作區上方,尋找「AI Assistant」或「Text-based Editing / Assistant」相關入口
    • 或在視窗:Window → Extensions / Assistant 類似選單中啟用

    如果介面語系是中文版,名稱可能翻成「AI 助理」或「創意代理」。

    行動建議:

    • 找到面板後,先不要管功能列表,直接貼一句完整需求給它,看看它能自動做到哪裡。

    步驟三:直接複製貼上的 5 條中文指令

    以下指令你可以直接貼到 Photoshop / Premiere 的 AI 助理裡,視情況替換關鍵詞(品牌名、秒數、平台):

    1. IG Reels 粗剪
      「從這個序列的素材裡挑出最有重點的畫面,做一支 30 秒直式影片,適合 IG Reels,幫我加上自動中文字幕和簡單背景音樂。」

    2. 多支短片拆分
      「把這段 5 分鐘的訪談剪成 4 支 20–30 秒短片,每支要有開場標題、主講人的名字條,結尾加上『關注我們獲得更多內容』字幕。」

    3. 品牌字幕樣式套用
      「用這個序列作為範例,幫我建立一個品牌字幕樣式(字體、顏色、位置),然後把同樣樣式套用到整個專案裡所有字幕。」

    4. 社群圖批量產出(Photoshop)
      「用這張 PSD 作為版型,幫我產生 6 張不同背景顏色的版本,把主標題替換成:A、B、C、D、E、F 六個詞,輸出成 1080×1080 PNG。」

    5. 產品照電商優化(Photoshop)
      「對這一批產品照做背景去雜物,統一換成純白背景,調整光線讓產品更亮但不過曝,並輸出成適合電商的 2000px 正方形圖片。」

    如果你是非專業影片/設計人,建議的第一步是:先用其中一條指令讓 AI 幫你做「初版」,你只需要學會調整少數幾個關鍵參數(秒數、版型、顏色),就能把 Adobe 當成會做苦工的「遠端設計助理」。


    🚀 你現在可以做的事

    • 打開 Premiere 或 Photoshop,找到 AI Assistant 面板,貼上文中的任一測試指令跑一次
    • 在 ChatGPT 或 Claude 裡寫一支 30 秒 IG Reels 腳本,再嘗試用指令把分鏡交給 Adobe 代理建立專案
    • 整理一個常用素材資料夾(產品照或錄屏),專門拿來實驗不同 AI 指令,觀察哪種工作流最順手
  • Kilo:把 AI 工程師變成你的隊友

    Kilo:把 AI 工程師變成你的隊友

    📌 本文重點

    • Kilo 把「AI 寫程式」變成可維護、可自動化的流程
    • 透過 Coding Agent 深度整合 Git、CI/CD 與多模型
    • 適合從 side project 到團隊技術債整理的多種場景

    Kilo 要解決的是:開發者用一堆零散 AI 工具寫程式,卻沒有一個「可維護、可自動化」的整體開發流程。

    Kilo 自稱是「agentic engineering platform」——你可以把它想成:在你的 repo 裡駐點的一個 AI 全端工程師,會幫你

    • 建專案骨架
    • 寫/改功能
    • 跑測試、看錯誤訊息
    • 幫你重構、整理技術債

    而且能直接接上你現有的 Git repo、CI/CD、以及本機或雲端的模型 Provider。


    為什麼需要「agentic 開發平台」?

    你現在可能已經在用:

    • VS Code 外掛(例如 Continue)生成小段程式碼
    • ChatGPT / Claude 看片段檔案、問問題
    • CLI 工具跑一下重構或加註解

    問題是:

    • 多工具拼接難維護:聊天室裡有一堆 prompt 歷史、VS Code 裡有另一堆,過幾天就找不到當初怎麼做到的。
    • Prompt 難複用:每次要做類似任務,都要重新描述一遍需求,無法像 CI script 一樣版本化、共用。
    • 沒有「可測試」的 AI 工作流:AI 幫你改了一堆檔案,但沒有標準化流程(跑測試、檢查 diff、回滾),風險很高。

    💡 關鍵: Kilo 的價值在於把一次性的「聊天魔法」變成可版本化、可測試、可接入 CI/CD 的標準工程流程。

    Kilo 的定位,就是把「AI 幫你寫程式」這件事,變成可配置、可重複、接得進 CI/CD 的工程流程,而不是一次性的聊天魔法。


    核心功能 1:代碼代理接管「從建專案到重構」的流水線

    在 Kilo 裡,你不是跟模型聊聊天,而是跟一個 Coding Agent 合作。這個 agent 可以:

    • 讀你的 repo、測試檔、package.json
    • 根據指令規劃任務(新增功能、修 bug、重構)
    • 自動修改多個檔案、寫測試、跑測試
    • 回報變更內容,讓你決定要不要 merge

    你可以這樣用:

    1. 選一個 side project 資料夾:

    bash
    cd my-project
    # 假設 Kilo 提供 CLI,例如:
    kilo init

    1. 用自然語言下任務(以下為示意):

    bash
    kilo task "在 /api/users 加一個 POST /users endpoint,驗證 email 格式,並補一個 basic 測試"

    1. 查看 Kilo 的輸出:

    2. 會顯示改了哪些檔案

    3. 建議的測試指令
    4. 可能的風險或 TODO

    5. 自己跑一次 git diff,確認沒問題再 commit。

    這個流程很貼近 Reddit 那篇「local coding agents 要一直看護」的心得,只是 Kilo 把「小任務 → 跑測試 → 看 diff → 重複」這套節奏變成標準功能,而不是你自己硬湊。


    核心功能 2:跟現有 Git repo、CI/CD 同步工作

    和一般 IDE 插件不同,Kilo 一開始就假設你有一個「活生生」的 repo 和 pipeline:

    • 直接在現有 repo 裡工作:不需要複製專案到另一個 SaaS;Kilo 讀的就是你本機或公司 Git server 裡的原始碼。
    • 可輸出標準化變更:讓你用 Pull Request / Merge Request 流程來審核 agent 的修改。
    • 能接到 CI/CD:
    • 在 CI 裡觸發 Kilo 工作流,例如:當 label 標記 ai-fix 時,讓 Kilo 先嘗試修 failing test。
    • 或讓 Kilo 自動根據測試結果重新調整 patch,再推一版。

    你可以這樣實作一個「半自動工人」:

    1. 在團隊的 monorepo 裡安裝 Kilo CLI。
    2. 在 CI(例如 GitHub Actions)加一個 job,當 PR 標上 ai-refactor 時:
    3. 讓 Kilo 讀 PR 變更與測試結果
    4. 自動嘗試整理重複程式碼、加註解
    5. 再 push 一個 commit 到同一 PR
    6. Reviewer 的工作就從「手動改所有小問題」變成「看 AI 的 patch,挑重要的修改」。

    這樣 Kilo 不會變成神祕黑箱,而是像一個會寫程式的 bot,嵌在你原本的開發流程裡。


    核心功能 3:在本機模型和雲端模型之間切換

    很多人用本地模型(Local LLM)當 coding agent,遇到的情況跟 Reddit 這篇 很像:

    • 小修小補很順
    • 任務一變大就開始迷路、亂改

    Kilo 的做法是:把「用哪個模型」變成設定,而不是你心情。你可以在 config 裡設定:

    • provider = local:例如接 Ollama、LM Studio,處理日常小變更、內網環境
    • provider = cloud:接 OpenAI、Anthropic 等,用於大 refactor 或跨多模組的大任務

    一個實用策略:

    • 開發階段:
    • 小任務(例如「把這個 service 改成 async/await」)用本地模型
    • 大任務(例如「重構整個 auth 流程」)切到雲端模型
    • CI 裡:
    • 預設用較便宜的雲端模型
    • 特定 label / branch 才用昂貴、上下文大的模型

    💡 關鍵: Kilo 讓你依任務大小與上下文需求,在本地與雲端模型間切換,避免為每個任務都付「最大 context window」的成本。

    這也呼應「context window tax」那篇文章的提醒:不要盲丟整個 codebase 進去,而是用 agent 幫你整理「當下任務真正需要的上下文」,再選適合的模型處理。


    Kilo 和其它 coding agent 的差異

    目前開源世界至少有兩個熱門路線:

    • Continue:偏 IDE 助手,貼近個人開發體驗。
    • Kilo:偏「平台」,替你包一整套 agentic workflow。

    簡單對比:

    名稱 核心功能 免費方案 適合誰
    Kilo Agentic engineering 平台,整合 repo / CI / 多模型 開源 有現成 repo、想把 AI 納入正式流程的個人或團隊
    Continue IDE 內嵌 coding agent,自然語言輔助寫碼 開源 主要在本機編輯器工作、想要即時補碼的工程師

    如果你想要的是「打開編輯器、有個 AI 可以問」,Continue 很好;
    如果你想要的是「把 AI 變成團隊裡固定的一個角色」,Kilo 更接近你要的東西。


    適合誰用:三種典型場景

    1. Side project 快速起步

    狀況:

    • 你有一個想做很久的 side project,但每次卡在「先建框架、選技術棧」。

    可以這樣用 Kilo:

    1. 建一個空資料夾 my-saas-idea。
    2. 啟動 Kilo,給一句需求:

    用 Next.js + Prisma 幫我建一個基本的 SaaS skeleton,要有登入、註冊、簡單的 dashboard。

    1. 讓 Kilo 生成初始專案結構、主要頁面、基本 API。
    2. 你再手動微調風格與商業邏輯。

    目標:把「從 0 到可以 deploy」壓縮到一個晚上。

    💡 關鍵: 把從「空資料夾到可部署原型」壓縮到一個晚上,大幅降低 side project 起步門檻。

    2. 團隊做 internal tool / PoC

    狀況:

    • 老闆要一個 data dashboard、內部工作流程工具,功能明確但預算有限。

    用法:

    1. 由一位工程師負責 repo 結構和核心 domain model。
    2. 讓 Kilo 處理:
    3. 重複的 CRUD API
    4. 表單驗證
    5. 基本的表格 / 篩選 UI
    6. 在 CI 加上:
    7. 每次 PR merge 前由 Kilo 自動生成/更新 API 文件或型別註解。

    這樣人類工程師把時間花在與利害關係人對齊需求,Kilo 負責把「說得清楚的需求」變成程式碼。

    3. 既有專案引入「半自動開發工人」

    狀況:

    • 大型 legacy repo,技術債多,沒人想改。

    你可以:

    1. 挑一小塊模組(例如帳號系統),讓 Kilo 專門負責:
    2. 改 function 命名、補型別
    3. 把重複邏輯抽成共用 helper
    4. 先設定幾個安全守則:
    5. 不改動資料庫 migration
    6. 不刪 public API
    7. 每週固定開一個 ai-refactor branch,讓 Kilo 在上面做整理,再由工程師 review 部分合併。

    你會得到一個「穩定每週幫你還 10% 技術債」的 bot,而不是一次性大爆改。


    15 分鐘上手:從安裝到跑出第一個任務

    以下是一個簡化的「試玩路線」,你可以在今天就跑一遍。

    步驟 1:從 GitHub 安裝 Kilo

    1. 確認你有 Node.js(18+)和 Git。
    2. 全域安裝 Kilo CLI(命令以實際文件為準,下面為示意):

    bash
    npm install -g @kilo-org/cli

    1. 或直接把專案 clone 下來:

    bash
    git clone https://github.com/Kilo-Org/kilocode.git
    cd kilocode
    pnpm install
    pnpm build

    👉 安裝細節請以官方 repo 為準:github.com/Kilo-Org/kilocode

    步驟 2:設定第一個模型 Provider

    1. 在專案根目錄建立 Kilo 設定檔(假設為 kilo.config.json):

    json
    {
    "provider": "openai",
    "model": "gpt-4.1-mini",
    "apiKeyEnv": "OPENAI_API_KEY"
    }

    1. 在 shell 裡設定環境變數:

    bash
    export OPENAI_API_KEY=sk-...your-key...

    1. 如果想用本地模型(例如 Ollama),則把 provider 換成 ollama,並指定對應模型名稱。

    步驟 3:挑一個現有 repo 試跑小任務

    1. 選一個你熟的專案,例如:

    bash
    cd ~/projects/my-api
    kilo init

    1. 跑一個小而明確的任務,例如新增 API endpoint:

    bash
    kilo task "新增 GET /health endpoint,回傳 { status: 'ok' },並補一個簡單的測試"

    1. 等 Kilo 完成後:

    2. 先跑一次測試(例如 npm test)

    3. 看 git diff,確認改動合理
    4. 滿意就 commit:

    bash
    git add .
    git commit -m "Add /health endpoint via Kilo"

    1. 如果想試重構任務,可以改成:

    bash
    kilo task "重構 userService:把重複的 email 驗證邏輯抽成 utils/email.ts,新增測試覆蓋 edge case"

    跑完這一輪,你就會直觀感受到:Kilo 比「一般聊天式 AI」更像是一位會說明自己在做什麼的 junior 工程師,你的工作變成指定需求、設好護欄、檢查成果。


    如果你已經在用各種 AI 助手寫程式,但總覺得東一塊西一塊,不妨試著把 Kilo 當成「AI 工程師駐點平台」,用上面這個 15 分鐘路線跑一圈,看看它能幫你穩定接下哪些工作。

    🚀 你現在可以做的事

    • 打開終端機,依照文中步驟安裝 Kilo CLI,並跑完第一個 kilo task
    • 在一個熟悉的 side project 上,設定 kilo.config.json 並嘗試本地模型與雲端模型切換
    • 在團隊 repo 的 CI(例如 GitHub Actions)中新增一個 ai-refactor label 流程,讓 Kilo 試著幫忙處理技術債
  • Fable 5 被勒令下架:AI 正式變成軍火

    Fable 5 被勒令下架:AI 正式變成軍火

    📌 本文重點

    • Fable 5 事件顯示頂尖雲端 AI 已成軍民兩用戰略物資
    • 不透明出口管制正在重寫全球 AI 供應鏈與資本路徑
    • 企業技術策略需將政策風險工程化,避免單點依賴

    Fable 5 事件真正宣告的是:在美國眼中,頂尖雲端 AI 不再是軟體服務,而是可以隨時被「扣板機」的軍民兩用戰略物資。從這一刻起,誰還把 AI 當成單純 SaaS,用一份標準 DPA 以為搞定合規,就註定會被政策風險收割。


    一、從「99% 無越獄」到「0 越獄」:政府在技術上開了一張空頭支票

    根據 Wired 報導,白宮對 Anthropic 的條件是:Fable 5 若要重新上線,必須「阻擋所有 jailbreak」。安全專家幾乎一面倒認為,這在現有大型語言模型架構下根本做不到——你可以降低風險,但做不到數學意義上的 0 越獄。

    💡 關鍵: 要求「0 越獄」等於訂出一個任何現有模型都無法達到的門檻,實際決定權自然轉向政治裁量。

    技術現實長這樣:

    • 模型是高維度統計機器,不是形式驗證過的通訊協定。
    • 任何自然語言防護規則都可以被重述、包裝、套殼(prompt injection、roleplay、code wrapper)而繞過。
    • Fable 5 被指出的「問題」,甚至不是華麗的 jailbreak,而只是「幫我修這段程式碼」之類的日常請求,卻被解讀為可能協助開發攻擊工具。

    關鍵不是 Anthropic 做得多爛,而是政府要求的是一個任何現有玩家都交不出來的 K.O. 成績單。

    這導致三件事:

    1. 監管門檻變成任意門:當要求本身不可能被嚴格驗證(怎麼證明「沒有任何 jailbreak」?),實際決定權就從「技術標準」落到「政治裁量」。
    2. 懲罰的是敢講真話的人:Anthropic 長期高調談模型「攻防兩用」、公開安全評估,結果被精準鎖定;那些低調上線、少講風險的服務,反而暫時避開聚光燈。
    3. 出口管制變成產品開關:這次是要求阻擋所有外國人,包括 Anthropic 自家外籍員工,最後公司被迫直接把 Fable 5 / Mythos 5 全面下線。

    AI 供應商第一次清楚感受到:模型能不能上線,不再主要由 GPU、技術 debt 或市場需求決定,而是由出口管制官員的風險想像決定。


    二、不透明的出口管制,正在重寫全球 AI 供應鏈與資本路徑

    這次對 Fable 5 的出口管制,有幾個特徵特別刺眼:

    • 指令是「未公開(unpublished)」的行政命令,不是明文化、可預先遵循的規則。
    • 封鎖對象是「任何外國國民」,連在美國本土、受公司控管的員工也一律斷線。
    • SK Telecom 因為「被懷疑與中國有關」被點名切斷 Mythos 存取權,說明這不只是「技術風險」,更是地緣政治綁定審查。

    這種做法直接在全球 AI 生態系引發幾個連鎖反應:

    1. 華爾街開始算一筆新風險:美股 AI 廠商是「可被關掉的資產」

    當一個頂尖模型可以在 76 小時內被強制熄火,投資人自然會問:

    • 這樣的技術折現後自由現金流到底有多大折扣?
    • 同樣的國安風險,為何只砍 Anthropic,不砍其他同級模型?

    於是部分資金開始尋找「受美國出口管制影響較小的對沖標的」,包括中國本地模組、開源社群與其他司法轄區的供應商。

    1. G7 領袖公開講出大家私下都在怕的事

    在最新的 G7 峰會 上,馬克宏與莫迪明講:

    我們要美國 AI,但不想讓美國有一鍵關閉別人 AI 的權力。

    Anthropic 的全球熄火,就是這個恐懼的實景 demo:

    • 想像一個國家將醫療系統、交通指揮、軍備維運大量接在美國雲端 AI 上;
    • 某天因為出口管制、外交衝突或一則未公開命令,關鍵模型被勒令停機。

    這對任何主權國家來說,都不是「假設」,而是必須寫進風險矩陣的國安條目。

    1. 供應鏈開始尋找「美國雲以外的生路」

    2. 歐洲強化 GAIA‑X、EU AI Act 下的在地模型與雲端方案。

    3. 中國與全球南方更有理由推進本土大模型,並把「不受美國開關控制」當作賣點。
    4. 雙邊合作開始出現奇怪的條款:
      • 「不得轉授予美國控制的第三方雲」
      • 「核心推理需可在本國境內離線運行」

    💡 關鍵: Fable 5 全球熄火,讓各國具體看到「雲端 AI 可在數十小時內被關掉」,主權風險不再只是理論。

    Fable 5 不是一個產品被關掉,而是一次全球直接看到「AI 供應鏈主權風險」的實況轉播。


    三、從「雲端依賴」到「政策工程」:企業與開發者要重寫技術策略

    對開發者與企業來說,這次事件最殘酷的教訓是:

    你不是在用一個 API,你是把業務命脈綁在某個國家的國安委員會上。

    之後的 AI 技術策略,不再只是 性能 vs 成本,而是至少三軸拉扯:性能 vs 主權 vs 合規。

    1. 性能:SOTA 不再總是正解

    Fable 5 展現的長上下文、高階程式分析與科研輔助能力,確實是生產力飛躍。但如果:

    • 啟用某個模型意味著隨時有一紙出口令把你核心功能拔掉;
    • 你甚至無法預測自己是否踩中「敏感行業」「敏感國家」的模糊定義,

    那麼下一代架構設計就必須接受一個現實:

    最強的模型只適合做「可被拔掉」的加分項,而不能是業務「唯一依賴」。

    2. 主權:把「可遷移、可替代」寫進技術設計

    實務上,應該開始做幾件事:

    • 多雲多模型設計:
    • 同一條關鍵業務線,至少要掛上 1 個美國模型 + 1 個本地或區域模型 + 1 個開源 fallback。
    • 前端語義層與工具鏈獨立於單一供應商,降低切換成本。
    • 資料與推理可在本地落地:
    • 有能力時,將最敏感場景遷往 on‑prem / VPC,使用自管或可在本國境內運行的模型。
    • 在合規上為「必要時可脫鉤美國雲」留條出路。

    💡 關鍵: 架構上預留「可替代、可遷移」,是對未來禁運或熄火場景的一種保險,而不是性能上的奢侈選項。

    3. 合規:把政策風險工程化,而不是交給法務最後救火

    Fable 5 的教訓之一,是單純把「AI 風險」交給合規部門已經不夠。你需要的是:

    • Policy‑as‑Code 思維:把出口管制、地域限制、使用者身份規則,變成可程式化策略引擎,而不是散落在合約 PDF 裡。
    • 模型路線圖中預留「監管事件」版本分支:
    • 假設某一等級模型被突然禁用時,要切換到哪些替代模型、哪些功能降級、哪些國家暫停服務。
    • 把這些流程當成 SRE 的「演練場景」,不只是 DR(災難復原),而是 GR(Geopolitics Recovery)。
    • 供應商風險評估不只看技術,也看地緣政治暴露度:
    • 例如:公司股權結構、主要客戶分佈、是否已被點名參與國防計畫,這些都會影響它被「特別關照」的機率。

    結語:Fable 5 是分水嶺,不是意外

    Fable 5 被下架,象徵的是 AI 產業從「自由競跑」正式切換到「地緣政治規則戰」模式。之後每一個嚴肅的 AI 團隊,都必須承認:

    • 模型選型 ≈ 地緣選邊站。
    • 架構設計 ≈ 對未來禁運場景的保險。
    • 產品路線圖 ≈ 技術、商業與政策三方博弈的結果。

    行動建議很直接:

    1. 在技術規劃文件中,新增一章〈政策風險設計〉,與可靠性、安全性同等級。
    2. 為關鍵功能至少接兩家不同司法轄區的模型供應商,並預先實作自動降級邏輯。
    3. 把法務、政策研究與架構師拉到同一張桌子,定期演練「某模型被出口管制」的紅隊演習。

    未來 AI 競爭,已經不只是「誰的模型更強」,而是誰能在國際規則的夾縫中,把風險工程化,仍持續交付可靠能力。Fable 5 只是第一個被當眾扣板機的例子,不會是最後一個。

    🚀 你現在可以做的事

    • 盤點現有產品對單一雲端 AI 供應商的依賴度,畫出「被關掉時」的影響矩陣
    • 在技術路線圖中加入第二家不同司法轄區模型的接入計畫,實作基本降級與切換機制
    • 與法務/政策研究/架構團隊安排一次「模型被出口管制」桌上演練,寫成標準作業流程