# LlamaIndex

LlamaIndex (ранее GPT Index) — это **фреймворк для работы с данными в приложениях на основе больших языковых моделей** с более чем **37 000 звёзд на GitHub**. В то время как LangChain ориентирован на последовательное вызовы LLM, LlamaIndex превосходит в **захвате данных, индексировании и структурированном запросе** — что делает его основным выбором, когда вашему приложению нужно рассуждать над большими разнородными коллекциями документов.

LlamaIndex обеспечивает первоклассную поддержку сложных структур данных (базы данных, API, PDF, страницы Notion, репозитории GitHub) и продуманных стратегий поиска. Запуск на GPU-серверах Clore.ai с локальными LLM устраняет затраты на API и сохраняет ваши данные приватными.

Ключевые сильные стороны:

* 📊 **Коннекторы данных** — более 160 интеграций (PDF, SQL, Notion, Slack, GitHub и др.)
* 🗂️ **Несколько типов индексов** — векторный, дерево, список, ключевые слова, граф знаний
* 🔍 **Продвинутый поиск** — декомпозиция на под-вопросы, рекурсивный поиск, гибридный поиск
* 🤖 **Двигатели запросов** — SQL, структурированные и естественно-языковые запросы по любому источнику данных
* 🧩 **Мультимодальность** — изображения, аудио и видео наряду с текстом
* 💾 **Сохранение** — встроенная поддержка ChromaDB, Pinecone, Weaviate и т.д.
* ⚡ **Асинхронность в приоритете** — разработан для пропускной способности в продакшене
* 🔗 **Совместим с LangChain** — используйте оба фреймворка вместе

{% hint style="success" %}
Все примеры можно запускать на GPU-серверах, арендуемых через [CLORE.AI Маркетплейс](https://clore.ai/marketplace).
{% endhint %}

***

## Требования к серверу

| Параметр | Минимум                 | Рекомендуется                       |
| -------- | ----------------------- | ----------------------------------- |
| GPU      | NVIDIA RTX 3080 (10 ГБ) | NVIDIA RTX 4090 (24 ГБ)             |
| VRAM     | 8 ГБ (модель 7B)        | 24 ГБ (модели 13B–34B)              |
| ОЗУ      | 16 ГБ                   | 32–64 ГБ                            |
| CPU      | 4 ядра                  | 16 ядер                             |
| Диск     | 30 ГБ                   | 100+ ГБ (локальные модели + данные) |
| ОС       | Ubuntu 20.04+           | Ubuntu 22.04                        |
| CUDA     | 11.8+                   | 12.1+                               |
| Python   | 3.9+                    | 3.11                                |
| Порты    | 22, 8000                | 22, 8000, 11434 (Ollama)            |

{% hint style="info" %}
LlamaIndex — это библиотека на Python — ресурсы GPU потребляются базовой LLM и моделью эмбеддингов. Для продакшен-развёртываний сочетайте LlamaIndex с Ollama (для локального вывода) и ChromaDB (для векторного хранилища), оба запущенные на вашем GPU-сервере Clore.ai.
{% endhint %}

***

## Быстрое развертывание на CLORE.AI

### 1. Найдите подходящий сервер

Перейдите на [CLORE.AI Маркетплейс](https://clore.ai/marketplace) и выбирайте в зависимости от размера вашей LLM:

| Сценарий использования    | GPU              | Примечания                             |
| ------------------------- | ---------------- | -------------------------------------- |
| Разработка / Тестирование | RTX 3080 (10 ГБ) | модели 7B, небольшие наборы документов |
| Продакшен (малый)         | RTX 4090 (24 ГБ) | модели 13B, средние наборы данных      |
| Продакшен (большой)       | A100 40G / 80G   | модели 34B–70B, большие наборы данных  |
| Корпоративный             | H100 (80 ГБ)     | Максимальная пропускная способность    |

### 2. Настройте ваше развёртывание

**Docker-образ (базовый):**

```
nvidia/cuda:12.1.0-cudnn8-devel-ubuntu22.04
```

**Проброс портов:**

```
22    → доступ по SSH
8000  → API LlamaIndex / Gradio UI
11434 → движок инференса Ollama
```

**Скрипт запуска:**

```bash
#!/bin/bash
# Установить Ollama
curl -fsSL https://ollama.ai/install.sh | sh
ollama serve &
sleep 5
ollama pull llama3:8b
ollama pull nomic-embed-text

# Установить LlamaIndex
pip install llama-index llama-index-llms-ollama llama-index-embeddings-ollama
pip install chromadb fastapi uvicorn

python /workspace/app.py
```

### 3. Доступ к API

```
http://<ip-вашего-clore-сервера>:8000
```

***

## Пошаговая настройка

### Шаг 1: Подключитесь по SSH к вашему серверу

```bash
ssh root@<ip-вашего-clore-сервера> -p <ssh-порт>
```

### Шаг 2: Установите Ollama

```bash
curl -fsSL https://ollama.ai/install.sh | sh
ollama serve &
sleep 5

# Загрузить модели
ollama pull llama3:8b              # LLM для генерации
ollama pull nomic-embed-text       # модель эмбеддингов

# Проверить
ollama list
```

### Шаг 3: Настройте Python-окружение

```bash
mkdir -p /workspace/llamaindex-app
cd /workspace/llamaindex-app

python3 -m venv venv
source venv/bin/activate
pip install --upgrade pip
```

### Шаг 4: Установите пакеты LlamaIndex

```bash
# Ядро LlamaIndex
pip install llama-index

# Интеграции LLM
pip install llama-index-llms-ollama
pip install llama-index-llms-openai     # Необязательно: OpenAI

# Интеграции эмбеддингов
pip install llama-index-embeddings-ollama
pip install llama-index-embeddings-huggingface

# Интеграции векторных хранилищ
pip install llama-index-vector-stores-chroma

# Загрузчики данных
pip install llama-index-readers-file
pip install llama-index-readers-web

# Необязательно: дополнительные ридеры
pip install pypdf docx2txt
```

### Шаг 5: Настройте глобальные параметры

```python
# settings.py
from llama_index.core import Settings
from llama_index.llms.ollama import Ollama
from llama_index.embeddings.ollama import OllamaEmbedding

# Настройка LLM
Settings.llm = Ollama(
    model="llama3:8b",
    base_url="http://localhost:11434",
    request_timeout=300.0,
    temperature=0.1,
)

# Настройка эмбеддингов
Settings.embed_model = OllamaEmbedding(
    model_name="nomic-embed-text",
    base_url="http://localhost:11434",
)

# Настройка параметров чанков
Settings.chunk_size = 1024
Settings.chunk_overlap = 200
```

### Шаг 6: Постройте ваш первый индекс

```python
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader

# Загрузить документы из директории
documents = SimpleDirectoryReader("/workspace/data/docs").load_data()
print(f"Загружено {len(documents)} документов")

# Построить векторный индекс (автоматически делает эмбеддинги и сохраняет)
index = VectorStoreIndex.from_documents(documents)

# Сохранить индекс на диск
index.storage_context.persist("/workspace/index_storage")
print("Индекс создан и сохранён!")
```

### Шаг 7: Запрос к индексу

```python
from llama_index.core import load_index_from_storage, StorageContext

# Загрузить существующий индекс
storage_context = StorageContext.from_defaults(persist_dir="/workspace/index_storage")
index = load_index_from_storage(storage_context)

# Создать движок запросов
query_engine = index.as_query_engine(similarity_top_k=5)

# Задать вопросы
response = query_engine.query("Какие GPU-серверы доступны на Clore.ai?")
print(f"Ответ: {response}")
print(f"\nИсточники: {len(response.source_nodes)} узлов использовано")
```

***

## Примеры использования

### Пример 1: Базовый Q\&A по документам

```python
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, Settings
from llama_index.llms.ollama import Ollama
from llama_index.embeddings.ollama import OllamaEmbedding
from pathlib import Path

# Настройка LlamaIndex с локальными моделями Ollama
Settings.llm = Ollama(model="llama3:8b", base_url="http://localhost:11434")
Settings.embed_model = OllamaEmbedding(
    model_name="nomic-embed-text",
    base_url="http://localhost:11434"
)

# Создать директорию с примерными документами
data_dir = Path("/workspace/data")
data_dir.mkdir(exist_ok=True)

# Создать примерный документ
(data_dir / "clore_faq.txt").write_text("""
FAQ Clore.ai

В: Что такое Clore.ai?
О: Clore.ai — это децентрализованный рынок облачных GPU, соединяющий владельцев GPU с исследователями и разработчиками ИИ, которым нужна вычислительная мощность.

В: Какие GPU доступны?
О: Clore.ai предлагает GPU от NVIDIA GTX 1080 до новейшего H100 80GB. Популярные варианты включают RTX 4090, A100 40G/80G и RTX 3090.

В: Как работает ценообразование?
О: Цены устанавливаются провайдерами GPU и зависят от модели GPU, объёма VRAM и доступности. В целом на 30–70% дешевле, чем AWS/GCP.

В: Какое ПО можно запускать?
О: Любой Docker-контейнер. Доступны преднастроенные образы для PyTorch, TensorFlow, ComfyUI, Stable Diffusion и др.
""")

# Построить индекс
documents = SimpleDirectoryReader(str(data_dir)).load_data()
index = VectorStoreIndex.from_documents(documents, show_progress=True)

# Запрос
query_engine = index.as_query_engine(similarity_top_k=3)

questions = [
    "Какие GPU предлагает Clore.ai?",
    "Как цены Clore.ai сравниваются с AWS?",
    "Могу ли я запускать собственные Docker-контейнеры?",
]

for q in questions:
    print(f"\n❓ {q}")
    response = query_engine.query(q)
    print(f"💬 {response}")
```

***

### Пример 2: Мульти-документный RAG с ChromaDB

```python
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, StorageContext, Settings
from llama_index.vector_stores.chroma import ChromaVectorStore
from llama_index.llms.ollama import Ollama
from llama_index.embeddings.ollama import OllamaEmbedding
import chromadb

# Настройка LLM и эмбеддингов
Settings.llm = Ollama(model="llama3:8b", base_url="http://localhost:11434")
Settings.embed_model = OllamaEmbedding(
    model_name="nomic-embed-text",
    base_url="http://localhost:11434"
)

# Подключение к ChromaDB (работающему на том же сервере Clore.ai)
chroma_client = chromadb.HttpClient(host="localhost", port=8001)
chroma_collection = chroma_client.get_or_create_collection("llamaindex_docs")

# Создать векторное хранилище ChromaDB для LlamaIndex
vector_store = ChromaVectorStore(chroma_collection=chroma_collection)
storage_context = StorageContext.from_defaults(vector_store=vector_store)

# Загрузить документы из нескольких источников
docs_dir = "/workspace/data/docs"
documents = SimpleDirectoryReader(
    docs_dir,
    recursive=True,              # Включать поддиректории
    required_exts=[".pdf", ".txt", ".md"],  # Только эти форматы
    filename_as_id=True          # Использовать имя файла как ID документа
).load_data()

print(f"Загружено {len(documents)} документов из {docs_dir}")

# Построить индекс (сохранится в ChromaDB)
index = VectorStoreIndex.from_documents(
    documents,
    storage_context=storage_context,
    show_progress=True
)
print("Индекс построен и сохранён в ChromaDB!")

# Загрузить существующий индекс (для будущих сессий)
# index = VectorStoreIndex.from_vector_store(vector_store)

# Продвинутый движок запросов с фильтрацией по метаданным
from llama_index.core.vector_stores import MetadataFilter, MetadataFilters

# Запрос с фильтром по метаданным
filtered_engine = index.as_query_engine(
    similarity_top_k=5,
    filters=MetadataFilters(
        filters=[
            MetadataFilter(key="file_type", value=".pdf"),
        ]
    )
)

response = filtered_engine.query("Суммируйте ключевые технические концепции в документах.")
print(f"\nОтфильтрованный ответ: {response}")
```

***

### Пример 3: Декомпозиция на под-вопросы

```python
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, Settings
from llama_index.core.query_engine import SubQuestionQueryEngine
from llama_index.core.tools import QueryEngineTool, ToolMetadata
from llama_index.llms.ollama import Ollama
from llama_index.embeddings.ollama import OllamaEmbedding

Settings.llm = Ollama(model="llama3:8b", base_url="http://localhost:11434")
Settings.embed_model = OllamaEmbedding(model_name="nomic-embed-text", base_url="http://localhost:11434")

# Создать отдельные индексы для разных областей знаний
def build_index(docs_path, index_name):
    docs = SimpleDirectoryReader(docs_path).load_data()
    index = VectorStoreIndex.from_documents(docs)
    return index

# Разделённые базы знаний
pricing_index = build_index("/workspace/data/pricing", "pricing")
technical_index = build_index("/workspace/data/technical", "technical")
faq_index = build_index("/workspace/data/faq", "faq")

# Обернуть как инструменты
tools = [
    QueryEngineTool(
        query_engine=pricing_index.as_query_engine(),
        metadata=ToolMetadata(
            name="pricing_docs",
            description="Содержит информацию о ценах, сравнении затрат и деталях биллинга для Clore.ai."
        )
    ),
    QueryEngineTool(
        query_engine=technical_index.as_query_engine(),
        metadata=ToolMetadata(
            name="technical_docs",
            description="Содержит техническую документацию о спецификациях GPU, развёртывании Docker и API."
        )
    ),
    QueryEngineTool(
        query_engine=faq_index.as_query_engine(),
        metadata=ToolMetadata(
            name="faq_docs",
            description="Содержит часто задаваемые вопросы и их ответы."
        )
    ),
]

# Движок по под-вопросам декомпозирует сложные запросы
sub_question_engine = SubQuestionQueryEngine.from_defaults(
    query_engine_tools=tools,
    verbose=True
)

# Сложный многосоставной вопрос
complex_question = """
Сравните стоимость запуска LLM с 7 миллиардами параметров на Clore.ai и на AWS за 100 часов,
и объясните техническую настройку, требуемую для каждого варианта.
"""

print(f"Вопрос: {complex_question}")
response = sub_question_engine.query(complex_question)
print(f"\nПодробный ответ:\n{response}")
```

***

### Пример 4: Индекс графа знаний

```python
from llama_index.core import KnowledgeGraphIndex, SimpleDirectoryReader, Settings
from llama_index.llms.ollama import Ollama
from llama_index.embeddings.ollama import OllamaEmbedding

Settings.llm = Ollama(model="llama3:13b", base_url="http://localhost:11434")  # Более крупная модель для лучшего извлечения
Settings.embed_model = OllamaEmbedding(model_name="nomic-embed-text", base_url="http://localhost:11434")

# Загрузить документы
documents = SimpleDirectoryReader("/workspace/data/docs").load_data()

# Построить граф знаний (извлекает сущности и отношения)
kg_index = KnowledgeGraphIndex.from_documents(
    documents,
    max_triplets_per_chunk=10,   # Извлекать до 10 триплетов на чанк
    include_embeddings=True,
    show_progress=True
)

# Сохранить граф
kg_index.storage_context.persist("/workspace/kg_storage")
print(f"Граф знаний построен!")
print(f"Узлы: {len(kg_index.index_struct.table)}")

# Запрос к графу знаний
kg_query_engine = kg_index.as_query_engine(
    include_text=True,            # Включать исходный текст
    retriever_mode="keyword",     # Использовать поиск по ключевым словам
    response_mode="tree_summarize"
)

questions = [
    "Каковы отношения между моделями GPU и областями применения?",
    "Как связаны ценообразование и спецификации GPU?",
    "Какие методы развёртывания подключаются к каким сервисам?",
]

for q in questions:
    print(f"\n🔍 {q}")
    response = kg_query_engine.query(q)
    print(f"📊 {response}")
```

***

### Пример 5: SQL-движок запросов поверх базы данных

```python
from llama_index.core import SQLDatabase, Settings
from llama_index.core.query_engine import NLSQLTableQueryEngine
from llama_index.llms.ollama import Ollama
from sqlalchemy import create_engine, text
import pandas as pd

Settings.llm = Ollama(model="llama3:8b", base_url="http://localhost:11434")

# Создать пример базы данных с данными маркетплейса GPU
engine = create_engine("sqlite:////workspace/clore_data.db")

# Создать и заполнить таблицы
with engine.connect() as conn:
    conn.execute(text("""
        CREATE TABLE IF NOT EXISTS gpu_servers (
            id INTEGER PRIMARY KEY,
            gpu_model TEXT,
            vram_gb INTEGER,
            price_per_hour REAL,
            location TEXT,
            available INTEGER
        )
    """))

    conn.execute(text("""
        INSERT OR REPLACE INTO gpu_servers VALUES
        (1, 'RTX 4090', 24, 0.65, 'US-East', 1),
        (2, 'RTX 4090', 24, 0.70, 'EU-West', 1),
        (3, 'A100 80G', 80, 2.50, 'US-West', 1),
        (4, 'H100 80G', 80, 4.20, 'US-East', 0),
        (5, 'RTX 3090', 24, 0.35, 'Asia-Pacific', 1),
        (6, 'RTX 3080', 10, 0.20, 'EU-East', 1),
        (7, 'A100 40G', 40, 1.50, 'US-East', 1)
    """))
    conn.commit()

# Создать обёртку LlamaIndex для SQL-базы данных
sql_database = SQLDatabase(engine, include_tables=["gpu_servers"])

# Движок преобразования естественного языка в SQL
query_engine = NLSQLTableQueryEngine(
    sql_database=sql_database,
    tables=["gpu_servers"],
)

# Запрашивать базу данных на естественном языке
nl_queries = [
    "Какой самый дешёвый доступный GPU-сервер?",
    "Покажите все GPU-серверы с более чем 40 ГБ VRAM",
    "Какова средняя цена в час для серверов RTX 4090?",
    "В каких локациях доступны GPU-серверы?",
    "Перечислите все доступные серверы A100, отсортированные по цене",
]

for query in nl_queries:
    print(f"\n💬 На естественном языке: {query}")
    response = query_engine.query(query)
    print(f"📊 Ответ: {response}")
    if hasattr(response, 'metadata') and 'sql_query' in response.metadata:
        print(f"🔧 SQL: {response.metadata['sql_query']}")
```

***

## Конфигурация

### Docker Compose (Полный стек LlamaIndex)

```yaml
version: '3.8'

services:
  ollama:
    image: ollama/ollama:latest
    container_name: ollama
    runtime: nvidia
    ports:
      - "11434:11434"
    volumes:
      - ollama_models:/root/.ollama
    environment:
      - NVIDIA_VISIBLE_DEVICES=all
    restart: unless-stopped

  chromadb:
    image: chromadb/chroma:latest
    container_name: chromadb
    ports:
      - "8001:8000"
    volumes:
      - chroma_data:/chroma/chroma
    environment:
      - IS_PERSISTENT=TRUE
      - ANONYMIZED_TELEMETRY=FALSE
    restart: unless-stopped

  llamaindex-api:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: llamaindex-api
    ports:
      - "8000:8000"
    volumes:
      - ./data:/workspace/data
      - ./indices:/workspace/indices
    environment:
      - OLLAMA_BASE_URL=http://ollama:11434
      - CHROMA_HOST=chromadb
      - CHROMA_PORT=8000
      - LLM_MODEL=llama3:8b
      - EMBED_MODEL=nomic-embed-text
    depends_on:
      - ollama
      - chromadb
    restart: unless-stopped

volumes:
  ollama_models:
  chroma_data:
```

### Ключевые переменные конфигурации

| Параметр                  | По умолчанию   | Описание                          |
| ------------------------- | -------------- | --------------------------------- |
| `Settings.llm`            | OpenAI GPT-3.5 | LLM для генерации                 |
| `Settings.embed_model`    | OpenAI Ada     | Модель эмбеддингов                |
| `Settings.chunk_size`     | 1024           | Размер текстового чанка в токенах |
| `Settings.chunk_overlap`  | 200            | Перекрытие между чанками          |
| `Settings.num_output`     | 256            | Максимум токенов в ответе LLM     |
| `Settings.context_window` | 4096           | Размер контекстного окна LLM      |

***

## Советы по производительности

### 1. Асинхронные запросы для пропускной способности

```python
import asyncio
from llama_index.core import VectorStoreIndex

query_engine = index.as_query_engine(use_async=True)

async def batch_query(questions):
    tasks = [query_engine.aquery(q) for q in questions]
    return await asyncio.gather(*tasks)

questions = ["Q1?", "Q2?", "Q3?", "Q4?", "Q5?"]
answers = asyncio.run(batch_query(questions))
```

### 2. Гибридный поиск (ключевые слова + семантический)

```python
from llama_index.core import VectorStoreIndex
from llama_index.core.retrievers import VectorIndexRetriever, KeywordTableSimpleRetriever
from llama_index.core.query_engine import RetrieverQueryEngine
from llama_index.core.retrievers import QueryFusionRetriever

# Комбинировать векторный и ключевой поиск
retriever = QueryFusionRetriever(
    [
        index.as_retriever(similarity_top_k=5),  # Векторный поиск
        index.as_retriever(retriever_mode="keyword"),  # Поиск по ключевым словам
    ],
    similarity_top_k=5,
    num_queries=3,  # Генерировать несколько вариантов запроса
    use_async=True,
    verbose=True,
)

query_engine = RetrieverQueryEngine(retriever=retriever)
```

### 3. Переранжирование для качества

```python
from llama_index.core.postprocessor import SentenceTransformerRerank

# Добавить шаг переранжирования после поиска
reranker = SentenceTransformerRerank(
    model="cross-encoder/ms-marco-MiniLM-L-2-v2",
    top_n=3
)

query_engine = index.as_query_engine(
    similarity_top_k=10,  # Получать больше кандидатов
    node_postprocessors=[reranker]  # Переранжировать до топ-3
)
```

### 4. Стриминг для отзывчивых интерфейсов

```python
# Стримить токены по мере их генерации
streaming_engine = index.as_query_engine(streaming=True)
response = streaming_engine.query("Объясните, как работает Clore.ai")

for token in response.response_gen:
    print(token, end="", flush=True)
```

***

## Устранение неполадок

### Проблема: модель эмбеддингов не подключается к Ollama

```bash
# Проверить эмбеддинги Ollama напрямую
curl http://localhost:11434/api/embeddings -d '{
  "model": "nomic-embed-text",
  "prompt": "тестовый текст"
}'
```

### Проблема: построение индекса медленное

```bash
# Отслеживать использование GPU во время эмбеддинга
watch -n1 nvidia-smi

# Используйте меньшие размеры пакетов
from llama_index.core import VectorStoreIndex
index = VectorStoreIndex.from_documents(
    доки,
    show_progress=True,
    # Вставлять меньшими пакетами
)
```

### Проблема: ModuleNotFoundError для интеграций

```bash
# LlamaIndex использует плагинную архитектуру в v0.10+
pip install llama-index-llms-ollama
pip install llama-index-embeddings-ollama
pip install llama-index-vector-stores-chroma

# Проверить установленные пакеты
pip list | grep llama
```

### Проблема: превышено окно контекста

```python
# Уменьшить размер чанка
Settings.chunk_size = 512
Settings.chunk_overlap = 50

# Или использовать модель с большим контекстом
Settings.llm = Ollama(
    model="llama3:8b",
    context_window=8192  # Расширить окно контекста
)
```

### Проблема: запросы возвращают нерелевантные результаты

```python
# Увеличить top-k по похожести
query_engine = index.as_query_engine(similarity_top_k=10)

# Или использовать лучшую модель эмбеддингов
from llama_index.embeddings.huggingface import HuggingFaceEmbedding
Settings.embed_model = HuggingFaceEmbedding(
    model_name="BAAI/bge-large-en-v1.5"
)
```

***

## Ссылки

* **GitHub**: <https://github.com/run-llama/llama_index>
* **Официальная документация**: <https://docs.llamaindex.ai>
* **PyPI**: <https://pypi.org/project/llama-index>
* **Интеграции**: <https://llamahub.ai>
* **Discord**: <https://discord.gg/dGcwcsnxhU>
* **Блог**: <https://www.llamaindex.ai/blog>
* **CLORE.AI Маркетплейс**: <https://clore.ai/marketplace>

***

## Рекомендации Clore.ai по GPU

| Сценарий использования                   | Рекомендуемый GPU | Примерная стоимость на Clore.ai |
| ---------------------------------------- | ----------------- | ------------------------------- |
| Разработка/Тестирование                  | RTX 3090 (24GB)   | \~$0.12/gpu/hr                  |
| Production RAG                           | RTX 3090 (24GB)   | \~$0.12/gpu/hr                  |
| Высокопропускная способность эмбеддингов | RTX 4090 (24GB)   | \~$0.70/gpu/hr                  |

> 💡 Все примеры в этом руководстве можно развернуть на [Clore.ai](https://clore.ai/marketplace) GPU-серверах. Просматривайте доступные GPU и арендуйте по часам — без обязательств, с полным root-доступом.