Metadata-Version: 2.4
Name: megflow-observability
Version: 0.4.1
Summary: Megflow AI API observability SDK — auto-instrument OpenAI, Anthropic, Gemini, AWS Bedrock and Cohere calls
License: MIT
Project-URL: Homepage, https://observability.megflow.com
Project-URL: Repository, https://github.com/saleem-megflow/megflow-observe
Keywords: llm,observability,openai,anthropic,monitoring
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Developers
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.8
Classifier: Programming Language :: Python :: 3.9
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Requires-Python: >=3.8
Description-Content-Type: text/markdown
Provides-Extra: openai
Requires-Dist: openai>=1.0.0; extra == "openai"
Provides-Extra: anthropic
Requires-Dist: anthropic>=0.20.0; extra == "anthropic"
Provides-Extra: gemini
Requires-Dist: google-generativeai>=0.5.0; extra == "gemini"
Provides-Extra: bedrock
Requires-Dist: boto3>=1.28.0; extra == "bedrock"
Provides-Extra: cohere
Requires-Dist: cohere>=5.0.0; extra == "cohere"
Provides-Extra: all
Requires-Dist: openai>=1.0.0; extra == "all"
Requires-Dist: anthropic>=0.20.0; extra == "all"
Requires-Dist: google-generativeai>=0.5.0; extra == "all"
Requires-Dist: boto3>=1.28.0; extra == "all"
Requires-Dist: cohere>=5.0.0; extra == "all"

# megflow-observability

Python SDK for [Megflow AI Observability](https://observability.megflow.com) — track tokens, cost, latency and errors across OpenAI, Anthropic, Gemini and more.

## Install

```bash
pip install megflow-observability
```

## Quick start

```python
from megflow_observability import MegflowObserve

observe = MegflowObserve(api_key="obs_your_key_here")

observe.track(
    provider="openai",
    model="gpt-4o",
    input_tokens=100,
    output_tokens=50,
    total_tokens=150,
    cost_usd=0.00075,
    latency_ms=320,
    status_code=200,
)
```

## Auto-instrument OpenAI

```python
from openai import OpenAI
from megflow_observability import MegflowObserve, wrap_openai

client = wrap_openai(OpenAI(), MegflowObserve(api_key="obs_your_key_here"))

# All calls are tracked automatically
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Hello"}],
)
```

## Auto-instrument Anthropic

```python
import anthropic
from megflow_observability import MegflowObserve, wrap_anthropic

client = wrap_anthropic(anthropic.Anthropic(), MegflowObserve(api_key="obs_your_key_here"))

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello"}],
)
```

## Auto-instrument Gemini

```python
import google.generativeai as genai
from megflow_observability import MegflowObserve, wrap_gemini

genai.configure(api_key="YOUR_GOOGLE_API_KEY")
observe = MegflowObserve(api_key="obs_your_key_here")

model = wrap_gemini(genai.GenerativeModel("gemini-2.0-flash"), observe)
response = model.generate_content("Hello")
```

## Auto-instrument AWS Bedrock

Works with Claude, Llama, Mistral, Titan and Cohere on Bedrock.

```python
import boto3
import json
from megflow_observability import MegflowObserve, wrap_bedrock

observe = MegflowObserve(api_key="obs_your_key_here")
client = wrap_bedrock(
    boto3.client("bedrock-runtime", region_name="us-east-1"),
    observe,
)

response = client.invoke_model(
    modelId="anthropic.claude-3-5-sonnet-20241022-v2:0",
    body=json.dumps({
        "anthropic_version": "bedrock-2023-05-31",
        "messages": [{"role": "user", "content": "Hello"}],
        "max_tokens": 1024,
    }),
)
result = json.loads(response["body"].read())
```

## Auto-instrument Cohere

Works with both `Client` (v1) and `ClientV2` (v2).

```python
import cohere
from megflow_observability import MegflowObserve, wrap_cohere

observe = MegflowObserve(api_key="obs_your_key_here")

# v2 API
co = wrap_cohere(cohere.ClientV2("COHERE_API_KEY"), observe)
response = co.chat(
    model="command-r-plus",
    messages=[{"role": "user", "content": "Hello"}],
)

# v1 API
co = wrap_cohere(cohere.Client("COHERE_API_KEY"), observe)
response = co.chat(model="command-r-plus", message="Hello")
```

## Optional dependencies

```bash
pip install megflow-observability[openai]      # includes openai
pip install megflow-observability[anthropic]   # includes anthropic
pip install megflow-observability[gemini]      # includes google-generativeai
pip install megflow-observability[all]         # includes all three
```

## Links

- Dashboard: [observability.megflow.com](https://observability.megflow.com)
- JS SDK: [npmjs.com/package/megflow-observability](https://www.npmjs.com/package/megflow-observability)
