# AI Observability: Monitor & Trace Agents and LLMs

> Monitor and trace AI agents, LLM calls, and tool executions in production. Catch errors, latency, token costs, and budget overruns with agent tracing and full trace context

**URL:** https://sentry.io/solutions/ai-observability/

---

Agents, LLMs, vector stores, custom logic: visibility can’t stop at the model call.

Trace every agent run end to end and get the context you need to debug failures, optimize performance, and keep AI features reliable.

## Supported SDKs

- Vercel AI — [Docs](https://docs.sentry.io/platforms/javascript/guides/node/agent-tracing/vercelai/)

- OpenAI — [Docs](https://docs.sentry.io/platforms/python/agent-tracing/openai/)

- OpenAI Agents — [Docs](https://docs.sentry.io/platforms/python/agent-tracing/openai-agents/)

- Anthropic — [Docs](https://docs.sentry.io/platforms/python/agent-tracing/anthropic/)

- Google Gen AI — [Docs](https://docs.sentry.io/platforms/python/agent-tracing/google-genai/)

- LangChain — [Docs](https://docs.sentry.io/platforms/python/agent-tracing/langchain/)

- LangGraph — [Docs](https://docs.sentry.io/platforms/python/agent-tracing/langgraph/)

- Mastra — [Docs](https://docs.sentry.io/platforms/javascript/guides/node/agent-tracing/mastra/)

- Pydantic AI — [Docs](https://docs.sentry.io/platforms/python/agent-tracing/pydantic-ai/)

- LiteLLM — [Docs](https://docs.sentry.io/platforms/python/agent-tracing/litellm/)

- Hugging Face — [Docs](https://docs.sentry.io/platforms/python/agent-tracing/huggingface_hub/)

- Workers AI — [Docs](https://docs.sentry.io/platforms/javascript/guides/cloudflare/agent-tracing/workers-ai/)

- Cloudflare Agents — [Docs](https://docs.sentry.io/platforms/javascript/guides/cloudflare/agent-tracing/agents-sdk/)

- Eve — [Docs](https://docs.sentry.io/platforms/javascript/guides/eve/)

- Flue — [Docs](https://docs.sentry.io/platforms/javascript/guides/node/agent-tracing/flue/)

- Laravel AI — [Docs](https://docs.sentry.io/platforms/php/guides/laravel/agent-tracing/)

## Details

### Full LLM Observability

#### See everything on one pane of glass

Track all agent runs, error rates, LLM calls, tokens used, and tool executions. Monitor traffic patterns and duration metrics across your AI-powered features.

### Track Model Costs & Tokens

#### Monitor spending across models.

Compare costs across different models. See token usage breakdown by model, track input vs output tokens, and identify expensive operations.

### Agent tracing, end to end

#### Trace every agent run, end to end.

AI agents fail across a chain of steps, not a single line of code. [Agent tracing](https://sentry.io/product/tracing/ai-agent/) stitches every LLM call, tool execution, and handoff into one connected trace, with full prompt and response context, token counts, cost, and timing on every span. Follow the trace to the exact tool or step that went wrong, and apply agent tracing best practices to keep runs reliable as they scale.

## Cookbook recipes

### Monitor your AI agent costs and calls in Next.js

Add Sentry's Vercel AI integration to your Next.js app to track LLM token usage, per-model costs, tool calls, and agent traces with full-stack trace context.

### Monitor your MCP server with Sentry

Add monitoring to your own Node.js or Python MCP server with one line of code. Track clients, transports, tool performance, error rates, and trace each request.

### Monitor Claude Code usage and costs with Sentry

Track Claude Code token usage, API costs, and tool activity with Sentry AI Observability. Set up OpenTelemetry-based observability for your Claude Code sessions in minutes.

### Monitor your OpenCode sessions with Sentry

Add Sentry AI observability to OpenCode in minutes. Track tool calls, token usage, model costs, and session durations across every coding session.

### Monitor your pi coding agent sessions with Sentry

Add Sentry AI observability to pi in minutes. Track tool calls, LLM calls, token usage, and model costs across every pi coding session.

### Use production AI agent conversations in your evals

Export real AI agent conversations from Sentry with the CLI or MCP server and turn them into eval datasets in Braintrust, Langfuse, promptfoo, or Phoenix.

### Send Vercel AI SDK telemetry to Sentry via OpenTelemetry

Keep your existing Vercel AI SDK and OpenTelemetry setup, and route LLM spans to Sentry's AI Agents Insights without ripping out @vercel/otel.

### Automate daily AI agent error triage with Claude Routines and Sentry

Set up a Claude Routine that uses Sentry Agent Tracing via MCP to automatically triage your AI agent's overnight errors, sample conversations, and file tickets

### Install the Sentry plugin in your coding agent

Install the Sentry plugin in Claude Code, Cursor, Codex, or Grok with one command, then use prompts for setup, debugging, monitoring, and code review.

### Instrument Flue agents with Sentry

Add Sentry to a Flue agent. Trace model calls and tools, correlate logs, and capture terminal agent failures as Sentry Issues.

### Instrument Eve agents with Sentry

Instrument an Eve agent with Sentry and inspect its conversations, model calls, tool executions, tokens, and latency.

### Monitor AI agent spend with dashboards and alerts

Build a Sentry dashboard with the CLI for AI agent cost, tokens, top spenders, and models, then add static and anomaly detectors that alert when hourly spend spikes.

## AI observability FAQ

**What is AI observability?**

AI observability is the practice of understanding what your AI features are actually doing in production, across LLM calls, agent runs, tool executions, and the application code around them. Instead of treating the model as a black box, it connects prompts, responses, token usage, latency, errors, and cost to the rest of your application's [traces](https://sentry.io/product/tracing/) and logs, so you can debug failures down to the specific call that caused them.

**What is LLM observability, and how is it different from AI observability?**

LLM observability focuses specifically on the behavior of large language model calls: prompts, completions, token counts, model latency, and cost. AI observability is broader: it covers LLM calls plus the agents, tools, retrieval steps, and custom logic that wrap them. In practice you want both, which is why Sentry tracks individual LLM calls and stitches them into full [agent traces](https://sentry.io/product/tracing/) in one place.

**What's the difference between AI monitoring and AI observability?**

AI monitoring tells you that something is wrong: an error spiked, a model got slow, costs jumped. AI observability helps you understand why, by giving you the connected traces, prompts, responses, and code context behind the signal. Sentry does both: real-time alerts when something breaks, plus the [debuggability](https://blog.sentry.io/monitoring-observability-and-debuggability-explained/) to trace it to a root cause.

**What is agent tracing?**

Agent tracing follows a single AI agent run from start to finish as a connected trace, capturing every LLM call, tool execution, and handoff as a span with its inputs, outputs, token counts, cost, and timing. Because AI agents make decisions across many steps, a flat log isn't enough; agent tracing shows you the full execution path so you can see exactly which step failed or stalled. [See how agent tracing works in Sentry](https://docs.sentry.io/product/agents/).

**How do I get observability for AI agents?**

Add the Sentry SDK and the integration for your agent framework: OpenAI Agents, Vercel AI SDK, LangChain, LangGraph, Anthropic, Google Gen AI, and more. Sentry auto-instruments agent runs and captures `invoke_agent`, `execute_tool`, and handoff spans, so you get full AI agent observability and tracing without rewriting your agent logic.

**Can I monitor and trace MCP servers?**

Yes. Sentry gives you [observability for Model Context Protocol (MCP) servers](https://sentry.io/resources/mcp-observability/): tracking tool calls, errors, latency, and usage, and connecting them into the same traces as the agents and LLMs that call them. See the [guide to monitoring an MCP server](https://sentry.io/cookbook/monitor-mcp-server/) to get started.

**Is AI observability included in Sentry's free plan?**

Yes. AI agent and LLM observability is available on every Sentry plan, including the free Developer plan: full tracing, token and cost tracking, and tool-execution monitoring out of the box. [See pricing details](https://sentry.io/pricing/).

## Customer Story

> Sentry played a significant role in helping us develop [Claude] Sonnet

[Read the full story](https://sentry.io/customers/anthropic/)

- **10-15%** increase in developer productivity

- **600+** engineers rely on Sentry to ship code

- **20-30%** faster incident resolution

## Quick Start

### Python

Install the Sentry Python SDK with pip

```bash
pip install sentry-sdk
```

Configuration should happen as early as possible in your application's lifecycle.

```python
import sentry_sdk

sentry_sdk.init(
  dsn="https://examplePublicKey@o0.ingest.sentry.io/0",
  # Add data like request headers and IP for users, if applicable;
  # see https://docs.sentry.io/platforms/python/data-management/data-collected/ for more info
  send_default_pii=True,
  # Set traces_sample_rate to 1.0 to capture 100%
  # of transactions for tracing.
  traces_sample_rate=1.0,
  #Enable logs to be sent to Sentry
  enable_logs=True,
  # To collect profiles for all profile sessions,
  # set profile_session_sample_rate to 1.0.
  profile_session_sample_rate=1.0,
  # Profiles will be automatically collected while
  # there is an active span.
  profile_lifecycle="trace",
)
```

### JavaScript

Install the Sentry JavaScript SDK with npm

```bash
npm install @sentry/browser --save
```

Configuration should happen as early as possible in your application's lifecycle.

```javascript
import * as Sentry from "@sentry/browser";

Sentry.init({
  dsn: "https://examplePublicKey@o0.ingest.sentry.io/0",
  // Adds request headers and IP for users, for more info visit:
  // https://docs.sentry.io/platforms/javascript/configuration/options/#sendDefaultPii
  sendDefaultPii: true,
  // Set tracesSampleRate to 1.0 to capture 100%
  // of transactions for tracing.
  tracesSampleRate: 1.0,
  // Set tracePropagationTargets to control for which URLs trace propagation should be enabled
  tracePropagationTargets: ["localhost", /^https:\/\/yourserver\.io\/api/],
  // Enable logs to be sent to Sentry
  enableLogs: true,
  // Set profilesSampleRate to 1.0 to profile every transaction.
  // Since profilesSampleRate is relative to tracesSampleRate,
  // the final profiling rate can be computed as tracesSampleRate * profilesSampleRate
  // For example, a tracesSampleRate of 0.5 and profilesSampleRate of 0.5 would
  // result in 25% of transactions being profiled (0.5*0.5=0.25)
  profilesSampleRate: 1.0,
  integrations: [
    Sentry.browserTracingIntegration(),
    Sentry.browserProfilingIntegration(),
  ],
});
```

### React

Run the command for your preferred package manager to add the Sentry SDK to your application:

```bash
npm install @sentry/react --save
```

To import and initialize Sentry, create a file in your project's root directory, for example, `instrument.js`, and add the following code:

```javascript
import * as Sentry from "@sentry/react";

Sentry.init({
  dsn: "https://examplePublicKey@o0.ingest.sentry.io/0",
  // Adds request headers and IP for users, for more info visit:
  // https://docs.sentry.io/platforms/javascript/guides/react/configuration/options/#sendDefaultPii
  sendDefaultPii: true,
  // Set tracesSampleRate to 1.0 to capture 100%
  // of transactions for tracing.
  // Learn more at
  // https://docs.sentry.io/platforms/javascript/configuration/options/#traces-sample-rate
  tracesSampleRate: 1.0,
  // Set `tracePropagationTargets` to control for which URLs trace propagation should be enabled
  tracePropagationTargets: [/^//, /^https://yourserver.io/api/],
  // Enable logs to be sent to Sentry
  enableLogs: true,
  // Set profilesSampleRate to 1.0 to profile every transaction.
  // Since profilesSampleRate is relative to tracesSampleRate,
  // the final profiling rate can be computed as tracesSampleRate * profilesSampleRate
  // For example, a tracesSampleRate of 0.5 and profilesSampleRate of 0.5 would
  // result in 25% of transactions being profiled (0.5*0.5=0.25)
  profilesSampleRate: 1.0,
  integrations: [
    // If you're using react router, use the integration for your react router version instead.
    // Learn more at
    // https://docs.sentry.io/platforms/javascript/guides/react/features/react-router/
    Sentry.browserTracingIntegration(),
    Sentry.browserProfilingIntegration(),
  ],
});
```

Initialize Sentry as early as possible in your application. We recommend putting the import of your initialization code as the first import in your app's entry point:

```javascript
// Sentry initialization should be imported first!
import "./instrument";
import App from "./App";
import { createRoot } from "react-dom/client";

const container = document.getElementById("app");
const root = createRoot(container);
root.render(<App />);
```

To make sure Sentry captures all your app's errors, configure error handling based on your React version. 
 For React versions 19 and up:  

```javascript
import { createRoot } from "react-dom/client";
import * as Sentry from '@sentry/react';

const container = document.getElementById("app");
const root = createRoot(container, {
  // Callback called when an error is thrown and not caught by an ErrorBoundary.
  onUncaughtError: Sentry.reactErrorHandler((error, errorInfo) => {
    console.warn('Uncaught error', error, errorInfo.componentStack);
  }),
  // Callback called when React catches an error in an ErrorBoundary.
  onCaughtError: Sentry.reactErrorHandler(),
  // Callback called when React automatically recovers from errors.
  onRecoverableError: Sentry.reactErrorHandler(),
});
root.render();
```

For React versions 18 and below, use the ErrorBoundary component to automatically send errors from specific component trees to Sentry and provide a fallback UI:

```javascript
import React from "react";
import * as Sentry from "@sentry/react";

<Sentry.ErrorBoundary fallback={<p>An error has occurred</p>}>
  <Example />
</Sentry.ErrorBoundary>;
```

### Next.js

To install Sentry using the installation wizard, run thrun the following command and step through the prompts:

```bash
npx @sentry/wizard@latest -i nextjs
```

For manual installation run the following command and use the following configurations:

```bash
npm install @sentry/nextjs --save
```

Extend your app's default Next.js options by adding code with `withSentryConfig` into your `next.config.(js|mjs)` file:

```javascript
const { withSentryConfig } = require("@sentry/nextjs");
const nextConfig = {
  // Your existing Next.js configuration
};
// Make sure adding Sentry options is the last code to run before exporting
module.exports = withSentryConfig(nextConfig, {
  org: "example-org",
  project: "example-project",
  // Only print logs for uploading source maps in CI
  // Set to `true` to suppress logs
  silent: !process.env.CI,
  // Automatically tree-shake Sentry logger statements to reduce bundle size
  disableLogger: true,
});
```

#### Client-Side Configuration

```javascript
import * as Sentry from "@sentry/nextjs";
Sentry.init({
  dsn: "https://examplePublicKey@o0.ingest.sentry.io/0",
  // Adds request headers and IP for users, for more info visit:
  // https://docs.sentry.io/platforms/javascript/guides/nextjs/configuration/options/#sendDefaultPii
  sendDefaultPii: true,
  // Set tracesSampleRate to 1.0 to capture 100%
  // of transactions for tracing.
  // We recommend adjusting this value in production
  // Learn more at
  // https://docs.sentry.io/platforms/javascript/configuration/options/#traces-sample-rate
  tracesSampleRate: 1.0,
  // Enable logs to be sent to Sentry
  enableLogs: true,
  // Set profilesSampleRate to 1.0 to profile every transaction.
  // Since profilesSampleRate is relative to tracesSampleRate,
  // the final profiling rate can be computed as tracesSampleRate * profilesSampleRate
  // For example, a tracesSampleRate of 0.5 and profilesSampleRate of 0.5 would
  // result in 25% of transactions being profiled (0.5*0.5=0.25)
  profilesSampleRate: 1.0,
});

// This export will instrument router navigations, and is only relevant if you enable tracing.
// `captureRouterTransitionStart` is available from SDK version 9.12.0 onwards
export const onRouterTransitionStart = Sentry.captureRouterTransitionStart;
```

#### Server-Side Configuration

```javascript
import * as Sentry from "@sentry/nextjs";
Sentry.init({
  dsn: "https://examplePublicKey@o0.ingest.sentry.io/0",
  // Adds request headers and IP for users, for more info visit:
  // https://docs.sentry.io/platforms/javascript/guides/nextjs/configuration/options/#sendDefaultPii
  sendDefaultPii: true,
  // Set tracesSampleRate to 1.0 to capture 100%
  // of transactions for tracing.
  // We recommend adjusting this value in production
  // Learn more at
  // https://docs.sentry.io/platforms/javascript/configuration/options/#traces-sample-rate
  tracesSampleRate: 1.0,
  // Enable logs to be sent to Sentry
  enableLogs: true,
});
```

#### Register Sentry Server-Side SDK Initialization

Create a Next.js Instrumentation file named `instrumentation.(js|ts)` in your project root or inside the `src` folder if you have one. Import your server and edge configurations, making sure that the imports point to your specific files:

```javascript
export async function register() {
  if (process.env.NEXT_RUNTIME === "nodejs") {
    await import("./sentry.server.config");
  }
  if (process.env.NEXT_RUNTIME === "edge") {
    await import("./sentry.edge.config");
  }
}
```

### Go

Grab the Sentry Go SDK:

```bash
go get "github.com/getsentry/sentry-go"
```

Configuration should happen as early as possible in your application's lifecycle.

```text
err := sentry.Init(sentry.ClientOptions{
  Dsn: "https://examplePublicKey@o0.ingest.sentry.io/0",
  // Enable printing of SDK debug messages.
  // Useful when getting started or trying to figure something out.
  Debug: true,
  // Adds request headers and IP for users,
  // visit: https://docs.sentry.io/platforms/go/data-management/data-collected/ for more info
  SendDefaultPII: true,
  EnableTracing: true,
  // Set TracesSampleRate to 1.0 to capture 100%
  // of transactions for tracing.
  TracesSampleRate: 1.0,
})
if err != nil {
  log.Fatalf("sentry.Init: %s", err)
}
// Flush buffered events before the program terminates.
// Set the timeout to the maximum duration the program can afford to wait.
defer sentry.Flush(2 * time.Second)
```

### Ruby

Add the sentry-ruby gem to your Gemfile:

```ruby
gem "sentry-ruby"
```

Configuration should happen as early as possible in your application's lifecycle.

```ruby
require 'sentry-ruby'

Sentry.init do |config|
  config.dsn = 'https://examplePublicKey@o0.ingest.sentry.io/0'

  # get breadcrumbs from logs
  config.breadcrumbs_logger = [:sentry_logger, :http_logger]

  # Add data like request headers and IP for users, if applicable;
  # see https://docs.sentry.io/platforms/ruby/data-management/data-collected/ for more info
  config.send_default_pii = true
  # enable tracing
  # we recommend adjusting this value in production
  config.traces_sample_rate = 1.0
  # Enable logs to be sent to Sentry
  config.enable_logs = true
  # enable profiling
  # this is relative to traces_sample_rate
  config.profiles_sample_rate = 1.0
end
```

### PHP

Install the Sentry SDK using Composer:

```bash
composer require sentry/sentry
```

To use Profiling, you'll also need to install the Excimer extension via PECL:

```bash
pecl install excimer
```

To capture all errors, even the one during the startup of your application, you should initialize the Sentry PHP SDK as soon as possible.

```php
\Sentry\init([
  'dsn' => 'https://examplePublicKey@o0.ingest.sentry.io/0',
  // Add request headers, cookies and IP address,
  // see https://docs.sentry.io/platforms/php/data-management/data-collected/ for more info
  'send_default_pii' => true,
  // Specify a fixed sample rate
  'traces_sample_rate' => 1.0,
  // Enable logs to be sent to Sentry
  'enable_logs' => true,
  // Set a sampling rate for profiling - this is relative to traces_sample_rate
  'profiles_sample_rate' => 1.0,
]);
```

### .NET

Install the NuGet package to add the Sentry dependency:

```shell
dotnet add package Sentry -v 5.16.2
```

To use Profiling, you'll also need to install the Sentry.Profiling package:

```shell
dotnet add package Sentry.Profiling -v 5.16.2
```

To capture all errors, even the one during the startup of your application, you should initialize the Sentry .NET SDK as soon as possible.

```csharp
SentrySdk.Init(options =>
{
    options.Dsn = "https://examplePublicKey@o0.ingest.sentry.io/0";
    options.Debug = true;
    // Adds request URL and headers, IP and name for users, etc.
    options.SendDefaultPii = true;
    // A fixed sample rate of 1.0 - 100% of all transactions are getting sent
    options.TracesSampleRate = 1.0f;
    // A sample rate for profiling - this is relative to TracesSampleRate
    options.ProfilesSampleRate = 1.0f;
});
```

---

*Source: [sentry.io/solutions/ai-observability/](https://sentry.io/solutions/ai-observability/)*