跳至主要內容

第2177篇：LLMOps平台选型——MLflow、W&B和LangSmith的工程对比

老张2026/4/30大约 7 分钟

第2177篇：LLMOps平台选型——MLflow、W&B和LangSmith的工程对比

适读人群：正在搭建LLM工程基础设施的技术负责人 | 阅读时长：约18分钟 | 核心价值：从真实工程需求出发，给出三大LLMOps平台的选型决策框架

"你们现在用什么追踪LLM实验？"

去年在一场内部分享上，我随口问了台下二十几个AI工程师这个问题。

答案五花八门：有人用Excel，有人用Notion，有人用自己写的脚本，还有两个团队在用完全不同的商业平台。没有一个团队用了相同的方案。

这很正常。LLMOps（LLM系统的工程运营）是2024-2025年才真正成熟的领域，工具链还没有形成公认的最佳实践。MLflow、Weights & Biases（W&B）、LangSmith是目前最主流的三个方向，但它们的定位和适用场景差别很大。

三个平台的核心定位

在深入比较之前，先要理解这三个工具的出发点完全不同：

MLflow：
  来源：传统ML实验追踪，2018年Databricks开源
  核心能力：实验管理、模型版本控制、模型部署
  LLM支持：后加的，2023年开始重点建设
  最适合：已有MLflow生态的ML团队向LLM迁移

Weights & Biases（W&B）：
  来源：深度学习训练追踪，2018年成立
  核心能力：训练可视化、超参数调优、数据集版本管理
  LLM支持：强调微调实验和评估
  最适合：有大量模型微调需求的团队

LangSmith：
  来源：LangChain生态，2023年推出
  核心能力：LLM调用链追踪、Prompt管理、评估
  LLM支持：原生为LLM设计
  最适合：LLM应用开发（不涉及模型训练）

深度功能对比：从工程需求出发

需求1：Prompt实验管理

这是LLM工程与传统ML最大的不同——"代码"变成了"Prompt"，需要专门管理。

Prompt实验管理能力对比：

LangSmith：★★★★★
  - Prompt版本化内置，一等公民支持
  - 支持Prompt模板的A/B测试
  - 每次调用都自动关联当前Prompt版本
  - 可视化比较不同Prompt版本的效果差异

W&B：★★★☆☆
  - 通过Artifact可以版本化Prompt文件
  - 需要手动关联Prompt和实验结果
  - 没有针对Prompt的专门可视化

MLflow：★★★☆☆
  - 可以用参数记录Prompt内容
  - 原生Prompt管理功能有限
  - 社区有插件扩展，但不统一

需求2：LLM调用链追踪

对于基于LangChain/LlamaIndex的复杂RAG或Agent系统，需要追踪整个调用链：

LLM调用链追踪能力对比：

LangSmith：★★★★★
  - 原生集成LangChain，零配置即可追踪所有调用
  - 可视化展示每个Chain/Agent的执行步骤
  - 可以看到每一步的输入输出和耗时
  - 支持追踪嵌套调用（Agent调用Tool再调用LLM）

W&B：★★★☆☆
  - 通过Weave（W&B新推的追踪工具）支持
  - 需要手动添加装饰器，侵入性较高
  - 可视化没有LangSmith直观

MLflow：★★☆☆☆
  - 基本的调用记录，没有链式展示
  - 适合记录实验级别的数据，不适合生产追踪

需求3：评估流水线

评估能力对比：

LangSmith：★★★★☆
  - 内置LLM-as-judge评估
  - 支持自定义评估器
  - 评估结果和追踪数据直接关联
  - 在线评估（生产数据采样评估）支持好

W&B：★★★★★
  - 最强的评估可视化（来自深度学习经验积累）
  - 支持大规模并行评估
  - 评估结果的统计分析能力强
  - 但LLM评估场景的内置支持不如LangSmith完整

MLflow：★★★☆☆
  - 支持自定义评估，但需要更多代码
  - 与模型版本管理集成好
  - 生产在线评估支持较弱

Java集成示例：三平台对比

/**
 * MLflow集成示例
 * 
 * 适合：实验阶段，记录不同Prompt/模型的对比实验
 */
@Component
@RequiredArgsConstructor
public class MLflowLLMTracker {

    private final MlflowClient mlflowClient;

    public void trackLLMExperiment(
            String promptVersion,
            String modelName,
            String query,
            String response,
            EvaluationMetrics metrics) {
        
        try (ActiveRun run = mlflowClient.startRun("llm-prompt-experiments")) {
            // 记录参数
            run.logParam("prompt_version", promptVersion);
            run.logParam("model_name", modelName);
            run.logParam("query_length", String.valueOf(query.length()));
            
            // 记录指标
            run.logMetric("faithfulness_score", metrics.getFaithfulness());
            run.logMetric("relevance_score", metrics.getRelevance());
            run.logMetric("latency_ms", metrics.getLatencyMs());
            run.logMetric("token_cost", metrics.getTokenCost());
            
            // 记录完整的输入输出（用Artifact存储）
            run.logArtifact("query.txt", query);
            run.logArtifact("response.txt", response);
            
            // 记录Prompt模板
            run.logArtifact("prompt_template.txt", 
                loadPromptTemplate(promptVersion));
            
            log.info("MLflow实验已记录: runId={}", run.getRunId());
        }
    }
}
/**
 * W&B（Wandb）集成示例
 * 
 * 适合：模型微调实验，大量训练指标可视化
 */
@Component
public class WandbLLMTracker {

    // W&B的Java SDK通过HTTP API调用
    private final WandbApiClient wandbClient;
    
    public String startFineTuningRun(
            String projectName,
            Map<String, Object> config) {
        
        WandbRun run = wandbClient.initRun(
            projectName,
            config,
            "finetuning-" + LocalDate.now());
        
        return run.getId();
    }

    public void logTrainingStep(
            String runId,
            int step,
            double trainLoss,
            double evalLoss,
            Map<String, Double> additionalMetrics) {
        
        Map<String, Object> metrics = new HashMap<>();
        metrics.put("train/loss", trainLoss);
        metrics.put("eval/loss", evalLoss);
        metrics.put("step", step);
        metrics.putAll(additionalMetrics);
        
        wandbClient.log(runId, metrics, step);
    }

    /**
     * W&B Weave：追踪LLM调用链
     */
    public void traceWithWeave(String operationName, 
                               Supplier<String> llmOperation) {
        // W&B Weave通过装饰器模式追踪
        // 在Java中通过包装器实现
        WeavoTrace trace = wandbClient.startTrace(operationName);
        try {
            String result = llmOperation.get();
            trace.success(result);
        } catch (Exception e) {
            trace.failure(e);
            throw e;
        }
    }
}
/**
 * LangSmith集成示例
 * 
 * 适合：生产环境的LLM调用追踪和在线评估
 */
@Component
@RequiredArgsConstructor
@Slf4j
public class LangSmithTracker {

    // LangSmith通过环境变量自动拦截LangChain调用
    // 对于Spring AI，需要手动集成

    private final LangSmithClient langSmithClient;
    
    /**
     * 手动记录LLM调用到LangSmith
     */
    public LangSmithRun trackLLMCall(
            String runName,
            String sessionId,
            Map<String, Object> inputs,
            Supplier<String> llmOperation) {
        
        LangSmithRun run = langSmithClient.createRun(
            LangSmithRunCreate.builder()
                .name(runName)
                .runType("llm")
                .sessionId(sessionId)
                .inputs(inputs)
                .startTime(Instant.now())
                .build());
        
        try {
            String output = llmOperation.get();
            
            // 记录成功结果
            langSmithClient.updateRun(run.getId(),
                LangSmithRunUpdate.builder()
                    .outputs(Map.of("output", output))
                    .endTime(Instant.now())
                    .build());
            
            return run;
            
        } catch (Exception e) {
            // 记录失败
            langSmithClient.updateRun(run.getId(),
                LangSmithRunUpdate.builder()
                    .error(e.getMessage())
                    .endTime(Instant.now())
                    .build());
            throw e;
        }
    }

    /**
     * 创建在线评估数据集
     * 
     * 从生产日志中采样，创建评估数据集
     */
    public String createEvaluationDataset(
            String datasetName,
            List<ProductionTrace> traces) {
        
        LangSmithDataset dataset = langSmithClient.createDataset(
            datasetName, "从生产日志采样，用于在线评估");
        
        List<LangSmithExample> examples = traces.stream()
            .map(trace -> LangSmithExample.builder()
                .inputs(Map.of("query", trace.getInput()))
                .outputs(Map.of("response", trace.getOutput()))
                .build())
            .collect(Collectors.toList());
        
        langSmithClient.addExamplesToDataset(dataset.getId(), examples);
        
        return dataset.getId();
    }
}

选型决策框架

决策路径：

Q1：团队主要工作是模型微调还是应用开发？
  ├── 主要是模型微调 → 优先考虑W&B
  └── 主要是应用开发（RAG/Agent） → 继续Q2

Q2：是否已经在用LangChain生态？
  ├── 是 → LangSmith是最低摩擦的选择
  └── 否 → 继续Q3

Q3：是否已经有MLflow基础设施（Databricks等）？
  ├── 是 → MLflow扩展LLM支持，成本最低
  └── 否 → 继续Q4

Q4：主要需求是生产监控还是实验管理？
  ├── 生产监控为主 → LangSmith
  └── 实验管理为主 → MLflow或W&B

特殊考虑：
  - 数据隐私要求高（不能用SaaS）→ MLflow（开源可自部署）
  - 预算紧张 → MLflow（免费开源）
  - 需要最快上线 → LangSmith（对LangChain集成开箱即用）

成本比较（2025年价格参考）

平台成本对比：

MLflow：
  - 开源版：完全免费（自部署）
  - Managed（Databricks上）：按计算资源收费，1k追踪约$0.01
  - 适合：有运维能力，希望控制成本的团队

W&B：
  - 免费版：100GB存储，个人/小团队够用
  - Team版：$50/用户/月起
  - 适合：ML团队，对可视化要求高

LangSmith：
  - 免费版：5K traces/月
  - Plus：$39/月，100K traces
  - Enterprise：自定义定价
  - 适合：生产LLM应用，监控需求强

实际建议：
  初期用LangSmith免费版 + MLflow开源版双栈，
  等规模上来了再统一选型。
  不要为了统一工具牺牲开发效率。

核心洞察：选工具不如先定需求

做了这个对比之后，我的建议是：不要先选平台，先想清楚你们真正需要解决的问题是什么。

三个平台能解决的问题不完全重叠，也不互斥。很多成熟团队是混用的：用LangSmith追踪生产调用链，用W&B管理微调实验，用MLflow做模型版本管理。

选型失败最常见的两个原因：

  1. 选了功能最全的，但用不起来。W&B功能强大，但如果你的团队不做深度学习微调，很多核心功能用不到，却要为它们付费。

  2. 选了免费的，却忘了运维成本。MLflow自部署确实免费，但有人需要维护服务器、处理故障、升级版本——这些隐性成本加起来可能超过商业服务的订阅费。

最后一个实用建议：花两周时间把三个平台都接一遍，在真实项目上跑一跑，再做决定。读文档和比较截图，永远比不上动手体验来得清楚。

编辑此页
最近更新:
贡献者: xiaozhangge