> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/clore.ai/clore.ai-eng-de/entwickler/python-sdk.md).

# Python SDK (clore-ai)

Die **clore-ai** Paket ist das offizielle Python-SDK für die [Clore.ai](https://clore.ai) GPU-Marktplatz. Es kapselt die gesamte REST-API in eine saubere, typsichere Schnittstelle mit integrierter Ratenbegrenzung, automatischen Wiederholungsversuchen und strukturierter Fehlerbehandlung — damit du dich auf das Mieten von GPUs konzentrieren kannst und nicht auf HTTP-Details.

***

## Installation

```bash
pip install clore-ai
```

**Anforderungen:** Python 3.9+

Das Paket installiert sowohl das Python-SDK als auch den [`clore` CLI](https://docs.clore.ai/clore.ai/clore.ai-eng-de/entwickler/cli-guide.md).

***

## Authentifizierung

Hole dir deinen API-Schlüssel im [Clore.ai-Dashboard](https://clore.ai) → **API** Abschnitt.

### Option 1: Umgebungsvariable (empfohlen)

```bash
export CLORE_API_KEY=your_api_key_here
```

Das SDK liest `CLORE_API_KEY` automatisch — keine Codeänderungen erforderlich.

### Option 2: CLI-Konfigurationsdatei

```bash
clore config set api_key YOUR_API_KEY
```

Dies speichert den Schlüssel in `~/.clore/config.json`.

### Option 3: Direkt im Code übergeben

```python
from clore_ai import CloreAI

client = CloreAI(api_key="your_api_key_here")
```

> ⚠️ **Wichtig:** Die Clore.ai-API verwendet den `auth` Header zur Authentifizierung, **nicht** `Authorization: Bearer`. Das SDK übernimmt dies automatisch.

***

## Schnellstart

```python
from clore_ai import CloreAI

client = CloreAI()
servers = client.marketplace(gpu="RTX 4090", max_price_usd=5.0)
for s in servers:
    print(f"Server {s.id}: {s.gpu_model} — ${s.price_usd:.4f}/h")
```

***

## Synchroner Client (`CloreAI`)

### Konstruktor

```python
CloreAI(
    api_key: str | None = None,       # Fällt auf CLORE_API_KEY aus Umgebung/Konfiguration zurück
    base_url: str | None = None,       # Standard: https://api.clore.ai/v1
    timeout: float = 30.0,             # Anfrage-Timeout in Sekunden
    max_retries: int = 3               # Wiederholungsversuche bei Rate-Limit-/Netzwerkfehlern
)
```

Der Client unterstützt Kontextmanager für automatische Bereinigung:

```python
with CloreAI() as client:
    wallets = client.wallets()
    # client.close() wird automatisch aufgerufen
```

***

### `wallets()`

Rufe deine Wallet-Guthaben und Einzahlungsadressen ab.

```python
wallets = client.wallets()

for wallet in wallets:
    print(f"{wallet.name}: {wallet.balance:.8f}")
    if wallet.deposit:
        print(f"  Einzahlung: {wallet.deposit}")
```

**Rückgabe:** `List[Wallet]`

| Feld             | Typ             | Beschreibung                                                               |
| ---------------- | --------------- | -------------------------------------------------------------------------- |
| `name`           | `str`           | Währungsname (z. B. `"bitcoin"`, `"CLORE-Blockchain"`, `"USD-Blockchain"`) |
| `balance`        | `float \| None` | Aktuelles Guthaben                                                         |
| `deposit`        | `str \| None`   | Einzahlungsadresse                                                         |
| `withdrawal_fee` | `float \| None` | Auszahlungsgebühr                                                          |

***

### `marketplace()`

Durchsuche den GPU-Marktplatz mit optionalen clientseitigen Filtern.

```python
# Alle verfügbaren Server
servers = client.marketplace()

# Nach GPU-Modell und Maximalpreis filtern
servers = client.marketplace(
    gpu="RTX 4090",
    max_price_usd=5.0
)

# Multi-GPU-Rigs mit viel RAM
servers = client.marketplace(
    min_gpu_count=4,
    min_ram_gb=128.0
)
```

**Parameter:**

| Parameter        | Typ             | Standard | Beschreibung                                                                                             |
| ---------------- | --------------- | -------- | -------------------------------------------------------------------------------------------------------- |
| `gpu`            | `str \| None`   | `None`   | Nach GPU-Modell filtern (Übereinstimmung als Teilstring ohne Berücksichtigung der Groß-/Kleinschreibung) |
| `min_gpu_count`  | `int \| None`   | `None`   | Mindestanzahl an GPUs                                                                                    |
| `min_ram_gb`     | `float \| None` | `None`   | Mindestens RAM in GB                                                                                     |
| `max_price_usd`  | `float \| None` | `None`   | Maximaler Preis pro Stunde in USD                                                                        |
| `available_only` | `bool`          | `True`   | Nur Server zurückgeben, die mietbar verfügbar sind                                                       |

**Rückgabe:** `List[MarketplaceServer]`

Jeder `MarketplaceServer` bietet praktische Eigenschaften für die häufigsten Felder sowie Zugriff auf die vollständigen verschachtelten Daten:

| Eigenschaft      | Typ             | Beschreibung                                                         |
| ---------------- | --------------- | -------------------------------------------------------------------- |
| `id`             | `int`           | Eindeutige Server-ID                                                 |
| `gpu_model`      | `str \| None`   | Beschreibung der primären GPU (z. B. `"1x NVIDIA GeForce RTX 4090"`) |
| `gpu_count`      | `int`           | Anzahl der GPUs (aus `gpu_array`)                                    |
| `ram_gb`         | `float \| None` | RAM in GB                                                            |
| `price_usd`      | `float \| None` | On-Demand-Preis in USD                                               |
| `spot_price_usd` | `float \| None` | Spot-Preis in USD                                                    |
| `available`      | `bool`          | Ob der Server verfügbar ist (nicht vermietet)                        |
| `location`       | `str \| None`   | Ländercode aus den Netzwerkspezifikationen                           |

Für fortgeschrittene Anwendungsfälle kannst du auf die vollständige verschachtelte Struktur zugreifen:

| Feld          | Typ                    | Beschreibung                                                                                                  |
| ------------- | ---------------------- | ------------------------------------------------------------------------------------------------------------- |
| `specs`       | `ServerSpecs \| None`  | Vollständige Hardwarespezifikationen (`specs.gpu`, `specs.ram`, `specs.cpu`, `specs.disk`, `specs.net`, etc.) |
| `price`       | `ServerPrice \| None`  | Vollständiges Preisobjekt (`price.usd.on_demand_usd`, `price.usd.spot`, `price.on_demand`, etc.)              |
| `vermietet`   | `bool \| None`         | Ob der Server derzeit vermietet ist                                                                           |
| `reliability` | `float \| None`        | Zuverlässigkeitswert des Servers                                                                              |
| `rating`      | `ServerRating \| None` | Serverbewertung (`rating.avg`, `rating.cnt`)                                                                  |

> **Hinweis:** Die `marketplace()` Der Endpunkt ist öffentlich — er funktioniert ohne API-Schlüssel.

***

### `my_servers()`

Liste die Server auf, die du dem Clore.ai-Marktplatz bereitstellst.

```python
my_servers = client.my_servers()

for server in my_servers:
    print(f"{server.name}: {server.gpu_model} [{server.status}]")
```

**Rückgabe:** `List[MyServer]`

| Eigenschaft    | Typ             | Beschreibung                                                                             |
| -------------- | --------------- | ---------------------------------------------------------------------------------------- |
| `id`           | `int`           | Server-ID                                                                                |
| `name`         | `str \| None`   | Servername                                                                               |
| `gpu_model`    | `str \| None`   | Beschreibung der primären GPU                                                            |
| `ram_gb`       | `float \| None` | RAM in GB                                                                                |
| `Status`       | `str`           | Menschenlesbarer Status: `"Online"`, `"Offline"`, `"Disconnected"`, oder `"Not Working"` |
| `verbunden`    | `bool \| None`  | Ob der Server verbunden ist                                                              |
| `online`       | `bool \| None`  | Ob der Server online ist                                                                 |
| `Sichtbarkeit` | `str \| None`   | `"public"` oder `"private"`                                                              |

***

### `server_config(server_name)`

Rufe die Konfiguration eines bestimmten Servers ab, den du hostest.

```python
config = client.server_config("MyGPU")

print(f"Server: {config.name}")
print(f"GPU: {config.gpu_model}")
print(f"Mindestmietdauer: {config.mrl}h")
print(f"On-Demand-Preis: ${config.on_demand_price}")
print(f"Spot-Preis: ${config.spot_price}")
```

**Parameter:**

| Parameter     | Typ   | Beschreibung     |
| ------------- | ----- | ---------------- |
| `server_name` | `str` | Name des Servers |

**Rückgabe:** `ServerConfig`

| Eigenschaft       | Typ                   | Beschreibung                           |
| ----------------- | --------------------- | -------------------------------------- |
| `name`            | `str \| None`         | Servername                             |
| `gpu_model`       | `str \| None`         | Beschreibung der primären GPU          |
| `mrl`             | `int \| None`         | Maximale Mietdauer in Stunden          |
| `on_demand_price` | `float \| None`       | Erster verfügbarer On-Demand-USD-Preis |
| `spot_price`      | `float \| None`       | Erster verfügbarer Spot-USD-Preis      |
| `specs`           | `ServerSpecs \| None` | Vollständige Hardwarespezifikationen   |
| `verbunden`       | `bool \| None`        | Ob der Server verbunden ist            |
| `Sichtbarkeit`    | `str \| None`         | `"public"` oder `"private"`            |

***

### `my_orders(include_completed)`

Rufe deine aktuellen Bestellungen ab, optional einschließlich abgeschlossener/abgelaufener.

```python
# Nur aktive Bestellungen
orders = client.my_orders()

# Abgeschlossene Bestellungen einschließen
all_orders = client.my_orders(include_completed=True)

for order in orders:
    print(f"Bestellung {order.id}: {order.type} — {order.status}")
    if order.pub_cluster:
        print(f"  IP: {order.pub_cluster}")
    if order.tcp_ports:
        print(f"  Ports: {order.tcp_ports}")
```

**Parameter:**

| Parameter           | Typ    | Standard | Beschreibung                                         |
| ------------------- | ------ | -------- | ---------------------------------------------------- |
| `include_completed` | `bool` | `False`  | Abgeschlossene/abgelaufene Bestellungen einschließen |

**Rückgabe:** `List[Order]`

| Feld          | Typ             | Beschreibung                             |
| ------------- | --------------- | ---------------------------------------- |
| `id`          | `int`           | Eindeutige Bestell-ID                    |
| `server_id`   | `int \| None`   | Server-ID                                |
| `type`        | `str`           | `"on-demand"` oder `"spot"`              |
| `Status`      | `str \| None`   | Bestellstatus                            |
| `Image`       | `str \| None`   | Docker-Image                             |
| `Währung`     | `str \| None`   | Zahlungswährung                          |
| `price`       | `float \| None` | Bestellpreis pro Tag                     |
| `pub_cluster` | `str \| None`   | Öffentlicher Hostname/IP für den Zugriff |
| `tcp_ports`   | `dict \| None`  | TCP-Port-Zuordnungen                     |

***

### `spot_marketplace(server_id)`

Zeige Spot-Marktangebote für einen bestimmten Server an.

```python
spot = client.spot_marketplace(server_id=6)

if spot.offers:
    for offer in spot.offers:
        print(f"Bestellung {offer.order_id}: ${offer.price}/day (server {offer.server_id})")

if spot.currency_rates_in_usd:
    for coin, rate in spot.currency_rates_in_usd.items():
        print(f"  {coin}: ${rate}")
```

**Parameter:**

| Parameter   | Typ   | Beschreibung          |
| ----------- | ----- | --------------------- |
| `server_id` | `int` | Zu prüfende Server-ID |

**Rückgabe:** `SpotMarket`

| Feld                    | Typ                        | Beschreibung                                                    |
| ----------------------- | -------------------------- | --------------------------------------------------------------- |
| `Angebote`              | `List[SpotOffer] \| None`  | Liste der Spot-Angebote (`order_id`, `price`, `server_id`)      |
| `server`                | `SpotServerInfo \| None`   | Serverinformationen (Mindestpreis, Sichtbarkeit, Online-Status) |
| `currency_rates_in_usd` | `Dict[str, float] \| None` | Währungsumrechnungskurse in USD                                 |

***

### `create_order(...)`

Erstelle eine neue On-Demand- oder Spot-Bestellung. So mietest du eine GPU.

#### On-Demand-Bestellung

```python
order = client.create_order(
    server_id=123,
    image="cloreai/ubuntu22.04-cuda12",
    type="on-demand",
    currency="bitcoin",
    ssh_password="MySecurePass123",
    ports={"22": "tcp", "8888": "http"}
)

print(f"Bestellung erstellt: {order.id}")
print(f"Verbinden: {order.pub_cluster}")
```

#### Spot-Bestellung

```python
order = client.create_order(
    server_id=123,
    image="cloreai/pytorch",
    type="spot",
    currency="bitcoin",
    spot_price=0.000005,
    ssh_password="MySecurePass123",
    ports={"22": "tcp"}
)
```

**Parameter:**

| Parameter            | Typ         | Erforderlich | Beschreibung                                                                                                                                                                                |
| -------------------- | ----------- | ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `server_id`          | `int`       | Ja           | Server-ID zum Mieten                                                                                                                                                                        |
| `Image`              | `str`       | Ja           | Docker-Image (z. B. `"cloreai/ubuntu22.04-cuda12"`)                                                                                                                                         |
| `type`               | `str`       | Ja           | `"on-demand"` oder `"spot"`                                                                                                                                                                 |
| `Währung`            | `str`       | Ja           | Zahlungswährung (z. B. `"bitcoin"`)                                                                                                                                                         |
| `ssh_password`       | `str`       | Nein         | SSH-Passwort (alphanumerisch, max. 32 Zeichen)                                                                                                                                              |
| `ssh_key`            | `str`       | Nein         | Öffentlicher SSH-Schlüssel (max. 3072 Zeichen)                                                                                                                                              |
| `ports`              | `dict`      | Nein         | Port-Zuordnungen, z. B. `{"22": "tcp", "8888": "http"}`                                                                                                                                     |
| `env`                | `dict`      | Nein         | Umgebungsvariablen                                                                                                                                                                          |
| `jupyter_token`      | `str`       | Nein         | Jupyter-Notebook-Token (max. 32 Zeichen)                                                                                                                                                    |
| `command`            | `str`       | Nein         | Shell-Befehl, der nach dem Start des Containers ausgeführt wird                                                                                                                             |
| `spot_price`         | `float`     | Nur Spot     | Preis pro Tag für Spot-Bestellungen                                                                                                                                                         |
| `required_price`     | `float`     | Nein         | Einen bestimmten Preis festlegen (nur On-Demand)                                                                                                                                            |
| `autossh_entrypoint` | `str`       | Nein         | Clore.ai-SSH-Entrypoint verwenden                                                                                                                                                           |
| `gpu_count`          | `int`       | Nein         | Miete nur N GPUs auf Servern mit [Teilvermietung](https://docs.clore.ai/clore.ai/clore.ai-eng-de/fur-mieter/partial-gpu-rental.md) (nur On-Demand); weglassen, um das gesamte Rig zu mieten |
| `gpu_indices`        | `list[int]` | Nein         | Exakte GPU-Slots von `partial_gpu_rental.free_indices`; Länge muss gleich `gpu_count`; für automatische Auswahl weglassen                                                                   |

> **Automatische Verlängerung:** das SDK (0.1.2 und früher) hat keine `create_order` noch keine Parameter für `rental_hours`, `auto_renew` oder `auto_renew_max_price`, und keine Methoden für `set_order_auto_renew` oder `order_renewals`. Bis dahin rufen Sie diese REST-Endpunkte direkt auf: [`create_order`](https://docs.clore.ai/clore.ai/clore.ai-eng-de/fur-hosts/api.md#id-10-create_order), [`set_order_auto_renew`](https://docs.clore.ai/clore.ai/clore.ai-eng-de/fur-hosts/api.md#id-16-set_order_auto_renew) und [`order_renewals`](https://docs.clore.ai/clore.ai/clore.ai-eng-de/fur-hosts/api.md#id-17-order_renewals). `Bestellung` Objekte behalten die Felder bei, die die API hinzufügt (`extra="allow"`), also `order.auto_renew`, `order.rental_end` und `order.term_end` sind auf Bestellungen lesbar, die sie enthalten; verwenden Sie `getattr(order, "auto_renew", None)` für ein Feld, das eine Bestellung möglicherweise nicht hat.

**Rückgabe:** Roh-API-Antwort (`{"code": 0}` bei Erfolg); rufen Sie die erstellte Bestellung über `my_orders()`

> **Ratenbegrenzung:** `create_order` hat zwischen Aufrufen eine besondere 5-Sekunden-Abkühlzeit. Das SDK erzwingt dies automatisch.

***

### `cancel_order(order_id, issue)`

Stornieren Sie eine aktive Bestellung oder ein Spot-Angebot. Optional können Sie ein Problem mit dem Server melden.

```python
# Einfaches Stornieren
client.cancel_order(order_id=38)

# Stornieren mit Problemmeldung
client.cancel_order(
    order_id=38,
    issue="GPU #1 überhitzte und drosselte"
)
```

**Parameter:**

| Parameter  | Typ   | Erforderlich | Beschreibung                                           |
| ---------- | ----- | ------------ | ------------------------------------------------------ |
| `order_id` | `int` | Ja           | Zu stornierende Bestell-ID                             |
| `Problem`  | `str` | Nein         | Stornierungsgrund / Problemmeldung (max. 2048 Zeichen) |

**Rückgabe:** `Dict[str, Any]`

***

### `set_server_settings(...)`

Aktualisieren Sie die Einstellungen für einen Server, den Sie auf dem Marktplatz hosten.

```python
client.set_server_settings(
    name="MyGPU",
    availability=True,
    mrl=96,
    on_demand=0.0001,
    spot=0.00000113
)
```

**Parameter:**

| Parameter       | Typ     | Erforderlich | Beschreibung                       |
| --------------- | ------- | ------------ | ---------------------------------- |
| `name`          | `str`   | Ja           | Servername                         |
| `Verfügbarkeit` | `bool`  | Nein         | Ob der Server gemietet werden kann |
| `mrl`           | `int`   | Nein         | Maximale Mietdauer in Stunden      |
| `on_demand`     | `float` | Nein         | On-Demand-Preis pro Tag            |
| `spot`          | `float` | Nein         | Mindest-Spotpreis pro Tag          |

**Rückgabe:** `Dict[str, Any]`

***

### `set_spot_price(order_id, price)`

Aktualisieren Sie den Preis Ihres Spot-Marktplatzangebots.

```python
client.set_spot_price(order_id=39, price=0.000003)
```

**Parameter:**

| Parameter  | Typ     | Beschreibung              |
| ---------- | ------- | ------------------------- |
| `order_id` | `int`   | Spot-Bestell-/Angebots-ID |
| `price`    | `float` | Neuer Preis pro Tag       |

**Rückgabe:** `Dict[str, Any]`

> **Hinweis:** Sie können Spotpreise nur alle 600 Sekunden und nur in begrenzten Schritten senken. Die API gibt `Code: 6` mit Details zurück, wenn Sie diese Grenzen überschreiten.

***

## Async-Client (`AsyncCloreAI`)

Die `AsyncCloreAI` Client bietet dieselben Methoden wie `CloreAI`, aber alle geben Coroutinen zurück. Verwenden Sie ihn, wenn Sie parallele API-Aufrufe benötigen oder in einer asynchronen Anwendung arbeiten.

### Grundlegende Verwendung

```python
import asyncio
from clore_ai import AsyncCloreAI

async def main():
    async with AsyncCloreAI(api_key="your_key") as client:
        wallets = await client.wallets()
        for w in wallets:
            print(f"{w.name}: {w.balance:.8f}")

asyncio.run(main())
```

### Parallele Operationen

Führen Sie mehrere API-Aufrufe parallel aus mit `asyncio.gather`:

```python
import asyncio
from clore_ai import AsyncCloreAI

async def compare_gpus():
    async with AsyncCloreAI() as client:
        # Suchen Sie parallel nach mehreren GPU-Modellen
        rtx4090, rtx3090, a100 = await asyncio.gather(
            client.marketplace(gpu="RTX 4090"),
            client.marketplace(gpu="RTX 3090"),
            client.marketplace(gpu="A100"),
        )

        for name, servers in [("RTX 4090", rtx4090), ("RTX 3090", rtx3090), ("A100", a100)]:
            if servers:
                cheapest = min(s.price_usd or float('inf') for s in servers)
                print(f"{name}: {len(servers)} verfügbar, günstigster ${cheapest:.4f}/h")
            else:
                print(f"{name}: nicht verfügbar")

asyncio.run(compare_gpus())
```

### Verfügbare Methoden

`AsyncCloreAI` unterstützt dieselben Methoden wie `CloreAI`:

| Methode                             | Beschreibung                      |
| ----------------------------------- | --------------------------------- |
| `await wallets()`                   | Wallet-Guthaben abrufen           |
| `await marketplace(...)`            | Marktplatz durchsuchen            |
| `await my_servers()`                | Ihre gehosteten Server auflisten  |
| `await server_config(name)`         | Serverkonfiguration abrufen       |
| `await my_orders(...)`              | Ihre Bestellungen auflisten       |
| `await spot_marketplace(server_id)` | Spot-Marktangebote abrufen        |
| `await create_order(...)`           | Eine neue Bestellung erstellen    |
| `await cancel_order(...)`           | Eine Bestellung stornieren        |
| `await set_server_settings(...)`    | Servereinstellungen aktualisieren |
| `await set_spot_price(...)`         | Spotpreis aktualisieren           |

***

## Fehlerbehandlung

Das SDK bietet strukturierte Ausnahme-Klassen für jeden API-Fehlercode.

```python
from clore_ai import CloreAI
from clore_ai.exceptions import (
    CloreAPIError,      # Basisklasse für alle API-Fehler
    AuthError,          # Code 3 — ungültiger API-Schlüssel
    RateLimitError,     # Code 5 — Ratenbegrenzung überschritten
    InvalidInputError,  # Code 2 — ungültige Anfragedaten
    DBError,            # Code 1 — Datenbankfehler
    InvalidEndpointError,  # Code 4 — ungültiger Endpunkt
    FieldError,         # Code 6 — feldspezifischer Fehler
)

client = CloreAI()

try:
    order = client.create_order(
        server_id=123,
        image="cloreai/ubuntu22.04-cuda12",
        type="on-demand",
        currency="bitcoin",
    )
except AuthError:
    print("Ungültiger API-Schlüssel. Überprüfen Sie Ihren CLORE_API_KEY.")
except RateLimitError:
    print("Ratenbegrenzung erreicht. Das SDK versucht es automatisch erneut, aber Sie haben die maximale Anzahl an Wiederholungen erreicht.")
except InvalidInputError as e:
    print(f"Ungültige Anfrage: {e}")
except FieldError as e:
    # Fehler des Codes 6 enthalten Details in der Antwort
    print(f"Feldfehler: {e} (Details: {e.response})")
except CloreAPIError as e:
    print(f"API-Fehler: {e} (Code: {e.code})")
```

### Fehlercodes

| Code | Ausnahme               | Beschreibung                                                         |
| ---- | ---------------------- | -------------------------------------------------------------------- |
| 0    | —                      | Erfolg                                                               |
| 1    | `DBError`              | Datenbankfehler                                                      |
| 2    | `InvalidInputError`    | Ungültige Eingabedaten                                               |
| 3    | `AuthError`            | Ungültiges API-Token                                                 |
| 4    | `InvalidEndpointError` | Ungültiger Endpunkt                                                  |
| 5    | `RateLimitError`       | Ratenbegrenzung überschritten                                        |
| 6    | `FieldError`           | Fehler in einem bestimmten Feld (siehe `Fehler` Feld in der Antwort) |

Alle Ausnahme-Klassen erben von `CloreAPIError` und enthalten:

* `e.code` — numerischer Fehlercode
* `e.response` — vollständiges API-Antwort-Dictionary (falls verfügbar)

***

## Ratenbegrenzung

Das SDK enthält einen integrierten Ratenbegrenzer, der die Limits von Clore.ai automatisch durchsetzt:

| Endpunkt              | Limit                    |
| --------------------- | ------------------------ |
| Die meisten Endpunkte | **1 Anfrage/Sekunde**    |
| `create_order`        | **1 Anfrage/5 Sekunden** |

Wenn die API einen Ratenbegrenzungsfehler (Code 5) zurückgibt, wendet das SDK **exponentielles Backoff** und versucht es erneut bis zu `max_retries` Mal (Standard: 3). Sie müssen kein `time.sleep()` zwischen den Aufrufen hinzufügen.

### So funktioniert es

1. Vor jeder Anfrage wartet der Ratenbegrenzer, bis das Mindestintervall verstrichen ist.
2. `create_order` Aufrufe erzwingen eine zusätzliche 5-Sekunden-Abkühlzeit.
3. Bei Ratenbegrenzungsfehlern fährt das SDK exponentiell zurück: 1s → 2s → 4s → ...
4. Nach `max_retries` fehlgeschlagenen Versuchen wird ein `RateLimitError` ausgelöst.

### Wiederholungsverhalten anpassen

```python
client = CloreAI(
    max_retries=5,    # Mehr Wiederholungen für lang laufende Skripte
    timeout=60.0      # Längeres Timeout für langsame Verbindungen
)
```

***

## Konfiguration

### Konfigurationsdatei

Die CLI speichert die Konfiguration in `~/.clore/config.json`:

```json
{
  "api_key": "your_api_key_here"
}
```

### Auflösungsreihenfolge

Das SDK löst den API-Schlüssel in dieser Reihenfolge auf:

1. `api_key` an den Konstruktor übergebenes Argument
2. `CLORE_API_KEY` Umgebungsvariable
3. `api_key` Feld in `~/.clore/config.json`

### Umgebungsvariablen

| Variable        | Beschreibung                            |
| --------------- | --------------------------------------- |
| `CLORE_API_KEY` | API-Schlüssel für die Authentifizierung |

***

## Nächste Schritte

* [**CLI-Referenz**](https://docs.clore.ai/clore.ai/clore.ai-eng-de/entwickler/cli-guide.md) — Verwenden Sie Clore.ai von Ihrem Terminal aus
* [**REST-API**](https://docs.clore.ai/clore.ai/clore.ai-eng-de/fur-hosts/api.md) — Roh-API-Dokumentation für benutzerdefinierte Integrationen
* [**On-Demand vs. Spot**](https://docs.clore.ai/clore.ai/clore.ai-eng-de/fur-mieter/on-demand-vs-spot.md) — Preismodelle verstehen
* [**Verfügbare Docker-Images**](https://docs.clore.ai/clore.ai/clore.ai-eng-de/fur-mieter/docker-images.md) — Vorgefertigte Images für GPU-Workloads


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.clore.ai/clore.ai/clore.ai-eng-de/entwickler/python-sdk.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
