LangSmith — Tracing with the Python SDK¶

import langsmith as ls
from langsmith import traceable


@traceable(run_type="retriever", name="search-kb", metadata={"index": "faq-v2"})
def search_kb(query: str) -> list[dict]:
    return [{"page_content": "Reset password: Settings → Security", "type": "Document", "metadata": {"source": "faq"}}]


@traceable(run_type="llm", name="classify", metadata={"ls_provider": "openai", "ls_model_name": "gpt-4o-mini"})
def classify(messages: list[dict]) -> dict:
    run = ls.get_current_run_tree()          # None when tracing is off
    if run:
        run.set(usage_metadata={"input_tokens": 27, "output_tokens": 3, "total_tokens": 30})
    return {"role": "assistant", "content": "P2"}


def hide_key(inputs: dict) -> dict:
    return {**inputs, "api_key": "[REDACTED]"}


@traceable(run_type="tool", process_inputs=hide_key)
def create_ticket(api_key: str, summary: str) -> str:
    return "T-981"


@traceable(name="triage", tags=["smoke"], metadata={"thread_id": "t-1"})
def triage(ticket: str) -> str:
    search_kb(ticket)
    create_ticket("sk-secret", ticket)
    return classify([{"role": "user", "content": ticket}])["content"]

import langsmith as ls

with ls.trace("checkout-flow", "chain", inputs={"cart": "c-42"}, tags=["e2e"], metadata={"tenant": "acme"}) as rt:
    total = compute_total("c-42")             # traceable calls inside become child runs
    rt.end(outputs={"total": total})

with ls.tracing_context(enabled=False):
    triage("contains customer data")           # not traced

with ls.tracing_context(project_name="tenant-acme", tags=["eu"], metadata={"thread_id": thread_id}):
    triage("traced to another project")

import anthropic
import openai
from langsmith.wrappers import wrap_anthropic, wrap_openai

oai = wrap_openai(openai.OpenAI(), tracing_extra={"tags": ["wrapped"], "metadata": {"suite": "smoke"}})
resp = oai.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "Classify: login fails"}],
    langsmith_extra={"metadata": {"call": "classify"}},      # per-call overrides
)

claude = wrap_anthropic(anthropic.Anthropic())

chain.invoke(
    {"ticket": "Typo on About page"},
    config={"run_name": "triage-chain", "tags": ["lc"], "metadata": {"thread_id": thread_id}},
)

with ls.tracing_context(enabled=True, project_name="adhoc"):       # trace one call when the env var is unset
    graph.invoke({"ticket": "..."})

THREAD_ID = str(ls.uuid7())


def handle_turn(message: str) -> str:
    with ls.tracing_context(metadata={"thread_id": THREAD_ID}):    # applied to the root and all child runs
        return chat_pipeline(message)

from langsmith import Client, traceable, uuid7

client = Client()
run_id = uuid7()


@traceable(name="answer")
def answer(question: str) -> str:
    return "Use Settings → Security."


answer("How do I reset my password?", langsmith_extra={"run_id": run_id})        # root run: trace_id == run_id
project_id = client.read_project(project_name="support-bot-ci").id

client.create_feedback(
    run_id=run_id, trace_id=run_id, session_id=project_id,
    key="user_score", score=1, comment="helpful",
)

# client service
from langsmith.run_helpers import get_current_run_tree

@traceable
async def call_backend(http, payload):
    headers = {}
    if run := get_current_run_tree():
        headers.update(run.to_headers())          # langsmith-trace + baggage
    return await http.post("/triage", json=payload, headers=headers)


# server service (FastAPI / Starlette)
from fastapi import FastAPI, Request
from langsmith.middleware import TracingMiddleware

app = FastAPI()
app.add_middleware(TracingMiddleware)              # or: with ls.tracing_context(parent=request.headers): ...

from langsmith.integrations.otel import configure        # pip install "langsmith[otel]"
from opentelemetry import trace

configure(project_name="otel-demo")                        # LangSmith becomes the only TracerProvider
with trace.get_tracer("qa").start_as_current_span("triage") as span:
    span.set_attribute("langsmith.span.kind", "chain")
    span.set_attribute("langsmith.metadata.user_id", "u-1")

export LANGSMITH_TRACING_SAMPLING_RATE=0.25        # send ~25% of traces

quiet = Client(tracing_sampling_rate=0.0)
with ls.tracing_context(client=quiet):             # per-client rates; 0.0 = nothing sent
    agent.invoke(...)

from langsmith import Client, traceable
from langsmith.anonymizer import create_anonymizer, create_secret_anonymizer

pii = create_anonymizer([
    {"pattern": r"[\w.+-]+@[\w-]+\.[\w.]+", "replace": "<email>"},
    {"pattern": r"\b(?:\d[ -]?){13,16}\b", "replace": "<card>"},
])
client = Client(anonymizer=pii)


@traceable(client=client, name="triage")
def triage(ticket: str) -> str:                     # trace shows: "mail me at <email> about order 42"
    return "P2"