> 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/guides/guides_v2-ru/rag-i-vektornye-bazy-dannykh/qdrant.md).

# Qdrant

> **Высокопроизводительная векторная база данных для семантического поиска и приложений RAG — индексация с ускорением на GPU**

Qdrant — это векторная база данных с открытым исходным кодом, готовая к использованию в продакшене, написанная на Rust. Она обеспечивает быстрый приблизительный поиск ближайших соседей (ANN) по миллиардам векторов с продвинутой фильтрацией, индексацией полезной нагрузки и поддержкой мультивекторов. Это основа многих продакшн-конвейеров RAG (Retrieval-Augmented Generation) и приложений семантического поиска.

**GitHub:** [qdrant/qdrant](https://github.com/qdrant/qdrant) — 22K+ ⭐

***

## Почему Qdrant?

| Функция                      | Qdrant        | Pinecone        | Weaviate | Chroma       |
| ---------------------------- | ------------- | --------------- | -------- | ------------ |
| Открытый исходный код        | ✅             | ❌               | ✅        | ✅            |
| Производительность Rust      | ✅             | —               | ❌ Go     | ❌ Python     |
| Фильтрация во время запроса  | ✅ Продвинутая | ✅ Базовая       | ✅        | ✅ Базовая    |
| Многовекторность             | ✅             | ❌               | ✅        | ❌            |
| HNSW на диске                | ✅             | ✅               | ✅        | ❌            |
| Индексация полезной нагрузки | ✅             | Ограниченная    | ✅        | Ограниченная |
| gRPC + REST                  | ✅ Оба         | ✅ REST          | ✅        | REST         |
| Самостоятельный хостинг      | ✅             | ❌ Только облако | ✅        | ✅            |

{% hint style="success" %}
**Qdrant написан на Rust** — обеспечивая производительность уровня C с безопасностью памяти. Бенчмарк-тесты показывают, что Qdrant стабильно **в 1,5–3 раза быстрее** чем Python-ориентированные альтернативы, такие как Chroma, в сценариях с высокой нагрузкой.
{% endhint %}

***

## Ключевые сценарии использования

* **RAG (Retrieval-Augmented Generation)** — находить релевантный контекст для запросов к LLM
* **Семантический поиск** — поиск по смыслу, а не только по ключевым словам
* **Рекомендательные системы** — находить похожие объекты по сходству эмбеддингов
* **Обнаружение дубликатов** — выявлять почти дублирующийся контент
* **Обнаружение аномалий** — находить векторы, удалённые от центров кластеров
* **Поиск похожих изображений/аудио** — мультимодальный поиск

***

## Предварительные требования

* Аккаунт Clore.ai с арендой GPU
* Базовое знакомство с REST API или Python
* Модель эмбеддингов на ваш выбор (OpenAI, SentenceTransformers и т. д.)

***

## Шаг 1 — арендуйте сервер на Clore.ai

Для обслуживания Qdrant в основном упирается в CPU/RAM, но выигрывает от GPU, когда:

* Генерация эмбеддингов одновременно с обслуживанием (модель эмбеддингов на том же сервере)
* Масштабные пакетные операции индексации

1. Перейдите на [маркетплейсе clore.ai](https://clore.ai) → **Маркетплейс**
2. Для **комбинация эмбеддингов + обслуживания:** RTX 3090/4090 с 32+ ГБ RAM
3. Для **только обслуживание:** сервер, оптимизированный для CPU, с быстрым NVMe-хранилищем

{% hint style="info" %}
**Планирование памяти:**

* Каждый вектор float32 с 1536 измерениями = 6 КБ
* 1 миллион векторов = \~6 ГБ RAM
* 10 миллионов векторов = \~60 ГБ RAM
* Включайте хранение на диске для очень больших коллекций
  {% endhint %}

***

## Шаг 2 — разверните контейнер Qdrant

**Docker-образ:**

```
qdrant/qdrant:latest
```

**Порты:**

```
22
6333
6334
```

* **Порт 6333:** REST API (HTTP)
* **Порт 6334:** gRPC API (более высокая производительность для массовых операций)

**Переменные среды:**

```
QDRANT__SERVICE__HTTP_PORT=6333
QDRANT__SERVICE__GRPC_PORT=6334
QDRANT__LOG_LEVEL=INFO
QDRANT__STORAGE__STORAGE_PATH=/qdrant/storage
```

**Том/постоянное хранилище:** Подключить `/qdrant/storage` для сохранения данных. Без этого данные будут потеряны при перезапуске контейнера.

***

## Шаг 3 — проверьте, что Qdrant запущен

```bash
ssh root@<server-ip> -p <ssh-port>

# Проверьте, что Qdrant запущен
curl http://localhost:6333/

# Ожидаемый ответ:
# {"title":"qdrant — векторный поисковый движок","version":"..."}

# Проверить состояние
curl http://localhost:6333/healthz

# Проверьте информацию о кластере
curl http://localhost:6333/cluster
```

***

## Шаг 4 — установите Python-клиент

```bash
# Установите Python-клиент Qdrant и инструменты для эмбеддингов
pip install qdrant-client sentence-transformers openai numpy

# Проверьте соединение
python3 << 'EOF'
from qdrant_client import QdrantClient

client = QdrantClient("localhost", port=6333)
print(f"Соединение с Qdrant установлено: {client.get_collections()}")
EOF
```

***

## Шаг 5 — создайте коллекцию

Коллекция — это именованная группа векторов с фиксированной размерностью.

```python
from qdrant_client import QdrantClient
from qdrant_client.models import (
    Distance,
    VectorParams,
    HnswConfigDiff,
    OptimizersConfigDiff,
    QuantizationConfig,
    ScalarQuantizationConfig,
    ScalarType
)

client = QdrantClient("localhost", port=6333)

# Создайте коллекцию для OpenAI text-embedding-3-small (1536 измерений)
client.create_collection(
    collection_name="documents",
    vectors_config=VectorParams(
        size=1536,           # Размерность вектора (соответствует вашей модели эмбеддингов)
        distance=Distance.COSINE,  # Варианты: COSINE, EUCLID, DOT
        on_disk=False        # Установите True для очень больших коллекций
    ),
    hnsw_config=HnswConfigDiff(
        m=16,                # Связность графа HNSW (больше = выше полнота, больше RAM)
        ef_construct=100,    # Глубина поиска при построении (больше = выше качество, медленнее индексация)
        full_scan_threshold=10000  # Используйте полный перебор ниже этого порога
    ),
    optimizers_config=OptimizersConfigDiff(
        indexing_threshold=20000  # Начинать индексацию HNSW после этого числа векторов
    ),
    quantization_config=QuantizationConfig(
        scalar=ScalarQuantizationConfig(
            type=ScalarType.INT8,  # Сжать векторы до INT8 (сокращение памяти в 4 раза)
            quantile=0.99,
            always_ram=True        # Хранить квантизированный индекс в RAM
        )
    )
)

print("Коллекция создана!")
print(client.get_collection("documents"))
```

### Коллекция для SentenceTransformers (384 измерения)

```python
client.create_collection(
    collection_name="embeddings_384",
    vectors_config=VectorParams(
        size=384,              # Размер выхода all-MiniLM-L6-v2
        distance=Distance.COSINE
    )
)
```

***

## Шаг 6 — индексируйте документы

### С эмбеддингами OpenAI

```python
from qdrant_client import QdrantClient
from qdrant_client.models import PointStruct
from openai import OpenAI
import uuid

client = QdrantClient("localhost", port=6333)
openai_client = OpenAI(api_key="your-openai-api-key")

def get_embeddings(texts: list[str], batch_size: int = 100) -> list[list[float]]:
    """Генерировать эмбеддинги пакетами."""
    all_embeddings = []
    for i in range(0, len(texts), batch_size):
        batch = texts[i:i + batch_size]
        response = openai_client.embeddings.create(
            model="text-embedding-3-small",
            input=batch
        )
        all_embeddings.extend([e.embedding for e in response.data])
    return all_embeddings

# Примеры документов
documents = [
    {
        "id": str(uuid.uuid4()),
        "text": "Qdrant — это векторная база данных, созданная на Rust для высокой производительности.",
        "source": "documentation",
        "category": "database",
        "year": 2024
    },
    {
        "id": str(uuid.uuid4()),
        "text": "Модели машинного обучения преобразуют текст в плотные векторные представления.",
        "source": "article",
        "category": "ml",
        "year": 2023
    },
    # Добавьте больше документов...
]

# Сгенерировать эмбеддинги
texts = [doc["text"] for doc in documents]
embeddings = get_embeddings(texts)

# Выполнить upsert в Qdrant
points = [
    PointStruct(
        id=str(uuid.uuid4()),
        vector=embedding,
        payload={
            "text": doc["text"],
            "source": doc["source"],
            "category": doc["category"],
            "year": doc["year"]
        }
    )
    for doc, embedding in zip(documents, embeddings)
]

client.upsert(
    collection_name="documents",
    points=points,
    wait=True  # Дождаться завершения индексации
)

print(f"Проиндексировано {len(points)} документов!")
```

### С SentenceTransformers (локально, с ускорением на GPU)

```python
from sentence_transformers import SentenceTransformer
from qdrant_client import QdrantClient
from qdrant_client.models import PointStruct
import torch
import uuid

# Загрузить модель эмбеддингов на GPU
model = SentenceTransformer("all-MiniLM-L6-v2", device="cuda")

client = QdrantClient("localhost", port=6333)

documents = [
    {"text": "Как настроить Qdrant на сервере с GPU?", "tag": "setup"},
    {"text": "Векторные базы данных хранят высокоразмерные эмбеддинги для поиска похожих объектов.", "tag": "concept"},
    {"text": "Алгоритм HNSW обеспечивает приближённый поиск ближайших соседей.", "tag": "algorithm"},
    # ... дополнительные документы
]

# Пакетное кодирование с ускорением на GPU
texts = [doc["text"] for doc in documents]
embeddings = model.encode(
    texts,
    batch_size=256,       # Большой размер пакета для эффективности GPU
    show_progress_bar=True,
    normalize_embeddings=True  # Нормализовать для косинусного сходства
)

# Индексация в Qdrant
points = [
    PointStruct(
        id=str(uuid.uuid4()),
        vector=embedding.tolist(),
        payload=doc
    )
    for doc, embedding in zip(documents, embeddings)
]

# Пакетный upsert (эффективнее)
BATCH_SIZE = 1000
for i in range(0, len(points), BATCH_SIZE):
    batch = points[i:i + BATCH_SIZE]
    client.upsert(collection_name="embeddings_384", points=batch)
    print(f"Проиндексировано {min(i + BATCH_SIZE, len(points))}/{len(points)}")
```

***

## Шаг 7 — поиск и запросы

### Базовый семантический поиск

```python
from qdrant_client import QdrantClient
from sentence_transformers import SentenceTransformer

client = QdrantClient("localhost", port=6333)
model = SentenceTransformer("all-MiniLM-L6-v2", device="cuda")

def search(query: str, limit: int = 5, collection: str = "embeddings_384"):
    # Сгенерировать эмбеддинг запроса
    query_vector = model.encode(query, normalize_embeddings=True).tolist()
    
    # Поиск
    results = client.search(
        collection_name=collection,
        query_vector=query_vector,
        limit=limit,
        with_payload=True,
        with_vectors=False    # Не возвращать векторы (экономит трафик)
    )
    
    return results

# Тестовый поиск
results = search("производительность векторной базы данных")
for r in results:
    print(f"Оценка: {r.score:.4f} | {r.payload['text'][:100]}")
```

### Фильтрованный поиск (метаданные + вектор)

```python
from qdrant_client.models import Filter, FieldCondition, MatchValue, Range

# Поиск с фильтрами по метаданным
results = client.search(
    collection_name="documents",
    query_vector=query_vector,
    query_filter=Filter(
        must=[
            FieldCondition(
                key="category",
                match=MatchValue(value="database")
            ),
            FieldCondition(
                key="year",
                range=Range(gte=2023)  # Год >= 2023
            )
        ]
    ),
    limit=10,
    with_payload=True
)
```

### Пакетный/многозапросный поиск

```python
from qdrant_client.models import SearchRequest

queries = [
    "как установить векторную базу данных",
    "оптимизация инференса машинного обучения",
    "архитектура RAG-пайплайна"
]

query_vectors = model.encode(queries, normalize_embeddings=True)

# Пакетный поиск (один API-вызов для всех запросов)
results = client.search_batch(
    collection_name="embeddings_384",
    requests=[
        SearchRequest(
            vector=vec.tolist(),
            limit=5,
            with_payload=True
        )
        for vec in query_vectors
    ]
)

for query, res in zip(queries, results):
    print(f"\nЗапрос: {query}")
    for r in res:
        print(f"  {r.score:.3f}: {r.payload['text'][:80]}")
```

***

## Шаг 8 — постройте RAG-пайплайн

```python
from qdrant_client import QdrantClient
from sentence_transformers import SentenceTransformer
from openai import OpenAI

# Инициализировать клиентов
qdrant = QdrantClient("localhost", port=6333)
embedder = SentenceTransformer("all-MiniLM-L6-v2", device="cuda")
llm = OpenAI(api_key="your-openai-key")

def rag_query(question: str, n_context: int = 5) -> str:
    # Шаг 1: Создать эмбеддинг вопроса
    query_vector = embedder.encode(question, normalize_embeddings=True).tolist()
    
    # Шаг 2: Получить релевантный контекст из Qdrant
    search_results = qdrant.search(
        collection_name="documents",
        query_vector=query_vector,
        limit=n_context,
        with_payload=True
    )
    
    # Шаг 3: Сформировать строку контекста
    context = "\n\n".join([
        f"[Источник: {r.payload.get('source', 'unknown')}]\n{r.payload['text']}"
        for r in search_results
        if r.score > 0.5  # Отфильтровать результаты с низкой уверенностью
    ])
    
    # Шаг 4: Сгенерировать ответ с помощью LLM
    response = llm.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {
                "role": "system",
                "content": "Отвечайте на вопросы на основе предоставленного контекста. Будьте краткими и точными."
            },
            {
                "role": "user",
                "content": f"Контекст:\n{context}\n\nВопрос: {question}"
            }
        ],
        temperature=0.1
    )
    
    return response.choices[0].message.content

# Проверка RAG-пайплайна
answer = rag_query("Что такое Qdrant и как он работает?")
print(answer)
```

***

## Шаг 9 — мониторинг и управление коллекциями

```python
# Статистика коллекции
info = client.get_collection("documents")
print(f"Количество векторов: {info.vectors_count:,}")
print(f"Количество точек: {info.points_count:,}")
print(f"Проиндексированных векторов: {info.indexed_vectors_count:,}")
print(f"Статус: {info.status}")
print(f"Использование диска: {info.disk_data_size / 1024 / 1024:.1f} МБ")

# Список всех коллекций
collections = client.get_collections()
for c in collections.collections:
    print(f" - {c.name}")

# Удалить точки по фильтру
client.delete(
    collection_name="documents",
    points_selector=Filter(
        must=[FieldCondition(key="source", match=MatchValue(value="old_source"))]
    )
)

# Оптимизировать коллекцию (принудительно построить индекс)
client.update_collection(
    collection_name="documents",
    optimizer_config=OptimizersConfigDiff(indexing_threshold=0)  # Принудительно немедленно начать индексацию
)
```

***

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

### Отказано в соединении

```bash
# Проверьте, что Qdrant запущен
docker ps | grep qdrant
# Или проверьте процесс
ps aux | grep qdrant

# Проверьте, что порты открыты
curl http://localhost:6333/
netstat -tlnp | grep 6333
```

### Низкая производительность поиска

```python
# Оптимизируйте параметры HNSW для лучшей полноты
client.update_collection(
    collection_name="documents",
    hnsw_config=HnswConfigDiff(ef=128)  # Увеличьте ef во время поиска (по умолчанию 100)
)

# Используйте квантизацию INT8, чтобы поместить больше векторов в RAM
```

### Высокое потребление памяти

```python
# Включите хранение на диске для больших коллекций
client.create_collection(
    collection_name="large_collection",
    vectors_config=VectorParams(
        size=1536,
        distance=Distance.COSINE,
        on_disk=True  # Хранить векторы на диске вместо RAM
    )
)
```

***

## Краткая справка по REST API

```bash
# Список коллекций
curl http://localhost:6333/collections

# Создать коллекцию
curl -X PUT http://localhost:6333/collections/my_collection \\
    -H "Content-Type: application/json" \\
    -d '{"vectors": {"size": 384, "distance": "Cosine"}}'

# Подсчитать точки
curl http://localhost:6333/collections/my_collection/points/count

# Поиск
curl -X POST http://localhost:6333/collections/my_collection/points/search \\
    -H "Content-Type: application/json" \\
    -d '{
        "vector": [0.1, 0.2, ...],
        "limit": 5,
        "with_payload": true
    }'

# Удалить коллекцию
curl -X DELETE http://localhost:6333/collections/my_collection
```

***

## Оценка стоимости на Clore.ai

| Конфигурация    | Сервер              | Ежемесячная стоимость | Ёмкость           |
| --------------- | ------------------- | --------------------- | ----------------- |
| Небольшой RAG   | RTX 3090, 32 ГБ ОЗУ | \~$60–80              | \~5 млн векторов  |
| Средний поиск   | RTX 4090, 64 ГБ ОЗУ | \~$120–150            | \~15 млн векторов |
| Крупный масштаб | A100, 128 ГБ ОЗУ    | \~$250–350            | \~30 млн векторов |

***

## Дополнительные ресурсы

* [Документация Qdrant](https://qdrant.tech/documentation/)
* [Qdrant GitHub](https://github.com/qdrant/qdrant)
* [Python-клиент Qdrant](https://github.com/qdrant/qdrant-client)
* [Примеры Qdrant](https://github.com/qdrant/examples)
* [Бенчмарки векторных баз данных](https://qdrant.tech/benchmarks/)
* [Sentence Transformers](https://www.sbert.net/)

***

*Qdrant на Clore.ai предоставляет вам высокопроизводительную векторную базу данных с самостоятельным хостингом без затрат за каждый запрос, как у Pinecone или Weaviate Cloud. Идеально подходит для RAG-пайплайнов, обрабатывающих миллионы документов.*

***

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

| Сценарий использования                                  | Рекомендуемый GPU | Оценочная стоимость на Clore.ai |
| ------------------------------------------------------- | ----------------- | ------------------------------- |
| Разработка/тестирование                                 | RTX 3090 (24 ГБ)  | $0.07–0.21/гпу/ч                |
| Векторный поиск для production                          | RTX 3090 (24 ГБ)  | $0.07–0.21/гпу/ч                |
| Генерация эмбеддингов с высокой пропускной способностью | RTX 4090 (24 ГБ)  | $0.14–0.42/гпу/ч                |

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


---

# 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 dynamically by asking a question.

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

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.