標籤: 開源模型

  • 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,試做一個小型「內網知識庫+搜尋/總結」流程
  • Graphify:讓 AI 助手看懂整個專案

    Graphify:讓 AI 助手看懂整個專案

    📌 本文重點

    • Graphify 把整個專案轉成可查詢的知識圖譜
    • 讓 Claude Code、Cursor 等助手理解「整個系統」而非單檔
    • 特別適合接手專案、Code review、排錯與重構場景

    Graphify 就是替 Claude Code、Cursor 等 AI 編碼助手建立專案的知識底層,把程式碼、SQL、腳本、文件通通轉成可查詢的圖譜,讓 AI 回答不再只看單檔,而是理解整個系統。

    專案連結:Graphify-Labs/graphify(GitHub)


    核心功能:把「專案」變成可對話的地圖

    1. 把任何專案資料夾變成知識圖譜

    Graphify 支援:

    • 程式碼:Python、JavaScript 等一般 repo
    • 資料庫:SQL schema
    • 腳本:R、shell scripts
    • 文件:docs、論文
    • 多媒體:圖片、影片(以檔案與路徑資訊的形式收錄)

    實際可做的事:

    1. 選一個專案資料夾,例如 ~/projects/legacy-crm
    2. 讓 Graphify 掃描後生成知識圖譜
    3. 把「圖譜」接到你的 AI 助手,開始用自然語言查專案

    效果:你可以問 AI:

    • 「這個專案所有跟訂單狀態相關的函式和 SQL 表有哪些?」
    • 「從 API 收到請求到入庫,整個流程經過哪些檔案?」

    行動建議:先挑一個你覺得難接手的專案,當作 Graphify 的第一個練習對象。


    2. 一次整合:程式碼 + DB schema + 基礎設施

    Graphify 強調的是「整個系統放進同一張圖」:

    • App code:API、service、models
    • Database schema:tables、relations
    • Infrastructure:scripts、部署設定、CI/CD

    這意味著 AI 助手不只看到某個函式,而是可以沿著圖譜一路追:

    • 「這支 API 最後寫進哪個資料表?」
    • 「這張資料表在哪裡被讀取/更新?」
    • 「這個 Cron job 觸發哪些腳本,再改變哪些表?」

    💡 關鍵: 把代碼、資料庫與基礎設施放進同一張圖,才能讓 AI 追蹤完整的請求與資料流向。

    行動建議:如果你常在大型專案裡迷路,優先把 App code + DB schema 一起餵給 Graphify,請 AI 幫你畫出「從前端到資料庫」的完整路徑。


    3. 支援主流 AI 編碼助手與本地模型

    Graphify 自稱是「AI coding assistant skill」,專門替各種助手提供專案知識底層,目前支援:

    • Claude Code
    • Cursor
    • Codex / OpenCode
    • Gemini CLI
    • 以及其他可透過 CLI / API 串接的助手

    好處是:你不用換開發工具,只是多了一層「專案圖譜」,讓原本的 AI 助手變得更懂上下文。

    行動建議:先選一個你已經在用的助手(例如 Cursor),只做一件事:把 Graphify 生成的圖譜加進你的 Prompt 或工具設定,看 AI 回答專案問題的精準度差異。


    適合誰用:3 個具體場景

    1. 接手大型專案:用 Graphify 做「三小時系統導覽」

    接手舊專案最常遇到:

    • 文件缺失
    • 系統邏輯分散在各層
    • 找不到「這個功能到底怎麼跑」

    操作範例

    1. 從 Git 拉下專案:

    bash
    git clone <your-legacy-repo>
    cd <your-legacy-repo>

    1. 用 Graphify 掃描整個 repo,生成圖譜(假設有 CLI 指令 graphify scan):

    bash
    graphify scan . -o graph.json

    1. 在 Claude Code 或 Cursor 裡,附上 graph.json(或指向 Graphify server),向 AI 提問:
    2. 「列出與『會員等級計算』相關的所有檔案與流程,並畫文字流程圖。」
    3. 「說明訂單取消從 API 到資料庫寫入的完整路徑。」

    行動建議:把你接手的新專案都跑一次 Graphify,強制自己在第一天就用 AI 做一輪「系統導覽問答」。


    2. Code review:從「看單檔」變成「看整條影響路徑」

    傳統 Code review 很容易只盯著 diff,看不到改動在整個系統的影響。

    用 Graphify 的方式:

    1. 在 PR 對應的分支跑 graphify scan,生成該版本的圖譜。
    2. 在 AI 助手裡,輸入:
    3. 「這個 PR 修改的函式,影響到哪些上游呼叫點與下游資料表?」
    4. 「幫我列出這個改動所有可能破壞的流程。」

    AI 可以沿著圖譜追蹤呼叫鏈、資料流向,給你一份「改動影響報告」,你再決定要多測哪些地方。

    💡 關鍵: 利用圖譜讓 AI 做「改動影響分析」,可以系統性找出需要回歸測試的區域,而不是只憑經驗猜。

    行動建議:選一個你覺得風險高的 PR,讓 Graphify + AI 助手一起做一次「影響分析」,當作試驗。


    3. 排錯與系統重構:先畫圖,再動手

    排錯時最痛苦的是:

    • 找不到錯誤在哪條鏈路上爆
    • 重構時不敢動,怕牽一髮動全身

    Graphify 的知識圖譜可以幫你:

    • 快速列出某個錯誤堆疊涉及的所有節點(檔案、函式、表)
    • 在重構前問 AI:「我要拆分 user_service,請列出所有依賴它的模組與路徑。」

    實戰問句示例

    • 「根據圖譜,payment_timeout_error 這個錯誤從觸發到記錄經過哪些模組?幫我列出路徑。」
    • 「如果我要把 orders 表拆成兩張表,請告訴我所有讀寫 orders 的程式碼位置。」

    行動建議:下一次遇到棘手 bug,不要先改碼,先用 Graphify + AI 把「錯誤路徑」問清楚,再決定從哪個節點下手。


    工具與助手比較:怎麼搭配使用?

    以下是 Graphify 與常見 AI 編碼助手的定位差異與搭配方式:

    名稱 核心功能 免費方案 適合誰
    Graphify 專案知識圖譜;整合代碼、DB、腳本等 開源,GitHub 可用 想讓 AI 助手「看懂整個專案」的人
    Claude Code 雲端 AI 編碼助手,強自然語言理解 有免費使用額度 想用對話方式改碼/理解代碼的人
    Cursor VS Code 風格編輯器 + AI 補全與聊天 有免費方案 想把 AI 深度融入 IDE 的工程師
    Gemini CLI Google Gemini 命令列助手 有免費配額 喜歡在終端機用 AI 的開發者

    行動建議:先選一個你主要的開發環境(例如 Cursor),再把 Graphify 當成「增強模組」接上去,而不是全部一起嘗試,降低學習成本。


    怎麼開始:從 GitHub 到「可用工作流」

    官方入口:https://github.com/Graphify-Labs/graphify

    以下示範兩個「從零到可用」的最短路徑,以你已有的開發工具為中心來設計。


    工作流 1:接手專案 + Claude Code 問答

    步驟一:安裝與掃描專案

    1. 安裝(假設使用 Python pip,依實際 README 為準):

    bash
    pip install graphify

    1. 進入你的專案目錄,掃描並輸出圖譜:

    bash
    cd ~/projects/legacy-crm
    graphify scan . -o graph.json

    步驟二:把圖譜交給 Claude Code

    1. 在 Claude Code 裡開啟專案,將 graph.json 上傳或貼到系統提示(System Prompt),例如:

    「你可以使用以下專案知識圖譜回答問題。請依圖譜中的檔案關係、表結構與腳本依賴,協助我理解和修改系統。」

    1. 問第一組問題:

    2. 「請整理出『會員等級計算』相關的所有模塊與資料表。」

    3. 「依據圖譜,畫出從前端呼叫到 DB 的完整流程(文字版即可)。」

    做到這一步,你就完成了:接手專案 → 建立圖譜 → 用 AI 做系統導覽 的基本工作流。

    💡 關鍵: 把圖譜丟給 AI 之後,每一個新問題都在累積你對整個系統的結構化理解。


    工作流 2:Cursor 裡做 Code review 影響分析

    步驟一:在 PR 分支生成圖譜

    1. 切換到 PR 對應分支:

    bash
    git checkout feature/new-pricing

    1. 跑 Graphify:

    bash
    graphify scan . -o pr-graph.json

    步驟二:在 Cursor 裡使用圖譜

    1. 打開 Cursor,載入這個專案,並在 AI 設定中把 pr-graph.json 放進系統提示,說明:

    「這是目前分支的專案知識圖譜。做 Code review 時,請根據圖譜分析改動的上游呼叫和下游資料影響。」

    1. 在看 diff 的同時詢問 Cursor:

    2. 「這次修改的 calculate_discount 函式,上游有哪些呼叫者?下游有哪些寫入或查詢動作?」

    3. 「依據圖譜,列出最需要回歸測試的 5 個功能。」

    這樣你就有一套:看 diff → 問圖譜 → 寫測試計畫 的 Code review 工作流。

    行動建議:先把上述其中一個工作流完整跑一次,感受「AI 從看單檔」變成「看整個系統圖」的差異,再決定要不要把 Graphify變成團隊標準工具。


    小結:把 AI 助手升級成「系統顧問」

    Graphify 的本質,是幫你的 AI 助手補上一層「專案整體結構」:

    • 不再只依靠目前開啟的 1–2 個檔案
    • 而是能沿著代碼、資料庫、腳本和設定,追到整條路徑

    如果你已經在用 Claude Code、Cursor 這類助手,下一步值得做的事,就是讓它們不只會寫函式,而是真的看懂你的系統——Graphify 正好是那一層缺少的底座。

    🚀 你現在可以做的事

    • Graphify GitHub 把專案 clone 下來並跑一次 graphify scan
    • 挑一個現有專案,把產生的圖譜接到你最常用的 AI 助手(如 Cursor 或 Claude Code)
    • 在下一次接手專案或處理高風險 PR 時,用 Graphify + AI 做一次完整的系統導覽或影響分析
  • 用 Frugon+開源模型,把 AI 帳單砍半

    用 Frugon+開源模型,把 AI 帳單砍半

    📌 本文重點

    • 用 Frugon 分析 LLM 使用紀錄與成本結構
    • 比較便宜/開源與高價模型的品質差異
    • 產生模型路由建議,讓簡單任務改用便宜模型

    只要你大量用 GPT/Claude 跑程式與 Agent 工作流,Frugon 要解決的,就是「到底哪些請求可以改用便宜或開源模型」,讓帳單直接往下掉。


    核心功能:把「模型選錯」找出來

    1. 讀取 API 日誌,算出你真實的模型成本結構

    Frugon 是一個本機 CLI 工具,核心第一步就是把你的 LLM 使用紀錄抓進來,算出每種任務到底花了多少錢。

    可採取的行動:

    1. 在你常用的 AI 平台(OpenAI / Anthropic)導出使用紀錄:
    2. OpenAI:到 Usage 頁面,下載帳單/log 檔(或透過 API 取得 responses.jsonl 類似格式)。
    3. Anthropic:到帳務或使用頁面,匯出調用紀錄(通常是 JSON 或 CSV)。
    4. 在本機安裝 frugon
      bash
      pip install frugon
    5. 在有日誌檔的資料夾執行:
      bash
      frugon analyze --logs ./logs

    Frugon 會讀取「OpenAI-style」的日誌格式,統計:

    • 各模型的使用次數、token 用量
    • 各任務類型(例如:搜尋、程式生成、摘要)的大致成本占比

    💡 關鍵: 透過實際日誌統計,你可以精確看到成本主要消耗在哪些模型與任務,而不是憑印象猜測。

    你會看到一個很直接的事實:大量錢其實花在一些很簡單的請求上,而不是最難的那 5% 任務。


    2. 對同一任務測試不同模型,估算品質差異

    真正的重點,是 Frugon 不只算錢,它會幫你試:同一個 prompt,如果改用便宜模型、甚至改用本地開源模型,結果差多少。

    可採取的行動:

    1. 準備你想比較的模型,例如:
    2. 雲端:gpt-4.1-minigpt-4.1claude-3.5-sonnetclaude-3-haiku
    3. 本地(透過 Ollama 或 vLLM):glm-4glm-5.2phi-4qwen2.5
    4. 在 Frugon 設定中,把不同模型接到同一組任務樣本:
      bash
      frugon compare \
      --logs ./logs \
      --models gpt-4.1-mini,gpt-4.1,glm-5.2 \
      --provider-config ./providers.yaml
    5. 查看報告:Frugon 會對每個任務類型輸出:
    6. 成本:每千 token 價格,預估每月支出
    7. 品質:用自動評估(例如比較回覆結構、關鍵字覆蓋率,或你自定的評分規則)估算「能否接受」

    實際效果:

    • 你會發現像 Databricks 報告提到的 pi-coding-agentGLM 5.2 等模型,在程式碼任務上,成本大幅低於主流付費模型,但通過率相近甚至更好(參考:https://www.reddit.com/r/LocalLLaMA/comments/1usrek0/)。
    • 對於簡單篩選、摘要、規則轉換類任務,gpt-4.1-mini 或開源模型往往「好到足夠」,沒必要動用最貴那一檔。

    💡 關鍵: 對相同任務批量 AB 測試不同模型,可以找到「成本明顯較低但品質仍達標」的替代方案。


    3. 自動給出「可以改用便宜模型」的路由建議

    分析完日誌與模型表現後,Frugon 會告訴你:哪些呼叫可以安全地改路由到便宜模型,還能估出你能省下的大致比例。

    可採取的行動:

    1. 在分析後產出的建議中,鎖定成本最高的前幾個任務類型,例如:
    2. code_generation_draft(寫樣板、測試腳架)
    3. search_scan(大量文本掃描、RAG 初步檢索)
    4. bulk_copywriting(批量行銷文案)
    5. 將這些任務標記為「可路由到便宜模型」,輸出為一份路由規則 YAML 或 JSON:
      “`yaml
      routes:

      • task_type: code_generation_draft
        preferred_model: glm-5.2
        fallback_model: gpt-4.1
      • task_type: search_scan
        preferred_model: gpt-4.1-mini
        fallback_model: claude-3.5-sonnet
        “`
    6. 在你的 Agent 或服務端程式裡,導入這份規則,改成:
    7. 先看任務類型(或 prompt tag)
    8. 符合路由規則時用便宜/開源模型
    9. 只有在評分不夠好時才回退到主力高價模型

    這就是 Towards AI 提到的「模型路由+編排(orchestration)」的實作方式:成本問題不是模型本身,而是你怎麼調度它們(參考:https://pub.towardsai.net/your-ai-coding-bill-is-not-a-model-problem-its-an-orchestration-problem-eeeacb340d1e)。

    💡 關鍵: 透過明確的路由規則,先用便宜模型處理大部分請求,再在需要時回退到高價模型,可以在不犧牲品質的前提下大幅壓低帳單。


    適合誰用:幾個很具體的場景

    1. 公司內部 Coding Agent/AI 助理

    如果你有:

    • 內部的程式碼自動補全、重構、寫測試的 Agent
    • 或自己用 GPT/Claude 當主力 coding 助理

    可採取的行動:

    1. 用 Frugon 分析最近一個月的 coding 相關 API 日誌。
    2. 把任務粗分為:
    3. 簡單工作:自動補全、樣板代碼、註解、測試腳架
    4. 困難工作:跨模組設計、大重構、疑難除錯
    5. 參考 Towards AI 的策略:讓簡單工作全部路由到本地開源模型(例如 GLM 5.2phi-4),只在困難工作時才叫 GPT-4.1Claude 3.5。(https://pub.towardsai.net/how-to-cut-your-ai-coding-bill-without-giving-up-the-frontier-model-870469d0d27d

    2. 批量文案生成服務

    如果你在做:

    • 大量短文案(社群貼文、電郵片段)
    • SEO 標題、meta 描述、A/B 測試版本

    可採取的行動:

    1. 把最近的批量文案請求丟給 Frugon 分析,看哪幾類 prompt 消耗最多 token。
    2. 用較便宜模型(例如 gpt-4.1-mini 或本地 qwen2.5)重跑一部分樣本,看品質是否能接受。
    3. 把「可接受的任務類型」在路由規則裡標記為便宜模型優先,主力模型只負責:
    4. 重要 campaign 的首稿
    5. 關鍵頁面(首頁/定價頁)的文案

    3. RAG 查詢服務、搜尋掃描類應用

    如果你有:

    • 內部知識庫問答網站
    • 客戶支援聊天機器人

    大多數成本在於「長上下文+大量查詢」,而不是最終回答的語氣。

    可採取的行動:

    1. 用 Frugon 找出所有包含超長 context 的調用(RAG 問答)。
    2. 評估:檢索+初步摘要能否先用便宜模型處理,再將壓縮後的內容交給高階模型發 final 回覆。
    3. 實作一條省錢路徑:
    4. 便宜模型/開源模型:負責檢索結果摘要、濾掉不相關段落(上下文壓縮)。
    5. 高階模型:只在最後一次,基於壓縮後資訊生成答案。

    怎麼開始:從第一次分析報告,到省錢工作流

    步驟 1:在本機安裝 Frugon

    Frugon 是 MIT 授權、可本地離線跑的 CLI 工具:

    pip install frugon
    frugon --help
    

    建議在專用虛擬環境裡安裝,方便後續更新和管理:

    python -m venv .venv
    source .venv/bin/activate  # Windows 用 .venv\Scripts\activate
    pip install frugon
    

    步驟 2:導出並載入 OpenAI/Anthropic 使用紀錄

    1. 從各平台匯出最近 2–4 週的 API 使用紀錄到 ./logs 目錄。
    2. 若格式不同,可先轉成近似 OpenAI responses JSON 結構(Frugon 文件裡有範例結構,可在 GitHub repo 查看)。
    3. 跑第一次分析:
      bash
      frugon analyze --logs ./logs --out report.json

    完成後你會拿到:

    • 各模型的 token 用量和估算費用
    • 各任務類型的成本分布

    步驟 3:設定模型比較與路由建議

    1. 建一個 providers.yaml,配置多家模型來源:
      yaml
      openai:
      api_key: $OPENAI_API_KEY
      anthropic:
      api_key: $ANTHROPIC_API_KEY
      ollama:
      host: http://localhost:11434
    2. 跑比較:
      bash
      frugon compare \
      --logs ./logs \
      --models gpt-4.1-mini,gpt-4.1,glm-5.2,phi-4 \
      --provider-config ./providers.yaml \
      --out routing_suggestions.yaml
    3. 根據輸出的 routing_suggestions.yaml,在你的後端服務加上簡單的模型路由:
    4. task_typemax_tokensimportance_level 作為分流條件
    5. 優先走便宜/本地模型,必要時再升級到高價模型

    步驟 4:用表格想清楚你的模型池搭配

    為了方便設計工作流,你可以把常用模型與工具列成表格:

    名稱 核心功能 免費方案 適合誰
    Frugon 讀取日誌、算成本、模型比較 開源 MIT,本機 有 API 日誌的開發者/團隊
    GLM 5.2 程式碼生成、一般助手 開源,可本地 內部 coding agent、IDE 助理
    pi-coding-agent 精簡 Bash 工具的 coding agent 依託基礎模型 想要低成本自動化寫程式的人
    GPT-4.1-mini 通用任務、便宜高效 依使用計費 批量文案、RAG 前處理
    Claude 3.5 高難度推理、長上下文 有免費層+計費 關鍵決策、難題除錯

    你不需要一次全換,只要先挑:

    • 成本最高的任務類型
    • 品質要求相對沒那麼嚴苛的場景

    用 Frugon 跑一輪比較,按表格逐步把這些流量導到更便宜或本地的模型,就能把 AI 帳單穩定壓下來,而不用放棄你熟悉的 GPTClaude 主力模型。


    🚀 你現在可以做的事

    • Frugon GitHubfrugon 安裝在本機,並準備最近 2–4 週的 API 日誌
    • 匯出 OpenAI/Anthropic 使用紀錄到 ./logs,執行 frugon analyzefrugon compare 產生第一版報告
    • 根據產出的 routing_suggestions.yaml,在你的後端或 Agent 加入模型路由邏輯,先讓一兩個任務類型切換到便宜或本地模型
  • Flint:讓 AI 也畫得出專業圖表

    Flint:讓 AI 也畫得出專業圖表

    📌 本文重點

    • Flint 讓 LLM 用簡單 JSON 就能畫出專業圖表
    • 透過中介視覺語言,把美觀與排版細節交給 Flint
    • 搭配 Data Formulator/MCP,可在多種場景自動出圖

    多數 LLM 雖然會「描述圖」,卻很難畫出乾淨、專業、可維護的圖表,Flint 就是專門幫 AI 接手這段「從文字到好圖」的工作。


    為什麼一般 LLM 畫圖總是歪掉?

    如果你用過 LLM 直接輸出 Vega-LiteEChartsMatplotlib,大概遇過這些情況:

    • 圖是畫出來了,但:
    • 顏色、比例亂選,看起來很業餘
    • 標軸標籤打錯、重疊、或被擠出畫面
    • 圖例、格線沒有依照人類習慣排版
    • 為了避免出錯,只敢給 LLM 很簡單的設定 → 圖表品質又退回系統預設
    • 一旦你說「把折線圖改成雙軸圖,多加一條移動平均」,整段 spec 幾乎要重寫

    Flint 的切入點是:不是 LLM 太笨,而是現有圖表語言太「底層」,逼模型做太多視覺細節決策。Flint 改成「中介視覺語言 + 自動排版引擎」,讓 LLM 只說高階意圖,低階美觀細節交給 Flint。

    💡 關鍵: Flint 把圖表設計拆成高階意圖與低階排版,讓 LLM 專心決策「畫什麼」,而 Flint 負責「怎麼畫得好看」。


    核心功能:Flint 幫 AI 補完「設計力」

    1. 中介視覺語言:LLM 只需要說人話版的圖表需求

    Flint 把圖表拆成幾個高階概念:

    • data: 用哪些欄位
    • mapping: 哪個欄位對應到 x、y、顏色、大小
    • mark: 用折線、長條、區域等標記
    • layout & style: 留給 Flint 自動排版與預設樣式

    LLM 只要輸出一份簡潔的 JSON,Flint 會負責:

    • 均衡配色
    • 合理的軸刻度、標籤格式
    • 避免文字重疊、圖例遮擋

    你可以做的事:在自己的 LLM 工具裡,把「請幫我生出完整 ECharts/Vega spec」改成「請輸出 Flint JSON」,再由後端把 Flint JSON 丟給 Flint 編譯成最終圖表。

    2. 與 Data Formulator 深度整合:圖表可以點一點改

    Data Formulator 是微軟另一個開源專案,可以視覺化地編輯 Flint 圖表:

    • 左邊是資料表
    • 中間是圖表
    • 右邊是 Flint 規格(JSON)

    你可以:

    • 讓 LLM 先產出 Flint 規格
    • 使用者在 Data Formulator 裡微調(拖拉欄位、改顏色)
    • 再把調整後的 Flint JSON 存回系統 → 變成可持久化的「報表模版」

    你可以做的事:把 Data Formulator 部署在內網,給資料分析團隊當「AI 生成初版圖表,人手最後調整」的工作台。

    3. MCP 伺服器:任何 Agent 都能叫 Flint 畫圖

    Flint 官方提供了符合 Model Context Protocol (MCP) 的伺服器,意思是:

    • 你用哪一家的 LLM / Agent 幾乎都不重要
    • 只要支援 MCP,就能把 Flint 當成「畫圖工具」來呼叫

    流程通常是:

    1. Agent 讀取你給的資料
    2. Agent 生成 Flint JSON
    3. 呼叫 Flint MCP 伺服器 → 回傳可嵌入網頁的圖表(或 Vega spec 等)

    你可以做的事:在自家 Agent(如 OpenAI, Claude, 自建 Llama)中,註冊 Flint MCP 工具,讓 Agent 回答問題時順手出圖,而不是只給一長段文字分析。


    適合誰用?三個具體場景

    1. 資料分析報告自動出圖

    情境:你每週要交「流量報告」、「營收報表」,但每次調整維度、時間區間都得重畫圖。

    用法:

    • 把數據放在資料庫或 CSV
    • 讓 LLM 讀取後,產出 Flint JSON
    • Flint 編譯成固定風格的圖,嵌入到報告模板(Notion、Confluence、內部系統)

    可行操作:

    • 建立一個簡單的 HTTP 服務 /generate-chart
    • 輸入:分析問題 + 資料表名稱
    • 中間:LLM → Flint JSON → Flint 編譯
    • 輸出:圖表 URL 或 HTML Snippet

    💡 關鍵:/generate-chart 這類服務,把「問問題 → 自動出圖」變成標準流程,可大幅減少手動報表製作時間。

    2. 內部 BI 助理

    情境:同事問「上個月付費轉換率怎麼樣?」,你不想每次都打開 Power BI 重拉圖。

    用法:

    • 建立一個聊天機器人(Slack / Teams / Line)
    • 後端讓 Bot 可以:
    • 查詢資料庫
    • 呼叫 LLM 產生 Flint JSON
    • 用 Flint 生成圖,回傳為圖片或互動式圖表連結

    可行操作:

    • 在 Bot 指令中加入:/chart 近三個月 活躍用戶 與 付費人數
    • Bot 回覆一張趨勢折線圖,並附上描述文字

    3. 技術文件中的動態圖表

    情境:你寫 SDK / API 文件,需要展示效能、流量、版本差異,數據常更新。

    用法:

    • 文檔系統只存「Flint JSON + 資料來源」
    • 每次讀者開啟頁面,後端動態用 Flint 產生最新圖表

    可行操作:

    • 在 docs 中嵌入一個 <iframe src="/docs/charts/latency">
    • 這個 endpoint 背後:查資料 → Flint render → 回傳 SVG / PNG

    實際長什麼樣?Flint JSON 範例

    以下是一個最小可用的 Flint 規格,畫出「每月營收折線圖」:

    {
      "data": {
        "fields": [
          { "name": "month", "type": "temporal" },
          { "name": "revenue", "type": "quantitative" }
        ],
        "values": [
          { "month": "2024-01", "revenue": 120000 },
          { "month": "2024-02", "revenue": 135000 },
          { "month": "2024-03", "revenue": 128000 }
        ]
      },
      "mark": "line",
      "encoding": {
        "x": { "field": "month", "type": "temporal" },
        "y": { "field": "revenue", "type": "quantitative" }
      },
      "title": "2024 Q1 每月營收"
    }
    

    LLM 只要穩定產出這樣結構清楚、語意正確的 JSON,Flint 就會幫你做出排版乾淨的圖,之後你想改顏色、字型、軸設定,都可以在 Data Formulator 介面上調整。


    怎麼開始?30 分鐘內畫出第一張 AI 圖

    1. 部署 Flint:本機或雲端

    官方文件與 Demo:https://microsoft.github.io/flint-chart/#/

    本機(開發測試)

    1. 安裝 Node.js(建議 18+
    2. Clone 專案:
      bash
      git clone https://github.com/microsoft/flint-chart.git
      cd flint-chart
    3. 安裝依賴並啟動示例:
      bash
      npm install
      npm run dev
    4. 瀏覽器打開 http://localhost:5173,可以看到範例圖表與 Flint Spec。

    雲端部署(給團隊用)

    • 打包為 Docker image(視官方 repo 指引)
    • 部署在自家 Kubernetes / VM 上,對外提供 REST API:
    • POST /render → 輸入 Flint JSON,回傳圖表

    2. 使用現成範例,串接任一主流 LLM / Agent

    基本流程:

    1. 在後端寫一個函式 askLLMForFlintSpec(prompt, data_schema)
    2. 提示詞約束:
    3. 請只輸出 JSON,不要加解釋文字
    4. JSON 結構遵守 Flint Spec(可把官方 schema 一併塞進 system prompt)
    5. 把 LLM 回傳的 Flint JSON 送到 Flint API:
    import requests, json
    
    flint_spec = llm_generate_flint_spec(user_query, data_schema)
    res = requests.post(
        "http://localhost:8000/render",
        json={"spec": flint_spec}
    )
    with open("chart.svg", "wb") as f:
        f.write(res.content)
    
    1. 前端直接顯示 chart.svg,或轉 PNG 給報告系統使用。

    3. MCP 整合:丟給你的 Agent 用

    若你使用支援 MCP 的 Agent(例如部分新一代 IDE 助理、Agent Framework),步驟大致是:

    1. 啟動 Flint MCP server(依官方 repo 指示)
    2. 在 Agent 設定檔中註冊 Flint MCP endpoint
    3. 在系統提示詞中說清楚:
    4. 何時該呼叫 Flint(遇到需要圖表的問題)
    5. 如何構造 Flint JSON

    完成後,你就可以在對話中自然問:「幫我畫一張 2024 各季度營收與毛利率的組合圖」,讓 Agent 自行決定查數據、生成 Flint JSON、再回傳圖表。


    Flint 與其他「讓 AI 變強」工具怎麼搭配?

    下面用一個表快速對比本文提到的工具角色:

    名稱 核心功能 免費方案 適合誰
    Flint 中介視覺語言,幫 LLM 生高品質圖表 開源 需要報表 / 圖表自動化的開發者
    Data Formulator 可視化編輯 Flint 圖表的前端工具 開源 想在瀏覽器調整 AI 圖表的資料分析師
    VisionBridge1 讓純文字 LLM 具備視覺理解能力的代理 開源 想給本地 LLM 加上看圖能力的開發者

    你可以把它們組成一條完整流水線:VisionBridge 提供「看圖」能力、LLM 做推理與產生 Flint JSON、Flint+Data Formulator 負責「畫好圖」與人類微調。


    結語:先讓 AI「畫得出像樣的圖」再談自動化報表

    如果你已經在用 LLM 做資料分析、寫 BI 查詢,下一步就是讓結果不是只停在文字。Flint 幫你用很低的開發成本,把「專業圖表」變成 AI 回答的一部分,而且保留 JSON 規格,後續要改樣式、改資料源,都能持續演進。

    最實際的建議:花 30 分鐘跑起官方 Demo,拿文中的範例 JSON 改成自己的資料,先做出第一張「AI 自動生成、你看得順眼、同事也改得動」的圖表,再來思考要怎麼把它嵌進你的報表、內部工具或 Agent 流程裡。

    🚀 你現在可以做的事

    • 打開 https://microsoft.github.io/flint-chart/#/,跑起官方 Demo 並試著改用自己的資料
    • 在後端實作一個簡單的 /generate-chart 服務,讓 LLM 產生 Flint JSON 再交給 Flint 渲染
    • 部署 Data Formulator,讓資料分析同事用瀏覽器微調 LLM 生成的 Flint 圖表並存成報表模版
  • 開源 ATS 開箱:先讓機器 HR 幫你看履歷

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

    📌 本文重點

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

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

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


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

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

    1. 關鍵字與職缺匹配

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

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

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

    2. 技能欄位結構化

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

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

    3. 格式與可解析度

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

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


    適合誰用:兩個典型場景

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

    選項 A:本機 Docker 一鍵跑起

    如果 README 提供 Docker Compose:

    docker compose up -d
    

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

    選項 B:雲端輕量部署

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    🚀 你現在可以做的事

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

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

    📌 本文重點

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

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

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


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

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

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

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

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

    你只需要:

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

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


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

    官方描述:

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

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

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

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

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

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

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


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

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

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

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

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

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

    適合誰用?三個典型場景

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

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

    情境

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

    你可以這樣用:

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

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


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

    情境

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

    例如:

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

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


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

    情境

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

    使用示例:

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

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


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

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


    步驟 0:準備環境

    先確認:

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

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


    步驟 1:Clone 專案

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

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


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

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

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

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


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

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

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

    2. 哪個 persona 用哪個 provider

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

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


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

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

    python main.py
    # 或
    council
    

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

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

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

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

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

    在終端中輸入:

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

    你應該會看到:

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

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


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

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

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

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

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

    最後的可行動點

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

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


    🚀 你現在可以做的事

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

    用文字畫 3D:Adam 實戰指南

    📌 本文重點

    • Adam 把自然語言變成可編輯的 OpenSCAD 程式碼與 3D 模型
    • 用「文字 + 滑桿」就能調整尺寸與設計邏輯
    • 雲端試用簡單,也能用 CADAM 自架整合到現有流程

    一句話先講結論:Adam 讓你用一句自然語言描述零件,就能拿到可編輯的 OpenSCAD 程式碼和 3D 模型,用滑桿或文字微調尺寸,直接接到現有 CAD/3D 列印流程。

    官網 / Demo:https://adam.new
    開源專案(CADAM):https://github.com/Adam-CAD/CADAM


    核心功能:從文字到 CAD 程式碼

    Adam 圍繞一條實際工作流程設計:「文字描述零件 → 生成 CAD 程式碼 → 視覺化 3D 模型 → 滑桿 / 文字微調 → 導出到現有流程」。

    💡 關鍵: 這條流程的重點是輸出「可維護的程式碼 + 模型」,而不是單次不可重用的模型檔。


    1. 兩種模式:參數化建模 vs 網格生成

    進入 Adam 介面後,先選模式:

    • 參數化建模(Text → OpenSCAD)
    • 輸入:
      • 例:「一個 20×40 mm 的 L 形支架,厚度 3 mm,兩邊各有 2 個直徑 4 mm 的螺絲孔,孔中心離邊 8 mm。」
    • 輸出:
      • 可編輯的 OpenSCAD 程式碼
      • 內建參數滑桿(長度、厚度、孔徑等)
    • 適合:

      • 要做多尺寸版本、後續要改尺寸的零件
    • 網格生成(Text → Mesh)

    • 輸入:較偏形狀描述,如「帶有圓角的桌角保護套,可套在 20 mm 厚桌板上」。
    • 輸出:
      • 一個可下載的網格(通常是 STL 或類似格式)
    • 適合:
      • 只要快速 3D 列印,不打算日後精細改版的形狀件

    實際操作行動

    1. 先想清楚這個零件未來會不會「常改尺寸」。
    2. 會改 → 選「參數化建模」;一次性打樣 → 可試「網格生成」。

    2. 滑桿調參 + 文本修改:像寫程式一樣調零件

    Adam 的核心體驗是「文字 + 滑桿」雙軌控制:

    1. 第一次生成
    2. 在文字框輸入需求,按下生成。
    3. Adam 會:

      • 呼叫 AI 生成 OpenSCAD 程式碼
      • 解析出關鍵尺寸,放成可拖曳的滑桿
    4. 用滑桿調整尺寸

    5. 介面右側是 3D 模型預覽,左側或下方是參數列表:
      • lengthwidththicknesshole_diameter 等。
    6. 你可以直接拖拉滑桿,看模型即時更新。
    7. 適用情境:

      • 客戶說「再厚一點」
      • 3D 列印測試後只想調整孔徑、間距
    8. 用文字改需求

    9. 覺得形狀邏輯要變,例如:
      • 原本「兩個孔」,改成「三個等距孔」。
    10. 直接在文字框補一句:「改成三個等距螺絲孔,孔徑 5 mm。」
    11. Adam 會重新生成程式碼,並保留參數化結構。

    💡 關鍵: 數值用滑桿、邏輯用文字,能把「一次性建模」變成「可持續迭代的設計流程」。

    實際操作行動

    • 每次修改先問自己:「這是數值調整,還是設計邏輯變更?」
    • 數值:用滑桿或直接改參數欄位數字。
    • 邏輯:用文字提示重新生成,然後再微調滑桿。

    3. Text → Code:產出可讀的 OpenSCAD

    Adam 的底層策略是「Text → Code → CAD」:

    • 你得到的不是黑盒模型,而是完整 OpenSCAD 程式碼
    • 具名變數:bracket_lengthwall_thicknesshole_offset
    • 結構清楚的 module() 函式。
    • 你可以:
    • 直接把程式碼複製到本機 OpenSCAD 編輯。
    • 放進 Git 版本控制。
    • 用腳本批次修改某些參數再輸出多版本。

    實際操作行動

    1. 生成完成後,打開程式碼面板,把 OpenSCAD 內容存成 part.scad
    2. 用 Git 建版(例如 v1.0v1.1),把 AI 產生的 CAD 正式納入工程專案。

    適合誰用?三個具體場景


    1. 機構工程師:快速打樣支架 / 夾具

    常見痛點:

    • 為測試治具、感測器支架畫模型,來回改尺寸耗時間。

    用 Adam 的 workflow:

    1. 文字描述:
    2. 「一個可以夾在 20 mm 厚鋁板上的 U 形夾具,內側貼合,外側有一個 5 mm 穿孔用來鎖 M5 螺絲。」
    3. 選「參數化建模」,生成模型和程式碼。
    4. 滑桿調整:板厚、公差、螺絲孔位置。
    5. 導出 STL,送去 3D 列印測試。

    建議做法:把專案常用尺寸(例如板厚、公差)命名成變數,後續專案只改變數就能重用設計。


    2. 3D 列印工作室:一次生成多尺寸版本

    需求:

    • 同一個產品,需要 10、20、30、40 mm 四種尺寸給不同客戶。

    做法:

    1. 在 Adam 生成一個參數化模型,例如「桌角保護套」,把關鍵尺寸寫成變數 edge_size
    2. 將 OpenSCAD 程式碼複製回本機,寫簡單迴圈:

    scad
    for (s = [10, 20, 30, 40]) {
    edge_size = s;
    // 呼叫 Adam 生成的 module
    corner_protector(edge_size=edge_size);
    }

    1. 在 OpenSCAD 中分別導出不同尺寸 STL。

    替代做法:懶得寫程式時,可在 Adam 的滑桿上手動切四個尺寸,分別匯出四個 STL,適合量少時使用。

    💡 關鍵: 把尺寸參數化後,同一份程式碼就能覆蓋多個規格,大幅減少重畫模型的時間成本。


    3. 軟體工程師:用文字產出可讀 CAD

    痛點:

    • 不熟 3D CAD,但懂程式,希望能為 Side Project 做外殼或支架。

    用 Adam 的方式:

    1. 用你熟悉的軟體語言思維來描述零件:
    2. 「為一塊 100×80 mm 的 PCB 做一個盒子,上方預留 10 mm 高空間,下方有 4 個 M3 鎖孔,孔位與 PCB 四角對齊。」
    3. Adam 會產生具名變數與模組化程式碼:
    4. 很像在讀一個乾淨的程式檔案。
    5. 你可以把 part.scad 放進專案 repo:
    6. hardware/case_v1.scad
    7. 在 CI 裡加註解:「生成 STL 時請用 OpenSCAD 2024.x 以上版本。」

    實際操作行動:團隊中沒有機構工程師時,讓軟體工程師先用 Adam 做「可用但不完美」的機構草稿,再請專業設計師基於 OpenSCAD 程式碼優化。


    怎麼開始:雲端體驗到本機部署


    1. 直接在線上玩 Demo(最快)

    1. 開啟:https://adam.new
    2. 用 Google / GitHub 帳號註冊或以訪客登入(以實際介面為準)。
    3. 選擇模式:
    4. 多尺寸零件 → 「參數化建模」
    5. 只要快速 3D 打樣形狀 → 「網格生成」
    6. 在文字框輸入第一個零件描述,按生成。
    7. 試著:
    8. 拖拉滑桿,觀察模型變化。
    9. 切到程式碼頁籤,複製 OpenSCAD 程式碼。

    目標:第一次使用,用 10 分鐘做出一個「有螺絲孔的簡單支架」並匯出 STL。


    2. 在本機部署開源 CADAM

    如果你想要自架服務(內網使用、接私有模型),可以部署開源專案 CADAM

    GitHub:https://github.com/Adam-CAD/CADAM

    CADAM 是一個 React + Supabase 的 web app,大致步驟:

    1. 準備環境(本機或伺服器):
    2. Node.js(建議 18+)
    3. pnpmnpm
    4. Docker(選用,如果你要用容器)

    5. Clone 專案

    bash
    git clone https://github.com/Adam-CAD/CADAM.git
    cd CADAM

    1. 安裝依賴

    bash
    pnpm install
    # 或 npm install

    1. 設定環境變數
    2. 依照 README 建立 .env 檔:

      • Supabase 金鑰 / URL
      • OpenAI 或相容 LLM 的 API Key(若要自接模型,依說明調整)
    3. 啟動開發伺服器

    bash
    pnpm dev

    在瀏覽器打開 http://localhost:3000 即可使用。

    行動建議:先在線上版熟悉介面,再決定是否要自架;部署前從 GitHub 的 issue / README 確認當前支援的模型與功能狀態。


    3. 接到 OpenSCAD / CAM / 生產流程

    Adam 的輸出是程式碼 + 模型,你可以這樣接入現有流程:

    3.1 接 OpenSCAD

    1. 從 Adam 介面複製生成的 OpenSCAD 程式碼。
    2. 在本機用 OpenSCAD 打開,進行:
    3. 更進階的布林運算(差集、交集)
    4. 加入你自己的 library / module
    5. 用 OpenSCAD 導出 STL / STEP,交給下游軟體。

    3.2 接 CAM / CNC / 3D 列印

    • 3D 列印
    • 從 Adam 或 OpenSCAD 匯出 STL。
    • Cura / PrusaSlicer / Bambu Studio 裡切片,設定填充率、支撐等。

    • CNC / CAM

    • 如果需要 STEP/IGES,可先用其他工具把 STL 轉 B-rep(或改用能輸出 STEP 的 CAD 路線)。
    • Fusion 360 / SolidWorks / FreeCAD 裡做 CAM 規劃,生成刀具路徑。

    實際操作行動:選一個目前專案中的小零件,用 Adam 生成 → 用 OpenSCAD 調整 → 匯出 STL → 3D 列印,完整跑一次小型「文字到實物」流程,確認團隊能接得住輸出格式。


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

    如果你是:

    • 機構工程師:先把常用的支架 / 夾具模板交給 Adam 生成 OpenSCAD 草稿,日後改尺寸只改變數。
    • 3D 列印工作室:用 Adam 做參數化模型,批次產生多尺寸版本,減少重畫時間。
    • 軟體工程師 / Maker:把 CAD 當程式寫,用 Git 管理 .scad,讓硬體外殼也成為可維護的程式碼資產。

    下一步,開啟 https://adam.new,用一句話描述你今天最想偷懶不想畫的零件,看看 Adam 能幫你省掉多少建模時間。

    🚀 你現在可以做的事

    • https://adam.new,用一句話生出一個含螺絲孔的小支架並匯出 STL
    • 把生成的 OpenSCAD 存成 part.scad,放進 Git repo 當作第一個「程式化 CAD」檔案
    • https://github.com/Adam-CAD/CADAM 看 README,評估是否在團隊內部自架一套 Adam/CADAM 服務
  • 自架 AI 全家桶實戰筆記

    自架 AI 全家桶實戰筆記

    📌 本文重點

    • 用舊 PC 搭建「迷你雲端 + 本地 AI」
    • 利用 Self-Hosting Guide 系統化部署 LLM 與自動化
    • 透過 WireGuard 打通安全的遠端存取通道

    一句話定位:這是一份幫你在家搭一個「迷你雲端 + AI 環境」的說明書,從本地 LLM、家用自動化到安全遠端存取,一套打包。

    主角是 GitHub 上超熱門的自架指南專案 mikeroyal/Self-Hosting-Guide,它像是一本持續更新的「自建 IT 生態系手冊」,你可以照著它,把一台舊 PC 變成自己的 AI 內網與家庭雲。

    下面會聚焦三件跟你最有關的事:

    • 怎麼選、怎麼跑本地 LLM(含硬體需求)
    • 怎麼把模型接進自動化管線(Home Assistant、開發工具、自架 Git)
    • 怎麼用 WireGuard 之類方案,讓整套系統能安全地從外面連回家

    最後會給一條「懶人起手路線」,照做就能在一個週末搭起初版 AI 內網。


    核心功能 1:幫你選與部署本地 LLM

    Self-Hosting Guide 做的事:把本地部署 LLM 的選項、硬體需求、工具鏈整理好,讓你不用從 Reddit、HN 一篇篇啃。

    1.1 怎麼挑模型?

    日常自用、寫程式或辦公,其實不必直接上 70B 巨獸。你可以用這份指南搭配社群經驗,先鎖定幾種典型選項:

    名稱 核心功能 免費方案 適合誰
    Qwen / LLaMA 系列 Q4 量化 通用聊天、程式輔助 開源模型免費 想把 GPT/Claude 部分換成本地的人
    中小型 7B-14B 模型 簡單對話、個人筆記、RAG 多數開源 硬體普通的家用機
    27B–32B 模型(如 Qwen3.6-27B) 強一點的程式與長文理解 模型免費,但吃資源 有 RTX 3090 級 GPU 的進階玩家

    在 Reddit 的 Qwen3.6-27B 優化案例 中,有人用 RTX 3090 + kvflash 把:

    • token 生成速度提升到約 38.6 tok/s
    • KV cache VRAM 從 ~21GB 降到 ~17.5GB

    💡 關鍵: 單張 RTX 3090 透過 kvflash 等優化就能流暢跑 27B 級模型,讓「高階單卡跑大模型」變成實務選項。

    這代表:

    • 高階單卡也能跑 27B 模型
    • 只要配置得當,日常 coding/聊天其實很順

    你可以馬上做的事:

    1. 先確認自己 GPU:
    2. 無 GPU / Intel NUC / 家用舊機 → 目標 7B 量化模型
    3. RTX 3060-3070 → 13B 或 14B 模型
    4. RTX 3090 / 4090 → 可以嘗試 27B 以上(搭配量化 + KV 優化)
    5. 打開 Self-Hosting Guide 的 LLM 章節,挑一套部署方案:
    6. 想圖形化、簡單管理 → 找「Docker + Web UI」路線
    7. 想自己玩細節 → 找 vLLM / text-generation-inference 等關鍵字

    1.2 必備工具:Ollama / LM Studio / vLLM

    本地 LLM 生態裡,以下幾種工具是常見組合(指南裡也有提到相關堆疊):

    名稱 核心功能 免費方案 適合誰
    Ollama 一行指令拉模型、啟動本地 API 完全免費 想快速起一個 ChatGPT 替代的人
    LM Studio 有 UI 的模型下載與啟動器 免費客戶端 不熟 CLI 的使用者
    vLLM 高效推理框架,支援長上下文、KV 優化 開源 想追求高吞吐、寫服務端的工程師

    你可以馬上做的事(以 Ollama 為例):

    1. 在你的 Linux / macOS / Windows 安裝 Docker(或直接安裝 Ollama):
      bash
      curl -fsSL https://ollama.com/install.sh | sh
    2. 拉一個通用聊天模型(例如 qwen:7b):
      bash
      ollama pull qwen:7b
      ollama run qwen:7b
    3. 開啟瀏覽器,接一個簡單 Web UI(比如 Open WebUI 或指南中的前端項目),就有本地 Chat。

    核心功能 2:把模型接進自動化管線

    只在終端機裡跟模型聊天很快會膩,Self-Hosting Guide 的價值是教你:怎麼讓模型變成你家裡與工作流的一部分

    2.1 家用場景:結合 Home Assistant

    指南中有完整一章介紹 Home Assistant,你可以這樣用:

    • 讓 LLM 幫你:
    • 轉換你說出的自然語言成自動化指令(例如:「我出門了」→ 關燈 + 關冷氣 + 啟動警報)
    • 設計複雜條件自動化(比如天氣 + 家人是否在家 + 時間條件)

    你可以馬上做的事:

    1. 在家裡一台常開機器(NUC/舊 PC)裝好 Docker。
    2. 依照指南,跑起 Home Assistant Docker 容器。
    3. 把本地 LLM 提供的 API(例如 Ollama 預設在 http://localhost:11434)接進 Home Assistant
    4. 透過 Home Assistant 的 REST / Webhook 自定義整合
    5. 或查指南中列出的 LLM 插件項目,選現成方案

    這樣就能做到:「家裡的自動化規則,全部走本地,不往外傳」。

    💡 關鍵: 把 Home Assistant 與本地 LLM 串起來,就能在完全離線的情況下,用自然語言控制整個智慧家居。

    2.2 工作場景:自架開發工具 + Git 服務

    Hacker News 上有不少人分享,已經用本地模型取代部分 GPT/Claude 的日常 coding(參考:Ask HN: Has anyone replaced Claude/GPT with a local model for daily coding?)。Self-Hosting Guide 把這些需求拆成幾件事:

    • 自架 Git 服務(例如 Gitea
    • 自架 Code Review / CI 工具
    • 本地 LLM 提供程式輔助、摘要、Code Review

    你可以馬上做的事:

    1. 按指南起一個 Gitea / GitLab Self-Hosted
    2. 管理自己專案
    3. 把程式碼全部留在家裡伺服器
    4. 啟動一個專門幫你寫程式的本地模型(例如 13B 量化模型):
    5. VS Code / Neovim 插件,把 LLM API 指到你的本地網址
    6. 讓「Copilot 類功能」完全在你自家網路裡運行

    核心功能 3:用 WireGuard 打通「安全外網」

    你在家裡搭了一堆服務(LLM、Home Assistant、Git),下一步就是:如何在外面(公司、咖啡店)也能安全用到?

    Self-Hosting Guide 花了不少篇幅介紹 WireGuard,重點是:

    • 比傳統 VPN 設定簡單
    • 效能好、延遲低
    • 適合「家裡一台主機 + 多台手機/筆電」的拓撲

    你可以馬上做的事:

    1. 按指南在家用伺服器上安裝 WireGuard
      bash
      sudo apt install wireguard
    2. 建立一個基本設定(指南裡有範本):
    3. 伺服器端設定 IP 範圍(例如 10.0.0.1/24
    4. 每台裝置一組 key
    5. 在手機、筆電裝 WireGuard App,把設定檔匯入。
    6. 測試從外網連回家裡的 Home Assistant / LLM Web UI:
    7. 確認只透過 VPN 通道能接入
    8. 不把服務直接暴露在公網

    這樣做完,你就可以在外面用自己的「家用 GPT」,而不怕資料跑到第三方。

    💡 關鍵: 用 WireGuard 把家裡變成「只給自己與信任設備開放」的私人雲端,比直接開公網埠安全太多。


    適合誰用?幾個具體情境

    1. 家裡有一台舊電腦,想做點有趣但不想再裝一堆雲服務的人

    • 把它變成:NAS + LLM + Home Assistant 的整合機
    • 儲存相片、影音,順便當你的「家庭 ChatGPT」

    2. 想降低雲端 LLM 成本的開發者 / 早期團隊

    • 常用功能(例如程式補全、文件摘要)搬回本地
    • 只在需要強模型時才連外部 API

    3. 對隱私敏感的自由工作者 / 企業

    • 客戶文件、程式碼不想上雲端
    • 自己管理整個資料與模型環境

    4. 喜歡折騰硬體與自動化的玩家

    • 把 Home Assistant + LLM 玩到極致
    • 用 WireGuard 把家當作自己的「個人雲端」。

    怎麼開始:一週末搞定的懶人路線

    最後總結一條 「起手路線」,照著走就能搭出你的第一版 AI 內網。

    Step 0:準備一台舊機 + Docker

    • CPU:近 5 年內的桌機或筆電
    • RAM:至少 16GB
    • GPU:沒有也行(先跑 7B 小模型),有 RTX 3060 以上更好
    • OS:建議 Ubuntu Server / Debian
    • 安裝 Docker + docker-compose

    Step 1:部署 1 個聊天模型(Ollama)

    1. 安裝 Ollama(或依照 Self-Hosting Guide 中的建議):
      bash
      curl -fsSL https://ollama.com/install.sh | sh
    2. 拉一個通用模型(例如 llama3:8bqwen:7b):
      bash
      ollama pull llama3:8b
    3. 啟動並確認能在瀏覽器/CLI 聊天。

    Step 2:部署 1 個文件 / RAG 服務

    1. 選一個簡單 RAG 專案(例如指南裡推薦的開源 RAG Web UI):
    2. 用 Docker 起一個 Web 服務
    3. 把本地 PDF / Markdown 丟進去建立索引
    4. 把 RAG 的 LLM 後端指向 Ollama 的 API:
    5. 在設定頁填入 http://host.docker.internal:11434 或你的本地 IP
    6. 測試:輸入「幫我整理公司 A 專案會議紀錄」,看回答是否依據你的文件。

    Step 3:逐步擴展成「個人 AI 內網」

    每成功一小步,就再加一個服務:

    1. 接 Home Assistant:
    2. 先只用它做幾條簡單自動化(睡前關燈、出門關冷氣)
    3. 再讓 LLM 參與規則設計與自然語言控制
    4. 接開發工具:
    5. VS Code 裝支援自定義 LSP / LLM 的插件
    6. 把 endpoint 指向你本地 LLM
    7. 最後再加上 WireGuard
    8. 把整套「迷你雲端」安全地帶出門用

    整個過程不用一次到位,只要跟著 Self-Hosting Guide 的章節,一個一個勾:

    • LLM → Automation → Home Assistant → WireGuard → 其他服務

    做完,你就會有一個完全掌控、可隨時擴充的「自架 AI 全家桶」。


    如果你一直想把 GPT 類工作能力留在自己家裡,這份 Self-Hosting Guide 值得直接 Star 收藏,照著它,一台舊機 + 一個週末,就能搭出你的第一個「個人 AI 內網」。

    🚀 你現在可以做的事

    • 打開 Self-Hosting Guide,先 Star 並閱讀 LLM 相關章節
    • 在一台舊電腦上安裝 Docker + Ollama,實際跑起一個 7B 模型試用
    • 依照指南部署 Home Assistant 與 WireGuard,把本地 LLM 串進家庭自動化與遠端存取
  • 用 North Mini Code 打造自己的 Coding Agent

    用 North Mini Code 打造自己的 Coding Agent

    📌 本文重點

    • North Mini Code 是針對程式碼與 Agent 優化的 30B 開源模型
    • 可在本地或內網部署,避免程式碼外流與雲端綁定
    • 透過 vLLM / FastAPI 等,可接到 IDE 當自家 Copilot
    • 可擴展成自動重構、產 PR 的完整 Code Agent workflow

    雲端 Copilot 很好用,但貴、會上傳程式碼、也被綁在特定平台;North Mini Code 讓你用一顆開源小模型,在自己機器上做出專屬的 AI 程式碼 Agent。

    模型連結:Hugging Face – CohereLabs/North-Mini-Code-1.0
    https://huggingface.co/CohereLabs/North-Mini-Code-1.0


    核心功能:這顆模型能幹嘛?

    1. 專門為「程式碼 + Agent」調過的 30 億參數模型

    • 參數規模:30B(約 3B active),重點是 效能 / 顯示記憶體比很友善
    • 授權:Apache 2.0,可商用、可改、可包進你的產品,不用談授權費。
    • 能力:在人工程式碼分析指標(Artificial Analysis Coding Index)拿到 33.4 分,與同級模型競爭力接近。
    • 官方定位:Cohere 把它稱為 開源 Agentic Coding Model,也就是特別優化「一步一步推理、呼叫工具、改檔案」這種工作流程。

    💡 關鍵: 這顆 30B 模型以約 3B active 參數達到 33.4 分表現,代表在顯存友善的前提下仍具同級競爭力。

    可以做的事:

    • 寫與理解多語言程式碼(Python、TypeScript、Go…)。
    • 幫你拆解需求 → 拆任務 → 生出具體修改建議與 patch。
    • 當成 Agent 的「大腦」,搭配工具去讀檔案、改檔案、送 Pull Request。

    行動建議:先到 Hugging Face 頁面按下 Duplicate in Space 或在 Web UI 裡試幾個自己的 code snippet,確認風格合不合胃口。


    適合誰用?幾個具體場景

    • 公司不方便把原始碼丟上雲端:金融、醫療、政府專案,用雲端 Copilot 有合規壓力,North Mini Code 可以放在內網 GPU 或伺服器裡使用。
    • Side project 想省錢又想有 Copilot 感覺:自己架一顆模型,用 Cursor、Claude Code 或自製 VSCode 插件連上去,平常寫 side project 就靠它輔助。
    • 想做自家產品的「內嵌 Coding Agent」:SaaS、DevOps 工具、内部平台,想加「一鍵重構」「一鍵產生自動化 script」,可以直接把這顆模型包進去,不用每月燒雲端 API。
    • 研究 / 教學單位:開課教 AI for Programming,可以讓學生直接在本地玩 Agent,而不是只調用雲端 API。

    怎麼開始(一):最快速的入門方式

    這一層目標:先看到模型實際寫程式碼的樣子,不用寫太多 infra。

    1. 直接在 Hugging Face 線上試

    1. 開啟模型頁:https://huggingface.co/CohereLabs/North-Mini-Code-1.0
    2. 找到 InferenceSpaces Demo 區塊。
    3. 貼上一段自己的函式,輸入提示:

    text
    你是一位資深後端工程師,請重構以下 Python 函式,要求:
    1. 拆成小函式
    2. 加上型別註記
    3. 解釋主要修改點

    1. 看輸出是否符合你平常期待的 coding style。

    行動目標:至少用你現在在做的專案語言(例如 TypeScript + NestJS / Python + FastAPI),試 3 個 prompt,確認模型對你主力技術棧的理解能力。

    2. 用現成推理伺服器跑起來(TGI / vLLM

    如果你手上有一台有 GPU 的機器,可以用現成的推理伺服器:

    • text-generation-inference (TGI):Hugging Face 官方推,部署簡單。
    • vLLM:效能好、支援 OpenAI-style API。

    vLLM + Docker 為例(概念示意):

    docker run --gpus all -p 8000:8000 \
      vllm/vllm-openai:latest \
      --model CohereLabs/North-Mini-Code-1.0 \
      --download-dir /models
    

    跑起來後,你就有一個 OpenAI 相容的 /v1/chat/completions API 可以 call。

    行動目標:用你最熟悉的推理方案(TGIvLLM 選一個)先在伺服器上跑起來,用 curl 或 Postman 成功打到一次 API。


    怎麼開始(二):包成 OpenAI-style API,接到 IDE 裡

    這一層目標:讓 North Mini Code 像 OpenAI 一樣被 Cursor、Claude Code 或自製 VSCode 插件當作後端使用。

    假設你已經用 vLLM 把模型跑在 localhost:8000,現在可以再包一層簡單的 Python 代理 API,對外維持 OpenAI 介面(方便未來切換模型)。

    1. 用 Python FastAPI 做一個薄封裝

    # app.py
    from fastapi import FastAPI
    from pydantic import BaseModel
    import requests
    
    OPENAI_COMPAT_URL = "http://localhost:8000/v1/chat/completions"  # vLLM
    
    app = FastAPI()
    
    class Message(BaseModel):
        role: str
        content: str
    
    class ChatRequest(BaseModel):
        model: str
        messages: list[Message]
        temperature: float | None = 0.2
    
    @app.post("/v1/chat/completions")
    async def chat(req: ChatRequest):
        payload = {
            "model": "CohereLabs/North-Mini-Code-1.0",
            "messages": [m.model_dump() for m in req.messages],
            "temperature": req.temperature,
        }
        r = requests.post(OPENAI_COMPAT_URL, json=payload)
        return r.json()
    

    啟動:

    uvicorn app:app --host 0.0.0.0 --port 3000
    

    現在,http://localhost:3000/v1/chat/completions 就是一個「自家版 OpenAI API」。

    2. 接到 Cursor / VSCode / 自製工具

    以 Cursor 為例:

    1. 打開 Cursor 設定 → Models → 自訂 API。
    2. 填寫:
    3. Base URL: http://localhost:3000/v1
    4. API Key:隨便填一個(例如 local-north-mini),因為你自己的服務可以忽略驗證。
    5. 選擇此自訂模型作為預設 Coding 模型。

    之後你在 Cursor 內:

    • Tab 補全、聊天寫 code、改檔案的請求,全部都會走到你這顆本地的 North Mini Code。

    行動目標:把 IDE(Cursor 或 VSCode 插件)接到你剛剛包好的 API,嘗試用它完成一個小功能(例如寫一個簡單的 REST API route)。


    怎麼開始(三):變成真正的 Code Agent Workflow

    這一層目標:不是只有「聊天寫 code」,而是讓模型能 看專案、給重構建議、自己產生 PR 草稿

    💡 關鍵: 當模型被嵌入自動讀檔、產 diff、送 PR 的流程時,才真正從「聊天輔助」升級為完整 Code Agent。

    範例 Workflow:從 Git repo → 重構建議 → PR 草稿

    流程拆解:

    1. 從 Git repo 讀取指定資料夾的檔案內容。
    2. 用 North Mini Code 產生重構建議與 patch(例如 unified diff)。
    3. 建立分支、套用 patch、產生 commit 和 PR 草稿(或 MR)。

    簡化版 Python 範例(偏偽碼):

    from git import Repo
    import openai  # 指向你自己的 /v1
    
    openai.api_base = "http://localhost:3000/v1"
    openai.api_key = "local-north-mini"
    
    repo = Repo("./your-project")
    files = ["app/service/user_service.py", "app/api/user_routes.py"]
    
    code_snippets = []
    for path in files:
        content = (repo.working_tree_dir + "/" + path)
        with open(content, "r", encoding="utf-8") as f:
            code_snippets.append(f"# FILE: {path}\n" + f.read())
    
    prompt = """
    你是一位資深後端工程師與程式碼重構專家。
    請針對下列檔案:
    1. 給出具體重構建議
    2. 產生 unified diff 格式的 patch(只包含必要修改)
    3. 每個修改前加上簡短註解(英文)
    
    注意:
    - 保持對外介面不變
    - 如果不需要改,請明確說明原因
    """ + "\n\n".join(code_snippets)
    
    resp = openai.ChatCompletion.create(
        model="north-mini-code",
        messages=[{"role": "user", "content": prompt}],
    )
    patch = resp["choices"][0]["message"]["content"]
    
    # 接下來可以用 `git apply` 或 python-git 應用 patch,然後用 GitHub / GitLab API 建 PR
    

    這裡的關鍵不是 Git 操作細節,而是:

    • 把「讀檔案」「套 patch」「建分支與 PR」都寫在程式裡。
    • North Mini Code 只負責做它擅長的事:理解現有 code → 給出修改 diff。

    SkillSpector + agentsview:安全與使用監控

    你一旦開始寫 Agent,下一步就是 安全與觀察。這裡可以搭兩個開源專案:

    名稱 核心功能 免費方案 適合誰
    SkillSpector 掃描 Agent 的「技能」或工具,找出可能的安全漏洞與惡意模式 開源 有多個自動化工具、會對 Repo/GCP/AWS 操作的團隊
    agentsview 本地優先的 Coding Agent 會話分析與使用監控,支援 Claude Code、Codex 等 開源 想看「Agent 整天在幹嘛」、算 Token 用量與失敗率的團隊

    實際做法:

    • SkillSpector 扫描你寫給 Agent 用的工具(例如「自動 apply patch」「執行 migration」),避免權限過大或不安全操作。
    • agentsview 紀錄 coding agent 的 session:prompt / 回應 / 結果,方便 debug 與觀察模型在專案上的實際表現。

    行動目標:挑一個小專案,寫一個「自動產生重構 PR 草稿」的 Agent,然後用 SkillSpector 檢查工具安全,並用 agentsview 觀察它的使用行為。


    實務建議:硬體需求與小顯卡怎麼玩

    最低硬體需求(實務向)

    North Mini Code 是 30B 級別模型,原生 FP16 會非常吃顯存,一般建議:

    • 順暢推理
    • 1 張 24GB GPU(如 RTX 4090 / A5000)+ 量化(例如 4-bit)
    • 或 2 張 16GB 以上多卡,使用 tensor parallel(如 vLLMTGI 支援)。
    • CPU-only:可以,但速度會很慢,只適合測試 API,不適合作 coding 時的即時補全。

    💡 關鍵: 若有 24GB 級 GPU 搭配 4-bit 量化,就能在單機上實現接近雲端 Copilot 的流暢體驗。

    只有一張小顯卡怎麼量化部署?

    如果你只有 12GB / 16GB 等級的顯卡,可以這樣做:

    1. 使用量化權重:在 Hugging Face 上搜尋是否有 North Mini Code 的 GPTQGGUFAWQ 版本。
    2. Ollama / llama.cpp 類工具載入 GGUF
    3. 例如:
      bash
      ollama create north-mini-code -f Modelfile
      # Modelfile 內容需指向 CohereLabs 的 GGUF 權重
    4. 再用 ollama serve + ollama run north-mini-code 來提供本地服務。
    5. 降低 context 長度與 batch size:在 vLLM / TGI 設定裡調低 max_tokens / max_seq_len 與 batch,換取顯存空間。

    如果你的顯卡只有 8GB:

    • 建議作為 離線工具 使用(例如一次性重構 / 安全掃描),不要期待「即時 Copilot 感受」。
    • 或改把模型部署在公司內部一台較大的伺服器上,自己本機透過 VPN 或內網連線使用。

    行動目標:確認自己機器的 GPU 型號與顯存,選一套適合的部署方式:

    • ≥24GB:直接 vLLM + 4-bit 量化,當日常 Copilot。
    • 12–16GB:找量化權重 + 降 context,當「按需叫用」的 Agent。
    • 只有 CPU:拿來跑批次任務或試驗,工作時還是接遠端伺服器。

    總結

    如果你:

    • 不想再冒險把私有程式碼丟到雲端,
    • 不想被單一 Copilot / API 鎖死,
    • 又想要一顆可以放進自己 workflow 裡的程式碼 Agent 大腦,

    那麼 Cohere North Mini Code 提供了:開源授權、針對程式碼與 Agent 工作流優化、可在本地或私有雲部署的折衷選項。從 Hugging Face 線上試用,到接進 IDE,再到自動產生 PR 的完整 Agent,你可以一步步把它變成你團隊自己的「內建 Copilot」。

    🚀 你現在可以做的事

    • 到 Hugging Face 下載或在線試用 CohereLabs/North-Mini-Code-1.0,用你的主力語言丟 3 段程式碼測試
    • vLLMTGI 在一台有 GPU 的機器上跑起來,並用 FastAPI 包成 OpenAI-style API 接到 Cursor / VSCode
    • 選一個小專案,實作「自動重構並產生 PR 草稿」的 Agent,搭配 SkillSpectoragentsview 做安全與使用監控
  • Lens 超輕量圖像生成實戰指南

    Lens 超輕量圖像生成實戰指南

    📌 本文重點

    • 小模型搭配高品質描述也能畫得好
    • Lens 完整開源,可在本機或雲端部署
    • 用 GPT 先整理資料,可微調出專屬圖像模型
    • 先用 Demo 試 prompt,再決定是否自建 API

    用一台普通筆電就能跑的開源圖像模型 Lens,把「小模型也能畫得好」這件事變成現實,適合想在本機或雲端快速搭一個可用圖像生成系統的人。

    原始研究與開源專案可見 Microsoft Research 公告與程式碼倉庫(可從 The Decoder 報導 追蹤連結)。


    核心功能:小模型,靠好資料撐起來

    1. 3.8B 參數也能畫出細節圖

    Lens 的參數量只有約 38 億,比主流閉源大模型小很多,但在多個圖像生成基準測試中,成績可以追上甚至超過體型更大的模型。關鍵不是「堆參數」,而是訓練資料:

    • 使用約 8 億筆、由 GPT‑4.1 產生的高品質圖像描述
    • 描述內容細到「光源方向、鏡頭焦段、材質、構圖」,不是只寫「一隻貓坐在桌子上」
    • 小模型可以在這些精準標註上更有效學習

    💡 關鍵: 約 38 億參數配上 8 億筆精準描述,證明小模型只要資料夠好,也能接近甚至超過大模型表現。

    你可以怎麼用這個優勢?

    在實際 prompt 時,多寫一點細節,Lens 特別吃「具體描述」:

    一個極簡風格的手機 App 圖標,白色背景,中間是扁平化的藍色雲朵,
    線條乾淨,無陰影,適合放在 iOS 主畫面。
    

    比起只寫「雲朵圖標」,具體描述會更接近 Lens 當初訓練時看到的高質量 caption,使輸出品質更穩定。


    2. 完整開源:程式碼 + 權重 + 資料流程

    Lens 的程式碼與模型權重開源,你可以:

    • 在本機部署,不經過第三方雲端
    • 在自己的伺服器上做內網圖像生成 API
    • 自行微調,適配特定風格(例如公司品牌視覺)

    可行動的做法

    • 把 Lens 當作「公司內部版 Midjourney」,搭配簡單前端頁面給同事用
    • 在產品原型工具(如 Figma 插件、內部 dashboard)後端接上 Lens API

    3. 訓練思路可複用:用 GPT 先把資料變好

    Lens 的另一個重點,是用 GPT‑4.1 先幫原始圖像資料寫出高品質描述,再拿來訓練。對個人或團隊來說,這給了很實際的路線:

    • 收集自家產品圖(例如鞋子、包包、介面截圖)
    • GPT‑4.x 幫每張圖生成細緻描述
    • 用這批資料微調 Lens,得到一個「專門懂你家產品」的圖像模型

    你可以馬上做的實驗

    1. 拿 50 張自家產品圖
    2. ChatGPT / Azure OpenAI 幫每張圖寫 3–4 句的超詳細描述
    3. 把這批圖 + 描述存成 JSON / CSV
    4. 未來如需微調 Lens,就已經有一批乾淨資料可以用

    💡 關鍵: 先用大型語言模型替資料加上高品質描述,可以顯著降低後續訓練或微調的成本,讓小模型也具備專領域能力。


    適合誰用:三個典型場景

    1. App 圖標與 UI 草圖

    需求:快速生出幾十款圖標概念,不想每次都手動畫。

    Lens 可以:

    • 輸出風格統一的 App 圖標草稿
    • 為不同功能模組快速生成 icon 系列

    範例 prompt

    為一款習慣追蹤 App 生成 4 個圖標提案:
    扁平化風格,柔和配色,每個圖標有明確象徵:
    打卡用打勾符號、番茄鐘用簡化的時鐘、
    統計用長條圖、個人設定用簡化人物輪廓。
    背景簡潔,適合 iOS 風格。
    

    2. 行銷素材:社群貼文、Banner 草圖

    需求:行銷團隊需要快速產出視覺草案,交給設計師再精修。

    Lens 可以:

    • 生成不同構圖的社群貼文底圖
    • 幫你先找到「方向」,再請設計師改

    實際使用方式:

    1. 將產品賣點寫成 2–3 句描述
    2. 指定風格(例如「韓系清新」、「科技感藍紫配」)
    3. 產出 5–10 張圖,挑 1–2 張給設計師重製

    3. 產品原型圖:硬體外觀、介面草稿

    需求:先有一組「看得懂」的圖,再進行工業設計或 UI 設計。

    Lens 可以:

    • 幫你畫出不同外型的裝置草案(例如智慧音箱、耳機)
    • 幫 App 原型搭配大致配色與版型

    範例 prompt

    一款家用智慧音箱的產品概念圖,
    圓柱形機身,霧面白色塑膠材質,上半部有細密圓孔,
    底部有一圈柔和的 LED 光環,放在木質桌面上,
    整體風格偏向北歐極簡風。
    

    怎麼開始:最低摩擦上手路線

    路線 1:完全不寫程式,先用 Hugging Face Demo Space

    如果你只是想試看畫得如何,最簡單是使用 Hugging Face 上的 Demo(搜尋「Lens text-to-image」即可,或從 The Decoder 報導頁面 追過去)。

    步驟:

    1. 開啟 Demo Space 頁面
    2. 在文字框輸入中文或英文 prompt
    3. 選擇解析度與步數(預設即可)
    4. 點擊 Generate

    適合:

    • 行銷或產品同事想先測試效果
    • 還沒有決定要不要自己部署

    小技巧

    • 先用 Demo 找到你喜歡的 prompt 模板
    • 再複製這些 prompt 到你自己的部署裡使用

    路線 2:會寫程式,用 Transformers 建自己的圖像生成 API

    如果你熟悉 Python,建議直接用 Hugging Face Transformers 在本機或雲端跑 Lens,幾行程式碼就能得到一個可呼叫的 API

    以下假設你已安裝 Python 3.10+

    1. 安裝必要套件

    pip install torch torchvision --index-url https://download.pytorch.org/whl/cpu
    pip install transformers accelerate safetensors
    

    如果你有 NVIDIA GPU,可改用官方 CUDA 版 PyTorch 安裝指令。

    2. 下載並載入 Lens 模型

    Transformers 為例(假設模型名稱為 microsoft/lens-3.8b,實際名稱請依 Hugging Face Hub 為準):

    from transformers import AutoTokenizer, AutoModelForCausalLM
    import torch
    
    model_id = "microsoft/lens-3.8b"
    
    tokenizer = AutoTokenizer.from_pretrained(model_id)
    model = AutoModelForCausalLM.from_pretrained(
        model_id,
        torch_dtype=torch.float16,
        device_map="auto"
    )
    
    prompt = "a minimal blue and white app icon of a cloud on a white background, flat design, no shadows"
    inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
    
    with torch.no_grad():
        outputs = model.generate(**inputs, max_new_tokens=256)
    
    # 假設模型會輸出圖像 latent,再解碼成圖片
    # 這部分請依官方範例加入解碼步驟
    

    因為 Lens 是影像模型,實際程式碼會包含「文字 -> 影像 latent -> 圖檔」三階段;建議直接參考官方 repoinference.py 或示範 notebook,把其中的 inference 函數包一層 API

    3. 快速包一個本機 API(Flask 範例)

    from flask import Flask, request, send_file
    from io import BytesIO
    
    app = Flask(__name__)
    
    @app.post("/generate")
    def generate():
        data = request.get_json()
        prompt = data.get("prompt", "")
        # 呼叫 Lens 推理函數,回傳 PIL Image
        image = run_lens(prompt)
    
        buf = BytesIO()
        image.save(buf, format="PNG")
        buf.seek(0)
        return send_file(buf, mimetype="image/png")
    
    if __name__ == "__main__":
        app.run(host="0.0.0.0", port=8000)
    

    有了這個 API,你就可以:

    • 在前端或 no-code 工具(如 Bubble、Retool)裡直接呼叫
    • CI pipeline 裡自動生成 demo 圖像

    💡 關鍵: 先用 Hugging Face Demo 測試,再用短短數十行程式碼包成 API,可以在普通硬體上快速搭起團隊可用的圖像生成服務。


    最低摩擦指南:你現在可以做什麼

    1. 先用 Hugging Face Demo 試出一組好用 prompt
    2. 各準備一組 App 圖標、行銷素材、產品原型的 prompt 模板
    3. 決定部署路線
    4. 只需要偶爾用 → 繼續用 Demo
    5. 團隊要每天用 → 自己在雲端或本機起一個 Lens API
    6. prompt 模板寫進文件
    7. 給團隊共用,確保風格一致

    Lens 的真正價值,不只是「輕量」這一點,而是用高品質 GPT‑4.1 描述資料換來的「小而準」行為。只要你願意在描述上多花一點心思,就能在普通硬體上,得到足夠好用的圖像生成系統。

    🚀 你現在可以做的事

    • 打開 Hugging Face 搜尋「Lens text-to-image」,實際輸入 3 組 prompt 測試效果
    • 在一台開發機上依照文中步驟安裝 Transformers,跑通一個簡單的 Lens API
    • 收集 20–50 張自家產品圖,配合 GPT‑4.x 產生描述,準備未來微調用的資料集