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

# Installation

> Install the Aether Python SDK.

## Requirements

* Python `3.12` or newer
* An Aether **API key**, created from the Aether Dashboard for each Connected System

## Install

The SDK is not on PyPI. Install it from GitHub, pinned to a release tag.

> [tab] pip
>
> ```bash theme={null}
> pip install "aether-sdk @ git+https://github.com/Ai-by-DNA/aether-python-sdk.git@v0.5.4"
> ```

> [tab] uv
>
> ```bash theme={null}
> uv add "aether-sdk @ git+https://github.com/Ai-by-DNA/aether-python-sdk.git@v0.5.4"
> ```

The only runtime dependency is `httpx`.

> [!NOTE]
>
> The package is installed as `aether-sdk` and imported as `aether_sdk`.

## Configure credentials

Set your API key as an environment variable:

```bash theme={null}
export AETHER_API_KEY="<system_api_key>"
```

`AetherClient()` reads the API key. You can also pass it directly:

```python theme={null}
from aether_sdk import AetherClient

client = AetherClient(api_key="<system_api_key>")
```

If the key is missing, `AetherClient` raises `AetherConfigError`.

> [!WARNING]
>
> The API key is shown only once, when it is created. Keep it secret and never commit it to source control.

## Verify

```python theme={null}
import asyncio
from aether_sdk import AetherClient

print(asyncio.run(AetherClient().get_health()))
```

A response means the SDK is installed and can reach Aether.

## Multiple agents in one project

Each API key belongs to one Connected System. Aether identifies the caller from the key, so every agent needs its own key, even when several agents run in the same file or process.

Give each key its own environment variable, and pass it explicitly to one client per agent:

```bash theme={null}
export AETHER_API_KEY_PLANNER="<planner_api_key>"
export AETHER_API_KEY_RESEARCHER="<researcher_api_key>"
```

```python theme={null}
import os
from aether_sdk import AetherClient

planner = AetherClient(api_key=os.environ["AETHER_API_KEY_PLANNER"])
researcher = AetherClient(api_key=os.environ["AETHER_API_KEY_RESEARCHER"])
```

Each call uses its client's key, so Aether records it under the right system. The same applies to `wrap_node`: pass the key of the agent that owns the node.

> [!WARNING]
>
> Never share one key between agents. Aether would attribute every agent's events to a single system.

### Per-agent LLM usage

Automatic LLM usage recording reads `AETHER_API_KEY` once per process. If several agents share a process, all their LLM usage is recorded under that one system.

To record usage per agent, run each agent in its own process, with its own key set as `AETHER_API_KEY`:

```python theme={null}
import os
import subprocess

def run_agent(module: str, key_env: str) -> subprocess.Popen[bytes]:
    env = {**os.environ, "AETHER_API_KEY": os.environ[key_env]}
    return subprocess.Popen(["python", "-m", module], env=env)

run_agent("agents.planner", "AETHER_API_KEY_PLANNER")
run_agent("agents.researcher", "AETHER_API_KEY_RESEARCHER")
```

Each process then speaks for exactly one system: its Deltas and its LLM usage.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.