--- title: LangChain description: 'Optimize LangChain usage: prompt sampling and performance and cost metrics.' breadcrumbs: Docs > Integrations > LangChain --- # LangChain Supported OS Integration version1.0.0 ## Overview{% #overview %} Monitor, troubleshoot, and evaluate your LLM-powered applications (e.g. chatbot, data extraction tool, etc) built using LangChain. Use LLM Observability to investigate the root cause of issues, monitor operational performance, and evaluate the quality, privacy, and safety of your LLM applications. See the [LLM Observability tracing view video](https://imgix.datadoghq.com/video/products/llm-observability/expedite-troubleshooting.mp4?fm=webm&fit=max) for an example of how you can investigate a trace. Get cost estimation, prompt and completion sampling, error tracking, performance metrics, and more out of [LangChain](https://docs.langchain.com/docs/) Python library requests using Datadog metrics and APM. **Minimum Agent version:** 7.47.0 ## Setup{% #setup %} ### LLM Observability: Get end-to-end visibility into your LLM application using LangChain{% #llm-observability-get-end-to-end-visibility-into-your-llm-application-using-langchain %} You can enable LLM Observability in different environments. Follow the appropriate setup based on your scenario: #### Installation for Python{% #installation-for-python %} ##### If you do not have the Datadog Agent:{% #if-you-do-not-have-the-datadog-agent %} 1. Install the `ddtrace` package: ```shell pip install ddtrace ``` 1. Start your application with the following command, enabling Agentless mode: ```shell DD_SITE= DD_API_KEY= DD_LLMOBS_ENABLED=1 DD_LLMOBS_AGENTLESS_ENABLED=1 DD_LLMOBS_ML_APP= ddtrace-run python .py ``` ##### If you already have the Datadog Agent installed:{% #if-you-already-have-the-datadog-agent-installed %} 1. Make sure the Agent is running and that APM and StatsD are enabled. For example, use the following command with Docker: ```shell docker run -d \ --cgroupns host \ --pid host \ -v /var/run/docker.sock:/var/run/docker.sock:ro \ -v /proc/:/host/proc/:ro \ -v /sys/fs/cgroup/:/host/sys/fs/cgroup:ro \ -e DD_API_KEY= \ -p 127.0.0.1:8126:8126/tcp \ -p 127.0.0.1:8125:8125/udp \ -e DD_DOGSTATSD_NON_LOCAL_TRAFFIC=true \ -e DD_APM_ENABLED=true \ gcr.io/datadoghq/agent:latest ``` 1. Install the `ddtrace` package if it isn't installed yet: ```shell pip install ddtrace ``` 1. Start your application using the `ddtrace-run` command to automatically enable tracing: ```shell DD_SITE= DD_API_KEY= DD_LLMOBS_ENABLED=1 DD_LLMOBS_ML_APP= ddtrace-run python .py ``` **Note**: If the Agent is running on a custom host or port, set `DD_AGENT_HOST` and `DD_TRACE_AGENT_PORT` accordingly. ##### If you are running LLM Observability in a serverless environment (AWS Lambda):{% #if-you-are-running-llm-observability-in-a-serverless-environment-aws-lambda %} 1. Install the **Datadog-Python** and **Datadog-Extension** Lambda layers as part of your AWS Lambda setup. 1. Enable LLM Observability by setting the following environment variables: ```shell DD_SITE= DD_API_KEY= DD_LLMOBS_ENABLED=1 DD_LLMOBS_ML_APP= ``` **Note**: In serverless environments, Datadog automatically flushes spans when the Lambda function finishes running. ##### Automatic LangChain Tracing{% #automatic-langchain-tracing %} LangChain integration is automatically enabled when LLM Observability is configured. This captures latency, errors, input/output messages, and token usage for LangChain operations. The following methods are traced for both synchronous and asynchronous LangChain operations: - LLMs: `llm.invoke()`, `llm.ainvoke()` - Chat Models: `chat_model.invoke()`, `chat_model.ainvoke()` - Chains/LCEL: `chain.invoke()`, `chain.ainvoke()`, `chain.batch()`, `chain.abatch()` - Embeddings: `OpenAIEmbeddings.embed_documents()`, `OpenAIEmbeddings.embed_query()` No additional setup is required for these methods. ##### Validation{% #validation %} Validate that LLM Observability is properly capturing spans by checking your application logs for successful span creation. You can also run the following command to check the status of the `ddtrace` integration: ```shell ddtrace-run --info ``` Look for the following message to confirm the setup: ``` Agent error: None ``` ##### Debugging{% #debugging %} If you encounter issues during setup, enable debug logging by passing the `--debug` flag: ```shell ddtrace-run --debug ``` This will display any errors related to data transmission or instrumentation, including issues with LangChain traces. ### APM: Get Usage Metrics for your python Applications{% #apm-get-usage-metrics-for-your-python-applications %} 1. Enable APM and StatsD in your Datadog Agent. For example, in Docker: ```shell docker run -d --cgroupns host \ --pid host \ -v /var/run/docker.sock:/var/run/docker.sock:ro \ -v /proc/:/host/proc/:ro \ -v /sys/fs/cgroup/:/host/sys/fs/cgroup:ro \ -e DD_API_KEY= \ -p 127.0.0.1:8126:8126/tcp \ -p 127.0.0.1:8125:8125/udp \ -e DD_DOGSTATSD_NON_LOCAL_TRAFFIC=true \ -e DD_APM_ENABLED=true \ gcr.io/datadoghq/agent:latest ``` 1. Install the Datadog APM Python library. ```shell pip install ddtrace>=1.17 ``` 1. Prefix your LangChain Python application command with `ddtrace-run`. ```shell DD_SERVICE="my-service" DD_ENV="staging" DD_API_KEY= ddtrace-run python .py ``` **Note**: If the Agent is using a non-default hostname or port, be sure to also set `DD_AGENT_HOST`, `DD_TRACE_AGENT_PORT`, or `DD_DOGSTATSD_PORT`. See the [APM Python library documentation](https://ddtrace.readthedocs.io/en/stable/installation_quickstart.html) for more advanced usage. #### Configuration{% #configuration %} See the [APM Python library documentation](https://ddtrace.readthedocs.io/en/stable/integrations.html#langchain) for all the available configuration options. #### Validation{% #validation-1 %} Validate that the APM Python library can communicate with your Agent using: ```shell ddtrace-run --info ``` You should see the following output: ``` Agent error: None ``` #### Debug Logging{% #debug-logging %} Pass the `--debug` flag to `ddtrace-run` to enable debug logging. ```shell ddtrace-run --debug ``` This displays any errors sending data: ``` ERROR:ddtrace.internal.writer.writer:failed to send, dropping 1 traces to intake at http://localhost:8126/v0.5/traces after 3 retries ([Errno 61] Connection refused) ``` ## Data Collected{% #data-collected %} ### Metrics{% #metrics %} | | | | | **langchain.request.duration**(gauge) | Request duration distribution.*Shown as nanosecond* | | **langchain.request.error**(count) | Number of errors.*Shown as error* | | **langchain.tokens.completion**(gauge) | Number of tokens used in the completion of a response.*Shown as token* | | **langchain.tokens.prompt**(gauge) | Number of tokens used in the prompt of a request.*Shown as token* | | **langchain.tokens.total**(gauge) | Total number of tokens used in a request and response.*Shown as token* | | **langchain.tokens.total\_cost**(count) | Estimated cost in USD based on token usage.*Shown as dollar* | ### Events{% #events %} The LangChain integration does not include any events. ### Service Checks{% #service-checks %} The LangChain integration does not include any service checks. ## Troubleshooting{% #troubleshooting %} Need help? Contact [Datadog support](https://docs.datadoghq.com/help/).