Trace LLM calls - Braintrust

Use the Braintrust CLI to automatically instrument your project with your preferred coding agent.

Auto-instrumentation

Auto-instrumentation patches supported AI libraries at startup so every LLM call is captured without wrapping individual clients. This is the recommended way to set up tracing. The examples on this page use OpenAI, but Braintrust supports many providers and frameworks.

Auto-instrumentation in TypeScript uses a startup hook that patches supported AI libraries automatically.

Install the dependencies

npm install braintrust openai

Set your environment variables

export BRAINTRUST_API_KEY="your-api-key"
export OPENAI_API_KEY="your-api-key"

For local development, the Braintrust Node.js SDK can instead read BRAINTRUST_API_KEY from a .env.braintrust file. When no key is set explicitly or through the environment, the SDK searches upward from the working directory to the filesystem root for a file like this:

.env.braintrust

BRAINTRUST_API_KEY=your-api-key

The nearest file wins. Discovery runs the first time the SDK needs the key, so construction succeeds even when no key is present at startup. This applies to the Node.js SDK only, not the browser, edge, or workerd builds. Add .env.braintrust to your .gitignore so the key isn’t committed.

Trace your LLM calls

This example traces a single OpenAI call:

import { initLogger } from "braintrust";
import OpenAI from "openai";

// Call once at startup — all LLM calls are traced automatically
initLogger({
  apiKey: process.env.BRAINTRUST_API_KEY,
  projectName: "My Project (TypeScript)",
});

const client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
const response = await client.responses.create({
  model: "gpt-5-mini",
  input: "What is the capital of France?",
});

Disabling specific integrations

Auto-instrumentation enables every supported TypeScript integration by default. Disable individual integrations with the BRAINTRUST_DISABLE_INSTRUMENTATION environment variable, a comma-separated, case-insensitive list of integration names to skip:

# Disable one integration
BRAINTRUST_DISABLE_INSTRUMENTATION=openai node --import braintrust/hook.mjs app.js

# Disable multiple integrations
BRAINTRUST_DISABLE_INSTRUMENTATION=openai,anthropic node --import braintrust/hook.mjs app.js

The names match the supported libraries, such as openai, anthropic, ai-sdk, langchain, and aws-bedrock. See Supported libraries for the full list.To configure the same behavior in code, call configureInstrumentation() before importing any AI SDKs:

import { configureInstrumentation } from "braintrust";

configureInstrumentation({
  integrations: { openai: false },
});

// Import AI SDKs after configuring. Use a dynamic import so it evaluates
// after configureInstrumentation() runs — static imports are hoisted.
const { default: OpenAI } = await import("openai");

Run your app

Run with the --import flag to enable auto-instrumentation:

node --import braintrust/hook.mjs app.js

Using a bundler?

If you’re using a bundler or a framework that uses one, use the appropriate bundler plugin instead of the --import flag. The plugins are included in the Braintrust SDK:

Bundler / Framework	Import path
Vite / SvelteKit	`braintrust/vite`
Nuxt	`braintrust/vite` (client) + `braintrust/rollup` (Nitro server)
Next.js	`braintrust/next`
Webpack	`braintrust/webpack`
esbuild	`braintrust/esbuild`
Rollup	`braintrust/rollup`

Vite (vite.config.ts):

import { defineConfig } from "vite";
import { braintrustVitePlugin } from "braintrust/vite";

export default defineConfig({
  plugins: [braintrustVitePlugin()],
});

Next.js (next.config.ts):Wrap your config with wrapNextjsConfigWithBraintrust. It selects the webpack plugin or the Turbopack loader based on the active Next.js build, so the same setup works whether you use Webpack (Next.js 15 and earlier) or Turbopack (Next.js 16+).

import { wrapNextjsConfigWithBraintrust } from "braintrust/next";

const nextConfig = {};

export default wrapNextjsConfigWithBraintrust(nextConfig);

Nuxt (nuxt.config.ts) — Nuxt uses Vite for the client build and Rollup (via Nitro) for the server build, so both plugins are needed:

import { braintrustVitePlugin } from "braintrust/vite";
import { braintrustRollupPlugin } from "braintrust/rollup";

export default defineNuxtConfig({
  vite: {
    plugins: [braintrustVitePlugin()],
  },
  nitro: {
    rollupConfig: {
      plugins: [braintrustRollupPlugin()],
    },
  },
});

Node.js version requirements

Requires Node.js 18.19.0+ or 20.6.0+ for --import flag support. Check with node --version.

Auto-instrumentation in Python uses auto_instrument() to patch supported AI libraries at startup.

Install the dependencies

pip install braintrust openai

Set your environment variables

export BRAINTRUST_API_KEY="your-api-key"
export OPENAI_API_KEY="your-api-key"

For local development, the Python SDK can instead read BRAINTRUST_API_KEY from a .env.braintrust file. When no key is set explicitly or through the environment, the SDK searches upward from the working directory (up to 64 parent directories) for a file like this:

.env.braintrust

BRAINTRUST_API_KEY=your-api-key

The nearest file wins. Discovery runs the first time the SDK needs the key, so construction succeeds even when no key is present at startup. The file is read for the key only and does not modify your process environment. Add .env.braintrust to your .gitignore so the key isn’t committed.

Trace your LLM calls

This example traces a single OpenAI call:

import os
import braintrust

# Call once at startup — all LLM calls are traced automatically
braintrust.auto_instrument()
braintrust.init_logger(
    api_key=os.environ["BRAINTRUST_API_KEY"],
    project="My Project (Python)",
)

from openai import OpenAI

client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])
response = client.responses.create(
    model="gpt-5-mini",
    input="What is the capital of France?",
)

Disabling specific integrations

braintrust.auto_instrument() enables every supported Python integration by default. Disable individual integrations by passing False for a specific keyword.

Parameter	Default	Library or framework
`openai`	`True`	OpenAI Python SDK
`anthropic`	`True`	Anthropic Python SDK
`litellm`	`True`	LiteLLM
`pydantic_ai`	`True`	Pydantic AI
`google_genai`	`True`	Google GenAI
`instructor`	`True`	Instructor
`openrouter`	`True`	OpenRouter native Python SDK
`mistral`	`True`	Mistral Python SDK
`huggingface_hub`	`True`	Hugging Face Hub
`agno`	`True`	Agno
`agentscope`	`True`	AgentScope
`claude_agent_sdk`	`True`	Claude Agent SDK
`dspy`	`True`	DSPy
`adk`	`True`	Google ADK
`langchain`	`True`	LangChain and LangGraph
`llamaindex`	`True`	LlamaIndex
`openai_agents`	`True`	OpenAI Agents SDK
`cohere`	`True`	Cohere Python SDK
`autogen`	`True`	AutoGen
`crewai`	`True`	CrewAI
`strands`	`True`	Strands Agents
`temporal`	`True`	Temporal
`livekit_agents`	`True`	LiveKit Agents

For example:

braintrust.auto_instrument(openrouter=False)

Run your app

python app.py

Auto-instrumentation in Ruby uses the braintrust/setup require to patch supported AI libraries on load.

Install the dependencies

Add the Braintrust gem to your Gemfile, using the braintrust/setup require to enable auto-instrumentation on load:

# Gemfile
gem "braintrust", require: "braintrust/setup"
gem "ruby-openai"

bundle install

Set your environment variables

export BRAINTRUST_API_KEY="your-api-key"
export OPENAI_API_KEY="your-api-key"
export BRAINTRUST_DEFAULT_PROJECT=<your-project-name>  # Project that spans are logged to

For local development, the Ruby SDK can instead read BRAINTRUST_API_KEY from a .braintrust.json file. When no key is set through the environment or an explicit api_key: argument, the SDK searches upward from the working directory for a file like this:

.braintrust.json

{ "BRAINTRUST_API_KEY": "your-api-key" }

The nearest file wins, and the file is read for the key only without modifying your process environment. Add .braintrust.json to your .gitignore so the key isn’t committed.

Trace your LLM calls

This example traces a single OpenAI call:

require 'bundler/setup'
Bundler.require

client = OpenAI::Client.new(access_token: ENV['OPENAI_API_KEY'])
response = client.responses.create(
  parameters: {
    model: 'gpt-5-mini',
    input: 'What is the capital of France?'
  }
)

Run your app

ruby app.rb

Auto-instrumentation in Go uses Orchestrion for compile-time tracing. Each provider integration is installed as a separate Go module.

Install and register the integration

Install the Braintrust SDK, the provider connector module, and Orchestrion:

go get github.com/braintrustdata/braintrust-sdk-go
go get github.com/braintrustdata/braintrust-sdk-go/trace/contrib/openai
go get github.com/openai/openai-go
go install github.com/DataDog/orchestrion@latest

Then create orchestrion.tool.go in your project root to register which integrations Orchestrion should instrument:

#skip-compile

//go:build tools

package main

import (
	_ "github.com/DataDog/orchestrion"
	_ "github.com/braintrustdata/braintrust-sdk-go/trace/contrib/openai"
)

Other providers

Each tracing integration is published as its own Go module. Install the ones you need and add them to orchestrion.tool.go:

go get github.com/braintrustdata/braintrust-sdk-go/trace/contrib/anthropic
go get github.com/braintrustdata/braintrust-sdk-go/trace/contrib/bedrockruntime
go get github.com/braintrustdata/braintrust-sdk-go/trace/contrib/genai
go get github.com/braintrustdata/braintrust-sdk-go/trace/contrib/genkit
go get github.com/braintrustdata/braintrust-sdk-go/trace/contrib/adk
go get github.com/braintrustdata/braintrust-sdk-go/trace/contrib/cloudwego/eino
go get github.com/braintrustdata/braintrust-sdk-go/trace/contrib/langchaingo
go get github.com/braintrustdata/braintrust-sdk-go/trace/contrib/github.com/sashabaranov/go-openai

Or use the trace/contrib/all meta-module to install and register every integration at once:

go get github.com/braintrustdata/braintrust-sdk-go/trace/contrib/all

#skip-compile

//go:build tools

package main

import (
	_ "github.com/DataDog/orchestrion"
	_ "github.com/braintrustdata/braintrust-sdk-go/trace/contrib/all"
)

Set your environment variables

export BRAINTRUST_API_KEY="your-api-key"
export OPENAI_API_KEY="your-api-key"

For local development, the Go SDK can instead read BRAINTRUST_API_KEY from a .braintrust.json file. When no key is set through the environment or the WithAPIKey option, the SDK searches upward from the working directory for a file like this:

.braintrust.json

{ "BRAINTRUST_API_KEY": "your-api-key" }

The nearest file wins. Discovery runs the first time the SDK authenticates or exports, so braintrust.New() succeeds even when no key is present at startup. Passing a blank or whitespace-only string to WithAPIKey is treated as unset and preserves this fallback. Add .braintrust.json to your .gitignore so the key isn’t committed.

Trace your LLM calls

This example traces a single OpenAI call. The Go SDK sends traces to Braintrust via OpenTelemetry, so you create a TracerProvider and pass it to Braintrust:

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	"github.com/braintrustdata/braintrust-sdk-go"
	"github.com/openai/openai-go"
	"github.com/openai/openai-go/option"
	"github.com/openai/openai-go/responses"
	"go.opentelemetry.io/otel"
	sdktrace "go.opentelemetry.io/otel/sdk/trace"
)

func main() {
	tp := sdktrace.NewTracerProvider()
	defer tp.Shutdown(context.Background())
	otel.SetTracerProvider(tp)

	_, err := braintrust.New(tp,
		braintrust.WithProject("My Project (Go)"),
		braintrust.WithAPIKey(os.Getenv("BRAINTRUST_API_KEY")),
	)
	if err != nil {
		log.Fatal(err)
	}

	client := openai.NewClient(option.WithAPIKey(os.Getenv("OPENAI_API_KEY")))

	response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
		Model: "gpt-5-mini",
		Input: responses.ResponseNewParamsInputUnion{OfString: openai.String("What is the capital of France?")},
	})
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(response.OutputText())
}

Build and run your app

Build with Orchestrion to enable auto-instrumentation:

go mod tidy
orchestrion go build -o myapp
./myapp

Enable Orchestrion via GOFLAGS

Instead of running orchestrion go build, you can set a GOFLAGS environment variable to enable Orchestrion for normal go build commands:

export GOFLAGS="-toolexec='orchestrion toolexec'"
go build ./...

The Braintrust Java agent uses ByteBuddy to automatically instrument supported AI libraries at JVM startup.

Add the agent dependency

# build.gradle
configurations {
    braintrustAgent
}

dependencies {
    braintrustAgent 'dev.braintrust:braintrust-java-agent:+'
}

tasks.withType(JavaExec).configureEach {
    jvmArgs "-javaagent:${configurations.braintrustAgent.asPath}"
}

Set your environment variables

export BRAINTRUST_API_KEY="your-api-key"

For local development, the Java SDK can instead read BRAINTRUST_API_KEY from a .env.braintrust file. When no key is set explicitly or through the environment, the SDK searches upward from the working directory (up to 64 parent directories) for a file like this:

.env.braintrust

BRAINTRUST_API_KEY=your-api-key

Run your app

./gradlew run

The agent automatically configures OTel and injects a Braintrust span exporter. For Spring Boot, use ./gradlew bootRun instead.

Not using Gradle? Download the agent JAR from the GitHub releases page and add -javaagent:/path/to/braintrust-java-agent-<version>.jar to your JVM startup flags directly.

Using with the OpenTelemetry Java agent

When the OpenTelemetry Java agent is also attached, the Braintrust agent’s auto-instrumentation is suppressed to avoid duplicate spans. To get Braintrust tracing of LLM calls in this setup, use the braintrust-otel-extension as an OTel agent extension.

# build.gradle
configurations {
    otelAgent
    braintrustExtension
}

dependencies {
    otelAgent 'io.opentelemetry.javaagent:opentelemetry-javaagent:<version>'
    braintrustExtension 'dev.braintrust:braintrust-otel-extension:+'
}

tasks.withType(JavaExec).configureEach {
    jvmArgs "-javaagent:${configurations.otelAgent.asPath}"
    jvmArgs "-Dotel.javaagent.extensions=${configurations.braintrustExtension.asPath}"
}

Then run as normal:

./gradlew run

Not using Gradle? Download the braintrust-otel-extension JAR from the GitHub releases page and pass -Dotel.javaagent.extensions=/path/to/braintrust-otel-extension-<version>.jar alongside your existing -javaagent flag.

Using with the Datadog Java agent

List the Braintrust -javaagent flag after the Datadog -javaagent flag:

java -javaagent:/path/to/dd-java-agent.jar \
     -javaagent:/path/to/braintrust-java-agent-<version>.jar \
     -jar your-app.jar

Filter non-AI spans

By default, the Braintrust agent exports all spans. Set BRAINTRUST_FILTER_AI_SPANS=true to export only AI-related spans (LLM calls, model invocations) and drop spans from generic instrumentation like HTTP clients and database calls.

export BRAINTRUST_FILTER_AI_SPANS=true

You can also set this programmatically via BraintrustConfig.builder().filterAISpans(true).

Enabling this reduces noise in Braintrust but means you won’t see the surrounding trace context (e.g., the HTTP request that triggered an LLM call).

Compress OTel payloads

By default, the Braintrust agent gzip-compresses OpenTelemetry span and log payloads before export, reducing network bandwidth with no changes on your side. Set BRAINTRUST_COMPRESS_OTEL_PAYLOAD=false to disable span compression.

export BRAINTRUST_COMPRESS_OTEL_PAYLOAD=false

You can also set this programmatically via BraintrustConfig.builder().compressOtelPayload(false).

Compression reduces network bandwidth, but Braintrust span size limits still apply to the uncompressed payload.

Extract base64 attachments

By default, the Braintrust span processor detects base64-encoded attachments (images, PDFs, and other binary data) in span inputs and outputs, uploads them to object storage, and replaces them with attachment references. This reduces span payload sizes and the chance of exceeding OpenTelemetry span size limits. OpenAI, Anthropic, Google Gemini, and AWS Bedrock Converse formats are supported.Each converted attachment is replaced with a reference object in the span data:

{ "type": "braintrust_attachment", "content_type": "image/png", "filename": "attachment.png", "key": "..." }

Set BRAINTRUST_AUTO_CONVERT_AI_ATTACHMENTS=false to disable conversion.

export BRAINTRUST_AUTO_CONVERT_AI_ATTACHMENTS=false

You can also set this programmatically via BraintrustConfig.builder().autoConvertAIAttachments(false).

If an attachment upload fails, the span is exported with its original content unchanged, so no data is lost.

Run your app and check Braintrust — your LLM calls will appear in the project logs.

Streaming responses are fully supported — Braintrust automatically collects streamed chunks and logs the complete response as a single span.

Manual instrumentation

Manual instrumentation lets you explicitly instrument individual client instances. This is an alternative to auto-instrumentation, useful if you prefer explicit control or if auto-instrumentation isn’t supported by the libraries you’re using. Unlike auto-instrumentation, you need to wrap each client instance in your application.

import { initLogger, wrapOpenAI } from "braintrust";
import OpenAI from "openai";

initLogger({
  apiKey: process.env.BRAINTRUST_API_KEY,
  projectName: "My Project (TypeScript)",
});

// Wrap the OpenAI client to trace all calls
const client = wrapOpenAI(new OpenAI({ apiKey: process.env.OPENAI_API_KEY }));
const response = await client.responses.create({
  model: "gpt-5-mini",
  input: "What is the capital of France?",
});

import os
import braintrust
from braintrust import wrap_openai
from openai import OpenAI

braintrust.init_logger(
    api_key=os.environ["BRAINTRUST_API_KEY"],
    project="My Project (Python)",
)

# Wrap the OpenAI client to trace all calls
client = wrap_openai(OpenAI(api_key=os.environ["OPENAI_API_KEY"]))
response = client.responses.create(
    model="gpt-5-mini",
    input="What is the capital of France?",
)

Use Braintrust.instrument! with a target: to instrument a specific client instance:

require 'braintrust'
require 'openai'

Braintrust.init(
  api_key: ENV['BRAINTRUST_API_KEY'],
  default_project: 'My Project (Ruby)',
  auto_instrument: false
)

# Wrap a specific OpenAI client to trace all calls
client = OpenAI::Client.new(access_token: ENV['OPENAI_API_KEY'])
Braintrust.instrument!(:ruby_openai, target: client)

response = client.responses.create(
  parameters: {
    model: 'gpt-5-mini',
    input: 'What is the capital of France?'
  }
)

Use :openai if you’re using the openai gem, or :ruby_openai for the ruby-openai gem.

The Go SDK provides tracing middleware that you pass to your AI provider’s client constructor:

package main

import (
	"context"
	"fmt"
	"log"
	"os"

	"github.com/braintrustdata/braintrust-sdk-go"
	traceopenai "github.com/braintrustdata/braintrust-sdk-go/trace/contrib/openai"
	"github.com/openai/openai-go"
	"github.com/openai/openai-go/option"
	"github.com/openai/openai-go/responses"
	"go.opentelemetry.io/otel"
	sdktrace "go.opentelemetry.io/otel/sdk/trace"
)

func main() {
	tp := sdktrace.NewTracerProvider()
	defer tp.Shutdown(context.Background())
	otel.SetTracerProvider(tp)

	_, err := braintrust.New(tp,
		braintrust.WithProject("My Project (Go)"),
		braintrust.WithAPIKey(os.Getenv("BRAINTRUST_API_KEY")),
	)
	if err != nil {
		log.Fatal(err)
	}

	// Create an OpenAI client with tracing middleware
	client := openai.NewClient(
		option.WithAPIKey(os.Getenv("OPENAI_API_KEY")),
		option.WithMiddleware(traceopenai.NewMiddleware()),
	)

	response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
		Model: "gpt-5-mini",
		Input: responses.ResponseNewParamsInputUnion{OfString: openai.String("What is the capital of France?")},
	})
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(response.OutputText())
}

# build.gradle
dependencies {
    implementation 'dev.braintrust:braintrust-sdk-java:+'
    implementation 'com.openai:openai-java:+'
}

#skip-compile

import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.ChatCompletionCreateParams;
import com.openai.models.chat.completions.ChatCompletionUserMessageParam;
import dev.braintrust.Braintrust;
import dev.braintrust.config.BraintrustConfig;
import dev.braintrust.instrumentation.openai.BraintrustOpenAI;

class Main {
    public static void main(String[] args) {
        var config = BraintrustConfig.builder()
            .apiKey(System.getenv("BRAINTRUST_API_KEY"))
            .defaultProjectName("My Project (Java)")
            .build();
        var braintrust = Braintrust.get(config);
        var openTelemetry = braintrust.openTelemetryCreate();

        // Wrap the OpenAI client to trace all calls
        OpenAIClient openaiClient = OpenAIOkHttpClient.builder()
            .apiKey(System.getenv("OPENAI_API_KEY"))
            .build();
        OpenAIClient client = BraintrustOpenAI.wrapOpenAI(openTelemetry, openaiClient);

        var params = ChatCompletionCreateParams.builder()
            .model("gpt-5-mini")
            .addMessage(ChatCompletionUserMessageParam.builder()
                .content("What is the capital of France?")
                .build())
            .build();
        var response = client.chat().completions().create(params);
    }
}

dotnet add package Braintrust.Sdk
dotnet add package Braintrust.Sdk.OpenAI
dotnet add package OpenAI

#skip-compile

using System;
using Braintrust.Sdk;
using Braintrust.Sdk.Config;
using Braintrust.Sdk.OpenAI;
using OpenAI;
using OpenAI.Chat;

var config = BraintrustConfig.Of(
    ("BRAINTRUST_API_KEY", Environment.GetEnvironmentVariable("BRAINTRUST_API_KEY")),
    ("BRAINTRUST_DEFAULT_PROJECT_NAME", "My Project (.NET)"));
var braintrust = Braintrust.Sdk.Braintrust.Get(config);
var activitySource = braintrust.GetActivitySource();

// Wrap the OpenAI client to trace all calls
var openAIClient = BraintrustOpenAI.WrapOpenAI(
    activitySource, Environment.GetEnvironmentVariable("OPENAI_API_KEY"));

var chatClient = openAIClient.GetChatClient("gpt-5-mini");
var response = await chatClient.CompleteChatAsync(
    new ChatMessage[]
    {
        new UserChatMessage("What is the capital of France?")
    });

For local development, the .NET SDK can instead read BRAINTRUST_API_KEY from a .env.braintrust file. When no key is set explicitly or through the environment, the SDK searches upward from the working directory (up to 64 parent directories) for a file like this:

.env.braintrust

BRAINTRUST_API_KEY=your-api-key

Braintrust gateway

The Braintrust gateway provides a unified OpenAI-compatible API for accessing models from many providers. When you call a model through the gateway, your requests are automatically traced — no SDK instrumentation needed. The gateway also provides automatic caching and observability across providers.

Supported libraries

To help you log traces, Braintrust’s SDKs support automatic and manual instrumentation for many common libraries. Select a language to get started.

Library	Min. library version	Setup guide
openai	4.0.0	OpenAI
@anthropic-ai/sdk	0.60.0	Anthropic
@anthropic-ai/bedrock-sdk	0.30.2	Anthropic
@aws-sdk/client-bedrock-runtime	3.1048.0	AWS Bedrock
@google/genai	1.0.0	Gemini
@google/adk	0.6.x, 1.x	Google ADK
ai (Vercel AI SDK)	3.0.0	Vercel AI SDK
@anthropic-ai/claude-agent-sdk	0.1.0	Claude Agent SDK
@mistralai/mistralai	1.0.0	Mistral
@openrouter/agent	0.1.2	OpenRouter Agent
@openrouter/sdk	0.9.11	OpenRouter SDK
@huggingface/inference	2.0.0	Hugging Face
cohere-ai	7.0.0	Cohere
groq-sdk	1.0.0	Groq
@openai/agents	0.0.14	OpenAI Agents SDK
@openai/codex-sdk	0.128.0	OpenAI Codex SDK
@cursor/sdk	1.0.7	Cursor SDK
@flue/runtime	0.8.0	Flue
@strands-agents/sdk	1.0.0	Strands Agent SDK
@langchain/core	0.3.42	LangChain
genkit	1.0.0	Firebase Genkit
@mastra/core	1.20.0	Mastra
eve	0.20.0	Eve
@earendil-works/pi-coding-agent	0.79.0	Pi Coding Agent SDK

Library	Min. library version	Setup guide
openai	1.71.0	OpenAI
anthropic	0.48.0	Anthropic
google-genai	1.30.0	Gemini
openrouter	0.6.0	OpenRouter
mistralai	1.12.4	Mistral
openai-agents	0.0.19	OpenAI Agents SDK
claude-agent-sdk	0.1.10	Claude Agent SDK
litellm	1.74.0	LiteLLM
google-adk	1.14.1	Google ADK
agentscope	1.0.0	AgentScope
pydantic-ai	1.10.0	Pydantic AI
agno	2.1.0	Agno
dspy	2.6.0	DSPy
langchain-core	0.3.28	LangChain
llama-index-core	0.13.0	LlamaIndex
cohere	5.0.0	Cohere
autogen-agentchat	0.7.0	AutoGen
crewai	1.13.0	CrewAI
strands-agents	1.20.0	Strands
temporalio	1.19.0	Temporal
instructor	1.11.0	Instructor
huggingface-hub	0.32.0	Hugging Face
boto3	1.34.116	AWS Bedrock

Library	Min. library version	Setup guide
openai	0.1.0	OpenAI
ruby-openai	7.0.0	OpenAI
anthropic	0.3.0	Anthropic
ruby_llm	1.8.0	RubyLLM

Library	Min. library version	Setup guide
github.com/openai/openai-go	1.12.0	OpenAI
github.com/anthropics/anthropic-sdk-go	1.23.0	Anthropic
github.com/aws/aws-sdk-go-v2/service/bedrockruntime	1.49.0	AWS Bedrock
google.golang.org/genai	1.41.0	Gemini
google.golang.org/adk	0.4.0	Google ADK
github.com/tmc/langchaingo	0.1.13	LangChain
github.com/sashabaranov/go-openai	1.41.2	OpenAI
github.com/cloudwego/eino	0.8.4	CloudWeGo Eino
github.com/firebase/genkit/go	1.5.0	Firebase Genkit

Library	Min. library version	Setup guide
com.openai:openai-java	2.15.0	OpenAI
com.anthropic:anthropic-java	2.2.0	Anthropic
com.google.genai:google-genai	1.18.0	Gemini
dev.langchain4j:langchain4j	1.8.0	LangChain
org.springframework.ai:spring-ai-core	1.0.0	—
software.amazon.awssdk:bedrockruntime	2.30.0	AWS Bedrock

Library	Min. library version	Setup guide
OpenAI	2.6.0	OpenAI
Anthropic	12.5.0	Anthropic

Braintrust also integrates with frameworks like LangChain, LangGraph, AgentScope, CrewAI, LlamaIndex, Mastra, Eve, and OpenTelemetry. Many Python frameworks can be auto-instrumented directly with braintrust.auto_instrument(), while others still require framework-specific setup. See Integrations.

Next steps

Trace application logic to trace non-LLM code like data retrieval, tool calls, and business logic
Advanced tracing for distributed tracing, custom rendering, and more
Explore integrations with AI providers, SDKs, and developer tools

​Auto-instrumentation

​Manual instrumentation

​Braintrust gateway

​Supported libraries

​Next steps

Auto-instrumentation

Manual instrumentation

Braintrust gateway

Supported libraries

Next steps