LangGraph

LangGraph uses LangChain’s callback system, so Lemma’s LangGraph integration is an explicit LangChain callback adapter with LangGraph defaults (default trace name langgraph-agent). It creates one owned Lemma trace per graph invocation, records graph nodes as nested child spans, model calls as generations, tools as tool calls, extracts current-turn input from graph message state, and preserves parent run IDs with orphan-safe fallback. You do not need to wrap graph calls in lemma.trace(). Pass the callback handler through the graph invoke config. A complete docs-chat agent using this integration lives in examples/langgraph (TypeScript) and examples/python/langgraph (Python). See Runnable examples.

TypeScript

Install LangGraph and the Lemma SDK:

npm install @uselemma/tracing @langchain/langgraph

Pass langGraph() in the graph invoke config:

import { StateGraph, START, END } from "@langchain/langgraph";
import { langGraph } from "@uselemma/tracing";

type GraphState = {
  input: string;
  output?: string;
};

const graph = new StateGraph<GraphState>()
  .addNode("answer", async (state) => ({
    output: `You said: ${state.input}`,
  }))
  .addEdge(START, "answer")
  .addEdge("answer", END)
  .compile();

export async function callGraph(userMessage: string) {
  const lemmaHandler = langGraph({
    apiKey: process.env.LEMMA_API_KEY,
    projectId: process.env.LEMMA_PROJECT_ID,
    release: process.env.LEMMA_RELEASE,
    agentName: "support-graph",
  });
  const result = await graph.invoke(
    { input: userMessage },
    {
      callbacks: [lemmaHandler],
    },
  );
  await lemmaHandler.flush();

  return result.output;
}

Python

Install the optional extra:

pip install "uselemma-tracing[langgraph]" langgraph

Pass langgraph() in the graph invoke config:

import os
from typing_extensions import TypedDict
from langgraph.graph import END, START, StateGraph
from uselemma_tracing import langgraph


class GraphState(TypedDict):
    input: str
    output: str


def answer(state: GraphState):
    return {"output": f"You said: {state['input']}"}


graph = (
    StateGraph(GraphState)
    .add_node("answer", answer)
    .add_edge(START, "answer")
    .add_edge("answer", END)
    .compile()
)


def call_graph(user_message: str):
    result = graph.invoke(
        {"input": user_message},
        {
            "callbacks": [
                langgraph(
                    api_key=os.environ["LEMMA_API_KEY"],
                    project_id=os.environ["LEMMA_PROJECT_ID"],
                    agent_name="support-graph",
                )
            ]
        },
    )
    return result["output"]

What Lemma records

LangGraph callback	Lemma record
Root graph run	One owned Lemma trace (default name `langgraph-agent`) with current-turn input from state, final output or root error, `thread_id` / `user_id`, wall times
Graph node	Child span with node input, output, timing, and parent ID
LLM or chat model	Generation with normalized messages, structured assistant output, derived provider/model, timing, parent ID
Tool call	Tool span with input, output or soft/hard error, timing, and parent ID
Retriever	Span with query input, output, timing, and parent ID

langGraph() / langgraph() is an explicit LangChain-callback adapter. LangGraph emits LangChain callback events; Lemma does not use a separate LangGraph tracer. Prompts, tool inputs, outputs, model output text, and error messages are always recorded. Redact secrets and sensitive user data before they reach the graph.

Debug this integration

Enable debug mode while developing to confirm that spans arrive live and parent IDs are attached:

import { enableDebugMode } from "@uselemma/tracing";

enableDebugMode();

from uselemma_tracing import enable_debug_mode

enable_debug_mode()

Tracing

Integrations

Troubleshooting

Reference

TypeScript

Python

What Lemma records

Debug this integration

​TypeScript

​Python

​What Lemma records

​Debug this integration

TypeScript

Python

What Lemma records

Debug this integration