0. 前言：金融 AI 多智能體的挑戰

隨著 AI Agent 技術的成熟，金融領域成為多智能體系統的重要應用場景。然而，構建一個實用的金融 AI 平台面臨多重挑戰：

• 數據來源多樣：美股 SEC 文件、A 股財報、加密貨幣數據、新聞資訊
• 任務類型複雜：研究分析、交易執行、定時監控、策略回測
• 安全性要求高：API 密鑰管理、本地數據存儲、交易風控
• 可擴展性需求：支持多種 LLM、多個交易所、社群貢獻的 Agent

ValueCell 是一個開源的金融多智能體平台，採用 Planner-Executor 架構，實現了從使用者意圖理解到任務執行的完整鏈路。本文將從工程角度深入剖析其設計與實現。

---

1. 項目概覽

1.1 核心定位

ValueCell 是一個社群驅動的多智能體金融應用平台，
目標是打造全球最大的去中心化金融智能體社群。

核心功能：

• 提供頂尖投資智能體團隊（選股、調研、追蹤、交易）
• 敏感資訊完全託管本地
• 支持多種 LLM Provider 和交易所

1.2 技術棧總覽

層級	技術選型
後端	Python 3.12+, FastAPI, Uvicorn, SQLite
前端	React 19, TypeScript, Vite, TailwindCSS
桌面端	Tauri 2.x (Rust)
AI 框架	Agno (Agent Framework)
向量數據庫	LanceDB
狀態管理	Zustand
LLM 支持	OpenRouter, SiliconFlow, Google, OpenAI, Azure, DeepSeek

1.3 專案結構

valuecell/
├── python/                    # 後端核心
│   ├── valuecell/
│   │   ├── core/             # 核心模組
│   │   │   ├── plan/         # Planner (任務規劃)
│   │   │   ├── task/         # Task (任務模型與執行)
│   │   │   ├── coordinate/   # Orchestrator (協調器)
│   │   │   ├── super_agent/  # Super Agent (入口分流)
│   │   │   ├── agent/        # Agent 基礎設施
│   │   │   └── conversation/ # 對話管理
│   │   ├── agents/           # 具體 Agent 實現
│   │   │   ├── research_agent/
│   │   │   ├── news_agent/
│   │   │   ├── prompt_strategy_agent/
│   │   │   └── grid_agent/
│   │   ├── server/           # FastAPI 服務
│   │   ├── adapters/         # 數據適配器
│   │   └── config/           # 配置管理
│   └── configs/              # YAML 配置檔
├── frontend/                  # React 前端
│   ├── src/
│   │   ├── app/              # 頁面路由
│   │   ├── api/              # API 客戶端
│   │   ├── components/       # UI 組件
│   │   └── store/            # Zustand 狀態
│   └── src-tauri/            # Tauri 桌面端
└── docs/                      # 文檔

---

2. 系統架構

2.1 整體架構圖

flowchart TB
    subgraph Frontend["前端層 (React + Tauri)"]
        UI[Web UI / Desktop App]
        SSE[SSE 串流接收]
    end

    subgraph Backend["後端層 (FastAPI)"]
        API[API Router]
        Orchestrator[AgentOrchestrator]

        subgraph CoreServices["核心服務"]
            SuperAgent[Super Agent Service]
            PlanService[Plan Service]
            TaskExecutor[Task Executor]
            ConvService[Conversation Service]
        end
    end

    subgraph AgentLayer["Agent 層"]
        Planner[ExecutionPlanner]

        subgraph Agents["遠端 Agents"]
            ResearchAgent[Research Agent]
            NewsAgent[News Agent]
            StrategyAgent[Strategy Agent]
            GridAgent[Grid Agent]
        end
    end

    subgraph External["外部服務"]
        LLM[LLM Providers]
        Exchange[交易所 API]
        DataSource[數據來源]
    end

    UI --> API
    API --> Orchestrator
    Orchestrator --> SuperAgent
    Orchestrator --> PlanService
    Orchestrator --> TaskExecutor

    PlanService --> Planner
    Planner --> LLM

    TaskExecutor --> Agents
    Agents --> LLM
    Agents --> DataSource
    StrategyAgent --> Exchange

    Orchestrator --> SSE
    SSE --> UI

2.2 核心設計模式

ValueCell 採用 Planner-Executor 分離架構：

1. Super Agent：入口分流，判斷是直接回答還是交給 Planner
2. Planner：理解使用者意圖，規劃任務，選擇 Agent
3. Executor：執行具體任務，串流回傳結果

這種設計的優勢：

• 關注點分離：規劃邏輯與執行邏輯解耦
• 可擴展性：新增 Agent 只需實現標準介面
• Human-in-the-Loop：支持執行中斷、使用者確認

---

3. 核心流程深度解析

3.1 完整請求處理流程

sequenceDiagram
    participant User as 使用者
    participant UI as 前端
    participant API as FastAPI
    participant Orch as Orchestrator
    participant SA as Super Agent
    participant Plan as Planner
    participant Exec as Executor
    participant Agent as Target Agent
    participant LLM as LLM Provider

    User->>UI: 輸入查詢
    UI->>API: POST /api/v1/agent/stream
    API->>Orch: process_user_input()

    Note over Orch: 建立 Conversation
    Orch->>Orch: ensure_conversation()
    Orch-->>UI: SSE: conversation_started
    Orch-->>UI: SSE: thread_started

    alt 目標是 Super Agent
        Orch->>SA: run(user_input)
        SA->>LLM: 分析意圖

        alt 簡單問題
            SA-->>Orch: decision=ANSWER
            Orch-->>UI: SSE: message_chunk
        else 複雜任務
            SA-->>Orch: decision=HANDOFF_TO_PLANNER
            Note over Orch: 繼續到 Planner 階段
        end
    end

    Orch->>Plan: start_planning_task()
    Orch-->>UI: SSE: tool_call_started (generate_execution_plan)
    Plan->>LLM: 規劃任務

    alt 需要使用者確認
        Plan-->>Orch: adequate=false
        Orch-->>UI: SSE: plan_require_user_input
        User->>UI: 確認/提供資訊
        UI->>Orch: 繼續執行
    end

    Plan-->>Orch: ExecutionPlan (tasks)
    Orch-->>UI: SSE: tool_call_completed

    loop 每個 Task
        Orch->>Exec: execute_plan()
        Exec->>Agent: stream(query)
        Agent->>LLM: 執行任務
        Agent-->>Exec: StreamResponse
        Exec-->>UI: SSE: message_chunk / tool_call
    end

    Orch-->>UI: SSE: done

3.2 Orchestrator 核心邏輯

AgentOrchestrator 是整個系統的協調中心：

# python/valuecell/core/coordinate/orchestrator.py

class AgentOrchestrator:
    """Coordinate planning, execution, and persistence across services."""

    async def process_user_input(
        self, user_input: UserInput
    ) -> AsyncGenerator[BaseResponse, None]:
        """
        Stream responses for a user input, decoupled from the caller's lifetime.

        關鍵設計：
        - 背景任務獨立於 SSE 連接生命週期
        - 使用 asyncio.Queue 解耦生產者/消費者
        - 支持 Human-in-the-Loop 中斷
        """
        queue: asyncio.Queue = asyncio.Queue()
        active = {"value": True}

        async def emit(item):
            if active["value"]:
                await queue.put(item)

        # 啟動背景任務
        asyncio.create_task(self._run_session(user_input, emit))

        # 串流輸出
        while True:
            item = await queue.get()
            if item is None:
                break
            yield item

核心設計點：

1. 生產者/消費者解耦：使用 asyncio.Queue 讓背景任務獨立運行
2. 生命週期管理：即使 SSE 連接斷開，任務也會繼續執行
3. 執行上下文：支持任務暫停、恢復（ExecutionContext）

3.3 Execution Context 狀態機

stateDiagram-v2
    [*] --> ACTIVE: 建立對話
    ACTIVE --> PLANNING: 開始規劃
    PLANNING --> REQUIRE_USER_INPUT: 需要確認
    REQUIRE_USER_INPUT --> PLANNING: 使用者回應
    PLANNING --> EXECUTING: 規劃完成
    EXECUTING --> COMPLETED: 任務完成
    EXECUTING --> FAILED: 任務失敗
    REQUIRE_USER_INPUT --> EXPIRED: 逾時
    EXPIRED --> [*]
    COMPLETED --> [*]
    FAILED --> [*]

---

4. Multi-Agent 設計

4.1 Agent 層級架構

flowchart TB
    subgraph EntryLayer["入口層"]
        SuperAgent[ValueCell Agent<br/>Super Agent]
    end

    subgraph PlanningLayer["規劃層"]
        Planner[Execution Planner]
    end

    subgraph ExecutionLayer["執行層"]
        ResearchAgent[Research Agent<br/>金融研究]
        NewsAgent[News Agent<br/>新聞監控]
        StrategyAgent[Strategy Agent<br/>交易策略]
        GridAgent[Grid Agent<br/>網格交易]
    end

    SuperAgent -->|簡單問題| DirectAnswer[直接回答]
    SuperAgent -->|複雜任務| Planner
    Planner -->|選擇Agent| ExecutionLayer

4.2 Agent Card 機制

每個 Agent 透過 Agent Card 描述其能力，供 Planner 選擇：

# configs/agent_cards/research_agent.yaml
name: "Research Agent"
description: "金融研究助手，專門分析公司財報、SEC 文件和市場數據"
skills:
  - id: "sec_filing_analysis"
    name: "SEC Filing Analysis"
    description: "獲取並分析 10-K, 10-Q, 8-K 等 SEC 文件"
    examples:
      - "What was Apple's Q2 2024 revenue?"
      - "Analyze Tesla's latest 10-K risk factors"
    tags: ["research", "fundamentals", "sec"]

  - id: "ashare_analysis"
    name: "A-Share Analysis"
    description: "分析中國 A 股公司財報"
    examples:
      - "茅台2024年年報的營收是多少？"
    tags: ["research", "china", "ashare"]

Planner 使用 tool_get_enabled_agents() 獲取所有可用 Agent：

def tool_get_enabled_agents(self) -> str:
    map_agent_name_to_card = self.agent_connections.get_planable_agent_cards()
    parts = []
    for agent_name, card in map_agent_name_to_card.items():
        parts.append(f"<{agent_name}>")
        parts.append(agentcard_to_prompt(card))
        parts.append(f"</{agent_name}>\n")
    return "\n".join(parts)

4.3 Research Agent 詳解

Research Agent 是最核心的 Agent，具備多種金融數據工具：

# python/valuecell/agents/research_agent/core.py

class ResearchAgent(BaseAgent):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)

        # 工具列表
        tools = [
            fetch_periodic_sec_filings,   # 10-K, 10-Q
            fetch_event_sec_filings,      # 8-K, Form 3/4/5
            fetch_ashare_filings,         # A 股財報
            web_search,                   # 網路搜尋
            search_crypto_projects,       # 加密貨幣項目
            search_crypto_vcs,            # VC 機構
            search_crypto_people,         # 加密貨幣人物
        ]

        # 知識庫
        knowledge = get_knowledge()

        self.knowledge_research_agent = Agent(
            model=get_model_for_agent("research_agent"),
            instructions=[KNOWLEDGE_AGENT_INSTRUCTION],
            expected_output=KNOWLEDGE_AGENT_EXPECTED_OUTPUT,
            tools=tools,
            knowledge=knowledge,
            search_knowledge=knowledge is not None,
            # 對話記憶
            add_history_to_context=True,
            num_history_runs=3,
            read_chat_history=True,
            enable_session_summaries=True,
        )

工具路由矩陣：

查詢類型	優先工具	備用工具
具體數字 (營收、淨利)	SEC Filings	Knowledge Base
事件披露 (8-K, 股權變動)	Event Filings	Web Search
分析性問題 (趨勢、比較)	Knowledge Base	SEC Filings
A 股數據	A-Share Filings	Knowledge Base

---

5. Prompt Engineering 深度解析

5.1 Prompt 層級架構

ValueCell 的 Prompt 設計採用分層結構：

flowchart TB
    subgraph SuperAgentPrompt["Super Agent Prompt"]
        SA_Purpose[Purpose: 入口分流]
        SA_Rules[Core Rules: 回答/移交決策]
        SA_Matrix[Decision Matrix]
    end

    subgraph PlannerPrompt["Planner Prompt"]
        P_Purpose[Purpose: 透明代理]
        P_Rules[Core Rules: Agent 選擇]
        P_Schedule[Schedule Handling]
        P_Output[Output Format: JSON]
    end

    subgraph AgentPrompt["Agent Prompt (Research)"]
        A_Purpose[Purpose: 金融研究]
        A_Tools[Tool Guidelines]
        A_Routing[Routing Matrix]
        A_Output[Output Format]
    end

    SuperAgentPrompt --> PlannerPrompt
    PlannerPrompt --> AgentPrompt

5.2 Super Agent Prompt 設計

核心任務：快速分流，減少不必要的 Planner 調用

<purpose>
You are a frontline Super Agent that triages incoming user requests.
Your job is to:
- If the request is simple or factual and can be answered safely
  and directly, answer it.
- Otherwise, hand off to the Planner by returning a concise,
  well-formed `enriched_query` that preserves the user's intention.
</purpose>

決策矩陣：

<decision_matrix>
- Simple, factual, safe to answer → decision=answer with a short reply.
- Complex/ambiguous/needs tools or specialized agents
  → decision=handoff_to_planner with enriched_query.
- Missing detail but a safe default yields value
  → decision=answer with a brief assumption note.
</decision_matrix>

關鍵設計原則：

1. 避免失敗主義措辭：不說 “I can’t”，而是積極移交
2. 不假裝執行：不聲稱呼叫了 API 或獲取了數據
3. 語言對齊：使用使用者的語言回應

5.3 Planner Prompt 設計

核心任務：透明代理，最小化干預

<purpose>
Act as a transparent proxy for the user:
- if they specify a target agent, forward their request unchanged
- if they don't specify an agent, select the best-fit agent
Only intervene specially for recurring/scheduled requests
that need user confirmation.
</purpose>

Agent 選擇邏輯：

<core_rules>
2) Agent selection when missing
- If target_agent_name is missing or empty, call tool_get_enabled_agents,
  compare each agent's Description and Available Skills with the query,
  and pick the clearest match.
- Do not split into multiple tasks.
- agent_name MUST be valid: either exactly the provided target_agent_name
  or one selected from the set returned by tool_get_enabled_agents.
</core_rules>

排程處理：

<schedule_config>
- Intervals: map phrases like "every hour", "every 30 minutes"
  to schedule_config.interval_minutes
- Daily time: map phrases like "every day at 9 AM"
  to schedule_config.daily_time (24-hour HH:MM format)
- Only one of interval_minutes or daily_time should be set
</schedule_config>

輸出格式：

{
  "tasks": [
    {
      "title": "Short task title",
      "query": "Original user query (unchanged for normal)",
      "agent_name": "Provided agent or best-fit agent",
      "pattern": "once | recurring",
      "schedule_config": {
        "interval_minutes": null,
        "daily_time": "09:00"
      }
    }
  ],
  "adequate": true,
  "reason": "Brief explanation",
  "guidance_message": "Required when adequate is false"
}

5.4 Research Agent Prompt 設計

核心任務：金融研究助手

<purpose>
You are a financial research assistant. Your primary objective is to
satisfy the user's information request about a company's financials,
filings, or performance with accurate, sourceable, and actionable answers.
</purpose>

工具使用指南：

<tool_usage_guidelines>
1. Batch parameters: For multi-period requests, prefer a single broader
   call (e.g., year=2024) over multiple quarterly calls.
2. Call budget: Avoid more than 3 filing-tool calls per response.
3. Smart defaults: If year/quarter are missing, use the most recent
   available period.
4. Routing by query type: see <routing_matrix> to decide filings-first
   vs KB-first.
5. On tool failure: return partial findings, state the fact succinctly,
   and propose concrete next steps.
</tool_usage_guidelines>

A 股特殊規則：

<ashare_rules>
- ALWAYS use English report types: "annual", "semi-annual", "quarterly"
- NEVER use Chinese terms like "年報/半年報/季報" in the API call
- Stock codes should be 6 digits (e.g., "600519" for Moutai)
- Mapping: 年報→annual, 半年報→semi-annual, 季報→quarterly
</ashare_rules>

輸出風格適應：

<output_format>
**For factual queries** (e.g., "What was Apple's Q2 2024 revenue?"):
- Lead with a direct answer in plain language
- Follow with 2-3 key supporting facts with sources
- Keep it concise (2-3 paragraphs max)

**For analytical queries** (e.g., "How is Apple's profitability trending?"):
- Start with an interpretive summary
- Weave data points into the narrative naturally
- Explain what the numbers mean in business terms
- Use headers to organize longer responses

**For exploratory queries** (e.g., "What should I know about Tesla's risks?"):
- Organize by themes with clear headers
- Prioritize insights over raw data dumps
- Make connections between different pieces of information
</output_format>

---

6. Task 模型與執行

6.1 Task 狀態機

stateDiagram-v2
    [*] --> PENDING: 建立任務
    PENDING --> RUNNING: start()
    RUNNING --> WAITING_INPUT: 需要使用者輸入
    WAITING_INPUT --> RUNNING: 使用者回應
    RUNNING --> COMPLETED: complete()
    RUNNING --> FAILED: fail(error)
    RUNNING --> CANCELLED: cancel()
    COMPLETED --> [*]
    FAILED --> [*]
    CANCELLED --> [*]

6.2 Task 資料模型

# python/valuecell/core/task/models.py

class Task(BaseModel):
    task_id: str
    title: str
    query: str
    conversation_id: str
    thread_id: str
    user_id: str
    agent_name: str

    # 狀態
    status: TaskStatus = TaskStatus.PENDING
    pattern: TaskPattern = TaskPattern.ONCE
    schedule_config: Optional[ScheduleConfig] = None

    # 時間戳
    created_at: datetime
    started_at: Optional[datetime]
    completed_at: Optional[datetime]

    # 結果
    error_message: Optional[str]
    remote_task_ids: List[str] = []
    handoff_from_super_agent: bool = False

6.3 排程任務

支持兩種排程模式：

1. 間隔執行：interval_minutes (e.g., 每 60 分鐘)
2. 每日定時：daily_time (e.g., “09:00”)

class ScheduleConfig(BaseModel):
    interval_minutes: Optional[int] = None
    daily_time: Optional[str] = None  # HH:MM format

    def is_valid(self) -> bool:
        return self.interval_minutes is not None or self.daily_time is not None

---

7. 配置系統

7.1 三層配置優先級

flowchart TB
    ENV[環境變數] --> DOT_ENV[.env 檔案] --> YAML[YAML 配置]

    ENV -->|最高優先| Final[最終配置]
    DOT_ENV -->|中等優先| Final
    YAML -->|最低優先| Final

7.2 Provider 配置

# configs/providers/openrouter.yaml
connection:
  base_url: "https://openrouter.ai/api/v1"
  api_key_env: "OPENROUTER_API_KEY"

default_model: "anthropic/claude-haiku-4.5"

defaults:
  temperature: 0.5
  max_tokens: 4096

7.3 Agent 配置

# configs/agents/research_agent.yaml
name: "Research Agent"
enabled: true

models:
  primary:
    model_id: "google/gemini-2.5-flash"
    provider: "openrouter"
    provider_models:
      siliconflow: "Qwen/Qwen3-235B-A22B-Thinking-2507"
      google: "gemini-2.5-flash"

  embedding:
    model_id: "Qwen/Qwen3-Embedding-4B"
    provider: "siliconflow"
    parameters:
      dimensions: ${EMBEDDER_DIMENSION:2560}

env_overrides:
  RESEARCH_AGENT_MODEL_ID: "models.primary.model_id"
  RESEARCH_AGENT_PROVIDER: "models.primary.provider"

7.4 Provider 自動偵測與 Fallback

# 優先級順序
PROVIDER_PRIORITY = [
    "openrouter",
    "siliconflow",
    "google",
    "openai",
    "openai_compatible",
    "azure",
    "dashscope",
    "deepseek",
]

# Fallback 機制
# 當主要 Provider 失敗時，自動嘗試備用 Provider

---

8. 前端架構

8.1 路由結構

// frontend/src/routes.ts
export default [
  index("app/redirect-to-home.tsx"),

  ...prefix("/home", [
    layout("app/home/_layout.tsx", [
      index("app/home/home.tsx"),
      route("/stock/:stockId", "app/home/stock.tsx"),
    ]),
  ]),

  route("/market", "app/market/agents.tsx"),     // Agent 市場
  route("/ranking", "app/rank/board.tsx"),       // 排行榜

  ...prefix("/agent", [
    route("/:agentName", "app/agent/chat.tsx"),        // Agent 對話
    route("/:agentName/config", "app/agent/config.tsx"), // Agent 配置
  ]),

  ...prefix("/setting", [
    layout("app/setting/_layout.tsx", [
      index("app/setting/models.tsx"),     // 模型設定
      route("/general", "app/setting/general.tsx"),
      route("/memory", "app/setting/memory.tsx"),
    ]),
  ]),
]

8.2 技術選型

功能	技術
框架	React 19 + React Router 7
狀態管理	Zustand
資料獲取	TanStack Query
表單處理	TanStack Form + Zod
UI 組件	Radix UI + Tailwind CSS
圖表	ECharts
Markdown	react-markdown + remark-gfm
動畫	Framer Motion
桌面端	Tauri 2.x

8.3 SSE 串流處理

前端透過 Server-Sent Events 接收串流回應：

// 事件類型
type StreamEvent =
  | "conversation_started"
  | "thread_started"
  | "reasoning_started"
  | "reasoning"
  | "reasoning_completed"
  | "tool_call_started"
  | "tool_call_completed"
  | "message_chunk"
  | "plan_require_user_input"
  | "done"

---

9. API 設計

9.1 核心 Endpoints

/api/v1/
├── healthz                    # 健康檢查
├── agent/
│   ├── stream                 # SSE 串流 (POST)
│   ├── {agent_name}/card      # Agent Card
│   └── enabled                # 啟用的 Agents
├── conversation/
│   ├── {id}                   # 對話詳情
│   ├── {id}/messages          # 對話歷史
│   └── list                   # 對話列表
├── task/
│   ├── {id}                   # 任務詳情
│   └── {id}/cancel            # 取消任務
├── models/
│   ├── providers              # Provider 列表
│   └── {provider}/models      # 模型列表
├── strategy/
│   ├── create                 # 建立策略
│   ├── {id}/start             # 啟動策略
│   └── {id}/stop              # 停止策略
└── system/
    ├── env                    # 環境變數
    └── data-dir               # 數據目錄

9.2 串流協議

// SSE 事件格式
{
  "event": "message_chunk",
  "data": {
    "conversation_id": "conv_xxx",
    "thread_id": "thread_xxx",
    "task_id": "task_xxx",
    "content": "Tesla reported revenue of..."
  }
}

---

10. 數據流完整示例

10.1 查詢 “What was Tesla’s Q3 2024 revenue?“

sequenceDiagram
    participant User
    participant UI
    participant API
    participant SA as Super Agent
    participant Plan as Planner
    participant RA as Research Agent
    participant SEC as SEC EDGAR
    participant LLM

    User->>UI: "What was Tesla's Q3 2024 revenue?"
    UI->>API: POST /agent/stream

    API->>SA: 分析意圖
    SA->>LLM: 判斷是否直接回答
    LLM-->>SA: decision=handoff_to_planner
    Note over SA: 需要工具，移交 Planner

    SA-->>API: enriched_query
    API->>Plan: 規劃任務
    Plan->>LLM: 選擇 Agent
    LLM-->>Plan: agent_name=ResearchAgent

    Plan-->>API: ExecutionPlan
    API->>RA: stream(query)

    RA->>LLM: 決定使用工具
    LLM-->>RA: call fetch_periodic_sec_filings

    RA->>SEC: GET /filings?cik=TSLA&form=10-Q&year=2024&quarter=3
    SEC-->>RA: Filing data

    RA->>LLM: 分析並生成回答
    LLM-->>RA: "Tesla reported revenue of $25.2 billion..."

    RA-->>API: StreamResponse (chunks)
    API-->>UI: SSE: message_chunk (multiple)
    UI-->>User: 顯示回答

---

11. 安全設計

11.1 本地數據存儲

所有敏感數據存儲在本地：

~/Library/Application Support/ValueCell/  (macOS)
~/.config/valuecell/                       (Linux)
%APPDATA%\ValueCell\                       (Windows)

├── .env              # API 密鑰
├── valuecell.db      # SQLite 數據庫
├── lancedb/          # 向量數據庫
└── .knowledge/       # 知識庫

11.2 交易安全

• API 密鑰本地存儲：不發送到任何第三方
• 沙盒模式：支持紙上交易測試
• 風控機制：內建交易護欄

---

12. 擴展指南

12.1 新增 Agent

1. 在 python/valuecell/agents/ 建立目錄
2. 實現 BaseAgent 介面
3. 編寫 Agent Card YAML
4. 註冊到配置

class MyAgent(BaseAgent):
    async def stream(
        self,
        query: str,
        conversation_id: str,
        task_id: str,
        dependencies: Optional[Dict] = None,
    ) -> AsyncGenerator[StreamResponse, None]:
        # 實現邏輯
        yield streaming.message_chunk("Response...")
        yield streaming.done()

12.2 新增 Provider

1. 在 configs/providers/ 建立 YAML
2. 實現 Provider class (如需要)
3. 註冊到 ModelFactory

---

13. 總結

ValueCell 展示了一個生產級金融 AI 多智能體平台的完整實現：

特性	實現
架構模式	Planner-Executor 分離
Agent 協調	Super Agent → Planner → Executor
任務管理	狀態機 + 排程支持
Prompt 設計	分層結構 + 決策矩陣
配置系統	三層優先級 + 自動 Fallback
串流處理	SSE + asyncio.Queue
數據安全	本地存儲 + 風控機制

關鍵技術決策：

1. 使用 Agno 作為 Agent 框架，統一工具調用和記憶管理
2. 採用 YAML 配置 + 環境變數，支持靈活部署
3. LanceDB 作為本地向量數據庫，保護隱私
4. Tauri 實現跨平台桌面應用

---

參考資料

• ValueCell GitHub
• Agno Agent Framework
• A2A Protocol
• SEC EDGAR API