OpenInference

OpenInference is a set of OpenTelemetry instrumentors for LLM frameworks and providers. Each one auto-captures model calls, tool calls, retrieval steps, and agent runs as OTLP spans. AgentMark reads the OpenInference attribute conventions directly, so any OpenInference-instrumented app sends usable traces by pointing its exporter at AgentMark, with no per-framework setup on the AgentMark side.

Supported frameworks

OpenInference maintains instrumentors for a wide range of libraries, including:

Category	Instrumentors
Orchestration	LangChain, LangGraph, LlamaIndex, Haystack, DSPy
Agents	OpenAI Agents SDK, CrewAI, AutoGen, smolagents, Google ADK, Agno
Providers	OpenAI, Anthropic, Amazon Bedrock, Vertex AI, Gemini, Mistral, Groq, LiteLLM
Other	Instructor, Guardrails, Model Context Protocol (MCP)

See the OpenInference repository for the complete, current list and the Python and JavaScript package names.

Setup

OpenInference ships instrumentors for both Python and JavaScript/TypeScript. The example below instruments OpenAI; swap the instrumentor package and class for the framework you use. The OTLP wiring stays identical.

Install the instrumentor and the OTLP exporter

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

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

Point the exporter at AgentMark

Register a tracer provider that exports to AgentMark, then instrument your framework. Use your AgentMark API key and app id (from project settings).

import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
import { registerInstrumentations } from "@opentelemetry/instrumentation";
import { OpenAIInstrumentation } from "@arizeai/openinference-instrumentation-openai";

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();

registerInstrumentations({ instrumentations: [new OpenAIInstrumentation()] });

from openinference.instrumentation.openai import OpenAIInstrumentor
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>",
            },
        )
    )
)

OpenAIInstrumentor().instrument(tracer_provider=provider)

Swap OpenAIInstrumentation / OpenAIInstrumentor for the instrumentor that matches your framework (for example @arizeai/openinference-instrumentation-langchain or openinference-instrumentation-langchain).

In TypeScript, this setup must run before you import the instrumented libraries, so the instrumentor can patch them. Put it in its own module and load it first, for example node -r ./instrumentation.js app.js.

Run your app

Run your 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.

Every OpenInference instrumentor exports through the same OTLP endpoint, so the only thing that changes between frameworks is the instrumentor you install and register. You can also set the endpoint and headers with the standard OTEL_EXPORTER_OTLP_TRACES_ENDPOINT and OTEL_EXPORTER_OTLP_TRACES_HEADERS environment variables instead of configuring the exporter in code. See OpenTelemetry.

What AgentMark captures

AgentMark maps OpenInference attributes onto its normalized trace fields:

OpenInference attribute	AgentMark field
`llm.model_name`	Model
`llm.token_count.prompt` / `.completion` / `.total`	Input / output / total tokens
`llm.token_count.completion_details.reasoning`	Reasoning tokens
`llm.input_messages.` / `llm.output_messages.`	Input / output messages
`input.value` / `output.value`	Input / output on chain, tool, and agent spans
`llm.output_messages..tool_calls.`	Tool calls
`llm.invocation_parameters`	Settings (temperature, max tokens, top-p, penalties)
`retrieval.documents.*.document.{id,content,score,metadata}`	Retrieved documents (ranked, with relevance scores) on retrieval spans
`openinference.span.kind`	Span kind (`llm`, `tool`, `agent`, `retrieval`, …)
`session.id` / `user.id` / `metadata`	Session, user, and custom metadata

Token counts and the model feed AgentMark’s cost tracking automatically.

Next steps

OpenTelemetry endpoint

The endpoint, authentication, and environment-variable configuration

Traces and logs

Explore traces once they arrive

Have questions?

Reach out any time:

Email the team at hello@agentmark.co for support
Schedule an Enterprise Demo to learn about AgentMark’s business solutions

Get started

Coding agents

Concepts

Build prompts

Evaluate

Observe

Deploy

Account & billing

Integrations

Reference

Supported frameworks

Setup

What AgentMark captures

Next steps

OpenTelemetry endpoint

Traces and logs

Have questions?

​Supported frameworks

​Setup

​What AgentMark captures

​Next steps

OpenTelemetry endpoint

Traces and logs

​Have questions?

Supported frameworks

Setup

What AgentMark captures

Next steps

Have questions?