DEV Community: Kshitij Gupta

You Don't Need LangSmith to Trace LangGraph

Kshitij Gupta — Sun, 21 Jun 2026 13:40:07 +0000

You Don't Need LangSmith to Trace LangGraph

Local-first LangGraph tracing — two lines of code, a live trace UI, zero cloud.

You built a LangGraph agent. It works… until it doesn't. A tool gets called twice,
the supervisor routes to the wrong node, the token bill creeps up, and your only
window into any of it is a wall of print() statements scrolling past in the
terminal.

The usual answer is LangSmith — and it's good. But it also means a cloud
account, an API key, and shipping every prompt, tool call, and response off your
machine to someone else's servers. For local development, that's a lot of
ceremony (and a lot of data leaving your laptop) just to see what your graph is
doing.

Here's the thing: you don't need any of that to trace LangGraph.

import tracesage

async with tracesage.session(install=True):        # ← line 1
    await graph.ainvoke({"input": "plan me a trip"})  # ← your existing call

That's it. No account, no Docker, no Postgres. A browser tab opens with a live,
interactive trace of your run:

The whole system at a glance: the LangGraph orchestrator fans out to agents, which
call tools — some from MCP servers (weather, math), some local — plus the LLM and
retriever. Everything is captured from LangChain's callback stream; nothing left
the machine.

This is tracesage — a local-first
observability tool for LangChain & LangGraph. Let me show you what it does, and why
"local-first" is the whole point.

The 60-second setup

pip install "tracesage[langchain]"

Quote the brackets — zsh (the macOS default shell) treats [...] as a glob and
will otherwise complain no matches found.

Then either flip on global capture (no callbacks= wiring needed)…

import asyncio
from tracesage import TraceSage

async def main():
    async with TraceSage.session(install=True) as tl:   # global capture + UI
        await graph.ainvoke({"input": "plan me a trip"})
        await tl.flush()
        print("trace UI:", tl.ui_url)                    # open this

asyncio.run(main())

…or pass the handler explicitly if you prefer:

await graph.ainvoke(
    {"input": "plan me a trip"},
    config={"callbacks": [tl.handler]},   # the only line you add
)

Want to see it work right now, with no API key? tracesage ships no-key demos
that use a fake chat model:

python examples/mcp/main.py        # multi-agent + MCP tools
# then open the URL it prints (default http://localhost:7842/ui)

tracesage is provider-agnostic — it traces LangChain's callback stream, so
OpenAI, Anthropic, local models, whatever you wire up are all captured the same
way. There's no provider setting.

What you actually get

1. A live topology of your system

Every node is one of a few kinds — agent, tool, llm, retriever, chain —
plus a synthesized mcp node per MCP server. You can see the architecture: who
calls what, which tools came from where, where the LLM and retriever sit. It pulses
as events stream in over a WebSocket.

The topology defaults to the currently selected run, so a tool you removed two
iterations ago doesn't haunt the graph forever (a toolbar selector switches to
last-N-runs or all-time when you want the bigger picture).

2. Run trace + a step-by-step timeline

Click any run and the graph flips to execution-flow mode — the actual path this
run took — alongside a chronological timeline of every callback event. Hit play and
it re-animates the run step by step:

Left: the path this run took through the graph. Right: every step in order — chain
starts, the LLM call, each tool invocation — with timestamps and durations. Replay
at 1×/2×/5×.

3. Full request and response payloads

This is the part that replaces your print() debugging. Click a step and you get
its complete input and output — the exact prompt that went in, the exact result
that came back, plus metadata, duration, and any error with a full traceback:

The request payload and response payload, paired together for a single step — no
more guessing what your chain actually received.

4. Tap into any node for its stats

Click any node in the graph — an agent, a tool, an MCP server — and a drawer opens
with everything tracesage knows about it: invocation count, error count, average
and p95 duration, the tools it provides or uses, and who calls it.

Click the weather MCP server node → it lists its invocations, error rate,
durations, **all four tools it provides, and which agents use it. Click an agent
instead and you get its in-code tools, the MCP servers it depends on, and what
called it.

For real LLM calls (OpenAI, Anthropic, …), each LLM step also shows token usage —
↑input ↓output — and every run rolls those up into totals you can compare across
runs with tracesage diff. (The no-key demos use a fake model that reports none, so
they show no token badges.)

5. MCP tool-source attribution

If your agent loads tools from MCP servers,
tracesage attributes each tool call back to the server it came from — so you can
tell "these 4 tools are from the weather server, these 2 are hardcoded" at a
glance. As far as I know, no other LangChain tracer does this; it shows up as mcp:
nodes in the graph and a dedicated "Tools by source" panel.

6. It works for RAG too

retriever is a first-class node kind, so RAG pipelines render cleanly — prompt
template → retriever → LLM → output:

A retrieval pipeline: the retriever node (pink) is its own dimension, so "did we
fetch the right docs?" stays a separate question from "did the LLM use them well?".

Debug from the terminal, too

Not everything needs a browser. The CLI reads the same local data:

tracesage show <run_id>          # render a run as a tree in your terminal
tracesage watch <run_id>         # live-tail events as they stream
tracesage diff <run_a> <run_b>   # compare two runs: tokens, tools, errors
tracesage runs --status failed   # find the runs that broke

And there's a pytest fixture for asserting on agent behavior in CI:

def test_agent_uses_search(tracesage_capture):
    agent.invoke("find me a hotel")
    tracesage_capture.assert_tool_called("search")
    tracesage_capture.assert_no_errors()

So… when should you use LangSmith?

This isn't "tracesage beats LangSmith." They solve different problems.

	tracesage	LangSmith
Setup	`pip install`, two lines	Cloud account + API key
Where your data lives	Your machine (SQLite + local files)	LangChain's cloud
Works offline	✓	✗
Live trace UI	✓	✓
MCP tool attribution	✓	✗
Eval / datasets / prompt versioning	✗ (non-goal)	✓
Team dashboards / cost reporting	✗	✓
License	MIT	Proprietary

Reach for LangSmith / LangFuse / Phoenix when you need evaluation pipelines,
datasets, prompt versioning, team collaboration, or hosted long-term retention.

Reach for tracesage when you're at your desk debugging a graph and want to see
what it's doing now, without signing up for anything or sending your prompts to
the cloud.

And you don't have to choose forever. tracesage can export every trace as
OpenTelemetry spans to your collector / Tempo / Jaeger / Datadog / Honeycomb — so
the local dev loop and your production stack share the same data:

pip install "tracesage[otel]"
export TRACESAGE_OTLP_ENDPOINT=http://localhost:4318

Try it

pip install "tracesage[langchain]"
python examples/getting_started/01_smart_search_agent.py   # no API key needed

Then open the URL it prints and click around. Two lines into your own graph and
you'll never go back to reading raw callback logs.

GitHub: https://github.com/kjgpta/tracesage
Docs: https://kjgpta.github.io/tracesage/
PyPI: pip install "tracesage[langchain]"

tracesage is open source (MIT). If it saves you an afternoon of print()
debugging, a ⭐ on GitHub is appreciated.

tracesage: See Inside Your LangGraph Agents

Kshitij Gupta — Tue, 16 Jun 2026 14:08:03 +0000

See Inside Your LangGraph Agents

Open-source LangChain/LangGraph tracing — drop in two lines, watch your agents run live in your browser.

The problem: agents are black boxes

If you've built anything non-trivial with LangChain or LangGraph — a multi-agent supervisor, a RAG pipeline, a tool-using ReAct loop — you know the feeling. It works on the happy path, then a real query comes in and… something goes wrong. But what?

Which agent actually ran? In what order?
Did the model call the tool you expected, or hallucinate a different one?
How many tokens did that one request burn?
Where did the error come from — your tool, the model, or the orchestration?

The usual answer is a wall of print() statements and verbose=True logs you scroll through at 2 a.m. There are great hosted tracing platforms, but they mean signing up, shipping your prompts to a third party, and wiring up an SDK.

I wanted something I could pip install and have running in ten seconds, entirely on my laptop. So I built tracesage.

What is tracesage?

tracesage is a local-first observability tool for LangChain & LangGraph agents. It hooks into LangChain's callback stream, captures every chain / tool / LLM / retriever event, stores it locally (SQLite + gzipped blobs), and renders it as an interactive graph + timeline UI in your browser — in real time.

🚀 Two-line integration. One callback added to your existing invoke/ainvoke.
🧰 Zero infrastructure. No Docker, no Postgres, no external service. Just pip install.
🔒 Never crashes your app. The callback handler is wrapped to never raise — tracing can fail, your agent keeps running.
🗺️ MCP-aware. Tools loaded from MCP servers are attributed back to their server, so you can see which tools came from where.
🧪 Testable. A pytest fixture lets you assert "did my agent call search?" in CI.
📦 MIT licensed, runs in a single Python process.

Links:

PyPI: https://pypi.org/project/tracesage/
Docs: https://kjgpta.github.io/tracesage/
Examples gallery (30 before/after apps): in the repo under examples/showcase/

A 30-second taste

Before we write any code, see what we're aiming for:

pip install "tracesage[langchain]"
tracesage demo            # seeds a sample trace and opens the UI

Your browser opens to http://localhost:7842/ui and you're looking at a live agent topology.

Tutorial: trace a real agent

Let's build a tiny but real LangGraph agent and wire tracesage into it. You'll need Python 3.11+ and an LLM provider key (we'll use OpenAI; Anthropic or any LangChain model works identically — tracesage is provider-agnostic).

pip install "tracesage[langchain]" langgraph langchain-openai
export OPENAI_API_KEY=sk-...

Step 1 — the agent (no tracing yet)

before.py — a standard LangGraph ReAct agent with two tools:

import asyncio
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
from langgraph.prebuilt import create_react_agent


@tool
def get_weather(city: str) -> str:
    """Return the current weather for a city."""
    return f"It's 22°C and sunny in {city}."


@tool
def to_fahrenheit(celsius: float) -> float:
    """Convert a temperature in Celsius to Fahrenheit."""
    return celsius * 9 / 5 + 32


agent = create_react_agent(
    ChatOpenAI(model="gpt-4o-mini", temperature=0),
    tools=[get_weather, to_fahrenheit],
)


async def main() -> None:
    result = await agent.ainvoke(
        {"messages": [{"role": "user",
                       "content": "What's the weather in Paris, in Fahrenheit?"}]}
    )
    print(result["messages"][-1].content)


asyncio.run(main())

Run it and you get an answer. But you have no idea how it got there — did it call get_weather then to_fahrenheit? Did it loop? How many model calls?

Step 2 — add tracesage (the two lines)

after.py — the only difference is creating a tracer and passing its handler:

import asyncio
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
from langgraph.prebuilt import create_react_agent

from tracesage import TraceSage          # 1️⃣ import


@tool
def get_weather(city: str) -> str:
    """Return the current weather for a city."""
    return f"It's 22°C and sunny in {city}."


@tool
def to_fahrenheit(celsius: float) -> float:
    """Convert a temperature in Celsius to Fahrenheit."""
    return celsius * 9 / 5 + 32


agent = create_react_agent(
    ChatOpenAI(model="gpt-4o-mini", temperature=0),
    tools=[get_weather, to_fahrenheit],
)


async def main() -> None:
    tracer = await TraceSage.create()    # 2️⃣ start tracesage (UI on :7842)

    result = await agent.ainvoke(
        {"messages": [{"role": "user",
                       "content": "What's the weather in Paris, in Fahrenheit?"}]},
        config={"callbacks": [tracer.handler]},   # 3️⃣ the one line you add
    )
    print(result["messages"][-1].content)

    # Keep the process alive so you can explore the UI.
    input("Trace ready at http://localhost:7842/ui — press Enter to exit.")
    await tracer.stop()


asyncio.run(main())

That's it. Run python after.py, open http://localhost:7842/ui, and your run is there.

Even less code: the `with` block

For scripts and notebooks, there's a context manager that starts the UI and installs a global handler — so you don't even pass callbacks=:

import tracesage

with tracesage.trace() as tl:                 # starts UI + global capture
    result = agent.invoke({"messages": [...]})    # 🔍 tracesage: http://127.0.0.1:7842/ui/#run=...
    input("Trace ready — open the printed link, then Enter to exit.")

Every new run prints a clickable deep link to that exact trace.

Reading the UI

Here's where tracesage earns its keep. Open a run and you get a topology graph of everything that happened.

Every node is one of six kinds, colour-coded in the legend (bottom-left):

Kind	What it is
`agent`	a function you registered as a node, that calls other things
`tool`	a `@tool` side-effect function (DB, API, calculation)
`llm`	a language-model call (what you count, cost, and cache)
`retriever`	a `BaseRetriever` — the "R" in RAG
`chain`	plumbing: LCEL pipes, the LangGraph state machine, routing functions
`mcp`	a synthesized node grouping the tools loaded from one MCP server

Click any node to open its inspector — call counts, durations, errors, and the tools it provides or uses:

The timeline on the right replays the run step-by-step; click a step to expand the full payload (prompts, tool inputs/outputs, token usage, and — on errors — the exception type and traceback).

The killer feature: MCP tool-source attribution

If your agent loads tools from MCP servers (via langchain-mcp-adapters), you usually lose track of where each tool came from — they all look like generic LangChain tools at runtime. tracesage fixes that.

Install the extra and register your MCP client:

pip install "tracesage[mcp]"

from langchain_mcp_adapters.client import MultiServerMCPClient
from tracesage import TraceSage
from tracesage.adapters.mcp import register_mcp_client

tracer = await TraceSage.create()

client = MultiServerMCPClient({
    "weather": {"command": "python", "args": ["weather_server.py"], "transport": "stdio"},
    "math":    {"command": "python", "args": ["math_server.py"],    "transport": "stdio"},
})

# Loads every server's tools AND records tool → server provenance.
tools = await register_mcp_client(tracer, client)
# Your own @tool functions stay "local" (unattributed) automatically.

Now the UI shows a "Tools by source" panel and dedicated mcp: nodes — every tool is grouped by where it came from:

Click an MCP server node and you see exactly what it provides, how often it was called, and which agents used it:

A complete, runnable MCP example (two local stdio servers + hardcoded tools, no API key needed) lives in the repo at examples/mcp/:

pip install "tracesage[mcp]"
python examples/mcp/main.py     # then open http://localhost:7842/ui

Testing your agents in CI

Tracing isn't just for eyeballing. tracesage ships a pytest fixture (tracesage_capture, auto-registered) so you can assert behaviour:

def test_agent_uses_search(tracesage_capture):
    agent.invoke("find me a hotel in Paris")
    tracesage_capture.assert_tool_called("get_weather")
    tracesage_capture.assert_no_errors()
    assert tracesage_capture.total_tokens()[0] < 5000   # input-token budget

No setup, no server — the fixture captures the run in-process and gives you assertions like assert_tool_called, assert_no_errors, and total_tokens.

Shipping to production (and turning it off)

tracesage is built so you can wire it in once and control it per-environment:

Kill switch: set TRACESAGE_ENABLED=false (or enabled=False) and TraceSage returns an inert tracer — no server, no DB, a no-op handler, near-zero overhead. Same code ships to prod; tracing just turns off.
Capture without the UI: TRACESAGE_START_SERVER=false records traces to disk in prod without binding the in-process UI; view them later with tracesage serve.
Safety rails: bearer-token auth, root-level sampling (sample_rate), a per-run event cap, and a hard fail-stop if you bind a non-loopback address without an auth token.

# In prod: capture is off, zero overhead, no code change.
#   TRACESAGE_ENABLED=false
# Or capture quietly, no UI:
#   TRACESAGE_START_SERVER=false   → then `tracesage serve` to look later

Try it yourself

pip install "tracesage[langchain]"
tracesage demo

PyPI: https://pypi.org/project/tracesage/
Docs & full quickstart: https://kjgpta.github.io/tracesage/
Concepts (what each node kind means): https://kjgpta.github.io/tracesage/concepts/
MCP attribution guide: https://kjgpta.github.io/tracesage/mcp/
30 before/after example apps: examples/showcase/ in the repo

If you build agents with LangChain or LangGraph and you're tired of print-debugging your way through a run, give it a spin. Two lines, one browser tab, and your agent stops being a black box.

tracesage is MIT-licensed and open source.

DEV Community: Kshitij Gupta

You Don't Need LangSmith to Trace LangGraph

You Don't Need LangSmith to Trace LangGraph

The 60-second setup

What you actually get

1. A live topology of your system

2. Run trace + a step-by-step timeline

3. Full request and response payloads

4. Tap into any node for its stats

5. MCP tool-source attribution

6. It works for RAG too

Debug from the terminal, too

So… when should you use LangSmith?

Try it

tracesage: See Inside Your LangGraph Agents

See Inside Your LangGraph Agents

The problem: agents are black boxes

What is tracesage?

A 30-second taste

Tutorial: trace a real agent

Step 1 — the agent (no tracing yet)

Step 2 — add tracesage (the two lines)

Even less code: the with block

Reading the UI

The killer feature: MCP tool-source attribution

Testing your agents in CI

Shipping to production (and turning it off)

Try it yourself

Even less code: the `with` block