TradingAgents 深度实战：从 78.7k Star 的多智能体交易框架到量化投研工程化完全指南

前言：当 AI Agent 遇上华尔街

2026 年 5 月，GitHub 上一个名为 TradingAgents 的项目悄然冲到了 78.7k Star。这不是一个普通的量化交易库，而是一个完全用 LLM 驱动的多智能体协作系统——它模拟了一家真实交易公司的完整运作流程：基本面分析师看财报、技术面分析师画 K 线、情绪分析师刷社交媒体、研究员做辩论、交易员下单、风控官一票否决。

这个项目来自 TauricResearch，背后的论文发表在 arXiv（2412.20138），代码完全开源。更关键的是，它不只是一个学术玩具——从 v0.2.0 到 v0.2.5，短短几个月内已经支持了 GPT-5.x、Gemini 3.x、Claude 4.x、DeepSeek、Qwen、GLM 等十几个 LLM 提供商，还提供了 Docker 部署和 Ollama 本地模型支持。

作为一名程序员，我对这个项目的兴趣不在于"能不能用它赚钱"（它的 disclaimer 写得很清楚：仅供研究，不构成投资建议），而在于它的多智能体协作架构——这代表了 2026 年 AI Agent 工程化的一个重要方向：用角色分工 + 结构化辩论来提升决策质量。

本文将从源码级别深度拆解 TradingAgents 的架构设计，带你理解它是如何用 LangGraph 编排多个 LLM Agent 协作完成复杂决策的，以及你可以如何借鉴它的设计思路来构建自己的多智能体系统。

一、为什么多智能体架构适合量化交易？

1.1 单 Agent 的天花板

传统的量化系统是"规则 + 模型"的 pipeline：数据采集 → 特征工程 → 模型预测 → 风控过滤 → 执行。每个环节都是确定性的，模型输出一个分数，系统根据阈值做决策。

LLM Agent 试图改变这个范式——让 AI 直接"理解"市场并做出交易决策。但单 Agent 面临一个根本问题：认知偏差。

一个 LLM Agent 在分析市场时，很容易被某个维度的信息"锚定"。比如看到一条利好新闻就忽略技术面的超买信号，或者盯着 RSI 背离就忘了公司基本面已经恶化。人类的交易员团队之所以比单个人更强，不是因为他们智商更高，而是因为不同角色的人会从不同角度审视同一个决策，通过辩论来纠正偏差。

TradingAgents 的核心洞察就是：把这种人类团队协作模式搬到 AI Agent 上。

1.2 交易公司的角色映射

TradingAgents 的架构直接映射了一家对冲基金的典型组织结构：

这不是花哨的命名，而是真实的职责分离——每个 Agent 都有独立的 Prompt、独立的工具集、独立的输出格式。

二、架构设计深度解析

2.1 基于 LangGraph 的状态图编排

TradingAgents 的核心编排引擎是 LangGraph。为什么选 LangGraph 而不是直接用 LangChain？

关键区别在于：LangGraph 支持有状态图的持久化检查点（Checkpoint）。在量化交易场景中，一个完整的分析流程可能需要跑 10-20 分钟（涉及多次 LLM 调用、数据获取、辩论轮次），如果中途挂了，你需要能从断点恢复，而不是从头再来。

核心图结构如下：

class TradingAgentsGraph:
    def __init__(self, selected_analysts, debug=False, config=None, callbacks=None):
        self.config = config or DEFAULT_CONFIG
        
        # 双 LLM 策略：深度思考用大模型，快速任务用小模型
        llm_kwargs = self._get_provider_kwargs()
        
        self.deep_thinking_llm = create_llm_client(
            provider=self.config["llm_provider"],
            model=self.config["deep_think_llm"],
            **llm_kwargs,
        ).get_llm()
        
        self.quick_thinking_llm = create_llm_client(
            provider=self.config["llm_provider"],
            model=self.config["quick_think_llm"],
            **llm_kwargs,
        ).get_llm()

注意这里的一个精妙设计：双 LLM 策略。系统维护两个 LLM 客户端——一个用于需要深度推理的场景（如研究员辩论、最终决策），另一个用于轻量级任务（如数据格式化、信号处理）。这样既保证了决策质量，又控制了成本和延迟。

2.2 状态管理：Agent 之间如何传递信息

LangGraph 的核心是 State。TradingAgents 定义了几种关键状态：

# 基础 Agent 状态
class AgentState(TypedDict):
    ticker: str                    # 股票代码
    analysis_date: str             # 分析日期
    fundamentals_data: dict        # 基本面数据
    technical_indicators: dict     # 技术指标数据
    news_data: list                # 新闻数据
    sentiment_data: dict           # 情绪数据
    analyst_reports: dict          # 各分析师报告
    researcher_debates: dict       # 研究员辩论记录
    trading_decision: dict         # 交易决策
    risk_assessment: dict          # 风险评估
    portfolio_decision: dict       # 组合经理最终决策

# 投资辩论状态
class InvestDebateState(TypedDict):
    bull_report: str               # 看多报告
    bear_report: str               # 看空报告
    debate_round: int              # 当前辩论轮次
    bull_arguments: list           # 看多论据列表
    bear_arguments: list           # 看空论据列表
    consensus_score: float         # 共识分数

# 风险辩论状态  
class RiskDebateState(TypedDict):
    risk_factors: list             # 风险因素列表
    risk_score: float              # 风险评分
    mitigations: list              # 风险缓解措施
    discuss_round: int             # 风险讨论轮次

这些状态定义了 Agent 之间的"语言"。每个 Agent 的输入和输出都是这些结构化状态的一部分，通过 LangGraph 的图边（edge）自动传递。

2.3 完整工作流：从启动到决策

整个交易决策流程是一个有向无环图（DAG），分为以下几个阶段：

阶段一：数据采集（并行）

四个分析师 Agent 同时启动，各自获取数据：

def setup_graph(self, selected_analysts):
    workflow = StateGraph(AgentState)
    
    # 并行启动多个分析师
    if "fundamentals" in selected_analysts:
        workflow.add_node("fundamentals_analyst", fundamentals_analyst_node)
    if "market" in selected_analysts:
        workflow.add_node("technical_analyst", technical_analyst_node)
    if "social" in selected_analysts:
        workflow.add_node("sentiment_analyst", sentiment_analyst_node)
    if "news" in selected_analysts:
        workflow.add_node("news_analyst", news_analyst_node)
    
    # 设置并行执行
    workflow.add_edge(START, "fundamentals_analyst")
    workflow.add_edge(START, "technical_analyst")
    workflow.add_edge(START, "sentiment_analyst")
    workflow.add_edge(START, "news_analyst")

分析师们使用的工具集包括：

# 数据获取工具（基于 yfinance）
get_stock_data(ticker, period, interval)    # 获取历史价格数据
get_indicators(ticker, indicators_list)      # 计算技术指标（MACD, RSI, 布林带等）
get_fundamentals(ticker)                      # 获取基本面指标（PE, PB, ROE 等）
get_balance_sheet(ticker)                     # 获取资产负债表
get_cashflow(ticker)                          # 获取现金流量表
get_income_statement(ticker)                  # 获取利润表
get_news(ticker)                              # 获取个股相关新闻
get_insider_transactions(ticker)              # 获取内部人交易记录
get_global_news()                             # 获取全球宏观经济新闻

阶段二：结构化辩论

分析师输出报告后，进入研究员辩论阶段：

class ConditionalLogic:
    def __init__(self, max_debate_rounds=3, max_risk_discuss_rounds=2):
        self.max_debate_rounds = max_debate_rounds
        self.max_risk_discuss_rounds = max_risk_discuss_rounds
    
    def should_continue_debate(self, state: InvestDebateState) -> str:
        """决定是否继续辩论"""
        if state["debate_round"] >= self.max_debate_rounds:
            return "end_debate"
        if state["consensus_score"] > 0.8:
            return "end_debate"  # 已达成高度共识
        return "continue_debate"

辩论机制的核心是"对抗性思维"——看多研究员和看空研究员必须针对对方的论点逐一反驳，直到达成共识或达到最大轮次。这有效地减少了"确认偏差"（Confirmation Bias）。

阶段三：交易决策

Trader Agent 收集所有分析师报告和辩论结果，生成交易提案：

• 买入/卖出/持有
• 建议仓位比例
• 入场价格区间
• 止损/止盈位
• 时间维度（短期/中期/长期）

阶段四：风险评估

Risk Management Agent 独立评估交易提案的风险：

• 波动率分析
• 流动性评估
• 相关性风险
• 最大回撤预估

阶段五：最终审批

Portfolio Manager 做出最终决定——批准或否决。

2.4 信号处理与反思机制

v0.2.x 版本引入了两个重要的新组件：

class SignalProcessor:
    """信号处理器：将多个 Agent 的输出综合为量化信号"""
    def __init__(self, quick_llm):
        self.llm = quick_llm
    
    def aggregate_signals(self, analyst_reports, researcher_conclusion):
        """将多个分析师的信号聚合成综合评分"""
        # 每个分析师输出一个 [-1, 1] 的信号
        # 加权平均后输出最终信号
        pass

class Reflector:
    """反思器：对决策结果进行回顾"""
    def __init__(self, quick_llm):
        self.llm = quick_llm
    
    def reflect_on_decision(self, decision, market_outcome):
        """将决策结果与市场实际表现对比，生成反思报告"""
        pass

三、代码实战：从零搭建你的多智能体交易系统

3.1 环境准备

# 克隆项目
git clone https://github.com/TauricResearch/TradingAgents.git
cd TradingAgents

# 创建虚拟环境
conda create -n tradingagents python=3.13
conda activate tradingagents

# 安装依赖
pip install .

# 配置 API 密钥
cp .env.example .env
# 编辑 .env 文件，填入你的 API key

3.2 最小化示例：自定义 Agent 工作流

如果你想理解核心机制，可以写一个最小化的多智能体系统：

from langgraph.graph import StateGraph, START, END
from typing import TypedDict, Annotated
from langchain_core.messages import HumanMessage, SystemMessage
import operator

# ========== 1. 定义状态 ==========
class TradingState(TypedDict):
    ticker: str
    signals: Annotated[list, operator.add]  # 用 Annotated + operator.add 实现信号累积
    decision: str
    confidence: float

# ========== 2. 定义分析师 Agent ==========
def technical_analyst(state: TradingState, llm) -> TradingState:
    """技术分析师：基于技术指标生成信号"""
    prompt = f"""你是一个技术分析师。分析 {state['ticker']} 的技术面。
    基于以下数据给出交易信号：
    - 输出格式：{{"signal": "bullish/bearish/neutral", "confidence": 0.0-1.0, "reasoning": "..."}}
    """
    response = llm.invoke([SystemMessage(content=prompt)])
    
    # 解析 LLM 输出为结构化信号
    signal = parse_signal(response.content)
    return {"signals": [signal]}

def sentiment_analyst(state: TradingState, llm) -> TradingState:
    """情绪分析师：基于新闻和社交媒体生成信号"""
    # 获取最新新闻（使用你的新闻 API）
    news = fetch_recent_news(state["ticker"])
    
    prompt = f"""你是一个情绪分析师。基于以下新闻分析 {state['ticker']} 的市场情绪：
    {json.dumps(news, ensure_ascii=False)}
    
    输出格式：{{"signal": "bullish/bearish/neutral", "confidence": 0.0-1.0, "reasoning": "..."}}
    """
    response = llm.invoke([SystemMessage(content=prompt)])
    signal = parse_signal(response.content)
    return {"signals": [signal]}

# ========== 3. 定义交易决策 Agent ==========
def trader(state: TradingState, llm) -> TradingState:
    """交易员：综合所有信号做出决策"""
    prompt = f"""你是一个交易员。基于以下分析信号做出交易决策：
    股票：{state['ticker']}
    信号列表：{json.dumps(state['signals'], ensure_ascii=False)}
    
    输出格式：{{"action": "buy/sell/hold", "confidence": 0.0-1.0, "reasoning": "..."}}
    """
    response = llm.invoke([SystemMessage(content=prompt)])
    decision = parse_decision(response.content)
    return {"decision": decision["action"], "confidence": decision["confidence"]}

# ========== 4. 构建工作流图 ==========
def build_trading_graph(llm):
    workflow = StateGraph(TradingState)
    
    # 添加节点
    workflow.add_node("technical", lambda s: technical_analyst(s, llm))
    workflow.add_node("sentiment", lambda s: sentiment_analyst(s, llm))
    workflow.add_node("trader", lambda s: trader(s, llm))
    
    # 设置边：两个分析师并行执行，然后汇聚到交易员
    workflow.add_edge(START, "technical")
    workflow.add_edge(START, "sentiment")
    workflow.add_edge("technical", "trader")
    workflow.add_edge("sentiment", "trader")
    workflow.add_edge("trader", END)
    
    return workflow.compile()

# ========== 5. 运行 ==========
graph = build_trading_graph(your_llm)
result = graph.invoke({"ticker": "AAPL", "signals": []})
print(f"决策：{result['decision']}，置信度：{result['confidence']}")

3.3 添加辩论机制

上面的例子缺少了 TradingAgents 最核心的辩论机制。让我们加上：

class DebateState(TypedDict):
    bull_arguments: list
    bear_arguments: list
    round: int
    max_rounds: int

def bull_researcher(state: DebateState, llm) -> DebateState:
    """看多研究员：基于看空论点进行反驳"""
    prompt = f"""你是一个看多研究员。对方提出了以下看空论点：
    {json.dumps(state['bear_arguments'], ensure_ascii=False)}
    
    请逐一反驳，并补充看多论据。
    输出格式：[{{"argument": "...", "evidence": "..."}}]
    """
    response = llm.invoke([SystemMessage(content=prompt)])
    new_args = parse_arguments(response.content)
    return {"bull_arguments": state["bull_arguments"] + new_args, "round": state["round"] + 1}

def bear_researcher(state: DebateState, llm) -> DebateState:
    """看空研究员：基于看多论点进行反驳"""
    prompt = f"""你是一个看空研究员。对方提出了以下看多论点：
    {json.dumps(state['bull_arguments'], ensure_ascii=False)}
    
    请逐一反驳，并补充看空论据。
    输出格式：[{{"argument": "...", "evidence": "..."}}]
    """
    response = llm.invoke([SystemMessage(content=prompt)])
    new_args = parse_arguments(response.content)
    return {"bear_arguments": state["bear_arguments"] + new_args, "round": state["round"] + 1}

def should_continue_debate(state: DebateState) -> str:
    """辩论终止条件"""
    if state["round"] >= state["max_rounds"]:
        return "end_debate"
    return "continue_debate"

# 构建辩论子图
def build_debate_graph(llm, max_rounds=3):
    workflow = StateGraph(DebateState)
    
    workflow.add_node("bull", lambda s: bull_researcher(s, llm))
    workflow.add_node("bear", lambda s: bear_researcher(s, llm))
    
    workflow.add_conditional_edges("bull", should_continue_debate, {
        "continue_debate": "bear",
        "end_debate": END,
    })
    workflow.add_conditional_edges("bear", should_continue_debate, {
        "continue_debate": "bull",
        "end_debate": END,
    })
    
    return workflow.compile()

3.4 使用 Docker 部署生产环境

# 复制环境配置
cp .env.example .env

# 编辑 .env，填入 API keys
# OPENAI_API_KEY=sk-xxx
# ALPHA_VANTAGE_API_KEY=xxx

# 使用 Docker Compose 启动
docker compose run --rm tradingagents

# 使用 Ollama 本地模型（无需 API key）
docker compose --profile ollama run --rm tradingagents-ollama

Docker 部署的优势在于环境一致性——量化系统对依赖版本极其敏感，Docker 确保了 Python 版本、包版本、系统库的一致性。

四、多 LLM 提供商支持的工程实现

4.1 统一的 LLM 客户端抽象

TradingAgents v0.2.x 最大的工程进步之一是统一了多 LLM 提供商的支持。它通过一个工厂模式来创建 LLM 客户端：

from tradingagents.llm_clients import create_llm_client

# OpenAI
client = create_llm_client(provider="openai", model="gpt-5.5")

# Google Gemini
client = create_llm_client(provider="google", model="gemini-3.1")

# Anthropic Claude
client = create_llm_client(provider="anthropic", model="claude-4.6")

# DeepSeek（国产）
client = create_llm_client(provider="deepseek", model="deepseek-v3")

# 通义千问（国际版/国内版）
client = create_llm_client(provider="dashscope", model="qwen-max")
client = create_llm_client(provider="dashscope_cn", model="qwen-max")

# Ollama 本地模型
client = create_llm_client(provider="ollama", model="llama3:70b")

4.2 Provider 特定参数

不同 LLM 提供商有不同的"推理深度"参数，TradingAgents 做了针对性适配：

def _get_provider_kwargs(self) -> Dict[str, Any]:
    kwargs = {}
    provider = self.config.get("llm_provider", "").lower()
    
    if provider == "google":
        # Gemini 的 thinking_budget 参数
        thinking_level = self.config.get("google_thinking_level")
        if thinking_level:
            kwargs["thinking_level"] = thinking_level
    
    elif provider == "openai":
        # OpenAI 的 reasoning_effort 参数（low/medium/high）
        reasoning_effort = self.config.get("openai_reasoning_effort")
        if reasoning_effort:
            kwargs["reasoning_effort"] = reasoning_effort
    
    elif provider == "anthropic":
        # Claude 的 effort 控制
        effort = self.config.get("anthropic_effort")
        if effort:
            kwargs["effort"] = effort
    
    return kwargs

这个设计的启示是：在构建多 Agent 系统时，不要假设所有 LLM 都一样。不同提供商的 API 有细微差别，做好抽象层能让你在未来无缝切换模型。

4.3 双区域支持（国际/国内）

对于国内开发者，一个很贴心的设计是 Qwen 和 GLM 的双区域支持：

# Qwen 国际版（走 dashscope-intl.aliyuncs.com）
export DASHSCOPE_API_KEY=xxx

# Qwen 国内版（走 dashscope.aliyuncs.com）
export DASHSCOPE_CN_API_KEY=xxx

# GLM 国际版（走 z.ai）
export ZHIPU_API_KEY=xxx

# GLM 国内版（走 open.bigmodel.cn）
export ZHIPU_CN_API_KEY=xxx

这解决了国内开发者使用海外 API 延迟高、不稳定的问题。

五、性能优化与成本控制

5.1 LLM 调用成本分析

一个完整的交易分析流程涉及多少次 LLM 调用？粗略估算：

如果使用 GPT-5.5（假设 $15/M input tokens, $60/M output tokens），每次调用平均消耗 5k input + 2k output tokens，单次分析成本约为：

• Deep 模型（11 次）：$1.325 - $1.925
• Quick 模型（4 次）：$0.48 - $0.68
• 总计：约 $2 - $3 每次分析

这是纯 API 成本，还不算数据获取和时间成本。

5.2 成本优化策略

策略一：分级使用模型

像 TradingAgents 一样，把简单任务（信号处理、数据格式化）用便宜的小模型，只在需要深度推理的环节（辩论、最终决策）用大模型。

# 配置示例
config = {
    "deep_think_llm": "gpt-5.5",      # 辩论和决策用
    "quick_think_llm": "gpt-4o-mini",  # 数据处理和格式化用
}

策略二：控制辩论轮次

config = {
    "max_debate_rounds": 2,          # 默认 3，降到 2 省一次深度调用
    "max_risk_discuss_rounds": 1,    # 默认 2，降到 1
}

策略三：使用本地模型

对于 Ollama 用户，可以用 Llama 3 70B 或 Qwen2.5 72B 跑完全流程，API 成本为零（但需要 GPU）。

策略四：缓存与检查点

# LangGraph 的 checkpointer 支持断点续跑
checkpointer = get_checkpointer()
graph = workflow.compile(checkpointer=checkpointer)

# 如果中途崩溃，可以从 checkpoint 恢复
# 避免重复调用已完成的分析步骤

5.3 分析师并发控制

config = {
    "analyst_concurrency_limit": 1,  # 默认 1，串行执行分析师
    # 设为 4 可以并行执行，但需要处理并发问题
}

并行执行分析师可以将第一阶段的时间从 4x 缩短到 1x，但需要注意 API 的 Rate Limit。

六、多智能体架构的通用启示

TradingAgents 虽然是量化交易领域的项目，但它的架构模式可以迁移到任何需要多角度分析的复杂决策场景。

6.1 适合多 Agent 架构的场景

1. 需要对抗性思维的场景：如代码审查（一个写代码、一个挑毛病）、方案评审（一个提案、一个质疑）
2. 需要多领域专家协作的场景：如医疗诊断（内科 + 外科 + 影像科）、法律分析（合同法 + 公司法 + 知识产权法）
3. 需要风险控制的决策：任何涉及"建议 → 审核 → 批准"流程的系统

6.2 不适合的场景

1. 简单确定性任务：如格式转换、数据清洗——直接写代码更快更稳
2. 实时性要求极高的场景：LLM 调用的延迟（秒级）不适合高频交易
3. 结果可精确验证的任务：如数学计算——LLM 可能出错，直接用程序算

6.3 关键设计原则

从 TradingAgents 的源码中，我总结出几个构建多 Agent 系统的关键原则：

原则一：角色职责单一化

每个 Agent 只做一件事，做好一件事。Fundamentals Analyst 不看技术指标，Technical Analyst 不看新闻。这确保了每个维度都能被深入分析，而不是被一个 Agent 的"注意力分配"稀释。

原则二：结构化输出协议

Agent 之间不传自由文本，传结构化数据。每个 Agent 的输出都经过解析，变成 JSON 格式的信号或报告。这让下游 Agent 可以精确引用上游的结论。

原则三：对抗性辩论机制

这是 TradingAgents 最独特的设计。不是"多个人讨论"而是"多个人辩论"——你必须反驳对方的观点，而不是简单地说"我同意"。这种结构强制 Agent 从不同角度思考同一个问题。

原则四：最终否决权

Portfolio Manager 有最终否决权，Risk Management 有风控否决权。不是所有信号都需要被采纳，系统需要在最后一道关卡做过滤。

原则五：可恢复的状态管理

通过 LangGraph 的 checkpointer，整个分析流程可以被暂停、恢复、回溯。这是生产级系统必须具备的能力。

七、局限性与改进方向

7.1 当前局限

1. 数据源依赖：核心数据依赖 yfinance 和 Alpha Vantage，对于 A 股、港股的支持有限（虽然有社区 fork 版本如 TradingAgents-A Share Edition）
2. LLM 幻觉风险：LLM 可能在分析中"编造"不存在的财报数据或新闻事件，需要人工验证
3. 成本问题：完整流程的 API 成本不低，不适合大规模回测
4. 缺乏反馈闭环：虽然有 Reflector 模块，但决策结果与实际市场表现的自动对比尚未完善

7.2 改进方向

# 1. 添加 RAG 增强：让分析师可以检索历史案例
from langchain.vectorstores import FAISS

def create_knowledge_base(historical_decisions):
    """将历史交易决策建立向量索引，供 Agent 检索参考"""
    vectorstore = FAISS.from_documents(
        historical_decisions,  # 历史决策记录
        embeddings,             # 嵌入模型
    )
    return vectorstore.as_retriever()

# 2. 添加实时数据流：用 WebSocket 接入实时行情
import asyncio
import websockets

async def stream_realtime_quotes(ticker, callback):
    async with websockets.connect(f"wss://stream.example.com/{ticker}") as ws:
        async for message in ws:
            callback(json.loads(message))

# 3. 添加回测引擎：用历史数据验证策略有效性
class Backtester:
    def __init__(self, strategy_fn, data_loader):
        self.strategy_fn = strategy_fn
        self.data_loader = data_loader
    
    def run(self, start_date, end_date, initial_capital=100000):
        """运行回测"""
        portfolio_value = initial_capital
        trades = []
        
        for date in pd.date_range(start_date, end_date):
            market_data = self.data_loader.get(date)
            decision = self.strategy_fn(market_data)
            
            if decision["action"] == "buy":
                # 模拟买入
                shares = (portfolio_value * decision["position_pct"]) / market_data["close"]
                portfolio_value -= shares * market_data["close"]
                trades.append({"date": date, "action": "buy", "shares": shares})
            elif decision["action"] == "sell":
                # 模拟卖出
                portfolio_value += shares * market_data["close"]
                trades.append({"date": date, "action": "sell", "shares": shares})
        
        return {
            "final_value": portfolio_value,
            "return_pct": (portfolio_value - initial_capital) / initial_capital * 100,
            "trades": trades,
        }

八、总结

TradingAgents 代表了 2026 年 AI Agent 工程化的一个重要方向：用多角色协作 + 结构化辩论来解决复杂决策问题。

从技术角度看，它的核心价值不在于"AI 能不能炒股"，而在于它提供了一个完整的多智能体系统参考实现：

• LangGraph 的生产级应用：有状态图、检查点、条件边、并行节点
• 双 LLM 策略：深度推理用大模型，轻量任务用小模型，平衡质量和成本
• 多提供商抽象：一套代码适配十几个 LLM 提供商
• 结构化辩论：用对抗性思维减少 LLM 的确认偏差
• 职责分离：每个 Agent 只做一件事，架构清晰可扩展

对于想学习多 Agent 系统开发的程序员来说，TradingAgents 的源码是一个非常好的学习资源。它的架构设计可以迁移到代码审查、方案评审、故障诊断等任何需要多角度分析的工程场景。

重要提醒：TradingAgents 是一个研究框架，不构成任何投资建议。如果你真的想用它做交易，请务必加入人工审核环节，并充分回测后再投入真金白银。

参考资料

• GitHub 仓库：https://github.com/TauricResearch/TradingAgents
• 论文：https://arxiv.org/abs/2412.20138
• Trading-R1 技术报告：https://arxiv.org/abs/2509.11420
• LangGraph 文档：https://langchain-ai.github.io/langgraph/