Skip to main content
The OpenInference LangChain instrumentor instruments LangChain chains, agents, and LangGraph graphs. It captures model calls, tool calls, retrieval steps, and chain runs as OTLP spans. Point the exporter at AgentMark and the traces arrive normalized. LangGraph runs on top of LangChain, so the same instrumentor covers both.

​
Setup

1

Install the instrumentor and the OTLP exporter

npm install @arizeai/openinference-instrumentation-langchain \
  @opentelemetry/sdk-trace-node @opentelemetry/sdk-trace-base \
  @opentelemetry/exporter-trace-otlp-http

pip install openinference-instrumentation-langchain \
  opentelemetry-sdk opentelemetry-exporter-otlp-proto-http
2

Point the exporter at AgentMark and instrument LangChain

Use your AgentMark API key and app id from project settings.
// instrumentation.ts
import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
import { LangChainInstrumentation } from "@arizeai/openinference-instrumentation-langchain";
import * as CallbackManagerModule from "@langchain/core/callbacks/manager";

const provider = new NodeTracerProvider({
  spanProcessors: [
    new BatchSpanProcessor(
      new OTLPTraceExporter({
        url: "https://api.agentmark.co/v1/traces",
        headers: {
          Authorization: process.env.AGENTMARK_API_KEY!, // raw key, no "Bearer" prefix
          "X-Agentmark-App-Id": process.env.AGENTMARK_APP_ID!,
        },
      })
    ),
  ],
});
provider.register();

// LangChain.js exposes its callbacks manager as a non-standard module, so you
// must instrument it manually rather than through registerInstrumentations.
const lcInstrumentation = new LangChainInstrumentation();
lcInstrumentation.manuallyInstrument(CallbackManagerModule);

from openinference.instrumentation.langchain import LangChainInstrumentor
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter

provider = TracerProvider()
provider.add_span_processor(
    BatchSpanProcessor(
        OTLPSpanExporter(
            endpoint="https://api.agentmark.co/v1/traces",
            headers={
                "Authorization": "<YOUR_API_KEY>",  # raw key, no "Bearer" prefix
                "X-Agentmark-App-Id": "<YOUR_APP_ID>",
            },
        )
    )
)

LangChainInstrumentor().instrument(tracer_provider=provider)
In TypeScript, this setup must run before you import LangChain, so the instrumentor can patch the callbacks manager. Put it in its own module and load it first, for example node -r ./instrumentation.js app.js.
3

Run your app

Run your LangChain or LangGraph application as usual. Each model call, tool call, and retrieval step arrives in AgentMark as a span, grouped into a trace. See Traces and logs.

​
What AgentMark captures

spans use the OpenInference attribute conventions: model, token usage, input and output messages, tool calls, settings, and span kind are all mapped onto AgentMark’s normalized trace fields, and token counts feed cost tracking. See OpenInference for the full attribute mapping.

​
Next steps

OpenInference

How AgentMark reads OpenInference attributes

Traces and logs

Explore traces once they arrive

​
Have questions?

Reach out any time: