langsmith-trace

两个主要主题：为应用添加**追踪**，以及**查询追踪**以进行调试和分析。支持 Python 和 Javascript 实现。 环境变量

LANGSMITH_API_KEY=lsv2_pt_your_api_key_here          # Required
LANGSMITH_PROJECT=your-project-name                   # Optional: default project
LANGSMITH_WORKSPACE_ID=your-workspace-id              # Optional: for org-scoped keys

重要： 在查询或与 LangSmith 交互之前，务必检查环境变量或 .env 文件中的 LANGSMITH_PROJECT。该变量会告知你相关追踪和数据所属的项目。如果 LangSmith 项目不可用，请根据最佳判断确定合适的项目。

CLI 工具

curl -sSL https://raw.githubusercontent.com/langchain-ai/langsmith-cli/main/scripts/install.sh | sh

<trace_langchain_oss> 对于 LangChain/LangGraph 应用，追踪会自动进行。只需设置环境变量：

export LANGSMITH_TRACING=true
export LANGSMITH_API_KEY=<your-api-key>
export OPENAI_API_KEY=<your-openai-api-key>  # or your LLM provider's key

可选变量：

• LANGSMITH_PROJECT - 指定项目名称（默认为 "default"）
• LANGCHAIN_CALLBACKS_BACKGROUND=false - 用于无服务器环境，确保追踪在函数退出前完成（Python） </trace_langchain_oss>

<trace_other_frameworks> 对于非 LangChain 应用，如果框架原生支持 OpenTelemetry，请使用 LangSmith 的 OpenTelemetry 集成。

如果应用未使用框架，或使用的框架不支持自动 OTel，则使用 traceable 装饰器/包装器包装 LLM 客户端。

使用 @traceable 装饰器和 wrap_openai() 实现自动追踪。 ```python from langsmith import traceable from langsmith.wrappers import wrap_openai from openai import OpenAI

client = wrap_openai(OpenAI())

@traceable def my_llm_pipeline(question: str) -> str: resp = client.chat.completions.create( model="gpt-4o-mini", messages=[{"role": "user", "content": question}], ) return resp.choices[0].message.content

Nested tracing example

@traceable def rag_pipeline(question: str) -> str: docs = retrieve_docs(question) return generate_answer(question, docs)

@traceable(name="retrieve_docs") def retrieve_docs(query: str) -> list[str]: return docs

@traceable(name="generate_answer") def generate_answer(question: str, docs: list[str]) -> str: return client.chat.completions.create(...)

</python>

<typescript>
使用 traceable() 包装器和 wrapOpenAI() 实现自动追踪。
```typescript
import { traceable } from "langsmith/traceable";
import { wrapOpenAI } from "langsmith/wrappers";
import OpenAI from "openai";

const client = wrapOpenAI(new OpenAI());

const myLlmPipeline = traceable(async (question: string): Promise<string> => {
  const resp = await client.chat.completions.create({
    model: "gpt-4o-mini",
    messages: [{ role: "user", content: question }],
  });
  return resp.choices[0].message.content || "";
}, { name: "my_llm_pipeline" });

// Nested tracing example
const retrieveDocs = traceable(async (query: string): Promise<string[]> => {
  return docs;
}, { name: "retrieve_docs" });

const generateAnswer = traceable(async (question: string, docs: string[]): Promise<string> => {
  const resp = await client.chat.completions.create({
    model: "gpt-4o-mini",
    messages: [{ role: "user", content: `${question}\nContext: ${docs.join("\n")}` }],
  });
  return resp.choices[0].message.content || "";
}, { name: "generate_answer" });

const ragPipeline = traceable(async (question: string): Promise<string> => {
  const docs = await retrieveDocs(question);
  return await generateAnswer(question, docs);
}, { name: "rag_pipeline" });

最佳实践：

• 对所有希望在 LangSmith 中显示的嵌套函数应用 traceable
• 包装后的客户端会自动追踪所有调用 — wrap_openai()/wrapOpenAI() 会记录每次 LLM 调用
• 为追踪命名，以便更轻松地筛选
• 添加元数据，便于搜索 </trace_other_frameworks>

<traces_vs_runs> 使用 langsmith CLI 查询追踪数据。

了解两者的区别至关重要：

• Trace = 完整的执行树（根 run + 所有子 run）。一个 trace 表示一次完整的 Agent 调用，其中包含所有 LLM 调用、工具调用和嵌套操作。
• Run = 树中的一个节点（一次 LLM 调用、一次工具调用等）。

通常应优先查询 trace — 它们能提供完整上下文并保留层级结构，这是轨迹分析和数据集生成所必需的。 </traces_vs_runs>

<command_structure> 两组命令的行为一致：

langsmith
├── trace (operations on trace trees - USE THIS FIRST)
│   ├── list    - List traces (filters apply to root run)
│   ├── get     - Get single trace with full hierarchy
│   └── export  - Export traces to JSONL files (one file per trace)
│
├── run (operations on individual runs - for specific analysis)
│   ├── list    - List runs (flat, filters apply to any run)
│   ├── get     - Get single run
│   └── export  - Export runs to single JSONL file (flat)
│
├── dataset (dataset operations)
│   ├── list    - List datasets
│   ├── get     - Get dataset details
│   ├── create  - Create empty dataset
│   ├── delete  - Delete dataset
│   ├── export  - Export dataset to file
│   └── upload  - Upload local JSON as dataset
│
├── example (example operations)
│   ├── list    - List examples in a dataset
│   ├── create  - Add example to a dataset
│   └── delete  - Delete an example
│
├── evaluator (evaluator operations)
│   ├── list    - List evaluators
│   ├── upload  - Upload evaluator
│   └── delete  - Delete evaluator
│
├── experiment (experiment operations)
│   ├── list    - List experiments
│   └── get     - Get experiment results
│
├── thread (thread operations)
│   ├── list    - List conversation threads
│   └── get     - Get thread details
│
└── project (project operations)
    └── list    - List tracing projects

主要区别：

	traces *	runs *
筛选条件应用于	仅根 run	任何匹配的 run
--run-type	不可用	可用
返回内容	完整层级结构	平铺列表
导出输出	目录（每个 trace 一个文件）	单个文件
</command_structure>

<querying_traces> 使用 langsmith CLI 查询 trace。命令与语言无关。

# List recent traces (most common operation)
langsmith trace list --limit 10 --project my-project

# List traces with metadata (timing, tokens, costs)
langsmith trace list --limit 10 --include-metadata

# Filter traces by time
langsmith trace list --last-n-minutes 60
langsmith trace list --since 2025-01-20T10:00:00Z

# Get specific trace with full hierarchy
langsmith trace get <trace-id>

# List traces and show hierarchy inline
langsmith trace list --limit 5 --show-hierarchy

# Export traces to JSONL (one file per trace, includes all runs)
langsmith trace export ./traces --limit 20 --full

# Filter traces by performance
langsmith trace list --min-latency 5.0 --limit 10    # Slow traces (>= 5s)
langsmith trace list --error --last-n-minutes 60     # Failed traces

# List specific run types (flat list)
langsmith run list --run-type llm --limit 20

</querying_traces>

所有命令都支持以下筛选条件（条件之间为 AND 关系）：

基本筛选条件：

• --trace-ids abc,def - 筛选指定 trace
• --limit N - 最大结果数
• --project NAME - 项目名称
• --last-n-minutes N - 时间筛选
• --since TIMESTAMP - 时间筛选（ISO 格式）
• --error / --no-error - 错误状态
• --name PATTERN - 名称包含（不区分大小写）

性能筛选条件：

• --min-latency SECONDS - 最小延迟（例如，5 表示 >= 5s）
• --max-latency SECONDS - 最大延迟
• --min-tokens N - 最小总 token 数
• --tags tag1,tag2 - 包含这些标签中的任意一个

高级筛选条件：

• --filter QUERY - 用于复杂情况（反馈、元数据等）的原始 LangSmith 筛选查询

# Filter traces by feedback score using raw LangSmith query
langsmith trace list --filter 'and(eq(feedback_key, "correctness"), gte(feedback_score, 0.8))'

<export_format> 导出会创建 .jsonl 文件（每行一个 run），包含以下字段：

{"run_id": "...", "trace_id": "...", "name": "...", "run_type": "...", "parent_run_id": "...", "inputs": {...}, "outputs": {...}}

使用 --include-io 或 --full 包含输入/输出（生成数据集时必需）。 </export_format>

• 从 traces 开始——它们提供了生成轨迹和数据集所需的完整上下文
• 使用 traces export --full 导出用于数据集的大批量数据
• 始终指定 --project，避免混合不同项目的数据
• 使用 /tmp 存放临时导出文件
• 添加 --include-metadata，用于性能和成本分析
• 合并文件：cat ./traces/*.jsonl > all.jsonl