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
   

   implementation("com.langchain.smith:langsmith-java:0.1.0-alpha.28")
   

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 your account is in a region other than US (the default), also set LANGSMITH_ENDPOINT to the API URL for your region. Without this, your API key won’t be recognized and requests will fail to authenticate.

   Region
   GCP US
   GCP EU
   GCP APAC
   AWS US

   For example, EU accounts: export LANGSMITH_ENDPOINT="https://eu.api.smith.langchain.com".

   If you are using Anthropic, use the Anthropic wrapper. If you are using Google Gemini, use the Gemini 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:

• OpenAI wrapper: wraps the OpenAI client so every LLM call is automatically logged as a nested span.
• Traceable wrapper: wraps a function so its inputs, outputs, and any nested spans appear as a single trace in LangSmith. Use @traceable in Python, traceable in TypeScript and Kotlin, and Tracing.traceFunction in Java.

The assistant function calls a tool (get_context) to retrieve relevant context, then passes that context to the model. Using the traceable wrapper on both functions captures the full pipeline in one trace, with the tool call and LLM call as nested spans.

Create a file called app.py, index.ts, App.java, or App.kt 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(run_type="tool")  # trace this as a tool span
def get_context(question: str) -> str:
    # In a real app, this would query a knowledge base or vector store
    return "LangSmith traces are stored for 14 days on the Developer plan."

@traceable  # capture the full pipeline as a single trace
def assistant(question: str) -> str:
    context = get_context(question)
    response = client.chat.completions.create(
        model="gpt-5.4-mini",
        messages=[
            {
                "role": "system",
                "content": f"Answer using the context below.\n\nContext: {context}",
            },
            {"role": "user", "content": question},
        ],
    )
    return response.choices[0].message.content

if __name__ == "__main__":
    print(assistant("How long are LangSmith traces stored?"))

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

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

const getContext = traceable(
    async function getContext(question: string): Promise<string> { // trace this as a tool span
        // In a real app, this would query a knowledge base or vector store
        return "LangSmith traces are stored for 14 days on the Developer plan.";
    },
    { run_type: "tool" }
);

const assistant = traceable(async function assistant(question: string) { // capture the full pipeline as a single trace
    const context = await getContext(question);
    const response = await client.chat.completions.create({
        model: "gpt-5.4-mini",
        messages: [
            {
                role: "system",
                content: `Answer using the context below.\n\nContext: ${context}`,
            },
            { role: "user", content: question },
        ],
    });
    return response.choices[0]?.message?.content ?? null;
});

(async () => {
    console.log(await assistant("How long are LangSmith traces stored?"));
})();

import com.langchain.smith.tracing.RunType;
import com.langchain.smith.tracing.TraceConfig;
import com.langchain.smith.tracing.Tracing;
import com.langchain.smith.wrappers.openai.OpenAITracing;
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.ChatModel;
import com.openai.models.chat.completions.ChatCompletion;
import com.openai.models.chat.completions.ChatCompletionCreateParams;
import com.openai.models.chat.completions.ChatCompletionMessageParam;
import com.openai.models.chat.completions.ChatCompletionSystemMessageParam;
import com.openai.models.chat.completions.ChatCompletionUserMessageParam;
import java.util.function.Function;

class ObservabilityQuickstartApp {
  public static void main(String[] args) {
    new ObservabilityQuickstartRunner().run();
  }

  private static final class ObservabilityQuickstartRunner {
    private final OpenAIClient client =
        OpenAITracing.wrapOpenAI(OpenAIOkHttpClient.fromEnv());

    private final Function<String, String> getContext =
        Tracing.traceFunction(
            question -> "LangSmith traces are stored for 14 days on the Developer plan.",
            TraceConfig.builder().name("get_context").runType(RunType.TOOL).build());

    private final Function<String, String> assistant =
        Tracing.traceFunction(
            question -> {
              String context = getContext.apply(question);
              ChatCompletion response =
                  client.chat()
                      .completions()
                      .create(
                          ChatCompletionCreateParams.builder()
                              .model(ChatModel.GPT_5_CHAT_LATEST)
                              .addMessage(
                                  ChatCompletionMessageParam.ofSystem(
                                      ChatCompletionSystemMessageParam.builder()
                                          .content(
                                              "Answer using the context below.\n\nContext: " + context)
                                          .build()))
                              .addMessage(
                                  ChatCompletionMessageParam.ofUser(
                                      ChatCompletionUserMessageParam.builder()
                                          .content(question)
                                          .build()))
                              .build());
              return response.choices().get(0).message().content().orElse("");
            },
            TraceConfig.builder().name("assistant").build());

    void run() {
      System.out.println(assistant.apply("How long are LangSmith traces stored?"));
    }
  }
}

import com.langchain.smith.tracing.RunType
import com.langchain.smith.tracing.TraceConfig
import com.langchain.smith.tracing.traceable
import com.langchain.smith.wrappers.openai.wrapOpenAI
import com.openai.client.okhttp.OpenAIOkHttpClient
import com.openai.models.ChatModel
import com.openai.models.chat.completions.ChatCompletionCreateParams
import com.openai.models.chat.completions.ChatCompletionMessageParam
import com.openai.models.chat.completions.ChatCompletionSystemMessageParam
import com.openai.models.chat.completions.ChatCompletionUserMessageParam
import kotlin.jvm.optionals.getOrNull

val client = wrapOpenAI(OpenAIOkHttpClient.fromEnv())

val getContext =
    traceable(
        { _: String -> "LangSmith traces are stored for 14 days on the Developer plan." },
        TraceConfig.builder().name("get_context").runType(RunType.TOOL).build(),
    )

val assistant =
    traceable(
        { question: String ->
            val context = getContext(question)
            val response =
                client.chat().completions().create(
                    ChatCompletionCreateParams.builder()
                        .model(ChatModel.GPT_5_CHAT_LATEST)
                        .addMessage(
                            ChatCompletionMessageParam.ofSystem(
                                ChatCompletionSystemMessageParam.builder()
                                    .content("Answer using the context below.\n\nContext: $context")
                                    .build(),
                            ),
                        )
                        .addMessage(
                            ChatCompletionMessageParam.ofUser(
                                ChatCompletionUserMessageParam.builder()
                                    .content(question)
                                    .build(),
                            ),
                        )
                        .build(),
                )
            response.choices()[0].message().content().getOrNull().orEmpty()
        },
        TraceConfig.builder().name("assistant").build(),
    )

println(assistant("How long are LangSmith traces stored?"))

3. Run the app

Python

python app.py

npx tsx index.ts

./gradlew run

4. View your trace

In the LangSmith UI, go to Tracing and select your default project. Click the assistant row to open the trace. The Messages tab shows the conversation as it was sent to the model. Select the Details tab to see the full run tree, including the assistant function with the get_context tool call and the OpenAI call nested inside it.

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

You can also inspect traces from the terminal using the LangSmith CLI.

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 Chat to analyze them and get AI-powered insights into your application’s performance.

---

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

Edit this page on GitHub or file an issue.