# 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-доступом.


---

# Agent Instructions: Querying This Documentation

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

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-ru/rag-i-vektornye-bazy-dannykh/llamaindex.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.