Kerwin AI Information

標籤: Multi-agent

  • 用 Sim 管一整隊 AI 員工

    用 Sim 管一整隊 AI 員工

    📌 本文重點

    • Sim 幫你管理一整隊多 Agent AI
    • 用 TypeScript 定義角色與完整工作流
    • 支援多家 LLM 與外部 API 工具
    • 先從一條固定流程開始導入

    Sim 要解決的問題很單純：你不想再手動 copy / paste 提示詞，而是讓一整隊 AI 员工自己分工、排程、回報進度。

    專案連結：https://github.com/simstudioai/sim

    Sim 是什麼？一句話定位

    如果把 Claude、GPT 看成「單一員工」，Sim 就是幫你管理一整支 AI 團隊的中控台：

    • 不提供自己的模型
    • 專門用來定義多個 Agent 角色（researcher、writer、reviewer…）
    • 負責任務分派、狀態管理、排程
    • 幫你接上各家 LLM 與外部 API / 工具

    你可以把它想成「用 TypeScript 寫的一個 Agent 作業系統」。

    核心功能：用 TypeScript 排好一條完整工作線

    1. 在一個專案裡定義多個 Agent 角色

    Sim 的基礎就是：所有 Agent 都是 TypeScript 物件，你可以清楚寫出每個角色的職責與能力。

    最小範例（簡化版）：

    // agents/researcher.ts
import { defineAgent } from "sim";

export const researcher = defineAgent({
  name: "researcher",
  model: "gpt-4.1",
  instructions: "負責查找資料，整理重點，用 bullet points 回覆。",
});

// agents/writer.ts
export const writer = defineAgent({
  name: "writer",
  model: "claude-3-5-sonnet",
  instructions: "根據研究重點，寫成條理清楚的文章草稿。",
});

// agents/reviewer.ts
export const reviewer = defineAgent({
  name: "reviewer",
  model: "gpt-4o",
  instructions: "檢查文章結構、錯字與邏輯，提出修改建議。",
});

    你可以採取的行動：

    • 先從兩個角色開始（例如 researcher + writer），不要一開始就弄 5 個 Agent
    • 把你平常給 ChatGPT 的系統提示，搬進 instructions 裡

    💡 關鍵： 所有 Agent 以 TypeScript 物件定義，讓職責、模型與提示詞都可版本控制與共用。

    2. 中央排程、任務分派與狀態管理

    有了多個 Agent，接下來是：誰先做、做完交給誰、每一步狀態記錄在哪？

    Sim 提供「任務 orchestrator」，你可以用工作流的方式描述整條流程：

    // workflows/contentPipeline.ts
import { defineWorkflow } from "sim";
import { researcher, writer, reviewer } from "../agents";

export const contentPipeline = defineWorkflow({
  name: "content-pipeline",
  steps: [
    {
      agent: researcher,
      input: (task) => `請針對主題：${task.topic} 搜集 5 個重點`,
      saveAs: "researchNotes",
    },
    {
      agent: writer,
      input: (ctx) => ctx.researchNotes,
      saveAs: "draft",
    },
    {
      agent: reviewer,
      input: (ctx) => ctx.draft,
      saveAs: "reviewedDraft",
    },
  ],
});

    這段程式直接做到：

    • 定義固定步驟順序（research → write → review）
    • 每一步產出的結果存進 context（researchNotes / draft）
    • 後面 Agent 直接讀 context，不用你再 copy / paste

    你可以採取的行動：

    • 先用一條同步工作流（一次跑完）熟悉 API
    • 等熟悉後再考慮加排程（例如每天 9 點自動跑一次報表）

    💡 關鍵： 透過 workflow 把多步驟流程寫死在程式中，避免人工在多個對話間來回 copy / paste。

    3. 接現有 LLM 與外部 API / 工具

    Sim 本身不訓練模型，而是非常直接地：

    • 支援 OpenAI / Anthropic / Mistral 等主流 LLM
    • 可設定不同 Agent 用不同模型（便宜模型做抓資料，貴模型做審稿）
    • 提供工具介面讓 Agent 呼叫外部 API

    範例：設定不同 Agent 用不同 provider：

    // config/models.ts
export const models = {
  cheap: { provider: "openai", model: "gpt-4.1-mini" },
  strong: { provider: "anthropic", model: "claude-3-5-sonnet" },
};

    // agents/reportBot.ts
import { defineAgent } from "sim";
import { models } from "../config/models";

export const reportBot = defineAgent({
  name: "report-bot",
  model: models.cheap,
  tools: ["fetchSalesAPI", "generateCSV"],
});

    你可以採取的行動：

    • 先只用一個 provider（例如 OpenAI 或 Anthropic），確保 key 正常
    • 把現有內部 API 包成簡單 function（例如 fetchIssues()），讓 Agent 直接呼叫

    延伸閱讀：關於「模型只是基礎，缺的是中間這層 Agent / Workflow」的觀念，可以看這篇：
    From Models to Agents: The Missing Layer Between AI and Real Problems
    https://pub.towardsai.net/from-models-to-agents-the-missing-layer-between-ai-and-real-problems-8b08498780bd

    適合誰用？三個具體場景

    1. 內容生產流水線：多步驟寫作

    典型流程：

    1. researcher：收集資料、整理架構
    2. writer：產生初稿
    3. editor / reviewer：針對品牌語氣、錯字、結構調整

    用 Sim，你可以：

    • 把這條線寫成一支 workflow
    • 每天丟一批題目進去，由 AI 團隊自動輸出草稿
    • 人類只負責最後一層審稿

    行動建議：

    • 先挑一種固定格式內容（例如每週電子報）導入，不要從最複雜的長文開始

    💡 關鍵： 把「固定格式內容」交給多 Agent 流水線，可穩定產出草稿，讓人類專注在高價值審稿。

    2. 程式碼維護：issue triage → patch → review

    典型流程：

    1. triage Agent：閱讀 issue / log，分類並估工
    2. patch Agent：嘗試產生修補碼
    3. reviewer Agent：檢查 patch 是否合理

    這個工作流很適合用 Sim：

    • 由 triage Agent 先過一遍 backlog，把 issue 打標籤
    • patch Agent 先產生 PR 草稿
    • reviewer Agent 給出建議，最後再交給人類工程師合併

    行動建議：

    • 先從「只產出 patch 草稿，不自動 merge」開始，上線風險較低

    3. 資料處理 / 報表自動化

    場景：

    • 每天從內部系統拉數據
    • 清洗 / 合併
    • 生成自然語言報表，發到 Slack / Email

    用 Sim 可以：

    1. data-fetcher Agent：呼叫 API 把原始資料抓回來
    2. transformer Agent：整理成標準格式
    3. reporter Agent：寫出「本日營收摘要」「異常提醒」

    行動建議：

    • 從一份你現在已經在做的固定報表開始，把現有流程翻成 workflow

    怎麼開始：最小 Demo 三步走

    下面是一條「10 分鐘內跑起來」的路線，假設你有基本 Node / TypeScript 基礎。

    步驟 1：拉專案 + 安裝

    git clone https://github.com/simstudioai/sim
cd sim
pnpm install # 或 npm install / yarn

    （建議用 pnpm，與官方 repo 一致。）

    步驟 2：設定 LLM Key

    1. 建一個 .env 或使用 repo 提供的環境變數範本
    2. 至少填一個 provider：
    OPENAI_API_KEY=你的key
# 或
ANTHROPIC_API_KEY=你的key
    1. 在 config 檔裡確認預設 model 指向你有 key 的 provider。

    步驟 3：啟動一個簡單 workflow

    1. 在 examples/ 目錄中選一個最小示例（通常會有 content pipeline / hello-world workflow）
    2. 執行：
    pnpm run dev
# 或 repo 內標註的 demo 指令，例如：
pnpm run demo:content
    1. 到終端機或簡單 web UI 中，輸入一個主題，例如：
    {
  "topic": "2025 年 AI 多 Agent 平台現況"
}

    你應該會看到：

    • researcher 的查資料結果
    • writer 的初稿
    • reviewer 的修改建議

    行動建議：

    • 先改一下 instructions，讓它用你的品牌語氣寫，感受一次「只改提示就換整隊 AI 風格」的效果

    跟現有工具銜接：Routing、MCP、部署注意事項

    與 Routing 工具（如 Followloop）搭配

    Sim 專注在「多 Agent 工作流內部的協作」，而像 Followloop 這類工具更像是：

    • 負責不同入口的請求路由（例如：客服問答 → FAQ Agent；技術問題 → Dev Agent）
    • 決定「這個請求要送到哪條 Sim workflow」

    實際做法：

    • Followloop 端：根據使用者請求分類，決定要呼叫哪個 Sim API endpoint
    • Sim 端：把每條 workflow 對外暴露成 HTTP endpoint
    名稱 核心功能 免費方案 適合誰
    Sim 多 Agent 工作流編排與執行 開源、可自架 想打造 AI 團隊的人
    Followloop 請求路由與入口流量分配 視官方方案而定 有多入口流量的產品

    與 MCP 工具共用

    現在很多工具透過 MCP（Model Context Protocol）暴露能力，例如：

    • 檔案系統存取
    • 資料庫查詢
    • 內部 API 代理

    你可以：

    • 在 Sim 的 Agent 定義裡，把 MCP 工具包裝成 tool
    • 讓 Agent 在 workflow 中直接呼叫 MCP 工具

    好處是：

    • 你不用重寫工具，Sim 只負責編排誰在什麼時候用哪個工具

    部署：Vercel 或自家伺服器

    Sim 是 TypeScript 專案，所以部署邏輯跟一般 Node / Next app 相近。

    部署到 Vercel 時注意：

    • 把各家 LLM 的 API key 設成 Vercel environment variables
    • workflow 若有排程，需要配合 Vercel cron / Edge function 或外部 scheduler
    • 注意 Vercel 的執行時間限制，長任務可能要改為 background job

    部署在自家伺服器時注意：

    一句話收尾：先把你的一條「固定流程」交給 Sim

    不要一口氣把所有工作丟給多 Agent 系統，先挑一條你每天都在重複的流程（例如每週電子報、bug triage、固定報表），在 Sim 裡寫成 workflow，跑通一次，就能感受到「管理一整隊 AI 員工」的差別。

    🚀 你現在可以做的事

    • 到 GitHub 把 sim 專案 git clone 下來，跑一次官方 examples workflow
    • 把你現行的一條固定流程畫成步驟圖，翻成第一個 Sim workflow
    • 把現有給 ChatGPT 的系統提示整理進 instructions，測試同一 workflow 換不同提示的效果
  • 用 openai-agents-python 搭一個 AI 小團隊

    用 openai-agents-python 搭一個 AI 小團隊

    📌 本文重點

    • 用多個專職 agent 分工處理一個大任務
    • 透過 orchestrator 串起明確的多步驟流程
    • 將既有 API / 工具包成 @tool 打造可落地工作流
    • 先做最小 demo，再逐步擴展到既有系統

    只靠一個聊天機器人常常做出「四不像」的結果，而 openai‑agents‑python 要解決的，就是讓你把一個大任務拆給多個各司其職的 AI 代理人，像一個小團隊一樣協作完成。

    GitHub 專案連結：https://github.com/openai/openai-agents-python

    核心功能：把一個大任務拆給多個 AI

    1. 定義多個專長不同的 Agent

    你可以在程式裡定義多個「角色」：

    • 資料蒐集 agent：負責上網查資料、整理重點
    • 寫作／寫程式 agent：負責產出初稿或程式碼
    • 審稿 agent：負責檢查結構、風格、錯字或潛在 bug

    這些都用 Python class 或函式就能描述，像這樣：

    from openai_agents import Agent

researcher = Agent(
    name="researcher",
    instructions="你負責閱讀提供的資料，整理三個重點與參考連結。",
)

writer = Agent(
    name="writer",
    instructions="你負責寫出條列清楚的技術部落格草稿，語氣教學向。",
)

reviewer = Agent(
    name="reviewer",
    instructions="你負責審稿，只給出修改建議與需要補充的段落。",
)

    行動：先想一個你日常會做的「三步驟」任務，直接對應成三個 agent 的職責。

    2. 設計任務流程：交接、審查、協作

    openai‑agents‑python 的重點不只是「多個 agent」，而是讓你把流程寫清楚：誰先做、誰接手、誰審查。

    例如做一個「自動寫技術部落格」的流程：

    1. researcher：根據題目蒐集資料，產出重點摘要
    2. writer：根據摘要寫出完整草稿
    3. reviewer：審稿，給出修改建議

    💡 關鍵： 把一長串需求拆成 2–3 個明確步驟，比一次丟給單一聊天模型更穩定、可控。

    在框架裡你可以用一個 orchestrator（像主揪）來控制：

    from openai_agents import Orchestrator

orchestrator = Orchestrator(agents=[researcher, writer, reviewer])

async def run_blog_flow(topic: str):
    research_notes = await orchestrator.run("researcher", input={"topic": topic})
    draft = await orchestrator.run("writer", input={"topic": topic, "notes": research_notes})
    review = await orchestrator.run("reviewer", input={"draft": draft})
    return {"draft": draft, "review": review}

    行動：把你現在用 ChatGPT 一次請他「幫我想題目、寫文、修稿」的流程，拆成 2–3 個步驟，寫在紙上，對應到上面這種 orchestrator 程式碼結構。

    3. 串接外部工具與 API，變成真的工作流

    openai‑agents‑python 支援 agent 呼叫你自定義的工具函式，例如：

    • 網頁爬蟲（requests、Playwright）
    • 存取資料庫或 Google Sheets
    • 操作檔案系統，輸出成 Excel / CSV

    你先寫好 Python 函式，再把它註冊給 agent 使用：

    import requests
from openai_agents import tool

@tool
def fetch_url(url: str) -> str:
    """抓取指定網址的 HTML"""
    return requests.get(url, timeout=10).text

scraper = Agent(
    name="scraper",
    instructions="根據給定網址抓網頁內容並擷取需要的欄位。",
    tools=[fetch_url],
)

    行動：先選一個你常用的 API（例如某個內部 HTTP API、Notion API），包成一個最小的 @tool 函式，讓 agent 能直接呼叫。

    Demo：一晚內做完的「自動寫技術部落格」小團隊

    這裡做一個最小可用版本：輸入一個主題，幫你：

    1. 蒐集重點
    2. 產生技術部落格草稿
    3. 用 reviewer 做一次審查，輸出建議

    步驟 0：安裝與環境準備

    pip install openai-agents-python openai

    在專案根目錄建立 .env（或直接用環境變數）：

    export OPENAI_API_KEY="你的 API Key"

    💡 關鍵： 只要設定好 OPENAI_API_KEY，就能在一晚內跑起一個可用的多 agent 小流程。

    步驟 1：建立第一個 writer agent

    新增 agents_blog.py：

    from openai_agents import Agent

writer = Agent(
    name="writer",
    instructions=(
        "你是技術部落客，請用繁體中文寫 1200 字內的教學文，"
        "條列清楚、加上小標題，讀者是有基礎的工程師。"
    ),
)

    先單獨測試這個 agent：

    import asyncio
from agents_blog import writer

async def main():
    result = await writer.run({"topic": "Python logging 實戰"})
    print(result)

if __name__ == "__main__":
    asyncio.run(main())

    行動：先確保「單一 agent + 單一呼叫」正常運作，看到一篇文章草稿再往下加複雜度。

    步驟 2：加上 researcher + reviewer

    修改 agents_blog.py：

    from openai_agents import Agent

researcher = Agent(
    name="researcher",
    instructions=(
        "你負責針對主題列出 5 個實用重點與常見坑，"
        "輸出 JSON 格式：{\"key_points\": [...]}。"
    ),
)

writer = Agent(
    name="writer",
    instructions=(
        "根據 research.key_points 寫技術部落格，"
        "包含簡介、實作步驟與常見錯誤排查。"
    ),
)

reviewer = Agent(
    name="reviewer",
    instructions=(
        "你是嚴格的技術編輯，檢查草稿是否：1) 結構清楚、"
        "2) 範例正確、3) 沒有太多空話。輸出建議清單。"
    ),
)

    再加一個 orchestrator 流程（新檔 run_blog.py）：

    import asyncio
from openai_agents import Orchestrator
from agents_blog import researcher, writer, reviewer

orchestrator = Orchestrator(agents=[researcher, writer, reviewer])

async def run_blog(topic: str):
    research_notes = await orchestrator.run("researcher", input={"topic": topic})
    draft = await orchestrator.run("writer", input={"topic": topic, "research": research_notes})
    review_notes = await orchestrator.run("reviewer", input={"draft": draft})

    print("=== 草稿 ===\n")
    print(draft)
    print("\n=== 審稿建議 ===\n")
    print(review_notes)

if __name__ == "__main__":
    topic = input("輸入技術主題：")
    asyncio.run(run_blog(topic))

    行動：實際輸入你下週想寫的一個主題，看這個流程能不能生成一份你「願意再改一版就能上 blog」的草稿。

    步驟 3：做成簡單 CLI 或排程

    CLI（已經算一種）：

    python run_blog.py

    若要每天自動產出草稿，可以用 crontab：

    crontab -e
# 每天早上 9 點產出一篇關於 Python 的文章
0 9 * * * cd /path/to/project && OPENAI_API_KEY=xxx python run_blog.py <<EOF
Python 非同步程式設計實戰
EOF

    行動：先用 CLI 手動跑幾次，確認品質與 token 消耗，再考慮排程自動化。

    適合誰用？幾個具體場景

    • 工程師／資料工程師：
    • 資料抓取 → 清洗 → 產出報表（多個 agent 分別負責）
    • 專案 scaffold 生成 → 單元測試撰寫 → reviewer 檢查風險
    • 技術寫作者 / Developer Advocate：
    • 自動產出技術部落格初稿、Release Note、API 範例
    • 內部平台團隊：
    • 把既有的 CI/CD、監控 API 包成工具，讓 AI agent 幫忙查 log、整理 incident 報告

    💡 關鍵： 只要你習慣在 ChatGPT 下一長串指令，就幾乎一定能拆成 multi‑agent workflow 減少來回與手動操作。

    只要你目前已經在用 ChatGPT 做「一長串指令」，就適合把流程拆成 multi‑agent workflow 測試看看。

    延伸應用：部署、成本控制、整合現有系統

    1. 部署到雲端

    • 用 FastAPI 或 Flask 包一層 HTTP API，把 orchestrator 暴露成 /run_flow endpoint
    • 部署到 Render / Railway / Fly.io / 自家 Kubernetes，都只是一般 Python Web 服務部署流程

    2. 控制成本與錯誤

    • 限制 max_tokens / 模型：對只負責小任務的 agent 用較便宜的模型
    • 加上 retry + logging：為 orchestrator 跑的每一步記錄 prompt、輸出與 token 使用
    • 設定明確 instructions：讓 reviewer 僅輸出「建議清單」，避免重複生成整篇文章浪費 token

    3. 與既有後端或 Slack Bot 整合

    • 既有後端：在服務裡呼叫 orchestrator，把結果回寫資料庫或觸發其他工作
    • Slack Bot：
    • 用 Slack API 建一個 slash command /ai-team
    • 收到指令後，把文字丟給 orchestrator，完成後再貼回頻道

    行動：先選一個「已在跑的」後端流程（例如每週報表），先只把其中一段換成 agent 完成，觀察穩定度與成本。

    怎麼開始：最快上手路徑

    1. 看 GitHub README：https://github.com/openai/openai-agents-python
    2. 先實作一個最小 demo：如本文的 blog flow 或「抓網頁 → 清洗 → 匯出 CSV」
    3. 再慢慢拆更多 agent：把你原本寫在同一個 prompt 或腳本裡的步驟，一個一個拆成獨立角色

    只要先完成一個「今晚就能跑起來」的小流程，你之後會很自然開始想：還有哪些工作可以交給這個 AI 小團隊做。

    🚀 你現在可以做的事

    • 打開專案，實作一個最小的 writer agent 並用單一呼叫產出一篇草稿
    • 把你常用的一個內部或公開 HTTP API 包成 @tool，讓 agent 能直接呼叫
    • 依照文中的 researcher → writer → reviewer 範例，寫出自己的第一個 orchestrator 流程並在本機跑一次