> 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) по миллиардам векторов с продвинутой фильтрацией, индексированием полезных данных (payload) и поддержкой мультивекторных структур. Она является основой многих производственных конвейеров RAG (Retrieval-Augmented Generation) и приложений семантического поиска.

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

***

## Почему Qdrant?

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

{% hint style="success" %}
**Qdrant написан на Rust** — обеспечивает производительность уровня С с безопасностью памяти. Тесты производительности показывают, что 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 с 32GB+ памяти
3. Для **только обслуживание:** Сервер, оптимизированный под CPU, с быстрым NVMe-хранилищем

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

* Каждый float32-вектор с 1536 измерениями = 6KB
* 1 миллион векторов = \~6GB ОЗУ
* 10 миллионов векторов = \~60GB ОЗУ
* Включите хранение на диске для очень больших коллекций
  {% 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 - vector search engine","version":"..."}

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

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

***

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

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

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

client = QdrantClient("localhost", port=6333)
print(f"Qdrant connected: {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 (больше = лучшее восстановление, больше ОЗУ)
        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        # Держать квантованный индекс в ОЗУ
        )
    )
)

print("Collection created!")
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 Embeddings

```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 is a vector database built in Rust for high performance.",
        "source": "documentation",
        "category": "database",
        "year": 2024
    },
    {
        "id": str(uuid.uuid4()),
        "text": "Machine learning models convert text to dense vector representations.",
        "source": "article",
        "category": "ml",
        "year": 2023
    },
    # Добавьте больше документов...
]

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

# Вставить в Qdrant (upsert)
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"Indexed {len(points)} documents!")
```

### С 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": "How do I set up Qdrant on a GPU server?", "tag": "setup"},
    {"text": "Vector databases store high-dimensional embeddings for similarity search.", "tag": "concept"},
    {"text": "HNSW algorithm provides approximate nearest neighbor search.", "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"Indexed {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("vector database performance")
for r in results:
    print(f"Score: {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 = [
    "how to install vector database",
    "machine learning inference optimization",
    "RAG pipeline architecture"
]

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"\nQuery: {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: Встроить (embed) вопрос
    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"[Source: {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"Context:\n{context}\n\nQuestion: {question}"
            }
        ],
        temperature=0.1
    )
    
    return response.choices[0].message.content

# Тест RAG-конвейера
answer = rag_query("What is Qdrant and how does it work?")
print(answer)
```

***

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

```python
# Статистика по коллекции
info = client.get_collection("documents")
print(f"Vectors count: {info.vectors_count:,}")
print(f"Points count: {info.points_count:,}")
print(f"Indexed vectors: {info.indexed_vectors_count:,}")
print(f"Status: {info.status}")
print(f"Disk usage: {info.disk_data_size / 1024 / 1024:.1f} MB")

# Список всех коллекций
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, чтобы уместить больше векторов в ОЗУ
```

### Высокое использование памяти

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

***

## Краткое руководство по 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, 32GB ОЗУ | \~$60–80              | \~5M векторов  |
| Средний поиск    | RTX 4090, 64GB ОЗУ | \~$120–150            | \~15M векторов |
| Крупномасштабный | A100, 128GB ОЗУ    | \~$250–350            | \~30M векторов |

***

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

* [Документация Qdrant](https://qdrant.tech/documentation/)
* [Qdrant на GitHub](https://github.com/qdrant/qdrant)
* [Qdrant Python Client](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-конвейеров, обрабатывающих миллионы документов.*

***

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

| Сценарий использования                   | Рекомендуемый GPU | Примерная стоимость на Clore.ai |
| ---------------------------------------- | ----------------- | ------------------------------- |
| Разработка/Тестирование                  | RTX 3090 (24GB)   | \~$0.12/gpu/hr                  |
| Производственный векторный поиск         | 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
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.