> ## Documentation Index
> Fetch the complete documentation index at: https://docs.fiddler.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Agentic AI Overview

> Native SDKs and framework integrations for agentic AI and LLM applications

Monitor and evaluate your agentic AI applications with Fiddler's native SDKs and framework integrations. From auto-instrumented LangGraph agents to Strands agent applications, Fiddler provides comprehensive observability for the next generation of AI systems.

## Why Agentic Observability Matters

Agentic AI systems—autonomous agents that reason, plan, and coordinate—introduce exponential complexity compared to traditional AI applications:

* **[26x more monitoring resources](https://www.capgemini.com/insights/expert-perspectives/ai-lab-the-efficient-use-of-tokens-for-multi-agent-systems/)** required than single-agent systems
* **Non-deterministic behavior** makes traditional debugging approaches inadequate
* **Multi-step workflows** require hierarchical tracing across agents, tools, and LLM calls
* **Cascading failures** demand root cause analysis across distributed agent architectures

Fiddler's agentic observability provides visibility into every stage of the agent lifecycle: Thought → Action → Execution → Reflection → Alignment.

## Native SDKs

Fiddler-built and maintained instrumentation libraries for production-grade agentic observability.

### Fiddler OTel SDK

Core OpenTelemetry instrumentation library for framework-agnostic GenAI observability. The foundation package that all other Fiddler integrations build on.

**Best for:** Custom Python agents with no framework dependency, or any application where you want lightweight, decorator-based instrumentation

**Key Features:**

* `@trace` decorator for zero-boilerplate function instrumentation (sync and async)
* Typed span wrappers: `FiddlerGeneration`, `FiddlerTool`, `FiddlerChain`
* Context isolation — does not interfere with any existing OpenTelemetry setup
* `set_conversation_id()` for multi-turn conversation tracking
* JSONL local capture and console tracing for development

[**Get Started with Fiddler OTel SDK →**](/integrations/agentic-ai/fiddler-otel-sdk)

### Fiddler LangChain SDK

Auto-instrumentation for LangChain V1 agents built with `langchain.agents.create_agent`.

**Best for:** LangChain V1 agents that use the `create_agent` API

**Key Features:**

* One call to `FiddlerLangChainInstrumentor.instrument()` auto-traces all agents
* Clean, flat trace hierarchy: agent → LLM calls → tool calls, no noisy Chain wrappers
* Full async support via `agent.ainvoke()`
* Single-trace multi-agent nesting — sub-agents nest under delegation tool spans automatically
* Retriever-as-tool support

[**Get Started with Fiddler LangChain SDK →**](/integrations/agentic-ai/langchain-sdk)

### Fiddler LangGraph SDK

Auto-instrument LangGraph applications with OpenTelemetry-based tracing.

**Best for:** LangChain LangGraph agent applications with complex multi-agent workflows

**Key Features:**

* Automatic span creation for agent steps, tool calls, and LLM requests
* Hierarchical tracing across Application → Session → Agent → Span levels
* Zero-configuration setup with one environment variable
* Full context preservation for debugging non-deterministic behavior

[**Get Started with LangGraph SDK →**](/integrations/agentic-ai/langgraph-sdk)

### Strands Agents SDK

Native integration for Strands Agents applications.

**Best for:** Teams building agents with the Strands framework

**Key Features:**

* Purpose-built for Strands agent architecture
* Seamless integration with Strands agent runtime
* Multi-agent coordination tracking
* Platform-agnostic deployment (works on AWS, custom infrastructure, etc.)

[**Get Started with Strands Agents SDK →**](/integrations/agentic-ai/strands-sdk)

### Google ADK SDK

Native integration for Google ADK (Agent Development Kit) applications.

**Best for:** Teams building agents with Google's ADK framework and Gemini models

**Key Features:**

* Two-line setup with `FiddlerClient` + `GoogleADKInstrumentor`
* Works with Gemini API keys and Vertex AI authentication
* Automatic capture of agent, LLM, and tool spans
* Session identity propagation across multi-turn conversations
* No monkey-patching -- pure OpenTelemetry SpanProcessor approach

[**Get Started with Google ADK SDK →**](/integrations/agentic-ai/google-adk-sdk)

### Claude Code Integration

Zero-instrumentation integration for teams using [Claude Code](https://docs.anthropic.com/en/docs/claude-code/overview) — Anthropic's CLI coding agent. Captures LLM calls, tool invocations, user prompts, token usage, and permission decisions via Claude Code's built-in OpenTelemetry tracing.

**Best for:** Teams deploying Claude Code for software engineering and wanting visibility into coding agent sessions, tool usage patterns, and safety compliance

**Key Features:**

* **Zero code changes** — Claude Code emits OTel traces natively; just set environment variables
* Captures user prompts, LLM call metadata (tokens, latency, model), and tool invocations
* Session correlation via `session.id` for multi-turn coding session replay
* Permission decision tracking (accept/deny) for tool invocations
* Compatible with Fiddler enrichment rules (Prompt Safety scoring on agent spans)

<Warning>
  Claude Code's OTel tracing is in **beta** and has limitations — LLM response content is not available in traces, and tool input/output requires `OTEL_LOG_TOOL_CONTENT=1`. See the integration guide for full details. To capture LLM responses, add the [Fiddler Claude Code Plugin](/integrations/agentic-ai/fiddler-claude-code-plugin).
</Warning>

[**Get Started with Claude Code Integration →**](/integrations/agentic-ai/claude-code-integration)

### Fiddler Evals SDK

LLM experiments framework with pre-built evaluators and custom eval support.

**Best for:** Offline evaluation of LLM applications and agentic workflows

**Key Features:**

* 14+ pre-built evaluators (faithfulness, toxicity, PII, coherence, etc.)
* Custom evaluator framework for domain-specific metrics
* Batch evaluation for datasets
* Integration with the Fiddler platform for tracking and comparison

[**Get Started with Evals SDK →**](/integrations/agentic-ai/evals-sdk)

## AI Gateways

Already routing LLM traffic through a third-party AI gateway? Fiddler plugs in at the proxy layer for observability and guardrail enforcement — **Kong AI Gateway**, **AgentGateway**, and **LiteLLM** — with no application code changes, and independently of the SDKs above. (This is distinct from the [Fiddler LLM Gateway](/reference/administration/llm-gateway), which manages Fiddler's own provider credentials.)

[**AI Gateway Integrations →**](/integrations/agentic-ai/ai-gateways) — category overview, capability comparison, and per-gateway setup links.

## Platform SDKs

Core API access for building custom integrations and monitoring workflows.

### Python Client SDK

Comprehensive Python client for all Fiddler platform capabilities.

**Best for:** Custom integrations, ML model monitoring, programmatic access to Fiddler features

**Key Features:**

* Full API coverage for ML and LLM monitoring
* Dataset uploads, model publishing, event ingestion
* Alert configuration, dashboard management
* Custom metrics and enrichments

[**Python Client Documentation →**](/sdk-api/python-client/connection)

### REST API

Complete HTTP API for language-agnostic platform access.

**Best for:** Non-Python environments, webhook integrations, custom tooling

[**REST API Reference →**](/sdk-api/rest-api)

## Advanced Integrations

### S3 Trace Ingestion

Ingest pre-generated OTLP trace files from Amazon S3 into Fiddler without modifying your application. The S3 connector automatically discovers, parses, and forwards trace files to the Fiddler platform.

**Key Features:**

* Automatic file discovery — no manual trigger required
* Supports both base64 and hex-encoded `traceId`/`spanId` fields
* IAM role-based authentication (cross-account supported)
* Per-file retry logic with status tracking via API
* Compatible with any OTLP JSON producer

[**Get Started with S3 Trace Ingestion →**](/integrations/agentic-ai/s3-trace-ingestion)

### OpenTelemetry Integration

Direct OTLP integration for custom agent frameworks and multi-framework environments.

**Best for:** Multi-framework environments, custom agentic frameworks, advanced users requiring full instrumentation control

**Key Features:**

* Vendor-neutral telemetry using OpenTelemetry standards
* Manual span creation for complete control over instrumentation
* Multi-framework support for custom and emerging agent frameworks
* Compatible with existing OpenTelemetry infrastructure
* Attribute mapping to Fiddler semantic conventions

<Info>
  **When to Use OpenTelemetry vs SDKs**

  Use OpenTelemetry integration for advanced use cases requiring manual control. For LangGraph and Strands applications, we recommend using the dedicated SDKs for easier setup and automatic instrumentation.
</Info>

[**Get Started with OpenTelemetry →**](/integrations/agentic-ai/opentelemetry-integration)

### Exporting OTel Traces to Fiddler

Client-side export path for shipping pre-existing OpenTelemetry traces to Fiddler from your own storage or pipeline — map span attributes to Fiddler's schema and POST to the `v1/traces` endpoint.

**Best for:** Replaying traces from a data warehouse, JSONL files, or a logging pipeline; custom export pipelines; batch backfill of historical trace data

[**Exporting OTel Traces to Fiddler →**](/integrations/agentic-ai/otel-trace-export)

## Framework Support

While Fiddler provides native SDKs for LangGraph and Strands, agentic applications can be monitored regardless of framework:

### Supported Frameworks & Tools

**AI Agent Frameworks:**

* **LangGraph** - Native SDK with auto-instrumentation ✓
* **LangChain V1** (`create_agent`) - Native SDK with auto-instrumentation ✓
* **Custom Python agents** - [Fiddler OTel SDK](/integrations/agentic-ai/fiddler-otel-sdk) with `@trace` decorator ✓
* **Other agentic frameworks** - [Fiddler OTel SDK](/integrations/agentic-ai/fiddler-otel-sdk) is the recommended path for any custom or unsupported framework

**LLM Provider SDKs:**

* **OpenAI SDK** - Track via Python Client or custom instrumentation
* **Anthropic SDK** - Monitor Claude API calls via Python Client
* **Strands Agents** - Native Strands Agents SDK ✓
* **LiteLLM SDK** - [Built-in OTel integration, no Fiddler package required](/integrations/agentic-ai/litellm-integration) ✓
* **Claude Code** - [Zero-instrumentation coding agent integration](/integrations/agentic-ai/claude-code-integration) ✓ — beta OTel tracing, limited content capture

**Gateways & Proxies:** (see [AI Gateway Integrations](/integrations/agentic-ai/ai-gateways) for the capability comparison)

* **Kong AI Gateway** - [Gateway-layer OTel export and guardrails](/integrations/agentic-ai/kong-integration) ✓
* **AgentGateway** - [Proxy-layer tracing, guardrails, and MCP tool tracing](/integrations/agentic-ai/agentgateway-integration) ✓
* **LiteLLM** - [SDK or proxy tracing and guardrails](/integrations/agentic-ai/litellm-integration) ✓

**Observability Standards:**

* **OpenTelemetry** - [Full OTLP support](/integrations/agentic-ai/opentelemetry-integration) for custom instrumentation
* **Custom Tracing** - Python Client API for framework-agnostic monitoring

## Integration Selector

Not sure which SDK to use? Here's a quick decision guide:

| Your Use Case | Recommended Integration | Why |
| - | - | - |
| LangGraph agent application | [**LangGraph SDK**](/integrations/agentic-ai/langgraph-sdk) | Auto-instrumentation, zero config, hierarchical tracing |
| LangChain V1 (`create_agent`) | [**LangChain SDK**](/integrations/agentic-ai/langchain-sdk) | One `instrument()` call, flat clean traces, full async |
| Custom Python agent, no framework | [**Fiddler OTel SDK**](/integrations/agentic-ai/fiddler-otel-sdk) | `@trace` decorator, typed span wrappers, context isolation |
| Strands Agents | **Strands Agents SDK** | Purpose-built for Strands framework |
| LLM experiment workflows | **Evals SDK** | Pre-built evaluators, batch processing, tracking |
| LiteLLM SDK (direct calls) | [**LiteLLM Integration**](/integrations/agentic-ai/litellm-integration) | One-line setup, no Fiddler package required, native OTel support |
| LiteLLM proxy / gateway | [**LiteLLM Integration**](/integrations/agentic-ai/litellm-integration) | Zero-code, auto-detects proxy traces, cost attribution |
| AgentGateway | [**AgentGateway Integration**](/integrations/agentic-ai/agentgateway-integration) | Zero code changes, proxy-layer LLM and MCP tool tracing, session grouping |
| Kong AI Gateway | [**Kong AI Gateway Integration**](/integrations/agentic-ai/kong-integration) | Zero code changes, gateway-layer OTel export, multi-provider |
| Guardrail enforcement at your gateway | [**AI Gateway Guardrails**](/integrations/agentic-ai/ai-gateways) | Block or redact PII and secrets inline (Kong, AgentGateway, LiteLLM) |
| Claude Code (coding agent) | [**Claude Code Integration**](/integrations/agentic-ai/claude-code-integration) | Zero code changes, session replay, prompt safety enrichment (beta, limited content) |
| Claude Code with LLM response capture | [**Fiddler Claude Code Plugin**](/integrations/agentic-ai/fiddler-claude-code-plugin) | Per-turn traces with LLM responses, tool input/output, and token usage; fails open |
| Multi-framework / raw OTel | [**OpenTelemetry Integration**](/integrations/agentic-ai/opentelemetry-integration) | Standards-based manual tracing, multi-framework environments |
| ECS Fargate / air-gapped / S3 batch | [**S3 Trace Ingestion**](/integrations/agentic-ai/s3-trace-ingestion) | No direct connection needed, file-based async ingestion |
| Pre-existing OTel traces to replay | [**Exporting OTel Traces**](/integrations/agentic-ai/otel-trace-export) | Client-side attribute mapping + batch export to `v1/traces` |
| Traditional ML monitoring | **Python Client** | ML-specific features, drift detection, explainability |

## Getting Started

### Quick Start Paths

1. **Custom Python Agents (Fiddler OTel SDK)**

   ```bash theme={null}
   pip install fiddler-otel
   ```

   ```python theme={null}
   from fiddler_otel import FiddlerClient, trace

   client = FiddlerClient(api_key="...", application_id="...", url="...")

   @trace(as_type="generation")
   def call_llm(prompt: str) -> str:
       ...
   ```

   [Full Fiddler OTel SDK Guide →](/integrations/agentic-ai/fiddler-otel-sdk)

2. **LangChain V1 Applications**

   ```bash theme={null}
   pip install fiddler-langchain
   ```

   ```python theme={null}
   from fiddler_otel import FiddlerClient
   from fiddler_langchain import FiddlerLangChainInstrumentor
   import langchain.agents

   client = FiddlerClient(api_key="...", application_id="...", url="...")
   FiddlerLangChainInstrumentor(client=client).instrument()
   # All create_agent() calls are now traced automatically
   ```

   [Full LangChain SDK Guide →](/integrations/agentic-ai/langchain-sdk)

3. **LangGraph Applications**

   ```bash theme={null}
   pip install fiddler-langgraph
   ```

   ```python theme={null}
   from fiddler_langgraph import FiddlerClient, LangGraphInstrumentor

   client = FiddlerClient(api_key="...", application_id="...", url="...")
   LangGraphInstrumentor(client).instrument()
   ```

   [Full LangGraph Quick Start →](/integrations/agentic-ai/langgraph-sdk)

4. **Strands Agents**

   ```bash theme={null}
   pip install fiddler-strands
   # Configure for your Strands Agent
   ```

   [Full Strands Agents SDK Quick Start →](/integrations/agentic-ai/strands-sdk)

5. **LLM Experiments**

   ```bash theme={null}
   pip install fiddler-evals
   # Run experiments on your dataset
   ```

   [Full Evals Quick Start →](/integrations/agentic-ai/evals-sdk)

6. **LiteLLM SDK**

   ```bash theme={null}
   export OTEL_EXPORTER_OTLP_ENDPOINT="https://your-fiddler-instance.com"
   export OTEL_EXPORTER_OTLP_HEADERS="authorization=Bearer <token>,fiddler-application-id=<app-uuid>"
   export OTEL_RESOURCE_ATTRIBUTES="application.id=<app-uuid>"
   ```

   ```python theme={null}
   import litellm
   litellm.callbacks = ["otel"]  # Traces flow to Fiddler automatically
   ```

   [Full LiteLLM SDK Quick Start →](/integrations/agentic-ai/litellm-integration#litellm-sdk-integration)

7. **LiteLLM Proxy**

   ```bash theme={null}
   export OTEL_EXPORTER_OTLP_ENDPOINT="https://your-fiddler-instance.com"
   export OTEL_EXPORTER_OTLP_HEADERS="authorization=Bearer <token>,fiddler-application-id=<app-uuid>"
   export OTEL_RESOURCE_ATTRIBUTES="application.id=<app-uuid>"
   litellm --config config.yaml  # Traces flow to Fiddler automatically
   ```

   [Full LiteLLM Proxy Quick Start →](/integrations/agentic-ai/litellm-integration#litellm-proxy-integration)

8. **AI Gateways (Kong, AgentGateway, LiteLLM)**

   Route LLM traffic through a gateway you already run instead of instrumenting application code. See [AI Gateway Integrations →](/integrations/agentic-ai/ai-gateways) for setup and a capability comparison.

9. **Raw OpenTelemetry (Advanced)**

   ```bash theme={null}
   pip install opentelemetry-api opentelemetry-sdk opentelemetry-exporter-otlp-proto-http
   # Configure OTLP endpoint and instrument your agent
   ```

   [Full OpenTelemetry Quick Start →](/developers/quick-starts/opentelemetry-quick-start)

## What's Next?

* [**Span and Resource Attributes**](/integrations/agentic-ai/attributes) - Understand required fields, value typing, custom attributes, and how they flow into metrics and alerts
* [**Agentic Observability Concepts**](/glossary/agentic-observability) - Understand the agent lifecycle and monitoring approach
* [**Agentic Observability Quick Start**](/getting-started/agentic-monitoring) - Complete setup guide
* [**Centor Models Overview**](/glossary/centor-models) - Learn about the evaluation platform powering Fiddler