標籤: 免費 AI 工具推薦

  • Needle:把工具調用 Agent 塞進手機

    Needle:把工具調用 Agent 塞進手機

    📌 本文重點

    • Needle 是專門負責工具選擇與參數填充的小型中控模型
    • 能在手機級硬體離線、高吞吐運行,降低雲端大模型成本
    • 最適合當工具路由器 / 前置規劃器,輸出穩定 JSON 給其他系統

    Needle 就是一顆專門幫大模型「只負責選工具、組參數、吐 JSON」的超小中控腦,讓工具調用 Agent 能在手機級硬體離線或低延遲運作。

    原始專案在 GitHub:https://github.com/cactus-compute/needle


    核心功能:專心當「工具路由中樞」的 26M 模型

    1. 26M 參數 + 純 Attention:為工具調用瘦身

    Needle 的設計很直接:

    • 只有約 2600 萬參數(26M),比動輒數十億參數的聊天模型小一到兩個數量級。
    • 結構是 Simple Attention Network:只有 attention + gating,沒有 MLP/FFN 層。
    • 目標任務只有一件事:
    • 讀取指令 + 工具列表描述
    • 選擇要用哪個工具(或多個)
    • 從指令中抽出參數
    • 輸出工具調用 JSON

    💡 關鍵: 只有約 2600 萬參數的 Needle,能在極小成本下專門負責工具路由與參數抽取,是取代通用大模型做 function calling 決策的關鍵。

    這代表你的行動步驟是:

    • 如果你現在是用 GPT / Gemini / Claude 來做工具決策(例如 function calling),可以把「決定用什麼工具」這一步改交給 Needle,減少大模型 token 消耗與延遲。

    2. 專門為工具調用預訓與微調

    Needle 的訓練重點不是聊天對話,而是「工具使用」:

    • 先在 200 億 token 上預訓練語言能力。
    • 再用約 20 億條合成函數調用資料微調,來源是模擬 Gemini style 工具(例如鬧鐘、導航、日曆、筆記等)。

    💡 關鍵: 針對 20 億條函數調用資料微調,讓 Needle 在工具選擇與參數解析上比同尺寸聊天模型穩定得多。

    實際上,它不負責長篇推理,而是非常擅長:

    • 從口語指令中抓出結構化欄位(時間、地點、標題…)。
    • 在多個工具之間做正確匹配。
    • 輸出符合 schema 的 JSON 給你直接丟進 API。

    行動建議:

    • 如果你已經有一組工具 schema(例如 OpenAPI、function calling 定義),可以直接拿來給 Needle,讓它幫你產生調用 payload,再由你自己的程式實際發 API。

    3. 手機級硬體也能跑的高吞吐

    作者實測在「消費級裝置」可達:

    • 6000 tok/s prefill
    • 1200 tok/s decode

    💡 關鍵: 在一般消費級裝置上就能達到 6000 tok/s prefill、1200 tok/s decode,讓 Needle 可以長駐於手機與邊緣設備當本地 Agent 大腦。

    翻成白話:

    • 放在中階手機、平板、開發板(如樹莓派級別 SoC)上,當離線工具路由器是可行的。
    • 可以把 Needle 當作 永遠常駐的本地 Agent 大腦,大模型只在真正需要複雜推理/生成時才被叫起。

    行動建議:

    • 如果你正在做行動 App 或智慧硬體(耳機、車機、家電),可以先用 Laptop 上測試 Needle 的工具選擇邏輯,再評估移植到裝置端做本地推理。

    適合誰用:三種典型場景

    1. 行動裝置上的離線 / 低延遲 Agent

    典型案例:

    • 「早上 7 點幫我叫醒,順便播固定歌單」→ Needle 決定:set_alarm + play_playlist
    • 「開車回家,避開高速公路」→ Needle 決定:navigate,並填好目的地與偏好
    • 「幫我記一條:明天 meeting 要問預算」→ Needle 決定:create_note,抽出時間與內容

    做法:

    • 語音 → 本地 ASR(或雲端 Transcription)
    • 文字指令 + 工具列表 → Needle → 工具 JSON
    • 裝置端程式依 JSON 實際調起鬧鐘、導航、筆記 App

    適合:行動 App 團隊、智慧手錶 / 車機 / AR 眼鏡、想要弱網路或離線也能用的指令助手

    2. 雲端大模型前面加一層「本地工具路由器」

    你可能遇過這種成本問題:

    • 每個使用者點一個按鈕,就丟完整上下文給 GPT 讓它幫你:
    • 看要不要查資料庫
    • 看要不要 call search API
    • 看要不要調 CRM
    • 結果大部分情況都只是在查一個欄位,卻要跑一整輪大模型推理。

    用 Needle 可以:

    • 由 Needle 先判斷:這次是否需要工具?用哪個?
    • 只有當需要長推理 / 文本生成時,才叫雲端 LLM

    這樣能直接對應到多代理系統常被提到的「orchestration tax」問題:減少不必要的 LLM orchestration 回合數。

    適合:SaaS 後端、API 產品、任何大量使用 function calling 的服務,希望降成本 + 降延遲

    3. MCP / Function Calling 之前的一層「前置規劃器」

    如果你已經在用:

    • OpenAI / Gemini / ClaudeTool Use / Function Calling
    • 或是某種 MCP(Multi-Channel Prompting 或 Model Context Protocol)架構

    Needle 可以扮演:

    • 用戶輸入 → Needle 選擇:
    • 要走哪一條 MCP channel
    • 要用哪個 Function / Tool
    • 再把整理好的工具調用意圖,交給聊天模型做:
    • 實際回應文案
    • 或進一步分解子任務

    差別在於:

    • 一般微型聊天模型:
    • 會嘗試「理解+回答+決定工具」,但在複雜工具 schema 上容易出錯或 hallucinate。
    • Needle:
    • 不負責聊天,只專注在「選工具+填參數+吐 JSON」。

    適合:已經有多工具、多 Agent 架構的團隊,需要一個可控、可本地跑的規劃器 / 路由器


    Needle vs 一般微型聊天模型

    名稱 核心功能 免費方案 適合誰
    Needle 工具選擇+參數抽取+輸出 JSON 完全開源,自架 行動 App、硬體端、本地 Agent
    微型聊天模型 閒聊、簡單問答 多數可免費測試 想要基本對話、不重工具調用的人

    關鍵差異:

    • Needle 的輸出預期是結構化工具調用,不是自然語言回答。
    • 在工具 schema 清楚的情況下,Needle 通常比同尺寸聊天模型更穩定地填參數、遵守格式。

    行動建議:

    • 若你只需要「會聊天」:選一般微型聊天模型。
    • 若你需要「穩定地依 schema 呼叫工具」:可以試 Needle 當前置規劃器,再用大模型生成回覆文案。

    怎麼開始:從 clone Repo 到跑出第一個工具調用

    1. 抓下專案與模型

    # 1. clone repo
    git clone https://github.com/cactus-compute/needle.git
    cd needle
    
    # 2. 建議先建立虛擬環境
    python -m venv .venv
    source .venv/bin/activate  # Windows 用 .venv\Scripts\activate
    
    # 3. 安裝依賴
    pip install -r requirements.txt
    

    模型本體會在首次推理時自動下載(或依 README 指示手動下載權重)。

    2. 用現成推理腳本跑官方 demo

    Repo 裡提供了簡單的推理範例(實際檔名可能隨版本變動,可在 examples/ 或 README 中找到):

    python examples/simple_tool_calling.py
    

    通常你需要提供:

    • 工具 schema(JSON / Python dict)
    • 使用者指令文字

    腳本會回傳一段包含工具名稱與參數的 JSON,確認能跑通是第一步。

    行動建議:

    • 先照官方 demo 跑一遍,不改任何 schema,只看 Needle 如何選工具。

    3. 定義自己的工具 schema

    假設你要做一個簡單的鬧鐘 + 記事 Agent,可以這樣定義工具(示意):

    tools = [
      {
        "name": "set_alarm",
        "description": "設定鬧鐘時間(24 小時制)",
        "parameters": {
          "type": "object",
          "properties": {
            "time": {"type": "string", "description": "例如 07:30"},
            "label": {"type": "string", "description": "鬧鐘備註"}
          },
          "required": ["time"]
        }
      },
      {
        "name": "create_note",
        "description": "建立一則文字筆記",
        "parameters": {
          "type": "object",
          "properties": {
            "title": {"type": "string"},
            "content": {"type": "string"}
          },
          "required": ["content"]
        }
      }
    ]
    

    接著丟給 Needle:

    from needle import NeedleModel
    
    model = NeedleModel.from_pretrained("cactus/needle-base")
    
    user_query = "明天早上七點叫我起床,順便幫我記:早會要問預算"
    
    result = model.route_tools(query=user_query, tools=tools)
    print(result)
    

    預期會拿到類似:

    [
      {
        "tool": "set_alarm",
        "arguments": {"time": "07:00", "label": "早會"}
      },
      {
        "tool": "create_note",
        "arguments": {"title": "早會", "content": "早會要問預算"}
      }
    ]
    

    接下來只要用你熟悉的語言(Swift / Kotlin / Node / Python),依這個 JSON 實際呼叫 OS API 或雲端 API 即可。

    4. 把 Needle 接在現有 LLM 後面,做一條簡單 workflow

    以下是一條最小可行的 workflow(伪碼):

    1. 語音 → 文字
    2. 行動裝置用本地或雲端 ASR:
    3. speech.wav -> transcript = "幫我找台北明天不下雨的戶外咖啡廳"

    4. Needle 選工具

    5. 工具例:search_weather, search_places 兩個 API。
    6. needle.route_tools(transcript, tools) → 回傳要先查天氣再查地點的參數 JSON。

    7. 實際 API 呼叫

    8. 你的後端或 App 依 Needle 給的 JSON,分別呼叫天氣 API、地點 API,整理出可用候選。

    9. 大模型生成回覆(可選)

    10. 把 API 結果 + 原始指令送給 GPT / Gemini / Claude,只讓它負責自然語言回覆:「幫你找到三間明天不預測下雨的咖啡廳…」。

    這種分工方式:

    • Needle:做工具決策+參數解析
    • LLM:只在真正需要「說人話」的最後一步出現

    能同時達到:成本可控、延遲更低、邊緣裝置也能預先處理大量決策。


    適合誰現在就試用 Needle?

    • 行動 App 開發者:想做語音指令、快捷操作、離線助手,又不想每次都打雲端 LLM。
    • 硬體產品團隊:智慧手錶、車機、家電、AR 眼鏡,需要一顆小而穩定的本地「工具路由中樞」。
    • 個人自架 Agent 系統玩家:已經有多工具、多 Agent,正在煩惱 orchestration 成本和延遲的人。

    只要你場景的核心在「選工具+填參數」,而不是長篇聊天,Needle 值得你花一個下午跑起 demo,直接把它塞到你的 workflow 裡測一次。更多細節與最新腳本可以在 GitHub 查看:https://github.com/cactus-compute/needle

    🚀 你現在可以做的事

    • 先 clone Needle 專案並跑一次官方 demo:git clone https://github.com/cactus-compute/needle.git
    • 把你現有的 function calling / OpenAPI schema 丟給 Needle,觀察它產生的工具 JSON
    • 在一個實際專案裡,嘗試用 Needle 接在 ASR 和雲端 LLM 之間,實測延遲與成本差異
  • 用 goose AI Agent 開一隻全能小幫手

    用 goose AI Agent 開一隻全能小幫手

    📌 本文重點

    • goose 是用 Rust 寫的開源 AI Agent 框架
    • 讓 LLM 真的能跑指令、改檔案、寫測試而不只聊天
    • 可接任意 LLM,並透過 workflow 自動化多步驟任務
    • 很適合 DevOps / 開發者做日常開發與部署自動化

    用一句話說清楚:goose 是一個用 Rust 寫的開源 AI Agent 框架,可以讓 LLM 不只聊天,而是真的幫你在電腦上安裝套件、跑指令、改程式碼、寫測試,變成一個可以自動執行任務的「全能小幫手」。

    GitHub 專案:https://github.com/aaif-goose/goose


    goose 和一般聊天機器人有什麼不同?

    一般 ChatGPT / Claude 類工具,多半停在「給你建議」:

    • 產生程式碼片段
    • 幫你想測試案例
    • 告訴你下一步可以怎麼做

    goose 的差別在於:它可以自己動手做。

    透過 goose,你可以讓模型:

    • 在你的環境裡 執行殼層指令(shell commands)
    • 直接修改專案檔案、重構程式碼
    • 跑測試、根據結果再修正
    • 用 plugin / tool 的形式接上你自己的 API 或腳本

    換句話說,它比較像一個「可編程的 AI 工具人」,而不是純聊天機器人。

    💡 關鍵: goose 不只回覆文字,而是能在你的實際環境中「讀檔案、下指令、改程式」,真正把建議變成動作。


    核心功能:你可以拿 goose 來做什麼?

    1. 調用殼層指令:讓 LLM 幫你按命令行上的按鈕

    goose 內建「可以執行 shell 指令」的能力。

    你可以叫 agent 做這些事:

    • 安裝套件:apt-get, brew, pip, cargo
    • 拉專案:git clone、切分支、pull 最新版
    • 跑工具:npm testcargo testpytestmake build

    你要做的行動:

    • 想一件你平常常打的一串指令(例如部署前要跑的 3–5 個步驟)
    • 把它寫成一句自然語言任務,交給 goose,觀察它如何自己拆解並下指令

    2. 程式碼編輯與測試:真的會改你專案的那種

    goose 支援對檔案系統操作,讓 LLM 直接:

    • 開啟 / 讀取專案中的檔案
    • 修改檔案內容(插入、刪除、重構)
    • 新增測試檔、更新 README

    常見用法:

    • 讓 agent 自動幫你 加 log / exception handling
    • 要它針對某個 module 補齊單元測試
    • 改 config、更新版本號、調整 CI 設定檔

    你要做的行動:

    • 選一個「可以放心被 AI 改壞」的小 side project
    • 用 goose 給它一個任務,例如:「在這個 Rust 專案裡,新增一個 health check endpoint,並幫我補上測試」

    3. 自訂工具擴充:把你自己的腳本、API 變成 agent 的能力

    goose 的設計重點是 「可擴充的工具」。你可以:

    • 把現有的 Python / Bash 腳本包裝成一個 tool
    • 把團隊內部 API(如 issue tracker、部署服務)接進來
    • 讓 agent 用「呼叫工具」的方式,連續完成更複雜的流程

    實際效果:

    • LLM 不用自己「想像」怎麼部署,而是呼叫你提供的 deploy_api
    • 你可以限制它只能用你認可的工具,控制風險

    你要做的行動:

    • 列出你工作中最常手動跑的 2–3 個腳本
    • 想像它們如果變成一個 deploy_service / create_release 的工具,agent 可以怎麼自動串起來

    4. 接任意 LLM:OpenAI、DeepSeek、本地模型都行

    goose 標榜 「with any LLM」,實際上就是可以在設定中自由切換 backend:

    • OpenAI(如 gpt-4.1
    • DeepSeek API(如 deepseek-coder
    • 透過 OpenAI-compatible API 的本地模型(Ollama、LM Studio…)

    這讓你可以:

    • 開發時用免費 / 便宜模型測試流程
    • 上線到正式環境時再換成更穩定的雲端模型

    你要做的行動:

    • 先挑一個你現有就有 API Key 的 LLM(例如 OpenAI 或 DeepSeek)
    • 決定:
    • 「實驗階段」用哪個模型
    • 「正式跑自動化」時要不要升級到較貴的模型

    💡 關鍵: 透過切換 GOOSE_MODEL 等設定,你可以在成本(本地 / 便宜模型)與效果(雲端高階模型)之間彈性取捨。


    適合誰用?三種典型場景

    1. DevOps/SRE:日常腳本自動化

    例如:

    • 部署前:拉最新程式碼 → 跑測試 → build → health check
    • 緊急修補:切 branch → 套 patch → 跑 smoke test → 發一版 hotfix

    用 goose 的做法:

    • 把這些步驟包成一個「任務腳本」(workflow)
    • 讓 agent 自己決定下一步要跑哪個指令、根據輸出結果調整

    2. 開發者:專案 boilerplate 生成與重構

    適用情境:

    • 開一個新服務:想要快速產生「專案骨架 + 基本路由 + CI 檔案」
    • 老專案:想系統性把某種寫法換成新的 pattern

    用 goose 可以這樣玩:

    • 指定專案資料夾給 agent
    • 給一個任務:「初始化一個 NestJS API 專案,幫我加上 Dockerfile 和 GitHub Actions CI」

    3. 團隊工程流程:CI 前自動檢查與修修補補

    在 CI 跑之前,先讓 goose 幫你:

    • 檢查程式格式、lint 問題
    • 嘗試自動修正簡單的錯誤
    • 對 PR 產生簡短變更說明

    做法:

    • 在 CI pipeline 裡加入「goose agent 步驟」
    • 給它權限在 CI runner 上修改檔案並 push(或開新 PR)

    💡 關鍵: 把 goose 放進 CI / pre-commit,可以在錯誤進到主線分支之前,自動完成一輪整理與簡單修補。


    怎麼開始:最快速的上手路徑

    1. 用 Docker 跑起官方範例(最快測試)

    前提:

    • 已安裝 Docker
    • 手邊有一個 LLM API Key(例:OPENAI_API_KEY

    步驟:

    # 1. 拉專案
    git clone https://github.com/aaif-goose/goose.git
    cd goose
    
    # 2. 建一個 .env,放你的模型設定(簡化示意)
    cat << 'EOF' > .env
    OPENAI_API_KEY=your_key_here
    GOOSE_MODEL=openai/gpt-4.1
    EOF
    
    # 3. 用 docker compose 跑起來(實際以 repo 裡的 compose 指令為準)
    docker compose up --build
    

    跑起來後,通常會有:

    • 一個 CLI / HTTP 介面
    • 你可以丟:
    • 「在這個容器裡安裝 curl 並測試對 google.com 發送請求」

    行動建議:先在容器內做「無害」的事情,例如安裝一個套件、建立一個測試檔案,確認 goose 真的有在動你環境。


    2. 本機安裝(Rust 使用者)

    前提:

    • Rust toolchain(rustup

    步驟:

    # 1. 安裝依賴
    cargo install --path .  # 實際請以 README 為準
    
    # 2. 設定環境變數
    export OPENAI_API_KEY=your_key_here
    export GOOSE_MODEL=openai/gpt-4.1
    
    # 3. 跑 CLI
    goose run
    

    你可以在終端機裡對 agent 下指令,例如:

    • 「列出目前資料夾的檔案,幫我找出所有含有 TODO 的檔案並列出行號」

    3. 接上常見模型(OpenAI / DeepSeek / 本地 LLM)

    以下是假設性的設定方向(實際請對照 goose README):

    OpenAI

    export OPENAI_API_KEY=your_key
    export GOOSE_MODEL=openai/gpt-4.1
    

    DeepSeek

    通常會提供 OpenAI 相容 API:

    export OPENAI_BASE_URL=https://api.deepseek.com/v1
    export OPENAI_API_KEY=your_deepseek_key
    export GOOSE_MODEL=deepseek-chat
    

    本地 LLM(以 Ollama 為例)

    啟動 Ollama 後:

    export OPENAI_BASE_URL=http://127.0.0.1:11434/v1
    export OPENAI_API_KEY=dummy
    export GOOSE_MODEL=ollama/llama3.1
    

    行動建議:先用最簡單、你現在就有的 API Key 接上,確認 goose 的流程跑得通,再考慮搬到本地模型節省成本。


    寫一個自己的「任務腳本」:讓 agent 連續完成幾個步驟

    goose 的強項在於可以定義「多步驟任務」。概念上,你會有一個 workflow 設定(格式依官方為準,這裡用 pseudo-code 示意):

    # workflows/dev_check.toml
    name = "dev_precommit_check"
    
    [[steps]]
    type = "shell"
    command = "git status"
    
    [[steps]]
    type = "agent"
    prompt = "閱讀 git status,決定要先格式化哪一些檔案,並執行對應指令。"
    
    [[steps]]
    type = "shell"
    command = "cargo test"
    
    [[steps]]
    type = "agent"
    prompt = "根據測試結果,如果有簡單錯誤可以直接修,並再次執行對應測試。"
    

    用法:

    goose run-workflow workflows/dev_check.toml
    

    這樣,你可以一行命令啟動一個「會看情況調整動作」的前置檢查流程。

    你要做的行動:

    • 先定義一個超簡單的 workflow:
    • Step1:ls 專案
    • Step2:請 agent 根據專案結構生成一段簡短說明,寫入 PROJECT_SUMMARY.md

    實戰:從零做一個小型自動化 workflow

    目標:在一個現有專案裡,做「提交前自動整理 + 簡單修補」流程。

    我們要達成:

    1. 檢查目前分支變更檔案
    2. 對變更檔案跑 formatter / linter
    3. 如果有明顯錯誤,由 agent 嘗試自動修改
    4. 重新跑測試

    Step 1:準備專案與權限

    1. 找一個你熟悉、可以接受被改動的專案資料夾
    2. 新開一個分支,如 feat/goose-auto-fix
    3. 確保 goose 有權限:
    4. 讀寫這個資料夾
    5. 執行必要的指令(例:npm testcargo test

    Step 2:定義 workflow(示意)

    依 goose 支援的格式建立一個 workflow 檔(假設是 YAML):

    name: precommit-helper
    steps:
      - type: shell
        command: git diff --name-only
      - type: agent
        prompt: |
          你看到的是目前分支有變更的檔案清單。
          目標:
          1. 對這些檔案執行合適的 formatter / linter 指令(依照檔案類型判斷)。
          2. 若 formatter/linter 回報可自動修復的問題,請修改檔案並重新執行檢查。
      - type: shell
        command: npm test  # 或你專案的測試指令
      - type: agent
        prompt: |
          根據測試輸出,
          - 若是小型邏輯/型別錯誤,嘗試修改相關檔案後再次執行測試。
          - 若錯誤較複雜,請產生簡短說明寫入 precommit_report.md。
    

    Step 3:實際執行與調整

    1. 在專案根目錄跑:

    bash
    goose run-workflow precommit-helper.yaml

    1. 觀察它的行為:
    2. 有沒有亂跑你不想要的指令?
    3. 修改的檔案是否合理?

    4. 根據結果調整:

    5. 限制能用的指令範圍(例如只允許 npm test, npm run lint
    6. 在 prompt 裡多加一些「安全護欄」,例如「不要刪除檔案」。

    完成後,你就有了一個:

    • 可以在提交前幫你「整理 + 修補 + 產生報告」的小型 AI 助理
    • 海豚式改進:遇到痛點就稍微改一下 workflow / 工具清單,越用越貼近你團隊習慣

    小結:下一步可以怎麼玩?

    如果你看到這裡,建議接下來這樣走:

    1. 先跑官方範例容器一次,確認 goose 在你機器上可以正常跑指令。
    2. 選一個專案資料夾,做一個超小 workflow:只做檔案摘要或自動補 README。
    3. 把你現有的一個腳本包成 tool,讓 agent 可以呼叫(例如部署或打包腳本)。
    4. 等你有信心後,再把它接進 CI / pre-commit 流程。

    完整專案與最新用法請看:https://github.com/aaif-goose/goose

    把 goose 想成一個「可編程的 ChatGPT + 指令列機器人」,先從最小、風險最低的自動化開始,你會很快找到適合自己工作流的用法。

    🚀 你現在可以做的事

    • 打開 <https://github.com/aaif-goose/goose>,用 Docker 照著 README 跑一次官方範例
    • 選一個 side project,讓 goose 幫你完成「新增一個 endpoint + 補上測試」的小任務
    • 把日常最常用的一個部署或檢查腳本包成 tool,寫一個只包含 2–3 個步驟的簡單 workflow
  • TrendRadar:一句話問清今天網路在吵什麼

    TrendRadar:一句話問清今天網路在吵什麼

    📌 本文重點

    • TrendRadar 幫你每天自動整理「值得在意的事」
    • 透過多平台聚合 + AI 翻譯與情感分析過濾雜訊
    • 可與 ChatGPT/Claude 分工整合,從監控到決策一條龍
    • 開源專案,支援 Docker 快速自架部署

    每天打開社群、新聞、論壇一堆訊息轟炸,TrendRadar 的用途只有一個:幫你先把「今天值得在意的事」整理好,讓你用一句話就能問清楚今天網路在吵什麼。

    專案連結:https://github.com/sansan0/TrendRadar


    核心功能:把資訊過濾、翻譯、分析到位


    1. 多平台聚合:RSS + 關鍵字一次收攏

    TrendRadar 的第一步,就是幫你「收集」:

    • 支援 RSS 訂閱:新聞網站、部落格、論壇,只要有 RSS 都能加
    • 支援多平台來源:可以接常見內容源(Twitter/X、Telegram 頻道、各類資訊流等,具體依你配置的 RSS 和接口而定)
    • 關鍵字篩選:只保留跟你在意的議題相關的內容

    你可以這樣實際操作:

    1. 列出你真的在乎的 3–5 個主題:
    2. 例:品牌名稱、競品名稱、關鍵技術(LLM、RAG)、產業關鍵詞(電商、SaaS、生成式 AI)
    3. 找到對應的 RSS 或資訊源:
    4. 媒體:TechCrunch、36kr、Inside、數位時代等
    5. 技術:Hacker News、Product Hunt、GitHub Trending
    6. 在 TrendRadar 的設定檔中,把 RSS URL 和關鍵字寫進去(下文有具體步驟)。

    💡 關鍵: 先選好 3–5 個核心主題,再讓系統自動過濾,能最大幅度減少你每天要處理的雜訊量。

    效果:每天系統自動幫你從海量資訊中,先過一輪「話題相關性」的篩選,你只看自己訂的幾條線。


    2. AI 翻譯 + 情感分析:跨語言、看氣氛

    TrendRadar 不是只推原文連結,而是會先用內建的 AI 分析:

    • 自動翻譯:把英文、日文等新聞翻成中文摘要
    • 情感分析:判斷內容情緒(正面 / 負面 / 中性)
    • 概要整理:用幾句話抓出重點

    具體可以怎麼用:

    • 品牌輿情:
    • 快速看今天關於你品牌的討論是偏正面還是負面
    • 先看 AI 摘要,再決定要不要點進原文細讀
    • 技術動態:
    • GitHub Trending 上出現的新專案,先用中文看懂做什麼
    • 挑出「跟你技術棧有關」且熱度在上升的專案

    實際行動:

    1. 在 TrendRadar 設定好要做情感分析的關鍵字(例如你的品牌名、產品名)。
    2. 啟用 AI 翻譯與摘要(專案中已預設支持,依 README 配好 API Key 或本地模型)。
    3. 每天在通訊工具裡看一眼「今日摘要」,不用再一篇篇翻。

    3. 多通訊工具推送 + MCP:變成你自己的「輿情機器人」

    TrendRadar 支援把整理過的結果,推送到你已經在用的工具:

    • 微信
    • 飛書
    • 釘釋
    • Telegram
    • Slack
    • Email / ntfy / Bark 等

    你可以把它當成一個「只會講重點的資訊機器人」,每天固定時間或有關鍵事件時推播給你。

    更關鍵的是:TrendRadar 支援 MCP(Model Context Protocol),可以讓它和你現有的 AI 助手(例如 ChatGPTClaude)整合:

    • TrendRadar 負責:收集、過濾、打標(情感、主題)
    • ChatGPT/Claude 負責:深度分析、寫彙整報告、產生回應草稿

    實際可做的 workflow:

    1. TrendRadar 把今天跟品牌相關的負面事件整理成一份 JSON / 簡報式摘要。
    2. 在支援 MCP 的 AI 助手中,呼叫 TrendRadar 工具:「請分析今天的負面輿情,幫我寫一份回應策略與 Q&A 草稿」。
    3. 得到可以直接丟給 PR 團隊修改的版本。

    💡 關鍵: 讓 TrendRadar 負責「聽與記錄」,AI 助手負責「想與表達」,能把你每天需要親自處理的工作壓到最低。


    適合誰用?三個具體場景


    1. 品牌輿情追蹤:先知道「今天有沒有燒起來」

    角色:行銷、公關、品牌經理。

    設定方式:

    • 關鍵字:品牌名、CEO 名字、產品名、常見錯別字
    • 來源:
    • 新聞 RSS(產業媒體 + 大眾媒體)
    • 論壇 / 社群聚合 RSS(若有)
    • 推送頻率:
    • 每天早上 9 點彙總
    • 一有高負面情感的內容就即時推送

    日常用法:

    • 在 Slack/微信 建一個 #brand-alert 群組,只放 TrendRadar。
    • 每天固定看一眼,看今天有沒有需要回應的聲音。
    • 把其中幾則交給 ChatGPT:
    • 「請用溫和但不卑不亢的語氣,回覆這篇負面評論,給出三種版本。」

    2. 競品 / 技術趨勢監控:避開資訊焦慮,只看真正相關的

    角色:產品經理、技術主管、創業者。

    設定方式:

    • 關鍵字:
    • 競品名稱 + 公司名
    • 技術關鍵字(如 RAGvector DBserverless LLM
    • 來源:
    • GitHub Trending(配合關鍵字過濾)
    • Product Hunt / Hacker News
    • 主要技術媒體 RSS

    日常用法:

    • 每天收到一份「競品 / 新技術」摘要:
    • 新發佈的功能 / 產品
    • 高熱度技術文章 / 專案
    • 再把摘要丟給 Claude:
    • 「整理成 5 點,說明這些變化對我們產品路線的影響,按緊急程度排序。」

    3. 內容創作者:每日素材雷達

    角色:寫 newsletter、拍 YouTube、寫部落格或社群的人。

    設定方式:

    • 關鍵字:
    • 你頻道聚焦的主題(AI 工具、遠端工作、投資、行銷等)
    • 來源:
    • 國外媒體 RSS
    • Twitter/X 清單轉 RSS(或間接服務)
    • 技術 / 產業部落格

    日常用法:

    • 每天早上收一份「今日 10 則值得寫的素材」,每則附:
    • 中文重點摘要
    • 推估情緒(這件事觀眾會興奮、焦慮、好奇?)
    • 把其中 1–2 則交給 ChatGPT:
    • 「幫我把這則趨勢寫成 5 條適合 IG / 小紅書的貼文金句。」

    TrendRadar + ChatGPT/Claude:兩工具分工實戰

    名稱 核心功能 免費方案 適合誰
    TrendRadar 多平台聚合、輿情監控、AI 摘要 開源,自架即免費 要持續監控品牌、競品、技術的人
    ChatGPT / Claude 深度分析、寫作、策略思考 有免費/試用方案 要把資訊變成企劃、回應、內容的人

    建議分工:

    • TrendRadar:
    • 24 小時自動收集與過濾
    • 做第一層翻譯、情感分析、摘要
    • ChatGPT/Claude:
    • 根據 TrendRadar 產出的內容,做二次加工
    • 產生 PR 草稿、簡報大綱、內容腳本

    操作示例:

    1. 在 Slack 接收 TrendRadar 的每日報告。
    2. 把報告內容複製到 ChatGPT:
    3. 指令範例:「請依照這份 TrendRadar 摘要,幫我生成一頁簡報的大綱,分成『今天發生什麼』『為何重要』『我們該怎麼做』。」

    怎麼開始:用 Docker 快速拉起 TrendRadar

    TrendRadar 是開源專案,支援 Docker 部署,你可以在本機或雲端(例如自家伺服器、雲主機)跑起來。


    1. 基本前置:準備環境

    必備條件:

    • 已安裝 Docker(和 docker-compose,如果專案使用)
    • 一台可以長時間運作的機器(本機、NAS 或雲主機都可)

    實際行動:

    • 安裝 Docker:
    • macOS / Windows:安裝 Docker Desktop
    • Linux:依發行版安裝(Ubuntu 可用 apt install docker.io 等)

    2. 拉取專案並啟動服務

    以下為通用步驟,具體以官方 README 為準(https://github.com/sansan0/TrendRadar):

    # 1. 取得程式碼
    git clone https://github.com/sansan0/TrendRadar.git
    cd TrendRadar
    
    # 2. 建立環境設定(通常會有 .env.example 或 config 檔)
    cp .env.example .env
    # 編輯 .env,填入必要的 API Key(如翻譯 / LLM 模型)
    
    # 3. 使用 Docker 啟動
    docker compose up -d
    

    啟動後,可以依 README 提供的網址(通常是 http://localhost:xxxx)打開管理介面或 API。

    💡 關鍵: 利用 Docker 一次配置好環境,之後只需重啟服務即可持續運作與更新。


    3. 設定第一組關鍵字與訂閱來源

    實際配置方式會依專案版本稍有差異,大致流程如下:

    1. 打開 TrendRadar 設定頁或編輯配置檔(例如 config.yaml):
    2. 新增一個「監控主題」(如 brand_watchai_trend)。
    3. 在主題下設定:
      • keywords: 你要追的關鍵字列表
      • sources: RSS 或其他來源 URL 列表
    4. 設定推送渠道:
    5. 在設定檔中填入 Slack Webhook URL、Telegram bot token 或微信/飛書機器人配置。
    6. 指定這個主題要推送到哪個渠道、頻率(例如每 6 小時一次)。
    7. 重新啟動或重新載入配置:
    docker compose restart
    

    檢查:等 10–30 分鐘,看通訊工具裡是否開始收到 TrendRadar 的摘要訊息。


    用一句話開始:把 TrendRadar 當成你的「每日第一問」

    當 TrendRadar 跑起來之後,你可以把每天的第一件事,改成問 AI:

    「根據 TrendRadar 的資料,今天跟我品牌 / 產業最有關的三件事是什麼?幫我說給非技術同事聽。」

    TrendRadar 負責幫你把訊息世界「縮小成可理解的摘要」,再交給 ChatGPT 或 Claude 做深度分析,你只要把最後的洞察做決策、做內容,就能在資訊過載的世界裡,保留大腦給真正重要的事情。


    🚀 你現在可以做的事

    • 開啟 TrendRadar 專案頁:https://github.com/sansan0/TrendRadar,照 README 在本機用 Docker 跑起來
    • 列出你最在意的 3–5 個主題,設定第一組 keywords 和 RSS sources 做實驗
    • 在常用通訊工具(Slack、微信等)建立一個專用頻道,把 TrendRadar 摘要接進來,明天早上開始用它看「今天在吵什麼」
  • 用 Vercel Skills 把 AI 變成你的命令列工具箱

    用 Vercel Skills 把 AI 變成你的命令列工具箱

    📌 本文重點

    • Vercel Skills 把 AI Agent 打包成可安裝的 CLI 工具
    • 一行 npx skills 就能體驗預設技能並接到自動化流程
    • 每個 skill 可在不同專案與 CI/CD 中重複使用與串聯
    • 適合開發者、行銷、DevOps 做文字與流程自動化

    用一句話說清楚:Vercel Skills 讓你用一行 npx skills,把一整包 AI Agent 當成可安裝的命令列工具,快速接到你的開發與自動化流程裡。

    專案連結:vercel-labs/skills on GitHub


    核心功能:把「AI 能力」做成可重用的 Skill 模組

    1. 一行指令啟動預設技能:npx skills

    想先感受效果,不想碰程式碼,可以直接這樣做:

    npx skills@latest
    

    執行後會:

    • 問你要使用哪些預設技能(例如:文件總結、PR 說明、自動整理 issue 等)
    • 在終端機互動式詢問你輸入內容或指定檔案
    • 把 AI 結果輸出在終端機,必要時也會幫你生成檔案

    你可以把它當成「AI 強化版 CLI 工具集」,用一次就知道哪些任務適合被 AI 自動化。

    💡 關鍵: 一行 npx skills@latest 就能體驗整套預設 AI 技能,是評估哪些工作可以自動化的最快方式。


    2. 每個 skill 就是一個可複用的 Agent 模組

    在 Skills 的設計裡:

    • 一個 skill = 一件具體可自動化的工作
    • 例如:summarize-doc(總結文件)、pr-description(產生 PR 描述)、rewrite-copy(改寫文案)
    • 實作上:一個 skill 就是一個 TypeScript/Node.js 模組,負責:
    • 接收輸入(檔案路徑、文字、Git diff 等)
    • 呼叫 LLM(預設走 Vercel AI SDK,可接 OpenAI / Vercel 等)
    • 回傳結構化結果(可以寫回檔案、回傳 JSON、或印在 CLI)

    這種設計的好處是:

    • 你可以在不同專案重複使用同一個 skill
    • 一個專案裡可以組合多個 skill 變成「串聯流程」(例如:先用一個 skill 擷取重點,再用另一個 skill 生成測試案例)

    💡 關鍵: 把每個任務抽象成 skill 模組後,你可以在多個專案與流程中重複組裝同一套 AI 邏輯,維護成本更低。


    3. 兩種使用方式:CLI 與程式內呼叫

    你可以把 Skills 當成:

    1. 命令列工具(CLI):適合快速手動使用、寫腳本
    2. 例如:
      bash
      # 執行某個 skill
      npx skills run summarize-doc ./docs/api.md

    3. 程式內呼叫(Node.js / TypeScript):適合接到 CI/CD、背景工作、Bot

    4. 基本結構類似:
      “`ts
      import { runSkill } from “skills”;

      const result = await runSkill(“summarize-doc”, {
      path: “./docs/api.md”,
      });

      console.log(result.summary);
      “`

    這讓 Skills 不只是一個「玩具 CLI」,而是可以被真正嵌入系統裡的 AI 自動化模組。

    💡 關鍵: 同一個 skill 既能在 CLI 使用,也能在程式碼中透過 runSkill 呼叫,降低從實驗到正式上線的落差。


    適合誰用:幾個具體場景

    1. 開發者:減少重複性的開發瑣事

    可以嘗試這幾類 skill:

    • 自動產出 PR 描述
    • CI 裡加入:檢查 PR 的 diff,用 skill 生成清楚的變更說明
    • 好處:大家不再花時間想描述格式,Reviewer 一眼看完重點
    • 整理 issue / ticket
    • 拉取標題 + 描述,讓 skill 自動標記類型、估計複雜度、抽出待辦項目
    • 好處:產品、工程、PM 都看到一致結構的內容
    • 生成測試案例
    • 針對關鍵函式或 API 定義,讓 skill 幫你列出可能的測試情境
    • 再由你挑選重要的手動補完

    可以做的行動:

    • 先用 npx skills 跑一輪預設技能
    • 想想你專案裡最常被抱怨「麻煩但又必須做」的步驟,選 1 個先做成 skill

    2. 內容與行銷:批次改寫與整理文字

    如果你常做這些事,Skills 很適合:

    • 批次改寫文案
    • 輸入一批產品描述,統一改寫成:短版、長版、社群貼文版
    • 可以客製 skill:輸入 CSV / JSON,輸出同格式檔案
    • 整理長文件摘要
    • 對內部文件(產品規格、研究報告)做摘要 + 重點 bullet points
    • 適合接到定時腳本:每天把新文件丟給 skill,產出摘要寄到 Slack

    可以做的行動:

    • 先準備一個資料夾,放你常用的範本文案或長文
    • npx skills 裡的 summary / rewrite 類 skill 試一次,感受輸出品質

    3. DevOps / 自動化工程師:接到 CI/CD、排程腳本

    你可以把 Skills 當成「AI 版 shell script 函式庫」:

    • GitHub ActionsGitLab CI 裡:
    • Pull Request 建立時自動跑 npx skills run pr-description
    • Release 前跑一次 npx skills run summarize-changelog 整理修改內容
    • cron / 定時腳本 裡:
    • 每天抓 issue / log / 監控報表丟給某個 skill,整理成一份人類可讀的摘要

    可以做的行動:

    • 在現有 CI pipeline 裡挑一個步驟,加一個額外 job 試跑 Skills
    • 先只在非必要流程執行,觀察穩定度與輸出品質

    怎麼開始:從預設技能到自訂 skill

    1. 安裝與首次執行

    前置需求:

    • Node.js(建議 18+)
    • 一個可用的 LLM API(例如 OpenAI 或 Vercel AI)

    第一步:直接執行 CLI(免全域安裝):

    npx skills@latest
    

    依照互動式提示:

    1. 選擇或設定你的模型提供者(可能會要求設定 API key)
    2. 選擇一個想先試的 skill(例如 summarize / pr-description)
    3. 依照提示輸入文字、選檔或指定路徑

    這一步的目標:先確認環境 OK + 大概知道 skill 的輸出長什麼樣子。


    2. 看一個最簡單自訂 skill 的程式結構

    接下來你可以把專案 clone 下來:

    git clone https://github.com/vercel-labs/skills.git
    cd skills
    pnpm install # 或 npm / yarn
    

    假設你要做一個最簡單的「文案改寫」 skill,概念結構會像這樣(簡化示意):

    // ./skills/rewrite-copy/index.ts
    import { defineSkill } from "skills";
    import { generateText } from "ai-sdk"; // 具體以官方範例為準
    
    export default defineSkill({
      name: "rewrite-copy",
      description: "改寫一段文案,維持原意但更口語/正式。",
      inputs: {
        text: {
          type: "string",
          description: "要改寫的原始文案",
          required: true,
        },
        tone: {
          type: "string",
          description: "語氣:casual 或 formal",
          default: "casual",
        },
      },
      async run({ inputs, model }) {
        const prompt = `請用${inputs.tone} 語氣改寫以下文案,但保留原本資訊:\n\n${inputs.text}`;
    
        const result = await generateText({
          model,
          prompt,
        });
    
        return {
          rewritten: result.text,
        };
      },
    });
    

    接著,你可以在本地 CLI 裡直接呼叫:

    npx skills run rewrite-copy --text "原始文案內容" --tone casual
    

    這就是 Skills 的基本模式:

    1. defineSkill 宣告輸入/輸出與執行邏輯
    2. run 裡呼叫你喜歡的模型
    3. 回傳一個乾淨的結果物件,方便 CLI 或其他程式接

    3. 在你的專案裡以 API / CLI 串接

    有兩種常見方式:

    方式 A:在 CI / script 裡用 CLI

    以 GitHub Actions 為例,在 .github/workflows/pr-description.yml 加上:

    jobs:
      generate-pr-description:
        runs-on: ubuntu-latest
        steps:
          - uses: actions/checkout@v4
          - uses: actions/setup-node@v4
            with:
              node-version: 20
          - run: npx skills@latest run pr-description --diff "$(git diff origin/main)"
            env:
              OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
    

    這樣每次開 PR 就會自動產生一段描述,印在 log 或寫到你指定的地方。

    方式 B:在 Node.js 應用程式裡呼叫

    在你自己的專案中安裝:

    npm install skills
    

    然後在程式裡:

    import { runSkill } from "skills";
    
    async function summarizeDoc(path: string) {
      const result = await runSkill("summarize-doc", { path });
      return result.summary;
    }
    

    接著你可以:

    • 在後端 API 提供 /summaries endpoint
    • 在排程腳本裡定時呼叫
    • 在 Slack Bot 裡接指令呼叫

    把 Skills 放進你的「AI 自動化工具箱」的建議做法

    建議一日內可以完成的小目標:

    1. 先用 npx skills 跑三個預設技能:文件摘要、PR 描述、文案改寫
    2. 挑一個你每天都會做、卻很耗時間的文字相關工作,寫成一個最小版 skill
    3. 在你現在的 CI 或本地腳本裡,接入這個 skill(先只給自己用)
    4. 一週後觀察:
    5. 節省了哪些手動步驟?
    6. 哪些輸出需要調 prompt 或加後處理?

    只要跑完這一輪,你就等於有了一個可持續擴充的「AI 自動化工具箱」,之後每多一個 skill,就是少一個你自己要反覆做的瑣事。


    專案連結再附一次:https://github.com/vercel-labs/skills

    想像一下:未來你新增工具,不是寫一串 shell script,而是新增一個 skill,讓 AI 幫你處理掉更多「人做很累、AI 卻很擅長」的工作。

    🚀 你現在可以做的事

    • 在本機直接執行 npx skills@latest,跑一輪預設技能體驗輸出
    • git clone 官方專案並閱讀 skills 目錄下的範例,試著複製一個改成自己的 skill
    • 在一個現有 CI pipeline(如 GitHub Actions)中,加上一個使用 npx skills run pr-description 的非關鍵實驗步驟
  • 3 小時做出專屬雲端 AI 小幫手

    3 小時做出專屬雲端 AI 小幫手

    📌 本文重點

    • open-agents 是給前端工程師用的雲端 AI Agent 腳手架
    • 幫你處理好 Agent 架構、工具整合與雲端部署樣板
    • 3 小時內就能做出可上線、會調 API 的 AI 小幫手

    用一句話說清楚:Vercel 的開源專案 open-agents 是一套「前端工程師也能駕馭的雲端 AI Agent 腳手架」,幫你處理好架構、模型與工具整合,以及雲端部署樣板,3 小時內就能把一個可上線的 AI 小幫手跑起來。

    💡 關鍵: open-agents 把「3 小時內做出可上線 Agent」變成合理門檻,適合用來做快速 MVP 驗證。


    核心功能:open-agents 幫你省掉哪些麻煩?

    1. 標準化的 Agent 架構:不用自己設計「大腦」骨架

    在 open-agents 裡,你會碰到三個核心概念:

    • Agent:像「大腦」,負責看使用者輸入、決定要不要用工具、整理最後回答。
    • Tool:可以是 REST API、資料庫查詢、檔案讀寫等,Agent 可以選擇呼叫它們。
    • Memory:用來記住上下文或歷史對話,讓 Agent 回答更連貫。

    open-agents 做好的事:

    • 幫你定義好 Agent 的 TypeScript 介面與執行流程
    • 提供現成的 tool 呼叫機制(類似 OpenAI Agents SDK 的工具系統)
    • Memory 設計已經整合到框架中,不用自己處理 token 管理

    你可以做的行動

    • 把原本散落在專案裡的「AI 回答」「API 呼叫」邏輯收斂成一支 Agent
    • 把「查 FAQ」「查內部 API」「整理結果」交給同一個 Agent 流程,而不是寫一堆 if-else

    2. 工具 / 模型整合:一支 Agent 同時用多個 API

    open-agents 預設支援多家模型服務(含 OpenAI,對應最新的 Agents SDK 概念),也很容易接:

    • 便宜模型(例如 OpenAI 最新較低價型號)
    • 你現有的 REST API / GraphQL / 內部服務

    你只要:

    1. .env 放入 API Key(例如 OPENAI_API_KEY
    2. 在程式裡註冊工具,例如一個查訂單狀態的 REST API
    3. 把工具掛在 Agent 上,Agent 自己會決定何時呼叫

    你可以做的行動(兩個實用 workflow 範例):

    1. 客服 FAQ + 後端 API 查詢自動回覆 Bot
    2. FAQ:丟成向量資料或直接塞 prompt
    3. 工具:GET /orders/:id 查訂單,GET /user/:id 查會員
    4. Agent 邏輯:先看能不能從 FAQ 回答,不行再調 API,最後回傳整理好的訊息。

    5. 團隊內部文件檢索 + 任務整理助理

    6. Memory:保留本週的對話與任務
    7. 工具:一支「搜尋 Notion / Google Drive / 自家知識庫」的 API
    8. Agent:自動整理「這週待辦」「文件連結」,丟回 Slack/前端介面

    💡 關鍵: 一支 Agent 就能同時整合多個 API 和便宜模型,讓你用低成本做出實用的自動化工作流程。


    3. 雲端部署樣板:Next.js + Vercel 直接起飛

    open-agents 專案 本身就是一個可以部署到 Vercel 的樣板:

    • 內建 API routes,可以當成你的 Agent 後端
    • 前端可以用 Next.js / React 串同一支 Agent API
    • 與 Vercel 部署流程打通:GitHub 綁定 → 自動 CI/CD

    你可以做的行動

    • 先只改後端的 Agent + tool,保持前端 UI 簡單
    • 驗證 Agent 工作流程沒問題後,再慢慢優化 UI/權限

    適合誰用?幾個具體場景

    1. 前端工程師:想要一個「會用 API 的聊天小幫手」

    你手上可能已經有:

    • 一些 REST API(訂單、會員、專案、ticket…)
    • 一個 React/Next.js 專案

    只要把 open-agents 當成「AI 後端模板」,你就能做出:

    • 客服頁面裡的 FAQ + 訂單查詢 bot
    • 專案管理頁面的「自然語言查詢資料」側邊欄

    2. 團隊技術 owner:要做 MVP 的 AI 助理,但不想先上 MCP 這種大型架構

    根據「MCP for Backend Engineers」那篇文章的建議:

    1 app · 1 team · 1 toolset → 用簡單的 tool calling 就好,MCP 是 scaling 決策,不是起步點。

    如果你目前只有:

    • 一個 Web App
    • 一兩個後端服務

    那 open-agents 就剛好:

    • 架構不重,適合 MVP
    • 想擴展到多工具、多系統再慢慢抽象

    3. 產品/營運團隊身邊的「懂一點前端」的人

    只要會基本 TypeScript/React,照樣可以:

    • 改現有範例成「文件搜尋 + 任務整理」內部助手
    • 讓團隊先用起來,再決定要不要投入更多資源

    怎麼開始:3 小時完成「會調 API 的 AI 小助手」

    下面以「客服 FAQ + 訂單查詢 Bot」為例,走一次從 0 到可部署的流程。

    前提:你會基本 Git、Node.js、TypeScript,並有一個 GitHub 帳號。

    步驟 0:成本 & 免費方案心裡有底

    • open-agents 本身是免費開源
    • 模型費用:可使用 OpenAI 較低價模型,成本通常是每月幾美元起(視流量)
    • 部署:Vercel 有免費方案,適合開發 / 小流量 MVP

    💡 關鍵: 開源 + 便宜模型 + 免費部署方案,讓你可以「先上線再優化」,不必一開始就投入大量預算。


    步驟 1:從 GitHub 模板拉起專案

    1. 打開專案:https://github.com/vercel-labs/open-agents
    2. 點右上角 Use this template → Create a new repository
    3. 在自己的 GitHub 底下建立 repo
    4. 本機 clone:

    bash
    git clone https://github.com/<你的帳號>/<你的-repo>
    cd <你的-repo>
    pnpm install # 或 npm install / yarn

    1. 新增 .env.local,放入:

    bash
    OPENAI_API_KEY=sk-...

    此時行動pnpm dev 跑起來,確認預設的 Agent Demo 正常回覆。


    步驟 2:配置一個模型 + 建立簡單 REST Tool

    假設你要讓 Agent 查詢 GET https://api.example.com/orders/:id

    1. src/tools/orderTool.ts 新增:

    “`ts
    import { z } from “zod”;

    export const orderTool = {
    name: “get_order_status”,
    description: “根據訂單編號查詢訂單狀態”,
    parameters: z.object({
    orderId: z.string().describe(“訂單編號”)
    }),
    execute: async ({ orderId }: { orderId: string }) => {
    const res = await fetch(https://api.example.com/orders/${orderId});
    if (!res.ok) throw new Error(“查詢失敗”);
    const data = await res.json();
    return {
    status: data.status,
    items: data.items,
    total: data.total,
    };
    },
    };
    “`

    1. 在 Agent 定義中(例如 src/agents/supportAgent.ts),把這個 tool 加進去:

    “`ts
    import { createAgent } from “./baseAgent”;
    import { orderTool } from “../tools/orderTool”;

    export const supportAgent = createAgent({
    name: “support”,
    systemPrompt:
    “你是客服小幫手,先用 FAQ 回答,如果使用者提到訂單編號(像是 #12345),再用工具查詢訂單狀態,最後用中文整理回答。”,
    tools: [orderTool],
    });
    “`

    1. 模型設定通常在 baseAgent 或 config 檔裡(視專案結構),選一個便宜模型,例如:

    ts
    model: "gpt-4.1-mini" // 範例,視官方文件更新調整

    此時行動:在本機跑 server,從 Agent API 打一個 request,例如:

    「我有一筆訂單 #12345 ,請幫我看目前出貨狀態」

    觀察 log,確認 Agent 會:

    • 自動偵測訂單編號
    • 呼叫 get_order_status 工具
    • 整理成可讀中文回答

    步驟 3:接一個簡單前端(Next.js / React)

    如果你用 Next.js

    1. /app/api/chat/route.ts 建一個 API route,轉發到 supportAgent

    “`ts
    import { NextResponse } from “next/server”;
    import { supportAgent } from “@/agents/supportAgent”;

    export async function POST(req: Request) {
    const { message } = await req.json();
    const reply = await supportAgent.run({ input: message });
    return NextResponse.json({ reply });
    }
    “`

    1. 在前端頁面建一個最簡聊天 UI:

    “`tsx
    “use client”;
    import { useState } from “react”;

    export default function ChatPage() {
    const [input, setInput] = useState(“”);
    const [messages, setMessages] = useState([]);

     const send = async () => {
       const res = await fetch("/api/chat", {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({ message: input }),
       });
       const data = await res.json();
       setMessages((m) => [...m, `你:${input}`, `Bot:${data.reply}`]);
       setInput("");
     };
    
     return (
       <div>
         <div>{messages.map((m, i) => (
           <div key={i}>{m}</div>
         ))}</div>
         <input value={input} onChange={(e) => setInput(e.target.value)} />
         <button onClick={send}>送出</button>
       </div>
     );
    

    }
    “`

    此時行動:在本機 UI 輸入訂單問題,看是否能走完整流程「輸入問題 → Agent 決定要不要調 API → 回傳整理後答案」。


    步驟 4:一鍵部署到 Vercel

    1. 把程式 push 到 GitHub
    2. Vercel 登入 → New Project → 選你的 repo
    3. 在 Vercel Project 的 Environment Variables 中填入:
    4. OPENAI_API_KEY
    5. 其他內部 API 的 token(若有)
    6. 部署完成後,拿到一個網址,例如 https://your-agent.vercel.app

    成本提示

    • 小流量下 Vercel 免費方案通常足夠
    • 模型費主要取決於:使用人數 × 對話長度 × 模型單價
    • 有預算疑慮時,可以先用小模型做 MVP,流量上來再調整

    延伸玩法 & 心智模型

    • 想接更多內部系統?就把每個系統包成一個 tool,掛在同一個 Agent 或拆成多個 Agent。
    • 想做內部文件助理?多加一個「文件搜尋 API」,Agent 再負責整理成待辦或重點摘要。
    • 覺得專案變大、團隊變多?再考慮引入 MCP / API Gateway,把目前的 tools 重構即可。

    如果你今天只想要「一個會用你的 API 的雲端 AI 小幫手」,照著上面四個步驟做完,你就已經比大多數還停在概念階段的人,多了一個真正跑在雲端的 Agent。動手開一個 open-agents 專案,從一個最簡單的 tool 開始,就行了。

    🚀 你現在可以做的事

    • 開啟 open-agents GitHub 專案,用 Use this template 建一個自己的 repo
    • 在專案裡實作一個最簡單的 REST tool(例如查訂單或查專案狀態),掛到一支自訂 Agent 上
    • 用 Vercel 免費方案部署這個 Agent,丟給團隊實際試用並收集回饋
  • 把常用 Prompt 變成一鍵技能:Chrome AI Skills 實測

    把常用 Prompt 變成一鍵技能:Chrome AI Skills 實測

    📌 本文重點

    • Chrome Skills:把常用 Prompt 變成一鍵工具
    • 可跨網站、多分頁套用同一個 Skill
    • 非技術同事也能用的標準化 AI 工作流程
    • 適合團隊共用固定模板與報表解讀

    一句話先說清楚:Chrome 的「AI Skills」= 把你常用的 Prompt,變成可以隨時一鍵呼叫的小工具,不用再到處找、複製貼上。

    官方介紹: Turn your best AI prompts into one-click tools in Chrome(Google AI Blog)


    核心功能:把 Prompt 做成「可重複的一鍵技能」

    1. 儲存 / 命名 / 重用你的 Skills

    你在 Gemini 側邊欄打的任何 Prompt,都可以存成一個 Skill:

    • 操作概念
    • 先在側邊欄對 Gemini 下指令(例:請幫我用禮貌英文回覆客戶…)。
    • 覺得這個 Prompt 之後會常用,就直接存成 Skill。
    • 下次在任何網頁,只要一鍵點這個 Skill,就能套用到當前頁面的內容。

    • 能客製化的部分:

    • 幫 Skill 取一個好記的名字(例:「英文客服回覆」、「報表解讀」)。
    • 說明它是拿來做什麼的,方便同事看得懂。

    💡 關鍵: 把高頻重複的 Prompt 存成 Skill,可以用「一鍵點擊」取代每次複製貼上與重寫指令。

    你可以立刻做的事
    先想 3 個你每天都會重複貼給 AI 的 Prompt,等一下在「怎麼開始」小節,直接把它們變成 Skills。

    2. 官方預設技能庫:先用現成的再改

    Google 在 Chrome 的 Gemini 側邊欄,內建了一批「預設 Skills」,常見例子(見 Wired 介紹):

    • 食譜優化:例如「最大化蛋白質含量」或改成純素、低卡版。
    • YouTube / 長文總結:幫你抓重點,整理成條列。

    你可以:

    • 先直接用這些現成 Skills。
    • 再把你調整過的 Prompt 版本,存成自己的自訂 Skills(Google 官方文也強調可「discover, save and remix AI workflows」)。

    你可以立刻做的事
    打開 Gemini 側邊欄,先試用 1 個預設 Skill(例如「Summarize this video」),再把回答風格微調後存成自己的版本。

    3. 在任何網頁側邊欄一鍵呼叫

    根據 TechCrunch 與 The Verge 的說明,Skills 的重點是:

    • 跨網站、跨分頁 使用同一個 Skill。
    • 勾選多個 Tab,一次對多個頁面跑同一個 Skill(例如一口氣總結 3 則產品更新頁)。

    實際效果:

    • 你不用再:
    • 開 Notion / Google Docs 找那段老 Prompt。
    • 複製貼上到 Gemini。
    • 只需要:
    • 打開側邊欄 → 點你命名好的 Skill → 選擇要套用的分頁。

    你可以立刻做的事
    打開 2–3 個需要處理的頁面(例如不同客戶信、不同產品頁),試一次「同一 Skill 跑多個分頁」。


    適合誰用?4 個實際場景示範

    1. 批改英文 Email:固定語氣、固定格式

    使用方式:

    1. 在 Gemini 側邊欄寫一個完整 Prompt,例如:

      「請幫我把選取的英文 Email 改寫成禮貌、簡潔、B2B 科技公司口吻,保留原本資訊,但語氣更友善、用詞自然。」

    2. 存成 Skill:命名為「英文客服回信優化」。
    3. 之後每封英文信:
    4. 在 Gmail 開信 → 開側邊欄 → 點這個 Skill → 貼入草稿內容或讓它讀取頁面內容。

    行動建議:
    – 先為 「英文回覆」和「英文道歉信」 分別各做一個 Skill,之後全部照這兩種模板改。

    2. 食譜轉成低卡 / 純素版

    The Verge 舉例,過去你每換一個食譜頁面,就要重新輸入「幫我改成純素版」。現在可以:

    1. 建立 Skill:

      「閱讀這個網頁中的食譜,將其改寫成純素版本,提出必要的食材替代方案,並計算每份大致卡路里。」

    2. 命名為「純素 & 低卡改寫」。
    3. 之後遇到任何食譜頁面,只要一鍵點這個 Skill。

    行動建議:
    – 如果你有特定飲食需求(低醣、高蛋白),為每種飲食習慣做一個專屬 Skill。

    3. 總結長文 / YouTube:變成「固定摘要格式」

    基於 Wired 的範例,你可以把「摘要」做得更標準化:

    1. 在一篇長文章或 YouTube 頁面上,對 Gemini 說:

      「請用繁體中文,幫我整理為:1)三點重點;2)一段 100 字內摘要;3)列出適合轉貼到 Slack 的一句話。」

    2. 存成 Skill「內容三段式摘要」。
    3. 之後任何長文 / 影片都可以套用同樣格式。

    行動建議:
    – 為「給自己看的摘要」和「給團隊看的摘要」各自定義格式,做成兩個 Skills。

    4. 固定格式報表 → 自動生成解讀摘要

    你可能每週都要解讀一份長得很像的數據報表(GA4、廣告報表、CRM 匯出):

    1. 建立 Skill Prompt:

      「閱讀當前頁面的數據表格,幫我用以下格式解讀:
      1)本週 vs 上週差異;2)異常指標與可能原因(列出 3 點假設);3)下週建議行動(列出 3 個具體操作)。請用條列,長度控制在 300 字內。」

    2. 命名為「每週數據解讀 300 字」。
    3. 套用在每週固定打開的報表分頁上。

    行動建議:
    – 先選一份你 最常被問要解釋的報表,為它設計一個專用 Skill,讓 AI 先產出初稿,再微調。


    Workflow 範例:為公司建立一套「團隊共用 Skills」

    雖然 Google 尚未完全打開「公開 Skill 市集」,但你可以先用很簡單的方法做「團隊半共用」。

    1. 客服回覆模板

    1. 在文件中定義好客服回覆規則,例如:
    2. 語氣(專業、溫和、不推責)。
    3. 固定結尾句(例如邀請進一步聯絡)。
    4. 把這段規則寫進 Prompt,存成 Skill「客服標準回覆」。
    5. 把這段 Prompt 原文和「如何新增 Skill」的教學,傳給全團隊,讓大家在各自的 Chrome 裡建一模一樣的 Skill。

    2. 產品 Changelog 生成流程

    假設你每次發版,都要:

    • 從 issue tracker / Git log 撈出變更。
    • 寫成「用戶看得懂的版本更新說明」。

    可以這樣設計 Skill:

    「根據這個頁面的變更紀錄,幫我生成一份產品 Changelog,格式為:1)標題一句話;2)三個重點功能更新;3)一段給現有用戶看的說明(100 字內);4)一段給內部同事看的技術摘要(150 字內)。」

    流程建議:

    1. PM 在自己瀏覽器裡先調到滿意的 Prompt,再存成 Skill。
    2. 把 Prompt 原文放進團隊知識庫(Notion / Confluence),讓其他同事照樣建立。

    你可以立刻做的事
    選一個你們團隊「每週都會重複做、但內容每次都不一樣」的工作(公告、週報、教學信),先為它寫一個完整 Prompt,再交給全員自己建 Skill。


    實作教學:如何在 Chrome 開啟、建立與使用 Skills

    注意:Skills 目前在 桌面版 Chrome 並搭配 Gemini 側邊欄 的環境下提供,實際入口可能會隨版本更新微調,以下以官方 Blog 和多家媒體描述整理出典型流程。

    1. 在哪裡開啟 Skills(設定路徑)

    1. 更新 Chrome 至最新版本。
    2. 登入你的 Google 帳號。
    3. 在右上角找到 Gemini 圖示 或從側邊欄開啟 Gemini(有些版本是「使用 Gemini」按鈕)。
    4. 若已開放 Skills 功能,會在側邊欄看到 Skills 區塊或「Save as Skill」類似選項(可持續留意:TechCrunch 報導)。

    行動建議:
    – 先確認你能在 Chrome 裡正常使用 Gemini 側邊欄,再來找 Skills 相關選項。

    2. 如何從現有 Prompt 儲存成 Skill

    1. 打開任一網頁(例如 Gmail、文件、報表)。
    2. 開啟 Gemini 側邊欄,輸入你想重複使用的 Prompt,先讓它跑一次,調整到你滿意的回答風格。
    3. 在這則對話附近,尋找「Save as Skill」或「Create Skill」按鈕(介面可能是三點選單裡的選項)。
    4. 設定:
    5. Skill 名稱(簡短但具體,例如「GA4 每週報告摘要」)。
    6. 說明 / Tag(方便未來辨識)。
    7. 儲存後,它就會出現在 Skills 清單中。

    行動建議:
    – 第一次先存 1 個 Skill,不要一次做太多,確保你真的會用它,之後再慢慢擴充。

    3. 如何在多個 Tab 上使用 Skills

    根據 The Verge 的說明,Skills 可以在多個分頁上重複使用,典型操作如下:

    1. 開啟多個相關分頁,例如:3 篇產品更新文章、或 3 份不同客戶的簡報頁。
    2. 打開 Gemini 側邊欄 → 選擇你要用的 Skill。
    3. 在 Skills 介面中,選擇要套用的 Tab(有些版本可能支援勾選多個)。
    4. 按下執行,AI 會依序對每個分頁運行該 Skill,生成各自的結果。

    行動建議:
    – 嘗試在 兩個很相似的頁面(例如兩個競品產品頁)使用同一個 Skill 做比較分析,快速得到可對照的結果。


    與「複製貼上 Prompt」相比的優勢

    傳統做法

    • 在 Notion / Google Docs / 備忘錄保存一堆 Prompt。
    • 每次要用時:切換視窗 → 複製 → 回到瀏覽器 → 貼上 → 再調整。

    用 Skills 的差別

    1. 少一步切換工具:Prompt 就在 Chrome 裡,直接點名字就套用。
    2. 減少 Version 混亂:不用在多個文件裡找「最新版 Prompt」,你只維護同一個 Skill。
    3. 跨分頁一致性:同一個 Skill 直接套在不同頁面,輸出風格一致,特別適合報表解讀、客服回覆、摘要格式。
    4. 更適合非技術同事:他們不需要理解什麼是 Prompt Engineering,只要知道「遇到這種工作,就點這個 Skill」。

    💡 關鍵: 把分散在文件裡的常用 Prompt 收斂成少量核心 Skills,可以同時解決「效率低」與「輸出不一致」兩個問題。

    你可以立刻做的事
    – 把你目前收藏 Prompt 的文件打開,挑出 最常用的前 3 個,優先轉成 Skills,其餘的保持在文件裡即可。


    和其他瀏覽器 AI 外掛有什麼不同?

    目前許多 AI 外掛(如各種 ChatGPT / Gemini / Claude 插件)也能在網頁上跑 Prompt,但 Chrome 原生 Skills 有幾個實際差異:

    比較項目 Chrome AI Skills 一般瀏覽器 AI 外掛
    整合程度 直接整合在 Chrome 與 Gemini 側邊欄 需額外安裝擴充功能
    Prompt 儲存方式 以「Skill」形式命名、可跨分頁一鍵呼叫 多為歷史記錄或簡單書籤,重用流程較散亂
    多分頁操作 官方說明可對多個 Tab 套用同一 Skill 多數外掛只對目前分頁或需逐一操作
    團隊共用 目前以「共用 Prompt 文本、各自建立 Skill」為主 有些外掛有雲端模板共享,但使用體驗不一
    安全與權限 跟隨 Google 帳號與官方隱私設定 視外掛開發者而定,需額外確認權限

    如果你已經習慣用某個外掛,可以:

    • 把外掛裡最常用的 Prompt,手動搬到 Chrome 的 Skills,讓「真正會每天用到的那幾個」留在瀏覽器原生工作流程中。

    💡 關鍵: Skills 的優勢不是「功能更多」,而是「離真實工作場景更近」,把 AI 變成瀏覽器內建的工作按鈕。


    怎麼開始:3 步驟快速上手

    1. 確認環境
    2. 更新 Chrome → 登入 Google 帳號。
    3. 確認你能在瀏覽器右側打開 Gemini 側邊欄。

    4. 選出你的「前三名常用 Prompt」

    5. 例如:
      • 英文 Email 改寫。
      • 報表摘要。
      • 網頁 / 影片整理成重點筆記。
    6. 先在 Gemini 裡照平常方式下指令,調整到滿意。

    7. 存成 Skills 並實際跑一次

    8. 用前面教的方式,將這三個 Prompt 各存成一個 Skill。
    9. 立刻在兩種不同頁面上試跑(例如兩封不同的信件、兩篇不同文章),看輸出是否符合期待,必要時再回頭微調 Prompt。

    這樣設定完,你之後在 Chrome 裡看到任何「值得用 AI 幫忙處理」的頁面,就不用思考要怎麼下指令,只要想:「這件事有沒有對應的 Skill 可以點?」

    🚀 你現在可以做的事

    • 打開你存 Prompt 的 Notion 或文件,挑出 3 個最高頻使用的指令,準備轉成 Skills
    • 在桌面版 Chrome 更新並登入 Google 帳號,確認 Gemini 側邊欄與 Skills 入口是否已可使用
    • 選一個固定重複的工作(如週報、Email 模板),寫成完整 Prompt,存成第一個可重複使用的 Skill
  • 用 Claude Cookbooks 做出你的第一個 AI 小工具

    用 Claude Cookbooks 做出你的第一個 AI 小工具

    📌 本文重點

    • Claude Cookbooks 是一套可直接照抄的實戰 Notebook
    • 非工程師可當高級提示模板庫直接用
    • 工程師可快速接 API 做聊天機器人與 RAG 助手
    • 最快五步就能跑出自己的 AI 小工具

    用一句話說清楚:Claude Cookbooks 是一套「Claude 實戰菜單」,照著 Notebook 抄一遍,你今天就能做出自己的聊天機器人、文件助手或程式碼助手。

    原始專案連結:👉 anthropics/claude-cookbooks


    核心功能:這套「菜單」可以幫你做什麼?

    1. 清楚的 Repo 結構:先選你要的「菜」

    進到 GitHub 專案後,你大致會看到這幾類資料夾(名稱可能會略有調整,但概念相近):

    • notebooks/:主要範例,都用 Jupyter Notebook 寫好
    • basic_examples/:最簡單的對話、提示工程示範
    • tools_and_workflows/:工具呼叫、工作流程自動化
    • rag/:RAG(檢索增強生成),用你自己的文件做問答
    • agents/ 或類似資料夾:多步驟任務、小型 Agent 範例

    可以做的事,對應你能採取的行動:

    • 如果你完全沒寫過程式 → 先看標題含有 conversationprompting 的 Notebook,當成「高級版提示語模板」,直接複製到 Claude 網頁版使用。
    • 如果你會一點 Python → 跑 basic_examples 裡的 Notebook,先確認你能成功打出第一個 API 回應。
    • 如果你想做內部工具或 Agent → 從 tools_and_workflowsrag 開始,把範例裡的「假資料」換成你公司的文件或 API。

    2. Notebook 類型:從聊天到自動化,一路拆給你

    Cookbooks 裡的 Notebook 大致可以分成四類,每一類都可以直接改成你的專案:

    1. 對話 / 提示工程 Notebook
    2. 示範怎麼寫系統提示(system prompt)、角色設定、回覆風格控制。
    3. 行動:把裡面的 system prompt 複製出來,替換成你的場景,例如:

      • 把「你是一位友善的 AI 助手」改成「你是一位專門回答退貨政策的客服人員」。
    4. 工具調用(Tool Use)Notebook

    5. 示範怎麼讓 Claude 主動呼叫你定義好的函式,例如查訂單、算報表。
    6. 行動:照著 Notebook 裡的結構定義一個簡單工具:

      python
      def get_order_status(order_id: str) -> dict:
      # TODO: 這裡先寫死假資料,之後再接真的 DB
      return {"order_id": order_id, "status": "shipped"}

      然後讓 Claude 根據使用者輸入決定要不要呼叫這個工具。

    7. RAG(文件問答)Notebook

    8. 示範怎麼把 PDF、Markdown、內網文件先「切片 + 向量化」,再讓 Claude 根據搜尋結果回答。
    9. 行動:先不管效果好不好,拿一份你真的會用到的文件(公司 FAQ、課程教材)丟進範例 Notebook,看能不能成功問出答案。

    10. 工作流程自動化 / Agent Notebook

    11. 示範多步驟流程,例如:解析需求 → 查資料 → 產出報告 → 修稿。
    12. 行動:把裡面的流程步驟改成你的工作,例如「整理每日客服問題 → 匯總成報表」。

    💡 關鍵: 這些 Notebook 的真正價值在於「可直接照抄運行」,先跑出結果再改一兩行,就能快速變成你的專案雛形。

    這些 Notebook 的重點不是「看懂內部原理」,而是先照抄跑出結果,再從中挑一兩行改成自己的業務語句


    3. 拿 Cookbooks 當提示工程與 API 練習教材

    你可以把整個 repo 當成一套免費教材:

    • 練提示工程
    • 每次只做一件事:挑一個 Notebook,只改 system prompt,觀察回覆差異。
    • 練習把「模糊指令」改成「具體條件」,例如:

      • 從「請你幫我改寫」改成「請幫我改寫成 300 字以內、用條列式、適合放在 EDM 裡」。
    • 練 API 使用

    • 大多數 Notebook 只需要你把 api_key 換成自己的,就能跑起來。
    • 把官方文件 + Cookbooks Notebook 打開對照看,很快就能理解 messagestools 等欄位用法。

    適合誰用:非工程師、工程師都能上手

    1. 非工程師:直接拿 Prompt 模板做你的專屬助手

    你不用會 Python,也能從 Cookbooks 撈出超實用的提示模板:

    適合的場景與行動:

    • 客服:
    • 找對話範例 Notebook,看 system prompt 區塊,改成:
      • 「你是某某品牌的客服,回答只能根據以下政策文件,不要自己杜撰。」
    • 把這串 prompt 複製到 Claude 官網或任何支援 Claude 的聊天界面使用。

    • 教學 / 內訓:

    • 找「教學型」prompt(通常會強調分步驟解釋),改成你的主題:

      • 例如從「解釋 Python 基礎」改成「解釋公司新制度給新進同仁」。
    • 內容產生:

    • 使用「內容規劃」「格式控制」相關的 prompt,限制輸出格式,例如:
      • 「每篇貼文必須含有標題、三個重點、CTA 一句。」

    你可以完全忽略程式碼,只把 Notebook 當作「可複製的提示語範本庫」。


    2. 工程師:照範例接後端、做簡單 Agent 或內部工具

    如果你會基本的 JavaScript / Python,Cookbooks 就是現成腳手架:

    • 接後端 API
    • 參考工具調用 Notebook,把你現有的 REST API 包成一個 tool,讓 Claude 負責決定何時呼叫。

    • 做簡單 Agent

    • 用工作流程 Notebook,把「找資料 → 分析 → 生報告」這種流程拆成數個函式,交給模型逐步完成。

    • 配合其他工具

    • 例如搭配 gsd-build/get-shit-done 這類 meta-prompting 框架,把你在 Cookbooks 練出來的 prompt 模板,包成可重用的規格驅動開發模組。

    怎麼開始:5 步跑出你的第一個 AI 小工具

    以下示範用「本機 + 最實用 Notebook」的最短上手路徑。

    步驟 0:準備一支 Claude API Key

    1. 前往 Anthropic 官方平台(依區域而定,通常是 Anthropic Console)。
    2. 建立帳號,進入 API 區域,建立一支 API Key。
    3. 暫存好這串金鑰,等等要寫進環境變數或 Notebook。

    步驟 1:Fork 專案 + 下載到本機

    1. 打開 repo:https://github.com/anthropics/claude-cookbooks
    2. 右上角點選 Fork,建立自己的副本,方便之後修改。
    3. 在終端機輸入:

    bash
    git clone https://github.com/<你的帳號>/claude-cookbooks.git
    cd claude-cookbooks

    如果你不想在本機操作,也可以直接用雲端 Notebook(例如 GitHub Codespaces、Colab)打開 repo,步驟類似,只是不用 git clone


    步驟 2:安裝環境 + 設定 API Key

    1. 建議建立虛擬環境:

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

    1. 安裝依賴(專案內通常有 requirements.txtpyproject.toml):

    bash
    pip install -r requirements.txt

    1. 設定環境變數(以 macOS / Linux 為例):

    bash
    export ANTHROPIC_API_KEY="你的_API_Key"

    Windows PowerShell 則是:

    powershell
    setx ANTHROPIC_API_KEY "你的_API_Key"

    💡 關鍵: 只要正確設定 ANTHROPIC_API_KEY 環境變數,大部分 Notebook 幾乎「零修改」就能直接跑起來。


    步驟 3:啟動 Jupyter Notebook

    在專案根目錄啟動:

    jupyter notebook
    

    瀏覽器會打開一個頁面,看到專案檔案結構,接下來只要點進想學的 Notebook 即可。


    實戰示範 1:照抄一個「聊天機器人」 Notebook

    以一個最簡單的對話 Notebook 為例(名稱可能類似 basic_chat.ipynb):

    1. 打開 Notebook,找到這幾段:
    2. 匯入套件(通常是 from anthropic import Anthropic
    3. 建立 client:client = Anthropic()
    4. 呼叫模型的程式碼:

      python
      response = client.messages.create(
      model="claude-3-5-sonnet-latest",
      max_tokens=256,
      messages=[
      {"role": "user", "content": "你好,幫我想三個 IG 貼文主題"}
      ],
      )
      print(response.content[0].text)

    5. 直接執行所有 Cell,確認能拿到一段回覆。

    6. 第一個客製化改動
    7. messages 改成你要的 system + user:

      python
      messages=[
      {
      "role": "system",
      "content": "你是一位專門幫新創品牌寫社群貼文的內容策劃,回覆一律用繁體中文,語氣自然口語。"
      },
      {
      "role": "user",
      "content": "我們是做手沖咖啡器材的,幫我想三個 IG 貼文主題。"
      }
      ]

    8. 再跑一次,這就是你的第一個「內容策劃小幫手」。

    延伸修改方向:

    • 把 user input 改成 input(),讓程式變成簡單的 CLI 聊天機器人。
    • 限制輸出格式:要求 Claude 回傳 JSON,方便之後接到前端或自動排程工具。

    實戰示範 2:照抄一個「文件助手」 RAG Notebook

    找一個 RAG 相關 Notebook(例如 basic_rag.ipynb),你可以這樣照做:

    1. 找到「載入文件」的 Cell,把原來的 sample text 改成你自己的 FAQ 或產品說明。
    2. 跟著 Notebook 步驟做:
    3. 切分文件 → 建立向量索引 → 根據提問檢索相關片段。
    4. 在最後呼叫 Claude 的地方,確認有把「檢索結果」放進 prompt 裡,例如:

    “`python
    prompt = f”””
    根據以下文件內容回答使用者問題,如果文件裡沒有答案,就老實說不知道:

    {retrieved_chunks}

    問題:{user_question}
    “””
    “`

    1. 執行後,你就得到一個最簡單版的「文件問答助手」。

    延伸修改方向:

    • 把檔案來源改成公司內部 SOP 或 Notion 匯出的 Markdown。
    • 在回覆前加上一段「引用來源」,列出這次回答用到哪些文件標題。

    小結:先抄,再改,最後變成你的專屬 Cookbooks

    使用 Claude Cookbooks 有一個簡單心法:

    1. 先選一個最貼近你需求的 Notebook(聊天 / 文件 / 工具調用)。
    2. 照著跑一次,不改任何東西,只確認能成功呼叫 API。
    3. 從 system prompt 開始改成你的場景,再逐步替換資料來源、工具函式。

    💡 關鍵: 當你能順手改兩三個 Notebook,你實際上已經掌握提示設計、API 呼叫與簡單 Agent 的完整流程。

    當你能順手改兩三個 Notebook,你實際上已經會:

    • 寫出能穩定工作的提示語
    • 呼叫 Claude API,做出自己的 AI 小工具
    • 把文件、後端 API、工作流程接進來,做出簡單 Agent

    接下來,你就可以把自己的版本再 push 回 GitHub,變成「你公司的 Claude Cookbooks」。


    🚀 你現在可以做的事

    • 打開 anthropics/claude-cookbooks,先挑一個最貼近你需求的 Notebook
    • 依照文中步驟設定 ANTHROPIC_API_KEY,完整跑通一個聊天或 RAG 範例
    • 把其中一個 Notebook 的 system prompt 改成你的實際場景,存成你自己的第一個 Cookbooks 版本
  • Hippo 記憶:讓本機 AI Agent 真正記住你

    📌 本文重點

    • Hippo 讓 AI Agent 具備結構化長期記憶
    • 不只用向量搜索,而是多維度記憶召回
    • 可直接接入 LangChain / LangGraph 現有架構

    如果你受夠了每次開新對話 AI 就失憶,Hippo 是一個專門幫 AI Agent 建長期記憶結構 的開源工具,讓模型可以跨對話記住你、記住專案、記住世界觀。

    專案連結:https://github.com/kitfunso/hippo-memory


    核心功能:它跟「塞進向量資料庫」有什麼不一樣?

    1. 生物啟發的記憶結構:不是只靠 embedding 搜索

    一般「加記憶」做法:

    • 把所有對話 / 文件轉成向量,丟進向量資料庫
    • 查詢時用 embedding 相似度召回

    這樣會遇到:

    • 記憶越多越慢
    • 容易抓到語意相似但情境不對的內容
    • 很難做「時間感」與「重要程度」的區分

    Hippo 的做法更像大腦海馬迴:

    • 把記憶拆成多種型態(事件、事實、偏好、任務等)
    • 每種記憶有自己的欄位:時間戳、重要性、來源、關聯 id
    • 召回時不只看相似度,還會考慮:
    • 時間距離(最近 / 很久以前但被多次提及)
    • 重要性(例如「明天要開會」權重更高)
    • 記憶種類(對話中問的是偏好,就優先找偏好類)

    💡 關鍵: Hippo 透過「記憶類型 + 時間 + 重要性」多維度過濾與排序,比單靠 embedding 更接近人類大腦的記憶方式。

    你可以採取的行動

    • 在設計 Agent 時,把「要記住什麼」先分類(例:使用者設定、長期專案狀態、一次性任務)
    • 對應到 Hippo 的不同記憶類型,而不是全部塞進單一向量庫

    2. 高效寫入 / 召回:不是每一句話都存

    Hippo 會讓 LLM 幫忙「過濾」哪些內容要進長期記憶:

    • 每輪對話結束時,呼叫一次 LLM:
    • 請它輸出:要存什麼?是什麼類型?重要性幾分?
    • 只有被標註為「值得記住」的內容才寫入記憶庫

    召回時則是:

    • 先根據 當前任務類型 過濾可疑記憶(例如問「專案」時,優先專案類)
    • 再用 embedding + 時間 + 重要性加權排序

    效果:

    • 記憶庫不會無限膨脹
    • 查詢時間穩定,對話變長也不會暴漲

    💡 關鍵: 透過 LLM 篩選與加權排序,Hippo 在長期對話下仍能維持穩定的查詢速度與記憶品質。

    你可以採取的行動

    • 在對話 loop 中加入一個 summarize_and_store_memory() 步驟
    • 規劃一份提示詞,教 LLM:什麼東西需要記住(例如使用者偏好、長期任務)

    3. 可以直接當「記憶模組」接到 LangChain / LangGraph

    Hippo 把核心封裝成一個獨立記憶層:

    • 暴露簡單的 API:add_memory(), retrieve_memories(), summarize_dialogue()
    • 你可以把它包成一個自訂的 LangChain Memory 類或 LangGraph node

    這代表你不必改整個 Agent 架構,只要:

    • 把原本「向量記憶」的那一層換成 Hippo
    • Prompt 裡多餵一段:{relevant_memories}

    你可以採取的行動

    • 先用 Hippo 做一個獨立小腳本,確定記憶寫入 / 召回正常
    • 再把它接進現有的 LangChain / LangGraph 專案

    適合誰用?三種具體場景

    1. 客服 / 助理型 Agent:跨對話記住使用者

    問題:

    • 今天跟你聊過喜好,明天又得重講一次

    用 Hippo 可以:

    • 把「使用者個人偏好」「公司規則」「歷史問題」分成不同記憶類型
    • 在每次新對話開始前,先用使用者 id 去 retrieve_memories()

    具體做法:

    • 每個 user 綁一個 user_memory_store
    • 首輪對話後,寫入:
    • 常用產品 / 方案
    • 語氣偏好(喜歡簡短回答、或喜歡詳細教學)
    • 下次對話開頭,在系統 prompt 裡加:
    • 你已知這個使用者的偏好:...

    2. 工具型 Agent:追蹤專案長期狀態

    像是:

    • 本機程式碼助手
    • 專案管理 / 自動化腳本編排 Agent

    用 Hippo 可以把:

    • 已完成的任務
    • 未完成的 TODO
    • 決策理由(為什麼選 A 而不是 B)

    長期存起來,讓 Agent 未來做決策時可以「回頭想」,而不是只看當前 prompt。

    具體做法:

    • 每次工具成功執行後,寫入:操作內容、輸入、輸出、錯誤紀錄
    • 下次 Agent 在決定要不要呼叫同個工具時,先查過去的失敗 / 成功案例

    💡 關鍵: 對工具型 Agent 來說,持續累積「決策與結果」記憶,可以大幅降低重複犯錯與無效操作。

    3. 遊戲 / 模擬:角色人格與世界觀持久化

    如果你在做:

    • 文字冒險遊戲中的 NPC
    • 模擬城市 / 社會裡的多 Agent 系統

    Hippo 可以:

    • 把 NPC 的「人生事件」「人際關係」「信念」拆成不同記憶
    • 讓同一個角色在不同局遊戲中保有成長、偏好

    具體做法:

    • 每次玩家與 NPC 互動後,將關鍵事件寫入該 NPC 的記憶庫
    • 下次載入遊戲時,先載入角色記憶,再生成回應

    怎麼開始:本機跑一個有長期記憶的 Agent

    下面示範:在本機用一個輕量開源 LLM + Hippo 跑出一個最小可用的長期記憶 Agent。

    1. 安裝依賴(Python)

    假設你有 Python 3.10+,先開一個虛擬環境:

    python -m venv venv
    source venv/bin/activate  # Windows 用 venv\Scripts\activate
    
    pip install hippo-memory
    pip install transformers accelerate sentence-transformers
    

    如果你想用 Ollama / 本機模型,也可以只要 HTTP API,把 llm_call() 改成呼叫本地端服務即可。

    2. 建一個最小記憶介面

    概念流程:

    1. 使用者說話
    2. Agent 回應(用 LLM)
    3. 用 LLM 檢查這輪對話有沒有值得記住的東西
    4. 需要記住的就丟給 Hippo
    5. 下一輪對話前,從 Hippo 取出相關記憶加進 prompt

    簡化版範例(偽代碼結構):

    from hippo_memory import HippoMemory
    
    memory = HippoMemory()
    
    def llm_call(prompt: str) -> str:
        # TODO: 換成你實際使用的本機 LLM(Ollama / vLLM / transformers)
        ...
    
    
    def summarize_for_memory(dialogue: str) -> list[dict]:
        """讓 LLM 決定要存哪些記憶,回傳 list[{"type":..., "content":..., "importance":...}]"""
        prompt = f"""
    你是記憶管理員。以下是剛剛的一段對話:
    {dialogue}
    
    請列出值得長期記住的事情(使用者偏好、長期目標、重要事件)。
    用 JSON 陣列輸出,每個元素包含 type, content, importance(1-5)。
    如果沒有,回傳 []。
    """
        import json
        res = llm_call(prompt)
        return json.loads(res)
    
    
    def add_dialogue_to_memory(history: list[tuple[str, str]]):
        # history = [(user_msg, assistant_msg), ...]
        text = "\n".join([f"User: {u}\nAssistant: {a}" for u, a in history[-3:]])
        items = summarize_for_memory(text)
        for item in items:
            memory.add_memory(
                mem_type=item["type"],
                content=item["content"],
                importance=item.get("importance", 3),
            )
    
    
    def chat_loop():
        history = []
        while True:
            user = input("你:")
            if user.strip().lower() in {"exit", "quit"}:
                break
    
            # 1) 先查記憶
            relevant = memory.retrieve_memories(query=user, top_k=5)
            memory_text = "\n".join([f"- {m.content}" for m in relevant])
    
            # 2) 組 prompt
            prompt = f"""你是一個會記住使用者的助理。
    以下是你對這位使用者的已知記憶:
    {memory_text or '(目前沒有特別記憶)'}
    
    現在的對話:
    使用者:{user}
    請根據記憶與對話回應。
    """
            assistant = llm_call(prompt)
            print("Agent:", assistant)
    
            history.append((user, assistant))
            add_dialogue_to_memory(history)
    
    
    if __name__ == "__main__":
        chat_loop()
    

    你可以採取的行動

    • 把上面程式框架複製到自己的專案
    • llm_call() 替換成你現用的 LLM(如 Ollama 的 /api/chat
    • 用幾輪「自我介紹 → 問之前說過什麼」來測試記憶效果

    3. 接到 LangChain / LangGraph 的 memory 模組

    如果你已經在用這些框架,可以這樣思考:

    • LangChain:
    • 寫一個 HippoMemoryWrapper,實作 load_memory_variables + save_context
    • 內部直接呼叫 HippoMemory.add_memory() / retrieve_memories()
    • LangGraph:
    • 把 Hippo 抽成一個 node:「更新記憶」與「擷取記憶」
    • 在主對話 graph 中,讓每輪都經過這兩個 node

    這樣你不用推翻原有設計,只是把記憶 backend 換成更聰明的 Hippo。


    小結:什麼時候值得上 Hippo?

    你可以用一個簡單判斷:

    • 只做「單次任務、一次對話就結束」的 Agent → 一般向量資料庫就夠
    • 需要「跨天、跨專案、角色長期成長」的 Agent → 值得導入 Hippo 記憶

    先從一個很小的場景開始:例如讓你的本機助理 記住你的個人偏好。當你發現它真的記得你說過的事,再把同樣的記憶結構,複製到客服、專案管理或遊戲 NPC 上。

    專案原始碼與設計細節: https://github.com/kitfunso/hippo-memory

    🚀 你現在可以做的事

    • 打開專案頁面,閱讀 Hippo 的 README 與範例程式碼:https://github.com/kitfunso/hippo-memory
    • 在本機建立一個小腳本,實作文中 llm_call() 並跑起示範的記憶型 Agent
    • 將 Hippo 接入你現有的 LangChain / LangGraph 專案,先讓一個特定 user 或 NPC 擁有長期記憶