LangChain and LangGraph observability

Overview

Laminar is an open-source, OpenTelemetry-native observability platform for AI agents. Trace, debug, and monitor every LangChain chain and LangGraph agent in TypeScript and Python: each graph node, tool call, retriever query, and LLM call is recorded with its inputs, outputs, token usage, and cost. Self-host via Helm or use managed cloud. Your LangChain and LangGraph code stays as it is. Laminar builds the run tree from LangChain’s own callbacks. Calls to OpenAI and Anthropic models are recorded by Laminar’s OpenAI and Anthropic integrations, so each call is one LLM span with the provider’s full request and response.

Getting started

TypeScript
Python

Install Laminar and LangChain

npm install @lmnr-ai/lmnr @langchain/core @langchain/langgraph @langchain/openai openai zod

This needs @lmnr-ai/lmnr 0.8.53 or later. Install the model provider’s SDK (openai here, @anthropic-ai/sdk if you use @langchain/anthropic) as a direct dependency, because you pass it to Laminar in step 3.

Set up your environment variables

.env

LMNR_PROJECT_API_KEY=your-laminar-project-api-key
OPENAI_API_KEY=your-openai-api-key

Load them with a package like dotenv, or node --env-file=.env.

Initialize Laminar with your LangChain modules

Laminar can’t patch an ES module that your code has already imported, so pass the LangChain modules, and the SDK of each model provider you call, to instrumentModules. Do it once, in its own file:

instrumentation.ts

import { Laminar } from '@lmnr-ai/lmnr';
import * as callbackManagerModule from '@langchain/core/callbacks/manager';
import * as chatModelsModule from '@langchain/core/language_models/chat_models';
import * as llmsModule from '@langchain/core/language_models/llms';
import * as singletonsModule from '@langchain/core/singletons';
import * as langgraphModule from '@langchain/langgraph';
import OpenAI from 'openai';

Laminar.initialize({
  instrumentModules: {
    OpenAI,
    langchain: {
      callbackManagerModule,
      chatModelsModule,
      llmsModule,
      singletonsModule,
      langgraphModule,
    },
  },
});

Then import it first in your entry point, before any LangChain code runs:

index.ts

import './instrumentation.js';

Each module turns on part of the trace. The LangChain modules go under instrumentModules.langchain, and the provider SDKs go at the top level:

Key	What you lose without it
`callbackManagerModule`	Nothing from LangChain is recorded.
`singletonsModule`	Spans created inside a chain step, tool, or graph node (`observe()`, direct SDK calls) don’t nest under it.
`chatModelsModule`, `llmsModule`	OpenAI and Anthropic calls are recorded twice, once by LangChain and once by the provider integration.
`langgraphModule`	The graph’s nodes and edges aren’t recorded, so the trace has no LangGraph view.
`OpenAI`	OpenAI calls are recorded by LangChain as a `ChatOpenAI.chat` span instead of the OpenAI integration’s span.
`anthropic`	Anthropic calls are recorded by LangChain as a `ChatAnthropic.chat` span instead of the Anthropic integration’s span. Pass it as `import * as anthropic from '@anthropic-ai/sdk'`.

Pass the same copy of the provider SDK that the LangChain package loads. @langchain/anthropic and @langchain/openai each depend on a specific version of their provider’s SDK, and if your app depends on a different major version, npm installs two copies and Laminar patches the one LangChain doesn’t use. Run npm ls openai @anthropic-ai/sdk and check that each package resolves to a single version. When the copies differ, the calls are still recorded once, as the LangChain-side span.

In a CommonJS app, calling Laminar.initialize() before LangChain is loaded instruments it without instrumentModules. Passing the modules works in both module systems, so it’s the setup we recommend.

Use LangChain and LangGraph as usual

A chain:

chain.ts

import './instrumentation.js';
import { Laminar } from '@lmnr-ai/lmnr';
import { StringOutputParser } from '@langchain/core/output_parsers';
import { ChatPromptTemplate } from '@langchain/core/prompts';
import { ChatOpenAI } from '@langchain/openai';

const prompt = ChatPromptTemplate.fromMessages([
  ['system', 'You are a helpful assistant. Answer in one sentence.'],
  ['human', '{question}'],
]);
const chain = prompt
  .pipe(new ChatOpenAI({ model: 'gpt-5.6-terra' }))
  .pipe(new StringOutputParser());

console.log(await chain.invoke({ question: 'What is the capital of France?' }));

await Laminar.shutdown();

A LangGraph agent with a tool:

agent.ts

import './instrumentation.js';
import { Laminar } from '@lmnr-ai/lmnr';
import { HumanMessage } from '@langchain/core/messages';
import { tool } from '@langchain/core/tools';
import { MemorySaver, MessagesAnnotation, START, StateGraph } from '@langchain/langgraph';
import { ToolNode, toolsCondition } from '@langchain/langgraph/prebuilt';
import { ChatOpenAI } from '@langchain/openai';
import { z } from 'zod';

const getWeather = tool(
  async ({ city }) => `It is 18C and sunny in ${city}.`,
  {
    name: 'get_weather',
    description: 'Get the current weather for a city.',
    schema: z.object({ city: z.string() }),
  },
);

const model = new ChatOpenAI({ model: 'gpt-5.6-terra' }).bindTools([getWeather]);

const agent = new StateGraph(MessagesAnnotation)
  .addNode('agent', async (state) => ({
    messages: [await model.invoke(state.messages)],
  }))
  .addNode('tools', new ToolNode([getWeather]))
  .addEdge(START, 'agent')
  .addConditionalEdges('agent', toolsCondition)
  .addEdge('tools', 'agent')
  .compile({ checkpointer: new MemorySaver() });

const result = await agent.invoke(
  { messages: [new HumanMessage('What is the weather in Paris?')] },
  { configurable: { thread_id: 'user-42' } },
);
console.log(result.messages.at(-1)?.text);

await Laminar.shutdown();

Agents built with createAgent from the langchain package run on LangGraph, so they’re traced the same way. await Laminar.shutdown() sends the last spans before a short-lived script exits; a long-running server doesn’t need it.

Install Laminar and LangChain

pip install -U lmnr langchain-openai langgraph

This needs lmnr 0.8.2 or later.

Set up your environment variables

.env

LMNR_PROJECT_API_KEY=your-laminar-project-api-key
OPENAI_API_KEY=your-openai-api-key

Load them with python-dotenv or export them in your shell.

Initialize Laminar

Call Laminar.initialize() once at startup, before any LangChain or LangGraph code runs. LangChain and LangGraph are instrumented automatically.

from lmnr import Laminar

Laminar.initialize()

Use LangChain and LangGraph as usual

A chain:

chain.py

from lmnr import Laminar
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI

Laminar.initialize()

prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant. Answer in one sentence."),
    ("human", "{question}"),
])
chain = prompt | ChatOpenAI(model="gpt-5.6-terra") | StrOutputParser()

print(chain.invoke({"question": "What is the capital of France?"}))
Laminar.flush()

A LangGraph agent with a tool:

agent.py

from lmnr import Laminar
from langchain_core.messages import HumanMessage
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
from langgraph.checkpoint.memory import MemorySaver
from langgraph.graph import START, MessagesState, StateGraph
from langgraph.prebuilt import ToolNode, tools_condition

Laminar.initialize()


@tool
def get_weather(city: str) -> str:
    """Get the current weather for a city."""
    return f"It is 18C and sunny in {city}."


model = ChatOpenAI(model="gpt-5.6-terra", use_responses_api=True).bind_tools([get_weather])


def call_model(state: MessagesState):
    return {"messages": [model.invoke(state["messages"])]}


agent = (
    StateGraph(MessagesState)
    .add_node("agent", call_model)
    .add_node("tools", ToolNode([get_weather]))
    .add_edge(START, "agent")
    .add_conditional_edges("agent", tools_condition)
    .add_edge("tools", "agent")
    .compile(checkpointer=MemorySaver())
)

result = agent.invoke(
    {"messages": [HumanMessage("What is the weather in Paris?")]},
    {"configurable": {"thread_id": "user-42"}},
)
print(result["messages"][-1].text)

Laminar.flush()

Laminar.flush() sends the last spans before a short-lived script exits; a long-running server doesn’t need it.

To see Laminar inside a FastAPI application, check out the FastAPI guide.

What Laminar records

Each invocation of a chain or graph is one trace:

Span	What it holds
The run, named after the chain or graph (`RunnableSequence`, `LangGraph`, or the `runName` you set)	The input you passed and the final output or state. For a graph, also its nodes and edges, which power the LangGraph view.
`execute_task <name>` for every chain step and graph node	The step’s input and output, nested under the run.
A tool span, named after the tool	The tool’s arguments, result, and tool call ID. Tool spans show up as tool calls in the transcript.
`vector_db_retrieve <name>`	The retriever’s query and the documents it returned.
An LLM span for every model call	The messages, the response with any tool calls, the model, token usage, and cost.

Which integration records each LLM call

OpenAI (including Azure OpenAI) and Anthropic chat models are recorded by Laminar’s provider integrations, as openai.chat, openai.response, or anthropic.chat spans. In Python, Google GenAI (langchain-google-genai 4 or later) and Groq models are handed off the same way.
Every other chat model (Gemini in TypeScript, Mistral, Amazon Bedrock, Ollama, and so on) is recorded by LangChain as an LLM span named after the model class, such as ChatGoogleGenerativeAI.chat or ChatMistralAI.chat. It carries the same messages, tool calls, model, token usage, and cost. Any provider SDK instrumentation underneath is silenced for that call, so nothing is recorded twice.

Group a LangGraph thread into a session

LangGraph’s thread_id is recorded on the graph and node spans. To see every run of a thread together in Laminar’s sessions view, wrap the call in observe with the thread ID as the session ID:

TypeScript
Python

import { observe } from '@lmnr-ai/lmnr';

const threadId = 'user-42';
const result = await observe({ name: 'weather_agent', sessionId: threadId }, () =>
  agent.invoke(
    { messages: [new HumanMessage('What is the weather in Paris?')] },
    { configurable: { thread_id: threadId } },
  ),
);

from lmnr import observe


@observe(name="weather_agent", session_id="user-42")
def run(question: str):
    return agent.invoke(
        {"messages": [HumanMessage(question)]},
        {"configurable": {"thread_id": "user-42"}},
    )

The graph’s spans nest under the weather_agent span, and the whole trace joins the session.

See what happened in a trace

Open a trace in Laminar and the default view is the transcript: the agent’s auto-extracted input, every LLM turn with a one-line preview of its response, and each tool call with its arguments and result, in the order they ran. You read the conversation instead of clicking through a tree of execute_task spans. Switch to tree view for the span-by-span structure, or open the LangGraph view to see which nodes ran. More on the trace UX: Viewing traces.

Track outcomes with Signals

Traces answer what happened on this run. Signals answer the cross-trace question: how often does the agent answer without calling the tool it needed, when does a graph loop between the same two nodes, which runs end with an apology instead of an answer. A Signal pairs a plain-language instruction with a JSON output schema. Laminar runs it live on new traces (Triggers) or backfills it across history (Jobs) and records a structured event every time it matches. From there you query, cluster, and alert on events across every trace.

Every new project ships with a Failure Detector Signal that categorizes issues on any trace over 1000 tokens. Open it from the Signals sidebar to see events as soon as your LangChain traces arrive.

Query across traces

SQL editor for ad-hoc queries across traces, spans, signals, and evals.
SQL API for programmatic access from scripts and pipelines.
CLI (lmnr-cli sql query) for terminal-driven queries and piping JSON into shell tools or coding agents.
MCP server to query Laminar from Claude Code, Cursor, or Codex.

Troubleshooting

I don't see any traces in Laminar (TypeScript)

Pass the LangChain modules to instrumentModules as shown in step 3. In an ES module app, Laminar.initialize() without them records nothing from LangChain.
Import your instrumentation file before any file that runs LangChain code.
Confirm LMNR_PROJECT_API_KEY is set in the process that runs LangChain.
Call await Laminar.shutdown() before a short-lived script exits.

Every OpenAI or Anthropic call shows up twice (TypeScript)

Add chatModelsModule and llmsModule to instrumentModules.langchain. Without them, LangChain can’t hand the call to the provider integration, so both record it. Laminar logs a warning at startup when chatModelsModule is missing.

I see ChatOpenAI.chat instead of an openai.* span (TypeScript)

The OpenAI integration didn’t record the call, so LangChain recorded it instead. Pass OpenAI from openai to instrumentModules, and check with npm ls openai that @langchain/openai uses the same copy of openai that you import. The same applies to ChatAnthropic.chat and @anthropic-ai/sdk.

Self-hosting Laminar

Point the SDK at your instance when initializing. For a local OSS deployment:

TypeScript
Python

Laminar.initialize({
  baseUrl: 'http://localhost',
  httpPort: 8000,
  grpcPort: 8001,
  instrumentModules: { /* as in step 3 */ },
});

Laminar.initialize(base_url="http://localhost", http_port=8000, grpc_port=8001)

What’s next

Viewing traces

Read the transcript view, filter, and search across traces.

Signals

Detect behaviors and failures across every run, then query, cluster, and alert on them.

SQL editor and MCP server

Query traces programmatically from the UI, API, or your IDE.

Tracing structure

Sessions, user IDs, metadata, and tags.

deepagents

Trace deepagents runs, subagents, and tool calls.

Pydantic AI

Trace Pydantic AI agent runs and typed tool calls.

LiteLLM

One integration for every model LiteLLM routes to.

OpenAI

Trace the OpenAI SDK directly in TypeScript and Python.

Langfuse

Keep Langfuse and send the same spans to Laminar too.

All integrations

Browse every provider, framework, coding agent, and browser integration Laminar supports.

Overview

LLM provider SDKs

Agent frameworks

Coding agents

Browser and computer-use agents

Eval frameworks

Other platforms

OpenTelemetry

LangChain and LangGraph observability

Overview

Getting started

What Laminar records

Which integration records each LLM call

Group a LangGraph thread into a session

See what happened in a trace

Track outcomes with Signals

Query across traces

Troubleshooting

What’s next

Viewing traces

Signals

SQL editor and MCP server

Tracing structure

deepagents

Pydantic AI

LiteLLM

OpenAI

Langfuse

All integrations

​Overview

​Getting started

​What Laminar records

​Which integration records each LLM call

​Group a LangGraph thread into a session

​See what happened in a trace

​Track outcomes with Signals

​Query across traces

​Troubleshooting

​What’s next

Viewing traces

Signals

SQL editor and MCP server

Tracing structure

​Related integrations

deepagents

Pydantic AI

LiteLLM

OpenAI

Langfuse

All integrations

Overview

Getting started

What Laminar records

Which integration records each LLM call

Group a LangGraph thread into a session

See what happened in a trace

Track outcomes with Signals

Query across traces

Troubleshooting

What’s next

Related integrations