追踪 LangChain 应用程序 (Python 和 JS/TS)

LangSmith 与流行的用于构建 LLM 应用程序的开源框架 LangChain（支持 Python 和 JavaScript）实现了无缝集成。

安装

为 Python 或 JS 安装以下包（代码示例中使用了 OpenAI 集成）。有关所有可用软件包的完整列表，请参阅 LangChain 文档。

pip install langchain_openai

yarn add @langchain/openai @langchain/core

npm install @langchain/openai @langchain/core

pnpm add @langchain/openai @langchain/core

快速入门

1. 配置您的环境

export LANGSMITH_TRACING=true
export LANGSMITH_API_KEY=<your-api-key>
# This example uses OpenAI, but you can use any LLM provider of choice
export OPENAI_API_KEY=<your-openai-api-key>
# For LangSmith API keys linked to multiple workspaces, set the LANGSMITH_WORKSPACE_ID environment variable to specify which workspace to use.
export LANGSMITH_WORKSPACE_ID=<your-workspace-id>

如果您的账户位于美国以外的区域（默认为美国），还需要将 LANGSMITH_ENDPOINT 设置为您所在区域对应的 API URL。如果不这样做，您的 API 密钥将无法识别，请求将无法通过身份验证。

Region
GCP US
GCP EU
GCP APAC
AWS US

例如，欧盟账户应设置：export LANGSMITH_ENDPOINT="https://eu.api.smith.langchain.com"。

如果您正在使用 LangChain.js 并结合 LangSmith，且不在无服务器环境中，我们还建议您显式设置以下变量以减少延迟：export LANGCHAIN_CALLBACKS_BACKGROUND=true如果您处于无服务器环境中，我们建议设置相反的值，以便在函数结束前完成追踪：export LANGCHAIN_CALLBACKS_BACKGROUND=false

2. 记录追踪

将追踪记录到 LangSmith 不需要额外代码。只需像往常一样运行您的 LangChain 代码即可。

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant. Please respond to the user's request only based on the given context."),
    ("user", "Question: {question}\nContext: {context}")
])

model = ChatOpenAI(model="gpt-5.4-mini")
output_parser = StrOutputParser()
chain = prompt | model | output_parser

question = "Can you summarize this morning's meetings?"
context = "During this morning's meeting, we solved all world conflict."

chain.invoke({"question": question, "context": context})

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

const prompt = ChatPromptTemplate.fromMessages([
  ["system", "You are a helpful assistant. Please respond to the user's request only based on the given context."],
  ["user", "Question: {question}\nContext: {context}"],
]);

const model = new ChatOpenAI({ modelName: "gpt-5.4-mini" });
const outputParser = new StringOutputParser();
const chain = prompt.pipe(model).pipe(outputParser);

const question = "Can you summarize this morning's meetings?"
const context = "During this morning's meeting, we solved all world conflict."

await chain.invoke({ question: question, context: context });

3. 查看您的追踪

默认情况下，追踪记录将被记录到名为 default 的项目中。

选择性追踪

上一节展示了如何通过设置单个环境变量来追踪应用程序中所有 LangChain 可运行对象的调用。虽然这是一种方便的入门方式，但您可能只想追踪特定的调用或应用程序的特定部分。在 Python 中有两种方法可以实现：手动传入一个 LangChainTracer 实例作为回调，或使用 tracing_context 上下文管理器。在 JS/TS 中，您可以将 LangChainTracer 实例作为回调传递。

# 您可以选择只追踪特定的调用..
import langsmith as ls

with ls.tracing_context(enabled=True):
    chain.invoke({"question": "Am I using a callback?", "context": "I'm using a callback"})

# 这次不会被追踪（假设未设置 LANGSMITH_TRACING）
chain.invoke({"question": "Am I being traced?", "context": "I'm not being traced"})

# 即使设置了 LANGSMITH_TRACING=true，这次也不会被追踪
with ls.tracing_context(enabled=False):
    chain.invoke({"question": "Am I being traced?", "context": "I'm not being traced"})

// 您可以配置一个 LangChainTracer 实例来追踪特定的调用。
import { LangChainTracer } from "@langchain/core/tracers/tracer_langchain";

const tracer = new LangChainTracer();
await chain.invoke(
  {
    question: "Am I using a callback?",
    context: "I'm using a callback"
  },
  { callbacks: [tracer] }
);

记录到特定项目

静态设置

正如在追踪概念指南中提到的，LangSmith 使用项目（Project）的概念来对追踪进行分组。如果未指定，追踪器项目默认设置为 default。您可以通过设置 LANGSMITH_PROJECT 环境变量来为整个应用程序运行配置自定义项目名称。这应在执行应用程序之前完成。

export LANGSMITH_PROJECT=my-project

LANGSMITH_PROJECT 标志仅在 JS SDK 版本 >= 0.2.16 中受支持，如果您使用的是旧版本，请改用 LANGCHAIN_PROJECT。

动态设置

这主要建立在上一节的基础上，并允许您为特定的 LangChainTracer 实例或在 Python 中作为 tracing_context 上下文管理器的参数设置项目名称。

# 您可以使用 project_name 参数设置项目名称。
import langsmith as ls

with ls.tracing_context(project_name="My Project", enabled=True):
    chain.invoke({"question": "Am I using a context manager?", "context": "I'm using a context manager"})

// 您可以为特定的追踪器实例设置项目名称：
import { LangChainTracer } from "@langchain/core/tracers/tracer_langchain";

const tracer = new LangChainTracer({ projectName: "My Project" });
await chain.invoke(
  {
    question: "Am I using a callback?",
    context: "I'm using a callback"
  },
  { callbacks: [tracer] }
);

向追踪添加元数据和标签

您可以通过在 RunnableConfig 中提供任意元数据和标签来注释您的追踪。这对于将附加信息（如执行环境或发起用户）关联到追踪非常有用。有关如何按元数据和标签查询追踪和运行的信息，请参阅查询追踪 (SDK)。

当您将元数据或标签附加到一个可运行对象（无论是通过 RunnableConfig 还是在运行时通过调用参数）时，它们会被该可运行对象的所有子可运行对象继承。

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful AI."),
    ("user", "{input}")
])

# 标签 "model-tag" 和元数据 {"model-key": "model-value"} 将只附加到 ChatOpenAI 运行
chat_model = ChatOpenAI().with_config({"tags": ["model-tag"], "metadata": {"model-key": "model-value"}})
output_parser = StrOutputParser()

# 标签和元数据可以通过 RunnableConfig 配置
chain = (prompt | chat_model | output_parser).with_config({"tags": ["config-tag"], "metadata": {"config-key": "config-value"}})

# 标签和元数据也可以在运行时传递
chain.invoke({"input": "What is the meaning of life?"}, {"tags": ["invoke-tag"], "metadata": {"invoke-key": "invoke-value"}})

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

const prompt = ChatPromptTemplate.fromMessages([
    ["system", "You are a helpful AI."],
    ["user", "{input}"]
])

// 标签 "model-tag" 和元数据 {"model-key": "model-value"} 将只附加到 ChatOpenAI 运行
const model = new ChatOpenAI().withConfig({ tags: ["model-tag"], metadata: { "model-key": "model-value" } });
const outputParser = new StringOutputParser();

// 标签和元数据可以通过 RunnableConfig 配置
const chain = (prompt.pipe(model).pipe(outputParser)).withConfig({"tags": ["config-tag"], "metadata": {"config-key": "top-level-value"}});

// 标签和元数据也可以在运行时传递
await chain.invoke({input: "What is the meaning of life?"}, {tags: ["invoke-tag"], metadata: {"invoke-key": "invoke-value"}})

自定义运行名称

您可以通过在 Config 中提供名称来自定义给定运行（run）在调用或流式传输您的 LangChain 代码时的名称。此名称用于在 LangSmith 中标识运行，并可用于过滤和分组运行。该名称也用作 LangSmith 用户界面中运行的标题。这可以通过在构造时在 RunnableConfig 对象中设置 run_name，或者在 JS/TS 中的调用参数中传递 run_name 来实现。

# 在 LangChain 内部进行追踪时，运行名称默认为被追踪对象的类名（例如 'ChatOpenAI'）。
configured_chain = chain.with_config({"run_name": "MyCustomChain"})
configured_chain.invoke({"input": "What is the meaning of life?"})

# 您也可以在调用时配置运行名称，如下所示
chain.invoke({"input": "What is the meaning of life?"}, {"run_name": "MyCustomChain"})

// 在 LangChain 内部进行追踪时，运行名称默认为被追踪对象的类名（例如 'ChatOpenAI'）。
const configuredChain = chain.withConfig({ runName: "MyCustomChain" });
await configuredChain.invoke({ input: "What is the meaning of life?" });

// 您也可以在调用时配置运行名称，如下所示
await chain.invoke({ input: "What is the meaning of life?" }, {runName: "MyCustomChain"})

run_name 参数仅更改您调用的可运行对象（例如链、函数）的名称。它不会自动重命名当您调用像 ChatOpenAI (gpt-5.4-mini) 这样的 LLM 对象时自动创建的嵌套运行。在此示例中，外部运行在 LangSmith 中将显示为 MyCustomChain，而嵌套的 LLM 运行仍然显示模型的默认名称。要为 LLM 运行指定更有意义的名称，您可以：

将模型包装在另一个可运行对象中，并为该步骤分配 run_name。
使用追踪装饰器或辅助函数（例如 Python 中的 @traceable，或 JS/TS 中来自 langsmith 的 traceable）在模型调用周围创建一个自定义运行。

在追踪中覆盖模型名称

在追踪 LangChain 模型调用时，LangSmith 会自动捕获 API 调用中使用的模型标识符。但是，出于组织目的或区分不同模型配置，您可能希望在追踪中显示一个不同的、更具描述性的名称。您可以在构造或配置 LangChain 模型时传递 ls_model_name 元数据参数来实现这一点。这在以下情况下特别有用：

使用自托管或本地模型，其模型 ID 可能不具描述性。
使用相同模型的不同配置，并希望在追踪中区分它们。
为模型创建别名，使追踪对您的团队更具可读性。
在不同部署环境中标准化模型名称。

from langchain_openai import ChatOpenAI
from langchain_ollama import ChatOllama

# 为本地模型覆盖模型名称
llm = ChatOllama(
    model="llama2:13b-chat",  # 实际的模型 ID
    metadata={"ls_model_name": "llama2-13b-production"}  # LangSmith 中显示的名称
)

# 或者在 OpenAI 中区分配置
llm_creative = ChatOpenAI(
    model="gpt-5.5",
    temperature=0.9,
    metadata={"ls_model_name": "gpt-5.4-creative"}
)

llm_factual = ChatOpenAI(
    model="gpt-5.5",
    temperature=0.1,
    metadata={"ls_model_name": "gpt-5.4-factual"}
)

# 当模型在链中使用时，元数据会被继承
result = llm.invoke("What is the meaning of life?")

import { ChatOpenAI } from "@langchain/openai";
import { ChatOllama } from "@langchain/ollama";

// 为本地模型覆盖模型名称
const llm = new ChatOllama({
  model: "llama2:13b-chat",  // 实际的模型 ID
  metadata: { ls_model_name: "llama2-13b-production" }  // LangSmith 中显示的名称
});

// 或者在 OpenAI 中区分配置
const llmCreative = new ChatOpenAI({
  modelName: "gpt-5.5",
  temperature: 0.9,
  metadata: { ls_model_name: "gpt-5.4-creative" }
});

const llmFactual = new ChatOpenAI({
  modelName: "gpt-5.5",
  temperature: 0.1,
  metadata: { ls_model_name: "gpt-5.4-factual" }
});

// 当模型在链中使用时，元数据会被继承
const result = await llm.invoke("What is the meaning of life?");

当您在模型的元数据中传递 ls_model_name 时，此名称将出现在涉及该模型实例的所有追踪的 LangSmith 界面中。这适用于任何 LangChain 聊天模型或 LLM，并被使用该模型的所有运行（包括作为链的一部分时）继承。

ls_model_name 元数据参数也用于成本跟踪。当与 ls_provider 参数结合使用时，LangSmith 可以自动计算自托管或自定义模型的成本。有关所有可用元数据参数的更多信息，请参阅元数据参数参考。

自定义运行 ID

您可以通过在 Config 中提供 ID 来自定义给定运行（run）在调用或流式传输您的 LangChain 代码时的 ID。此 ID 用于在 LangSmith 中唯一标识运行，并可用于查询特定运行。该 ID 对于跨不同系统链接运行或实现自定义跟踪逻辑非常有用。这可以通过在构造时在 RunnableConfig 对象中设置 run_id，或者在调用参数中传递 run_id 来实现。

此功能目前不直接支持 LLM 对象。

import uuid

my_uuid = uuid.uuid4()

# 您可以在调用时配置运行 ID：
chain.invoke({"input": "What is the meaning of life?"}, {"run_id": my_uuid})

const myUuid = crypto.randomUUID();

// 您可以在调用时配置运行 ID，如下所示
await chain.invoke({ input: "What is the meaning of life?" }, { runId: myUuid });

请注意，如果您在追踪的根部（即顶级运行）执行此操作，该运行 ID 将被用作 trace_id。

获取 LangChain 调用的运行 (span) ID

当您调用一个 LangChain 对象时，可以手动指定该调用的运行 ID。此运行 ID 可用于在 LangSmith 中查询该运行。在 JS/TS 中，您可以使用 RunCollectorCallbackHandler 实例来访问运行 ID。

import uuid

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant. Please respond to the user's request only based on the given context."),
    ("user", "Question: {question}\n\nContext: {context}")
])
model = ChatOpenAI(model="gpt-5.4-mini")
output_parser = StrOutputParser()

chain = prompt | model | output_parser

question = "Can you summarize this morning's meetings?"
context = "During this morning's meeting, we solved all world conflict."
my_uuid = uuid.uuid4()
result = chain.invoke({"question": question, "context": context}, {"run_id": my_uuid})
print(my_uuid)

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

const prompt = ChatPromptTemplate.fromMessages([
  ["system", "You are a helpful assistant. Please respond to the user's request only based on the given context."],
  ["user", "Question: {question}\n\nContext: {context}"],
]);
const model = new ChatOpenAI({ modelName: "gpt-5.4-mini" });
const outputParser = new StringOutputParser();

const chain = prompt.pipe(model).pipe(outputParser);
const runCollector = new RunCollectorCallbackHandler();

const question = "Can you summarize this morning's meetings?"
const context = "During this morning's meeting, we solved all world conflict."
await chain.invoke(
    { question: question, context: context },
    { callbacks: [runCollector] }
);
const runId = runCollector.tracedRuns[0].id;
console.log(runId);

确保在退出前提交所有追踪

在 LangChain Python 中，LangSmith 的追踪在后台线程中进行，以避免阻碍您的生产应用程序。这意味着您的进程可能在所有追踪成功发送到 LangSmith 之前就已结束。这在无服务器环境中尤其常见，您的虚拟机可能在链或代理完成后立即被终止。您可以通过将 LANGCHAIN_CALLBACKS_BACKGROUND 环境变量设置为 "false" 来使回调同步。对于这两种语言，LangChain 提供了方法，以便在退出应用程序之前等待追踪提交完成。下面是一个示例：

from langchain_openai import ChatOpenAI
from langchain_core.tracers.langchain import wait_for_all_tracers

llm = ChatOpenAI()

try:
  llm.invoke("Hello, World!")
finally:
  wait_for_all_tracers()

import { awaitAllCallbacks } from "@langchain/core/callbacks/promises";

try {
    const llm = new ChatOpenAI();
    const response = await llm.invoke("Hello, World!");
} catch (e) {
    // 处理错误
} finally {
    await awaitAllCallbacks();
}

不设置环境变量进行追踪

正如其他指南中提到的，以下环境变量允许您配置追踪是否启用、API 端点、API 密钥和追踪项目：

LANGSMITH_TRACING
LANGSMITH_API_KEY
LANGSMITH_ENDPOINT
LANGSMITH_PROJECT

然而，在某些环境中，无法设置环境变量。在这些情况下，您可以通过编程方式设置追踪配置。这主要建立在上一节的基础上。

import langsmith as ls

# 您可以创建一个包含 API 密钥和 API URL 的客户端实例
client = ls.Client(
    api_key="YOUR_API_KEY",  # 可以从密钥管理器获取
    api_url="https://api.smith.langchain.com",  # 根据需要使用自托管、GCP EU (`eu.api...`)、GCP APAC (`apac.api...`) 或 AWS US (`aws.api...`)
)

# 您可以将客户端和 project_name 传递给 tracing_context
with ls.tracing_context(client=client, project_name="test-no-env", enabled=True):
    chain.invoke({"question": "Am I using a callback?", "context": "I'm using a callback"})

import { LangChainTracer } from "@langchain/core/tracers/tracer_langchain";
import { Client } from "langsmith";

// 您可以创建一个包含 API 密钥和 API URL 的客户端实例
const client = new Client(
    {
        apiKey: "YOUR_API_KEY",
        apiUrl: "https://api.smith.langchain.com", // 根据需要使用自托管、GCP EU (`eu.api...`)、GCP APAC (`apac.api...`) 或 AWS US (`aws.api...`)
    }
);

// 您可以将客户端和 project_name 传递给 LangChainTracer 实例
const tracer = new LangChainTracer({client, projectName: "test-no-env"});
await chain.invoke(
  {
    question: "Am I using a callback?",
    context: "I'm using a callback",
  },
  { callbacks: [tracer] }
);

使用 LangChain (Python) 进行分布式追踪

LangSmith 支持与 LangChain Python 进行分布式追踪。这允许您跨不同的服务和应用程序链接运行 (span)。其原理类似于 LangSmith SDK 的分布式追踪指南。

import langsmith
from langchain_core.runnables import chain
from langsmith.run_helpers import get_current_run_tree

# -- 此代码应位于单独的文件或服务中 --
@chain
def child_chain(inputs):
    return inputs["test"] + 1

def child_wrapper(x, headers):
    with langsmith.tracing_context(parent=headers):
        child_chain.invoke({"test": x})

# -- 此代码应位于单独的文件或服务中 --
@chain
def parent_chain(inputs):
    rt = get_current_run_tree()
    headers = rt.to_headers()
    # ... 使用 headers 向另一个服务发出请求
    # headers 应传递给另一个服务，最终传递给 child_wrapper 函数

parent_chain.invoke({"test": 1})

LangChain (Python) 和 LangSmith SDK 之间的互操作性

如果您在应用程序的某些部分使用 LangChain，而在其他部分使用 LangSmith SDK（参见自定义插桩），您仍然可以无缝地追踪整个应用程序。 LangChain 对象在 traceable 函数内被调用时会被追踪，并绑定为 traceable 函数的子运行。

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langsmith import traceable

prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant. Please respond to the user's request only based on the given context."),
    ("user", "Question: {question}\nContext: {context}")
])

model = ChatOpenAI(model="gpt-5.4-mini")
output_parser = StrOutputParser()
chain = prompt | model | output_parser

# 上面的链将被追踪为 traceable 函数的子运行
@traceable(
    tags=["openai", "chat"],
    metadata={"foo": "bar"}
)
def invoke_runnnable(question, context):
    result = chain.invoke({"question": question, "context": context})
    return "The response is: " + result

invoke_runnnable("Can you summarize this morning's meetings?", "During this morning's meeting, we solved all world conflict.")

这将生成以下追踪树： Trace tree python interop

LangChain.JS 和 LangSmith SDK 之间的互操作性

在 `traceable` 内追踪 LangChain 对象（仅限 JS）

从 langchain@0.2.x 开始，LangChain 对象在 @traceable 函数内使用时会被自动追踪，并继承 traceable 函数的客户端、标签、元数据和项目名称。对于低于 0.2.x 的旧版 LangChain，您需要手动传递一个从 @traceable 中的追踪上下文创建的 LangChainTracer 实例。

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

const prompt = ChatPromptTemplate.fromMessages([
  [
    "system",
    "You are a helpful assistant. Please respond to the user's request only based on the given context.",
  ],
  ["user", "Question: {question}\nContext: {context}"],
]);

const model = new ChatOpenAI({ modelName: "gpt-5.4-mini" });
const outputParser = new StringOutputParser();
const chain = prompt.pipe(model).pipe(outputParser);

const main = traceable(
  async (input: { question: string; context: string }) => {
    const callbacks = await getLangchainCallbacks();
    const response = await chain.invoke(input, { callbacks });
    return response;
  },
  { name: "main" }
);

通过 `traceable` / RunTree API 追踪 LangChain 子运行（仅限 JS）

我们正在努力改进 traceable 和 LangChain 之间的互操作性。在将 LangChain 与 traceable 结合使用时存在以下限制：

修改通过 RunnableLambda 上下文的 getCurrentRunTree() 获取的 RunTree 将导致无操作（no-op）。
不鼓励遍历通过 RunnableLambda 的 getCurrentRunTree() 获取的 RunTree，因为它可能不包含所有 RunTree 节点。
不同的子运行可能具有相同的 execution_order 和 child_execution_order 值。因此在极端情况下，某些运行可能会根据 start_time 以不同的顺序结束。

在某些用例中，您可能希望将 traceable 函数作为 RunnableSequence 的一部分运行，或通过 RunTree API 命令式地追踪 LangChain 运行的子运行。从 LangSmith 0.1.39 和 @langchain/core 0.2.18 开始，您可以直接在 RunnableLambda 内调用 traceable 包装的函数。

import { traceable } from "langsmith/traceable";
import { RunnableLambda } from "@langchain/core/runnables";
import { RunnableConfig } from "@langchain/core/runnables";

const tracedChild = traceable((input: string) => `Child Run: ${input}`, {
  name: "Child Run",
});

const parrot = new RunnableLambda({
  func: async (input: { text: string }, config?: RunnableConfig) => {
    return await tracedChild(input.text);
  },
});

或者，您可以使用 RunTree.fromRunnableConfig 将 LangChain 的 RunnableConfig 转换为等效的 RunTree 对象，或者将 RunnableConfig 作为 traceable 包装函数的第一个参数传递。

import { traceable } from "langsmith/traceable";
import { RunnableLambda } from "@langchain/core/runnables";
import { RunnableConfig } from "@langchain/core/runnables";

const tracedChild = traceable((input: string) => `Child Run: ${input}`, {
  name: "Child Run",
});

const parrot = new RunnableLambda({
  func: async (input: { text: string }, config?: RunnableConfig) => {
    // 将 config 传递给现有的 traceable 函数
    await tracedChild(config, input.text);
    return input.text;
  },
});

import { RunTree } from "langsmith/run_trees";
import { RunnableLambda } from "@langchain/core/runnables";
import { RunnableConfig } from "@langchain/core/runnables";

const parrot = new RunnableLambda({
  func: async (input: { text: string }, config?: RunnableConfig) => {
    // 从 RunnableLambda 的 RunnableConfig 创建 RunTree
    const childRunTree = RunTree.fromRunnableConfig(config, {
      name: "Child Run",
    });

    childRunTree.inputs = { input: input.text };
    await childRunTree.postRun();

    childRunTree.outputs = { output: `Child Run: ${input.text}` };
    await childRunTree.patchRun();

    return input.text;
  },
});

如果您更喜欢视频教程，请查看 LangSmith 入门课程中的替代追踪方式视频。

Connect these docs to Claude, VSCode, and more via MCP for real-time answers.

Edit this page on GitHub or file an issue.

Tracing setup

Configuration & troubleshooting

追踪 LangChain 应用程序 (Python 和 JS/TS)

安装

快速入门

1. 配置您的环境

2. 记录追踪

3. 查看您的追踪

选择性追踪

记录到特定项目

静态设置

动态设置

向追踪添加元数据和标签

自定义运行名称

在追踪中覆盖模型名称

自定义运行 ID

获取 LangChain 调用的运行 (span) ID

确保在退出前提交所有追踪

不设置环境变量进行追踪

使用 LangChain (Python) 进行分布式追踪

LangChain (Python) 和 LangSmith SDK 之间的互操作性

LangChain.JS 和 LangSmith SDK 之间的互操作性

在 `traceable` 内追踪 LangChain 对象（仅限 JS）

通过 `traceable` / RunTree API 追踪 LangChain 子运行（仅限 JS）

​安装

​快速入门

​1. 配置您的环境

​2. 记录追踪

​3. 查看您的追踪

​选择性追踪

​记录到特定项目

​静态设置

​动态设置

​向追踪添加元数据和标签

​自定义运行名称

​在追踪中覆盖模型名称

​自定义运行 ID

​获取 LangChain 调用的运行 (span) ID

​确保在退出前提交所有追踪

​不设置环境变量进行追踪

​使用 LangChain (Python) 进行分布式追踪

​LangChain (Python) 和 LangSmith SDK 之间的互操作性

​LangChain.JS 和 LangSmith SDK 之间的互操作性

​在 traceable 内追踪 LangChain 对象（仅限 JS）

​通过 traceable / RunTree API 追踪 LangChain 子运行（仅限 JS）

安装

快速入门

1. 配置您的环境

2. 记录追踪

3. 查看您的追踪

选择性追踪

记录到特定项目

静态设置

动态设置

向追踪添加元数据和标签

自定义运行名称

在追踪中覆盖模型名称

自定义运行 ID

获取 LangChain 调用的运行 (span) ID

确保在退出前提交所有追踪

不设置环境变量进行追踪

使用 LangChain (Python) 进行分布式追踪

LangChain (Python) 和 LangSmith SDK 之间的互操作性

LangChain.JS 和 LangSmith SDK 之间的互操作性

在 `traceable` 内追踪 LangChain 对象（仅限 JS）

通过 `traceable` / RunTree API 追踪 LangChain 子运行（仅限 JS）