西瓜空间站

Agent 评估与可观测性

7/6/2026 AI Agent评估可观测性LangSmith

# Agent 评估与可观测性

📅 发布于 2026-07-06

第六篇：工程化 — 怎么知道你的 Agent 好不好？

# 17.1 Agent 评估的挑战

传统软件有明确的对错——单元测试通过就行。但 Agent 的输出是自然语言，"好不好"变得模糊：

传统软件评估 Agent 评估
输入确定 → 输出确定 相同输入 → 不同输出（LLM 随机性）
单元测试覆盖即可 难以定义"正确"
有明确的对错标准 多步骤、多轮交互
性能指标：延迟、吞吐量 需评估：准确度、相关性、安全性、效率

# 17.2 Agent 评估的六个维度

1. 任务完成率 Agent 是否完成了用户要求的任务？最基本指标。分完全完成、部分完成、失败三级。

2. 准确性 回答是否正确？事实是否准确？有没有幻觉？用 LLM-as-Judge 或人工标注评估。

3. 效率 完成任务用了多少步？多少 token？多少时间？步数越少、token 越省越好。

4. 安全性 有没有执行危险操作？有没有泄露敏感信息？有没有被提示注入攻击？

5. 鲁棒性 面对异常输入、模糊指令、边界条件时是否稳定？不崩溃、不无限循环。

6. 用户满意度 用户觉得有用吗？通过反馈（👍👎）、评分、留存率衡量。最终指标。

# 17.3 四种评估方法

🔬 怎么评估 Agent？

方法 原理 优缺点 适合场景
人工标注 人判断输出好不好 ✓最准 ✗贵、慢 小规模、最终验收
LLM-as-Judge 用另一个 LLM 评判 ✓快、便宜 ✗有偏差 大规模、迭代优化
基准测试集 预设问答对，比对标准答案 ✓可重复 ✗覆盖有限 回归测试、CI/CD
用户反馈 收集真实用户评分 ✓最真实 ✗噪声大 线上监控、持续改进

# LLM-as-Judge 示例

eval_prompt = """
你是一个严格的评估员。请评估以下 Agent 回答的质量。

用户问题：{question}
Agent 回答：{answer}
参考答案：{reference}

请从以下维度打分（1-5分）：
1. 准确性：回答是否正确，与参考答案一致
2. 完整性：是否回答了问题的所有方面
3. 相关性：回答是否切题，没有多余内容
4. 表达清晰度：语言是否清晰易懂

输出 JSON 格式：
{
  "accuracy": 4,
  "completeness": 3,
  "relevance": 5,
  "clarity": 4,
  "overall": 4,
  "comments": "回答基本正确但缺少XX细节"
}
"""

# 批量评估
scores = []
for sample in test_dataset:
    result = judge_llm.invoke(
        eval_prompt.format(
            question=sample.question,
            answer=sample.agent_answer,
            reference=sample.reference
        )
    )
    scores.append(parse_json(result))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

# 17.4 Agent 可观测性

评估是离线的——测试集跑完看分数。可观测性是在线的——生产环境中实时监控 Agent 行为。

📊 Agent 可观测性的三个层次

1. 日志（Logging） 记录每一步：用户输入、LLM 调用、工具调用、返回结果。最基本的可观测性。

2. 指标（Metrics） 聚合统计：Token 消耗、响应延迟、成功率、工具调用次数。用于监控和告警。

3. 追踪（Tracing） 全链路追踪：一次用户请求经过的所有步骤、每次 LLM 调用的完整 prompt 和 response。

# 主流可观测性工具

工具 定位 特点
LangSmith LangChain 官方 与 LangChain/LangGraph 深度集成
Langfuse 开源可观测 开源、自部署、框架无关
Phoenix Arize AI 出品 支持评估+追踪+幻觉检测
OpenTelemetry 通用标准 与现有 APM 系统集成

# 17.5 Agent 监控的黄金指标

📈 生产环境必须监控的指标

质量指标

  • 任务成功率（应该 > 90%）
  • 幻觉率（应该 < 5%）
  • 用户满意度（👍率 > 80%）
  • 工具调用成功率

性能指标

  • 首 token 延迟（P95 < 2s）
  • 端到端延迟（P95 < 30s）
  • 平均步数（越少越好）
  • Token 消耗（成本控制）

安全指标

  • 提示注入攻击次数
  • 敏感信息泄露次数
  • 危险工具调用次数
  • 无限循环发生率

业务指标

  • 日活用户（DAU）
  • 平均会话长度
  • 用户留存率
  • 每次对话成本

# 17.6 Agent 评估指标体系

评估 Agent 不能只靠直觉和感觉，需要建立一套量化指标体系。下面从任务完成率、步数效率、Token 成本、准确率、鲁棒性五个核心维度展开，每个指标都有明确的计算公式和适用场景，帮助你建立可度量、可对比、可追踪的评估体系。

📐 核心评估指标计算公式与适用场景

指标名称 计算公式 适用场景 目标值
任务完成率 完成任务数 / 总任务数 × 100% 端到端 Agent 能力评估 > 90%
步数效率 实际步数 / 最优步数（比值越接近1越好） Agent 规划能力评估 < 1.5
Token 成本 Σ(prompt_tokens + completion_tokens) × 单价 成本优化与预算控制 按业务定
准确率 正确回答数 / 总回答数 × 100% 事实型问答、信息检索 > 95%
鲁棒性 异常输入下正常处理数 / 异常输入总数 × 100% 压力测试、对抗测试 > 85%
工具调用准确率 正确工具调用数 / 总工具调用数 × 100% 工具选择与参数生成质量评估 > 95%
幻觉率 含幻觉回答数 / 总回答数 × 100% 事实准确性监控 < 5%

# 评估指标雷达图

🎯 Agent 五维评估雷达图

下图展示了一个优秀 Agent 的理想评估分数（蓝色）与当前版本评估分数（橙色）的对比。通过雷达图可以直观发现 Agent 的短板维度，指导优化方向。

五维评估指标：任务完成率 (95)、准确率 (90)、效率 (85)、鲁棒性 (80)、安全性 (92)

图例：蓝色为理想目标值，橙色为当前版本评分

# 17.7 LangSmith 完整实战

LangSmith 是 LangChain 官方推出的 Agent 评估与可观测性平台，提供了从 Trace 收集、数据分析到评估数据集管理的完整工具链。下面通过一个完整的实战案例，演示如何将 LangSmith 集成到 Agent 项目中，实现全链路追踪和自动化评估。

# 评估流水线图

🔄 LangSmith 评估流水线

下图展示了 LangSmith 评估的完整流程：从数据集创建、Agent 运行、评估器打分到结果对比分析。每个环节都通过 API 自动化完成，无需手动操作。

流程：Dataset（创建评估数据集）→ Run（Agent 执行并追踪）→ Evaluate（评估器打分）→ Compare（对比实验结果）

对应 API：create_dataset() → @traceable + invoke() → evaluate() → experiment_prefix

# LangSmith 集成与评估代码

import os
from langsmith import Client, traceable
from langchain.chat_models import ChatOpenAI
from langchain.agents import create_react_agent, AgentExecutor
from langchain import hub
from langchain.tools import Tool
from langchain_community.tools import DuckDuckGoSearchRun

# 1. 配置环境变量
os.environ["LANGCHAIN_TRACING_V2"] = "true"
os.environ["LANGCHAIN_API_KEY"] = "lsv2_pt_xxx"
os.environ["LANGCHAIN_PROJECT"] = "ai-agent-eval"
os.environ["OPENAI_API_KEY"] = "sk-xxx"

# 2. 定义工具
search_tool = DuckDuckGoSearchRun()
calc_tool = Tool(
    name="calculator",
    description="用于数学计算，输入数学表达式",
    func=lambda expr: str(eval(expr)),
)

# 3. 装饰需要追踪的函数
@traceable(run_type="chain", name="qa_agent")
def run_qa_agent(question: str) -> str:
    llm = ChatOpenAI(model="gpt-4o", temperature=0)
    prompt = hub.pull("hwchase17/react")
    tools = [search_tool, calc_tool]
    agent = create_react_agent(llm, tools, prompt)
    executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
    result = executor.invoke({"input": question})
    return result["output"]

# 4. 创建评估数据集
client = Client()
dataset = client.create_dataset(
    dataset_name="qa-eval-v1",
    description="问答 Agent 评估集"
)

examples = [
    {"inputs": {"question": "北京今天天气？"}, "outputs": {"answer": "晴，25度"}},
    {"inputs": {"question": "1+1等于几？"}, "outputs": {"answer": "2"}},
    {"inputs": {"question": "AI Agent 是什么？"}, "outputs": {"answer": "AI Agent 是能自主使用工具完成任务的智能体"}},
]
client.create_examples(dataset_id=dataset.id, examples=examples)

# 5. 定义评估器
def correctness(run, example):
    """检查预测结果是否包含参考答案"""
    pred = run.outputs["output"]
    ref = example.outputs["answer"]
    return {"score": 1.0 if ref in pred else 0.0}

def conciseness(run, example):
    """评估回答简洁性：少于100词得满分"""
    pred = run.outputs["output"]
    word_count = len(pred.split())
    score = 1.0 if word_count <= 100 else 0.5
    return {"score": score, "comment": f"词数: {word_count}"}

# 6. 运行评估
from langsmith.evaluation import evaluate
results = evaluate(
    run_qa_agent,
    data=dataset.name,
    evaluators=[correctness, conciseness],
    experiment_prefix="gpt4o-baseline"
)
print(f"评估结果: {results}")
# 输出示例：正确率 0.67 | 简洁性 1.0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

上面的代码展示了 LangSmith 的完整工作流：先通过 @traceable 装饰器自动收集 Trace，再通过 Client 创建评估数据集和样本，最后用 evaluate 函数批量运行评估。每次评估都会在 LangSmith 平台生成一个实验记录，支持多版本对比分析。

# Trace 分析与调试

from langsmith import Client
from datetime import datetime, timedelta

client = Client()

# 查询最近24小时的追踪记录
runs = client.list_runs(
    project_name="ai-agent-eval",
    start_time=datetime.now() - timedelta(hours=24),
    run_type="chain",
    error=False,
)

# 分析 Token 消耗与延迟
for run in runs:
    total_tokens = run.prompt_tokens + run.completion_tokens
    latency = (run.end_time - run.start_time).total_seconds()
    print(f"Run: {run.name} | Tokens: {total_tokens} | Latency: {latency:.1f}s | Status: {run.status}")

# 找出耗时最长的 Top 5 请求
slowest = sorted(runs, key=lambda r: (r.end_time - r.start_time), reverse=True)[:5]
for run in slowest:
    print(f"[SLOW] {run.name}: {(run.end_time - run.start_time).total_seconds():.1f}s")

# 导出失败 Trace 用于离线分析
failed_runs = client.list_runs(
    project_name="ai-agent-eval",
    start_time=datetime.now() - timedelta(hours=24),
    error=True,
)
for run in failed_runs:
    print(f"[ERROR] {run.name}: {run.error}")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

# 17.8 评估驱动开发（EDD）方法论

评估驱动开发（Evaluation-Driven Development，简称 EDD）是一种以评估为核心的 Agent 开发方法论。它的核心理念是：先定义评估标准和数据集，再开发 Agent 逻辑。这类似于测试驱动开发（TDD），但评估集替代了单元测试，LLM 评估器替代了断言。

🔄 EDD 开发流程

❌ 传统开发

  1. 开发 Agent 逻辑
  2. 手动测试几个 case
  3. 上线后发现效果不好
  4. 回头改 prompt、改工具
  5. 反复试错，效率低下

✅ EDD 开发

  1. 设计评估数据集（50+ case）
  2. 定义评估器和通过标准
  3. 跑基线评估（即使 Agent 还没写好）
  4. 开发 Agent，每改一版跑评估
  5. 评估分数达标后再上线

# 评估集设计原则

📐 评估集设计四原则

原则 说明 示例
代表性 覆盖真实用户场景的典型问题 从真实日志中提取高频问题
多样性 包含简单、中等、困难不同难度 简单30% + 中等50% + 困难20%
边界覆盖 包含异常输入和边界条件 空输入、超长文本、注入攻击
可演进 持续补充新发现的 bad case 线上 bad case 定期归入评估集

# 离线评估 vs 在线评估

离线评估（Offline） 在固定数据集上运行 Agent，用评估器自动打分。 特点：可重复、快速迭代、成本低。 用途：开发阶段 prompt 优化、模型选型、回归测试。 局限：评估集覆盖有限，无法发现新问题。

在线评估（Online） 在生产环境中收集真实用户反馈和行为数据。 特点：最真实、持续运行、噪声大。 用途：线上质量监控、发现新 bad case、A/B 测试。 局限：反馈滞后、需要流量、不可重复。

# A/B 测试在 Agent 中的应用

import random
from dataclasses import dataclass
from typing import Optional

@dataclass
class ABTestConfig:
    """A/B 测试配置"""
    experiment_name: str
    variant_a_name: str  # 对照组（如 gpt-4o）
    variant_b_name: str  # 实验组（如 gpt-4o-mini）
    traffic_split: float  # B 组流量比例，如 0.2 表示 20%
    min_sample_size: int = 100  # 最小样本量
    metrics: list = None  # 关注的指标列表

class AgentABTester:
    def __init__(self, config: ABTestConfig):
        self.config = config
        self.results_a = []  # A 组结果
        self.results_b = []  # B 组结果

    def assign_variant(self, user_id: str) -> str:
        """根据用户 ID 确定性分配分组，保证同一用户始终在同一组"""
        hash_val = hash(user_id) % 100 / 100
        return self.config.variant_b_name if hash_val < self.config.traffic_split else self.config.variant_a_name

    def record_result(self, variant: str, success: bool, latency: float, tokens: int):
        """记录一次请求的结果"""
        result = {"success": success, "latency": latency, "tokens": tokens}
        if variant == self.config.variant_a_name:
            self.results_a.append(result)
        else:
            self.results_b.append(result)

    def analyze(self) -> dict:
        """分析 A/B 测试结果，计算关键指标差异"""
        def stats(results):
            if not results:
                return {"success_rate": 0, "avg_latency": 0, "avg_tokens": 0}
            n = len(results)
            return {
                "success_rate": sum(r["success"] for r in results) / n,
                "avg_latency": sum(r["latency"] for r in results) / n,
                "avg_tokens": sum(r["tokens"] for r in results) / n,
            }
        return {self.config.variant_a_name: stats(self.results_a),
                self.config.variant_b_name: stats(self.results_b)}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

A/B 测试是 Agent 线上迭代的核心手段。通过流量分割，将一部分用户导向新版本 Agent，对比关键指标（成功率、延迟、Token 消耗）的差异，决定是否全量发布。注意：Agent 的 A/B 测试需要更大的样本量，因为 LLM 输出方差大，单次请求的随机性可能掩盖真实差异。

# 回归测试设计

import json
from pathlib import Path

# 回归测试集结构
class RegressionTestSuite:
    def __init__(self, test_data_path: str):
        self.path = Path(test_data_path)
        self.test_cases = self._load()

    def _load(self):
        """加载回归测试集"""
        with open(self.path) as f:
            return json.load(f)

    def run(self, agent_fn, evaluators):
        """运行回归测试，返回通过率和退化用例"""
        results = []
        for case in self.test_cases:
            pred = agent_fn(case["input"])
            scores = [ev(pred, case) for ev in evaluators]
            passed = all(s["score"] >= 0.8 for s in scores)
            results.append({
                "case_id": case["id"],
                "passed": passed,
                "scores": scores,
                "input": case["input"][:50],
            })
        passed_count = sum(r["passed"] for r in results)
        regressions = [r for r in results if not r["passed"]]
        return {"pass_rate": passed_count / len(results),
                "regressions": regressions}

# 使用示例
suite = RegressionTestSuite("tests/agent_regression_v1.json")
report = suite.run(run_qa_agent, [correctness, conciseness])
print(f"通过率: {report['pass_rate']:.0%}")
print(f"退化用例: {len(report['regressions'])}")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

回归测试是 EDD 方法论的安全网。每次修改 Agent 的 prompt、工具或模型后，都跑一遍回归测试集，确保改动不会引入退化。建议将回归测试集成到 CI/CD 流水线中，在每次 PR 合并前自动运行，退化用例数必须为 0 才允许合并。

# 17.9 评估框架：Ragas 与 DeepEval

手动评估效率低、不可重复。专业评估框架可以自动化评估流程，提供量化指标，让你像跑单元测试一样跑 Agent 评估。

# 17.9.1 Ragas：RAG 评估的事实标准

Ragas（Retrieval Augmented Generation Assessment）是专为 RAG 系统设计的评估框架，提供 4 个核心指标：

指标 评估什么 计算方式
Faithfulness（忠实度） 回答是否基于检索内容？有没有编造？ 将回答拆分语句，逐条验证是否可从上下文推导
Answer Relevance（回答相关性） 回答是否切题？ 用 LLM 从回答反推可能的问题，与原问题比较相似度
Context Precision（上下文精确率） 检索到的文档中有多少是相关的？ 判断每个检索文档是否包含答案，计算精确率
Context Recall（上下文召回率） 答案所需的信息是否都被检索到了？ 将标准答案拆分，逐条验证是否在检索内容中
from ragas import evaluate
from ragas.metrics import (
    faithfulness,            # 忠实度
    answer_relevancy,       # 回答相关性
    context_precision,      # 上下文精确率
    context_recall          # 上下文召回率
)
from datasets import Dataset

# 准备评估数据集
eval_data = {
    "question": [
        "Agent 的记忆系统有哪些类型？",
        "MCP 协议解决了什么问题？",
        "LangGraph 的 Checkpoint 机制有什么用？",
    ],
    "answer": [
        "Agent 的记忆分为短期记忆和长期记忆……",  # Agent 的回答
        "MCP 解决了工具定义不统一的问题……",
        "Checkpoint 机制用于状态保存和人工干预……",
    ],
    "contexts": [
        ["短期记忆存储对话历史……", "长期记忆使用向量数据库……"],  # 检索到的文档
        ["MCP 之前每个框架有自己的工具格式……"],
        ["LangGraph 的 Checkpoint 每步自动保存……"],
    ],
    "ground_truth": [
        "记忆分为短期记忆（对话历史）和长期记忆（向量存储）",  # 标准答案
        "MCP 统一了 Agent 与工具的连接标准",
        "用于状态持久化、人工干预、错误恢复",
    ],
}

dataset = Dataset.from_dict(eval_data)

# 运行评估
result = evaluate(
    dataset=dataset,
    metrics=[faithfulness, answer_relevancy, context_precision, context_recall],
    llm=ChatOpenAI(model="gpt-4o"),        # 评估用的 LLM
    embeddings=OpenAIEmbeddings(),           # 用于 answer_relevancy
)

print(result)
# {'faithfulness': 0.85, 'answer_relevancy': 0.92,
#  'context_precision': 0.78, 'context_recall': 0.88}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

# 17.9.2 DeepEval：通用 Agent 评估框架

DeepEval 不局限于 RAG，提供更通用的 Agent 评估指标，支持单元测试风格的断言。

from deepeval import assert_test
from deepeval.test_case import LLMTestCase
from deepeval.metrics import (
    AnswerRelevancyMetric,
    FaithfulnessMetric,
    HallucinationMetric,
    ToxicityMetric,
    GEval          # 自定义评估指标
)

# 定义评估指标
answer_relevancy = AnswerRelevancyMetric(threshold=0.7)
faithfulness = FaithfulnessMetric(threshold=0.8)
hallucination = HallucinationMetric(threshold=0.5)  # 幻觉分数越低越好

# 创建测试用例（类似单元测试）
test_case = LLMTestCase(
    input="什么是 ReAct 模式？",
    actual_output="ReAct 是让 LLM 在推理和行动之间交替的框架……",  # Agent 回答
    expected_output="ReAct 让 Agent 在推理(Thought)和行动(Action)之间循环",  # 期望
    context=["ReAct 模式由 Yao 等人提出，核心是 Thought-Action-Observation 循环"],  # 上下文
)

# 运行评估 + 断言（CI/CD 友好）
assert_test(test_case, [answer_relevancy, faithfulness, hallucination])
# 如果任何指标低于阈值，测试失败 → CI 阻止发布

# 自定义指标：用 G-Eval 定义你自己的评估标准
correctness = GEval(
    name="Correctness",
    criteria="""判断回答是否在事实上正确，逻辑是否严密，
    是否完整覆盖了用户问题的所有方面""",
    threshold=0.7
)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

# 17.9.3 Ragas vs DeepEval 选型

对比维度 Ragas DeepEval
专注领域 RAG 评估（检索+生成） 通用 Agent 评估
核心指标 Faithfulness/Relevance/Context Precision/Recall Relevance/Faithfulness/Hallucination/Toxicity/G-Eval
测试风格 数据集批量评估 单元测试 + 断言
CI/CD 集成 脚本式 pytest 原生（assert_test）
自定义指标 有限 G-Eval 灵活自定义
推荐场景 RAG 系统评估 Agent 全流程评估 + CI/CD

💡 最佳实践：两者结合 如果你的 Agent 包含 RAG，用 Ragas 评估检索质量（Context Precision/Recall），用 DeepEval 评估生成质量和安全性（Hallucination/Toxicity）。两者互补，覆盖完整。

# 面试八股

Q：Agent 评估为什么比传统软件难？有哪些维度？

A： 难点：LLM 输出有随机性（相同输入不同输出），"正确"难以定义，多步骤多轮交互。

六个维度：①任务完成率 ②准确性 ③效率（步数/token/时间）④安全性 ⑤鲁棒性 ⑥用户满意度。

传统软件只需要功能正确性，Agent 需要全方位评估。

Q：LLM-as-Judge 是什么？有什么优缺点？

A： 原理：用另一个 LLM（通常是更强的模型）来评判 Agent 输出的质量。给定评分维度和标准，Judge LLM 输出分数和评语。

优点：快、便宜、可大规模评估。 缺点：有自身偏差（偏好长回答、偏好同模型输出）、对细微事实错误不敏感、评分一致性不如人工。

最佳实践：用 LLM-as-Judge 做大规模初筛，人工标注做最终验收。

Q：Agent 可观测性的三个层次是什么？

A： ① 日志（Logging）：记录每一步操作——用户输入、LLM 调用、工具调用、返回结果。最基础。 ② 指标（Metrics）：聚合统计——Token 消耗、响应延迟、成功率、工具调用次数。用于监控告警。 ③ 追踪（Tracing）：全链路追踪——一次请求经过的所有步骤、每次 LLM 调用的完整 prompt 和 response。用于调试和优化。

Q：生产环境 Agent 必须监控的黄金指标有哪些？

A： 质量指标：任务成功率（>90%）、幻觉率（<5%）、满意度（>80%） 性能指标：首 token 延迟（P95<2s）、端到端延迟（P95<30s）、Token 消耗 安全指标：提示注入次数、敏感信息泄露、危险工具调用、无限循环 业务指标：DAU、会话长度、留存率、每次对话成本

Q：LangSmith 和 Langfuse 有什么区别？怎么选？

A： LangSmith：LangChain 官方产品，与 LangChain/LangGraph 深度集成。SaaS 为主，闭源。 Langfuse：开源可观测平台，框架无关（支持任何 LLM 应用）。可自部署，数据自控。

选择：用 LangChain 生态选 LangSmith（集成最好），要自部署或跨框架选 Langfuse（开源灵活）。

Q：Agent 评估的 5 大核心指标是什么？分别怎么计算？

A： ① 任务完成率：完成任务数 / 总任务数 × 100%，衡量 Agent 是否完成了用户要求。 ② 步数效率：实际步数 / 最优步数，比值越接近 1 说明规划能力越强。 ③ Token 成本：Σ(prompt_tokens + completion_tokens) × 单价，用于成本控制。 ④ 准确率：正确回答数 / 总回答数 × 100%，衡量事实准确性。 ⑤ 鲁棒性：异常输入下正常处理数 / 异常输入总数 × 100%，衡量稳定性。

这五个指标从能力、效率、成本、质量、稳定性全面覆盖 Agent 表现。

Q：LangSmith 的核心功能有哪些？

A： ① Trace 追踪：通过 @traceable 装饰器自动收集 Agent 每一步的输入输出、Token 消耗、延迟。 ② Dataset 管理：创建评估数据集，管理输入输出样本对，支持版本化。 ③ 自动化评估：evaluate() 函数批量运行 Agent 并用自定义评估器打分。 ④ 实验对比：通过 experiment_prefix 标记不同版本，在平台上直观对比指标差异。 ⑤ 在线监控：生产环境实时监控 Trace，支持按时间、项目、状态查询和告警。

Q：离线评估和在线评估有什么区别？怎么配合使用？

A： 离线评估：在固定数据集上运行评估器打分。可重复、快速迭代、成本低，适合开发阶段做 prompt 优化和模型选型。但覆盖有限，无法发现新问题。 在线评估：在生产环境中收集真实用户反馈和行为数据。最真实、持续运行，适合线上质量监控和发现 bad case。但反馈滞后、噪声大。

配合方式：离线评估做快速迭代（每天多次），在线评估做长期监控（持续运行）。线上发现的 bad case 定期补充到离线评估集中，形成闭环。

Q：什么是评估驱动开发（EDD）？它和 TDD 有什么区别？

A： EDD（Evaluation-Driven Development）：先设计评估数据集和评估器，再开发 Agent 逻辑。每改一版跑评估，分数达标再上线。

与 TDD 的区别：TDD 用确定性的单元测试（assert 相等），EDD 用概率性的 LLM 评估器（打分 + 阈值）；TDD 关注功能正确性，EDD 关注多维度表现（准确率、效率、安全性等）；TDD 的断言是二值的，EDD 的评估是连续分数。

核心价值：避免"凭感觉改 prompt"的盲目迭代，让每次改动都有数据支撑。

Q：怎么设计 Agent 的回归测试集？

A： 设计原则： ① 代表性：从真实日志中提取高频问题，覆盖主要使用场景。 ② 多样性：包含简单（30%）、中等（50%）、困难（20%）三个难度。 ③ 边界覆盖：包含空输入、超长文本、提示注入等异常 case。 ④ 可演进：线上发现的 bad case 定期归入回归集，持续扩充。

实践建议：回归集至少 50 个 case，集成到 CI/CD 流水线，每次 PR 自动运行。退化用例数必须为 0 才允许合并。建议按功能模块分组管理，定位问题更快。

Q：什么是影子测试（Shadow Testing）？在 Agent 评估中有什么作用？

A： 影子测试：在生产环境同时运行新旧两套 Agent 的逻辑，对比输出差异，精准验证优化效果。类似 A/B 测试但不影响用户体验——两套逻辑并行运行，用户只看到旧版结果，新版结果仅用于内部对比。

作用：① 验证新版本是否真的更好，不只是离线指标好看；② 发现离线评估未覆盖的生产环境 edge case；③ 降低新版本上线风险——先影子跑一段时间确认无异常再正式切换。

面试要点：影子测试是"从离线评估到上线"之间的最后一道验证，体现专业评估思维而非"改完就上线"的粗糙做法。

Q：怎么量化评估一个 Agent 的性能好坏？2026 面试四维评估框架是什么？

A： 避免自学答题片面、话术不专业的问题，我从四个维度量化评估：

① 核心任务成功率：最终能完整解决用户需求的比例。这是最根本的指标——能干成事才是硬道理。生产环境要求 >90%。

② 平均推理步数：步数越少 → 模型推理成本越低 → 响应速度越快 → 体验更好。反映 Agent 的"效率"而非"能力"。

③ 工具调用准确率：避免无效/错误的工具调用。反映 Agent "决策精准度"——选对了工具、传对了参数才算成功。

④ 影子测试：生产环境同时运行新旧两套 Agent 逻辑，对比输出差异，精准验证优化效果。这是专业评估的标志，避免"凭感觉说优化了"的模糊表述。

面试要点：四维框架覆盖能力（成功率）、效率（步数）、精准度（工具准确率）、验证（影子测试），体现系统化评估思维。

# 课后练习

# 第 1 题（单选）

Agent 评估相比传统软件评估的最大挑战是？

A. Agent 运行速度太慢 B. LLM 输出有随机性，"正确"难以定义 C. Agent 不需要评估 D. 评估工具太少

答案与解析

答案：B

LLM 输出有随机性（相同输入不同输出），"正确"难以明确定义。需要多维度评估。

# 第 2 题（单选）

LLM-as-Judge 评估方法的主要缺点是？

A. 速度太慢 B. 成本太高 C. 有自身偏差（如偏好长回答） D. 无法使用

答案与解析

答案：C

LLM-as-Judge 有自身偏差：偏好长回答、偏好同模型输出、对细微事实错误不敏感、评分一致性不如人工。

# 第 3 题（单选）

Agent 可观测性中 Tracing（追踪）的作用是？

A. 记录聚合统计数据 B. 全链路追踪一次请求的所有步骤 C. 发送告警通知 D. 训练模型

答案与解析

答案：B

Tracing 记录一次用户请求经过的所有步骤：每次 LLM 调用的完整 prompt 和 response、工具调用等。用于调试和优化。

# 第 4 题（单选）

生产环境 Agent 的幻觉率应该控制在？

A. < 1% B. < 5% C. < 20% D. < 50%

答案与解析

答案：B

幻觉率应控制在 < 5%。任务成功率 > 90%，用户满意度 > 80% 是生产环境的基本要求。

# 第 5 题（单选）

需要自部署且框架无关的 Agent 可观测性工具是？

A. LangSmith B. Langfuse C. LangChain D. PyTorch

答案与解析

答案：B

Langfuse 是开源可观测平台，支持自部署且框架无关。LangSmith 是 LangChain 官方的 SaaS 产品。

# 第 6 题（多选）

Agent 评估的六个维度包括哪些？

A. 任务完成率 B. 准确性 C. 代码行数 D. 安全性

答案与解析

答案：A、B、D

六维度：任务完成率、准确性、效率、安全性、鲁棒性、用户满意度。代码行数不是评估维度。

# 第 7 题（多选）

关于 Agent 评估方法，以下说法正确的是？

A. 人工标注最准但贵且慢 B. LLM-as-Judge 快但有偏差 C. 基准测试集可重复但覆盖有限 D. 用户反馈最真实且无噪声

答案与解析

答案：A、B、C

用户反馈最真实但噪声大（用户可能随便点）。其他三项描述正确。

# 第 8 题（多选）

Agent 生产环境必须监控的安全指标包括？

A. 提示注入攻击次数 B. 敏感信息泄露次数 C. 危险工具调用次数 D. 代码风格违规

答案与解析

答案：A、B、C

安全指标：提示注入、敏感信息泄露、危险工具调用、无限循环。代码风格违规不是 Agent 安全指标。

# 第 9 题（单选）

LangSmith 中 @traceable 装饰器的作用是？

A. 提高 Agent 运行速度 B. 自动收集函数调用的 Trace 信息（输入、输出、延迟、Token） C. 加密 Agent 的 prompt D. 自动生成评估数据集

答案与解析

答案：B

@traceable 装饰器会自动追踪被装饰函数的调用链路，记录输入、输出、延迟、Token 消耗等信息，并上传到 LangSmith 平台。

# 第 10 题（单选）

LangSmith 中创建评估数据集使用的 API 是？

A. Client.create_dataset() + Client.create_examples() B. Client.upload_data() C. Client.train_model() D. Client.export_results()

答案与解析

答案：A

先用 Client.create_dataset() 创建数据集，再用 Client.create_examples() 批量添加评估样本，每个样本包含 inputs 和 outputs。

# 第 11 题（单选）

LangSmith evaluate() 函数的 experiment_prefix 参数的作用是？

A. 设置评估器的名称前缀 B. 标记实验版本名称，便于在平台上对比不同版本的结果 C. 限制评估的并发数 D. 设置评估的超时时间

答案与解析

答案：B

experiment_prefix 用于标记实验版本（如 "gpt4o-baseline"、"gpt4o-mini-v2"），在 LangSmith 平台上可以直观对比不同实验的指标差异。

# 第 12 题（多选）

关于评估驱动开发（EDD），以下说法正确的是？

A. 先设计评估数据集，再开发 Agent 逻辑 B. 每次改动后跑评估，用数据驱动决策 C. EDD 用确定性的 assert 断言替代评估器 D. 评估分数达标后才上线

答案与解析

答案：A、B、D

EDD 先设计评估集再开发，每改一版跑评估，达标才上线。EDD 用概率性评估器（打分+阈值），不是确定性 assert 断言，选项 C 错误。

# 第 13 题（多选）

Agent A/B 测试中需要注意的事项包括？

A. 需要更大的样本量，因为 LLM 输出方差大 B. 同一用户应始终分配到同一组（确定性分组） C. A/B 测试只适合离线评估，不能用于线上 D. 需要对比成功率、延迟、Token 消耗等多个指标

答案与解析

答案：A、B、D

A/B 测试需要更大样本量（LLM 随机性大），同一用户确定性分组（避免体验不一致），对比多指标。A/B 测试主要用于线上评估，选项 C 错误。

CLI Agent：命令行智能助手