samples/langsmith_1 — awesome-ai-stack

Example

LangSmith — trace a Claude call (hosted)

A real, runnable mini-project. Download it and run with Docker.

View samples/langsmith_1 on GitHub ↗

June 28, 2026

LangSmith — trace a Claude call (hosted)

A tiny LangSmith demo: @traceable wraps a Claude call so each run shows up in LangSmith, then the app reads the run back via the SDK and prints it — proving the round trip, not just that the call didn't error. LangSmith is a hosted SaaS, so this needs your own API key (there's no free self-host).

Configure

cd samples/langsmith_1
cp .env.sample .env
# edit .env: set LANGSMITH_API_KEY and ANTHROPIC_API_KEY

Set these in .env:

LANGSMITH_API_KEY — from smith.langchain.com → Settings → API Keys
LANGSMITH_TRACING — true to send traces
LANGSMITH_PROJECT — project name traces land in
ANTHROPIC_API_KEY — key for the Claude call being traced

EU accounts also set LANGSMITH_ENDPOINT=https://eu.api.smith.langchain.com. .env is gitignored — only .env.sample is committed.

Run with Docker

cd samples/langsmith_1
docker build -t aas-langsmith .
docker run --rm --env-file .env aas-langsmith "How do I reset my password?"

Run with Docker (in a devcontainer with DooD)

In a dev container that talks to the host Docker daemon (Docker-outside-of-Docker), the foreground docker run above often prints nothing and exits 0 — but the run itself succeeds. The script runs to completion and Docker captures all of its output; only the live attached stream drops it over the VM boundary. You can confirm this: docker logs on the same container shows the full output, the container exits 0, and it is not an OOM. Run detached and follow the logs instead:

cd samples/langsmith_1
docker build -t aas-langsmith .
docker logs -f "$(docker run -d --env-file .env aas-langsmith \
  "How do I reset my password?")"

Run locally

cd samples/langsmith_1
pip install -r requirements.txt
python app.py "How do I reset my password?"

python-dotenv loads .env automatically.

Example run

Output varies by model and run — LLMs are non-deterministic, so the model's wording differs each time (the trace round-trip itself is what's being shown). Below is one run with claude-opus-4-8.

model says: I'd be happy to help you reset your password! However, the exact
steps depend on which service or account you're trying to access. ...

reading the run back from LangSmith ...
  run id:  019eff2d-6596-7461-80d0-25388eb56ec4
  name:    plan
  inputs:  {'question': 'How do I reset my password?'}
  outputs: {'output': "I'd be happy to help you reset your password! ..."}
  url:     https://smith.langchain.com/o/<org-id>/projects/p/<project-id>/r/019eff2d-...

.env.sample

# Copy this file to `.env` and add your keys.
#   cp .env.sample .env

# LangSmith is a hosted SaaS — get an API key at https://smith.langchain.com
# (Settings -> API Keys). EU users also set LANGSMITH_ENDPOINT=https://eu.api.smith.langchain.com
LANGSMITH_API_KEY=
LANGSMITH_TRACING=true
LANGSMITH_PROJECT=aas-langsmith-sample

# The call being traced uses Claude.
ANTHROPIC_API_KEY=
MODEL=claude-opus-4-8

app.py

"""LangSmith: trace a Claude call to LangSmith, then read the run back.

`@traceable` wraps the model call so each invocation shows up as a run in
LangSmith (a hosted SaaS). After the call we use the SDK to fetch the run and
print it — proving the trace landed, not just that the call didn't error.

Run:
    docker build -t aas-langsmith .
    docker run --rm --env-file .env aas-langsmith "How do I reset my password?"
"""

import os
import sys
import time

from anthropic import Anthropic
from dotenv import load_dotenv
from langsmith import Client, traceable
from langsmith.run_helpers import get_current_run_tree

load_dotenv()

MODEL = os.environ.get("MODEL", "claude-opus-4-8")
PROJECT = os.environ.get("LANGSMITH_PROJECT", "default")

anthropic = Anthropic()  # reads ANTHROPIC_API_KEY
ls = Client()  # reads LANGSMITH_API_KEY


@traceable(run_type="chain", name="plan")
def plan(question: str) -> str:
    resp = anthropic.messages.create(
        model=MODEL, max_tokens=256, messages=[{"role": "user", "content": question}]
    )
    # Stash the run id so we can read this exact run back afterwards.
    run = get_current_run_tree()
    if run is not None:
        plan.last_run_id = str(run.id)
    return resp.content[0].text


def fetch_run(run_id: str):
    """Tracing is async, so poll until the run is queryable and finished."""
    for _ in range(30):
        try:
            run = ls.read_run(run_id)
            if run.end_time is not None:
                return run
        except Exception:
            pass
        time.sleep(2)
    return None


def main() -> None:
    question = " ".join(sys.argv[1:]) or "How do I reset my password?"

    answer = plan(question)
    print("model says:", answer)

    ls.flush()  # push buffered traces before we read them back

    run_id = getattr(plan, "last_run_id", None)
    print("\nreading the run back from LangSmith ...")
    run = fetch_run(run_id) if run_id else None
    if run is None:
        print("run not queryable yet (tracing is async); check https://smith.langchain.com")
        return
    print(f"  run id:  {run.id}")
    print(f"  name:    {run.name}")
    print(f"  inputs:  {run.inputs}")
    print(f"  outputs: {run.outputs}")
    print(f"  url:     {ls.get_run_url(run=run)}")


if __name__ == "__main__":
    main()

Dockerfile

# Minimal image for the LangSmith sample.
FROM python:3.13-slim

ENV PYTHONUNBUFFERED=1

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY app.py .

# Provide your config at run time (.env is NOT baked into the image):
#   docker run --rm --env-file .env aas-langsmith "<question>"
ENTRYPOINT ["python", "app.py"]