Tracing quickstart

Add LangSmith tracing to an LLM application in minutes.

LangSmith gives you end-to-end visibility into your LLM application by capturing traces; a complete record of every step that ran during a request, from the inputs passed in to the final output returned.

In this quickstart, you will add tracing to an AI assistant and view the results in LangSmith.

If you’re building with LangChain or LangGraph, you can enable LangSmith tracing with a single environment variable. Refer to trace with LangChain or trace with LangGraph.

Prerequisites

Before you begin, make sure you have:

• A LangSmith account: Sign up or log in at smith.langchain.com.
• A LangSmith API key: Follow the Create an API key guide.
• An OpenAI API key: Generate this from the OpenAI dashboard.

This example uses OpenAI as the LLM provider. You can adapt it for your own provider.

1. Set up your environment

1. Create a project directory, install the dependencies, and configure the required environment variables:

   Python

   mkdir ls-quickstart && cd ls-quickstart
   python -m venv .venv && source .venv/bin/activate
   pip install -U langsmith openai
   

   mkdir ls-quickstart-ts && cd ls-quickstart-ts
   npm init -y
   npm install langsmith openai
   npm install -D typescript tsx
   

2. Export your environment variables in your shell:

   export LANGSMITH_TRACING=true
   export LANGSMITH_API_KEY="<your-langsmith-api-key>"
   export OPENAI_API_KEY="<your-openai-api-key>"
   
   To send traces to a specific project, use the LANGSMITH_PROJECT environment variable. If this is not set, LangSmith will create a default tracing project automatically on trace ingestion.

   If you are using Anthropic, use the Anthropic wrapper. For other providers, use the @traceable decorator to trace calls manually.

2. Build the app

The following app uses two LangSmith tools to add tracing:

• wrap_openai: wraps the OpenAI client so every model call is automatically logged.
• @traceable: wraps a function so its inputs, outputs, and nested runs appear as a single trace in LangSmith.

Create a file called app.py (or index.ts) with the following code:

Python

from openai import OpenAI
from langsmith.wrappers import wrap_openai
from langsmith import traceable

client = wrap_openai(OpenAI())  # log every OpenAI call automatically

@traceable  # capture the full function as a trace
def assistant(question: str) -> str:
    response = client.chat.completions.create(
        model="gpt-4.1-mini",
        messages=[
            {
                "role": "system",
                "content": "You are a helpful coding assistant. Answer questions concisely.",
            },
            {"role": "user", "content": question},
        ],
    )
    return response.choices[0].message.content

if __name__ == "__main__":
    print(assistant("How do I reverse a list in Python?"))

import OpenAI from "openai";
import { wrapOpenAI } from "langsmith/wrappers";
import { traceable } from "langsmith/traceable";
import { RunTree } from "langsmith";

const client = wrapOpenAI(new OpenAI()); // log every OpenAI call automatically

const assistant = traceable(async function assistant(question: string) { // capture the full function as a trace
    const response = await client.chat.completions.create({
        model: "gpt-4.1-mini",
        messages: [
            {
                role: "system",
                content: "You are a helpful coding assistant. Answer questions concisely.",
            },
            { role: "user", content: question },
        ],
    });
    return response.choices[0]?.message?.content ?? null;
});

(async () => {
    console.log(await assistant("How do I reverse a list in Python?"));
})();

3. Run the app and view your traces

Run the app:

Python

python app.py

npx tsx index.ts

Open the LangSmith UI and navigate to your default tracing project. You will see a trace for the assistant function with the OpenAI call nested inside it.

The outer span captures your assistant function’s inputs and outputs. The nested ChatOpenAI span records the exact prompt sent to the model and the response returned.

Next steps

• Tracing integrations: LangChain, LangGraph, Anthropic, and other providers.
• Trace an LLM application: a full lifecycle tutorial, from prototyping through production.
• Filter traces: search and navigate large tracing projects.
• Log to a specific project: send traces to a named project instead of default.

After logging traces, use Polly to analyze them and get AI-powered insights into your application’s performance.

---

Edit this page on GitHub or file an issue.

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