標籤: 本地部署

  • 一行 API 串 34 家免費 LLM

    一行 API 串 34 家免費 LLM

    📌 本文重點

    • 一個 OpenAI 風格 /v1 入口接 34 家免費 LLM
    • 改 baseURL 即可把現有專案切到免費模型
    • 內建智慧路由、故障切換與 API key 加密
    • 特別適合 side project、AB test 與教學場景

    用 freellmapi,你可以用一個 OpenAI 風格的 /v1 API,一次接上 34 家免費 LLM 供應商、635 個模型端點,還幫你自動路由、故障切換與加密 API key。

    專案連結:tashfeenahmed/freellmapi on GitHub


    核心功能:為什麼值得多看一眼?

    1. 統一 OpenAI 風格 API,一行替換

    freellmapi 把所有免費 LLM 都包成一個 OpenAI 相容的 /v1 入口,你原本用 OpenAI 的程式碼,只要改「base URL」就能直接跑:

    • 不需要逐家閱讀文件(OpenAI、DeepSeek、Groq…)
    • 不需要改 SDK,只動環境變數或初始化設定

    行動建議:

    先想一個你現在在用的 OpenAI 小專案(chatbot、摘要、工具人腳本),等等在「實作教學」小節,直接照著把它改接 freellmapi 當後端。

    💡 關鍵: 只改 baseURL 就能讓既有 OpenAI 專案直接跑在 34 家免費 LLM 上,幾乎零改動成本。


    2. 智慧路由與自動故障切換

    freellmapi 會在後端幫你:「這次要用哪個免費模型?」

    • 以你設定的「模型白名單」與「路由策略」挑選模型
    • 若某個供應商 rate limit 或掛掉,自動換下一個
    • 同一個「邏輯模型名」可以對應多個實際端點

    效果:你把請求打到 model: "gpt-4-free" 這種自訂名字,背後實際可能是不同家的 GPT-4 等級替代品,但你的應用程式不用改任何邏輯。

    行動建議:

    在自己的 side project 裡,把「重要的核心功能」放到多個模型輪詢(多條路),就算其中一條限流,你的服務還是能繼續回應。


    3. API key 加密保護

    freellmapi 需要你提供各家免費 LLM 的 API key,它會:

    • 在本機或伺服器端加密儲存 key
    • 只在轉發請求時解密使用

    好處是:

    • 你可以在團隊裡共用一個 freellmapi 服務,而不用把各家 key 散落在每個人電腦
    • 教學/工作坊環境,學員只要打到你架好的 freellmapi,不用自己申請一堆 key

    行動建議:

    如果你常在 Meetup / 企業內訓帶 AI workshop,可以先在自己的 VPS 架一個 freellmapi,把所有免費 LLM key 放裡面,課上只給一個 endpoint 給學員使用。

    💡 關鍵: 把多家 API key 集中加密管理在 freellmapi 上,可以兼顧團隊共享、教學便利與安全性。


    適合誰用?三種典型場景

    1. 個人 side project:免成本把服務「先上線」

    情境:你想做一個小產品(例如:履歷優化、腳本生成工具),但不確定會不會有人用,不想一開始就綁 OpenAI 月費或高額 token 費用。

    freellmapi 可以:

    • 把所有請求先跑在免費 LLM 上,把成本壓到接近 0
    • 等服務有流量、驗證需求後,再考慮導回 OpenAI 或付費模型

    可以立刻做的事:

    1. 按照後面「怎麼開始」部署 freellmapi
    2. 把你的 side project OPENAI_BASE_URL 改成 freellmapi
    3. 設一個環境變數 LLM_ENV=free,未來要切回付費,只要改環境

    💡 關鍵: 先用免費 LLM 驗證產品市場,等真的有流量再切回付費模型,可以大幅壓低前期開發成本。


    2. 替代/補充 OpenAI:做多模型 AB test

    情境:你想比較「不同模型在同一個任務上的表現」,例如:

    • 哪個模型對客服問答最穩定?
    • 哪個模型摘要長文比較不亂砍重點?

    用 freellmapi,你可以:

    • 在設定裡定義一組「候選模型」
    • 讓應用程式隨機或輪詢分配模型,收集回應
    • 做 AB / ABC test,再決定要長期用誰

    可以立刻做的事:

    在後面「多模型回答比較小工具」段落,照範例做一個簡單的「輸入同一個 prompt,拉出多模型回答」的 internal tool,幫你更快做選擇。


    3. 教學/工作坊:一個 endpoint 全班共用

    情境:你要開一門「用 API 串 LLM」的課:

    • 如果叫學生各自申請 OpenAI / 各家帳號,流程會拖很久
    • 如果用單一共享 key,很容易被濫用或不小心外流

    freellmapi 做法:

    • 你在雲端部署一個 freellmapi
    • 學員只要在程式裡填一個 BASE_URL + 你發的一組 class token
    • 你的伺服器決定實際用哪些免費模型、怎麼路由

    可以立刻做的事:

    下一期課程,試著在教案裡只給一份「freellmapi endpoint + 例子程式碼」,把重點放在「怎麼設計 prompt、怎麼串接應用」,而不是每家註冊流程。


    怎麼開始:從部署到改程式,一次走完

    1. 安裝與部署(本機 / 雲端)

    先到 GitHub 下載專案:

    git clone https://github.com/tashfeenahmed/freellmapi.git
    cd freellmapi
    

    freellmapi 是用 TypeScript / Node.js 寫的,你需要:

    • Node.js(建議 18+)
    • pnpm 或 npm / yarn

    安裝依賴與啟動(以 pnpm 為例):

    pnpm install
    pnpm build
    pnpm start
    # 預設會在 http://localhost:3000(實際以 repo 說明為主)
    

    如果要丟到雲端:

    • 可直接丟到 Render、Railway、Fly.io 等支援 Node 的平台
    • 把 PORT 設成平台給你的 port,HOST 設 0.0.0.0

    行動建議:

    先在本機跑起來,用 curl 測一下:

    curl http://localhost:3000/health
    # 若回應 OK 類訊息,代表 freellmapi 正常啟動
    

    2. 把原本用 OpenAI SDK 的程式改指向 freellmapi

    freellmapi 是 OpenAI 相容 API,重點只有兩件事:

    1. 改 baseURL 指向 freellmapi
    2. apiKey 用 freellmapi 的 key(或你設定的任意字串),模型名按照 freellmapi 支援的命名

    Node.js 範例(原本用 OpenAI)

    import OpenAI from "openai";
    
    const client = new OpenAI({
      apiKey: process.env.OPENAI_API_KEY,
    });
    
    const resp = await client.chat.completions.create({
      model: "gpt-4o-mini",
      messages: [{ role: "user", content: "幫我寫一段產品介紹" }],
    });
    console.log(resp.choices[0].message.content);
    

    改成指向 freellmapi

    import OpenAI from "openai";
    
    const client = new OpenAI({
      apiKey: process.env.FREELLMAPI_KEY || "test-key", // freellmapi 端驗證用
      baseURL: process.env.FREELLMAPI_BASE_URL || "http://localhost:3000/v1",
    });
    
    const resp = await client.chat.completions.create({
      model: "gpt4-free-mix", // 你在 freellmapi 裡定義的邏輯模型名
      messages: [{ role: "user", content: "幫我寫一段產品介紹" }],
    });
    
    console.log(resp.choices[0].message.content);
    

    行動建議:

    直接把你現有專案的 baseURL 抽成環境變數,方便之後一鍵切回 OpenAI:

    # .env
    LLM_BASE_URL=http://localhost:3000/v1
    LLM_API_KEY=test-key
    

    Python 範例(原本用 OpenAI)

    from openai import OpenAI
    import os
    
    client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
    
    resp = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": "用一句話介紹台北"}],
    )
    
    print(resp.choices[0].message.content)
    

    改成指向 freellmapi

    from openai import OpenAI
    import os
    
    client = OpenAI(
        api_key=os.getenv("FREELLMAPI_KEY", "test-key"),
        base_url=os.getenv("FREELLMAPI_BASE_URL", "http://localhost:3000/v1"),
    )
    
    resp = client.chat.completions.create(
        model="city-intro-free",
        messages=[{"role": "user", "content": "用一句話介紹台北"}],
    )
    
    print(resp.choices[0].message.content)
    

    3. 設定路由策略與模型白名單(概念版)

    實際設定檔請以 repo 中的說明為主,這裡用一個簡化的概念例子:

    // models.config.json
    {
      "logicalModels": {
        "gpt4-free-mix": {
          "strategy": "round_robin",
          "providers": [
            { "name": "providerA", "model": "gpt-4-alt-1" },
            { "name": "providerB", "model": "gpt-4-alt-2" }
          ]
        },
        "city-intro-free": {
          "strategy": "fallback",
          "providers": [
            { "name": "providerC", "model": "fast-lite" },
            { "name": "providerD", "model": "backup-lite" }
          ]
        }
      }
    }
    
    • round_robin:多模型輪詢,適合平均分流、做 AB test
    • fallback:按順序嘗試,失敗才換下一個,適合有「主力模型」的情境

    行動建議:

    先定義 1 個你常用任務(例如:客服回覆),設 2–3 個候選模型,用 round_robin 跑一週,看看哪個回覆風格最適合,再把不適合的從白名單移除。


    多模型回答比較:做一個小內部工具

    這是一個「輸入同一個 prompt,並行打多個模型,最後把回答排在一起比」的簡單例子(Node,使用同一個 freellmapi endpoint):

    import OpenAI from "openai";
    
    const client = new OpenAI({
      apiKey: "test-key",
      baseURL: "http://localhost:3000/v1",
    });
    
    const models = ["gpt4-free-mix", "city-intro-free", "long-doc-free"];
    
    async function compareModels(prompt: string) {
      const tasks = models.map(async (model) => {
        const resp = await client.chat.completions.create({
          model,
          messages: [{ role: "user", content: prompt }],
        });
        return {
          model,
          answer: resp.choices[0].message.content,
        };
      });
    
      const results = await Promise.all(tasks);
    
      for (const r of results) {
        console.log("=====", r.model, "=====");
        console.log(r.answer);
        console.log();
      }
    }
    
    compareModels("請用三點條列說明:使用 freellmapi 的優點");
    

    你可以把這段包成一個簡單的 CLI 或小網頁,讓團隊成員在設計 prompt 或選模型時,有一個快速對照的工具。


    小結:把 freellmapi 當成「免費 LLM 門面」

    使用策略可以簡單記:

    • 開發期:全部走 freellmapi,專心做產品與實驗
    • 上線後:把關鍵路徑逐步切到穩定的付費模型,freellmapi 當備援或 AB 測試平台
    • 教學 / 團隊內訓:freellmapi 當唯一 endpoint,避免新人被一堆帳號與 key 卡住

    如果你手上已經有任何使用 OpenAI 的程式碼,現在只需要改一行 baseURL,就能開始玩 34 家免費 LLM,這就是 freellmapi 最實際的價值。

    🚀 你現在可以做的事

    • 打開一個現有的 OpenAI 專案,先把 baseURL 抽成環境變數,預留接 freellmapi 的位置
    • 到 GitHub 把 tashfeenahmed/freellmapi clone 下來,在本機跑起來並用 curl /health 測試
    • 寫一個簡單腳本,對同一個 prompt 呼叫多個邏輯模型,開始比較免費 LLM 的表現
  • 用 DeepSeek Harness 做你的多模態工作助理

    用 DeepSeek Harness 做你的多模態工作助理

    📌 本文重點

    • DeepSeek Harness 提供免費開源多模態 Agent
    • 用 /goal + /plan 讓 Agent 自動拆任務與執行
    • 結合 @引用與 MCP/ACP,管理圖文與文件上下文
    • 適合搭建團隊內部的多種工作助理流程

    用 DeepSeek Harness,你可以在一個免費開源的 Agent 裡,同時處理文字、圖片與文件,還能把任務拆成計畫持續執行,變成真正可用的工作助理。

    官網與程式碼:https://github.com/deepseek-ai/deepseek-harness

    v0.1.1 版本公告(含多模態更新):https://www.reddit.com/r/LocalLLaMA/comments/1vugyfe/deepseek_harness_v011_released/


    核心功能:先搞懂這幾個就能開始用

    這節的目標:看完就知道 DeepSeek Harness 能做什麼,並決定要拿它來解哪一種工作。

    1. 多模態 Agent:文字+圖片同一條工作流

    DeepSeek Harness v0.1.1 把 DeepSeek-V4-Flash-Vision-Exp 視覺模型接進來,讓 Agent 能直接理解圖片與文字的混合輸入。

    💡 關鍵: DeepSeek-V4-Flash-Vision-Exp 讓同一個 Agent 對話同時理解截圖與文字,大幅減少人工整理資料的時間。

    具體能做什麼:

    • 同一個對話裡:丟截圖+補充文字說明,讓 Agent 一次看懂
    • 圖片可以來自:本地檔案、貼上的螢幕截圖、工具回傳的圖片
    • 模型可以辨識:表格、報表、UI 介面、流程圖等常見工作截圖

    你可以立刻試的操作:

    1. 準備一張產品後台的報表截圖(營收、轉換率等)。
    2. 啟動 DeepSeek Harness 的介面(後面會教安裝)。
    3. 新建一個工作空間,把截圖拖進對話框,輸入:
    4. 「看這張圖幫我總結 3 個關鍵指標,列點回答。」
    5. 確認 Agent 是否正確抓到數字與欄位名稱,再往下問細節。

    2. /goal + /plan:讓 Agent 自己拆任務與追進度

    v0.1.1 在指令上最重要的更新,是 /goal 和 /plan 支援文字+圖片輸入,讓 Agent 不只回答,而是「接案」做事。

    • /goal:定義整個任務的目標
    • /plan:請 Agent 把目標拆成步驟並執行

    這兩個指令搭配多模態輸入,就是一個簡單版的「工作流程自動化」。

    💡 關鍵: 用 /goal 定義目標、用 /plan 拆步驟,等於在本地擁有一個能持續追任務進度的工作助理。

    實作示範:用報表截圖做完整 /goal /plan 流程

    假設你有一張過去 6 個月的營收報表截圖,要讓 Agent 幫你找問題並列出下一步行動:

    1. 在對話中貼上報表截圖。
    2. 輸入 /goal 指令,例如:

    text
    /goal
    目標:根據這張營收報表,找出過去 6 個月的主要變化,並提出 3 個可執行的優化建議。
    條件:
    - 優先關注營收跌幅較大的月份
    - 建議要具體到可以交給營運同事執行

    1. 接著輸入 /plan,讓 Agent 自己拆步驟並開始做:

    text
    /plan
    請你:
    1. 把圖表資料轉成文字總結(列月份與數字)
    2. 找出營收明顯下降的兩個區間、分析可能原因
    3. 寫出 3 個具體可執行的優化方案,列為待辦事項

    1. 觀察 Agent 的輸出是否有:
    2. 明確的步驟
    3. 對每一步有完成狀態或說明

    做到這裡,你就完成了第一個多模態 /goal /plan 工作流,可以直接複製到其他任務。

    3. @引用+MCP/ACP 附件:把「舊對話+文件+圖片」都變成上下文

    DeepSeek Harness 有一個 @選單,可以在對話裡引用:

    • 先前的對話(舊任務、舊討論)
    • 上傳過的文檔(規格書、工單、需求單)
    • 圖像附件(透過 MCP/ACP 持久化保存)

    MCP/ACP 的重點是:圖片附件不是用完就消失,而是可以被 Agent 在後續任務重複引用。

    💡 關鍵: 透過 @引用與 MCP/ACP,把一次上傳的文件與截圖變成「可重複調用的知識庫」,避免每次任務都重貼同樣資料。

    你實際可以這樣用:

    1. 建一個「產品知識助理」工作空間。
    2. 上傳:
    3. PRD 文件(PDF 或 Markdown)
    4. 過去的 UI 設計稿截圖
    5. 內部 FAQ 文檔
    6. 用 @選單把「當前任務相關的文檔+截圖」拉進上下文:
    7. 比如在對話裡輸入「@PRD_v2 @首頁_UI_2024Q3」,再描述你的問題:
    8. 「請根據這兩份資料,列出目前首頁設計還沒對齊 PRD 的地方。」

    這樣你就不用重複貼同一份文檔或截圖,Agent 會把被 @引用的內容當作背景知識來分析。


    適合誰用:幫你對號入座的 4 種場景

    這節的目標:找到一個你現在就能在團隊裡試跑的具體用例。

    1. 內部知識助理:丟截圖+需求文檔,快速對齊產品理解

    場景:產品經理/設計師/工程師討論新功能,常常出現「UI 截圖+PRD+ Slack 對話」混在一起。

    你可以這樣做:

    • 把 PRD、設計稿截圖、過去討論記錄丟進同一個 DeepSeek Harness 工作空間
    • 用 @引用相關文件,再丟目前版本的 UI 截圖
    • 下指令:
    • 「幫我列出目前 UI 和 PRD 不一致的地方,按照頁面區塊分組。」

    好處:比人力逐段比對更快,當成第一輪檢查,再由人做最後確認。

    2. 簡易 UI/UX 互評工具

    場景:設計團隊想快速收集對某個頁面或流程的評價。

    你可以這樣做:

    • 為每個頁面開一條對話,貼上 UI 截圖
    • 使用 /goal 定義評估目標:
    • 「目標:根據這個頁面,從資訊架構、可用性、視覺一致性三個方向提出具體改善建議。」
    • 用 /plan 要 Agent:
    • 步驟 1:描述目前設計
    • 步驟 2:列出問題
    • 步驟 3:提出修改方案

    輸出可以直接整理成設計回饋文件,給團隊參考。

    3. 客服工單理解與歸類

    場景:客服每天收到大量截圖+文字描述的問題,要先分門別類再交給工程或產品。

    你可以這樣做:

    • 把客服工單內容(文字)+使用者提供的錯誤截圖丟進同一個任務
    • 用 @引用產品 FAQ 或已知問題列表
    • 下指令:
    • 「幫我判斷這個工單屬於哪一個模組/錯誤類型,給出分類標籤與可能原因。」

    這可以當作客服內部的輔助工具,加速初步分類與指派。

    4. 報表截圖分析與週報草稿

    場景:營運、行銷同事每週要寫報告,但常常只有報表截圖(如 GA、後台報表)。

    你可以這樣做:

    • 把這週的關鍵報表截圖整理好,丟進一條對話
    • /goal:設定這週報告的目標(例如:找出異常、解釋波動)
    • /plan:請 Agent 依序:
    • step 1:總結數據
    • step 2:指出異常點
    • step 3:產出週報草稿

    最後再由人類修稿,就能快速產出可用的報告初稿。


    怎麼開始:從 GitHub 到第一個多模態任務

    這節的目標:照著做,30–60 分鐘內跑起第一個多模態 Agent。

    1. 安裝與基本啟動

    前置:

    • 準備一台可以連外網的開發環境(macOS / Linux / WSL 皆可)
    • 安裝好:
    • Python 3.10+ 或 Docker
    • Git

    步驟一:抓專案

    git clone https://github.com/deepseek-ai/deepseek-harness.git
    cd deepseek-harness
    

    步驟二:安裝依賴(以 Python 為例)

    pip install -r requirements.txt
    

    (實際依賴與啟動腳本以官方 README 為準:https://github.com/deepseek-ai/deepseek-harness)

    步驟三:啟動介面或 CLI

    專案提供 Web UI / CLI 等不同啟動方式,通常是:

    python -m deepseek_harness.server
    

    啟動後,開啟瀏覽器訪問本地 URL(例如 http://localhost:8000,以官方文件為準)。

    2. 跑官方範例:確認 Agent 正常運作

    在介面中:

    1. 新建一個 Agent 或工作空間,選擇 DeepSeek 相關模型(包含 vision 的版本,例如 DeepSeek-V4-Flash-Vision-Exp)。
    2. 跑官方示範任務:通常會有預設指令或範例對話,可以先用純文字確認:
    3. 能正常回應
    4. 能接受簡單的 /goal 或 /plan 指令

    如果你偏好程式方式,也可以參考 Towards AI 上的介紹,了解這個框架如何搭配 Claude Code 或 Codex 等開發工具使用:

    3. 實作:做一個自己的「圖文理解工作助理」

    現在,把前面提到的多模態能力,結合你現有的 RAG / 工具調用。

    步驟一:接上你的 RAG 或工具

    • 如果你已有向量資料庫(如:Chroma、Weaviate、Elastic):
    • 將檢索 API 包成一個工具(function / MCP provider)
    • 在 DeepSeek Harness 的工具設定中註冊這個檢索工具
    • 將「查文件」完全交給工具,「理解文件+圖片+任務規劃」交給 Agent。

    可以對照 Agentic RAG 的設計思路:讓 Agent 主動決定何時檢索、檢索幾次:

    步驟二:設計一個固定流程的工作助理

    例如「產品需求評估助理」,定義一個模板:

    1. 使用者輸入:
    2. 需求文檔(文字或 PDF)
    3. 現有 UI 截圖
    4. Agent 流程:
    5. /goal:永遠是「評估新需求與現有產品是否一致」
    6. /plan:
      1. 用工具檢索相關歷史需求與決策記錄
      2. 比對現有 UI 截圖與新需求
      3. 輸出評估報告與待辦事項

    你可以把這整套流程固化在一個「預設對話開場白」裡,讓團隊每次只要丟資料,就能跑同樣的流程。

    步驟三:逐步優化指令模板

    實際跑幾次之後:

    • 把效果好的 /goal 與 /plan 指令存成模板
    • 整理常用的 @引用組合(例如:@最新PRD @設計截圖)
    • 在團隊裡分享一份「怎麼跟助理說話」指南

    DeepSeek Harness 與其他開發者工具的簡易比較

    如果你已在用其他 AI 助手(像是 Claude Code、Codex),可以用下表定位:

    名稱 核心功能 免費方案 適合誰
    DeepSeek Harness 多模態 Agent、/goal /plan、工具整合 開源免費,自架 想打造自家工作流的工程師/產品團隊
    Claude Code 雲端程式助理、自然語言改碼 有免費額度 需要雲端 IDE 型助理的開發者
    Codex(API 生態) 程式碼生成與補全 API 依供應商而定 想在 SaaS 產品中嵌入程式助理的團隊

    對開發者而言,DeepSeek Harness 的定位比較像「你自己可控的骨幹」:多模態理解+任務規劃+工具調用都在你掌控的環境裡,適合拿來搭建團隊內部的工作助理。


    最後建議:從一個小任務開始,把 Agent 變成「同事」

    如果你第一次接觸多模態 Agent,建議從下面的順序開始:

    1. 先選一個單一任務:例如「每週報表截圖分析」。
    2. 用 DeepSeek Harness 跑完整的 /goal + /plan 流程,確認能穩定產出你要的結果。
    3. 再慢慢加上:文件 @引用、RAG 檢索、更多工具。

    一旦你有第一個能被同事穩定使用的「圖文理解工作助理」,後面要擴展到客服、產品、設計等場景,只是複製流程與調整指令而已。

    🚀 你現在可以做的事

    • 去 GitHub 下載並安裝 deepseek-harness,跑一遍官方範例
    • 在團隊中挑一個具體任務(如週報表分析),設計對應的 /goal 和 /plan 模板
    • 整理一批常用文件與截圖,建立首個「產品知識助理」工作空間並實際試用
  • 讓桌面自己動的 UI-Mate 實戰筆記

    讓桌面自己動的 UI-Mate 實戰筆記

    📌 本文重點

    • UI-Mate 讓 AI 直接「看畫面、動滑鼠鍵盤」
    • 用自然語言或示範錄製,就能生成桌面操作流程
    • 可與現有 Python 腳本與 RPA 流程整合,減少人工操作

    用一句話說:UI-Mate 就是一個「看得懂螢幕、聽得懂人話、會自己動滑鼠鍵盤」的桌面機器人,幫你把重複性的桌面操作交給 AI 來做。

    模型主頁:https://huggingface.co/tencent/UI-Mate-27B


    核心功能:這三件事搞懂就能用

    1. 視覺理解:給截圖,它看得懂 UI

    UI-Mate-27B 的核心是一個多模態模型:
    – 你提供「螢幕截圖」+
    – 一段自然語言說明(例如:請幫我打開 Chrome 並登入後台)
    – 它輸出一段結構化動作序列:滑鼠移動、點擊、鍵盤輸入等

    💡 關鍵: 只要一張截圖加一句需求,模型就能直接產出可執行的桌面操作步驟。

    實際可以怎麼用:
    1. 先準備好一個測試畫面(例如:公司後台登入頁)。
    2. 截圖保存為 screen.png。
    3. 把截圖和指令丟給 UI-Mate,看它給出怎樣的「下一步操作」。

    你會拿到類似這樣的結構化輸出(示意):

    {
      "actions": [
        {"type": "move", "x": 540, "y": 320},
        {"type": "click", "button": "left"},
        {"type": "keyboard", "text": "your_email@example.com"},
        {"type": "key", "value": "TAB"},
        {"type": "keyboard", "text": "your_password"},
        {"type": "click", "x": 620, "y": 410}
      ]
    }
    

    接下來你只要寫一個小腳本讀這個 JSON,真的去移動滑鼠、輸入文字,桌面就會「自己操作」。

    2. 自然語言指令:講人話就能控制桌面

    UI-Mate 的互動方式很直覺:
    – 你不需要寫流程圖,也不必一開始就拆成「步驟 1、步驟 2」
    – 只要描述結果:
    -「幫我批量把 Excel 檔案匯入這個 ERP 系統」
    -「打開 Outlook,把今天的報表寄給 A 組所有人」

    模型會自己規劃步驟,並在每一步:
    1. 讀取最新截圖
    2. 思考現在畫面狀態(按鈕位置、輸入框、表格等)
    3. 給出下一步滑鼠鍵盤操作

    你可以這樣實作一個最小可用版本:
    – 外層自己寫「迴圈」:
    1. 每步:截圖 → 丟給 UI-Mate → 執行動作
    2. 執行完再截圖下一幀
    – UI-Mate 負責:理解畫面 + 決定下一步

    行動建議:
    – 先選一個你每天重複 10 次以上的操作(例如:下載報表、貼到另一個系統),用自然語言完整描述「你平常怎麼做」,當成指令丟給 UI-Mate,看它的步驟規劃是否合理。

    3. 示範錄製重用:示範一次,變成可重複流程

    UI-Mate 還有一個「示範引導模式」(demo-guided mode):
    – 你親自操作一次完整流程
    – 系統記錄下:每一步的截圖 + 你的操作
    – 模型會從這次成功示範中,歸納出一個「可泛化的流程」

    這跟傳統 RPA 的差別在於:
    – 傳統 RPA:錄的是「座標腳本」,畫面稍微變一下就壞掉
    – UI-Mate:每次執行時都重新「看畫面」,按「字樣、位置關係」來找按鈕,不是死記座標

    💡 關鍵: UI-Mate 不是重播固定座標,而是每次重新看 UI,用文字與位置關係判斷該點哪裡。

    可以這樣玩:
    1. 用你熟悉的桌面錄製工具(或自製簡單 recorder)記錄一步步操作與截圖。
    2. 把「示範過程」餵給 UI-Mate,請它輸出一個「可重複使用的任務描述 + 動作模板」。
    3. 下次只要換資料(不同 Excel、不同客戶),讓 UI-Mate 根據新畫面、自動套同一個流程。

    行動建議:
    – 選一個流程性質很穩定、但資料每天不同的任務(例如:每日匯入銷售數據),試著用「示範一次 → 重用」方式,取代你手動教同事的 SOP。


    適合誰用:四種典型場景

    1. 重複性後台系統操作

    • 例如:
    • 每天登入多個 SaaS 後台,下載報表、貼到內部系統
    • 每週批次更新客戶狀態
    • 你可以:
    • 把這些步驟示範一次
    • 用 UI-Mate 產生可重複的「桌面任務」
    • 未來只改輸入條件(日期、客戶名),交給 AI 操作

    2. 桌面版軟體批量設定

    • 例如:
    • VPN 客戶端批量新增設定檔
    • 本地 ERP/會計軟體批量開立客戶資料
    • 傳統腳本難點在於:UI 複雜、不易找到穩定 API
    • UI-Mate 直接「看畫面」,幫你點選和輸入。

    3. 跨 app 搬資料

    • 例如:
    • 從 Outlook 下載附件 → 存到指定資料夾 → 打開 Excel 做簡單整理 → 貼到公司內部系統
    • 原本要寫一堆整合腳本或 RPA 流程
    • 現在可以:
    • 用自然語言描述「從哪裡拿資料、要丟去哪裡」
    • UI-Mate 在不同程式之間切換畫面、操作滑鼠鍵盤

    4. 給不會寫程式的同事用的「桌面機器人」

    • 對象:
    • 業務、行政、財務等非工程同事
    • 玩法:
    • 工程師先搭好「UI-Mate 服務」和一個簡單的 Web / 桌面介面
    • 同事只要:
      • 輸入指令(或從下拉選任務)
      • 確認螢幕共享權限
    • 剩下交給 UI-Mate 自己在他們的桌面操作

    怎麼開始:Hugging Face + 本地部署實戰

    以下以在本地機器上跑 UI-Mate-27B 為主線,預設你有一台具備較強 GPU 的機器(例如 48GB VRAM 以上),或準備先在雲端機器試用。

    步驟 0:硬體與環境準備

    建議環境:
    – GPU:單張 48GB VRAM(或多卡切分),若用量化(如 4-bit)可略降需求
    – 系統:Ubuntu 20.04 / 22.04 或 Windows + WSL
    – Python:3.10 或以上

    行動:

    conda create -n uimate python=3.10 -y
    conda activate uimate
    pip install torch torchvision --index-url https://download.pytorch.org/whl/cu124
    pip install transformers accelerate safetensors pillow
    

    💡 關鍵: 若使用 4-bit 等量化,可以在較小 VRAM 的 GPU 上嘗試跑 UI-Mate-27B。

    步驟 1:從 Hugging Face 下載權重

    模型頁面:https://huggingface.co/tencent/UI-Mate-27B

    行動:

    huggingface-cli login  # 輸入你的 HF token
    # 下載模型(示例,可改路徑)
    huggingface-cli download tencent/UI-Mate-27B --local-dir ./uimate-27b
    

    如果你不想預先全部拉下來,也可直接用 from_pretrained 動態下載(見下一步)。

    步驟 2:跑一個最小 Demo

    以下是一個「給一張截圖 + 一句指令,讓 UI-Mate 回傳動作計劃」的簡單腳本:

    from transformers import AutoModelForCausalLM, AutoTokenizer
    from PIL import Image
    import torch, json
    
    MODEL_PATH = "tencent/UI-Mate-27B"  # 或改成本地路徑
    
    device = "cuda" if torch.cuda.is_available() else "cpu"
    
    print("Loading model...")
    model = AutoModelForCausalLM.from_pretrained(
        MODEL_PATH,
        torch_dtype=torch.float16,
        device_map="auto"
    )
    
    tokenizer = AutoTokenizer.from_pretrained(MODEL_PATH)
    
    # 1. 準備截圖與指令
    image = Image.open("screen.png")  # 先手動截一張
    user_instruction = "在這個畫面中,幫我輸入帳號和密碼,然後按登入。"  
    
    # 2. 組合多模態輸入(形式視官方範例為準)
    inputs = tokenizer(
        user_instruction,
        return_tensors="pt"
    ).to(device)
    
    # 一般會有圖像編碼器,這裡假設模型內已處理;實作時請對照官方範例
    
    with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_new_tokens=512
        )
    
    reply = tokenizer.decode(outputs[0], skip_special_tokens=True)
    print("Model output:\n", reply)
    
    # 若模型以 JSON 格式輸出動作,可直接解析
    try:
        actions = json.loads(reply)
        print("Parsed actions:", actions)
    except json.JSONDecodeError:
        print("請依官方格式調整 prompt,確保輸出為 JSON。")
    

    實務上請以 UI-Mate 官方示例程式為準,Hugging Face 頁面的 README 通常會附完整 demo,先照抄跑通,再慢慢改成你的場景。

    步驟 3:用 Python 腳本發指令 + 真實執行

    接下來要做的是把模型輸出的動作「真的」執行在桌面上:

    1. 安裝桌面操作套件(以 Windows 為例):
    pip install pyautogui mss
    
    1. 寫一個簡單「桌面代理 loop」:
    import pyautogui, time, json
    from mss import mss
    
    # 假設這是從 UI-Mate 拿到的 JSON
    plan = {
      "actions": [
        {"type": "move", "x": 500, "y": 300},
        {"type": "click", "button": "left"},
        {"type": "keyboard", "text": "demo_user"}
      ]
    }
    
    for step in plan["actions"]:
        if step["type"] == "move":
            pyautogui.moveTo(step["x"], step["y"], duration=0.2)
        elif step["type"] == "click":
            pyautogui.click(button=step.get("button", "left"))
        elif step["type"] == "keyboard":
            pyautogui.typewrite(step["text"], interval=0.05)
        time.sleep(0.2)
    
    1. 把兩段程式串起來:
    2. 每步:用 mss 截圖 → 丟給 UI-Mate → 解析 JSON → 用 pyautogui 執行
    3. 加上錯誤處理(超時、視窗關閉等),就能形成一個簡單的桌面機器人。

    怎麼接到既有自動化腳本 / RPA 流程

    多數團隊已經有一堆:
    – Python 自動化腳本
    – 現成 RPA 流程(如 UiPath、Power Automate)

    你可以把 UI-Mate 當成「一個新步驟」插進去,而不是全部重寫。

    實戰示例:Python 腳本 + UI-Mate 處理「UI 部分」

    假設你原本有一個腳本:
    – 從資料庫抓訂單 → 輸出 CSV
    – 然後要人手動開某個老舊桌面系統,把這些訂單一筆筆輸入

    改造方式:
    1. 保留原本「資料庫 → CSV」的 Python 程式
    2. 新增一個 fill_orders_with_uimate() 函式:
    – 負責:
    1. 打開舊系統
    2. 逐筆讀取 CSV
    3. 對每一筆訂單:
    – 截圖
    – 呼叫 UI-Mate:請依照示範流程,把這筆訂單填入畫面上對應欄位。
    – 執行模型輸出的滑鼠鍵盤動作

    整體流程變成:

    原本 Python 程式:
      資料庫 → CSV  → (人手動輸入)
    
    改造後:
      資料庫 → CSV → UI-Mate 桌面代理 → 舊系統
    

    與 RPA 工具共存的方式

    如果你公司已經有 RPA 工具(例如 UiPath):
    – 把 UI-Mate 當成「一個 API」:
    1. 在本地或伺服器上跑一個簡單的 Flask/FastAPI 服務,提供 /plan-actions endpoint:
    – Input:截圖 + 任務描述
    – Output:UI-Mate 計劃好的動作 JSON
    2. 在 RPA 流程裡新增一個步驟:
    – 呼叫這個 API 拿動作
    – 用 RPA 自己的「滑鼠/鍵盤活動」元件,執行 JSON 裡的動作

    這樣的好處:
    – 原有 RPA 流程不必大改
    – 跟 IT 合規的整合點很清楚:只是一個額外的內部 API


    小結:建議你的第一個實驗任務

    如果你只想花半天試試 UI-Mate,這樣安排:
    1. 選一個每天都在做、步驟固定的桌面任務(例如:登入兩個系統、下載/上傳一份報表)。
    2. 用 Hugging Face Demo 或本地部署,先跑通:
    – 截圖 + 自然語言指令 → UI-Mate 回傳動作
    3. 寫一個小 Python 腳本,真的在桌面執行那些動作。
    4. 最後,再把這個任務掛到你現有的自動化腳本或 RPA 裡,讓 UI-Mate 僅負責「用眼睛看 UI 的那一段」。

    做到這一步,你就多了一個「會看畫面、會動滑鼠」的 AI 同事,可以逐步把更多枯燥的桌面操作交給它。

    🚀 你現在可以做的事

    • 打開 UI-Mate-27B 模型頁,按 README 示範先跑通官方 demo
    • 在自己的機器上依照文中指令建立 uimate 環境並試跑一次截圖 + 指令的最小腳本
    • 選一個固定桌面任務,設計截圖迴圈 + pyautogui 執行,做出你的第一個 UI-Mate 桌面機器人
  • 把舊遊戲卡變成本地 AI 程式助手

    把舊遊戲卡變成本地 AI 程式助手

    📌 本文重點

    • 16GB 顯卡即可本地跑 Qwen 3.8-27B 程式助手
    • llama.cpp + MTP 把長上下文推理速度壓到可用
    • 少數高階指令即可讓 Agent 自動讀 repo、寫 code、跑測試

    用一張 16GB 顯卡,把 Qwen 3.8-27B 跑在自己機器上,變成一個能讀 repo、寫 code、自己跑測試的本地程式助手。


    核心功能:這套組合能幫你做什麼?

    1. 在 16GB 顯卡上跑 27B 長上下文 Agent

    • Qwen 3.8-27B 是阿里開源的大模型,在 Reddit 實測 裡,表現接近商用雲端模型,特別擅長長上下文推理和實務知識。
    • 社群已針對 16GB VRAM 做過完整配置分享,可在 73k context 下跑 agentic coding,單專案可吃超過百萬 token 歷史。參考設定。
    • 透過 GGUF 量化 + cache 量化,搭配 CPU RAM,把 27B 模型擠進「遊戲卡 + 小主機」這種平價組合。

    💡 關鍵: 只要 16GB 顯卡就能在本地處理 73k 以上長上下文,支援單專案百萬 token 歷史。

    你可以做的:
    – 把原本只能打遊戲的 16GB 顯卡,變成一台完全離線的 AI 程式助手。
    – 不依賴雲端,內網就能讓 AI 幫你寫 CLI 工具、重構專案。


    2. llama.cpp v0.1.0 + FastMTP / adaptive MTP:把延遲壓到能用

    • llama.cpp v0.1.0 是穩定版,支援多平台(Windows / Linux / macOS / Apple Silicon),對 GGUF 模型友善。版本連結
    • HauhauCS 的 FastMTP(多 token 預測)在 Qwen 3.8-27B 上可達 3 倍輸出速度提升:模型頁面。
    • llama.cpp 的 adaptive MTP(PR#27210)會依情境自動調整 MTP 深度:簡單部分快出,多步推理時才放慢,代碼生成速度可提升 10–50%。

    💡 關鍵: 結合 FastMTP 與 adaptive MTP,可以把原本「一秒一 token」的體驗提升到實際可用的程式生成速度。

    你可以做的:
    – 在同一台機器上,從「一秒一 token」變成「可以實際用來寫 code」的速度。
    – 不用糾結 MTP 數字,用 adaptive 模式就能有不錯的平衡。


    3. 真正的「Agent」:少數幾個高階提示就能跑完整專案

    • Qwen 3.8-27B 在所謂 medium reasoning 模式下,對「代理式編碼」特別吃香:實測 benchmark 顯示,比 xhigh 模式更省 token、更少請求,完成度相近。
    • 你只要給它幾個高階指令(例如:讀 repo、規劃任務、按計畫實作),讓它自己呼叫 shell/測試,就能完成一個小專案。

    你可以做的:
    – 把它當成「本地版 Cursor Agent」:讓它自己看專案、拆任務、寫程式、跑測試。


    適合誰用?

    • 個人開發者 / 接案工程師:
    • 想用 Qwen 3.8-27B 協助寫後端 / CLI 工具,但又不想每月付雲端費用。
    • 例:在家用 3060 16GB + N100 補一台小主機,做本地私有助手。

    • 公司內部專案:

    • 需要把專案 code、內部文件給 LLM 看,但有資料不出防火牆的限制。
    • 例:在 CI/CD server 上掛一個 Qwen Agent,協助寫腳本、改 pipeline。

    • AI 工具愛好者 / 自架控:

    • 喜歡試不同量化、推理引擎,把效能擠到極限。
    • 例:對比 medium reasoning + adaptive MTP vs xhigh + 固定 MTP 的速度與品質差異。

    工具與環境:一次給你可複製的配置

    1. 必要硬體與系統建議

    最低建議(接近 Reddit 實測環境):

    • GPU:RTX 4060/5060 Ti 16GB,或同級 16GB 顯卡
    • CPU:Intel N100 以上(有 AVX2 更好)
    • RAM:32GB(推薦 48GB+,上下文拉長時更穩)
    • 系統:Ubuntu 22.04 / Windows 11(本文以 Linux 命令為例)

    行動:檢查自己機器:

    nvidia-smi  # 看 VRAM 容量
    free -h     # 看 RAM
    

    2. 模型與 llama.cpp 安裝

    Step 1:抓 llama.cpp v0.1.0

    git clone https://github.com/ggml-org/llama.cpp.git
    cd llama.cpp
    git checkout v0.1.0
    make -j$(nproc)
    

    Step 2:下載 Qwen 3.8-27B GGUF

    建議用 HauhauCS Aggressive + MTP 版本:

    下載範例(用 hf_hub_download 或直接瀏覽器下載):

    mkdir -p models/qwen-3.8-27b
    # 將下載好的 .gguf 放進這個資料夾
    mv ~/Downloads/Qwen3.8-27B-*-Q5_K_M.gguf models/qwen-3.8-27b/
    

    3. 實測好用的啟動指令(16GB VRAM)

    下面是一個可直接用來跑 Agent 的作者實測配置(參考自 1M+ token 實作):

    ./bin/llama-server \
      -m models/qwen-3.8-27b/Qwen3.8-27B-*-Q5_K_M.gguf \
      --ctx-size 73000 \
      --batch-size 512 \
      --n-gpu-layers 45 \
      --gpu-layers-split auto \
      --cache-type-k q8_0 \
      --cache-type-v q8_0 \
      --no-mmap \
      --temp 0.8 \
      --top_p 0.9 \
      --seed 42 \
      --mtl 4 \
      --mtp-adaptive
    

    關鍵說明:

    • --ctx-size 73000:長上下文,適合讀整個 repo。
    • --cache-type-k/v q8_0:cache 量化,換取更大上下文與速度。
    • --mtp-adaptive:啟用 adaptive MTP,自動調整多 token 推理深度。
    • --mtl 4:多執行緒,視 CPU 調整(8 核可用 6–8)。

    行動:啟動後,瀏覽器開 http://localhost:8080,確認模型可以互動,再往下走 Agent Workflow。


    Workflow 示範:讓本地 Qwen 自己寫一個 CLI 工具

    目標:寫一個「掃描專案中 TODO 註解並輸出報表」的 Python CLI 工具,讓 Agent 自己:

    1. 讀 repo
    2. 規劃任務
    3. 分步撰碼
    4. 呼叫 pytest 或自訂測試

    1. 準備一個 repo + agent shell

    假設你的專案在 ~/projects/todo-cli:

    cd ~/projects/todo-cli
    python -m venv .venv
    source .venv/bin/activate
    pip install pytest
    

    準備一個簡單的「Agent shell」腳本(例如 agent_shell.py),透過 HTTP 調用 llama.cpp,並允許它執行有限制的 shell 指令:

    import subprocess, json, requests, os
    
    API_URL = "http://localhost:8080/completion"
    
    ALLOWED_CMDS = ["pytest", "python", "ls", "cat"]
    
    def call_llm(prompt):
        payload = {
            "prompt": prompt,
            "max_tokens": 512,
            "temperature": 0.7
        }
        r = requests.post(API_URL, json=payload)
        return r.json()["content"]
    
    def run_cmd(cmd):
        if cmd.split()[0] not in ALLOWED_CMDS:
            return "[blocked command]"
        return subprocess.run(cmd, shell=True, capture_output=True, text=True).stdout
    
    if __name__ == "__main__":
        while True:
            user = input("You> ")
            if user.strip() == "exit":
                break
            resp = call_llm(user)
            print("Agent>", resp)
    

    行動:確保你能從命令列下指令,讓 Agent 先以「聊天模式」回答,再逐步加上工具使用(shell 執行)。


    2. 用高階提示引導 Qwen 變成程式助手

    示範系統提示(可貼進 Web UI 或 agent_shell 的第一個請求):

    你是一位本地程式助手,目標是在不依賴外網的情況下,完成整個專案開發流程。
    
    能力與規則:
    1. 你可以要求我執行指令,例如:`RUN: pytest`、`RUN: ls`、`RUN: cat filename`。
    2. 每次回答時,如果需要實際操作,請先說明要做什麼,再給出一行 `RUN:` 指令。
    3. 每個階段先列出簡短計畫,再實作。
    4. 對於程式碼修改,請輸出完整檔案內容,而不是差異片段。
    

    接著,使用者只需幾個高階指令:

    1. 讀 repo + 規劃任務

    text
    請先用 `RUN: ls` 和 `RUN: find . -maxdepth 3` 理解專案結構,之後提出一個開發計畫:
    目標是寫一個 `todo_report` CLI,掃描整個 repo 的 TODO 註解,輸出為 JSON 檔。

    1. 實作 CLI

    text
    依照你的計畫,先實作最小可用版本的 `todo_report`,用 Python 實作,並寫對應的 pytest 測試。

    1. 自動測試與修正

    text
    實作完成後,請要求我執行 `RUN: pytest`,你再根據測試結果修正程式。

    你會看到的典型互動流程:

    • 模型要求 RUN: ls、RUN: cat ... → 你在 shell 中照做,把結果貼回給它。
    • 它產生 todo_report.py 完整檔案內容 → 你存檔。
    • 它產生測試檔 → 你存檔,執行 pytest,貼回錯誤訊息。
    • 迭代 2–3 輪,CLI 工具就完成了。

    重點:整個過程你只下了 3–4 個高階指令,其餘由 Agent 自己規劃與修正。


    進階調校:reasoning 模式、量化與「記憶」

    1. medium vs xhigh reasoning:怎麼選?

    根據 agentic coding benchmark:

    • medium reasoning:
    • 得分較高、請求數幾乎減半,生成 token 也少三分之一。
    • 非常適合「多輪小步」的代理任務(寫 code、修測試)。

    • xhigh reasoning:

    • 單次 prompt 的嚴苛推理題可能略好,但耗時、耗 token。

    💡 關鍵: 實測顯示 medium reasoning 在代理式編碼中比 xhigh 更省時、省 token,完成度相近。

    建議:

    • 本地 Agent 預設用 medium。
    • 偶爾需要「一次回答寫完一篇長文或複雜設計」時,再開 xhigh。

    2. 量化與快取:怎麼不犧牲太多品質?

    實用組合(16GB 卡):

    • 權重:Q4_K_M 起跳,追求品質用 Q5_K_M。
    • KV cache:q8_0 或 q6_K,在長上下文時性價比佳。

    調整原則:

    • 若 VRAM 爆掉 → 降權重量化或減 --n-gpu-layers,讓更多層跑在 CPU。
    • 若輸出過慢 → 開 --mtp-adaptive 或固定 --mtp 3,配合 --batch-size 512 以上。

    3. 延伸玩法:簡單「長期記憶」

    你可以加一層「記憶層」,例如:

    • 使用簡單檔案索引:
    • 把重要檔案(設計文件、規格)摘要成短段落,存 JSON。
    • 開發時先用關鍵字搜尋相關摘要,附在 prompt 開頭,讓 Qwen 有「記憶」。

    • 像 ai-memory 那樣記錄對話:

    • 把每次對話中重要決策(例如:架構選擇、命名約定)存到 memory.md。
    • 每次新任務前,把 memory.md 摘要貼給模型。

    行動:先在專案根目錄加一個 ai_memory/,把設計決策和重要檔案摘要集中存放,讓下一次 Agent 啟動時也能延續上下文。


    怎麼開始:一鍵腳本 + 三個可套用 Prompt

    1. 安裝腳本(Linux 範例)

    # 安裝依賴\sudo apt update && sudo apt install -y build-essential git python3-venv
    
    # 取得 llama.cpp v0.1.0
    git clone https://github.com/ggml-org/llama.cpp.git
    cd llama.cpp
    git checkout v0.1.0
    make -j$(nproc)
    
    # 建立模型資料夾
    mkdir -p models/qwen-3.8-27b
    # 將從 Hugging Face 下載的 Qwen3.8-27B GGUF 放入上述資料夾
    
    echo "完成:請下載 GGUF 模型到 models/qwen-3.8-27b,然後執行啟動命令。"
    

    2. 一行啟動命令(可直接複製)

    ./bin/llama-server \
      -m models/qwen-3.8-27b/Qwen3.8-27B-*-Q5_K_M.gguf \
      --ctx-size 73000 --batch-size 512 --n-gpu-layers 45 \
      --cache-type-k q8_0 --cache-type-v q8_0 \
      --temp 0.8 --top_p 0.9 --mtl 4 --mtp-adaptive
    

    3. 三個可直接用的 Agent prompt 範本

    (1) Repo 讀取與理解

    你是一位本地程式助手,目標是理解這個 repo 的結構與目的。
    請:
    1. 用 `RUN:` 指令要求我列出檔案與重要檔案內容。
    2. 整理出專案用途、主要模組、依賴關係。
    3. 最後輸出一段 <SUMMARY> ... </SUMMARY> 作為後續任務的簡要說明。
    

    (2) 新功能開發(CLI 工具)

    根據目前 repo 的內容,規劃並實作一個新 CLI 工具:
    需求:{在此描述}
    步驟:
    1. 先列出開發計畫(檔案變更列表)。
    2. 依序產出完整檔案內容。
    3. 為新功能撰寫至少一個 pytest 測試。
    每個階段如果需要檔案內容或測試結果,請用 `RUN:` 指令要求我執行。
    

    (3) 重構與程式碼審查

    請針對這個模組進行重構,目標:
    - 提升可讀性
    - 避免重複邏輯
    - 保持對外 API 不變
    流程:
    1. 要求我貼上目前檔案內容。
    2. 提出重構建議清單。
    3. 輸出重構後的完整檔案。
    4. 建議或修改對應的測試。
    

    照著這套流程,你今天就能把舊遊戲卡升級成一個能讀 repo、寫 code、自己跑測試的本地 Qwen 3.8 程式助手。


    🚀 你現在可以做的事

    • 在自己的機器上執行 nvidia-smi 和 free -h,確認硬體是否符合 16GB VRAM + 32GB RAM 的建議配置
    • 按文中步驟安裝 llama.cpp v0.1.0,下載 Qwen 3.8-27B GGUF 到 models/qwen-3.8-27b 並用啟動指令跑起來
    • 在一個現有 repo 中建立 agent_shell.py,貼上提供的系統 prompt,實際讓本地 Qwen 幫你完成一個小型 CLI 工具或重構任務
  • HashAgent:一鍵分享、在地跑的 AI 代理

    HashAgent:一鍵分享、在地跑的 AI 代理

    📌 本文重點

    • HashAgent 用一條 URL 分享可用狀態代理
    • 所有設定編碼進網址,在瀏覽器本地跑模型
    • 適合團隊共享工具、PoC demo、隱私文本處理
    • 開發者可當無後端前端容器做快速試驗

    用一句話說清楚:HashAgent 是一個「用 URL 分享、在瀏覽器本地跑」的 AI 代理容器,讓你不用架伺服器,就能把一個預先設定好的 AI 小工具分享給同事或客戶。

    工具網址:https://hashagent.pages.dev/


    核心功能:把「會動的代理」裝進一條網址

    1. 用一條 URL 分享一個預先配置好的代理

    HashAgent 的設計很直覺:所有代理設定都被編碼進 URL,像是:

    • 使用哪個模型
    • 預設系統 prompt
    • 任務腳本(例如:「請幫我總結貼上的文件」)

    你只要:

    1. 打開 HashAgent:https://hashagent.pages.dev/
    2. 在設定區填好:
    3. 模型名稱
    4. 系統提示(System prompt)
    5. 任務描述或腳本
    6. 點擊產生/複製 URL,丟給同事

    對方打開連結就直接進入一個「可用狀態」的代理,不用再解釋怎麼切模型、怎麼寫指令。

    💡 關鍵: HashAgent 把完整代理配置嵌入網址,任何人點開就能直接用同一套設定。

    👉 可立即行動:

    • 想像你現在有一個固定的「會議紀錄總結」工作,把提示寫好,生成 URL,貼到團隊 Slack,讓大家以後都用這一個入口。

    2. 在瀏覽器端用 WebGPU 本地推論

    HashAgent 依賴瀏覽器 WebGPU 能力,在使用者的電腦上直接跑模型,好處很明確:

    • 文字內容不會送到外部伺服器
    • 沒有額外 API 費用
    • 測試 PoC 不用再申請雲端資源

    要讓它順利運作,你可以這樣檢查與調整:

    1. 使用支援 WebGPU 的瀏覽器:
    2. 建議:Chrome / Edge / Brave(版本越新越好)
    3. 在 chrome://flags 搜尋「WebGPU」,確認是啟用狀態(若已預設開啟可忽略)。
    4. 打開 HashAgent 頁面時,留意是否有「WebGPU not supported」類似提示,有的話換一個瀏覽器或機器測試。

    💡 關鍵: 使用者的瀏覽器與硬體決定推論是否能在本地完成,這是 HashAgent 的隱私與免伺服器優勢來源。

    👉 可立即行動:

    • 用自己的筆電和桌機各打開同一條 HashAgent URL,感受不同 GPU/CPU 下的速度差異。

    3. 支援自訂 Prompt 與任務腳本

    HashAgent 不是只有一個對話框,而是可以預設「代理該怎麼工作」:

    典型可設定內容包括(實際欄位以官方頁面為準):

    • System prompt:定義代理角色,例如:「你是一個專門做長文摘要的助手,只輸出三段摘要與三個行動建議。」
    • 任務腳本:針對一個固定流程,例如:
    • 接收使用者貼上的原文
    • 先輸出 3 句話摘要
    • 再輸出一個行動清單

    你可以把這些寫死在設定裡,然後一鍵分享:

    • 同事只要打開網址、貼文本,就能得到同樣格式的輸出
    • 測試不同版本的提示時,只要多產幾條 URL 對比

    👉 可立即行動:

    • 做兩條代理 URL:
    • A 版:摘要偏「精簡」
    • B 版:摘要偏「詳細」
    • 實際讓同事在會議前後各用一次,收集哪一版更好用。

    適合誰用:三類典型場景

    1. 團隊共享小工具:一鍵文檔總結代理

    情境:公司裡大家都在用 ChatGPT / Claude 檢查文件,但每個人 prompt 都不一樣,輸出品質參差不齊。

    用 HashAgent 可以:

    • 把「標準版」文檔總結流程寫成 system prompt
    • 固定輸出格式(例如:摘要、風險點、下一步行動)
    • 用一條 URL 分享到團隊 wiki / Notion

    效果:

    • 新人只要打開網址+貼文件,就能用同一套「公司標準」摘要模板。

    2. 內部 PoC:不用伺服器就能 demo 的代理

    情境:你是內部 AI 團隊,要給老闆看一個新的代理 workflow 構想,但還不想花時間架後端。

    做法:

    • 在 HashAgent 裡設定好流程 prompt
    • 選一個本地可跑的模型
    • 把生成的 URL 直接在會議現場打開 demo

    效果:

    • 不用申請雲帳號、API Key
    • Demo 環境就是瀏覽器,任何人都可以當場打開運行

    3. 個人隱私場景:本地處理敏感文本

    情境:

    • 合約書、履歷、公司內部簡報,不想丟出去雲端
    • 但又想用 LLM 做摘要、改寫、潤飾

    HashAgent 的本地推論特性很適合:

    • 打開自己的「合約總結代理」
    • 把 PDF 文本複製貼上
    • 整個過程只在自己機器上運算

    👉 可立即行動:

    • 做一條專門處理「履歷優化」的 HashAgent URL,只在求職階段自己用,且資料不離開裝置。

    實作教學:幾分鐘建立一個簡單 HashAgent

    以下用「一鍵文檔總結代理」當示範,步驟會以官方頁面目前常見結構為例(未來若 UI 調整,以頁面為準)。

    步驟一:打開 HashAgent 並選模型

    1. 進入:https://hashagent.pages.dev/
    2. 找到模型選擇欄(例如「Model」或類似欄位)。
    3. 選擇一個支援 WebGPU 的本地模型(通常會有預設選項)。

    如果頁面提供多個模型:

    • 選較小的模型:載入快、推論快
    • 選較大的模型:推論慢,但輸出品質可能更好

    步驟二:寫任務描述(System Prompt)

    在「System Prompt」或「Agent Prompt」欄位填入類似內容:

    你是一個專門為知識工作者服務的文檔摘要助手。
    使用繁體中文回答。請依照以下格式輸出:
    1. 三句話總結本文重點。
    2. 列出 3-5 個可行的下一步行動建議。
    3. 若本文有任何風險點或注意事項,請額外列出。

    這樣一來,任何人打開這條 URL,再貼入文本,都會得到相同格式的輸出。


    步驟三:生成分享 URL

    在 HashAgent 頁面通常會有某種「Share」或「Copy URL」按鈕,底層邏輯是:

    • 把你的設定序列化寫入 URL hash 或 query string
    • 例如:https://hashagent.pages.dev/#... 或 ?config=...

    操作方式:

    1. 點擊「Generate / Copy URL」
    2. 取得一條很長的連結
    3. 貼到:
    4. Slack / Teams 群組
    5. 公司內部 wiki
    6. 產品 demo 文檔

    👉 可立即行動:

    • 做好第一條代理後,請兩位同事用它來總結同一份文件,觀察輸出是否一致,微調 prompt。

    如何在不同瀏覽器 / 機器上測試效能

    HashAgent 的效能很依賴硬體與瀏覽器,以下是一個簡單測試流程:

    1. 準備一條相同的 HashAgent URL
    2. 在以下環境各測一次:
    3. Windows + Chrome
    4. macOS + Chrome / Safari(視 WebGPU 支援情況)
    5. Linux + Chromium 或支援 WebGPU 的瀏覽器
    6. 測量兩個指標:
    7. 模型載入時間(從進入頁面到可以輸出第一段文字)
    8. 單次完整回應時間(例如處理同一篇 1,000 字文章)

    若遇到太慢或無法運行,可以:

    • 換較小的模型
    • 確認瀏覽器版本已更新
    • 在設定裡調低生成長度或溫度(根據 UI 選項調整)

    💡 關鍵: 透過在不同環境測量載入與回應時間,你可以實際評估 HashAgent 是否符合團隊或產品 demo 的效能需求。


    與其他工具搭配:向量庫、Obsidian、VSCode

    HashAgent 目前偏「單體代理」,但你可以把它當作前端容器,搭配其他工具:

    • 搭配本地向量庫:
    • 在後端用你熟悉的工具(如 LlamaIndex、Local vector DB)先做檢索
    • 把檢索後的上下文貼到 HashAgent 中,由代理負責總結/解釋

    • 搭配 Obsidian:

    • 在 Obsidian 裡選一篇筆記,複製內容
    • 貼到 HashAgent 的「摘要代理」裡
    • 把輸出貼回新筆記,形成標準化摘要

    • 搭配 VSCode:

    • 將部分程式碼或 log 貼入 HashAgent 的「debug 代理」URL
    • 以預先設定好的 prompt 輔助 debug 或重構

    👉 可立即行動:

    • 建兩條代理 URL:一個專門負責「Obsidian 筆記摘要」、一個專門負責「程式碼解說」,分別收藏在瀏覽器書籤列。

    給開發者:把 HashAgent 當成前端容器

    如果你在做 LLM workflow、agent framework,HashAgent 可以扮演:

    • 「無後端 Demo 殼」:
    • 把整個 workflow 壓縮成一組 prompt + 設定
    • 用 HashAgent 的 URL 形式丟給使用者試用

    • 「早期用戶回饋管道」:

    • 你可以快速產出多個版本(不同 prompt、不同模型)
    • 用多條 URL 做 A/B 測試

    • 「內部教學模板」:

    • 把教學代理(例如:教如何寫公司標準文件)包成 URL
    • 給新員工在瀏覽器裡直接操作

    當你準備好要產品化時,再把這些代理邏輯搬到自己的前端 + 後端架構裡即可。


    小結:先從一個「可分享的摘要代理」開始

    如果你不知道從哪裡開始,建議順序:

    1. 打開 https://hashagent.pages.dev/
    2. 選一個預設模型
    3. 寫一個「公司標準的文檔摘要 prompt」
    4. 生成 URL,貼到團隊群組

    當你能用 HashAgent 成功分享第一個「會動」的代理給同事,你就掌握了這個工具的核心價值:用 URL 把 AI 工作流程裝起來,讓任何人打開就能用,且資料留在自己的裝置上。

    🚀 你現在可以做的事

    • 立刻打開 HashAgent,建立一條「公司標準文檔摘要」URL 並分享到團隊 Slack 或 Teams
    • 在兩台不同設備上用同一條代理 URL 測試 WebGPU 效能,確認是否適合正式使用
    • 為個人敏感資料(履歷或合約)設計一條專用 HashAgent 代理 URL,加入瀏覽器書籤以便重複使用
  • 用 Unsloth 把筆電變成小型 AI 伺服器

    用 Unsloth 把筆電變成小型 AI 伺服器

    📌 本文重點

    • Unsloth Desktop 把筆電變成本地多模態 AI 伺服器
    • 支援多 GPU / CPU,並提供 OpenAI 兼容 API
    • 適合本地聊天助理、RAG、Agent 與多模態 Side Project
    • 幾乎不改程式即可把既有 OpenAI workflow 搬到本機

    用一句話定位:Unsloth Desktop 就是把你的筆電變成「小型 AI 伺服器 + 實驗室」的開源桌面工具,讓聊天、程式助理、RAG、影像與語音模型都能在本機跑起來。

    工具來源:
    – Reddit 介紹文:https://www.reddit.com/r/LocalLLaMA/comments/1vlj87v/introducing_unsloth_desktop_app/
    – Product Hunt:https://www.producthunt.com/products/unsloth


    核心功能:把「本地模型」變成可用的服務

    下面三個功能,是你真的會用到、立刻能起手的重點。

    1. 支援多種模型格式:MLX / diffusion / 語音 / GGUF

    Unsloth Desktop 的定位不是「只跑 LLM」,而是一個多模態模型的統一入口:

    • 語言模型:支援 GGUF(llama.cpp 系列)、MLX(Apple Silicon 上的高效框架)
    • 影像 / 視覺:支援 diffusion 影像 / 影片模型
    • 語音:支援音訊模型(語音辨識、TTS 等)

    你可以這樣開始行動:

    1. 安裝好 Unsloth 後,打開模型面板
    2. 選擇一個預設 GGUF LLM(例如 MiniMax-H3、Muse Glimmer)
    3. 選一個簡單的 diffusion 模型(如 Stable Diffusion 系列)
    4. 在同一個介面裡,分別測試文字聊天和影像生成

    這種「同一套操作邏輯管理多模態模型」的好處,是你不用在不同 CLI 工具之間切來切去,對 AI 新手非常友善。


    2. 多 GPU & CPU 加速,本地推理真的跑得動

    很多人「幻想」在筆電上跑模型,卡在效能與顯示記憶體。Unsloth Desktop 的重點是盡量把你手上的硬體吃乾抹淨:

    • 支援多種 GPU:NVIDIA、AMD、Intel、Mac(含 Apple Silicon)
    • 支援 CPU 推理:沒有獨顯也可以跑,只是速度會慢一些
    • 對訓練 / 微調:標榜約 2 倍訓練速度、70% VRAM 節省(來源:官方 Reddit 介紹)

    💡 關鍵: 大約 2 倍訓練速度與 70% VRAM 節省,代表同樣硬體上能跑更大模型或更多實驗。

    你可以立刻做的事:

    1. 在設定頁面確認硬體偵測到的 GPU / CPU
    2. 選一個中型模型(例如 7B gguf),先跑一次聊天測試
    3. 觀察系統資源使用(macOS 的活動監視器、Windows 的工作管理員),確認真的有用到 GPU

    如果你是 Mac 使用者,可以搭配像這篇關於 Apple Silicon + llama.cpp 的效能優化思路:https://github.com/trycua/cua/blob/main/blog/gpu-passthrough-macos-vms.md,來理解「為什麼在 M 系列晶片上跑本地 LLM 是可行的」。


    3. OpenAI 兼容 API + 自我修復工具呼叫

    Unsloth Desktop 最關鍵的功能,是把本地模型包成一個 OpenAI 兼容的 API:

    • 提供 OpenAI-compatible endpoint(Unsloth Native)
    • 可以同時串本地模型和雲端模型(例如 OpenAI、Anthropic 等),在同一個 API 層切換
    • 內建「自我修復」的工具呼叫與沙盒化代碼執行:模型在呼叫外部工具或執行程式碼出錯時,可以自動重試 / 修正,同時把程式碼限制在安全環境裡

    💡 關鍵: OpenAI 兼容 API 讓你幾乎不改程式碼,就能把原本的雲端 workflow 直接換成本地模型。

    這讓你可以做幾件事:

    1. 把本地 LLM 當成 ChatGPT-compatible 的後端,接在現成客戶端(如 Chatbox、Continue、Open WebUI 等)
    2. 在 VS Code 旁邊跑自己的模型,搭配 Claude Code / Codex 類工具一起用
    3. 建立簡單 Agent:模型收到任務 → 呼叫系統工具或小腳本 → 在沙盒裡執行 → 回傳結果

    適合誰用:三種典型場景

    1. 本地聊天與程式助理:在 VS Code 旁跑自己的模型

    如果你平常習慣用 Claude Code、Cursor 或 GitHub Copilot,想要多一個「完全不出機房」的備用助理,可以這樣玩:

    • 把 Unsloth Desktop 裝在開發機上,啟動一個 GGUF LLM
    • 用 VS Code 外掛或本地聊天客戶端,改成連至 Unsloth 的 OpenAI 兼容 API
    • 寫程式時,用雲端模型做主力、遇到敏感專案(公司內網、客戶程式碼)就切到本地模型

    具體行動建議:

    1. 選一套 ChatGPT-compatible 客戶端(例如 Continue 或 Chatbox)
    2. 在其設定裡,把 api_base 改成 Unsloth 提供的 endpoint(例如 http://localhost:port/v1)
    3. 選定模型名稱,例如 local-llm-7b,直接開始對話與程式補全

    2. 私有資料實驗與原型:本機 RAG / Agent,不經雲端

    很多團隊不敢把內部文件丟上雲端 RAG,Unsloth 提供了一條完全本地的實驗路線:

    • 把公司或個人 PDF / Markdown / internal wiki 先處理成向量資料庫(自行寫腳本或用現成 RAG 套件)
    • 模型端用 Unsloth 提供的本地 LLM API
    • 在本機 web app 或小工具裡,做檢索 + 回答組合

    可以這樣起手:

    1. 在你的後端(Node.js / Python)中,接 Unsloth 的 API 當成 chat/completions 或 responses 來源
    2. 用如 n8n / LangChain / LlamaIndex 這類工具,把「取文件片段 → 呼叫本地 LLM」串起來
    3. 先做一個只服務自己筆電的小型內部 FAQ Bot,再考慮用 Cloudflare Tunnels 把 Unsloth API 安全地開到公司內網(Unsloth 原文有提到 Cloudflare 保護連線)

    3. 多模態 Side Project:影像生成、語音模型、簡單 Agent 工作流

    如果你平常喜歡做 Side Project,Unsloth 可以當成你所有 AI 功能的統一後端:

    • 用 diffusion 模型接一個「本地 Stable Diffusion 影像生成頁面」
    • 用語音模型做「錄音 → 轉文字 → LLM 摘要 → TTS 回覆」的工作流
    • 用 Agent 功能做一個「會自己跑 bash / Python 腳本」的小助手,幫你整理檔案或抓網頁資料

    具體行動:

    1. 在 Unsloth Desktop 裡啟動影像 + 語言 + 語音模型
    2. 在本地 web app(React / Vue / Svelte 任意)裡,統一呼叫同一個 API endpoint
    3. 利用工具呼叫與沙盒功能,設計幾個具體指令,例如「幫我整理 Downloads 資料夾」或「抓這個網站最新 10 篇文章做摘要」

    怎麼開始:從安裝到接上現有 workflow

    1. 安裝:Mac / Windows / Linux 都有

    Unsloth Desktop 是開源工具,支援三大桌面平台:

    • Mac:適合 Apple Silicon,用 MLX 模型可以發揮硬體優勢
    • Windows:多數開發者主力,適合接 NVIDIA / AMD GPU
    • Linux:伺服器與進階用戶首選

    行動步驟:

    1. 前往官網或 GitHub 下載最新版(可從 Product Hunt 連過去:https://www.producthunt.com/products/unsloth)
    2. 安裝並啟動,確認介面可以看到模型列表
    3. 在設定裡檢查硬體偵測與 API 設定(本地端口、是否啟用 OpenAI 兼容模式)

    2. 跑起第一個 GGUF / MLX 模型

    上手建議流程:

    1. 在介面中選擇一個輕量模型(例如 3B–7B GGUF),避免一開始就把 VRAM 撐爆
    2. 點選「啟動 / RUN」讓模型載入;等待載入完成
    3. 使用內建聊天介面,輸入一段問題(例如「幫我寫一個 Python 把 CSV 轉成 JSON 的程式」)
    4. 確認回答品質與速度,調整溫度、max tokens 等基本參數

    若你是 Mac M 系列:

    • 優先選 MLX 模型,在偏好設定裡確認使用 Apple GPU
    • 對照前面的 Apple Silicon + llama.cpp 文章,思考是否要調整 batch size 等設定

    3. 啟用 OpenAI 兼容 API:用 curl 測試

    確認 API 真的跑起來,是往後串接 n8n / Zapier 的基礎。

    假設 Unsloth 在本機開一個 http://localhost:8000/v1 的 API,可以這樣測:

    curl http://localhost:8000/v1/chat/completions \
      -H "Content-Type: application/json" \
      -H "Authorization: Bearer YOUR_LOCAL_KEY" \
      -d '{
        "model": "local-llm-7b",
        "messages": [
          {"role": "user", "content": "幫我用 Python 寫一個排序函式"}
        ]
      }'
    

    你應該會拿到一個結構與 OpenAI 非常接近的 JSON 回應。確認:

    • model 名稱是否正確
    • 是否需要 API key(有些版本可設定為無認證,只限本機)

    💡 關鍵: 成功用 curl 打通 http://localhost:8000/v1/chat/completions,就代表之後的任何 OpenAI 客戶端幾乎都能直接改 endpoint 來使用本地模型。


    4. 在 n8n / Zapier / 本地 web app 裡改掉 endpoint

    最後一步,把你原本的 workflow 直接「搬家」到自己筆電上的 Unsloth。

    以 n8n 為例:

    1. 找到原本呼叫 OpenAI 的 HTTP Request 節點
    2. 把 URL 從 https://api.openai.com/v1/chat/completions 改成 http://localhost:8000/v1/chat/completions
    3. 把 Authorization header 改成對應的本地 key(或移除認證視你設定而定)
    4. 保留原本的 messages 結構,只把 model 改成 Unsloth 內的本地模型名稱

    Zapier 類似做法:

    • 若使用 Webhooks by Zapier,改成打本地 URL
    • 若原本用的是 OpenAI 官方 integration,則改為自訂 webhook

    對於自己寫的 web app:

    • 在環境變數裡新增 OPENAI_BASE_URL=http://localhost:8000/v1
    • 程式碼中使用 OPENAI_BASE_URL 來組合 API URL,而不是寫死 api.openai.com

    這樣,你所有原本設計給 OpenAI / Claude 的 workflow,可以在幾乎不改程式的情況下,直接切到自己機器上的 Unsloth。本地 + 雲端混用時,只要切換 base URL 或 model 名稱,就能控制資料是否出機房。


    簡短比較:Unsloth 與常見本地 LLM 工具差異

    若你已經在用 Ollama、llama.cpp,也可以把 Unsloth 當成「更偏向多模態與訓練、又有桌面介面」的補充工具。

    名稱 核心功能 免費方案 適合誰
    Unsloth Desktop 多模態模型管理 + 本地訓練 + OpenAI 兼容 API 開源免費 想在筆電做本地 Agent、多模態實驗的開發者
    Ollama 本地 LLM 管理與推理(重文字) 開源免費 想快速跑文字模型、不需要訓練與多模態的人
    llama.cpp 低階 C++ 推理引擎(GGUF、效能優化) 開源免費 有工程背景、願意自己包 API 的技術使用者

    如果你想要一個「按裝置效能極限推到滿、又不必寫太多底層程式」的本地 AI 實驗室,Unsloth Desktop 是一個很實用的選擇:先讓它跑起一個本地 LLM,接上 OpenAI 兼容 API,然後把你現有的工作流一個一個搬過來,你就真正擁有了屬於自己的多模態 Agent 伺服器。

    🚀 你現在可以做的事

    • 前往 Product Hunt 或 GitHub 下載並安裝 Unsloth Desktop,啟動一個 7B gguf 或 MLX 模型
    • 用 curl 或你常用的 ChatGPT-compatible 客戶端,將 api_base 改成 http://localhost:8000/v1 測試本地 API
    • 挑一個現有用 OpenAI 的 workflow(如 n8n 流程或小型 web app),只改 endpoint 與 model 名稱,把它搬到本機 Unsloth 上跑
  • Needle 2 教學:手機也能跑本地 Agent

    Needle 2 教學:手機也能跑本地 Agent

    📌 本文重點

    • Needle 2:14MB、本地可跑的 Agent LLM
    • 在手機、Pi、穿戴裝置上做工具呼叫與自動化
    • 完全本地推理,低延遲且隱私友善
    • 適合智慧家居、語音助理、穿戴與教育機器人

    用一句話講清楚:Needle 2 是一個只有 14MB、能在 200 美元以內設備上流暢跑的本地 Agent LLM,讓你在手機、樹莓派上直接做工具呼叫與智慧自動化,不用雲端大模型。

    官網與原始介紹:
    – 官方網站:https://cactuscompute.com/needle
    – Hacker News 貼文:https://news.ycombinator.com/item?id=XXXX
    – LocalLLaMA 討論:https://www.reddit.com/r/LocalLLaMA/comments/1vkqy66/needle_2_14mb_agentic_llm_for_phones_wearables/


    核心功能:小,但有 Agent 能力

    1. 超迷你體積:14MB 模型、28MB RAM 就能跑

    Needle 2 是一個 約 45M 參數、2bit 量化壓縮的語言模型,整個模型打包成一個 14MB binary,推理時只吃約 28MB 記憶體。

    💡 關鍵: Needle 2 只要約 28MB RAM 就能推理,讓「在 Pi 和手機上跑 Agent LLM」變成現實。

    它基於 Cactus 提出的 Simple Attention Networks(簡化版注意力架構),犧牲部分模型規模,換來極低的計算量和能耗。實際效能:

    • Raspberry Pi 5:約 500 tokens/sec
    • VR 裝置(Meta Quest 3S / Apple Vision Pro):400–1500 tokens/sec
    • 約 200 美元等級手機(Samsung A 系列):300–700 tokens/sec

    能做什麼行動?
    – 先檢查你的設備是否有 至少 64MB RAM 可用(實務上 Pi 5 / Android 都足夠)。
    – 決定要放在哪台機器當「本地腦袋」:家裡的 Raspberry Pi、舊 Android 手機、或一台廉價 mini PC。


    2. Agent 能力:能理解指令、做工具呼叫

    Needle 2 不是只會聊天,而是設計成 agentic LLM:

    • 能根據系統提示決定是否呼叫工具(API / 裝置控制)
    • 支援 結構化輸出(JSON 等),方便接到你的程式邏輯
    • 專門對「手機操作、智慧家居控制、機器人指令」這類任務做了優化

    在工具呼叫和「手機裝置操作」基準測試上,Needle 2 的表現與 LFM2.5(230M 參數)和 Apple Foundation Model 等,接近甚至部分場景持平,但模型體積卻小了 5–70 倍。

    💡 關鍵: Needle 2 在工具呼叫表現接近百兆參數等級模型,卻能以小 5–70 倍的體積在邊緣設備上運行。

    能做什麼行動?
    – 先想好 你要讓它控制什麼:燈光、家電、機器人、APP、自訂 API。
    – 為每個動作做一個 簡單工具介面(HTTP endpoint、MQTT topic 或 Python function),預留給 Needle 2 來呼叫。


    3. 完全本地:低延遲 + 隱私友善

    Needle 2 最大的賣點不是「厲害」,而是夠小,才能真正放在邊緣設備:

    • 所有推理都在你自己的 Pi / 手機上跑
    • 不需要把語音、對話內容傳出去
    • 本地 TTS / ASR 加上 Needle 2,就能做 完全離線的語音助理

    💡 關鍵: 結合本地 ASR/TTS 與 Needle 2,可以打造完全離線、資料不出機器的語音助理系統。

    能做什麼行動?
    – 對隱私敏感的場景(家裡、兒童教育、醫療輔助)優先考慮放 Needle 2,而不是雲端 API。
    – 若你已用 Home Assistant 或其他 IoT 中樞,把 Needle 2 放在同一台機器上,就能做到「指令 → 本地推理 → 本地控制」。


    適合誰用:4 個具體場景

    1. 離線語音 / 文字助理

    需求情境:露營、船上、地下室、或任何網路不穩的地方,你仍然想有 AI 助理幫忙查資料、整理備忘、操作裝置。

    基本架構:
    1. 麥克風 → ASR(語音轉文字)模型
    2. 文字 → Needle 2 推理(決定要回話或呼叫工具)
    3. 回覆文字 → TTS(文字轉語音)模型

    TTS 可以參考 NVIDIA 在 Hugging Face 上開源的 Magpie TTS 系列:
    – 介紹:https://huggingface.co/blog/nvidia/magpie-tts-multilingual-voice-agents
    – 多語言、延遲低,適合作為本地語音回覆模組

    能做什麼行動?
    – 選一個輕量 ASR(可用 Whisper 小模型或其它 Tiny ASR),加上 Magpie TTS + Needle 2,在 Pi 5 上做一個「離線語音盒子」。
    – 第一步先只做 文字模式:在 Pi 上跑 Needle 2 和簡單 web chat,再再加語音。


    2. 智慧家居自動化中樞(搭配 Home Assistant)

    需求情境:你希望可以自然說「我要看電影模式」,系統自己:關燈、開投影、拉窗簾,而不是自己寫一堆硬規則。

    基本 workflow:
    1. Home Assistant 收到語音或文字指令
    2. 將指令丟給 Needle 2,並提供「目前設備狀態」的上下文
    3. Needle 2 輸出一個 JSON:要執行哪些自動化(開燈、調亮度、設溫度)
    4. Home Assistant 解析 JSON,執行對應動作

    能做什麼行動?
    – 在 Home Assistant 所在的機器(常見就是 Pi)上安裝 Needle 2,做一個 簡單 HTTP 服務,接收文字、回傳 JSON。
    – 設計一個固定格式的 prompt,例如:「你只能輸出 JSON,包含 actions: [],每個 action 有 device_id 和 command」;這樣 Home Assistant 比較好接。


    3. 穿戴式小助理(手錶、VR 裝置)

    需求情境:在 VR / AR 裝置裡,要一個能即時協助你操作菜單、記錄備忘、提示下一步的輕量 AI。

    Needle 2 在 Meta Quest 3S、Apple Vision Pro 上有 400–1500 tokens/sec 的速度,足夠做即時互動:

    基本 workflow:
    1. 系統在背景持續送「使用者現在在看什麼畫面、有哪些按鈕」給 Needle 2
    2. 使用者說「幫我開上次的檔案」,Needle 2 根據 UI 狀態決定操作步驟
    3. Needle 2 輸出一系列「點擊/選擇」指令,交給裝置 API 執行

    能做什麼行動?
    – 若你在做 VR 應用,先嘗試在裝置上跑 Needle 2 的 on-device 推理(官方有 binary 版本)。
    – 先用「純文字模擬」:把 UI 狀態描述成文字給 Needle 2,看它能否產出正確的操作序列。


    4. 教育 / DIY 機器人

    需求情境:學生或 Maker 想做一台會說話、能理解「去拿紅色積木」這種指令的簡易機器人,但硬體預算有限。

    基本設計:
    1. 使用者下指令(語音或文字)
    2. Needle 2 把自然語言轉成「機器人行為計畫」:走幾步、轉幾度、夾取哪個物體
    3. 下游控制程式把計畫翻成馬達指令

    能做什麼行動?
    – 把 Needle 2 放在機器人主控板(Pi / Jetson / 廉價 SBC),透過 UART / I2C 控制下層微控制器。
    – 先做「模擬模式」:給 Needle 2 一個簡化的世界(只有桌面、幾個物品),驗證它能否產出合理計畫,再接上真實硬體。


    怎麼開始:從下載到跑出第一個回應


    1. 下載模型:GitHub / Hugging Face

    Needle 2 主入口:
    – 官方頁面:https://cactuscompute.com/needle

    通常會提供:
    – 單一 binary 檔(約 14MB):內含模型權重與推理引擎
    – 示例程式碼(Python / C / Android)

    能做什麼行動?
    – 在你的開發機(桌機或筆電)先下載並跑一次,確認能輸出文字,再移到 Raspberry Pi / Android。


    2. 在 Raspberry Pi 上安裝與推理範例

    以 Raspberry Pi 5 + Raspberry Pi OS 為例:

    # 更新系統
    sudo apt update && sudo apt upgrade -y
    
    # 安裝基本工具
    sudo apt install -y git python3 python3-pip
    
    # 下載 Needle 2 binary(以官方提供連結為準)
    wget https://cactuscompute.com/needle/needle2_pi5.bin -O needle2
    chmod +x needle2
    

    最簡單文字對話範例(假設 binary 支援 CLI 模式):

    # 啟動互動模式
    ./needle2 --prompt "你是一個住在家裡的本地助理,回答使用者問題。"
    

    若有 Python 綁定,可以像這樣:

    from needle2 import Needle
    
    agent = Needle(model_path="./needle2")
    
    response = agent.generate(
        "幫我規劃一個今天晚上的家務待辦清單,用 JSON 格式輸出。"
    )
    print(response)
    

    能做什麼行動?
    – 先在 Pi 上跑出第一個文字回覆,再加入 HTTP server(Flask / FastAPI),讓其他設備可以丟請求給 Needle 2。


    3. 在 Android 上運行 Needle 2

    官方通常會提供 Android demo app 或 AAR 庫:

    大致步驟:
    1. 在 Android Studio 建立新專案
    2. 引入 Needle 2 的 AAR 或 JNI 庫
    3. 在 MainActivity 裡初始化模型

    示意程式碼(概念):

    class MainActivity : AppCompatActivity() {
        lateinit var needle: NeedleAgent
    
        override fun onCreate(savedInstanceState: Bundle?) {
            super.onCreate(savedInstanceState)
            setContentView(R.layout.activity_main)
    
            needle = NeedleAgent(this, modelPath = "needle2_android.bin")
    
            findViewById<Button>(R.id.sendBtn).setOnClickListener {
                val input = findViewById<EditText>(R.id.inputText).text.toString()
                val output = needle.generate(input)
                findViewById<TextView>(R.id.outputText).text = output
            }
        }
    }
    

    能做什麼行動?
    – 先做一個「純文字聊天 app」,確認速度在你的 Android 上是能接受的,再加麥克風、TTS。對高階機種,可以往即時語音助理發展;對低價機種,先鎖定文字用途即可。


    4. 與 IoT / Home Assistant / TTS / ASR 的整合路線

    把 Needle 2 變成真正的「中樞」,你可以用以下路線:

    1. Needle 2 HTTP 服務(在 Pi / mini PC 上)
    2. 提供 /chat(純文字)
    3. 提供 /plan(輸出 JSON,給自動化用)

    4. Home Assistant / IoT 平台

    5. 建立自訂整合,將使用者指令送到 /plan
    6. 解析 JSON,執行對應燈光、插座、場景

    7. 語音層

    8. ASR:Whisper 小模型或其他輕量 ASR
    9. TTS:NVIDIA Magpie TTS(多語言、低延遲),或其他本地 TTS

    能做什麼行動?
    – 先完成「文字 → Needle 2 → JSON → Home Assistant」的閉環,自動化一個簡單場景(開燈 / 關燈)。
    – 確認穩定後,再加語音層,最後再優化 prompt、加入安全限制(例如不允許某些危險指令)。


    Needle 2 vs 其他輕量模型:怎麼選?

    若你在考慮其它本地 LLM,下面表格可以幫你快速定位(僅示意,聚焦用途):

    名稱 核心功能 免費方案 適合誰
    Needle 2 14MB agent LLM,工具呼叫、IoT 開源權重 手機、Pi、穿戴、機器人
    Ling-3.0-tiny 8B MoE,高效推理、多任務 開源權重 有 GPU / M 系列筆電的開發者
    雲端 ChatGPT / Claude 大模型、通用對話與程式輔助 API / 訂閱 不在意隱私、重視效果的使用者

    Ling-3.0-tiny 參考:https://www.reddit.com/r/LocalLLaMA/comments/1vkqwso/inclusionailing30tiny_8b_a13b_moe_hugging_face/

    簡單判斷:
    – 只有 Pi / 低價手機 → 用 Needle 2 當主力
    – 有不錯 GPU / MacBook M 系列 → 可以用 Ling-3.0-tiny 做桌面助理,Needle 2 留給 IoT


    收尾:下一步行動清單

    如果你想現在就動手,建議照這個順序來:

    1. 去 https://cactuscompute.com/needle 下載 Needle 2,在桌機跑一次簡單對話
    2. 在 Raspberry Pi 5 上部署 Needle 2,做出一個最簡單的 HTTP /chat API
    3. 把家裡一個設備(例如客廳燈)接到 Home Assistant,用 Needle 2 產生 JSON 操作指令
    4. 若你有時間,再加上 ASR + Magpie TTS,讓整套系統能用語音控制

    做到第 3 步,你就已經擁有一個「完全集中在家裡跑、本地決策的智慧家居 Agent」。之後要擴充,只是慢慢多接幾個工具而已。


    🚀 你現在可以做的事

    • 立刻前往 Needle 官方頁面 下載 binary,先在桌機跑一個簡單對話測試
    • 在 Raspberry Pi 上部署 Needle 2,包一層簡單 HTTP /chat 或 /plan API 讓家中設備可呼叫
    • 選一個場景(客廳燈或一台機器人),實作「文字指令 → Needle 2 → JSON 計畫 → 實際動作」的完整閉環
  • 用手機跑 128K AI 小助手:LFM2.5 實戰

    用手機跑 128K AI 小助手:LFM2.5 實戰

    📌 本文重點

    • LFM2.5-2.6B 支援 128K 長上下文,可一次處理整本文件
    • 內建多步驟 Agent 與 tool calling,可拆解任務自動執行
    • 量化後記憶體 < 2.5GB,手機 CPU 也能跑到 17–30 tok/s
    • 適合本地文件助理、批量任務與離線手機 AI 助理

    一台手機就能跑的長上下文 AI 小助手,幫你在本地處理文件、批量任務和簡易自動化,不靠雲端也能用得上 AI。

    參考來源:Reddit LocalLLaMA 討論、LFM2.5-2.6B 發布帖、OnePlus 13 實測,以及 Hugging Face 專題文:Deploy local agents everywhere with LFM2.5-2.6B。


    核心功能:為什麼是「一台手機就能跑的 Agent」?

    1. 128K 長上下文:整本報告一次丟進去

    • 它是什麼:LFM2.5-2.6B 支援約 128K tokens 上下文,大約可以一次吃下數十萬字的內容。
    • 具體能做什麼:
    • 整本 PDF 報告、技術文件、會議紀錄一次丟進去,讓模型幫你摘要、對比、找重點。
    • 長期對話不會「忘記前文」,可以當持續的工作助理。
    • 你可以馬上做的事:
    • 準備 1–2 本常用的 PDF(如年度報告、專案文件),作為之後測試的資料集。

    💡 關鍵: 支援約 128K tokens 的長上下文,讓單次對話就能覆蓋整本報告或多份文件,減少來回上傳與分段處理的麻煩。

    2. 多步驟 Agent + 工具呼叫:不只是聊天,是能「自己拆步驟」的小幫手

    • 它是什麼:模型後訓練時就針對多步驟代理流程(multi-step agent workflows),並支援 tool calling 格式,能主動:
    • 判斷需要使用工具(如讀檔、發 API)。
    • 先規劃步驟,再分批完成任務。
    • 適合的工具類型:
    • 檔案讀寫工具:讀取本地 txt、md、pdf(先轉文字)。
    • Web API:查天氣、查匯率、打公司內部 API。
    • 你可以馬上做的事:
    • 想一個「需要拆步驟」的工作流程,例如:整理一週郵件 → 分類 → 摘要 → 拉出待辦清單,留著稍後做 Agent 範例。

    3. 本地推理友善:記憶體 < 2.5GB,在手機 CPU 跑到 17–30 tok/s

    • 它是什麼:LFM2.5-2.6B 約 2.69B 參數,官方提供 Q4_K_M GGUF 量化版本,在手機上記憶體占用低於 2.5GB。
    • 實測數據:
    • Reddit 用戶在 OnePlus 13 手機上純 CPU 跑,約 17 tok/s。
    • Liquid AI 官方報告在某些推理與工具調用基準上,和 Qwen 3.5 9B 類模型接近,但資源需求低很多。
    • 你可以馬上做的事:
    • 確認自己的設備:RAM 至少 4GB(桌機 / 筆電更好),手機 Android 版本支援安裝第三方推理 App 或自訂引擎。

    💡 關鍵: 在純 CPU 手機上僅需不到 2.5GB 記憶體就能跑到約 17 tok/s,代表即使沒有高階 GPU,也能實際部署長上下文本地 AI。


    適合誰用:三個實戰場景

    1. 本地文件助理:長文閱讀、知識庫整理

    場景:你有大量 PDF 報告、技術文件,平常用雲端模型怕機密外流,或上傳很慢。

    可以怎麼用 LFM2.5:

    1. 在桌機用 llama.cpp 跑 LFM2.5,讀取本地資料夾中的文件(轉成文字)。
    2. 把多份文件丟進同一個上下文,請它:
    3. 「幫我整理這三份報告的差異,列出一頁摘要+決策建議。」
    4. 「從這堆文件找出所有提到 2025 年預算的段落。」

    你可以立刻做的事:

    • 整理一個 docs/ 資料夾,把 3–5 份常用文件轉成純文字(txt),準備接入 LFM2.5。

    2. 批量任務 Agent:整理郵件、報告、待辦清單

    場景:你每天有一堆重複的小事,例如「每週整理專案更新」、「把會議紀錄轉成待辦」。

    可以怎麼用 LFM2.5:

    1. 寫一個簡單腳本從郵件或系統導出文字(如 weekly_emails.txt)。
    2. 讓 Agent 執行一套固定流程:
    3. 讀入所有文本 → 按專案或標籤分類。
    4. 每類輸出摘要與關鍵日期。
    5. 最後產生「本週待辦清單」。

    你可以立刻做的事:

    • 決定一個你每週都在做的重複整理任務,想好輸入格式(例如一個大 txt),稍後在工具呼叫範例裡實作。

    3. 手機上的離線問答與簡易自動化

    場景:出差在外、網路不穩,也想有一個在手機上的「私人 AI 小助理」。

    可以怎麼用 LFM2.5:

    1. 在手機安裝支援 GGUF 的本地推理 App(如某些社群版 llama.cpp App,或自行編譯)。
    2. 把常用資料(旅遊行程、公司 FAQ、個人筆記)放進手機,讓模型作為離線問答庫。
    3. 再加上幾個簡單工具:
    4. 查本地檔案(行程、備忘錄)。
    5. 呼叫 Web API(天氣、匯率)— 有網路時也能用。

    你可以立刻做的事:

    • 在手機上預留至少 3–4GB 空間和足夠 RAM,並確認能安裝第三方推理 App 或有 adb 環境可連接自製引擎。

    怎麼開始:從桌機到手機,一步步實作

    步驟一:在 Hugging Face 下載模型與量化權重

    1. 打開 Hugging Face 模型頁:
    2. 搜尋 LFM2.5-2.6B 或直接從官方 Blog 連結進入:https://huggingface.co/LiquidAI。
    3. 選擇 GGUF 格式(例如官方提到的 Q4_K_M 量化版本)。
    4. 使用 git lfs 或直接瀏覽器下載:

    bash
    git lfs install
    git clone https://huggingface.co/LiquidAI/lfm2-5-2-6b-gguf

    你可以立刻做的事:

    • 安裝 git lfs,測試是否能順利 clone 大檔案。

    步驟二:用 llama.cpp 在桌機跑起來

    1. 安裝 llama.cpp:

    bash
    git clone https://github.com/ggerganov/llama.cpp
    cd llama.cpp
    make

    1. 把剛下載的 GGUF 模型放到 ./models/lfm2-5-2-6b-q4_k_m.gguf。
    2. 用基本推理指令測試:

    bash
    ./main \
    -m models/lfm2-5-2-6b-q4_k_m.gguf \
    -c 128000 \
    -n 256 \
    -p "你是一個中文助理,請用繁體中文回覆。幫我總結這段文字:..."

    你可以立刻做的事:

    • 先把 -c 設小一點(例如 8192),確認能跑,再逐步拉高到 128K 測試極限。

    💡 關鍵: 先以較小上下文長度測試穩定性,再逐步拉高到 128K,可以避免一開始就因資源不足導致崩潰。

    步驟三:在手機或低端設備配置推理引擎

    你有兩條路可以選:

    方案 核心功能 免費方案 適合誰
    原生 llama.cpp 編譯 直接在 Android / Linux 編譯 llama.cpp,跑 GGUF 模型 開源免費 喜歡動手編譯、可用 adb 的技術玩家
    第三方推理 App 安裝社群開發的本地 LLM App,匯入 GGUF 模型 多數免費或開源 想快速在手機體驗本地 AI 的一般使用者

    大致步驟示意(原生編譯路線):

    1. 在桌機用 adb 連上 Android 手機,確認有 shell:

    bash
    adb shell

    1. 把編譯好的二進位與模型檔推上手機:

    bash
    adb push ./main /data/local/tmp/
    adb push ./models/lfm2-5-2-6b-q4_k_m.gguf /data/local/tmp/

    1. 在手機上跑:

    bash
    cd /data/local/tmp
    chmod +x main
    ./main -m lfm2-5-2-6b-q4_k_m.gguf -c 32768 -n 128 -p "請用繁體中文介紹你自己。"

    你可以立刻做的事:

    • 測試一次 adb shell 是否正常;如果你偏好 GUI,搜尋一款支援 GGUF 的 LLM App,確認可以匯入模型檔。

    步驟四:串接簡單工具(檔案讀取 + Web API)

    LFM2.5 支援 tool calling 格式,你可以在自己的程式裡定義工具,讓模型決定何時呼叫。

    以下以 Python + llama.cpp HTTP 伺服器為例(概念示意):

    1. 先啟動 llama.cpp 的伺服器模式:

    bash
    ./server \
    -m models/lfm2-5-2-6b-q4_k_m.gguf \
    -c 128000 \
    --host 127.0.0.1 --port 8080

    1. 在 Python 定義兩個工具:讀檔與查匯率:

    python
    tools = [
    {
    "name": "read_file",
    "description": "讀取本地文字檔內容",
    "parameters": {
    "type": "object",
    "properties": {
    "path": {"type": "string"}
    },
    "required": ["path"]
    }
    },
    {
    "name": "get_fx_rate",
    "description": "查詢美元對新台幣即時匯率",
    "parameters": {
    "type": "object",
    "properties": {}
    },
    }
    ]

    1. 當模型輸出 tool call 時,由你的程式實際執行:

    python
    def call_tool(name, args):
    if name == "read_file":
    with open(args["path"], "r", encoding="utf-8") as f:
    return f.read()
    if name == "get_fx_rate":
    # 這裡打某個匯率 API
    return "目前 USD/TWD 約為 32.1"

    你可以立刻做的事:

    • 先做最簡單版本:只寫一個 read_file 工具,讓模型幫你讀取某個 txt,並摘要內容。

    收尾:下一步可以做什麼?

    如果你已經在桌機跑起 LFM2.5,有幾個很實際的下一步:

    • 把你的「每週重複工作」整理成一個 Agent 流程,固定用同一組工具+提示詞執行。
    • 把常用的公司文件、技術文檔轉成文字,作為 128K 上下文的知識庫。
    • 在手機上先跑小上下文(8K/16K),確認效能,再逐步增加到 32K,觀察速度和可用性。

    LFM2.5-2.6B 的重點不在「有多大」,而在「足夠聰明又能在你手邊的設備上跑」,只要你願意花一個週末,把下載、llama.cpp、簡單工具串接三件事做完,就能擁有一個真正屬於自己的本地 AI 小助手。

    🚀 你現在可以做的事

    • 到 Hugging Face 下載 LFM2.5-2.6B 的 Q4_K_M GGUF 模型,並在桌機用 llama.cpp 跑通基本推理
    • 準備一個 docs/ 資料夾與一個「每週重複任務」,作為之後 Agent 與長上下文測試用資料
    • 在手機上安裝支援 GGUF 的本地 LLM App 或配置 adb 環境,預留 3–4GB 空間準備導入模型
  • 在手機上跑本地滲透測試 AI:Nightcrawler 實戰

    在手機上跑本地滲透測試 AI:Nightcrawler 實戰

    📌 本文重點

    • Nightcrawler 讓手機成為行動滲透測試助手
    • 所有掃描與報告盡量在本地完成以保護隱私
    • 適合個人、小型內網與紅隊前期偵察使用
    • 只需簡單設定即可建立可重複安全檢查流程

    只用一支手機,在本地跑一個 AI pentesting agent,幫你自動掃描手機與周邊網路、找出潛在弱點並給出修補建議,這就是 Nightcrawler 要解決的問題。

    專案連結:https://github.com/garagehq/nightcrawler/


    核心功能:手機上的「行動滲透測試助手」

    1. 本地運行的 AI 滲透測試代理

    Nightcrawler 的定位很單純:在你的手機上扮演一個會自動行動的「滲透測試助手」,所有分析與推理盡量在本地完成。

    你可以直接讓它:

    • 在目前網路環境中自動偵測可掃描的目標(路由器、NAS、開發機等)
    • 針對指定 IP、子網做基本安全檢查
    • 把掃描結果整理成報告,並列出優先處理的問題

    可行動: 安裝完成後,從最簡單的指令開始:

    nightcrawler scan --target 192.168.0.0/24
    

    這會讓它在你家或辦公室內網跑一輪基本偵察,之後再看報告調整範圍。


    2. 自動掃描手機與周邊網路

    Nightcrawler 的重點不是只看「單一主機」,而是以你的手機作為入口,對周邊環境做偵察與掃描。

    實際能做到的事情包括:

    • 讀取手機目前連線的 Wi-Fi 網段,列出可到達的主機
    • 對這些主機做基本的 port scan / service 掃描
    • 將服務指紋交給 AI module,判斷可能存在的弱點類型(例如:舊版 HTTP 伺服器、未設密碼的管理介面)

    💡 關鍵: 透過手機作為入口,可以在不額外佈署設備的情況下掌握整個局部網路的暴露面。

    可行動: 在安全範圍內測試家中設備:

    nightcrawler scan --auto
    

    這會依照手機當前的網路環境自動偵測可掃描主機,適合初次使用快速看「家用設備有哪些服務暴露在網路上」。

    提醒:只在你有權限的網路與設備上使用,遵守當地法律與公司安全政策。


    3. 弱點說明 + 修補建議,一次給你

    掃描只是第一步,Nightcrawler 的價值在於「解讀」:它會用 AI 把技術細節翻譯成你可以直接採取行動的建議。

    一份典型報告會包含:

    • 找到的主機列表、服務與 port
    • 可能的風險標籤(例如:medium-risk: outdated SSH)
    • 每條問題的:
    • 為什麼是風險
    • 可能被怎麼利用
    • 具體修補步驟(更新版本、關閉不必要服務、改密碼策略等)

    💡 關鍵: 把「資安專業術語」轉成具體修補步驟,是讓非專業使用者也能實際提升安全的關鍵差異。

    可行動: 每次跑完掃描後,把報告依「風險等級」分三類:

    • 先處理 High:例如公開管理介面、預設帳密
    • 再排 Medium:例如舊版服務、弱加密
    • Low 視情況保留或記錄

    4. 本地運行的隱私與延遲優勢

    與雲端安全掃描工具相比,Nightcrawler 強調「盡可能在本地推理」,好處是:

    • 不需把內網結構、設備 IP、服務資訊丟到第三方伺服器
    • 在弱網路或無網路環境仍可使用基本功能
    • 掃描結果只存放在你手機本地,方便做內網紅隊演練前期偵察

    💡 關鍵: 把掃描與分析留在本地,可以同時兼顧安全檢查與敏感環境下的隱私需求。

    可行動: 在報告設定中,將輸出目錄指定為手機加密儲存區或你信任的私有備份方案(如加密同步到自建 NAS),避免報告外流:

    nightcrawler scan --target 192.168.0.0/24 --output /secure/reports/
    

    適合誰用:三個具體場景

    1. 個人手機安全檢查

    如果你平常只靠 Android/iOS 內建的安全提示,其實只看到「App 權限」的一小部分。Nightcrawler 可以幫你補上:

    • 手機連線的 Wi-Fi 是否有可疑設備
    • 是否有開啟但你根本沒在用的服務(如某些測試用 web server)
    • 從外部角度看你的開發機、測試機有多「裸露」

    可行動: 每次連上公共 Wi-Fi(咖啡店、旅館)時,跑一次快速掃描:

    nightcrawler scan --auto --profile public_wifi
    

    把這當作「連上陌生網路前的健康檢查」。


    2. 小型內網的簡易滲透測試

    對中小企業、小型團隊來說,請專業資安顧問做完整滲透測試成本不低,但你可以先用 Nightcrawler 做一輪「預檢」。

    適合用在:

    • 新部署內網服務前,快速看是否有明顯暴露
    • 老舊系統尚未汰換前,先抓幾個最容易被打的點
    • 內部開發環境(CI server、test server)是否有開到外部網段

    可行動: 選擇一個子網作為範圍,定期(例如每月)跑一輪掃描,建立安全 baseline:

    nightcrawler scan --target 10.0.0.0/24 --output /secure/monthly/
    

    之後比對差異,看是否有新增高風險服務或設備。


    3. 紅隊演練的前期偵察

    對紅隊或安全研究者來說,Nightcrawler 可以當作「隨身偵察工具」。在合法授權範圍內:

    • 用手機在現場快速掃描演練環境
    • 取得初步服務列表後,再用更專業工具(如 nmap、Burp)深挖
    • 用 AI 生成攻擊路徑假設,幫助制定演練腳本

    可行動: 把 Nightcrawler 報告當作演練前的「資產盤點」,再把標記為 High 的項目納入紅隊攻擊路徑設計。


    怎麼開始:從安裝到第一次掃描

    1. 下載與安裝

    目前 Nightcrawler 以開源專案形式提供,主入口在 GitHub:

    https://github.com/garagehq/nightcrawler/

    一般上手路線:

    1. 確認支援平台:以 Android(搭配 Termux)或 Linux 手機環境為主,iOS 需額外繞路(如越獄或遠端代理)。
    2. 安裝必要環境:在手機安裝 Termux 或類似終端環境;確保有 Python / Node.js(依專案需求)與必要套件。
    3. Clone 專案:
      bash
      git clone https://github.com/garagehq/nightcrawler.git
      cd nightcrawler
    4. 依 README 安裝依賴:通常是 pip install -r requirements.txt 或專案提供的安裝腳本。

    可行動: 完成上述步驟後,在終端輸入:

    nightcrawler --help
    

    確認指令有正確註冊,確定環境準備完畢。


    2. 基本配置:先限制好掃描範圍

    為了避免不小心掃到不該掃的網段,建議一開始就設定清楚:

    • 指定允許掃描的子網(例如:家用路由器分配的網段)
    • 限制最大併發連線數,避免造成設備負擔
    • 啟用報告匿名化(隱藏部分 IP、主機名,方便分享給同事但不暴露太多細節)

    範例配置檔(假設為 config.yaml):

    network:
      allowed_ranges:
        - 192.168.0.0/24
      max_concurrent_scans: 32
    report:
      anonymize: true
      output_dir: /secure/reports/
    

    可行動: 按上述範例建立自己的 config.yaml,之後所有掃描都帶上:

    nightcrawler scan --config config.yaml --auto
    

    3. 第一次執行建議腳本與報告解讀方式

    第一次跑,建議用「保守但全面」的腳本:

    nightcrawler scan \
      --config config.yaml \
      --target 192.168.0.0/24 \
      --profile default \
      --output /secure/reports/first_scan.json
    

    跑完後,報告通常為 JSON 或簡易 HTML。解讀時可以照這個順序:

    1. 先看 Summary:總共有多少主機、幾個 High / Medium / Low issue。
    2. 鎖定 High:逐一查看是哪些設備(路由器?NAS?開發機?),問題是什麼類型(弱密碼、未授權存取、舊版服務)。
    3. 執行修補:根據建議更新 firmware、關掉不必要服務、改強密碼政策。
    4. 再跑一次掃描:確認問題是否消失或降級。

    可行動: 把第一份報告視為「現狀快照」,搭配你現有的備份/加固流程,一次整理。


    簡單 workflow 示範:Nightcrawler + 備份 / 加固工具

    為了讓你讀完就能馬上用,這裡給一個最簡單可落地的 workflow:

    1. 偵察與報告(Nightcrawler)
    2. 每月或每次環境變更後,跑一次:
      bash
      nightcrawler scan --config config.yaml --auto --output /secure/reports/scan_$(date +%F).json

    3. 備份重要設定與資料(例如:rsync / restic / 自建 NAS 工具)

    4. 對報告中標記為「關鍵設備」的主機,將設定檔與重要資料做加密備份。
    5. 可用簡單指令,例如:
      bash
      rsync -avz /etc /backup/router_config/

    6. 加固與追蹤

    7. 根據 Nightcrawler 報告中的修補建議,逐項調整設定。
    8. 建立一個簡單的變更紀錄(哪一天改了哪台設備、做了什麼修補)。
    9. 下次掃描時,比對報告、確認風險有下降。

    這樣,你就用一支手機,建立起一個「可重複、可追蹤」的個人或小型團隊安全檢查流程。


    小結

    Nightcrawler 把「手機上跑本地滲透測試 AI」這件事變成日常可以操作的工作:連上網路、跑掃描、看報告、依建議加固。只要你願意花一點時間設定範圍與流程,就能在不依賴雲端的大前提下,對自己的手機和內網做更有系統的安全檢查。

    🚀 你現在可以做的事

    • 到 GitHub 下載並安裝 Nightcrawler,完成環境與依賴設定
    • 建立自己的 config.yaml,限定掃描網段並設定輸出目錄後跑一次初始掃描
    • 依第一份報告中的 High / Medium 風險執行修補,並建立每月定期掃描與變更紀錄流程
  • Kimi K3 開源巨模型這樣玩

    Kimi K3 開源巨模型這樣玩

    📌 本文重點

    • Kimi K3:接近 GPT/Claude 的開源巨型模型
    • 專長程式碼與 Agent 任務,易於接商業系統
    • 可用雲端 API 或本地部署,自由度與控制高
    • 適合工程師、Agent 架構師與重度玩家實驗

    Kimi K3 解決的問題很單純:給你一個接近 GPT/Claude 水準、擅長程式與 Agent 任務的大模型,而且開源、可自己選擇在雲端或本機跑。

    相關連結:
    – Kimi K3 HuggingFace 模型頁:https://huggingface.co/moonshotai/Kimi-K3
    – Telnyx Inference K3 公告:https://telnyx.com/release-notes/kimi-k3-telnyx-inference
    – Unsloth K3 GGUF:https://huggingface.co/unsloth/Kimi-K3-GGUF


    什麼是 Kimi K3?跟 GPT / Claude 有什麼不一樣?

    用一句話概括:Kimi K3 是 Moonshot AI 開源的 2.8 兆參數巨型語言模型,對程式碼與 Agent 控制任務特別友好,目前表現被評為「僅次於 Claude Fable 5 和 GPT 5.6 Sol」等頂級閉源模型(來源:HN 社群與官方基準測試)。

    💡 關鍵: 2.8 兆參數的大模型搭配開源授權,讓你在接近 GPT/Claude 能力的同時,保有高度部署與成本控制自由度。

    跟 GPT / Claude 比較時,你可以這樣理解:

    • 能力層級接近:在長上下文、程式碼生成、多輪推理上,已經可以拿來對標主流商業模型。
    • 部署選擇更多:你可以用 Telnyx 的雲端推論 API,也可以下載權重自己跑(甚至用 GGUF + 本地推理框架)。
    • 成本與控制權:不綁死單一雲廠商,企業可以放在自家基礎設施,用自訂安全與合規策略。

    若你已經習慣用 OpenAI API,K3 的好處是:幾乎不用改程式碼,就能多一個「接近 GPT 等級、但開源」的備用模型。


    核心功能:這三件事值得你花時間試

    1. 程式碼生成與重構:偏工程、偏實作

    Moonshot 自己把 K3 定位在「程式與 Agent 任務」上,實際上,你可以這樣用:

    • 產生完整模組:給需求(功能 + 輸入 / 輸出),讓 K3 生成一個 Node.js/Go/Python 模組,再自行接測試。
    • 讀懂舊專案:把關鍵檔案貼進去,請 K3 建立架構圖、流程說明,或寫 README 草稿。
    • 重構與風格統一:讓它把多個檔案改成同一風格(命名規則、錯誤處理方式)。

    可立即行動:

    • 在 Telnyx 建一個 K3 endpoint,實測「給一份 200 行以上程式檔,請它加 log + 補型別註解」。
    • 用現有 GPT prompt 直接丟給 K3,看產出品質差異。

    2. 工具 / Agent 控制能力:讓它當「任務調度員」

    K3 被設計來擅長 Agent 類任務,包含:

    • 呼叫外部工具:根據自然語言指令自動選擇要呼叫的 API(例如:查資料 / 寫檔 / Call 內部服務)。
    • 多步驟工作流程:把「需求拆分 → 呼叫多支工具 → 彙整結果」變成自動化流程。

    實作方式很簡單:

    • 用現成 Agent 框架,如:
    • openwork
    • Task Monki
    • 把它們原本的 OpenAI / Anthropic provider,換成 Telnyx 的 K3 endpoint(通常只改 API base URL + model 名稱)。

    你可以做的具體場景:

    • 內部 Copilot:
    • Agent 負責:根據 ticket 自動查 DB、抓 log、產生初版修補建議。
    • 人類工程師:只做審核 & 修改。
    • 定時自動化工作:
    • 用 K3 + Agent 每天抓報表、生成 Slack 摘要。

    3. 長上下文 + 多地區推論:大專案與企業環境好用

    K3 的模型巨大(2.8 兆參數),這讓它在處理長文件、複雜專案時比較穩定。

    Telnyx 的優勢是:

    • 自有 GPU 基礎設施,在美 / 歐 / APAC / MENA 部署,減少延遲。
    • 零資料保留:回應送出後不存 prompt / completion,對隱私要求高的團隊友善。

    立即可做的事:

    • 把一份 100+ 頁的規格文件(或公司內部 SOP PDF)丟給 K3,測試:
    • 能否回答細節問題?
    • 能否根據規格寫出一份 API 設計草稿?

    適合誰用?三種典型使用者

    1. 後端工程師:把 K3 當成「外部推論服務」

    場景:你已經有 Node / Python 後端,希望:

    • 增加「用自然語言操作系統功能」的能力。
    • 做內部 Copilot / Chatbot,而不想完全依賴單一閉源模型。

    可做的事:

    • 在 Telnyx 註冊帳號、建立 API Key。
    • 用 OpenAI compatible 接口,把原本的 api.openai.com 換成 Telnyx endpoint。

    2. Agent / 自動化開發者:整合 openwork / Task Monki

    場景:你正在做多工具 Agent,或內部自動化流程。

    可做的事:

    • 在 Agent 專案的「模型 provider 設定」裡,加一個 kimi-k3 選項。
    • 給 K3 一個「工具列表 + JSON schema」,觀察它在多步驟任務中的表現。

    3. 重度玩家與本地部署愛好者

    場景:你有強力伺服器 / 迷你機櫃,想自己掌控推論環境。

    可以善用:

    • Unsloth 提供的 K3 GGUF:
    • MXFP4 版本約 1.5 TB,適合多 GPU / 伺服器集群。
    • 可搭配 LLaMA.cpp、vLLM 或其他支援 GGUF 的推論框架。
    • Reddit 上已有人用 80× RTX 5090 + 25GbE 跑 K3,用來驗證分散式推論架構。

    具體行動:

    • 先用 Telnyx API 測試 prompt 設計。
    • 確認效果滿意後,再評估是不是值得投資本地硬體。

    怎麼開始:最小可行程式碼

    1. 用 curl 測試:確認 API 正常

    假設 Telnyx 提供 OpenAI 兼容 API(實際 endpoint 以官方文件為準),你可以這樣打:

    curl https://api.telnyx.com/v1/chat/completions \
      -H "Authorization: Bearer YOUR_TELNYX_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{
        "model": "kimi-k3",
        "messages": [
          {"role": "system", "content": "You are a helpful coding assistant."},
          {"role": "user", "content": "用 Node.js 寫一個回傳 Hello Kimi K3 的 API server"}
        ]
      }'
    

    看到 JSON 回應就表示:

    • API Key 正常
    • 模型名稱設定正確

    接下來就能接進你的後端程式。

    2. Node.js 範例:在 Express 後端接 K3

    // 安裝:npm install openai axios
    import OpenAI from "openai";
    
    const client = new OpenAI({
      apiKey: process.env.TELNYX_API_KEY,
      baseURL: "https://api.telnyx.com/v1" // 以官方文件為準
    });
    
    async function askK3(prompt) {
      const completion = await client.chat.completions.create({
        model: "kimi-k3",
        messages: [
          { role: "system", content: "You are a senior backend engineer." },
          { role: "user", content: prompt }
        ]
      });
      return completion.choices[0].message.content;
    }
    
    // Express handler
    import express from "express";
    const app = express();
    app.use(express.json());
    
    app.post("/k3", async (req, res) => {
      try {
        const answer = await askK3(req.body.prompt);
        res.json({ answer });
      } catch (e) {
        console.error(e);
        res.status(500).json({ error: "K3 request failed" });
      }
    });
    
    app.listen(3000, () => console.log("Server running on http://localhost:3000"));
    

    立即可做的事:

    • 把 prompt 改成你的業務場景,例如「根據這個 JSON 產生 SQL 查詢」。
    • 加上簡單的 rate limit(例如用 express-rate-limit),避免過度消耗。

    3. Python 範例:快速做一個 CLI 助手

    # 安裝:pip install openai
    import os
    from openai import OpenAI
    
    client = OpenAI(
        api_key=os.environ.get("TELNYX_API_KEY"),
        base_url="https://api.telnyx.com/v1"  # 以官方文件為準
    )
    
    def ask_k3(prompt: str) -> str:
        resp = client.chat.completions.create(
            model="kimi-k3",
            messages=[
                {"role": "system", "content": "You are a helpful coding assistant."},
                {"role": "user", "content": prompt},
            ],
        )
        return resp.choices[0].message.content
    
    if __name__ == "__main__":
        while True:
            q = input("Question> ")
            if not q:
                break
            ans = ask_k3(q)
            print("\nK3:\n", ans, "\n")
    

    硬體與費用:API 用戶 vs 重度玩家

    一般使用者:建議走 Telnyx 等推論 API

    原因很直接:

    • 模型太大:2.8 兆參數,連 GGUF 壓縮版都動輒 TB 級。
    • 基礎設施複雜:多 GPU、網路拓撲、負載均衡都要自己維護。

    💡 關鍵: 對大多數團隊來說,先用雲端推論服務評估延遲與成本,再決定是否投資自架硬體,是風險最低的路線。

    實際做法:

    • 先用 Telnyx 的免費額度或最低計價方案測試。
    • 實際量測:每個請求平均延遲與成本,決定是否放進正式產品。

    重度玩家:考慮 GGUF + 自架集群

    若你符合以下條件:

    • 有多張高階 GPU(至少數十張 RTX 4090/5090 或同級別伺服器卡)。
    • 熟悉分散式訓練 / 推論、InfiniBand / 高速乙太網架構。

    可以這樣走:

    • 從 Unsloth 的 Kimi K3 GGUF 下載合適量化版本(例如 MXFP4)。
    • 搭配 LLaMA.cpp、vLLM 等框架測試吞吐量與延遲。
    • 先跑內部 PoC,把 prompt、系統設計穩定後再考慮大規模部署。

    小結:先把 K3 當「第二個 GPT 入口」來用

    如果你現在已經在用 GPT/Claude:

    • 第一步:把現有程式加一個 kimi-k3 選項,實際比較輸出品質。
    • 第二步:選一個流程(例如程式碼重構或自動產出內部報表)交給 K3 + Agent 試跑。
    • 第三步:根據成本與延遲,決定要不要深度綁定,或甚至規劃本地/自架方案。

    Kimi K3 的價值不在「多一個模型」,而是:讓你在接近 GPT/Claude 能力的級別上,第一次有了真正開源、可自由部署的選擇。

    🚀 你現在可以做的事

    • 到 Telnyx 註冊帳號並建立 kimi-k3 endpoint,用你的既有 GPT prompt 實測輸出品質與延遲
    • 在現有後端或 Agent 專案中,新增一個 kimi-k3 provider,實驗程式碼重構或內部 Copilot 場景
    • 前往 HuggingFace 下載 K3 模型或 Unsloth GGUF 版本,評估未來在自家硬體上部署的可行性