semvec/pypi-packages huggingface dataset:
ati-integrations-autogpt 0.1.1
ATI Integration for AutoGPT
Requires Python: >=3.10

# ATI Integration for AutoGPT

This package provides OpenTelemetry instrumentation for AutoGPT-style agents using IOcane ATI.

## Installation

```bash
pip install ati-integrations-autogpt opentelemetry-sdk opentelemetry-exporter-otlp
```

## Configuration

Set the standard OpenTelemetry environment variables:

```bash
export OTEL_EXPORTER_OTLP_ENDPOINT="https://api.iocane.ai"
export OTEL_EXPORTER_OTLP_HEADERS="x-iocane-key=YOUR_KEY,x-ati-env=YOUR_ENV_ID"
export OTEL_SERVICE_NAME="my-autogpt-agent"
```

## Usage

```python
import os
from ati_autogpt import AutoGPTInstrumentor
from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter

# 1. Configure OpenTelemetry
provider = TracerProvider()
exporter = OTLPSpanExporter()
provider.add_span_processor(BatchSpanProcessor(exporter))
trace.set_tracer_provider(provider)

# 2. Instrument AutoGPT
instrumentor = AutoGPTInstrumentor()
instrumentor.instrument() # auto-detects Agent class

# 3. Run your Agent
# ...

# 4. Flush traces
provider.shutdown()
```

## Configuration

Configure the instrumentation via environment variables:

| Variable | Description | Default |
|----------|-------------|---------|
| `ATI_CAPTURE_PAYLOADS` | Capture step inputs | `false` |

## Features
- Captures Agent steps (`ati.span.type=step`)
- Identifies Loop Iterations
rest-rpc 0.1.3
A Python library that makes type-checked REST APIs easy
Requires Python: >=3.12

# REST-RPC

REST-RPC is a Python library that makes writing type-checked REST APIs easy (by allowing you to define your API once and use it on both the server and the client).

It automatically creates convenient front-end bindings to your API for you, so from the front-end developer's perspective it's indistinguishable from an RPC library, hence the name.

REST-RPC's type-checking is based on Pydantic. For the back-end, it used FastAPI. For the front-end, it supports `requests`, `urllib3`, `httpx`, and `aiohttp` (or provide your own transport layer). If you want to use REST-RPC in the webbrowser, you can: It supports `pyodide`'s `pyfetch` and `pyscript`'s `fetch`!
This means that the only "hard" dependency is `pydantic`. Of course, you'll need FastAPI in the back-end and one of the mentioned HTTP libraries for the front-end.

REST-RPC is for you, if you:
- …like FastAPI and Pydantic.
- …just want to write simple type-checked REST APIs without frills.
- …don't want to repeat yourself when writing the front-end code.

Visit the [GitHub page](https://github.com/felsenhower/rest-rpc) for more information.