LangGraph (tracing) | Respan Docs

LangGraph is a framework for building stateful, multi-step agent workflows as graphs. Nodes represent operations such as LLM calls, tools, and routing decisions, while edges define the flow between them. Respan gives you full observability over every graph run, node, tool call, and LLM generation — and gateway routing through the OpenAI-compatible Respan endpoint.

Set up Respan

Create an account at platform.respan.ai and grab an API key.

Run npx @respan/cli setup to set up with your coding agent.

Use Respan Gateway

See LangGraph gateway setup to route this integration through the Respan gateway.

Example projects

Example projects

Setup

Install packages

$ pip install respan-tracing respan-instrumentation-langchain langgraph langchain-openai python-dotenv

Set environment variables

$ export RESPAN_API_KEY="YOUR_RESPAN_API_KEY"
$ export RESPAN_BASE_URL="https://api.respan.ai/api"

RESPAN_API_KEY is used to export traces to Respan. Set OPENAI_API_KEY too when graph nodes call provider-backed models.

Initialize and run

Use respan-instrumentation-langchain for LangGraph because LangGraph runs through LangChain callback managers.

1 import os
2 from contextlib import suppress
3 from typing import TypedDict
4 
5 from langgraph.graph import StateGraph, START, END
6 from respan_instrumentation_langchain import add_respan_callback
7 from respan_tracing import RespanTelemetry
8 
9 telemetry = RespanTelemetry(
10     app_name="langgraph-quickstart",
11     api_key=os.environ["RESPAN_API_KEY"],
12     base_url=os.getenv("RESPAN_BASE_URL", "https://api.respan.ai/api"),
13     is_auto_instrument=False,
14     is_batching_enabled=False,
15 )
16 
17 class State(TypedDict):
18     topic: str
19     joke: str
20 
21 def generate_joke(state: State) -> dict:
22     return {"joke": f"A short joke about {state['topic']}"}
23 
24 graph = StateGraph(State)
25 graph.add_node("generate", generate_joke)
26 graph.add_edge(START, "generate")
27 graph.add_edge("generate", END)
28 
29 app = graph.compile()
30 try:
31     result = app.invoke(
32         {"topic": "AI tracing"},
33         config=add_respan_callback(
34             {
35                 "run_name": "joke_graph",
36                 "tags": ["langgraph", "quickstart"],
37                 "metadata": {"framework": "langgraph"},
38             }
39         ),
40     )
41     print(result)
42 finally:
43     with suppress(Exception):
44         telemetry.flush()

View your trace

Open the Traces page to see the graph execution with node spans, LLM calls, and state transitions.

Configuration

Parameter	Type	Default	Description
`api_key`	`str \| None`	`None`	Falls back to `RESPAN_API_KEY` env var.
`base_url`	`str \| None`	`None`	Falls back to `RESPAN_BASE_URL` env var.
`instrumentations`	`list`	`[]`	Plugin instrumentations to activate, e.g. `LangChainInstrumentor()`.
`include_content`	`bool`	`True`	Includes graph inputs, node inputs, and outputs on spans.
`include_metadata`	`bool`	`True`	Includes LangGraph tags, metadata, and serialized runnable details.
`customer_identifier`	`str \| None`	`None`	Default customer identifier for all spans.
`metadata`	`dict \| None`	`None`	Default metadata attached to all spans.
`environment`	`str \| None`	`None`	Environment tag, e.g. `"production"`.

Attributes

In Respan()

Set defaults at initialization — these apply to all spans.

1 from respan import Respan
2 from respan_instrumentation_langchain import LangChainInstrumentor
3 
4 respan = Respan(
5     instrumentations=[LangChainInstrumentor()],
6     customer_identifier="user_123",
7     metadata={"service": "graph-api", "version": "1.0.0"},
8 )

With propagate_attributes

Override per-request using a context scope.

1 from respan import propagate_attributes
2 from respan_instrumentation_langchain import add_respan_callback
3 
4 def handle_request(user_id: str, topic: str):
5     with propagate_attributes(
6         customer_identifier=user_id,
7         thread_identifier="conv_abc_123",
8         metadata={"plan": "pro"},
9     ):
10         result = app.invoke(
11             {"topic": topic},
12             config=add_respan_callback({"run_name": "user_graph"}),
13         )
14         print(result)

Attribute	Type	Description
`customer_identifier`	`str`	Identifies the end user in Respan analytics.
`thread_identifier`	`str`	Groups related messages into a conversation.
`metadata`	`dict`	Custom key-value pairs. Merged with default metadata.

Decorators (optional)

Decorators are not required. Attach the Respan callback config to the graph invocation to trace graph and node runs. Use @workflow and @task (Python) or withWorkflow and withTask (TypeScript) to group graph runs inside larger application workflows.

1 from respan import workflow, task
2 from respan_instrumentation_langchain import add_respan_callback
3 
4 @task(name="run_joke_graph")
5 def run_joke_graph(topic: str):
6     return app.invoke(
7         {"topic": topic},
8         config=add_respan_callback({"run_name": "decorated_graph"}),
9     )
10 
11 @workflow(name="joke_pipeline")
12 def pipeline(topic: str):
13     print(run_joke_graph(topic))
14 
15 pipeline("AI tracing")
16 respan.flush()

Examples

Streaming updates

Stream graph node updates while keeping the same trace.

1 for update in app.stream(
2     {"topic": "AI tracing"},
3     config=add_respan_callback({"run_name": "streaming_graph"}),
4     stream_mode="updates",
5 ):
6     print(update)

Tool nodes

Tool calls inside graph nodes are captured as tool spans.

1 from langchain_core.tools import tool
2 from langgraph.prebuilt import ToolNode
3 
4 @tool
5 def search_docs(query: str) -> str:
6     """Search docs."""
7     return f"Results for {query}"
8 
9 tools = ToolNode([search_docs])