> ## Documentation Index
> Fetch the complete documentation index at: https://langchain-zh.cn/llms.txt
> Use this file to discover all available pages before exploring further.
# 追踪 LangChain 应用（Python 与 JS/TS）
LangSmith 与流行的开源框架 LangChain（Python 和 JavaScript）无缝集成，用于构建 LLM 应用。
## 安装
为 Python 或 JS 安装以下包（代码片段使用 OpenAI 集成）。
有关可用包的完整列表，请参阅 [LangChain 文档](/oss/python/integrations/providers/overview)。
```bash pip theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
pip install langchain_openai
```
```bash yarn theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
yarn add @langchain/openai @langchain/core
```
```bash npm theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
npm install @langchain/openai @langchain/core
```
```bash pnpm theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
pnpm add @langchain/openai @langchain/core
```
## 快速开始
### 1. 配置环境
```bash wrap theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
export LANGSMITH_TRACING=true
export LANGSMITH_API_KEY=<你的-api-key>
# 此示例使用 OpenAI，但你可以选择任何 LLM 提供商
export OPENAI_API_KEY=<你的-openai-api-key>
# 对于链接到多个工作空间的 LangSmith API 密钥，设置 LANGSMITH_WORKSPACE_ID 环境变量以指定要使用的工作空间。
export LANGSMITH_WORKSPACE_ID=<你的-workspace-id>
```
如果你在非无服务器环境中使用 LangChain.js 和 LangSmith，我们还建议显式设置以下变量以减少延迟：
`export LANGCHAIN_CALLBACKS_BACKGROUND=true`
如果你在无服务器环境中，我们建议设置相反的值，以便在函数结束前完成追踪：
`export LANGCHAIN_CALLBACKS_BACKGROUND=false`
### 2. 记录追踪
无需额外代码即可将追踪记录到 LangSmith。只需像往常一样运行你的 LangChain 代码。
```python Python theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
prompt = ChatPromptTemplate.from_messages([
("system", "你是一个有用的助手。请仅根据给定的上下文响应用户的请求。"),
("user", "问题：{question}\n上下文：{context}")
])
model = ChatOpenAI(model="gpt-4.1-mini")
output_parser = StrOutputParser()
chain = prompt | model | output_parser
question = "你能总结今天早上的会议吗？"
context = "在今天早上的会议中，我们解决了所有世界冲突。"
chain.invoke({"question": question, "context": context})
```
```typescript TypeScript theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
import { ChatOpenAI } from "@langchain/openai";
import { ChatPromptTemplate } from "@langchain/core/prompts";
import { StringOutputParser } from "@langchain/core/output_parsers";
const prompt = ChatPromptTemplate.fromMessages([
["system", "你是一个有用的助手。请仅根据给定的上下文响应用户的请求。"],
["user", "问题：{question}\n上下文：{context}"],
]);
const model = new ChatOpenAI({ modelName: "gpt-4.1-mini" });
const outputParser = new StringOutputParser();
const chain = prompt.pipe(model).pipe(outputParser);
const question = "你能总结今天早上的会议吗？"
const context = "在今天早上的会议中，我们解决了所有世界冲突。"
await chain.invoke({ question: question, context: context });
```
### 3. 查看追踪
默认情况下，追踪将记录到名为 `default` 的项目中。你可以在 LangSmith 中[公开查看](https://smith.langchain.com/public/e6a46eb2-d785-4804-a1e3-23f167a04300/r)使用上述代码记录的追踪示例。
## 选择性追踪
[上一节](#quick-start)展示了如何通过设置单个环境变量来追踪应用程序中所有 LangChain 可运行对象的调用。虽然这是一种便捷的入门方式，但你可能只想追踪特定的调用或应用程序的某些部分。
在 Python 中有两种方法可以实现：手动传递 `LangChainTracer` 实例作为[回调](https://reference.langchain.com/python/langchain_core/callbacks/)，或使用 [`tracing_context` 上下文管理器](https://reference.langchain.com/python/langsmith/observability/sdk/run_helpers/#langsmith.run_helpers.tracing_context)。
在 JS/TS 中，你可以传递 [`LangChainTracer`](https://reference.langchain.com/javascript/classes/_langchain_core.tracers_tracer_langchain.LangChainTracer.html) 实例作为回调。
```python Python theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
# 你可以选择性地启用特定调用..
import langsmith as ls
with ls.tracing_context(enabled=True):
chain.invoke({"question": "我是否在使用回调？", "context": "我正在使用回调"})
# 这不会被追踪（假设 LANGSMITH_TRACING 未设置）
chain.invoke({"question": "我是否被追踪？", "context": "我没有被追踪"})
# 即使 LANGSMITH_TRACING=true，这也不会被追踪
with ls.tracing_context(enabled=False):
chain.invoke({"question": "我是否被追踪？", "context": "我没有被追踪"})
```
```typescript TypeScript theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
// 你可以配置一个 LangChainTracer 实例来追踪特定调用。
import { LangChainTracer } from "@langchain/core/tracers/tracer_langchain";
const tracer = new LangChainTracer();
await chain.invoke(
{
question: "我是否在使用回调？",
context: "我正在使用回调"
},
{ callbacks: [tracer] }
);
```
## 记录到特定项目
### 静态设置
如[追踪概念指南](/langsmith/observability-concepts)所述，LangSmith 使用项目（Project）的概念来分组追踪。如果未指定，追踪器项目默认为 `default`。你可以设置 `LANGSMITH_PROJECT` 环境变量来为整个应用程序运行配置自定义项目名称。这应在执行应用程序之前完成。
```bash theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
export LANGSMITH_PROJECT=my-project
```
`LANGSMITH_PROJECT` 标志仅在 JS SDK 版本 >= 0.2.16 中受支持，如果你使用的是旧版本，请改用 `LANGCHAIN_PROJECT`。
### 动态设置
这主要基于[上一节](#trace-selectively)，允许你为特定的 `LangChainTracer` 实例设置项目名称，或在 Python 中作为 `tracing_context` 上下文管理器的参数。
```python Python theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
# 你可以使用 project_name 参数设置项目名称。
import langsmith as ls
with ls.tracing_context(project_name="我的项目", enabled=True):
chain.invoke({"question": "我是否在使用上下文管理器？", "context": "我正在使用上下文管理器"})
```
```typescript TypeScript theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
// 你可以为特定的追踪器实例设置项目名称：
import { LangChainTracer } from "@langchain/core/tracers/tracer_langchain";
const tracer = new LangChainTracer({ projectName: "我的项目" });
await chain.invoke(
{
question: "我是否在使用回调？",
context: "我正在使用回调"
},
{ callbacks: [tracer] }
);
```
## 向追踪添加元数据和标签
你可以通过在 [`RunnableConfig`](https://reference.langchain.com/python/langchain_core/runnables/?h=runnablecon#langchain_core.runnables.RunnableConfig) 中提供任意元数据和标签来注释你的追踪。这对于将额外信息与追踪关联非常有用，例如执行环境或发起用户。有关如何按元数据和标签查询追踪和运行的信息，请参阅[查询追踪（SDK）](/langsmith/export-traces)
当你将元数据或标签附加到可运行对象（通过 [`RunnableConfig`](https://reference.langchain.com/python/langchain-core/runnables/config/RunnableConfig) 或在运行时通过调用参数）时，它们会被该可运行对象的所有子可运行对象继承。
```python Python theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
prompt = ChatPromptTemplate.from_messages([
("system", "你是一个有用的人工智能。"),
("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": "生命的意义是什么？"}, {"tags": ["invoke-tag"], "metadata": {"invoke-key": "invoke-value"}})
```
```typescript TypeScript theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
import { ChatOpenAI } from "@langchain/openai";
import { ChatPromptTemplate } from "@langchain/core/prompts";
import { StringOutputParser } from "@langchain/core/output_parsers";
const prompt = ChatPromptTemplate.fromMessages([
["system", "你是一个有用的人工智能。"],
["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: "生命的意义是什么？"}, {tags: ["invoke-tag"], metadata: {"invoke-key": "invoke-value"}})
```
## 自定义运行名称
你可以在调用或流式处理 LangChain 代码时，通过在 [Config](https://reference.langchain.com/python/langchain_core/runnables/?h=runnablecon#langchain_core.runnables.RunnableConfig) 中提供运行名称来自定义给定运行的名称。此名称用于在 LangSmith 中标识运行，并可用于过滤和分组运行。该名称也用作 LangSmith UI 中运行的标题。这可以通过在构造时在 [`RunnableConfig`](https://reference.langchain.com/python/langchain-core/runnables/config/RunnableConfig) 对象中设置 `run_name` 或在 JS/TS 中在调用参数中传递 `run_name` 来完成。
```python Python theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
# 在 LangChain 中追踪时，运行名称默认为被追踪对象的类名（例如 'ChatOpenAI'）。
configured_chain = chain.with_config({"run_name": "MyCustomChain"})
configured_chain.invoke({"input": "生命的意义是什么？"})
# 你也可以在调用时配置运行名称，如下所示
chain.invoke({"input": "生命的意义是什么？"}, {"run_name": "MyCustomChain"})
```
```typescript TypeScript theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
// 在 LangChain 中追踪时，运行名称默认为被追踪对象的类名（例如 'ChatOpenAI'）。
const configuredChain = chain.withConfig({ runName: "MyCustomChain" });
await configuredChain.invoke({ input: "生命的意义是什么？" });
// 你也可以在调用时配置运行名称，如下所示
await chain.invoke({ input: "生命的意义是什么？" }, {runName: "MyCustomChain"})
```
`run_name` 参数仅更改你调用的可运行对象（例如链、函数）的名称。它不会自动重命名调用 LLM 对象（如 [`ChatOpenAI`](https://reference.langchain.com/python/langchain-openai/chat_models/base/ChatOpenAI) (`gpt-4.1-mini`)）时自动创建的嵌套运行。在示例中，外层运行将在 LangSmith 中显示为 `MyCustomChain`，而嵌套的 LLM 运行仍显示模型的默认名称。
要为 LLM 运行指定更有意义的名称，你可以：
* 将模型包装在另一个可运行对象中，并为该步骤分配 `run_name`。
* 使用追踪装饰器或辅助函数（例如 Python 中的 `@traceable`，或 JS/TS 中 `langsmith` 的 `traceable`）围绕模型调用创建自定义运行。
## 在追踪中覆盖模型名称
追踪 LangChain 模型调用时，LangSmith 会自动捕获 API 调用中使用的模型标识符。但是，你可能希望出于组织目的或区分不同模型配置，在追踪中显示不同的、更具描述性的名称。你可以在构造或配置 LangChain 模型时传递 `ls_model_name` [元数据参数](/langsmith/ls-metadata-parameters#ls-model-name) 来实现。
这在以下情况下特别有用：
* 使用自托管或本地模型，其中模型 ID 可能不具有描述性。
* 使用具有不同配置的同一模型，并希望在追踪中区分它们。
* 为模型创建别名，使追踪对你的团队更具可读性。
* 在不同部署环境中标准化模型名称。
```python Python theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
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-4.1",
temperature=0.9,
metadata={"ls_model_name": "gpt-4.1-creative"}
)
llm_factual = ChatOpenAI(
model="gpt-4.1",
temperature=0.1,
metadata={"ls_model_name": "gpt-4.1-factual"}
)
# 当模型在链中使用时，元数据会被继承
result = llm.invoke("生命的意义是什么？")
```
```typescript TypeScript theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
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-4.1",
temperature: 0.9,
metadata: { ls_model_name: "gpt-4.1-creative" }
});
const llmFactual = new ChatOpenAI({
modelName: "gpt-4.1",
temperature: 0.1,
metadata: { ls_model_name: "gpt-4.1-factual" }
});
// 当模型在链中使用时，元数据会被继承
const result = await llm.invoke("生命的意义是什么？");
```
当你在模型的元数据中传递 `ls_model_name` 时，该名称将出现在涉及该模型实例的所有追踪的 LangSmith UI 中。这适用于任何 LangChain 聊天模型或 LLM，并且会被使用该模型的所有运行继承，包括当它作为链的一部分时。
`ls_model_name` 元数据参数也用于[成本追踪](/langsmith/cost-tracking)。当与 `ls_provider` 参数结合使用时，LangSmith 可以自动计算自定义或自托管模型的成本。有关所有可用元数据参数的更多信息，请参阅[元数据参数参考](/langsmith/ls-metadata-parameters)。
## 自定义运行 ID
你可以在调用或流式处理 LangChain 代码时，通过在 [Config](https://reference.langchain.com/python/langchain_core/runnables/?h=runnablecon#langchain_core.runnables.RunnableConfig) 中提供运行 ID 来自定义给定运行的 ID。此 ID 用于在 LangSmith 中唯一标识运行，并可用于查询特定运行。该 ID 对于跨不同系统链接运行或实现自定义追踪逻辑非常有用。这可以通过在构造时在 [`RunnableConfig`](https://reference.langchain.com/python/langchain-core/runnables/config/RunnableConfig) 对象中设置 `run_id` 或在调用参数中传递 `run_id` 来完成。
此功能目前不直接支持 LLM 对象。
```python Python theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
import uuid
my_uuid = uuid.uuid4()
# 你可以在调用时配置运行 ID：
chain.invoke({"input": "生命的意义是什么？"}, {"run_id": my_uuid})
```
```typescript TypeScript theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
import { v4 as uuidv4 } from 'uuid';
const myUuid = uuidv4();
// 你可以在调用时配置运行 ID，如下所示
await chain.invoke({ input: "生命的意义是什么？" }, { runId: myUuid });
```
请注意，如果你在追踪的**根**（即顶级运行）处执行此操作，该运行 ID 将用作 `trace_id`。
## 访问 LangChain 调用的运行（span）ID
当你调用 LangChain 对象时，可以手动指定调用的运行 ID。此运行 ID 可用于在 LangSmith 中查询该运行。
在 JS/TS 中，你可以使用 `RunCollectorCallbackHandler` 实例来访问运行 ID。
```python Python theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
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", "你是一个有用的助手。请仅根据给定的上下文响应用户的请求。"),
("user", "问题：{question}\n\n上下文：{context}")
])
model = ChatOpenAI(model="gpt-4.1-mini")
output_parser = StrOutputParser()
chain = prompt | model | output_parser
question = "你能总结今天早上的会议吗？"
context = "在今天早上的会议中，我们解决了所有世界冲突。"
my_uuid = uuid.uuid4()
result = chain.invoke({"question": question, "context": context}, {"run_id": my_uuid})
print(my_uuid)
```
```typescript TypeScript theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
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", "你是一个有用的助手。请仅根据给定的上下文响应用户的请求。"],
["user", "问题：{question}\n\n上下文：{context}"],
]);
const model = new ChatOpenAI({ modelName: "gpt-4.1-mini" });
const outputParser = new StringOutputParser();
const chain = prompt.pipe(model).pipe(outputParser);
const runCollector = new RunCollectorCallbackHandler();
const question = "你能总结今天早上的会议吗？"
const context = "在今天早上的会议中，我们解决了所有世界冲突。"
await chain.invoke(
{ question: question, context: context },
{ callbacks: [runCollector] }
);
const runId = runCollector.tracedRuns[0].id;
console.log(runId);
```
## 确保所有追踪在退出前提交
在 LangChain Python 中，LangSmith 的追踪在后台线程中完成，以避免阻塞你的生产应用程序。这意味着你的进程可能在所有追踪成功发布到 LangSmith 之前结束。这在无服务器环境中尤其普遍，因为一旦你的链或代理完成，你的 VM 可能会立即终止。
你可以通过将 `LANGCHAIN_CALLBACKS_BACKGROUND` 环境变量设置为 `"false"` 来使回调同步。
对于两种语言，LangChain 都提供了在退出应用程序前等待追踪提交的方法。示例如下：
```python Python theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
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()
```
```typescript TypeScript theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
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`
但是，在某些环境中，无法设置环境变量。在这些情况下，你可以通过编程方式设置追踪配置。
这主要基于[上一节](#trace-selectively)。
```python Python theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
import langsmith as ls
# 你可以使用 api 密钥和 api url 创建客户端实例
client = ls.Client(
api_key="YOUR_API_KEY", # 可以从密钥管理器获取
api_url="https://api.smith.langchain.com", # 对于自托管安装或 EU 区域，请相应更新
)
# 你可以将 client 和 project_name 传递给 tracing_context
with ls.tracing_context(client=client, project_name="test-no-env", enabled=True):
chain.invoke({"question": "我是否在使用回调？", "context": "我正在使用回调"})
```
```typescript TypeScript theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
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", // 对于自托管安装或 EU 区域，请相应更新
}
);
// 你可以将 client 和 project_name 传递给 LangChainTracer 实例
const tracer = new LangChainTracer({client, projectName: "test-no-env"});
await chain.invoke(
{
question: "我是否在使用回调？",
context: "我正在使用回调",
},
{ callbacks: [tracer] }
);
```
## 使用 LangChain (Python) 进行分布式追踪
LangSmith 支持使用 LangChain Python 进行分布式追踪。这允许你跨不同服务和应用程序链接运行（span）。其原理与 LangSmith SDK 的[分布式追踪指南](/langsmith/distributed-tracing)类似。
```python theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
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（参见[自定义插装](/langsmith/annotate-code)），你仍然可以无缝追踪整个应用程序。
LangChain 对象在 `traceable` 函数内调用时将被追踪，并绑定为 `traceable` 函数的子运行。
```python theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
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", "你是一个有用的助手。请仅根据给定的上下文响应用户的请求。"),
("user", "问题：{question}\n上下文：{context}")
])
model = ChatOpenAI(model="gpt-4.1-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 "响应是：" + result
invoke_runnnable("你能总结今天早上的会议吗？", "在今天早上的会议中，我们解决了所有世界冲突。")
```
这将产生以下追踪树：
## LangChain.JS 与 LangSmith SDK 之间的互操作性
### 在 `traceable` 内追踪 LangChain 对象（仅限 JS）
从 `langchain@0.2.x` 开始，LangChain 对象在 `@traceable` 函数内使用时自动被追踪，并继承 traceable 函数的客户端、标签、元数据和项目名称。
对于低于 `0.2.x` 的旧版本 LangChain，你需要手动传递从 `@traceable` 中找到的追踪上下文创建的 `LangChainTracer` 实例。
```typescript theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
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",
"你是一个有用的助手。请仅根据给定的上下文响应用户的请求。",
],
["user", "问题：{question}\n上下文：{context}"],
]);
const model = new ChatOpenAI({ modelName: "gpt-4.1-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` 时存在以下限制：
1. 从 RunnableLambda 上下文的 `getCurrentRunTree()` 获取的 RunTree 进行修改将导致无操作。
2. 不建议通过 `getCurrentRunTree()` 遍历从 RunnableLambda 获取的 RunTree，因为它可能不包含所有 RunTree 节点。
3. 不同的子运行可能具有相同的 `execution_order` 和 `child_execution_order` 值。因此，在极端情况下，某些运行可能以不同的顺序结束，具体取决于 `start_time`。
在某些用例中，你可能希望将 `traceable` 函数作为 RunnableSequence 的一部分运行，或通过 `RunTree` API 强制追踪 LangChain 的子运行。从 LangSmith 0.1.39 和 @langchain/core 0.2.18 开始，你可以直接在 RunnableLambda 内调用 `traceable` 包装的函数。
```typescript theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
import { traceable } from "langsmith/traceable";
import { RunnableLambda } from "@langchain/core/runnables";
import { RunnableConfig } from "@langchain/core/runnables";
const tracedChild = traceable((input: string) => `子运行：${input}`, {
name: "子运行",
});
const parrot = new RunnableLambda({
func: async (input: { text: string }, config?: RunnableConfig) => {
return await tracedChild(input.text);
},
});
```
或者，你可以使用 `RunTree.fromRunnableConfig` 将 LangChain 的 [`RunnableConfig`](https://reference.langchain.com/python/langchain-core/runnables/config/RunnableConfig) 转换为等效的 RunTree 对象，或将 [`RunnableConfig`](https://reference.langchain.com/python/langchain-core/runnables/config/RunnableConfig) 作为 `traceable` 包装函数的第一个参数传递。
```typescript Traceable theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
import { traceable } from "langsmith/traceable";
import { RunnableLambda } from "@langchain/core/runnables";
import { RunnableConfig } from "@langchain/core/runnables";
const tracedChild = traceable((input: string) => `子运行：${input}`, {
name: "子运行",
});
const parrot = new RunnableLambda({
func: async (input: { text: string }, config?: RunnableConfig) => {
// 将 config 传递给现有的 traceable 函数
await tracedChild(config, input.text);
return input.text;
},
});
```
```typescript Run Tree theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
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: "子运行",
});
childRunTree.inputs = { input: input.text };
await childRunTree.postRun();
childRunTree.outputs = { output: `子运行：${input.text}` };
await childRunTree.patchRun();
return input.text;
},
});
```
如果你更喜欢视频教程，请查看 LangSmith 入门课程中的[替代追踪方式视频](https://academy.langchain.com/pages/intro-to-langsmith-preview)。
***
[Edit this page on GitHub](https://github.com/langchain-ai/docs/edit/main/src/i18n\zh-CN\langsmith\trace-with-langchain.mdx) or [file an issue](https://github.com/langchain-ai/docs/issues/new/choose).
[Connect these docs](/use-these-docs) to Claude, VSCode, and more via MCP for real-time answers.