Metadata-Version: 2.5
Name: openinference-instrumentation-anthropic
Version: 3.3.0
Summary: OpenInference Anthropic Instrumentation
Project-URL: Homepage, https://github.com/Arize-ai/openinference/tree/main/python/instrumentation/openinference-instrumentation-anthropic
Author-email: OpenInference Authors <oss@arize.com>
License-Expression: Apache-2.0
License-File: LICENSE
Classifier: Development Status :: 5 - Production/Stable
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: Apache Software License
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Programming Language :: Python :: 3.13
Classifier: Programming Language :: Python :: 3.14
Classifier: Programming Language :: Python :: 3.15
Requires-Python: <3.16,>=3.10
Requires-Dist: openinference-instrumentation>=0.1.71
Requires-Dist: openinference-semantic-conventions>=0.1.42
Requires-Dist: opentelemetry-api
Requires-Dist: opentelemetry-instrumentation
Requires-Dist: opentelemetry-semantic-conventions
Requires-Dist: typing-extensions
Requires-Dist: wrapt
Provides-Extra: instruments
Requires-Dist: anthropic>=1.8.0; extra == 'instruments'
Description-Content-Type: text/markdown

# OpenInference Anthropic Instrumentation

Python autoinstrumentation library for the [Anthropic](https://www.anthropic.com/api) package

This package implements the following Anthropic clients:
- `Messages` (`create`, `stream`, `parse`, `count_tokens`)
- `AsyncMessages`
- Beta `Messages` and `AsyncMessages`, including those of the Bedrock and Vertex AI clients

`llm.provider` is the platform hosting the model: `aws` for Bedrock, `google` for Vertex AI,
`azure` for Microsoft Foundry, and `anthropic` otherwise.

These traces are fully OpenTelemetry compatible and can be sent to an OpenTelemetry collector for viewing, such as [Arize Phoenix](https://github.com/Arize-ai/phoenix) or [Arize AX](https://arize.com/products/ax?utm_source=docs&utm_medium=web&utm_content=openinference).

## Compatibility

| `openinference-instrumentation-anthropic`  | `anthropic`       | Python          |
| ------------------------------------------ | ----------------- | --------------- |
| `>=3.2.0`                                  | `>=1.8.0`         | `>=3.10, <3.16` |
| `>=3.0.0, <3.2.0`                          | `>=1.8.0`         | `>=3.10, <3.15` |
| `>=2.1.6, <3.0.0`                         | `>=1.0.0`         | `>=3.10, <3.15` |
| `2.1.5`                                    | `>=1.0.0, <1.8`   | `>=3.10, <3.15` |
| `>=2.0, <2.1.5`                            | `>=1.0.0, <1.5`   | `>=3.10, <3.15` |
| `>=1.0.1, <2.0`                            | `>=0.84.0, <1.0`  | `>=3.10, <3.15` |
| `1.0.0`                                    | `>=0.84.0, <1.0`  | `>=3.9, <3.15`  |

Anthropic 1.0 removed the legacy Text Completions API. Instrumentor 2.0 therefore
requires `anthropic>=1.0.0` and instruments the Messages and Beta Messages APIs.
See Anthropic's [v1 migration guide](https://github.com/anthropics/anthropic-sdk-python/blob/main/MIGRATION.md)
for the upstream breaking changes.

### Spans of the Anthropic SDK

`anthropic>=1.14.0` creates an OpenTelemetry span of its own for each API call
(`anthropic.messages.create` and so on), unless it is turned off with
`open_telemetry=False` or `ANTHROPIC_OPEN_TELEMETRY=false`. For a call that this
instrumentor traces, the SDK's span is replaced by the OpenInference LLM span: the SDK
records no span, its request carries the LLM span's trace context, and HTTP spans are
children of the LLM span. Calls that this instrumentor does not trace, such as
`models.list()`, keep the SDK's span.

## Installation

```shell
pip install openinference-instrumentation-anthropic
```

## Quickstart

Through your *terminal*, install required packages.

```shell
pip install openinference-instrumentation-anthropic anthropic arize-phoenix opentelemetry-sdk opentelemetry-exporter-otlp
```

You can start Phoenix with the following terminal command:
```shell
python -m phoenix.server.main serve
````
By default, Phoenix listens on `http://localhost:6006`. You can visit the app via a browser at the same address. (Phoenix does not send data over the internet. It only operates locally on your machine.)


Try the following code in a *Python file*.

1. Set up `AnthropicInstrumentor` to trace your application and sends the traces to Phoenix. 
2. Then, set your Anthropic API key as an environment variable. 
3. Lastly, create a Anthropic client, make a request, then go see your results in Phoenix at `http://localhost:6006`!

```python
import os
from anthropic import Anthropic
from openinference.instrumentation.anthropic import AnthropicInstrumentor
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk import trace as trace_sdk
from opentelemetry.sdk.trace.export import SimpleSpanProcessor

# Configure AnthropicInstrumentor with Phoenix endpoint
endpoint = "http://127.0.0.1:6006/v1/traces"
tracer_provider = trace_sdk.TracerProvider()
tracer_provider.add_span_processor(SimpleSpanProcessor(OTLPSpanExporter(endpoint)))

AnthropicInstrumentor().instrument(tracer_provider=tracer_provider)

os.environ["ANTHROPIC_API_KEY"] = "YOUR_KEY_HERE"

client = Anthropic()

response = client.messages.create(
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": "Tell me about the history of Iceland!",
        }
    ],
    model="claude-3-opus-20240229",
)
print(response)
```

Now, on the Phoenix UI on your browser, you should see the traces from your Anthropic application. Click on a trace, then the "Attributes" tab will provide you with in-depth information regarding execution!

## More Info

* [More info on OpenInference and Phoenix](https://docs.arize.com/phoenix)
* [More info on OpenInference and Arize AX](https://arize.com/products/ax?utm_source=docs&utm_medium=web&utm_content=openinference)
* [How to customize spans to track sessions, metadata, etc.](https://github.com/Arize-ai/openinference/tree/main/python/openinference-instrumentation#customizing-spans)
* [How to account for private information and span payload customization](https://github.com/Arize-ai/openinference/tree/main/python/openinference-instrumentation#tracing-configuration)
