> ## Documentation Index
> Fetch the complete documentation index at: https://docs-v1.latitude.so/llms.txt
> Use this file to discover all available pages before exploring further.
# Anthropic
> Connect your Anthropic-powered application to Latitude Telemetry for feature-level observability and evaluations.
## Overview
This guide shows you how to integrate **Latitude Telemetry** into an existing application that uses the official **Anthropic SDK**.
After completing these steps:
* Every Anthropic call (e.g. `messages.create`) can be captured as a log in Latitude.
* Logs are grouped under a **prompt**, identified by a `path`, inside a Latitude **project**.
* You can inspect inputs/outputs, measure latency, and debug Anthropic-powered features from the Latitude dashboard.
You'll keep calling Anthropic exactly as you do today — Telemetry simply
observes and enriches those calls.
***
## Requirements
Before you start, make sure you have:
* A **Latitude account** and **API key**
* A **Latitude project ID**
* A Node.js or Python-based project that uses the **Anthropic SDK**
That's it — prompts do **not** need to be created ahead of time.
***
## Steps
Add the Latitude Telemetry package to your project:
```bash npm theme={null}
npm add @latitude-data/telemetry
```
```bash pnpm theme={null}
pnpm add @latitude-data/telemetry
```
```bash yarn theme={null}
yarn add @latitude-data/telemetry
```
```bash bun theme={null}
bun add @latitude-data/telemetry
```
```bash pip theme={null}
pip install latitude-telemetry
```
```bash uv theme={null}
uv add latitude-telemetry
```
```bash poetry theme={null}
poetry add latitude-telemetry
```
Initialize Latitude Telemetry and wrap the code that calls Anthropic using telemetry.capture.
```ts theme={null}
import { LatitudeTelemetry } from '@latitude-data/telemetry'
import Anthropic from '@anthropic-ai/sdk'
import * as AnthropicSDK from '@anthropic-ai/sdk'
const telemetry = new LatitudeTelemetry(
process.env.LATITUDE_API_KEY,
{ instrumentations: { anthropic: AnthropicSDK } }
)
export async function generateSupportReply(input: string) {
return telemetry.capture(
{
projectId: 123, // The ID of your project in Latitude
path: 'generate-support-reply', // Add a path to identify this prompt in Latitude
},
async () => {
const client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY })
const response = await client.messages.create({
model: 'claude-sonnet-4-20250514',
max_tokens: 1024,
messages: [{ role: 'user', content: input }],
})
return response.content[0].text
}
)
}
```
You can use the `capture` method as a decorator (recommended) or as a context manager:
```python Using decorator (recommended) theme={null}
import os
from anthropic import Anthropic
from latitude_telemetry import Telemetry, Instrumentors, TelemetryOptions
telemetry = Telemetry(
os.environ["LATITUDE_API_KEY"],
TelemetryOptions(instrumentors=[Instrumentors.Anthropic]),
)
@telemetry.capture(
project_id=123, # The ID of your project in Latitude
path="generate-support-reply", # Add a path to identify this prompt in Latitude
)
def generate_support_reply(input: str) -> str:
client = Anthropic()
response = client.messages.create(
model="claude-sonnet-4-20250514",
max_tokens=1024,
messages=[{"role": "user", "content": input}],
)
return response.content[0].text
```
```python Using context manager theme={null}
import os
from anthropic import Anthropic
from latitude_telemetry import Telemetry, Instrumentors, TelemetryOptions
telemetry = Telemetry(
os.environ["LATITUDE_API_KEY"],
TelemetryOptions(instrumentors=[Instrumentors.Anthropic]),
)
def generate_support_reply(input: str) -> str:
with telemetry.capture(
project_id=123, # The ID of your project in Latitude
path="generate-support-reply", # Add a path to identify this prompt in Latitude
):
client = Anthropic()
response = client.messages.create(
model="claude-sonnet-4-20250514",
max_tokens=1024,
messages=[{"role": "user", "content": input}],
)
return response.content[0].text
```
The `path`:
* Identifies the prompt in Latitude
* Can be new or existing
* Should not contain spaces or special characters (use letters, numbers, `- _ / .`)
***
## Streaming responses
When using streaming, consume the stream inside your capture block so the span covers the entire operation.
**Consume the stream inside** your `capture()` callback:
```typescript theme={null}
async function streamSupportReply(input: string, res: Response) {
await telemetry.capture(
{ projectId: 123, path: 'generate-support-reply' },
async () => {
const client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY })
const stream = client.messages.stream({
model: 'claude-sonnet-4-20250514',
max_tokens: 1024,
messages: [{ role: 'user', content: input }],
})
for await (const event of stream) {
if (event.type === 'content_block_delta' && event.delta.type === 'text_delta') {
res.write(event.delta.text)
}
}
res.end()
}
)
}
```
**Use a generator function** with the decorator:
```python theme={null}
@telemetry.capture(project_id=123, path="generate-support-reply")
async def stream_support_reply(input: str):
client = Anthropic()
with client.messages.stream(
model="claude-sonnet-4-20250514",
max_tokens=1024,
messages=[{"role": "user", "content": input}],
) as stream:
for text in stream.text_stream:
yield text
```
***
## Seeing your logs in Latitude
Once your feature is wrapped, logs will appear automatically.
1. Open the **prompt** in your Latitude dashboard (identified by `path`)
2. Go to the **Traces** section
3. Each execution will show:
* Input and output messages
* Model and token usage
* Latency and errors
* One trace per feature invocation
Each Anthropic call appears as a child span under the captured prompt execution, giving you a full, end-to-end view of what happened.
***
## That's it
No changes to your Anthropic calls, no special return values, and no extra plumbing — just wrap the feature you want to observe.