標籤: 本地部署

  • 用手機跑 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)。
    • 先規劃步驟,再分批完成任務。
    • 適合的工具類型
    • 檔案讀寫工具:讀取本地 txtmdpdf(先轉文字)。
    • 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.6BQ4_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 可以當作「隨身偵察工具」。在合法授權範圍內:

    • 用手機在現場快速掃描演練環境
    • 取得初步服務列表後,再用更專業工具(如 nmapBurp)深挖
    • 用 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.cppvLLM 或其他支援 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.cppvLLM 等框架測試吞吐量與延遲。
    • 先跑內部 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 版本,評估未來在自家硬體上部署的可行性
  • Moonshot Kimi K3:免費玩前沿級大模型

    Moonshot Kimi K3:免費玩前沿級大模型

    📌 本文重點

    • Kimi K3 提供接近前沿模型的開源選項
    • 原生支援約 100 萬 tokens 超長上下文
    • 採 MoE 結構與 MXFP4 量化,部署成本可控
    • 資安與數學能力較弱,需搭配其他模型

    Kimi K3 解決的是一個很直接的問題:中小團隊想用接近 Fable 5 / GPT-5.6 Sol 水準的大模型,但不想被閉源 API 的價格與限制綁死

    官方與基準介紹可參考 Moonshot 與媒體報導:The Verge 解讀中國開源策略(連結)、The Decoder 的 K3 權重釋出分析(連結)。


    核心功能:你真的能拿來做什麼

    1. 超長上下文:最高 100 萬 tokens

    Kimi K3 最實用的亮點,是原生支援最高約 1M tokens 的上下文,這代表:

    • 一次放進去整份法規、技術手冊、研究報告,讓模型直接「看完再回答」
    • 免拆章節、免自己做分段檢索(RAG),可以先用「暴力長上下文」快速原型

    💡 關鍵: 約 1M tokens 的上下文,讓你可以直接丟整份大型文件進模型處理,不必先做複雜的分段與檢索設計

    可以直接做的事:

    • 把公司內訓教材、API 文件打包成一個長 PDF,上傳到 K3 雲端推理,讓新人直接「問系統」而不是翻文件
    • 法務團隊把合約全集丟進模型,要求它找出一個特定條款在不同版本中的變化

    2. MoE 結構:896 個專家,16 個同時上場

    Kimi K3 是一個大型 Mixture of Experts(MoE)模型:

    • 2.8 兆參數、896 個 expert,每個 token 只啟用 16 個 expert
    • 好處:推理成本不像「全參數都算」那麼誇張,但表現接近前沿模型

    💡 關鍵: 以 2.8 兆參數、每個 token 僅啟用 16 個 expert 的 MoE 設計,在保留模型能力的同時,大幅降低推理成本

    對你而言的具體效果:

    • 做聊天助理、知識問答時,回應品質比一般開源中階模型要穩定
    • 成本與效能在「自己架」與「雲端推理」之間有彈性空間

    3. 視覺能力 + MXFP4 量化:為部署而生

    K3 內建:

    • 視覺能力:可以處理圖片(例如讀圖表、截圖說明、簡單 UI 規劃)
    • MXFP4 量化感知訓練:權重約 1.4 TB,原生就以低精度格式訓練,對推理效能更友善

    💡 關鍵: 原生 MXFP4 量化感知訓練與約 1.4 TB 權重,讓你在部署時不用額外量化,直接享受低精度帶來的效能優勢

    這對你意味著:

    • 如果你在做「文件 + 圖表」分析(財報、研究報告、技術圖解),可以用一套模型完成
    • 部署時不用自己再做一次量化,直接用官方 MXFP4 權重即可

    適合誰用:三種典型場景

    1. 中小團隊:自架聊天 / 知識助理,替代閉源 API

    痛點:用 GPT 類模型做內部知識庫或客服助理,API 成本難控、資料怕外流、客製受限。

    Kimi K3 能做的事:

    • 自架「公司版 ChatGPT」,所有資料在自己控制的環境裡
    • 把 FAQ、產品手冊、內部 SOP 都塞進去,做第一版知識助理原型

    具體行動:

    • 先用 Hugging Face 雲端推理試跑聊天助理雛型
    • 如果效果符合預期,再評估是否值得投入 GPU 成本做正式部署

    2. 長文檔處理:法務、研究、技術文件

    痛點:一般模型需要分段 + RAG,設定複雜,而且容易漏掉跨章節脈絡。

    Kimi K3 的優勢:

    • 用超長上下文直接塞進完整文件,不必先切小塊
    • 對「跨章節、跨文件」的比較與歸納特別方便

    具體行動:

    • 法務:將過去三年的合約樣本合併成一個長文件,讓 K3 找出常見風險條款
    • 研究:把十篇相關論文丟進同一 session,請模型整理不同方法的優劣與假設

    3. 做 AI 產品原型:蒸餾、微調的母模型

    痛點:想做垂直領域模型(醫療、金融、工業),但找不到足夠強的開源基底。

    Kimi K3 適合:

    • 當成「教師模型」,給你下游小模型做蒸餾
    • 作為微調基底,針對特定任務(寫程式、產出技術報告)強化

    具體行動:

    • 用雲端推理先定義「你希望學生模型學會的風格與能力」
    • 再用 K3 + 你的任務數據做一次指令微調,產出中型學生模型,方便在更便宜的硬體跑

    怎麼開始:免硬體門檻到最低部署指南

    路徑一:先用 Hugging Face / 雲端推理快速試

    如果你只是想評估 K3 適不適合你的場景,不要一開始就買 GPU,先用雲端:

    1. 到 Hugging Face 找模型卡
      搜尋「Kimi K3」或 Moonshot 官方模型卡(權重預計放在 HF,對應 Reddit 討論:連結)。

    2. 點進「Inference API」或社群提供的 web demo

    3. 用你的實際任務測試:

    4. 貼一段長文件(法規、說明書)
    5. 要它做摘要、條款比對、寫技術說明

    6. 記錄:

    7. 回答是否跟得上上下文
    8. 對專業領域的理解是否足夠

    評估重點:

    • 如果主要是長文理解、摘要與一般知識問答,K3 通常足夠
    • 若你要高風險場景(資安、程式驗證、精準數學),記下它的弱點,準備搭配其他模型

    路徑二:有 GPU 的讀者,最低門檻部署指南

    K3 的完整 MXFP4 權重大約 1.4 TB,單節點塞滿是高難度任務。社群實測從 A100B300,結論大致如下:

    GPU 配置 記憶體總量(8 卡) 實際狀況 適合誰
    A100 80G 約 640 GB 明顯不足,需多節點 + 進階分片,延遲高,數學表現被壓縮 有現成 A100 集群、願意做工程優化的團隊
    H200 約 1.13 TB 仍略不足,需要多節點;推理可行但調度較複雜 已在用 H200 做大模型、有 infra 團隊
    B300 約 2.3 TB 理論上單節點可放完整模型,部署體驗最佳 願意為前沿模型砸錢的大型團隊

    以上配置分析來源:r/LocalLLaMA 部署討論(連結)。

    最低實用部署步驟(以有 H200 / B300 為例)

    1. 決定你要跑的場景

    2. 若只做測試與小流量聊天:多節點 H200 即可

    3. 若預計有穩定商業流量:優先考慮 B300 單節點,省通訊痛苦

    4. 準備軟體堆疊(雲端或本地)

    5. 安裝支援大模型的推理框架:如 vLLMTensorRT-LLM 或自家客制方案

    6. 確定框架支援 MXFP4 / 低精度推理與 MoE 分片

    7. 下載權重並做分片配置

    8. 從 Hugging Face 拉取 K3 權重(約 1.4 TB,需有足夠存儲)

    9. 根據 GPU 數量與記憶體設定分片策略:每張卡 load 部分 expert

    10. 發布一個簡單的 API

    11. 預設路由:/chat/completion/file-qa

    12. 對內部前端(客服面板、知識庫 UI)只暴露 HTTP API,方便日後換模型

    成本與取捨提醒

    • A100 世代:沒有最新低精度 tensor core,跑 K3 會偏吃力,延遲與能耗都不優;如果只是測試,OK,但不建議長期商用。
    • H200:算力與頻寬更好,但仍需要多節點分散模型;工程複雜度較高。
    • B300:最接近「想跑就跑」的體驗,但硬體成本非常高,只適合已有前沿模型需求的公司。

    弱點與搭配策略:資安與數學要小心

    獨立測試與媒體報導提到,K3 在網路安全與數學能力上有明顯差距,很可能跟蒸餾過程有關(參考 The Decoder 報導:連結)。

    實際使用時,建議你這樣處理:

    1. 資安 / 攻擊向量相關任務

    2. 不要把「產生攻擊腳本、滲透測試細節」交給 K3

    3. 若你的產品涉及資安,只用 K3 做一般說明與文件整理,再用專門模型(或人工審核)處理技術細節

    4. 高精度數學與程式驗證

    5. 複雜數學推導、金融衍生品定價等,不要只信 K3 的第一個答案

    6. 可以採用「雙模型策略」:

      • K3 負責理解題目與長上下文(例如一整份投資報告)
      • 用擅長數學 / coding 的模型(如專門 code LLM)負責計算與程式檢查
    7. 內部評估流程

    8. 上線前,先設計一套測試題(你自己的真實問題),量測:

      • 資安敏感問題的回答是否合規
      • 數字題、程式題的錯誤率
    9. 把測試結果寫入內部使用指南,明確標記「K3 能做什麼/不能做什麼」。

    小結:你可以立刻採取的三個行動

    1. 先在 Hugging Face 上跑一次你的真實長文場景
      丟一份你現在用 GPT 處理的 PDF,看看 K3 的回答差異。

    2. 評估是否值得搭建內部知識助理
      若你每月在閉源 API 上花的錢已經不小,K3 是一個值得算帳的替代選項。

    3. 如果你有 GPU 集群,安排一個週末 PoC
      用最小配置把 K3 部署成內部 API,跑一輪你關鍵團隊(法務、客服、研發)的真實工作流程,再決定要不要進一步優化。

    Kimi K3 把「前沿級模型」帶進了開源與可控成本的範圍內,只要你清楚它的長處與短板,就能把它變成你團隊的工具,而不是風險。

    🚀 你現在可以做的事

    • 去 Hugging Face 搜尋「Kimi K3」,用 Inference API 跑一份你實際的長文件
    • 整理公司內部 FAQ、SOP 與技術文件,規劃一版「公司版 ChatGPT」原型需求
    • 盤點現有 GPU / 雲端資源,模擬在 H200B300 上部署 K3 成內部 /chat API 的 PoC 計畫
  • BTL-3:8GB 就能跑的本地程式代理人

    BTL-3:8GB 就能跑的本地程式代理人

    📌 本文重點

    • BTL-3 是可本地部署的程式代理人模型
    • 8.39GB GGUF 保留約 92% 的 27B 能力
    • 特化在工具呼叫與完整程式工作流
    • 適合離線開發與本地 Agent 架構

    想要在自己電腦上擁有類似 GitHub Copilot / Claude Code 的程式代理人,又不想連雲端?BTL-3 是目前少數「真實可落地」的開源選擇。

    原帖與技術細節:[Reddit] BTL-3 27B agentic coding model


    核心功能:一顆小體積、但會「自己想和動手做」的模型

    1. Agentic 架構:不只是聊天,而是完整工作迴圈

    BTL-3 的訓練目標不是「回答問題」,而是模擬一個真正的程式代理人工作流:

    Reason → Act → Inspect → Recover → Continue

    你可以直接把它當成一個「會自己規劃與檢查的本地 Copilot」,實際用法像這樣:

    1. Reason(思考):給它一個 repo 跟目標,例如:把這個專案加上簡單的健康檢查 API
    2. Act(行動):它會規劃要改哪些檔案、生成修改方案或腳本。
    3. Inspect(檢查):搭配工具(如 git diff、測試腳本)檢查結果。
    4. Recover(恢復):若測試失敗,會根據錯誤訊息繼續修正。

    行動建議:

    • 設計你的 prompt 時,直接描述「任務目標 + 可用工具 + 成功條件」,讓它接手後續流程,而不是只叫它「寫一段程式」。

    2. 工具呼叫:一次、連續、並行都能掌握

    BTL-3 內建工具使用能力,可做到:

    • 單次工具呼叫:例如呼叫 bash 跑測試、或呼叫 HTTP client 打內部 API。
    • 連續呼叫:先爬資料,再處理,再更新資料庫。
    • 並行呼叫:同時對多個服務發出請求,再整合結果。
    • 知道何時不要用工具:測試顯示,它在「工具呼叫放棄」場景的表現也很不錯(原文數據:工具呼叫放棄約 91.2% 準確)。

    💡 關鍵: 約 91.2% 的工具呼叫放棄準確率,代表它不只會用工具,也懂得在不需要時適時收手。

    你可以把它接到現成 orchestrator(如 MCP、或你自己的 agent framework),讓 BTL-3 再負責「判斷何時用哪個工具」。

    行動建議:

    • 若你已有工具系統(CLI、內部 API),先列出 3–5 個常用操作,包成「工具描述 + I/O 格式」,再讓 BTL-3 透過這些工具完成任務,而不是只輸出文字。

    3. 在 8.39GB GGUF 裡塞進 92% 的 27B 智慧

    BTL-3 原始是 27B 參數模型,但 Bad Theory Labs 用自家量化壓縮技術(AVQ2 解碼、INT4 仿射運算等),做出一個:

    • 單一 GGUF 檔(約 8.39GB)
    • 每參數不到 2.5 bits
    • 保留約 92.2% 原始模型能力

    💡 關鍵: 約 8.39GB 的 GGUF 就保留 92.2% 能力,代表一般開發者電腦即可接近 27B 模型效能。

    一個關鍵指標是 HumanEval pass@1 約 95.12%,這個成績在開源程式模型裡非常高,實際效果就是:

    • 常見演算法題、資料處理、API 包裝腳本,大多可以一次寫對(或只需小修)。

    💡 關鍵: HumanEval pass@1 約 95.12%,表示它在「一次寫對程式」上的成功率已逼近頂級商業程式模型水準。

    行動建議:

    • 若你現在在本地跑的是 7B–8B 一般聊天模型(例如常見的「通用 LLM」),可以直接用同一套 llama.cpp / LM Studio 配置,換成 BTL-3 GGUF,感受一次「針對程式與工具使用優化」的落差。

    適合誰用:三種典型場景

    1. 離線/內網環境的程式開發助手

    如果你的程式碼不能上雲(金融、政府、內網產品),BTL-3 提供一條路:

    • 在機房或開發者筆電本地部署,不經過外部 API。
    • 讓它讀 repo、理解架構、提出修改建議。

    典型任務:

    • 在不同微服務間統一 logging 格式。
    • 為舊專案補上基本 test suite。

    行動建議:

    • 選一個「不能丟到 GitHub Copilot」的專案,讓 BTL-3 先生成一份「系統總覽 + 待改善清單」,作為內網 code review 助手。

    2. 自動化腳本 & 工具串接

    BTL-3 對工具呼叫特別強,適合當成:

    • CLI 自動化腳本生成器幫我寫一個每天備份某資料夾到 S3 的腳本
    • 爬蟲與內部 API orchestration:串接 curlPython script、內部 REST API

    行動建議:

    • 設計一個小專案:例如「自動整理 log + 發 Slack 通知」,讓 BTL-3 負責生成腳本、再透過工具跑一次,測試它的完整 workflow 能力。

    3. 本地 Agent 開發環境的一顆「程式專家」核心

    你可能已經在用:

    • llama.cpp / vLLM 當推理引擎
    • 本地 IDE 插件(VS Code extension、JetBrains plugin)
    • MCP 或其他 orchestrator 做多工具協調

    BTL-3 可以直接當「程式 & 工具專家」,其他模型負責一般聊天或決策。

    行動建議:

    • 在你的 agent framework 裡,新增一個 coding-agent 路由:
    • 當任務涉及 repo、CLIAPI 操作時,轉給 BTL-3。
    • 其他任務仍用通用模型(如 Solar Open 2Laguna S 2.1 等)。

    下面用表格簡單比較常見選項:

    名稱 核心功能 免費方案 適合誰
    BTL-3 本地程式代理人、工具呼叫 開源、GGUF 免費 想要本地 Copilot / 程式 Agent
    Solar Open 2 長上下文、辦公 & 程式代理 開源模型 文件密集 + 長上下文任務
    Laguna S 2.1 多語言、大型本地通用模型 開源模型 需要高性能通用助手

    相關連結:


    怎麼開始:從硬體到第一個 workflow

    Step 1:確認硬體配置

    官方 8.39GB GGUF 版本的目標是「一般開發者電腦可以跑得動」,實務建議:

    • RAM:16–32GB(越多越穩定)
    • GPU:一張中階卡(8–12GB VRAM 足夠),或純 CPU 也可嘗試
    • 儲存空間:至少預留 20GB 給模型與前端工具

    行動建議:

    • 先在自己的機器跑過任一 7B–8B GGUF 模型,如果能順跑,再換 BTL-3 應可接受。

    Step 2:下載 BTL-3 GGUF 模型

    目前 BTL-3 GGUF 版本由 Bad Theory Labs 釋出(連結通常在 Reddit 原帖或其 X 帳號):

    行動建議:

    • 用瀏覽器或 wget 下載 GGUF 檔到一個固定資料夾,例如:~/models/btl3/btl3-agentic.gguf

    Step 3:用 llama.cpp / LM Studio / Ollama 載入

    三條常見路徑:

    1. llama.cpp(命令列 / 伺服器模式)
    2. 安裝:依官方 repo 說明編譯。
    3. 啟動 server:
      bash
      ./llama-server \
      -m ~/models/btl3/btl3-agentic.gguf \
      -c 262144 \
      --host 0.0.0.0 --port 8080
    4. 之後透過 HTTP API 或前端連接。

    5. LM Studio

    6. 開啟 LM StudioAdd local model → 指向 GGUF 檔。
    7. 選好推理設定(context 長度、GPU offload),直接在內建聊天介面測試。

    8. Ollama 類工具

    9. 建一個 Modelfile 指向 BTL-3 GGUF。
    10. ollama run btl3 即可啟動本地推理。

    行動建議:

    • 初次使用先從 LM Studio 或類似 GUI 工具開始,快速確認模型品質,再把配置搬到 llama.cpp / server 模式。

    Step 4:實作一個簡單 workflow:讀 repo → 改動 → Patch → 自評測

    以下示範用「BTL-3 + llama.cpp server + 你習慣的 HTTP client」做一個小流程。

    1. 讓 BTL-3 讀 repo
    2. 先用你自己的 script 把重要檔案(README、主要程式入口、config)整理成一個壓縮過的文字輸入。
    3. 發送一個請求:
      json
      {
      "prompt": "你是一個程式代理人。以下是專案的主要檔案內容:...\n\n請先用條列方式整理這個系統的主要模組與依賴,再列出 3 個可以改善的地方。",
      "max_tokens": 2048
      }

    4. 規劃改動

    5. 根據它提出的改善建議,選一項(例如「增加健康檢查 API」),再下指令:
      > 「請為此改動設計一個實作計畫:要改哪些檔案、新增哪些函式、需要哪些測試。」

    6. 生成 Patch

    7. 要求它輸出 git-style unified diff
      > 「根據上面的計畫,請輸出 unified diff 格式的 patch,適用於 git apply。」

    8. 自評測

    9. 套用 patch,跑測試(可寫成工具讓 BTL-3 呼叫)。
    10. 把測試結果回傳給 BTL-3:
      > 「以下是測試輸出,請根據錯誤訊息更新 patch。」

    行動建議:

    • 把上述流程包成一個腳本或簡單 web UI,讓 BTL-3 成為你團隊的「自動 Patch 提案助手」,從單一專案先試用。

    Step 5:接進你現有的 Agent workflow(如 MCP)

    如果你已在用 MCP 或其他 orchestrator:

    1. 新增一個 LLM provider 指向 BTL-3
    2. 透過 llama.cpp server / LM Studio API 對接。

    3. 定義工具

    4. read_repo:讀指定路徑檔案並壓縮輸出。
    5. run_tests:執行 test 命令並回傳 stdout / stderr
    6. apply_patch:套用 diff 到 repo。

    7. 給 BTL-3 的 system prompt

    8. 明確告訴它有哪些工具、何時該使用、成功定義(例如「所有測試通過」)。

    行動建議:

    • 在你的 orchestrator 裡,把「所有涉及程式碼修改的任務」預設派給 BTL-3,其他任務仍用通用模型,實際對比整體完成品質與速度。

    BTL-3 的定位很清楚:不是要取代所有模型,而是成為你本地環境裡專門負責「寫程式 + 用工具」的那顆專家模型。如果你正在找一個接近本地版 Copilot / Claude Code 的選擇,它值得你花一個週末搭起來試用。

    🚀 你現在可以做的事

    • 到 Reddit 原帖下載 BTL-3 GGUF,並用 LM Studiollama.cpp 在本地先跑一輪測試
    • 選一個不能上雲的專案,讓 BTL-3 產生「系統總覽 + 改善清單」,試做一次 Patch workflow
    • 在你現有的 agent framework 中新增 coding-agent 路由,將程式與工具相關任務導向 BTL-3 並觀察效果
  • moonshine 實戰:10 行程式碼做語音代理

    moonshine 實戰:10 行程式碼做語音代理

    📌 本文重點

    • moonshine 是可本地部署的低延遲語音代理 C++ pipeline
    • 一條 pipeline 完成 STT、意圖辨識與 TTS
    • 適合客服熱線、語音面板與 IoT 離線語音控制
    • 可直接接上任意 REST API 打造專屬語音 agent

    只想做一個語音版 ChatGPT、客服機器人,卻不想被雲端 API 綁死、每月付帳單?moonshine 就是那套「自己裝在機器上、一次搞定語音輸入+理解+回覆」的 C++ pipeline。

    原始碼在 GitHub:https://github.com/moonshine-ai/moonshine


    核心功能:一條語音 pipeline,全都自己掌控

    moonshine 的定位很直接:

    Very low latency speech to text, intent recognition, and text to speech, for building voice agents and interfaces.

    你可以把它想成「本地版語音代理引擎」——不是雲端服務,而是一個可以編譯進你自己程式的 C++ library/工具。

    💡 關鍵: moonshine 把 STT、意圖辨識與 TTS 串成單一低延遲 pipeline,從輸入到輸出都在你自己的機器上完成。

    1. 語音輸入:低延遲 STT(Speech-to-Text)

    • 功能:把麥克風語音即時轉成文字,延遲低,適合對話場景。
    • 實際效果:跑在桌機或中高階單板機上,可以做到「你講一句,它同時開始辨識」的互動感。
    • 你可以立刻做的事:
    • 把它接到客服電話錄音,轉成文字後送到 FAQ 引擎。
    • 接到操作面板上,用語音替代滑鼠點選。

    2. 意圖辨識:Intent Recognition

    • 功能:從文字中判斷「使用者想做什麼」,例如:查訂單、開支援 ticket、關燈、查庫存。
    • moonshine 的做法:把語音轉文字後,丟進意圖模型(可換成你自己訓練的分類器/LLM)。
    • 你可以立刻做的事:
    • 自訂幾個意圖(如 查訂單問價格人工轉接),用簡單規則或模型判斷要打到哪個 API

    3. 語音輸出:TTS(Text-to-Speech)

    • 功能:把系統回覆文字轉成語音,直接播放給使用者。
    • 實際效果:完成一個「講話→理解→查資料→講回來」的完整迴路,不需要外接雲端 TTS
    • 你可以立刻做的事:
    • 做一個「語音 FAQ 機器人」,接電話後用 TTS 讀出答案。
    • 做桌面語音助理,說出系統通知或報表摘要。

    適合誰用:三種典型場景

    1. 客服/熱線:電話接起來就有語音機器人

    問題情境

    • 只想讓機器人先接電話、回答常見問題或先收集基本資料,但不想把所有通話丟到雲端 AI

    moonshine 的用法

    • 把語音輸入接到電話系統的音訊流(VoIPSIP 方案都可),用 STT 轉文字。
    • 用意圖辨識判斷是「查訂單」「問營業時間」「真人客服」。
    • 走不同後端 API,最後用 TTS 回覆。

    你可以立刻做的實驗

    • 先不接真正電話,用錄音檔或麥克風假裝客戶提問,串一個「FAQ 搜尋 API」,測試回答流程。

    2. 語音面板:替既有系統加一層「講話就能操作」

    問題情境

    • 你有一套 SaaS 或內部系統(CRMERP、工單系統),想讓使用者用「語音」查資料、下指令,但不想大改前端。

    moonshine 的用法

    • 在桌面 appweb 前端旁放一個小語音代理程式:
    • 監聽麥克風 → STT → 判斷意圖 → 呼叫既有 REST API → 整理結果 → TTS 講回來或貼在 UI

    你可以立刻做的實驗

    • 選一個已有的 REST API(例如:查客戶資訊),用下方「10 行程式碼」範例改成語音查詢。

    3. IoT/嵌入式:低資源設備上的離線語音控制

    問題情境

    • 想做離線語音控制:開關設備、切換模式,但硬體算力有限、網路不穩。

    moonshine 的用法

    • 把精簡版模型放在裝置上(例如 ARM 單板機),只做幾個固定意圖:
    • 「開燈」「關燈」「設定 25 度」等,直接對接硬體控制程式。

    💡 關鍵: 在 IoT 裝置離線情境下,moonshine 可只保留少數固定意圖,大幅降低對算力與網路的依賴。

    你可以立刻做的實驗

    • 在一台樹莓派或小型工控機上跑最簡 demo,先做「聽到關燈就印出 turn_off_light」的文字,再接上 GPIO 控制。

    怎麼開始:從 GitHub clone 到第一個語音 agent

    💡 關鍵:git clone 到可用 demo,大致只需一次編譯與模型下載,就能完整體驗整條語音 pipeline。

    1. 先把專案拉下來、編譯成功

    1. 安裝基本依賴(以 Ubuntu 為例):

    bash
    sudo apt update
    sudo apt install -y git cmake build-essential

    1. Clone 專案:

    bash
    git clone https://github.com/moonshine-ai/moonshine.git
    cd moonshine

    1. 編譯:

    bash
    mkdir build && cd build
    cmake ..
    make -j$(nproc)

    完成後,你會得到可以執行的示範程式(名稱以官方 repo 為準,一般會有 demoexample 可跑)。

    2. 跑最簡 demo:確認 STT / TTS pipeline

    官方 repo 一般會提供類似:

    ./moonshine_demo --input mic --output speaker
    

    典型流程會是:

    1. 啟動程式,指定輸入為麥克風、輸出為喇叭。
    2. 程式下載或載入預設 STTTTS 模型(通常第一次跑會需要網路)。
    3. 你講一句話,終端機顯示辨識出的文字,並用 TTS 回覆一句預設回答。

    具體參數以官方 README 為準,重點是:先確認你機器上的音訊裝置、模型下載都 OK

    3. 配置模型:STT / TTS / Intent 拆清楚

    在實際專案中,你要決定三件事:

    1. STT 模型
    2. 選語系(中文/英文等)和大小(依你設備算力)。
    3. moonshine 通常會支援多種 backend,可以在 config 檔或啟動參數指定。
    4. TTS 模型
    5. 選擇語音風格(男聲/女聲)和延遲表現。
    6. 在設定中指定 model path 或使用預設 URL 拉取。
    7. Intent 模型或規則
    8. 簡單做法:先用關鍵字+正則,把意圖分成幾類。
    9. 進階做法:接上本地 LLM(例如使用你現有的推論服務)做意圖分類。

    你可以建立一個簡單的 config.json

    {
      "stt_model": "models/stt_zh_small.bin",
      "tts_model": "models/tts_zh_small.bin",
      "intent_backend": "http://localhost:8000/intent"
    }
    

    程式啟動時讀取這個 config,就能自由替換模型和意圖服務。

    4. 10 行程式碼:把任何 REST API 包成語音代理

    以下用「C++ + moonshine + 一個任意 REST API」示意,把核心流程壓縮成約 10 行邏輯。實際使用時需依官方 API 做正確呼叫。

    #include "moonshine.h"      // 假設提供 STT / TTS 接口
    #include <httplib.h>         // 用任意 HTTP client
    
    int main() {
        MoonshineAgent agent{"config.json"};              // 載入 STT/TTS 設定
        httplib::Client api("https://api.yourservice.com");
    
        while (true) {
            std::string text = agent.listen();             // 1. 麥克風→文字
            auto res = api.Get("/search?query=" + text);  // 2. 呼叫任意 REST API
            std::string reply = res->body;                 // 3. 取回文字結果
            agent.speak(reply);                            // 4. TTS 語音回覆
        }
    }
    

    這個基本版就已經是一個「語音代理壓在你自己的後端」:

    • 你說話 → STT -> text
    • 丟到你預先寫好的 API(可以是 FAQ 搜尋、工單建立、資料查詢)
    • 回傳文字 → 用 TTS 說回來

    你可以改幾行,就變成不同場景:

    • 客服熱線:把 text 先送進意圖辨識 API,再決定要打哪一個後端。
    • 語音面板:把 reply 不是用 TTS,而是顯示在 UITTS 只讀重點。
    • IoT 控制:把 api.Get(...) 換成控制硬體的函式,例如 set_light(false)

    小結:想自己掌控語音代理,就先把 moonshine 跑起來

    如果你:

    • 不想被雲端 STTTTS 綁約
    • 想在桌面 app、行動裝置或後端服務內嵌語音代理

    那 moonshine 提供的就是一個單純、可編譯進你程式的 C++ 語音 pipeline。從 GitHub clone 下來,先跑官方 demo,再按照上面範例把你的 REST API 接上去,你就能在一台機器上完成第一個「可用的語音 agent」。

    🚀 你現在可以做的事

    • 前往 moonshine GitHub 專案 clone 並完成一次編譯與官方 demo 執行
    • 寫一個簡單的 config.json,指定本地 STTTTS 模型與一個測試用意圖服務 endpoint
    • 按照文中「10 行程式碼」範例,挑一個現有 REST API,實作一個可對答的語音查詢小工具
  • 用 Whisper+Ollama 做一個本地語音助理

    用 Whisper+Ollama 做一個本地語音助理

    📌 本文重點

    • 用 Whisper+Ollama 做完全本地語音助理
    • 語音→文字→LLM→語音的完整閉環
    • 30 分鐘內跑起最小可行版本
    • 資料與聲音全留在自己機器上

    一句話就能叫得動電腦,而你的聲音和資料完全留在自己機器上,這就是用 Whisper+Ollama 做本地語音助理要解決的問題。

    參考原文:Build a Fully Local Voice Assistant With Whisper and Ollama(Towards AI)
    https://pub.towardsai.net/build-a-fully-local-voice-assistant-with-whisper-and-ollama-e5e6f713a220


    核心架構:一句話進,AI 一句話回

    這個本地語音助理由三塊組成:

    1. Whisper:把「語音 → 文字」(Speech-to-Text)
    2. Ollama + 本地 LLM:負責理解與生成文字回應
    3. 任一 TTS(Text-to-Speech):把「文字 → 語音」再念出來

    整體流程:

    1. 按快捷鍵開始錄音
    2. Whisper 辨識成文字指令
    3. 文字送到本地 LLM(透過 Ollama)推理
    4. 回傳文字答案,再由 TTS 念出

    💡 關鍵: Whisper+Ollama+TTS 組成「完全本地、無需雲端」的語音互動閉環。

    下文會先講三個核心功能,再看哪些人適合用,最後給一個可以在 30 分鐘內跑起來的最小範例。


    核心功能:你可以用聲音做什麼

    1. 聲控指令:一句話叫電腦做事

    你可以用自然語言下達指令,背後由 LLM 把「人話」轉成實際操作(shell 指令、API 呼叫或執行特定程式)。

    可做的事例如:

    • 「幫我開啟 VS Code 並打開 project 資料夾」
    • 「開始錄音會議,結束時幫我整理重點」
    • 「幫我查今天的天氣,再念給我聽」

    實作上,你可以:

    • 在 LLM 回應中約定一個格式,例如輸出 {"action": "open_app", "target": "VSCode"}
    • 程式解析 JSON,對應到不同的系統操作(Python 用 subprocess、Node 用 child_process

    2. 問答與解說:本地 ChatGPT,用嘴巴問

    Ollama 支援多種本地模型(如 LlamaQwen),你可以當成「只在本地跑的 ChatGPT」:

    • 「用白話講一次這段程式在做什麼」
    • 「幫我設計一個 3 天東京行程,預算一天 5000 台幣」
    • 「這篇英文信幫我改寫得更禮貌」

    如果你在意隱私(公司機密、未發表研究),這類內容只會停留在你的機器,不會上雲端。

    💡 關鍵: 對隱私敏感的程式碼、文件與會議內容,都可以在本地模型中處理而不外流。

    3. 筆記與總結:會議錄完直接變摘要

    結合 Whisper 長錄音能力,你可以:

    • 開會時一直錄音,會後自動產出:
    • 決議事項
    • 待辦清單
    • 各參與者的責任分工
    • 學習影片邊聽邊錄,最後生成「重點整理 + 閱讀筆記」

    做法:

    1. 持續錄音,分段送 Whisper 辨識
    2. 把完整文字餵給 LLM,提示詞(prompt)中要求輸出特定格式:例如「請用 5 點整理會議重點,並列出行動項目」

    適合誰用:具體場景示例

    1. 常開線上會議的知識工作者

    使用方式:

    • 開會前按快捷鍵啟動錄音
    • 會議中不必手寫紀錄
    • 開完會輸出「摘要+待辦」,貼回 Notion / Obsidian

    好處:

    • 不用依賴雲端錄音服務
    • 內部機密內容留在公司內網或個人電腦

    2. 開發者的語音 Coding 小助手

    使用方式:

    • 「幫我生成一個 Python 函數,讀取 CSV 並輸出 JSON」
    • 「這段錯誤訊息說什麼?幫我猜可能原因」
    • 「把這段程式重構成 class 寫法」

    你可以直接把 LLM 回應輸出到檔案,或搭配編輯器 API 完成簡單的自動插入。

    3. 家庭中控 / 桌面自動化

    使用方式:

    • 「關掉 Spotify,改播 YouTube 音樂」
    • 「打開家裡 NAS 的網頁介面」
    • 「查一下電價 API,現在是不是離峰」

    背後是:

    • LLM 產生要呼叫的 API 名稱 + 參數
    • 程式把它映射到實際的 REST API or Shell 指令

    工具比較:Whisper、Ollama、TTS

    名稱 核心功能 免費方案 適合誰
    Whisper 語音轉文字(STT) 開源、免費 要離線語音辨識的人
    Ollama 管理與執行本地 LLM 開源、免費 想在本地跑各種模型的人
    Coqui TTS 本地語音合成(TTS) 開源、免費 想客製化聲音的開發者
    pyttsx3 / edge-tts 簡單 TTS,快速上手 免費 只要能聽到回應即可的人

    Whisper GitHub:https://github.com/openai/whisper
    Ollama 官網:https://ollama.com


    怎麼開始:30 分鐘跑起一個最小版本

    下面以 Python+Whisper+Ollama+簡單 TTS 為例,目標是做到:

    按快捷鍵 → 說話 → AI 在本地回答並念出來

    💡 關鍵: 只要有 8GB RAM 和 Python 環境,大多數電腦在約 30 分鐘內就能完成這套本地語音助理的基本版。

    1. 最小硬體與環境需求

    • 作業系統:macOS / Linux / Windows(建議 10 以上)
    • RAM:至少 8 GB(12–16 GB 更順)
    • GPU:有當然更快,沒有也可跑小模型
    • Python 3.10+(或 Node 也可以,本文用 Python)

    2. 安裝 Ollama 與模型

    1. 到 https://ollama.com 下載並安裝
    2. 開啟終端機,拉一個小模型(例如 llama3.2qwen2.5):
    ollama pull llama3.2
    # 或
    ollama pull qwen2.5
    
    1. 測試一次:
    ollama run llama3.2
    

    能對話就表示後面 Python 可以直接透過 HTTP 使用它。

    3. 安裝 Whisper 與 TTS

    建立虛擬環境(可選,但建議):

    python -m venv venv
    source venv/bin/activate  # Windows: venv\Scripts\activate
    

    安裝必要套件:

    pip install openai-whisper sounddevice numpy requests pyttsx3
    

    說明:

    • openai-whisper:Whisper STT
    • sounddevice:錄音
    • pyttsx3:離線 TTS(Windows/macOS/Linux 都可用)
    • requests:呼叫 Ollama HTTP API

    4. 最小可行 main.py

    下面是一個簡化範例:按 Enter 開始錄音,Ctrl+C 結束程式。你可以之後再綁定系統快捷鍵(如 AutoHotkey、Karabiner)。

    import sounddevice as sd
    import numpy as np
    import whisper
    import requests
    import pyttsx3
    
    MODEL_NAME = "llama3.2"  # 或改成 "qwen2.5" 等你已拉下的模型
    OLLAMA_URL = "http://localhost:11434/api/generate"
    
    whisper_model = whisper.load_model("small")  # 可換 tiny / base / small / medium
    engine = pyttsx3.init()
    
    SAMPLE_RATE = 16000
    DURATION = 5  # 錄音秒數,可改成你想要的
    
    
    def record_audio(duration=DURATION):
        print("開始錄音,請說話...")
        audio = sd.rec(int(duration * SAMPLE_RATE), samplerate=SAMPLE_RATE, channels=1)
        sd.wait()
        print("錄音結束")
        return np.squeeze(audio)
    
    
    def speech_to_text(audio):
        print("正在轉文字...")
        result = whisper_model.transcribe(audio, fp16=False)
        text = result["text"].strip()
        print(f"你說:{text}")
        return text
    
    
    def call_ollama(prompt):
        print("正在思考...")
        resp = requests.post(
            OLLAMA_URL,
            json={"model": MODEL_NAME, "prompt": prompt},
            stream=False,
        )
        data = resp.json()
        answer = data.get("response", "")
        print(f"AI:{answer}")
        return answer
    
    
    def speak(text):
        engine.say(text)
        engine.runAndWait()
    
    
    if __name__ == "__main__":
        try:
            while True:
                input("按 Enter 開始錄音(Ctrl+C 結束):")
                audio = record_audio()
                text = speech_to_text(audio)
                if not text:
                    continue
                answer = call_ollama(text)
                speak(answer)
        except KeyboardInterrupt:
            print("\n結束程式")
    

    執行:

    python main.py
    

    流程:

    1. 按 Enter → 錄音 5 秒
    2. Whisper 轉文字 → 顯示你說的話
    3. 文字送到 Ollama → LLM 回答
    4. pyttsx3 把文字念出來

    你已經完成一個基本版「本地語音 ChatGPT」。接下來就可以:

    • 把錄音時間改成動態(按住鍵才錄)
    • call_ollama 的 prompt 中加入系統指令,例如:「你是一個會輸出 JSON 指令的系統助手」
    • answer 中解析 JSON,呼叫不同的系統功能

    換成本地 Qwen、Llama 模型與低配機調整建議

    換模型:Qwen、Llama 等

    Ollama 已經預設支援多個模型,換模型只要:

    1. 先拉模型:
    ollama pull qwen2.5
    ollama pull llama3.1
    
    1. MODEL_NAME 改成相對應名稱,例如:
    MODEL_NAME = "qwen2.5"
    # 或
    MODEL_NAME = "llama3.1"
    
    1. 重新執行 main.py 即可。

    低配機(8GB RAM / 無 GPU)調優建議

    • Whisper 模型:改用 tinybase
      python
      whisper_model = whisper.load_model("tiny")
    • LLM 模型:優先選擇 *-mini 或 3B 以內的小模型(例如 llama3.2 small 版)
    • TTS:選 pyttsx3 這種輕量離線 TTS,避免重型神經網路 TTS
    • 錄音長度:縮短單次錄音(例如 3–5 秒),減少 STT 負載
    • 批次模式:需要長會議紀錄時,可先用系統錄音軟體錄整段,之後分段丟給 Whisper 處理

    總結:把「叫電腦做事」變成一句話

    你現在已經有一套可以在本地跑的語音助理:

    • Whisper 負責聽懂你說什麼
    • Ollama+本地模型負責思考與生成回應
    • TTS 負責把答案念出來

    從這個最小版本開始,你可以一步步加上:「控制應用程式」、「呼叫 API」、「自動整理會議紀錄」,最後變成一個完全客製化的本地語音中控系統。

    🚀 你現在可以做的事

    • 安裝 Ollama 並拉下 llama3.2qwen2.5 模型,在終端測試對話
    • 建立 Python 虛擬環境,安裝 openai-whispersounddevicepyttsx3 等套件後跑起 main.py
    • 改寫 call_ollama 部分,讓回應輸出 JSON 指令,開始用語音控制你的桌面或 API
  • 用 AVA 自架語音總機

    用 AVA 自架語音總機

    📌 本文重點

    • AVA 可直接接在既有 Asterisk/FreePBX 上
    • 先用雲端 STT/LLM/TTS 做 PoC 再考慮本地化
    • 適合中小企業與研發團隊快速測試語音 AI 總機

    AVA 是一套能接在 Asterisk/FreePBX 上的開源語音客服引擎,讓你不用買 SaaS,也能自己搭一個會接電話、回答問題、轉分機的 AI 總機。

    想先看專案,可直接開 AVA GitHub。如果你手上已經有 FreePBX,這類型工具最實際的價值不是「聊天」,而是把既有電話流量接進 STT、LLM、TTS 流程,先做出可測的 PoC,再決定要不要擴到正式客服。


    核心功能

    1. 直接接進 Asterisk,不用重做整套電話系統

    AVA 的架構很直白:Asterisk 用原生 AudiosocketRTP 收到來電,把音訊送到 Python 引擎;Python 再依序呼叫語音轉文字(STT)、大型語言模型(LLM)、文字轉語音(TTS),最後把回覆送回通話。

    這代表你可以保留現有 SIP、分機、IVR 與 FreePBX 管理介面,只替換「講話的那一段」。

    2. 雲端模型先上線,本地模型後續再換

    AVA 內建支援 OpenAIGeminiGrokElevenLabs,也能自訂 STTLLMTTS 組合。最快的做法是先用雲端 API 跑第一版,例如 OpenAISTT+LLMElevenLabsTTS;如果後續遇到隱私或成本問題,再改成本地模型。

    💡 關鍵: 先用雲端組合上線 PoC,再視隱私與成本需求改成本地模型,是風險最低的導入路徑。

    官方也提到,若有 25GB 以上 GPU,可走全本地即時語音代理。

    3. 適合做可控腳本,不只自由聊天

    電話客服的重點不是模型多聰明,而是流程穩不穩。AVA 適合把提示詞、FAQ、分機規則、營業時間、留言流程都寫成明確腳本,例如:

    • 「辨識來意後轉接 201 業務部」
    • 「下班時間改成留言並發通知」

    先把流程規則化,測試會比直接放任模型自由發揮穩很多。


    適合誰用

    如果你是中小企業 ITSI、通訊整合商,手上已有 Asterisk 或 FreePBX,AVA 很適合拿來做低成本 PoC:一台伺服器、一組 API key、幾個分機規則,就能讓公司總機先有基本問答與轉接能力。

    💡 關鍵: 利用現有 Asterisk/FreePBX,只要加一台伺服器與一組 API key,就能快速驗證語音 AI 總機可行性。

    如果你是實驗室或研發團隊,AVA 的價值在於可替換性。你可以先用雲端模型驗證流程,再逐步把 STTLLMTTS 換成本地推論,測試隱私保護、工具呼叫、資料落地等需求。

    這比直接綁定單一 SaaS 平台更容易控制。

    下面這組搭配最適合先做測試:

    名稱 核心功能 免費方案 適合誰
    AVA 串接 Asterisk 的語音代理框架 開源免費 要自架語音客服的人
    OpenAI / Gemini / Grok STT、LLM 問答 多數為試用額度或按量計費 想最快上線 PoC 的團隊
    ElevenLabs 高品質英文與多語 TTS 有試用額度 重視語音自然度的客服場景

    怎麼開始

    最快路徑是用 Docker 把 AVA 部署在一台 Linux 伺服器,並接到現有 FreePBX。實作上可照這個順序做:

    1. 準備一台可連到 Asterisk 的伺服器,先安裝 Docker
    2. AVA GitHub 依範例啟動容器,填入 OpenAIGeminiElevenLabsAPI key
    3. 在 FreePBX 建一個測試路由,讓指定 DID 或分機把來電導到 AudiosocketRTP 對應的 AVA 服務。
    4. 先只做一個簡單腳本:自我介紹、詢問需求、依關鍵字轉接分機或播放 FAQ
    5. 拿真實電話測試 2030 通,記錄辨識錯誤、等待時間與轉接成功率,再調提示詞。

    💡 關鍵: 先用 20–30 通真實來電測試腳本與提示詞,比盲目擴大量更能看出系統穩定度與實用性。

    你可以先做兩個最有感的場景。

    第一個是公司語音 IVR:例如「按 1 找業務」改成自然語音,來電者直接說「我要報價」就轉接業務分機,同時能回答地址、營業時間、付款方式。

    第二個是 24 小時留言與簡單 FAQ:下班後由 AI 先接聽,回答常見問題,必要時收姓名、電話、需求摘要,再寄送到信箱或寫入工單。


    成本與進階玩法

    PoC 階段最主要的成本是語音與模型 API,用量低時通常比買整套 SaaS 便宜,尤其你已經有 Asterisk 時更明顯;但一旦通話量大,TTS 與即時 LLM 成本會開始浮現,所以建議先限制場景,只做總機問答、留言與分流。

    如果你有隱私要求,下一步就是把部分流程換成本地模型:例如本地 STT、本地 LLM,只把 TTS 留在雲端,或直接全本地化。

    另一個值得做的進階項目是客製對話腳本,把「業務、客服、總務」拆成不同代理,分別設定提示詞、FAQ 和轉接規則,測試效果會比單一通用客服更好。

    對已經有電話系統的團隊來說,AVA 最實際的切入點不是一次取代客服,而是先把一條來電流程自動化,讓你用自己的基礎設施,快速驗證語音 AI 到底能不能真正接電話。

    🚀 你現在可以做的事

    • 打開 AVA GitHub 專案頁,閱讀 README 並確認環境需求
    • 在現有 FreePBX 上規劃一條測試路由,準備 1 個具代表性的來電場景腳本
    • 申請 OpenAIGeminiElevenLabs 的 API key,實作一個 20–30 通的 PoC 測試流程
  • 在手機跑 27B 模型:Bonsai 27B 實戰上手

    在手機跑 27B 模型:Bonsai 27B 實戰上手

    📌 本文重點

    • 27B 模型壓到 3.8GB
    • 本地跑在 iPhone 與瀏覽器
    • 數學與程式推理仍可用
    • 適合隱私優先的 AI 場景

    用一句話說完:Bonsai 27B 讓一個原本要 50GB 以上的大型推理模型,縮到不到 4GB,在你的 iPhone 或瀏覽器裡本地跑推理。

    原始資訊與 Demo:


    核心功能:為什麼 1-bit4GBWebGPU 很關鍵?

    1. 1-bit dense 量化:54GB 壓到 3.8GB,還保留 90% 能力

    Bonsai 27B 原始是 27B 參數的大模型,正常 fp16 大概要 50GB 以上。PrismML 用自家的 1-bit dense 量化,直接把模型縮到約 3.8GB-93%,官方與社群測試顯示:

    • 整體表現:約保留 90% 原始性能
    • 在數學與程式碼推理上的分數,幾乎不受影響

    💡 關鍵: 27B 級模型從 50GB+ 壓到 3.8GB,代表大型模型首次更接近一般裝置可本地部署的範圍。

    這對你代表什麼?

    • 一般高階筆電、桌機的 GPUWebGPU 就能跑 27B 級模型
    • iPhone 等手機只要有足夠 RAM,也能載得下整個模型
    • 做產品 PoC 時,不用再想「我要租幾張雲端 GPU」才能展示效果

    你可以立刻做的事:

    2. 本機 / 手機 / 瀏覽器推理:速度與隱私的平衡點

    Bonsai 27B 的壓縮搭配 WebGPU + 客製 Kernel,讓它可以在:

    • 桌機瀏覽器(ChromeEdgeArc 等支援 WebGPU 的版本)直接跑
    • iPhone 上透過支援 WebGPU 的瀏覽器或 App 跑本地推理

    實際體感: 依硬體而異,但大致區間如下:

    • 答案生成速度:中高階筆電可達 20~40 tokens/s,接近雲端中階模型
    • 手機上:會慢一些,但仍能用於聊天、寫作輔助、簡易程式碼推理

    💡 關鍵: 本地推理不只是能跑,速度已進到可互動使用的區間,隱私與延遲也因此開始有實際優勢。

    隱私優勢:

    • 所有輸入(聊天內容、筆記、程式碼)都留在裝置上,不經過雲端 API
    • 適合公司內部敏感資料、個人私密日記、會議記錄摘要等情境

    你可以立刻做的事:

    • 打開支援 WebGPU 的瀏覽器,跑官方 Demo:確認你的硬體大概能跑到什麼速度(Demo 入口通常在 PrismML 新聞頁或 Hugging Face Space)。

    3. 數學與程式碼推理表現:不只是「能跑」,而是「能用」

    依據 PrismML 自家基準測試(見 Reddit 討論:https://www.reddit.com/r/LocalLLaMA/comments/1uwm2hd/prismmls_bonsai27b_benchmarks/),Bonsai 27B 的量化版本:

    • 在數學、程式碼題目上的分數,與原始模型接近
    • 部分測試甚至優於廣為討論的 Qwen 3.7 27B 量化版本

    💡 關鍵: 有趣的是,這類極端壓縮不一定先犧牲數學與程式碼推理,實際上它在這兩類任務仍維持可用水準。

    實際體感上,它適合:

    • LeetCode 等級的題目、協助理解他人程式碼
    • 做數學證明草稿、檢查推理步驟是否有漏洞

    你可以立刻做的事:

    • 準備一段你自己寫的程式碼或演算法題目,在 Demo 裡測試它的 debug 能力,看它能不能說出具體修改建議。

    適合誰用?具體場景與做法

    1. 個人使用:離線寫作、私密筆記與聊天

    場景:

    • 不想把日記、心理對話丟到雲端模型
    • 在飛機、車上等無網路環境寫作

    可以怎麼用:

    • 在桌機瀏覽器開 Bonsai 27B WebGPU Demo,寫文章時讓它幫你改標題、想小節架構
    • 在支援的手機上安裝對應 App 或透過瀏覽器,做離線聊天與筆記整理

    2. 開發者:簡易 coding 助手與邊緣 AI PoC

    場景:

    • 做一個「本地程式碼助手」Side project
    • 想給客戶看「產品內嵌 on-device 聊天/推理」的原型

    可以怎麼用:

    • 使用 Bonsai 27Bgguf 版本,搭配像 llama.cpp 或其他本地推理框架,在筆電上跑一個命令列助手
    • Web 前端整合官方 WebGPU 推理程式碼,做一個「瀏覽器內跑的大模型聊天框」,無需後端 GPU

    3. 產品團隊:在 App 裡塞 on-device 聊天 / 推理

    場景:

    • 筆記 App 想加「在本機摘要筆記」功能
    • 知識庫產品想做「邊緣 FAQ 助手」,部署在客戶內網而不是雲端

    可以怎麼用:

    • WebGPUBonsai 27B 做前端推理引擎,後端只處理權限與資料存取
    • iOS App 裡預載或動態下載壓縮模型,讓使用者自主選擇是否開啟「完全本地 AI 模式」

    什麼時候考慮不用它?

    • 若你需要 GPT-4 級別的長上下文寫作、極高準確度的工具調用
    • 若手機使用者硬體普遍較舊,無法提供足夠 RAMWebGPU 支援

    怎麼開始:從 WebGPU DemoiPhone 實跑

    Step 1:在桌機用 WebGPU Demo 跑起來

    1. 確認瀏覽器支援 WebGPU
    2. Chrome / Edge:版本需在 113+,建議更新到最新穩定版
    3. chrome://flags 搜尋 WebGPU,確保已啟用(某些平台預設已開)

    4. 進入 Demo 網頁

    5. PrismML 新聞頁:https://prismml.com/news/bonsai-27b 找到 WebGPU Demo 連結
    6. 或在 Hugging Face 上搜尋 Bonsai 27B WebGPU 找到 Space

    7. 測試推理

    8. 選擇 Bonsai-27B 1-bit 模型版本
    9. 輸入一個你熟悉的程式題目或寫作題目,觀察回答速度與品質

    常見坑:若載入卡住或速度極慢,通常是 WebGPU 未啟用,或顯示卡太舊。換瀏覽器或更新驅動是第一步。

    Step 2:在 iPhone 嘗試跑 Bonsai 27B

    目前 iPhone 端的整合仍在快速變動階段,Apple 也被報導正在測試 PrismML 技術(參考:https://www.reddit.com/r/LocalLLaMA/comments/1ux4cn2/apple_in_talks_with_startup_prismml_that_shrinks/)。以下是一般建議路線:

    1. 確認機型與系統
    2. 建議使用 A17 / M 系列晶片的機型,RAM 越大越好(Pro 機型優先)
    3. iOS 更新到最新版本,以取得最佳 WebGPU / Metal 支援

    4. 嘗試透過瀏覽器 Demo

    5. 使用支援 WebGPUiOS 瀏覽器(未來 Safari 正式支援後會更穩定)
    6. 開啟 Bonsai 27B Web Demo,選最低階參數設定,測試生成速度

    7. 留意記憶體與耗電

    8. 模型雖然不到 4GB,但推理仍會吃 RAM;建議在單一 App 裡跑,不要開太多背景程式
    9. 長時間推理會發熱,適合短對話與輕量寫作,而非長時間批量任務

    常見坑:

    • 推理中 AppiOS 回收:代表 RAM 不足,只能調小 context 長度或改用桌機。
    • 首次載入模型時間偏長:正常現象,可考慮在 App 中做「背景預載」。

    Step 3:整合到你的應用(基本架構示意)

    Web 應用為例,一般做法是:

    使用者瀏覽器
     ├─ UI:聊天框 / 筆記編輯器
     ├─ WebGPU 推理:載入 Bonsai 27B 壓縮模型
     └─ 本地記憶體:暫存對話與提示
    
    後端伺服器
     ├─ 使用者認證 & 權限
     ├─ 資料索引(向量庫、文檔)
     └─ 僅在用戶同意時返回資料,讓前端本地推理
    

    你可以:

    • 直接參考 PrismML 提供的 WebGPU Kernel 實作,把它包成一個 JS/TS SDK
    • 將模型檔放在 CDN,首次使用時下載到瀏覽器 IndexedDBApp 沙盒中

    本地 Bonsai 27B vs 雲端 API:成本與隱私快速比較

    項目 Bonsai 27B 本地推理 雲端 API(如 GPT-4)
    成本 一次下載模型,之後幾乎零邊際成本,主要是硬體耗電 tokens 計費,流量大時費用顯著
    延遲 裝置好時可達 20–40 tokens/s,無網路也能用 需經網路與伺服器排隊,遇高峰時延遲高
    隱私 所有內容留在本機,適合敏感資料 對話上傳到雲端,需信任供應商
    維護 需自己管理模型更新與相容性 供應商幫你維持最新模型與基礎設施

    簡單判斷:

    • 若你重視隱私、成本可控、願意接受略低於頂級雲端模型的效果,Bonsai 27B 是合適的本地方案。
    • 若你的產品主打極高準確度、長上下文、工具調用整合,仍需要雲端 API 作為主力,Bonsai 27B 可做輔助或離線備份模式。

    小結:下一步你可以做什麼?

    1. 用桌機開 Bonsai 27B WebGPU Demo,測試寫作與程式碼題目,感受性能。
    2. 若你是開發者,下載 Hugging Face 量化模型,在本地框架中跑一個簡單聊天助手。
    3. 思考你的產品裡哪個功能最需要「本地推理+隱私」,從那一點開始嘗試嵌入 Bonsai 27B

    🚀 你現在可以做的事

    • 打開 PrismML 官方新聞頁,直接進 WebGPU Demo 測你的裝置速度
    • Hugging Face 搜尋 prism-ml/Bonsai-27B-gguf,下載量化模型做本地測試
    • 拿一段你自己的程式碼、筆記或寫作題目,驗證它是否符合你的實際場景
  • OvisOCR2:在筆電本地跑的文件結構化神器

    OvisOCR2:在筆電本地跑的文件結構化神器

    📌 本文重點

    • OvisOCR2 在本地將整份 PDF 直接轉成結構化 Markdown
    • 對表格、公式與讀取順序有針對性優化
    • 適合內網文件、學術論文與財報合約結構化
    • 0.8B 模型可在筆電或小伺服器上順跑

    OvisOCR2 的定位很單純:在你自己電腦上,把整份 PDF / 掃描件直接變成乾淨、有結構的 Markdown,不丟雲端、不拆頁、不東拼西湊。

    模型頁面:https://huggingface.co/ATH-MaaS/OvisOCR2

    Reddit 討論串:https://www.reddit.com/r/LocalLLaMA/comments/1uv88co/ovisocr2_a_promising_08b_local_document_parser/


    核心功能:從「整頁」到「可用的 Markdown」

    這邊只看跟你工作直接有關的 3 件事:

    1. 端到端整頁解析:丟 PDF / 圖片,直接出 Markdown

    OvisOCR2 是基於 Qwen3.5-0.8B端到端文件解析模型,不是傳統那種「先做 OCR 再用別的模型理解」的兩段式流程。

    它的輸出直接是 Markdown,包含:

    • 標題、段落層級(### 等)
    • 粗體、斜體等基本格式
    • 清單、引用等常見排版

    你可以馬上做的事:

    • 把公司內部的 PDF 手冊、SOP 丟進去,拿到 可編輯的 Markdown,再丟進 Notion、Confluence 或 Git repo 管理
    • 把舊專案的掃描說明書轉成文字,方便全文搜尋

    模型在常見文件基準上表現:

    • OmniDocBench v1.6:96.58 分
    • PureDocBench:75.06 分

    💡 關鍵: 在標準文件基準上拿到 90+ 分,代表它對一般報表與說明文件的結構理解已足夠直接納入實際工作流程測試。

    這代表它對一般報表、說明文件的結構理解已經有相當水準,適合直接放進工作流程測試。

    2. 表格、公式還原:不只讀得懂,還能「還原格式」

    OvisOCR2 的重點不是只認出字,而是把表格和公式變回「可運算」的東西

    • 表格 → Markdown 表格(| a | b | 那種),貼到 Notion、GitHub README 都能正常顯示
    • 公式 → 以 LaTeX 或接近格式輸出,方便貼回論文、簡報或 Obsidian

    你可以馬上做的事:

    • 把財報 PDF 轉成 Markdown,表格直接貼到 Excel / Google Sheets 做後續處理
    • 把學術論文中的公式拉出來,貼回 LaTeX 文件或投影片,不用一條條重打

    3. 讀取順序:不再被兩欄排版搞瘋

    很多 PDF(尤其是:財報、學術期刊、政府報告)都有這些特徵:

    • 雙欄排版
    • 頁首頁尾反覆出現的小字
    • 複雜圖文混排

    傳統 OCR 常會變成:

    • 把左欄整段讀完,再接右欄,導致段落亂序
    • 頁碼、版權資訊被插進正文裡

    OvisOCR2 針對「讀取順序」有訓練,能比較好地還原成人類閱讀的順序,包括:

    • 正文優先,頁碼/頁眉多半排除或放在不干擾的位置
    • 圖表標題和內容靠在一起,不會被打散

    你可以馬上做的事:

    • 把年度報告、研究報告丟進去,得到可以直接丟給大語言模型總結的乾淨 Markdown
    • 省掉「先用 Acrobat 導出文字再手動整理」的痛苦步驟

    適合誰用:三種典型場景

    1. 公司內網文件數位化:需要「不出內網」的方案

    如果你在這些情境:

    • 金融、醫療、政府等對資料敏感的產業
    • 有一堆 PDF 合約、掃描件、紙本表單
    • 不允許把文件丟到雲端 OCR 服務

    OvisOCR2 很適合當成內網文件結構化引擎

    • 0.8B 模型,記憶體需求相對溫和,可以放在:
    • 中小型伺服器
    • 部門共用工作站
    • Apache 2.0 授權,方便整合到自家系統

    可以實做的具體流程:

    1. 把部門的 PDF 檔放進內網檔案伺服器
    2. 用 OvisOCR2 解析成 Markdown / JSON
    3. 把結果丟進 ElasticSearch / OpenSearch / Meilisearch 做全文搜尋
    4. 再接一個內網 LLM(例如本地 QwenLlama)做問答

    2. 學術論文整理:從 PDF 到筆記庫

    研究生、工程師、PM 常見的需求:

    • 一次下載一堆 PDF 論文
    • 想要在 Obsidian / Notion / Logseq 裡統一管理

    OvisOCR2 可以幫你:

    • 把論文的標題、章節、公式、圖表說明整合成 Markdown
    • 保留結構(例如 # Abstract## Method),方便之後全文搜尋或做自動總結

    可以實做的工作流:

    1. 建一個 papers/ 資料夾放 PDF
    2. 寫一個小腳本,用 OvisOCR2 把每篇論文轉成 .md
    3. 輸出時附上原始 PDF 路徑、bibtex key 等 metadata
    4. 直接把 .md 丟進 Obsidian 資料庫

    3. 財報與合約結構化:先結構化,再丟給 LLM

    財務、法務、投研人員常做的事:

    • 從財報裡抓關鍵表格
    • 從合約裡抓特定條款(付款條件、違約金…)

    OvisOCR2 可以先把內容整理成清楚的 Markdown / 結構化文本,接著:

    • 用本地或雲端 LLM 做:
    • 指標彙總
    • 條款比較
    • 風險條款標記

    這樣的好處是:

    • 原始 PDF 不用離開你的環境
    • 只有經過清理的文字,才會送到雲端 LLM(如果你選擇這樣做)

    為什麼 0.8B 模型適合在筆電或小伺服器上跑?

    0.8B(8 億)參數的級別,落在一個很實用的區間。

    • 硬體需求友善
    • 8–12GB VRAM 的顯示卡即可順跑
    • 或者用 CPU 推理,速度會慢一些,但足夠跑批次任務
    • 記憶體壓力較低
    • 不需要 80GB A100 等級的 GPU
    • 適合中小企業和個人開發者

    💡 關鍵: 0.8B 等級模型在 8–12GB 顯示卡上即可運行,讓「整份文件結構化」這種原本需要大型服務的工作,可以在一般筆電或中小企業伺服器內網完成。

    這個大小對「文件結構化」剛好夠用:

    • 任務相對專一(解析版面與內容)
    • 不需要像聊天大模型那樣超強的開放式生成能力

    如果你已經有一台:

    • RTX 3060 / 4060 級別的筆電
    • 或一台 16–32GB RAM 的小伺服器

    基本上都可以實際跑起來做實驗。


    怎麼開始:從 Hugging Face 到「丟 PDF 拿 Markdown」

    下面給一條最短路徑:不談訓練,只談拿來用。

    步驟 0:你需要準備什麼?

    • 作業系統:Linux / macOS / Windows 都可
    • Python 3.10+(盡量用虛擬環境)
    • 建議有 GPU(但非必須)

    步驟 1:下載模型

    到 Hugging Face 模型頁:

    做兩件事:

    1. 登入 Hugging Face 帳號(免費)
    2. 在本機安裝 huggingface_hub 方便下載:
    ypip install "huggingface_hub[cli]" transformers accelerate
    huggingface-cli download ATH-MaaS/OvisOCR2 --local-dir ./OvisOCR2
    

    如果你不想預先下載,也可以在程式裡直接用模型名稱自動拉取。

    步驟 2:用 vLLM 跑起 OvisOCR2(建議)

    OvisOCR2 支援 vLLM,適合要做批次處理或服務化部署的情境。

    先安裝 vLLM

    ypip install vllm
    

    啟動一個本地 server(假設你有支援 CUDA 的 GPU):

    python -m vllm.entrypoints.openai.api_server \
      --model ATH-MaaS/OvisOCR2 \
      --port 8000
    

    啟動後,你就有一個 OpenAI 相容 API,可以從任何語言呼叫。

    步驟 3:寫一個「丟 PDF → 拿 Markdown」的小腳本

    以下示範用 Python,把單頁 PDF 先轉成圖片,再送進 OvisOCR2,拿回 Markdown:

    提醒:實務上多頁 PDF 要迭代處理,每頁送一次,最後把 Markdown 串起來。

    安裝必要套件:

    ypip install pillow pypdfium2 requests
    

    簡易腳本(假設 vLLM server 在 http://localhost:8000):

    import base64
    import io
    import requests
    from PIL import Image
    import pypdfium2 as pdfium
    
    OPENAI_API_BASE = "http://localhost:8000/v1"
    OPENAI_MODEL = "ATH-MaaS/OvisOCR2"
    
    
    def pdf_page_to_image(pdf_path, page_index=0):
        pdf = pdfium.PdfDocument(pdf_path)
        page = pdf.get_page(page_index)
        pil_image = page.render(scale=2).to_pil()
        return pil_image
    
    
    def image_to_base64(image: Image.Image) -> str:
        buf = io.BytesIO()
        image.save(buf, format="PNG")
        return base64.b64encode(buf.getvalue()).decode("utf-8")
    
    
    def ovisocr2_parse_image(img: Image.Image) -> str:
        img_b64 = image_to_base64(img)
        payload = {
            "model": OPENAI_MODEL,
            "messages": [
                {
                    "role": "user",
                    "content": [
                        {"type": "text", "text": "Parse this page to Markdown."},
                        {
                            "type": "image_url",
                            "image_url": {"url": f"data:image/png;base64,{img_b64}"},
                        },
                    ],
                }
            ],
        }
    
        resp = requests.post(f"{OPENAI_API_BASE}/chat/completions", json=payload)
        resp.raise_for_status()
        return resp.json()["choices"][0]["message"]["content"]
    
    
    if __name__ == "__main__":
        pdf_path = "sample.pdf"  # 換成你的 PDF 路徑
        img = pdf_page_to_image(pdf_path, page_index=0)
        markdown = ovisocr2_parse_image(img)
    
        with open("output_page1.md", "w", encoding="utf-8") as f:
            f.write(markdown)
    
        print("已輸出:output_page1.md")
    

    改進方向:

    • 迭代所有頁面,輸出成 page_01.mdpage_02.md 再合併
    • 把檔名、頁碼寫在 Markdown 裡,方便追溯

    步驟 4:搭配雲端 LLM 的 workflow 範例

    OvisOCR2 本地做的是「結構化清洗」,你可以再串雲端 LLM 做「理解與生成」:

    1. 本地:
    2. OvisOCR2 把 PDF → Markdown
    3. 雲端(例如 OpenAI、Gemini 等):
    4. 把 Markdown 分段丟給 LLM,做:
      • 自動摘要
      • 關鍵條款整理
      • 生成簡報大綱

    好處是:

    • 原始掃描件、敏感欄位留在內網
    • 真正上雲的是整理過的文字,方便做權限控管與脫敏處理

    小結:先用一個資料夾試跑

    最簡單的開始方式:

    1. 選一個專案資料夾(例如 ./docs_to_parse
    2. 10–20 份代表性的 PDF
    3. 用本文的腳本跑一輪,觀察:
    4. 文字正確率
    5. 表格還原情況
    6. 讀取順序是不是能接受
    7. 再決定要不要擴大到整個部門或公司文件庫

    💡 關鍵: 小規模試跑可以快速評估在你實際文件類型上的效果,再決定是否投資整合到正式內網與搜尋系統。

    OvisOCR2 不會替你完成所有事,但可以把「文件數位化+結構化」這一步做得足夠穩定,讓後面的搜尋、分析、LLM 問答都有乾淨的輸入可以用。

    🚀 你現在可以做的事

    • 到 Hugging Face 下載 ATH-MaaS/OvisOCR2,在本機用 vLLM 跑一個測試 API server
    • 選 10–20 份你常用的 PDF(財報、論文、合約),用示範腳本轉成 Markdown 檔觀察品質
    • 把輸出的 Markdown 接到 Obsidian 或 ElasticSearch,試做一個小型「內網知識庫+搜尋/總結」流程