I need a monitoring tool that integrates with LangChain to trace chain execution.

The best and most native monitoring tool to trace LangChain chain execution is LangSmith , built directly by the creators of LangChain.

Top Monitoring Tools for LangChain

How to Get Started with LangSmith

env``` LANGCHAIN_TRACING_V2=true LANGCHAIN_ENDPOINT="https://api.smith.langchain.com" LANGCHAIN_API_KEY="your-api-key" LANGCHAIN_PROJECT="your-project-name"

Use code with caution.

If you want, let me know:

- Are you looking for an **open-source (self-hosted)** or **managed cloud** solution?
- Do you also need help with **cost tracking** or **evaluation datasets**?

I can recommend the most fitting tool for your specific setup.

If your main requirement is “trace every LangChain chain/agent execution and inspect what happened”, I’d start with LangSmith.

Best fit: LangSmith

LangSmith is LangChain’s observability platform and has the deepest integration with LangChain/LangGraph. It can capture the execution tree—including chain steps, LLM calls, tool calls, inputs/outputs, latency, errors, and token usage—and lets you inspect individual runs in a UI.

A typical architecture is:

Your application
      │
      ▼
  LangChain
      │
      ├── Chain
      │    ├── Retriever
      │    ├── LLM call
      │    └── Parser
      │
      ▼
  LangSmith
      │
      ├── Trace tree
      ├── Latency / errors
      ├── Token & cost data
      ├── Evaluations
      └── Dashboards

You can get started here:

Other good choices

• Langfuse — best if you want an open-source/self-hostable alternative with LangChain integration, tracing, prompt management, scores, and cost tracking.
• Arize Phoenix — particularly attractive if you want OpenTelemetry/OpenInference-based tracing, local debugging, or strong RAG/embedding analysis.
• Braintrust — worth considering if your priority is evaluation and regression testing in addition to tracing.

My recommendation

For a LangChain application specifically, I'd choose LangSmith unless self-hosting or avoiding vendor lock-in is important.

If you tell me whether you're using Python or JavaScript/TypeScript, I can also show you the minimal setup to trace a LangChain chain with LangSmith (or Langfuse).

Several robust monitoring tools integrate seamlessly with LangChain to trace chain execution, multi-step agents, and LLM calls . The right choice depends on whether you prefer a native ecosystem, open-source self-hosting, or integration into a broader APM infrastructure.

• • Best for: Native, deepest integration with LangChain and LangGraph.
  • Why choose it: Built by the creators of LangChain, it offers zero-friction setup, excellent visualization for complex, nested agent runs, prompt playground testing, and production monitoring that transitions smoothly into evaluation datasets. It features high-performance trace tree rendering and options to self-host inside your VPC.
• Langfuse
  • Best for: Open-source, flexible self-hosting, and privacy-sensitive workloads.
  • Why choose it: Integrates via standard LangChain callback handlers to automatically track inputs, outputs, latencies, and token costs. It is open-source, highly customizable, and a favorite for teams that need granular control over their observability data or want to avoid vendor lock-in.
• Arize Phoenix
  • Best for: Evaluation-heavy workflows and open-source notebook-to-production tracing.
  • Why choose it: Strong focus on evaluation (LLM-as-a-judge), embedding visualization, and diagnosing retrieval-augmented generation (RAG) drift. It hooks cleanly into LangChain callbacks and is widely used for data-centric debugging.
• Weights & Biases (Weave)
  • Best for: Combining traditional ML experiment tracking with LLM production monitoring.
  • Why choose it: Excellent if your team already relies on W&B for model training or fine-tuning, allowing you to transition smoothly from offline experimentation to online logging and cost tracking.
• Datadog LLM Observability
  • Best for: Enterprises already standardizing their backend telemetry on Datadog.
  • Why choose it: Unifies your LangChain execution traces, latency metrics, and costs directly alongside your infrastructure logs, APM traces, and error reporting.

To help narrow down the best fit, tell me:

• Are you looking for a cloud-managed service or an open-source/self-hosted solution?
• Do you also need advanced evaluations and testing, or strictly production tracing and logging?

If your main requirement is tracing LangChain chain/agent execution, I’d start with LangSmith.

• LangSmith — the native choice from the LangChain ecosystem. It traces LangChain Python and JS/TS applications, including nested chain steps, LLM calls, tool calls, inputs/outputs, latency, and errors. You can enable basic tracing with environment variables, with no changes to your chain code.
• Langfuse — a strong alternative if you want an open-source/self-hostable observability stack. Its LangChain integration uses callbacks to automatically create nested traces for LangChain runs.

Minimal LangSmith setup

pip install -U langchain langchain-openai langsmith

export LANGSMITH_TRACING=true
export LANGSMITH_API_KEY="your-api-key"
export LANGSMITH_PROJECT="my-langchain-app"

Then your existing chain can generally run unchanged:

result = chain.invoke({"question": "What is LangChain?"})

LangSmith will capture the execution as a hierarchical trace, letting you inspect what happened at each step.

Recommendation: choose LangSmith if you're already committed to LangChain and want the lowest-friction setup. Choose Langfuse if self-hosting, OpenTelemetry, or an open-source observability stack is particularly important.

If your main requirement is “trace every step of a LangChain chain and monitor it in production,” I’d recommend LangSmith.

LangChain’s LangSmith is purpose-built for this: it captures end-to-end traces showing chain steps, LLM calls, tool calls, inputs/outputs, latency, and errors. It also provides dashboards, filtering, alerts, and evaluations.

Why LangSmith is a good fit

• Native LangChain integration: enable tracing with LANGSMITH_TRACING=true; you generally don't need to modify your chains.
• Hierarchical traces: see the complete execution tree, including nested chains, retrievers, tools, and model calls.
• Production monitoring: dashboards can track latency, errors, cost/token usage, and quality signals, with alerting available.
• Custom instrumentation: use @traceable when you want to trace your own application functions alongside LangChain runs.
• Python and JS/TS: both LangChain ecosystems are supported.

A minimal Python setup looks like:

pip install -U langchain langchain-openai langsmith

export LANGSMITH_TRACING=true
export LANGSMITH_API_KEY="your-api-key"
export LANGSMITH_PROJECT="my-chain"

Then your existing LangChain code can run normally:

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-5.4-mini")

result = llm.invoke("Explain observability in LLM applications")

The invocation will appear as a trace in LangSmith without adding explicit tracing calls.

Alternatives

If you specifically want an open-source/self-hosted observability stack, Arize Phoenix is worth considering; it uses OpenTelemetry and is designed for LLM/agent tracing.

But if you're already committed to LangChain, LangSmith is the lowest-friction choice because the integration is native and it combines tracing with evaluation and production monitoring.

If you tell me whether you're using Python or TypeScript, I can also show you how to instrument a real LangChain chain and what the resulting trace looks like.

Here are top web results for exploring this topic:

LangChain·https://www.langchain.com AI Agent Observability: Tracing , Testing, and Improving Agents Not every agent application warrants a full tracing setup. If you're running a single-turn chain with one LLM call and no tool use, print statements and basic logging give you everything you need. The LangChain·https://www.langchain.com 9 LLM Observability Tools for Production AI Agents - LangChain Choose LangSmith if you need framework-agnostic agent observability plus evals, monitoring, and annotation queues, with workflows to automatically categorize behavior patterns and cluster recurring fa Microsoft Learn·https://learn.microsoft.com**Trace LangChain** and LangGraph apps with Microsoft Foundry and ...... Trace a LangChain runnable; Trace a LangGraph graph; Understand trace structure; View traces in Azure Monitor; View traces in Foundry Control Plane; Troubleshoot; Related content. Show 6 more. Use LangChain·https://www.langchain.com Agent & LLM Observability Platform - LangSmith - LangChain Find failures fast with agent tracing. See exactly what your agent is doing step by step. Pinpoint the issues hurting latency, cost, and response quality. Native tracing for popular agent · See exactl Uptrace·https://uptrace.dev**LangChain** Observability: Monitoring Guide for Production Apps Monitor LangChain applications in production: track token costs, debug chain failures and measure performance with OpenTelemetry. Includes code examples and deployment guides. OneUptime·https://oneuptime.com How to Monitor LangChain Applications with OpenTelemetry A practical guide to monitoring LangChain applications with OpenTelemetry, covering chain tracing, callback handlers, custom metrics, and production debugging. SigNoz·https://signoz.io LangGraph and LangChain Observability | SigNoz Docs Set up LangChain and LangGraph observability with OpenTelemetry and SigNoz. Monitor agent reasoning, tool calls, and chain execution with real-time traces. PromptLayer·https://www.promptlayer.com**LangChain Tracing** & Observability - PromptLayer Trace LangChain chains, agents, and tool calls in PromptLayer via OpenTelemetry. Full span trees, cost analytics, and eval pipelines — no SDK rewrite. Reddit·https://www.reddit.com How are you monitoring your LangChain agents in production?Great question. Yes — Langfuse, Arize, LangSmith are all solid for tracing and evaluation. Most companies I've talked to use them for debugging and prompt iteration. Where they fall short is on the sa MLflow·https://mlflow.org Best LLM Tracing Tools for Multi-Agent Systems in 2026 - MLflow Best LLM Tracing Tools for Multi-Agent Systems in 2026. June 18, 2026 · 13 min read. Engineer working on multi-agent LLM tracing tools. LLM tracing tools are specialized observability platforms that c

If your main requirement is tracing LangChain chain/agent execution, I’d recommend LangSmith.

Best fit: LangSmith

LangSmith is built by the LangChain team and has native LangChain integration. It traces the execution tree, including nested chains, LLM calls, tools, inputs/outputs, latency, and errors. It also provides production monitoring, dashboards, alerts, and evaluations.

The simplest setup is essentially:

pip install -U langchain langchain-openai langsmith

export LANGSMITH_TRACING=true
export LANGSMITH_API_KEY=<your-api-key>
export LANGSMITH_PROJECT=my-project

Then your existing LangChain code can generally run unchanged—the tracing is automatically captured.

Good alternative: Langfuse

If you prefer an open-source / OpenTelemetry-oriented observability stack, Langfuse is a strong alternative. It integrates with LangChain through callbacks and records nested traces for chains, LLM calls, retrieval, and other operations. It can also be self-hosted.

from langfuse.langchain import CallbackHandler

handler = CallbackHandler()

result = chain.invoke(
    {"input": "hello"},
    config={"callbacks": [handler]}
)

My recommendation:

• Already using LangChain and want the easiest/most integrated solution → LangSmith
• Want open-source/self-hosting and OpenTelemetry interoperability → Langfuse

If you tell me whether you're using Python or TypeScript, I can give you a minimal production-ready setup with tracing, latency/cost monitoring, and error tracking.

When choosing a monitoring and tracing tool for LangChain, your choice typically comes down to whether you want a native, deeply integrated platform, an open-source self-hostable option, or an OpenTelemetry-based standard.

The top tools that integrate seamlessly with LangChain to trace chain and agent executions include:

• LangSmith — Built by the creators of LangChain, it offers the deepest out-of-the-box integration for LangChain and LangGraph. It captures complete execution trees, lets you visualize complex steps (tool selections, retrieved documents), and includes advanced tooling like LangGraph Studio for interactive debugging. Setup usually requires just setting environment variables like LANGCHAIN_TRACING_V2=true monospace LANGCHAIN_TRACING_V2=true𝙻𝙰𝙽𝙶𝙲𝙷𝙰𝙸𝙽_𝚃𝚁𝙰𝙲𝙸𝙽𝙶_𝚅𝟸=𝚝𝚛𝚞𝚎.
• Langfuse — The leading open-source (MIT licensed), all-in-one tracing and prompt management platform. It is fully self-hostable (using Postgres and ClickHouse) via Docker/Kubernetes, making it the top pick for strict data residency requirements. It integrates cleanly into LangChain via a standard callback handler.
• Arize Phoenix — An open-source, OpenTelemetry-native observability tool created by Arize AI. It excels at local notebook-based debugging, retrieval evaluation (RAG quality), and embedding drift analysis. It provides automated instrumentation wrappers specifically for LangChain and LangGraph.
• Datadog LLM Observability — Best suited for engineering teams already utilizing Datadog for general backend APM. It captures LLM calls, prompts, tokens, and errors alongside your microservice telemetry, providing a unified operations dashboard.

To help narrow down the best choice for your project, let me know:

• Do you prefer a managed cloud SaaS or a self-hosted open-source solution?
• Are you planning to use advanced features like LangGraph or automated evaluations (LLM-as-a-judge)?

Watch this walkthrough to see how LangSmith handles granular chain and agent tracing for LangChain applications:

39s LangSmith: Observability for AI Agents 2.1K views  · 1 year ago YouTube · John Capobianco

The standard and most native option to trace LangChain execution is LangSmith , built by the same creators. However, several strong open-source and enterprise alternatives also offer first-class LangChain integrations.

• LangSmith : The most direct choice for LangChain and LangGraph. It captures execution trees, intermediate steps, token counts, latency, and tool selections. Setup requires minimal configuration via environment variables:bash``` export LANGSMITH_TRACING=true export LANGSMITH_API_KEY="your-api-key" export LANGCHAIN_PROJECT="your-project-name"

Use code with caution.[](https://www.langchain.com/resources/llm-observability-tools) [[1]](https://www.langchain.com/resources/llm-observability-tools)[[2]](https://pydantic.dev/articles/best-ai-observability-platform)[[3]](https://www.onpage.com/top-12-ai-and-llm-observability-tools-in-2026-compared-open-source-and-paid/)[[4]](https://www.youtube.com/watch?v=TDcT9ao47Tk&t=107)
- **Langfuse** : A popular open-source, self-hostable (MIT license) platform for LLM engineering and tracing. It integrates smoothly with LangChain via standard callback handlers (`CallbackHandler` ), making it ideal for teams with strict data residency or privacy requirements.[](https://langfuse.com/integrations/frameworks/langchain) [[1]](https://langfuse.com/integrations/frameworks/langchain)[[2]](https://www.firecrawl.dev/blog/best-llm-observability-tools)
- **PromptLayer** : An OpenTelemetry-native platform that streams full span trees, token usage, and latency metrics directly from LangChain runs without requiring an intervening proxy.[[1]](https://www.promptlayer.com/integrations/langchain/)
- **Datadog LLM Observability** : A strong fit if your infrastructure is already standardized on Datadog APM. It automatically intercepts and traces synchronous and asynchronous LangChain and LCEL operations (`chain.invoke()` , chat models, etc.) with zero extra setup beyond the agent configuration.[](https://docs.datadoghq.com/integrations/langchain/) [[1]](https://www.contextstudios.ai/guides/best-ai-agent-observability-tools-2026)[[2]](https://apxml.com/courses/langchain-production-llm/chapter-5-evaluation-monitoring-observability/third-party-observability-integration)

If you can share your preferred **deployment model** (managed cloud vs. self-hosted/on-premise) and whether you need **prompt management or evaluations** , I can help you pick the **ideal integration** for your stack.

For LangChain chain-execution tracing, I’d recommend LangSmith first.

Best fit: LangSmith

LangSmith is built by the LangChain team and has native LangChain tracing. It captures the execution tree—including chain steps, LLM calls, tool calls, inputs/outputs, latency, and errors.

The nice part is that enabling tracing can be as simple as environment variables:

export LANGSMITH_TRACING=true
export LANGSMITH_API_KEY="your-api-key"
export LANGSMITH_PROJECT="my-project"

You generally don't need to modify your existing LangChain code.

It also provides dashboards, filtering, alerts, evaluations, and production monitoring, rather than merely storing traces.

Good alternative: Langfuse

Langfuse is worth considering if you specifically want an open-source/self-hostable observability platform. It integrates with LangChain through its callback system and automatically creates nested traces for LangChain runs.

My recommendation:

• Already using LangChain → LangSmith for the lowest-friction integration.
• Want open source/self-hosting → Langfuse.
• Want just execution tracing rather than a full observability platform → OpenTelemetry can also be appropriate, but you'll have more instrumentation/setup work.

If you tell me whether you're using Python or TypeScript, I can show you the minimal LangChain + tracing setup.