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

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.

The tool you’re looking for is LangSmith. It’s LangChain’s monitoring and observability platform, designed specifically to trace chain/agent execution.

With LangSmith you can:

• Trace individual LangChain runs, chains, tools, and LLM calls
• Inspect inputs, outputs, latency, and errors
• View nested execution traces to understand how a chain arrived at an answer
• Monitor production runs and identify failures or performance bottlenecks
• Evaluate and compare LLM application behavior

It integrates directly with LangChain, so you generally don’t need to instrument every chain manually.

If you tell me whether you're using Python or JavaScript/TypeScript, I can show you the minimal setup and a traced LangChain example.

Here are the top monitoring and tracing tools that natively or seamlessly integrate with LangChain to trace execution trees, latencies, token usage, and tool calls.

• LangSmith — Built by the creators of LangChain, this is the native and most tightly integrated platform for LangChain and LangGraph. It captures deep execution trees, intermediate steps, tool selections, and exact token counts automatically.
  • Setup: Enable via environment variables (export LANGSMITH_TRACING=true and export LANGSMITH_API_KEY=<your-key>).
• Langfuse — An open-source, all-in-one LLM engineering and observability platform. It hooks directly into LangChain components using standard LangChain callback handlers to trace inputs, outputs, latencies, and costs.
  • Setup: Use the Langfuse CallbackHandler via their Python/JS SDK integration.
• Datadog LLM Observability — Ideal if your engineering team already relies on Datadog for APM and infrastructure monitoring. It automatically instruments LangChain operations (chain.invoke, chat_model.invoke , etc.) to track errors, latency, and costs.
  • Setup: Configure via the ddtrace integration library or the standard Datadog APM environment setup.
• MLflow Tracing — A versatile open-source platform for managing the machine learning lifecycle that features built-in native support for tracking LangChain workflows.
  • Setup: Initialize tracking with a single line of code (mlflow.langchain.autolog()).
• OpenLIT / Langtrace — OpenTelemetry-native (OTel) observability tools that auto-instrument langchain-core to extract traces and push them to your preferred backend (Elastic, Jaeger, Signoz, etc.).
  • Setup: Initialize the OpenTelemetry instrumentor at the start of your application script.

Are you looking for a hosted/cloud SaaS solution , a self-hosted open-source tool , or something that integrates with an existing APM stack (like Datadog)?

If you need a tool specifically for tracing LangChain chain execution, the most direct choice is:

LangSmith

LangSmith is built by the LangChain team for LLM application observability. It can trace LangChain chains and agents step-by-step, showing inputs/outputs, tool calls, prompts, model calls, latency, and failures.

Typical setup:

export LANGSMITH_TRACING=true
export LANGSMITH_API_KEY=<your-api-key>

Then run your LangChain app normally; traces are captured automatically.

Useful features:

• 🌳 Visual chain/agent execution traces
• 🔍 Debugging failed runs by inspecting intermediate steps
• 📊 Monitoring latency, cost, and quality signals
• 🧪 Evaluation workflows using recorded traces
• 🔗 Works with LangChain Python and JavaScript/TypeScript apps

Other options depending on your needs:

For a production LangChain application, I would usually start with LangSmith because it has the tightest integration with LangChain’s tracing APIs. www.langchain.com If you need self-hosting or want to avoid a hosted service, look at OpenTelemetry-compatible tools or open-source alternatives. LangSmith also supports OpenTelemetry-based tracing workflows.

The native and most deeply integrated monitoring tool for LangChain is LangSmith . Because it is built by the creators of LangChain, it requires zero code rewrites and captures complete execution trees (including LCEL chains, prompt details, tool selections, and vector store retrievers) simply via environment variables.

However, depending on your team's existing infrastructure, several alternative open-source and enterprise options natively support LangChain callbacks or OpenTelemetry instrumentation.

Top Monitoring Tools for LangChain

• LangSmith : The official platform for LangChain and LangGraph. It tracks latencies, token consumption, costs, and multi-agent trajectories with sub-second performance. You can set it up instantly without modifying your invoke/batch logic.
• Langfuse : A popular open-source LLM engineering and tracing platform. It hooks into LangChain using standard callback handlers (CallbackHandler ) to capture inputs, outputs, and latencies. It is fully self-hostable if you have strict data privacy or residency constraints.
• Datadog (LLM Observability) : Offers an out-of-the-box APM and tracing integration (ddtrace ) for LangChain. Ideal if your infrastructure is already standardized on Datadog and you need to correlate LLM latency/errors with standard microservices.
• Arize Phoenix : An open-source AI observability tool focused heavily on evaluation, embeddings, and troubleshooting complex agentic or retrieval-augmented generation (RAG) chains.
• LangTrace : A lightweight, OpenTelemetry-native open-source tool that auto-instruments LangChain and LangGraph workflows with minimal configuration and exports seamlessly to standard backends.

Quickstart: How to Enable LangSmith Tracing

If you want to use the native route, setting up tracing takes under a minute using environment variables.

1. Sign up for an account and generate an API key on the LangSmith Platform.
2. Configure your environment variables before executing your code:bash``` export LANGSMITH_TRACING=true export LANGSMITH_ENDPOINT="https://api.smith.langchain.com" export LANGSMITH_API_KEY="your-langsmith-api-key" export LANGSMITH_PROJECT="your-project-name"

Use code with caution.
3. Run your LangChain or LangGraph app normally (`chain.invoke(...)` ). The complete step-by-step run tree will stream straight into your LangSmith Dashboard.[](https://docs.langchain.com/langsmith/observability) [[1]](https://docs.langchain.com/langsmith/observability)[[2]](https://todatabeyond.substack.com/p/hands-on-langsmith-course27-tracing)[[3]](https://docs.langchain.com/langsmith/trace-with-langgraph)[[4]](https://docs.langchain.com/langsmith/trace-with-opentelemetry)[[5]](https://www.langchain.com/blog/end-to-end-opentelemetry-langsmith)[[6]](https://docs.langchain.com/oss/python/langchain/observability)

If you'd like to proceed, tell me:

- Are you looking for a **managed cloud service** or an **open-source tool you can self-host**?
- Do you need to integrate this with an **existing APM** (like Datadog or New Relic)?