Kerwin AI Information

標籤: 自動化工作流程

  • Plurality：在家自架你的 AI 中控台

    Plurality：在家自架你的 AI 中控台

    📌 本文重點

    • Plurality 是本地可自架的 AI 中控台
    • 同一介面整合聊天、腳本自動化與多代理協作
    • 透過沙盒與 MCP 打造安全可控的 AI Runbook 系統

    一句話定位：Plurality 是一個裝在你自己電腦或局域網裡的 AI 中控台，用同一個介面處理聊天、腳本自動化和多代理協作，而且完全開源、可本地部署。

    專案連結：https://github.com/azukaar/plurality （建議邊看文邊打開）

    核心功能：把「聊天 + 自動化 + 安全執行」塞進一個面板

    1. 一個介面同時管「聊天」和「背景自動化」

    Plurality 的定位很像「你自己架的 Slack + Jira + Runbook 執行器」，但全部交給 AI 來動。

    你可以在同一個 Web 介面裡：

    • 和 AI 助理聊天
    • 建立長期存在的 Agent（例如「專案助手」「報表助手」）
    • 為每個 Agent 配好自動化流程（Automation Flow），讓它在背景持續跑

    你可以這樣用：

    • 先在 Plurality 裡創一個「專案助理」Agent
    • 在聊天裡下達指令：「幫我建立一個每日 build 檢查流程」
    • 再把這段需求轉成 automation flow：每天定時跑腳本、整理結果、回報到同一個對話 Thread

    實際效果：你不再需要切來切去——一樣是在「跟 AI 聊天」，但對話可以變成「可重複、自動執行的任務」。

    💡 關鍵： 將常用對話轉成 automation flow，可把「會話」變成每天自動跑的固定任務，減少大量手動重複操作。

    行動建議：想像一下你現在最常對 ChatGPT 說的其中一件事（例如「整理日報」「幫我跑某個腳本」），這會是你在 Plurality 裡第一個要做成 Automation 的任務。

    2. 安全的 CLI + 檔案系統沙盒

    Plurality 支援讓代理在「沙盒環境」裡跑 CLI 命令、操作檔案，但重點是：

    • 可控制範圍：你可以只把某個專案資料夾掛載給該 Agent
    • 可審核：代理要執行敏感命令前，可以設成需要你點擊確認
    • 可記錄：所有命令和檔案操作都在介面裡看得到 log

    這意味著：

    • 開發者可以讓 Agent 幫忙跑測試、打包、整理 log
    • 知識工作者可以讓 Agent 在限定資料夾裡整理檔案、產出報告
    • 家用伺服器使用者可以讓 Agent 只碰 backup 資料夾，不碰其他東西

    你可以這樣設定：

    1. 在 Plurality 的設定中，新增一個「Project」或「Workspace」
    2. 把 /home/你/某個專案 或 NAS 的某個共享資料夾掛載給這個 Workspace
    3. 建立 Agent 並指定它只能使用這個 Workspace
    4. 開啟「命令前需要確認」（如果你怕它亂改東西）

    行動建議：先選一個「就算搞壞也不會心痛」的資料夾，當作 Agent 測試用沙盒，把 CLI 操作和檔案操作都限制在這裡。

    3. 搭配 MCP、多代理協作，變成你的「個人 Jira + Runbook 執行器」

    Plurality 支援 MCP（Model Context Protocol）等多代理協作生態，你可以把它當成一個統一入口，接上：

    • 不同工具的 MCP 伺服器（例如資料庫查詢、Issue 管理、監控系統）
    • 多個 Agent 各自負責不同任務

    用白話來說：

    • 「像 Jira 一樣」：你可以把每個自動化流程當成一個 Ticket / 任務
    • 「像 Runbook 一樣」：每個任務裡，是具體的步驟（腳本、API調用、檔案處理）
    • Plurality 的 Agent 負責：讀任務 → 選工具 → 執行 → 回報結果

    實際用法例子：

    • 一個「監控 Agent」：定時讀監控 API → 判斷是否異常 → 若異常就呼叫「Runbook Agent」
    • 「Runbook Agent」：按你寫好的流程，連線伺服器、跑腳本、紀錄在一個對話 Thread 裡

    行動建議：先想一個你現在「寫在 Notion / Wiki 的 Runbook」，例如「網站掛掉怎麼檢查」，把它拆成步驟，交給 Plurality Agent 來執行一次看看。

    適合誰用？三個具體場景

    1. 開發者：用 Plurality 管專案腳本

    適合這樣的人：

    • 手上有一堆 npm script / Makefile / shell script
    • 常常要：跑測試、打包、部署、整理 log

    實際流程可以長這樣：

    • 在 Plurality 裡建立一個「專案 Dev Agent」
    • 掛載你的專案資料夾（例如 /projects/my-app）
    • 讓 Agent：
    • 用 CLI 跑 npm test，把錯誤訊息整理貼回聊天
    • 根據你的指示修改設定檔或產出新腳本（在沙盒裡）
    • 定時跑 lint + test 並生成報告

    你每天要做的事情，就變成：開 Plurality → 問「今天 CI 有沒有紅？」→ 讓 Agent 調出 log 給你看。

    💡 關鍵： 讓 Agent 接管 npm test、lint 等例行腳本，可把日常 CI/開發檢查集中在單一對話介面完成。

    2. 知識工作者：整理檔案 + 做定時報告

    適合這樣的人：

    • 每週要交固定報告（營運簡報、數據摘要、內容整理）
    • 桌面 / NAS 上堆滿 PDF、Word、報表 CSV

    你可以這樣設計一個 Agent：

    • 掛載「報表資料夾」給它（例如 Reports/Weekly）
    • 每天或每週固定時間：
    • 掃描新檔案
    • 自動分類命名（根據檔名、內容）
    • 生成一份文字摘要（例如本週營運重點、會議紀錄整理）
    • 寄出 Email 或貼到公司內網

    整套流程變成：你只要把資料丟進資料夾，其它交給 Plurality。

    3. 自架家用伺服器：備份 + 監控

    如果你有自己的 NAS 或家用伺服器（例如和 Livinity 這種 homeserver OS 類似的架構），Plurality 很適合當成「AI 管家」。

    可以做的事情：

    • 每天半夜：
    • 檢查共享資料夾是否有新檔
    • 壓縮後備份到另一顆硬碟或雲端
    • 寫 log + 總結備份結果
    • 每小時：
    • 跑監控腳本（例如檢查 Docker 容器、硬碟空間）
    • 若異常，透過 Email / Telegram 通知你

    這些都可以用 Plurality 的 automation flow + CLI 沙盒來完成，而且所有設定都留在你自己的網路裡。

    💡 關鍵： 把備份與監控自動化放進局域網，能在不依賴外部服務的前提下，建立可審計又可控的「AI 管家」流程。

    15 分鐘入門：從 clone 到第一個 Automation Flow

    下面用一個具體目標來帶你：每天抓 RSS → 總結 → 寄信。

    步驟 0：準備環境（2 分鐘）

    需求：

    • 一台可以跑 Docker 的機器（你的電腦、NAS 或家用伺服器）
    • 至少一個可用的模型：
    • 本地：Ollama / LM Studio / 其他本地 LLM 伺服器
    • 雲端：OpenAI / Claude 等（有 API key）

    行動：先確認你有 Docker 和一個模型 API（或已裝好 Ollama）。

    步驟 1：拉 GitHub repo + 啟動（5 分鐘）

    1. 開啟 GitHub 專案：https://github.com/azukaar/plurality
    2. 在你的機器上：
    git clone https://github.com/azukaar/plurality
cd plurality
    1. 使用 Docker（以官方 README 為準，但大致會是）：
    docker compose up -d
    1. 打開瀏覽器，進入 http://你的機器 IP:PORT（通常 README 會寫預設 port）

    行動：先確認你能看到 Plurality 的 Web 介面，並完成初次設定帳號。

    步驟 2：連上本地或雲端模型（3 分鐘）

    在 Plurality 介面的設定裡（通常是「Models」「LLM Providers」之類）：

    • 如果你用本地模型（例如 Ollama）：
    • 填入 Ollama 的 URL（例如 http://host.docker.internal:11434）
    • 選一個模型（llama3 等）
    • 如果你用雲端模型：
    • 選 OpenAI / Anthropic 等
    • 貼入 API key

    接著：

    • 建立一個「預設 Agent」
    • 開一個新聊天，隨便問一個問題，確認模型回應正常

    行動：測一次聊天，確定模型接上沒問題，再往下做自動化。

    步驟 3：設定第一個 Automation Flow：RSS → 總結 → 寄信（5 分鐘）

    以概念步驟為主，實際操作依 Plurality 當前 UI 為準（版本更新可能略有差異）：

    1. 建立一個 Agent（例如叫 RSS Reporter）：
    2. 權限：允許網路請求（抓 RSS）

    3. 若需要寄信，先在設定裡填好 SMTP 或 Webhook（視官方檔案支援的方式）

    4. 建立 Automation Flow：

    5. 觸發條件：每日某個時間（例如 09:00）

    6. 步驟設計（可用自然語言描述給 Agent，再微調）：

      1. 抓取指定 RSS（例如科技新聞、公司部落格）
      2. 解析最近 24 小時的新文章
      3. 用模型生成摘要：
        • 列出 3-5 則重點
        • 每則一段話說明「為什麼重要」
      4. 把摘要整理成一封 Email 內容
      5. 呼叫 SMTP/Email 工具寄給你

    7. 測試一次：

    8. 不用等明天，先在介面裡手動 Run 這個 Flow
    9. 檢查 log 和 Email 是否如預期

    行動：先用你最常看的其中一個 RSS 做範例，例如你公司部落格或常看的技術網站。

    小結：把「雜事」搬進你自己的局域網裡

    Plurality 的核心價值在於：

    • 一個介面聚合聊天 + 自動化 + 多代理
    • 可以讓 AI 真正「動手」跑 CLI、操作檔案，但仍在你可控的沙盒裡
    • 搭配 MCP、多代理協作，把原本散在各處的腳本、Runbook 和任務，集中到一個你自己掌控的中控台

    如果你本來就有自架 NAS、家用伺服器，或公司內網伺服器，Plurality 很適合直接變成「AI 操作台」；如果你只是想找個比 ChatGPT 更能「實際做事」的工具，也可以先在自己電腦上跑一個 Plurality，從那個 RSS → 總結 → 寄信的 Flow 開始。

    下一步行動：打開 https://github.com/azukaar/plurality，照本文的 15 分鐘流程做出你的第一個 Automation Flow，之後再慢慢把日常重複工作移進去。

    🚀 你現在可以做的事

    • 打開 Plurality 專案頁，用 git clone 把專案拉到本機或 NAS
    • 準備好一個可用模型（例如設定好 Ollama 或貼入 OpenAI / Claude API key），完成第一次聊天測試
    • 挑一個你每天重複做的流程（如 RSS 摘要、報表整理），在 Plurality 裡實作成第一個 Automation Flow
  • 5 分鐘做出你的 Claude 專屬小 Agent

    5 分鐘做出你的 Claude 專屬小 Agent

    📌 本文重點

    • Claude Skills 是一包可重用的 Python 技能模組
    • 只要寫幾個函式就能讓 Claude 自動串起工作流
    • 10 分鐘內可跑起第一個實用小 Agent

    用一句話講清楚：Claude Skills 就是一包現成可重用的 Python「技能模組」，幫你把讀檔、叫 API、發 Slack 這種瑣事交給 AI 自動跑。

    下面的重點是：看完你應該要「馬上能照著做，跑起一個自己的小 Agent」。

    什麼是 Claude Skills？

    原始專案：https://github.com/anthropics/skills

    用人話解釋：

    • 每一個 Skill 就是一個 Python 函式，包住「一件具體可重複的任務」，例如：
    • 讀 / 寫某個資料夾的檔案
    • 呼叫外部 HTTP API
    • 用 pandas 處理 CSV / JSON
    • 串起一小段工作流程（抓資料 → 清洗 → 寫檔 → 發通知）
    • 這些函式會被包裝成 工具（tools），讓 Claude 之類的模型「自動決定要不要呼叫、用哪個參數」。
    • 你的工作：
    • 選幾個 skills
    • 配好權限與 API key
    • 用一個簡單的 Agent shell 把它們掛上去

    結果就是：你不用自己手刻複雜 Agent 架構，只要寫幾個普通的 Python 函式，Claude 就能幫你組成自動化流程。

    核心功能：你可以拿來做什麼

    1. 內建技能類型：檔案、API、資料處理、簡單工作流

    在 anthropics/skills 裡，你可以看到各種已經寫好的 skills（名稱可能持續調整，但類型大致如下）：

    • 檔案相關：
    • 讀寫本機檔案（通常限定在某個資料夾）
    • 列出目錄、建立新檔、更新內容
    • API 呼叫：
    • 通用 HTTP request（GET / POST）
    • 幫你處理 headers、JSON encode / decode
    • 資料處理：
    • 讀寫 CSV / JSON
    • 用 pandas 做簡單統計與篩選
    • 工作流協調：
    • 把多個 skills 串起來：例如「每天定時抓 API → 整理 → 寫報表 → 發通知」

    💡 關鍵： 多數常見「讀檔、叫 API、整理資料」的雜務，其實已經有現成 skill，可以直接拿來組合，而不用從零寫 Agent 架構。

    你可以立刻做的事：

    1. 打開 repo 的 skills/ 資料夾（或類似目錄），挑幾個你看得懂的 Python 檔。
    2. 看每個 skill 的 docstring，理解它預期的輸入、輸出是什麼。
    3. 想一件自己平常重複做的事，先用一個 skill 就好（例如：讀一個 CSV 幫你整理）。

    2. 如何跟你現有專案整合

    Skills 的設計很單純：

    • 你可以把整個 repo 當作 依賴套件 安裝，或直接把單一 skill 檔案 copy 進你專案。
    • 在你自己的 Agent 程式裡，把這些 functions 包成工具，丟給 Claude 使用。

    一個極簡示意（結構可能與實際 repo 有差異，但概念相似）：

    from skills.files import read_file, write_file
from anthropic import Anthropic

client = Anthropic(api_key="YOUR_API_KEY")

TOOLS = [read_file.tool_def, write_file.tool_def]

resp = client.messages.create(
    model="claude-3-7-sonnet-20250219",
    max_tokens=1024,
    tools=TOOLS,
    messages=[{
        "role": "user",
        "content": "請幫我打開 data/report.csv，整理成重點摘要，回給我。"
    }]
)

    Claude 看到 tools 後，會自己決定：

    • 要不要執行 read_file
    • 執行後用結果做後續推理

    你可以立刻做的事：

    • 如果你已經有在用 Claude API，先挑 1–2 個 skills 加進你的工具列表，看看 Claude 會怎樣使用它們。

    3. 搭配其他開源專案：拉出一條多代理 workflow

    有兩個常被一起提到的專案，很適合拿來串：

    名稱 核心功能 免費方案 適合誰
    Claude Skills 可重用的 Python 任務模組，給 Agent 當工具用 開源、自架 想快速做實用 Agent 的開發者、技術 PM
    scientific-agent-skills 研究、工程、金融、寫作等專業領域的技能集 開源、自架 科研團隊、量化分析、技術寫作者
    Personal_AI_Infrastructure 個人 AI 代理基礎架構、多代理協作 開源、自架 想打造個人 AI 工作桌面、內部 Agent 平台的人

    實際串法可以是：

    • 用 Personal_AI_Infrastructure 當「總控台」與排程器
    • 把 Claude Skills + scientific-agent-skills 當作不同專業領域的「工具箱」
    • 例如：
    • Agent A：每天抓研究資料（API + 檔案 download）
    • Agent B：用 scientific-agent-skills 做統計分析
    • Agent C：把結果用 Claude Skills 寫成報告，發到 Slack

    你可以立刻做的事：

    • 先單純在本機跑 Claude Skills，確認流程順暢後，再考慮拉入 Personal_AI_Infrastructure 做多 Agent 編排。

    適合誰用：三種常見場景

    1. 個人開發者 side project：資料整理 bot、FAQ 助理

    具體可以做：

    • 資料整理 bot：
    • 每天從某個 API 抓資料
    • 存成 CSV
    • 請 Claude 用 skills 幫你做摘要或簡單圖表
    • 客服 FAQ 助理：
    • 讀本機的 FAQ 檔案 + 客戶紀錄
    • 自動整理常見問題、生成回覆模板

    行動建議：

    • 先挑「你每天重複做、但不用太精準」的任務，例如：整理 log、閱讀報表。

    2. 小團隊：內部自動化腳本

    適合處理：

    • 例行報表產出
    • 專案進度彙整
    • Jira / GitHub issue 摘要

    作法：

    1. 把資料源（API、CSV）包成 2–3 個自訂 skills。
    2. 寫一個簡單 CLI 或 cron job，每天叫 Claude 跑一次。

    3. 結合其他開源專案：多步驟分析 + 報告

    對研究團隊、數據團隊特別實用：

    • 用 scientific-agent-skills 做嚴謹分析
    • 用 Claude Skills 負責「收資料 / 寫結果 / 發報告」

    行動建議：

    • 先把你現有的分析腳本包一層成 skill，讓 AI 能呼叫；不需要一開始就全部自動化。

    怎麼開始：10 分鐘跑起一個本地小 Agent

    以下示意流程假設你已經有 Claude API key，且會用基本的命令列。

    💡 關鍵： 只要準備 API key、安裝 repo，再加上兩三個簡單 skills，大約 5–10 分鐘內就能跑起第一個可用的本地 Agent。

    步驟 1：Clone 專案 + 安裝依賴

    git clone https://github.com/anthropics/skills.git
cd skills

# 依照專案說明，可能是
pip install -e .
# 或
pip install -r requirements.txt

    行動：確認 python -m skills 或範例指令能跑起來（依官方 README 為準）。

    步驟 2：設定 API Key

    export ANTHROPIC_API_KEY="你的 Claude API key"

    Windows PowerShell：

    $env:ANTHROPIC_API_KEY="你的 Claude API key"

    行動：用 repo 提供的最小範例（例如 examples/basic_agent.py）跑一次，看 Claude 能不能成功呼叫某個內建 skill。

    步驟 3：本機執行一個範例技能

    假設有一個簡單範例（名稱依實際 repo 為準）：

    python examples/list_files_agent.py

    你可能會看到：

    • 問你「要在哪個資料夾工作」
    • Claude 自動呼叫 list_files、read_file 等 skills

    行動：換一個你自己的資料夾（例如放了一些 CSV 報表），觀察 Claude 如何使用 skills 幫你瀏覽、整理。

    步驟 4：改成自己的任務——每天抓一個 API、整理、丟 Slack

    目標：

    1. 每天叫一個公開 API（例如匯率、Crypto 價格）
    2. 整理成簡單文字報表
    3. 發成訊息到 Slack 頻道

    實作方向：

    1. 寫一個自訂 skill：
    # skills/custom/fetch_rates.py
import requests

from skills.core import skill  # 依實際框架命名

@skill
def fetch_rates(base: str = "USD"):
    """從匯率 API 取得最新匯率資料。"""
    url = f"https://api.exchangerate.host/latest?base={base}"
    r = requests.get(url, timeout=10)
    r.raise_for_status()
    return r.json()
    1. 再寫一個發 Slack 的 skill（用 webhook 即可）：
    # skills/custom/post_to_slack.py
import os
import requests
from skills.core import skill

WEBHOOK = os.environ["SLACK_WEBHOOK_URL"]

@skill
def post_to_slack(text: str):
    """把文字訊息丟到預設 Slack 頻道。"""
    r = requests.post(WEBHOOK, json={"text": text}, timeout=10)
    r.raise_for_status()
    return {"status": "ok"}
    1. 寫一個小 Agent 腳本：
    from anthropic import Anthropic
from skills.custom.fetch_rates import fetch_rates
from skills.custom.post_to_slack import post_to_slack

client = Anthropic()

TOOLS = [fetch_rates.tool_def, post_to_slack.tool_def]

prompt = """
你是一個匯率小助理：
1. 先用工具抓最新 USD 匯率
2. 挑出 3 個對我們重要的幣別（EUR, JPY, TWD）
3. 排版成一段適合 Slack 的中文簡報
4. 用工具發到 Slack
"""

resp = client.messages.create(
    model="claude-3-7-sonnet-20250219",
    max_tokens=1024,
    tools=TOOLS,
    messages=[{"role": "user", "content": prompt}]
)

    1. 排程：

    2. Linux / macOS：用 cron 每天跑一次這個腳本

    3. Windows：用排程工作排每日執行

    到這裡，你就已經有一個「完全實用」的小 Agent，在幫你做每天的資訊整理與通知。

    最佳實踐：權限、安全與成本

    1. 限制權限：不要讓 Agent 隨便亂動

    • 檔案操作技能：
    • 設定 專用工作資料夾，例如 ./agent_workspace，只給這個路徑的讀寫權限。
    • API skills：
    • 把 API key 存在環境變數或 secret manager，不要寫死在程式碼。

    2. 記錄 log：看得出 Agent 做了什麼

    • 為每個 skill 加上基本 logging：
    • 呼叫時間
    • 參數（敏感資訊略過）
    • 成功 / 失敗
    • 方便之後調整 prompt 或參數，避免 Agent 做無用功。

    3. 控制成本：避免 runaway cost

    • 在建立 Claude 訊息時：
    • 設 max_tokens 合理上限
    • 控制 context 長度（不要丟整個專案 repo，先丟必要檔案）
    • 如果是排程任務：
    • 從「每天一次」開始
    • 先跑一週看看用量，再決定要不要加頻率或多任務

    💡 關鍵： 先以低頻率、小 context、適中 max_tokens 測試一陣子，再逐步放大規模，可以有效避免成本爆衝。

    總結

    如果你：

    • 會一點 Python
    • 有一些重複的資訊工作
    • 不想研究整套 Agent 框架

    那以 Claude Skills 作為工具層，加上 Claude API 當腦，就足以在 5–10 分鐘內生出一個實用的小 Agent。先從一個最簡單、最無害的任務開始，把整個流程跑順，之後要擴充成多代理、多專案，只是多加幾個 skills 與排程而已。

    🚀 你現在可以做的事

    • 打開 anthropics/skills 並瀏覽 skills/ 目錄，挑 1–2 個看得懂的 skill 研究輸入輸出
    • 在本機依照文中步驟安裝 repo、設定 ANTHROPIC_API_KEY，跑一次官方範例 agent
    • 依照「匯率 + Slack」示例，改寫成你自己的每天例行任務（例如拉報表、整理 log、寄出摘要）
  • 用 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 test、cargo test、pytest、make 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 test、cargo 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