LangSmith 实用指南

[Pines-Cheng]

评估智能体的中间步骤

在许多场景中，评估智能体不仅仅是关于最终结果，而是要理解它达到该决策所采取的步骤。本笔记本提供了一个入门演练，介绍如何配置评估器来基于智能体的"决策过程"进行评估，根据所选工具的序列进行评分。

智能体轨迹示例

我们将创建一个自定义运行评估器，捕获智能体的中间步骤并与预定义序列进行比较。这确保智能体不仅提供正确答案，而且在使用外部资源方面也是高效的。

基本步骤包括：

1. 准备包含输入查询和预期智能体动作的数据集
2. 定义具有特定工具和行为的智能体
3. 构建检查所采取动作的自定义评估器
4. 运行评估

评估完成后，您可以在 LangSmith 中查看结果。通过本指南，您将更好地了解如何将评估器应用于更复杂的输入，如智能体的轨迹。

%pip install -U langchain openai
import os

os.environ["LANGCHAIN_API_KEY"] = "您的API密钥"
os.environ["OPENAI_API_KEY"] = "您的OPENAI API密钥"
# 如果使用托管的Langsmith实例，请更新您的API URL
os.environ["LANGCHAIN_ENDPOINT"] = "https://api.smith.langchain.com"

1. 准备数据集

定义一个新的数据集。数据集至少应包含智能体需要解决的输入查询。我们还将在数据集中存储预期步骤，以演示智能体为解决查询而预期采取的动作序列。

可选地，您可以存储参考标签，以端到端的方式评估智能体的"正确性"。

import uuid
from langsmith import Client

client = Client()

questions = [
    (
        "为什么一个10美元的计算器应用成为了任天堂Switch上评分最高的游戏之一？",
        {
            "reference": "由于其高价位，它成为了网络梗。",
            "expected_steps": ["duck_duck_go"],
        },
    ),
    (
        "你好",
        {
            "reference": "您好，我能为您做些什么？",
            "expected_steps": [],  # 期望直接回应
        },
    ),
    (
        "Dejan Trajkov是谁？",
        {
            "reference": "马其顿教授、免疫学家和医生",
            "expected_steps": ["duck_duck_go"],
        },
    ),
    (
        "谁赢得了2023年U23世界摔跤锦标赛（男子自由式92公斤级）？",
        {
            "reference": "来自土耳其的Muhammed Gimri",
            "expected_steps": ["duck_duck_go"],
        },
    ),
    (
        "我周五的第一个会议是什么？",
        {
            "reference": '您的第一个会议是上午8:30的"团队站会"',
            "expected_steps": ["check_calendar"],  # 只期望日历工具
        },
    ),
]

uid = uuid.uuid4()
dataset_name = f"智能体评估示例 {uid}"
ds = client.create_dataset(
    dataset_name=dataset_name,
    description="使用搜索和日历检查的智能体评估数据集示例。",
)
client.create_examples(
    inputs=[{"question": q[0]} for q in questions],
    outputs=[q[1] for q in questions],
    dataset_id=ds.id,
)

2. 定义智能体

智能体程序的主要组件包括：

• 智能体（或可运行对象）：接受查询和中间状态，并响应下一步要采取的动作
• 工具：智能体可以访问的工具
• 执行器：控制选择后续动作时的循环行为

在此示例中，我们将创建一个智能体，它可以访问DuckDuckGo搜索客户端（用于信息搜索）和一个模拟工具来检查用户在给定日期的日历。

我们的智能体将使用OpenAI函数调用来确保它生成符合工具预期输入模式的参数。

from dateutil.parser import parse
from langchain.agents import AgentExecutor, create_openai_tools_agent
from langchain_openai import ChatOpenAI
from langchain_community.tools import DuckDuckGoSearchResults
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.tools import tool

@tool
def check_calendar(date: str) -> list:
    """检查用户在指定日期时间（ISO格式）的日历会议。"""
    date_time = parse(date)
    # 这是一个演示多个工具的占位符
    # 在测试时很容易模拟工具
    if date_time.weekday() == 4:
        return [
            "8:30 : 团队站会",
            "9:00 : 一对一会议",
            "9:45 设计评审",
        ]
    return ["专注时间"]  # 如果可以的话...

def agent(inputs: dict):
    llm = ChatOpenAI(
        model="gpt-3.5-turbo-16k",
        temperature=0,
    )
    tools = [
        DuckDuckGoSearchResults(
            name="duck_duck_go"
        ),  # 使用DuckDuckGo的通用互联网搜索
        check_calendar,
    ]
    prompt = ChatPromptTemplate.from_messages(
        [
            ("system", "您是一个有用的助手。"),
            MessagesPlaceholder(variable_name="agent_scratchpad"),
            ("user", "{question}"),
        ]
    )
    runnable_agent = create_openai_tools_agent(llm, tools, prompt)

    executor = AgentExecutor(
        agent=runnable_agent,
        tools=tools,
        handle_parsing_errors=True,
        return_intermediate_steps=True,
    )
    return executor.invoke(inputs)

3. 定义评估器

我们将创建一个自定义运行评估器来检查智能体轨迹。它将运行的中间步骤与我们在上面数据集中保存的"基准真值"进行比较。

请查看下面的代码。注意此评估器期望智能体的响应包含"intermediate_steps"键，其中包含智能体动作列表。这通过在上面设置return_intermediate_steps=True来完成。

这也期望您的数据集在每个示例输出中都有"expected_steps"键，如上所述。

from typing import Optional
from langsmith.schemas import Example, Run

def intermediate_step_correctness(run: Run, example: Optional[Example] = None) -> dict:
    if run.outputs is None:
        raise ValueError("运行输出不能为None")
    # 这是每次运行的输出
    intermediate_steps = run.outputs.get("intermediate_steps") or []
    # 由于我们要与工具名称进行比较，现在需要获取它
    # 中间步骤是一个元组[AgentAction, Any]
    # 第一个元素是采取的动作
    # 第二个元素是采取该动作的观察结果
    trajectory = [action.tool for action, _ in intermediate_steps]
    # 这是我们上传到数据集的内容
    expected_trajectory = example.outputs["expected_steps"]
    # 仅根据是否正确来评分
    score = int(trajectory == expected_trajectory)
    return {"key": "中间步骤正确性", "score": score}

4. 评估

将您的自定义评估器添加到下面评估配置中的custom_evaluators列表中。

由于我们的数据集有多个输出键，我们必须通过设置reference_key="reference"来指示run_on_dataset函数使用哪个键作为QA评估器的基准真值。

from langsmith.evaluation import LangChainStringEvaluator, evaluate

# 现在需要指定这个，因为我们的数据集中有多个输出
def prepare_data(run: Run, example: Example) -> dict:
    return {
        "input": example.inputs["question"],
        "prediction": run.outputs["output"],
        "reference": example.outputs["reference"],
    }

# 基于参考答案测量QA响应是否"正确"
qa_evaluator = LangChainStringEvaluator("qa", prepare_data=prepare_data)
chain_results = evaluate(
    agent,
    data=dataset_name,
    evaluators=[intermediate_step_correctness, qa_evaluator],
    experiment_prefix="智能体评估示例",
    max_concurrency=1,
)

错误运行目标函数：_get_url() https://links.duckduckgo.com/d.js DuckDuckGoSearchException: 速率限制

结论

恭喜！您已成功通过将智能体的轨迹与预期的动作序列进行比较来执行简单的智能体轨迹评估。当您知道要采取的预期步骤时，这很有用。

一旦您为这种类型的评估配置了自定义评估器，就很容易使用现成的评估器（如LangChain的TrajectoryEvalChain）应用其他技术，该评估器可以指示LLM对智能体动作的有效性进行评分。

[Pines-Cheng]

JavaScript中的基于视觉的评估

LangSmith对自定义评估器的支持为您检查链对数据集的表现提供了极大的灵活性。对于某些视觉生成用例，一个令人兴奋的可能性是提示视觉模型来确定成功度。

本笔记本将演示一个改进生成HTML页面的链的示例。我们将创建一个自定义评估器，首先使用名为Puppeteer的无头浏览器渲染输出，将截图传递给OpenAI的GPT-4V，并返回分数。让我们开始吧！

先决条件

本教程使用OpenAI模型和LangChain来组合链。为确保为LangSmith正确设置跟踪和评估，请适当配置您的API密钥。

本笔记本将使用Deno，因此您需要下载并设置它才能跟上。但是，本指南的原理和一般步骤也适用于其他JavaScript运行时。

设置

首先，让我们设置Chrome Puppeteer二进制文件。这是我们用来渲染HTML并对链的生成结果进行截图的工具。在终端中从此路径运行以下命令：

接下来，确保您已设置了一个.env文件，其中将您的OpenAI密钥设置为OPENAI_API_KEY，将您的LangSmith API密钥设置为LANGCHAIN_API_KEY。此外，您应该设置LANGCHAIN_TRACING_V2=true来启用跟踪。

import "dotenv/config";

接下来，让我们设置一个简单、朴素的链，它将根据某些输入生成HTML：

import { ChatPromptTemplate } from "@langchain/core/prompts";
import { ChatOpenAI } from "@langchain/openai";
import { StringOutputParser } from "@langchain/core/output_parsers";

const prompt = ChatPromptTemplate.fromTemplate(`生成一个实现以下功能的网页HTML。除了有效的HTML之外不要返回任何其他内容。\n\n{input}`);
const model = new ChatOpenAI({ temperature: 0 });

const chain = prompt.pipe(model).pipe(new StringOutputParser());
const html = await chain.invoke({
  input: "一个税收计算器",
});

html

输出：

"<!DOCTYPE html>\n" +
  "<html>\n" +
  "<head>\n" +
  "  <title>Tax Calculator</title>\n" +
  "</head>\n" +
  "<body>\n" +
  "  <h1>Tax Calculator</h"... 762 more characters

现在让我们定义一个使用Puppeteer将HTML输出渲染为图像的函数：

import puppeteer from "puppeteer";

async function renderHtml(html) {
  const browser = await puppeteer.launch();
  const page = await browser.newPage();
  // 将页面内容设置为我们的HTML
  // Puppeteer也可以导航到网站 - 更多选项请参见 https://pptr.dev
  await page.setContent(html);
  const screenshot = await page.screenshot({ encoding: "base64" });

  await browser.close();
  return screenshot;
}

const image = await renderHtml(html);

import { display } from "https://deno.land/x/display/mod.ts";

await display({ 
  "image/jpeg": image,
}, { raw: true });

太棒了！现在，让我们创建一个LangSmith数据集。这些是输入/输出对，其中输入是链的示例输入，输出是您希望链响应该输入而创建的理想生成结果。

对于这个演示笔记本，我们将使用我们正在评估的链的直接输出快速生成参考示例。在现实世界的情况下，您会希望使用您能获得的最高质量的示例作为参考输出，要么手工策划，要么使用可能的最佳模型。

const inputs = [
  { input: "一个税收计算器" },
  { input: "一个分享照片的社交媒体网站" },
  { input: "一个电子商务创业公司着陆页" },
];

const results = await chain.batch(inputs);

const referenceOutputs = results.map((result) => {
  return { output: result };
});

import { Client } from "langsmith";

const client = new Client();

const datasetName = `lcjs-vision-eval-demo-${new Date().toISOString()}`;
const dataset = await client.createDataset(datasetName);

await Promise.all(
  inputs.map(async (input, i) => {
    await client.createExample(input, referenceOutputs[i], {
      datasetId: dataset.id,
    });
  })
);

输出：[ undefined, undefined, undefined ]

您可以登录 https://smith.langchain.com/datasets 查看新创建的数据集。

现在，让我们在自定义评估器函数中将其与视觉模型结合起来。自定义评估器接受一些参数，在类型DynamicRunEvaluatorParams中定义。这些包括：

• input: 用于调用链的数据集中的原始输入
• prediction: 链的原始输出
• reference: 我们编译数据集中的原始参考输出
• run: 评估器作用的链运行的原始元数据
• example: 数据集中的完整原始示例

input、prediction和reference都存在于原始run和example对象上。为了您的方便，它们被解析出来。

以下是可能的样子：

import type { DynamicRunEvaluatorParams } from "langchain/smith";
import type { RunnableConfig } from "@langchain/core/runnables";
import { HumanMessage } from "@langchain/core/messages";

const visionBasedEvaluator = async (
  {
    run,
    example,
    input,
    prediction,
    reference,
  }: DynamicRunEvaluatorParams, 
  options: { config: RunnableConfig }
) => {
  if (typeof prediction?.output !== "string") {
    throw new Error(
      "此评估器的预测格式无效。请检查您的链的输出并重试。"
    );
  }
  const imageBase64 = await renderHtml(prediction.output);
  const visionModel = new ChatOpenAI({
    modelName: "gpt-4-vision-preview",
    temperature: 0,
    maxTokens: 2000,
  });
  const visionEvaluatorChain = visionModel.pipe(new StringOutputParser());
  // 简单的评估提示，根据您的用例进行调整
  const chainInputMessage = new HumanMessage({
    content: [
      {
        type: "text",
        text: `一个AI模型被要求生成"${input.input}"，并用以下图像进行了响应。
        请根据质量和对"${input.input}"的忠实度给图像打分，分数在0到10之间，其中0是完全偏离目标，
        10是所期望内容的精确表示。

        除了数字之外不要返回任何其他内容`,
      },
      {
        type: "image_url",
        image_url: {
          url: `data:image/jpeg;base64,${imageBase64}`,
        },
      },
    ]
  });

  const response = await visionEvaluatorChain.invoke([
    chainInputMessage
  ], options.config);

  const score = parseInt(response, 10);

  return {
    key: "visual_generation_quality",
    score: score / 10,
    comment: response,
  };
};

对于演示，我们没有使用参考输出，因为它们只是同一链的先前运行。在现实世界的情况下，您可能希望评估器在生成分数时考虑参考输出。

现在，最后一步是在我们的数据集上运行我们的链，并使用我们新的自定义评估器对其进行评估。以下是其样子：

import { runOnDataset } from "langchain/smith";

const finalResults = await runOnDataset(chain, datasetName, {
  evaluationConfig: {
    customEvaluators: [visionBasedEvaluator]
  },
});

输出：

预测中: ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ 100.00% | 3/3

完成
运行评估器: ▓▓▓▓▓▓▓▓▓▓▓▓▓░░░░░░░░░░░░░░░░░░░░░░░░░░░ 33.33% | 1/3

运行评估器: ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓░░░░░░░░░░░░░ 66.67% | 2/3

运行评估器: ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ 100.00% | 3/3

现在，如果您返回 https://smith.langchain.com/datasets 并查看您的数据集，您应该会看到一个填充的测试运行！

点击测试运行，您将看到链输入、链输出和参考输出。您还将看到上面的visionBasedEvaluator返回的分数：

结论

就是这样！您已经设置了一个由GPT-4V和Puppeteer驱动的视觉评估器。

进一步阅读，请查看以下指南：

• JS LangSmith演练
• 评估快速入门

[Pines-Cheng]

工具选择评估

工具选择是指LLM从列表中选择适当工具来响应用户查询的能力。

本笔记本演示如何测量选定工具的精确度，包括后续步骤尝试自动更新工具描述以解决第一轮中存在的错误。

我们将在这些示例中使用ToolBench数据集的子集。

%pip install -U langchain langchain_openai
import os

# 如果使用托管的Langsmith实例，请更新您的API URL
os.environ["LANGCHAIN_ENDPOINT"] = "https://api.smith.langchain.com"
os.environ["LANGCHAIN_API_KEY"] = "您的API密钥"  # 用您的API密钥更新
# 可选：如果未设置，则使用"default"
os.environ["LANGCHAIN_PROJECT"] = "工具选择"

dev_dataset_url = (
    "https://smith.langchain.com/public/bdf7611c-3420-4c71-a492-42715a32d61e/d"
)
dataset_name = "工具选择（物流）开发集"
import langsmith

client = langsmith.Client()

client.clone_public_dataset(dev_dataset_url)

定义指标

我们将计算第一个逻辑步骤中选定工具的交并比指标。

from typing import Set

from langchain.smith import RunEvalConfig
from langsmith.evaluation import run_evaluator


@run_evaluator
def selected_tools_precision(run, example):
    expected = example.outputs["expected"]
    predicted = run.outputs["output"]
    expected: Set[str] = {tool for tools in expected for tool in tools}
    predicted: Set[str] = {tool["type"] for tool in predicted}
    true_positives = predicted & expected

    if len(predicted) == 0:
        if len(expected) > 0:
            score = 0
        else:
            score = 1
    else:
        score = len(true_positives) / len(predicted)
    return {"key": "tool_selection_precision", "score": score}


eval_config = RunEvalConfig(
    custom_evaluators=[selected_tools_precision],
)

创建模型

我们将使用适合此数据集的工具执行简单的函数调用。

import json

with open("./data/tools.json") as f:
    tools = json.load(f)

# 示例工具
tools[0]

输出：

{'type': 'function',
 'function': {'name': 'TransportistasdeArgentina',
  'description': '在OCA e-Pack中为邮政编码报价。',
  'parameters': {'type': 'object',
   'properties': {'postCodeDst': {'type': 'number',
     'description': '目的地邮政编码'},
    'cuit': {'type': 'string',
     'description': '您在OCA e-Pack中的账户CUIT'},
    'operativa': {'type': 'string',
     'description': '您在OCA e-Pack中的账户操作号'},
    'cost': {'type': 'number', 'description': '产品成本（阿根廷比索）'},
    'postCodeSrc': {'type': 'number', 'description': '源邮政编码'},
    'volume': {'type': 'number', 'description': '体积（立方厘米）'},
    'weight': {'type': 'number', 'description': '重量（公斤）'}},
   'required': ['postCodeDst',
    'cuit',
    'operativa',
    'cost',
    'postCodeSrc',
    'volume',
    'weight']}}}

from langchain_core.output_parsers.openai_tools import JsonOutputToolsParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI

model = "gpt-3.5-turbo"

assistant_prompt = ChatPromptTemplate.from_messages(
    [
        (
            "system",
            "您是一个有用的助手。使用提供的工具响应用户的查询",
        ),
        ("user", "{query}"),
    ]
)


llm = ChatOpenAI(model=model).bind_tools(tools)

chain = assistant_prompt | llm | JsonOutputToolsParser()

评估

test_results = client.run_on_dataset(
    dataset_name=dataset_name,
    llm_or_chain_factory=chain,
    evaluation=eval_config,
    verbose=True,
    project_metadata={
        "model": model,
        "tool_variant": 0,
    },
)

输出：

在以下位置查看项目'clear-jet-37'的评估结果：
https://smith.langchain.com/o/30239cd8-922f-4722-808d-897e1e722845/datasets/462d8386-60c8-4cb3-84eb-6efeae3a1293/compare?selectedSessions=8b95a94e-c05f-4ecf-b749-aeaef3ff3327

在以下位置查看数据集工具选择（物流）开发集的所有测试：
https://smith.langchain.com/o/30239cd8-922f-4722-808d-897e1e722845/datasets/462d8386-60c8-4cb3-84eb-6efeae3a1293
[------------------------------------------------->] 100/100
实验结果：
feedback.tool_selection_precision	error	execution_time	run_id
count	100.000000	0	100.000000	100
unique	NaN	0	NaN	100
top	NaN	NaN	NaN	827e2f98-bcb1-4940-aa16-5a7d0eca80ff
freq	NaN	NaN	NaN	1
mean	0.636667	NaN	1.417737	NaN
std	0.370322	NaN	0.581734	NaN
min	0.000000	NaN	0.468482	NaN
25%	0.333333	NaN	1.141958	NaN
50%	0.500000	NaN	1.331713	NaN
75%	1.000000	NaN	1.576078	NaN
max	1.000000	NaN	4.320643	NaN

评估后，我们建议审查结果并手动识别您可以修复的问题。这是一个我们尚未清理的嘈杂数据集，因此您可能希望修复标签以实际作为基准真值。

如果您想尝试更自动化（但不太可靠）的方法，请继续阅读。

提示改进器

我们将采用懒惰的方法，要求LLM推荐一套改进的工具描述，它"认为"这将改进工具选择。

这将是一个基本的映射-归约类型操作：

1. 将每个失败案例映射到更新
2. 按工具名称归约更新
3. 提炼每个工具的更新

from typing import List

from langchain_core.prompts import ChatPromptTemplate
from langchain_core.pydantic_v1 import BaseModel, Field
from langchain_core.runnables import chain as as_runnable
from langchain_openai import ChatOpenAI


class FunctionUpdate(BaseModel):
    name: str = Field(
        description="您想要更新其描述的工具名称"
    )
    updated_description: str = Field(
        description="更新的描述，明确何时以及为什么调用此函数。"
    )


class ImproveToolDocumentation(BaseModel):
    """调用以更新给定工具的文档字符串和其他信息，
    以便用户更容易选择。"""

    updates: List[FunctionUpdate] = Field(
        description="要进行的更新，每个您想要更改的工具描述一个"
    )


improver_prompt = ChatPromptTemplate.from_messages(
    [
        (
            "system",
            "您是一个API文档助手，负责细致地改进我们API文档的描述。"
            " 我们的AI助手试图通过调用API来帮助用户，但它继续调用错误的API。"
            " 您必须改进它们的文档以消除歧义，这样助手就不会再犯任何错误。\n\n"
            "##有效的API\n以下是助手正在选择的现有API：\n```apis.json\n{apis}\n```\n\n"
            "## 失败案例\n以下是用户查询、预期的API调用和实际的API调用。"
            " 使用此失败案例进行有动机的文档更改。\n\n```failure_case.json\n{failure}\n```",
        ),
        (
            "user",
            "回应更新的工具描述以清除"
            " 导致上述失败案例的任何歧义。"
            " 如果这导致问题，请随时提及它不适合什么（如果这导致问题），比如'不要将此用于x'。"
            " 更新的描述应该反映助手首先出错的原因。",
        ),
    ]
)

llm = ChatOpenAI(model="gpt-3.5-turbo").with_structured_output(ImproveToolDocumentation)

improver_chain = improver_prompt | llm

apis = json.dumps(tools, indent=2)
df = test_results.to_dataframe()
# 过滤掉成功案例
df = df[df["feedback.tool_selection_precision"] < 1]


def format_inputs(series):
    return {
        "apis": apis,
        "failure": json.dumps(
            {
                "query": series["inputs.query"],
                "predicted": [out["type"] for out in series["output"]],
                "expected": series["reference.expected"][0],
            }
        ),
    }


improver_inputs = df.apply(format_inputs, axis=1).tolist()

映射错误 -> 更新

# 这是基本的"映射"步骤
all_updates = improver_chain.batch(improver_inputs, return_exceptions=True)
# 以防其中一个运行失败（OAI停机、LLM错误等）
all_updates = [u for u in all_updates if isinstance(u, ImproveToolDocumentation)]

按工具归约更新

from collections import defaultdict

toolwise_updates = defaultdict(list)
for updates in all_updates:
    for tool_update in updates.updates:
        toolwise_updates[tool_update.name].append(tool_update.updated_description)

将更新提炼为最终描述

distill_prompt = ChatPromptTemplate.from_messages(
    [
        (
            "system",
            "您是一个API文档助手，负责细致地改进我们API文档的描述。"
            " 我们的AI助手试图通过调用API来帮助用户，但它继续调用错误的API。"
            " 您的任务是更新{target_api}描述。\n\n"
            "## 当前API\n"
            "以下是当前API和描述的列表。\n"
            "```apis.json\n{apis}\n```\n\n"
            "## 候选\n"
            " 以下是一些候选描述改进：\n{candidates}\n"
            " 在您更新的描述中考虑上述反馈。",
        ),
        (
            "user",
            "回应{target_api} API的更新描述。"
            " 它应该提炼并结合候选描述以"
            " 清除导致我们的AI助手失败的任何歧义。",
        ),
    ]
).partial(apis=apis)

distill_llm = ChatOpenAI(model=model).with_structured_output(FunctionUpdate)

distill_chain = distill_prompt | distill_llm

distill_inputs = [
    {
        "target_api": name,
        "candidates": "\n".join(["- " + c for c in candidates]),
    }
    for name, candidates in toolwise_updates.items()
]
updated_descriptions = distill_chain.batch(distill_inputs)
updates_dict = {upd.name: upd.updated_description for upd in updated_descriptions}
updates_dict

输出：

{'TransportistasdeArgentina': '获取在阿根廷境内使用OCA e-Pack发送产品的运费报价。提供目的地和源邮政编码、CUIT、操作号、成本、体积和重量详细信息以获得准确定价。',
 'TurkeyPostalCodes': '根据城市代码检索土耳其车牌号（1到81）。此API专门设计用于提供土耳其车牌的详细信息，不适用于跟踪包裹或获取阿根廷城市的邮政编码。',
 'CEPBrazil': '根据巴西CEP号码检索地址详细信息。此函数不适用于跟踪包裹位置或状态、跟踪旅行文件或提供非地址相关信息。专门使用此API在巴西使用CEP号码进行地址查找。',
 'PridnestroviePost': '通过提供国际货运的跟踪号获取跟踪信息。专门使用此API跟踪包裹和货运。',
 'PackAndSend': '如果您有Pack & Send参考号，请使用此API跟踪交付状态并检索有关包裹的相关信息。此API专门设计用于使用Pack & Send参考号跟踪包裹，不适用于提供特定州城市的邮政编码信息。',
 'TrackingMore_v2': '列出包裹跟踪的所有支持承运商。此API提供可用于跟踪包裹的承运商的全面概述。它不适用于跟踪特定包裹详细信息，而是用于识别包裹跟踪服务的承运商。',
 'SQUAKE': '此函数没有定义的目的或参数。避免使用它，因为它不提供任何特定功能。它不适用于跟踪包裹或检索包裹信息。',
 'AmexAustraliaFastwayAustraliaTracking': "使用包裹跟踪号专门在澳大利亚境内跟踪包裹的运输详细信息。此API专为通过AmexAustraliaFastway服务运输的包裹跟踪而设计，不适用于跟踪国际货运或非包裹相关查询。",
 'suivi-colis': '通过提供包裹ID检索包裹的当前状态（即最新状态）。此函数适用于跟踪包裹状态并获取交付进度的实时更新。',
 'CreateContainerTracking': '使用提供的容器ID检索与容器相关的数据。此API适用于跟踪容器并检索其详细信息。',
 'Transitaires': '检索有关特定运输公司的详细信息。此函数不是为跟踪包裹或事件规划而设计的。',
 'KargomNerede': '检索运输公司列表。',
 'GS1Parser': '解析机器或人类可读的GS1条形码数据。'}

from copy import deepcopy

new_tools = deepcopy(tools)
for tool in new_tools:
    name = tool["function"]["name"]
    if name in updates_dict:
        updated = updates_dict[name]
        tool["function"]["description"] = updated

重新评估

我们将使用相同的LLM和提示，只更新工具描述（这些描述在OpenAI的服务器上注入到提示中）。

llm = ChatOpenAI(model=model).bind_tools(new_tools)

updated_chain = assistant_prompt | llm | JsonOutputToolsParser()

model = "gpt-3.5-turbo"

updated_test_results = client.run_on_dataset(
    dataset_name=dataset_name,
    llm_or_chain_factory=updated_chain,
    evaluation=eval_config,
    project_metadata={
        "model": model,
        # 标记这是新的工具描述版本
        "tool_variant": 2,
    },
    verbose=True,
)

输出：

在以下位置查看项目'ordinary-step-81'的评估结果：
https://smith.langchain.com/o/30239cd8-922f-4722-808d-897e1e722845/datasets/462d8386-60c8-4cb3-84eb-6efeae3a1293/compare?selectedSessions=a4204d34-4d08-42fa-a84d-19b850ad920e

在以下位置查看数据集工具选择（物流）开发集的所有测试：
https://smith.langchain.com/o/30239cd8-922f-4722-808d-897e1e722845/datasets/462d8386-60c8-4cb3-84eb-6efeae3a1293
[------------------------------------------------->] 99/100
链对示例033fd6d7-6c80-4ef2-ab26-e4116e4da24a失败，输入为{'query': "我正在计划与家人去巴西度假，需要在里约热内卢找一家酒店。您能为我提供里约热内卢市中心可用酒店的列表吗？此外，我想知道CEP Brazil API的当前健康状态以及它是否正常运行。"}
错误类型：InternalServerError，消息：错误代码：500 - {'error': {'message': '服务器在处理您的请求时出错。抱歉！您可以重试您的请求，或者如果您继续看到此错误，请通过我们的帮助中心help.openai.com联系我们。（请在您的电子邮件中包含请求ID req_35b74dde88208be45493f9827dc88674。）', 'type': 'server_error', 'param': None, 'code': None}}
[------------------------------------------------->] 100/100

指标看起来稍好一些，尽管不超出标准误差范围。您可以调查数据集和模型输出质量，并完善其中任一个以使过程更有用。

测试

我们一直在单个数据集上进行爬山，这意味着关于我们正在评估的内容的信息正在渗透到模型定义中。在得出变体B比A更好的结论之前，您应该在保留集上对两者进行基准测试。以下是从同一ToolBench数据集采样的数据集。

dataset_urls = {
    # 开发集与上面相同
    "dev": dev_dataset_url,
    "test": "https://smith.langchain.com/public/a5fd6197-36ed-4d06-993a-89929dded399/d",
    "train": "https://smith.langchain.com/public/cf5a1de8-68f0-4170-9bcc-f263c1abb063/d",
}

import langsmith

client = langsmith.Client()

client.clone_public_dataset(dataset_urls["test"])
test_dataset_name = "工具选择（物流）测试集"

for target_chain in [chain, updated_chain]:
    client.run_on_dataset(
        dataset_name=test_dataset_name,
        llm_or_chain_factory=chain,
        evaluation=eval_config,
        project_metadata={
            "model": model,
            # 标记这是新的工具描述版本
            "tool_variant": 2,
        },
    )

输出：

在以下位置查看项目'definite-coach-89'的评估结果：
https://smith.langchain.com/o/30239cd8-922f-4722-808d-897e1e722845/datasets/ddc1bcf7-c3fb-4669-824d-eb2e23af93d0/compare?selectedSessions=2b7204c8-7f07-4c2c-b798-d9005a059ce0

在以下位置查看数据集工具选择（物流）测试集的所有测试：
https://smith.langchain.com/o/30239cd8-922f-4722-808d-897e1e722845/datasets/ddc1bcf7-c3fb-4669-824d-eb2e23af93d0
[------------------------------------------------->] 234/234

在以下位置查看项目'sparkling-doctor-64'的评估结果：
https://smith.langchain.com/o/30239cd8-922f-4722-808d-897e1e722845/datasets/ddc1bcf7-c3fb-4669-824d-eb2e23af93d0/compare?selectedSessions=b9d4bd07-d96b-4da8-97df-279158ffafa1

在以下位置查看数据集工具选择（物流）测试集的所有测试：
https://smith.langchain.com/o/30239cd8-922f-4722-808d-897e1e722845/datasets/ddc1bcf7-c3fb-4669-824d-eb2e23af93d0
[------------------------------------------------> ] 231/234