> 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-es/desarrolladores/python-sdk.md).

# SDK de Python (clore-ai)

El **clore-ai** paquete es el SDK oficial de Python para el [Clore.ai](https://clore.ai) mercado de GPUs. Envuelve toda la API REST en una interfaz limpia y segura en cuanto a tipos, con limitación de velocidad integrada, reintentos automáticos y manejo estructurado de errores, para que puedas centrarte en alquilar GPUs, no en la gestión de HTTP.

***

## Instalación

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

**Requisitos:** Python 3.9+

El paquete instala tanto el SDK de Python como el [`clore` CLI](https://docs.clore.ai/clore.ai/clore.ai-eng-es/desarrolladores/cli-guide.md).

***

## Autenticación

Obtén tu clave API desde el [panel de Clore.ai](https://clore.ai) → **API** sección.

### Opción 1: Variable de entorno (recomendada)

```bash
export CLORE_API_KEY=your_api_key_here
```

El SDK lee `CLORE_API_KEY` automáticamente — no se necesitan cambios en el código.

### Opción 2: Archivo de configuración de la CLI

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

Esto almacena la clave en `~/.clore/config.json`.

### Opción 3: Pasar directamente en el código

```python
from clore_ai import CloreAI

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

> ⚠️ **Importante:** La API de Clore.ai usa el `auth` encabezado para la autenticación, **no** `Authorization: Bearer`. El SDK lo maneja automáticamente.

***

## Inicio rápido

```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")
```

***

## Cliente síncrono (`CloreAI`)

### Constructor

```python
CloreAI(
    api_key: str | None = None,       # Recurre a la variable de entorno / config CLORE_API_KEY
    base_url: str | None = None,       # Predeterminado: https://api.clore.ai/v1
    timeout: float = 30.0,             # Tiempo de espera de la solicitud en segundos
    max_retries: int = 3               # Intentos de reintento ante limitación de velocidad / errores de red
)
```

El cliente admite administradores de contexto para limpieza automática:

```python
with CloreAI() as client:
    wallets = client.wallets()
    # client.close() se llama automáticamente
```

***

### `wallets()`

Obtén los saldos de tus carteras y las direcciones de depósito.

```python
wallets = client.wallets()

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

**Devuelve:** `List[Wallet]`

| Campo            | Tipo            | Descripción                                                                        |
| ---------------- | --------------- | ---------------------------------------------------------------------------------- |
| `name`           | `str`           | Nombre de la moneda (p. ej. `"bitcoin"`, `"CLORE-Blockchain"`, `"USD-Blockchain"`) |
| `balance`        | `float \| None` | Saldo actual                                                                       |
| `deposit`        | `str \| None`   | Dirección de depósito                                                              |
| `withdrawal_fee` | `float \| None` | Comisión de retiro                                                                 |

***

### `marketplace()`

Busca en el mercado de GPUs con filtros opcionales en el lado del cliente.

```python
# Todos los servidores disponibles
servers = client.marketplace()

# Filtrar por modelo de GPU y precio máximo
servers = client.marketplace(
    gpu="RTX 4090",
    max_price_usd=5.0
)

# Equipos con varias GPUs y mucha RAM
servers = client.marketplace(
    min_gpu_count=4,
    min_ram_gb=128.0
)
```

**Parámetros:**

| Parámetro        | Tipo            | Predeterminado | Descripción                                                                                        |
| ---------------- | --------------- | -------------- | -------------------------------------------------------------------------------------------------- |
| `gpu`            | `str \| None`   | `None`         | Filtrar por modelo de GPU (coincidencia de subcadena sin distinción entre mayúsculas y minúsculas) |
| `min_gpu_count`  | `int \| None`   | `None`         | Número mínimo de GPUs                                                                              |
| `min_ram_gb`     | `float \| None` | `None`         | RAM mínima en GB                                                                                   |
| `max_price_usd`  | `float \| None` | `None`         | Precio máximo por hora en USD                                                                      |
| `available_only` | `bool`          | `True`         | Devuelve solo servidores que estén disponibles para alquilar                                       |

**Devuelve:** `List[MarketplaceServer]`

Cada `MarketplaceServer` ofrece propiedades convenientes para los campos más comunes, además de acceso a todos los datos anidados:

| Propiedad        | Tipo            | Descripción                                                             |
| ---------------- | --------------- | ----------------------------------------------------------------------- |
| `id`             | `int`           | ID único del servidor                                                   |
| `gpu_model`      | `str \| None`   | Descripción principal de la GPU (p. ej. `"1x NVIDIA GeForce RTX 4090"`) |
| `gpu_count`      | `int`           | Número de GPUs (de `gpu_array`)                                         |
| `ram_gb`         | `float \| None` | RAM en GB                                                               |
| `price_usd`      | `float \| None` | Precio bajo demanda en USD                                              |
| `spot_price_usd` | `float \| None` | Precio spot en USD                                                      |
| `available`      | `bool`          | Si el servidor está disponible (no alquilado)                           |
| `location`       | `str \| None`   | Código de país de las especificaciones de red                           |

Para casos de uso avanzados, puedes acceder a la estructura anidada completa:

| Campo         | Tipo                   | Descripción                                                                                                     |
| ------------- | ---------------------- | --------------------------------------------------------------------------------------------------------------- |
| `specs`       | `ServerSpecs \| None`  | Especificaciones completas de hardware (`specs.gpu`, `specs.ram`, `specs.cpu`, `specs.disk`, `specs.net`, etc.) |
| `precio`      | `ServerPrice \| None`  | Objeto completo de precio (`price.usd.on_demand_usd`, `price.usd.spot`, `price.on_demand`, etc.)                |
| `rented`      | `bool \| None`         | Si el servidor está alquilado actualmente                                                                       |
| `reliability` | `float \| None`        | Puntuación de fiabilidad del servidor                                                                           |
| `rating`      | `ServerRating \| None` | Valoración del servidor (`rating.avg`, `rating.cnt`)                                                            |

> **Nota:** El `marketplace()` el endpoint es público — funciona sin clave API.

***

### `my_servers()`

Enumera los servidores que estás proporcionando al mercado de Clore.ai.

```python
my_servers = client.my_servers()

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

**Devuelve:** `List[MyServer]`

| Propiedad     | Tipo            | Descripción                                                                           |
| ------------- | --------------- | ------------------------------------------------------------------------------------- |
| `id`          | `int`           | ID del servidor                                                                       |
| `name`        | `str \| None`   | Nombre del servidor                                                                   |
| `gpu_model`   | `str \| None`   | Descripción principal de la GPU                                                       |
| `ram_gb`      | `float \| None` | RAM en GB                                                                             |
| `estado`      | `str`           | Estado legible: `"En línea"`, `"Fuera de línea"`, `"Desconectado"`, o `"No funciona"` |
| `conectado`   | `bool \| None`  | Si el servidor está conectado                                                         |
| `en línea`    | `bool \| None`  | Si el servidor está en línea                                                          |
| `visibilidad` | `str \| None`   | `"público"` o `"privado"`                                                             |

***

### `server_config(server_name)`

Obtén la configuración de un servidor específico que hospedas.

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

print(f"Server: {config.name}")
print(f"GPU: {config.gpu_model}")
print(f"Mínimo de alquiler: {config.mrl}h")
print(f"Bajo demanda: ${config.on_demand_price}")
print(f"Spot: ${config.spot_price}")
```

**Parámetros:**

| Parámetro     | Tipo  | Descripción         |
| ------------- | ----- | ------------------- |
| `server_name` | `str` | Nombre del servidor |

**Devuelve:** `ServerConfig`

| Propiedad         | Tipo                  | Descripción                                  |
| ----------------- | --------------------- | -------------------------------------------- |
| `name`            | `str \| None`         | Nombre del servidor                          |
| `gpu_model`       | `str \| None`         | Descripción principal de la GPU              |
| `mrl`             | `int \| None`         | Duración máxima de alquiler en horas         |
| `on_demand_price` | `float \| None`       | Primer precio disponible en USD bajo demanda |
| `spot_price`      | `float \| None`       | Primer precio spot disponible en USD         |
| `specs`           | `ServerSpecs \| None` | Especificaciones completas de hardware       |
| `conectado`       | `bool \| None`        | Si el servidor está conectado                |
| `visibilidad`     | `str \| None`         | `"público"` o `"privado"`                    |

***

### `my_orders(include_completed)`

Obtén tus pedidos actuales, incluyendo opcionalmente los completados o expirados.

```python
# Solo pedidos activos
orders = client.my_orders()

# Incluir pedidos completados
all_orders = client.my_orders(include_completed=True)

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

**Parámetros:**

| Parámetro           | Tipo   | Predeterminado | Descripción                           |
| ------------------- | ------ | -------------- | ------------------------------------- |
| `include_completed` | `bool` | `False`        | Incluir pedidos completados/expirados |

**Devuelve:** `List[Order]`

| Campo         | Tipo            | Descripción                           |
| ------------- | --------------- | ------------------------------------- |
| `id`          | `int`           | ID único del pedido                   |
| `server_id`   | `int \| None`   | ID del servidor                       |
| `type`        | `str`           | `"on-demand"` o `"spot"`              |
| `estado`      | `str \| None`   | Estado del pedido                     |
| `imagen`      | `str \| None`   | Imagen de Docker                      |
| `currency`    | `str \| None`   | Moneda de pago                        |
| `precio`      | `float \| None` | Precio del pedido por día             |
| `pub_cluster` | `str \| None`   | Nombre de host/IP pública para acceso |
| `tcp_ports`   | `dict \| None`  | Mapeos de puertos TCP                 |

***

### `spot_marketplace(server_id)`

Ver ofertas del mercado spot para un servidor específico.

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

if spot.offers:
    for offer in spot.offers:
        print(f"Order {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}")
```

**Parámetros:**

| Parámetro   | Tipo  | Descripción                 |
| ----------- | ----- | --------------------------- |
| `server_id` | `int` | ID del servidor a comprobar |

**Devuelve:** `SpotMarket`

| Campo                   | Tipo                       | Descripción                                                            |
| ----------------------- | -------------------------- | ---------------------------------------------------------------------- |
| `ofertas`               | `List[SpotOffer] \| None`  | Lista de ofertas spot (`order_id`, `precio`, `server_id`)              |
| `server`                | `SpotServerInfo \| None`   | Información del servidor (precio mínimo, visibilidad, estado en línea) |
| `currency_rates_in_usd` | `Dict[str, float] \| None` | Tipos de cambio de moneda en USD                                       |

***

### `create_order(...)`

Crea un nuevo pedido bajo demanda o spot. Así es como alquilas una GPU.

#### Pedido bajo demanda

```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"Order created: {order.id}")
print(f"Connect: {order.pub_cluster}")
```

#### Pedido spot

```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"}
)
```

**Parámetros:**

| Parámetro            | Tipo        | Requerido | Descripción                                                                                                                                                                                                    |
| -------------------- | ----------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `server_id`          | `int`       | Sí        | ID del servidor a alquilar                                                                                                                                                                                     |
| `imagen`             | `str`       | Sí        | Imagen de Docker (p. ej. `"cloreai/ubuntu22.04-cuda12"`)                                                                                                                                                       |
| `type`               | `str`       | Sí        | `"on-demand"` o `"spot"`                                                                                                                                                                                       |
| `currency`           | `str`       | Sí        | Moneda de pago (p. ej. `"bitcoin"`)                                                                                                                                                                            |
| `ssh_password`       | `str`       | No        | Contraseña SSH (alfanumérica, máx. 32 caracteres)                                                                                                                                                              |
| `ssh_key`            | `str`       | No        | Clave pública SSH (máx. 3072 caracteres)                                                                                                                                                                       |
| `ports`              | `dict`      | No        | Mapeos de puertos, p. ej. `{"22": "tcp", "8888": "http"}`                                                                                                                                                      |
| `env`                | `dict`      | No        | Variables de entorno                                                                                                                                                                                           |
| `jupyter_token`      | `str`       | No        | Token de Jupyter Notebook (máx. 32 caracteres)                                                                                                                                                                 |
| `command`            | `str`       | No        | Comando de shell para ejecutar después de iniciar el contenedor                                                                                                                                                |
| `spot_price`         | `float`     | Solo spot | Precio por día para pedidos spot                                                                                                                                                                               |
| `required_price`     | `float`     | No        | Bloquea un precio específico (solo bajo demanda)                                                                                                                                                               |
| `autossh_entrypoint` | `str`       | No        | Usa el punto de entrada SSH de Clore.ai                                                                                                                                                                        |
| `gpu_count`          | `int`       | No        | Alquila solo N GPUs en servidores con [alquiler parcial](https://docs.clore.ai/clore.ai/clore.ai-eng-es/para-arrendatarios/partial-gpu-rental.md) (solo bajo demanda); omite esto para alquilar todo el equipo |
| `gpu_indices`        | `list[int]` | No        | Ranuras exactas de GPU de `partial_gpu_rental.free_indices`; la longitud debe ser igual a `gpu_count`; omite para selección automática                                                                         |

> **Renovación automática:** el SDK (0.1.2 y anteriores) no tiene `create_order` todavía parámetros para `rental_hours`, `auto_renew` o `auto_renew_max_price`, ni métodos para `set_order_auto_renew` o `order_renewals`. Hasta que los tenga, llama directamente a esos endpoints REST: [`create_order`](https://docs.clore.ai/clore.ai/clore.ai-eng-es/para-hosts/api.md#id-10-create_order), [`set_order_auto_renew`](https://docs.clore.ai/clore.ai/clore.ai-eng-es/para-hosts/api.md#id-16-set_order_auto_renew) y [`order_renewals`](https://docs.clore.ai/clore.ai/clore.ai-eng-es/para-hosts/api.md#id-17-order_renewals). `Order` los objetos conservan los campos que añade la API (`extra="allow"`), así que `order.auto_renew`, `order.rental_end` y `order.term_end` son legibles en los pedidos que los incluyen; use `getattr(order, "auto_renew", None)` para un campo que un pedido puede no tener.

**Devuelve:** respuesta bruta de la API (`{"code": 0}` en caso de éxito); obtén el pedido creado mediante `my_orders()`

> **Límite de velocidad:** `create_order` tiene una pausa especial de 5 segundos entre llamadas. El SDK la aplica automáticamente.

***

### `cancel_order(order_id, issue)`

Cancela un pedido activo o una oferta spot. Opcionalmente, informa un problema con el servidor.

```python
# Cancelación simple
client.cancel_order(order_id=38)

# Cancelar con informe de problema
client.cancel_order(
    order_id=38,
    issue="La GPU #1 se estaba sobrecalentando y reduciendo su rendimiento"
)
```

**Parámetros:**

| Parámetro  | Tipo  | Requerido | Descripción                                                        |
| ---------- | ----- | --------- | ------------------------------------------------------------------ |
| `order_id` | `int` | Sí        | ID del pedido a cancelar                                           |
| `problema` | `str` | No        | Motivo de cancelación / informe de problema (máx. 2048 caracteres) |

**Devuelve:** `Dict[str, Any]`

***

### `set_server_settings(...)`

Actualiza la configuración de un servidor que alojas en el mercado.

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

**Parámetros:**

| Parámetro        | Tipo    | Requerido | Descripción                          |
| ---------------- | ------- | --------- | ------------------------------------ |
| `name`           | `str`   | Sí        | Nombre del servidor                  |
| `disponibilidad` | `bool`  | No        | Si el servidor puede alquilarse      |
| `mrl`            | `int`   | No        | Duración máxima de alquiler en horas |
| `bajo demanda`   | `float` | No        | Precio bajo demanda por día          |
| `spot`           | `float` | No        | Precio mínimo spot por día           |

**Devuelve:** `Dict[str, Any]`

***

### `set_spot_price(order_id, price)`

Actualiza el precio de tu oferta en el mercado spot.

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

**Parámetros:**

| Parámetro  | Tipo    | Descripción               |
| ---------- | ------- | ------------------------- |
| `order_id` | `int`   | ID del pedido/oferta spot |
| `precio`   | `float` | Nuevo precio por día      |

**Devuelve:** `Dict[str, Any]`

> **Nota:** Solo puedes bajar los precios spot una vez cada 600 segundos, y con un tamaño de paso limitado. La API devuelve `código: 6` con detalles si excedes estos límites.

***

## Cliente asíncrono (`AsyncCloreAI`)

El `AsyncCloreAI` el cliente proporciona los mismos métodos que `CloreAI`, pero todos devuelven corutinas. Úsalo cuando necesites llamadas concurrentes a la API o estés trabajando dentro de una aplicación asíncrona.

### Uso básico

```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())
```

### Operaciones concurrentes

Ejecuta múltiples llamadas a la API en paralelo con `asyncio.gather`:

```python
import asyncio
from clore_ai import AsyncCloreAI

async def compare_gpus():
    async with AsyncCloreAI() as client:
        # Busca varios modelos de GPU simultáneamente
        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)} disponibles, más barato ${cheapest:.4f}/h")
            else:
                print(f"{name}: no hay ninguno disponible")

asyncio.run(compare_gpus())
```

### Métodos disponibles

`AsyncCloreAI` admite todos los mismos métodos que `CloreAI`:

| Método                              | Descripción                              |
| ----------------------------------- | ---------------------------------------- |
| `await wallets()`                   | Obtener saldos de la cartera             |
| `await marketplace(...)`            | Buscar en el mercado                     |
| `await my_servers()`                | Lista tus servidores alojados            |
| `await server_config(name)`         | Obtener la configuración del servidor    |
| `await my_orders(...)`              | Lista tus pedidos                        |
| `await spot_marketplace(server_id)` | Obtener ofertas del mercado spot         |
| `await create_order(...)`           | Crear un pedido nuevo                    |
| `await cancel_order(...)`           | Cancelar un pedido                       |
| `await set_server_settings(...)`    | Actualizar la configuración del servidor |
| `await set_spot_price(...)`         | Actualizar el precio spot                |

***

## Manejo de errores

El SDK proporciona clases de excepción estructuradas para cada código de error de la API.

```python
from clore_ai import CloreAI
from clore_ai.exceptions import (
    CloreAPIError,      # Clase base para todos los errores de la API
    AuthError,          # Código 3 — clave de API no válida
    RateLimitError,     # Código 5 — límite de velocidad excedido
    InvalidInputError,  # Código 2 — datos de solicitud incorrectos
    DBError,            # Código 1 — error de base de datos
    InvalidEndpointError,  # Código 4 — endpoint no válido
    FieldError,         # Código 6 — error específico de un campo
)

client = CloreAI()

try:
    order = client.create_order(
        server_id=123,
        image="cloreai/ubuntu22.04-cuda12",
        type="on-demand",
        currency="bitcoin",
    )
except AuthError:
    print("Clave de API no válida. Revisa tu CLORE_API_KEY.")
except RateLimitError:
    print("Límite de velocidad alcanzado. El SDK reintenta automáticamente, pero has alcanzado el máximo de reintentos.")
except InvalidInputError as e:
    print(f"Solicitud incorrecta: {e}")
except FieldError as e:
    # Los errores de código 6 incluyen detalles en la respuesta
    print(f"Error de campo: {e} (detalles: {e.response})")
except CloreAPIError as e:
    print(f"Error de la API: {e} (código: {e.code})")
```

### Códigos de error

| Código | Excepción              | Descripción                                                      |
| ------ | ---------------------- | ---------------------------------------------------------------- |
| 0      | —                      | Éxito                                                            |
| 1      | `DBError`              | Error de base de datos                                           |
| 2      | `InvalidInputError`    | Datos de entrada no válidos                                      |
| 3      | `AuthError`            | Token de API no válido                                           |
| 4      | `InvalidEndpointError` | Endpoint no válido                                               |
| 5      | `RateLimitError`       | Límite de velocidad excedido                                     |
| 6      | `FieldError`           | Error en un campo específico (ver `error` campo en la respuesta) |

Todas las clases de excepción heredan de `CloreAPIError` e incluyen:

* `e.code` — código de error numérico
* `e.response` — diccionario completo de respuesta de la API (cuando esté disponible)

***

## Limitación de velocidad

El SDK incluye un limitador de velocidad integrado que aplica automáticamente los límites de Clore.ai:

| Endpoint                    | Límite                     |
| --------------------------- | -------------------------- |
| La mayoría de los endpoints | **1 solicitud/segundo**    |
| `create_order`              | **1 solicitud/5 segundos** |

Cuando la API devuelve un error de límite de velocidad (código 5), el SDK aplica **retroceso exponencial** y reintenta hasta `max_retries` veces (predeterminado: 3). No necesitas añadir `time.sleep()` entre llamadas.

### Cómo funciona

1. Antes de cada solicitud, el limitador de velocidad espera hasta que transcurra el intervalo mínimo.
2. `create_order` las llamadas imponen una pausa adicional de 5 segundos.
3. Ante errores de límite de velocidad, el SDK realiza un retroceso exponencial: 1 s → 2 s → 4 s → ...
4. Después de `max_retries` intentos fallidos, se `RateLimitError` lanza.

### Personaliza el comportamiento de reintento

```python
client = CloreAI(
    max_retries=5,    # Más reintentos para scripts de larga duración
    timeout=60.0      # Tiempo de espera más largo para conexiones lentas
)
```

***

## Configuración

### Archivo de configuración

La CLI almacena la configuración en `~/.clore/config.json`:

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

### Orden de resolución

El SDK resuelve la clave de API en este orden:

1. `api_key` argumento pasado al constructor
2. `CLORE_API_KEY` variable de entorno
3. `api_key` campo en `~/.clore/config.json`

### Variables de entorno

| Variable        | Descripción                     |
| --------------- | ------------------------------- |
| `CLORE_API_KEY` | Clave de API para autenticación |

***

## Siguientes pasos

* [**Referencia de la CLI**](https://docs.clore.ai/clore.ai/clore.ai-eng-es/desarrolladores/cli-guide.md) — Usa Clore.ai desde tu terminal
* [**API REST**](https://docs.clore.ai/clore.ai/clore.ai-eng-es/para-hosts/api.md) — Documentación bruta de la API para integraciones personalizadas
* [**Bajo demanda vs. spot**](https://docs.clore.ai/clore.ai/clore.ai-eng-es/para-arrendatarios/on-demand-vs-spot.md) — Comprende los modelos de precios
* [**Imágenes Docker disponibles**](https://docs.clore.ai/clore.ai/clore.ai-eng-es/para-arrendatarios/docker-images.md) — Imágenes precompiladas para cargas de trabajo de GPU


---

# 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-es/desarrolladores/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.
