LangChain OpenTelemetry Instrumentation

Set up automatic OpenTelemetry tracing and instrumentation for LangChain.js applications to monitor chains, agents, and LLM calls in production.

What This Skill Does

This skill helps you instrument your LangChain.js application with OpenTelemetry to automatically trace and monitor:

Instructions

When the user requests LangChain OpenTelemetry instrumentation, follow these steps:

1. Verify Project Setup

First, check if this is a Node.js/TypeScript project and if LangChain is already installed:

2. Install Required Dependencies

Install the LangChain instrumentation package:

```bash

npm install --save @traceloop/instrumentation-langchain

```

For a complete setup, also install OpenTelemetry core dependencies if not already present:

```bash

npm install --save @opentelemetry/sdk-trace-node @opentelemetry/instrumentation @opentelemetry/api

```

**Note:** For simpler setup with all instrumentations bundled, suggest installing `@traceloop/node-server-sdk` instead.

3. Create Instrumentation Configuration

Create or update the OpenTelemetry instrumentation file. Common locations:

**Basic setup:**

```typescript

import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";

import { LangChainInstrumentation } from "@traceloop/instrumentation-langchain";

import { registerInstrumentations } from "@opentelemetry/instrumentation";

const provider = new NodeTracerProvider();

provider.register();

registerInstrumentations({

instrumentations: [new LangChainInstrumentation()],

});

```

4. Configure Trace Exporter (Optional but Recommended)

Add an exporter to send traces to an observability backend:

```typescript

import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-node";

import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";

const exporter = new OTLPTraceExporter({

url: process.env.OTEL_EXPORTER_OTLP_ENDPOINT || "http://localhost:4318/v1/traces",

});

provider.addSpanProcessor(new BatchSpanProcessor(exporter));

```

5. Import at Application Entry Point

Ensure the instrumentation is loaded **before** any LangChain imports:

**In your main application file (e.g., `src/index.ts`, `app.ts`):**

```typescript

// MUST be first import

import "./instrumentation";

// Now import LangChain and other dependencies

import { ChatOpenAI } from "@langchain/openai";

// ... rest of your application

```

6. Verify Compatibility

Check that the installed LangChain version is compatible:

7. Add Environment Variables (Optional)

Suggest adding OpenTelemetry configuration to `.env`:

```

OTEL_SERVICE_NAME=my-langchain-app

OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4318/v1/traces

OTEL_LOG_LEVEL=info

```

8. Test the Setup

Provide a simple test script to verify instrumentation is working:

```typescript

import { ChatOpenAI } from "@langchain/openai";

import { HumanMessage } from "@langchain/core/messages";

async function test() {

const model = new ChatOpenAI();

const response = await model.invoke([

new HumanMessage("Hello, this is a test!"),

]);

console.log("Response:", response);

console.log("Check your trace backend for spans");

}

test();

```

Important Notes

Example Output Structure

After completion, the project should have:

Questions to Ask User

If configuration details are unclear:

1. "Do you already have an OpenTelemetry backend configured, or would you like to set up a local Jaeger instance for testing?"

2. "Where is your application's main entry point file?"

3. "Would you prefer the complete `@traceloop/node-server-sdk` bundle or just the LangChain instrumentation?"