Qdrant

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

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

GitHub: qdrant/qdrant — 22K+ ⭐

---

Почему Qdrant?

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

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

---

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

• RAG (Retrieval-Augmented Generation) — находить релевантный контекст для запросов к LLM

• Семантический поиск — поиск по смыслу, а не только по ключевым словам

• Рекомендательные системы — находить похожие объекты по сходству эмбеддингов

• Обнаружение дубликатов — выявлять почти дублирующийся контент

• Обнаружение аномалий — находить векторы, удалённые от центров кластеров

• Поиск похожих изображений/аудио — мультимодальный поиск

---

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

• Аккаунт Clore.ai с арендой GPU

• Базовое знакомство с REST API или Python

• Модель эмбеддингов на ваш выбор (OpenAI, SentenceTransformers и т. д.)

---

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

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

• Генерация эмбеддингов одновременно с обслуживанием (модель эмбеддингов на том же сервере)

• Масштабные пакетные операции индексации

1. Перейдите на маркетплейсе clore.ai → Маркетплейс

2. Для комбинация эмбеддингов + обслуживания: RTX 3090/4090 с 32+ ГБ RAM

3. Для только обслуживание: сервер, оптимизированный для CPU, с быстрым NVMe-хранилищем

Планирование памяти:

• Каждый вектор float32 с 1536 измерениями = 6 КБ

• 1 миллион векторов = ~6 ГБ RAM

• 10 миллионов векторов = ~60 ГБ RAM

• Включайте хранение на диске для очень больших коллекций

---

Шаг 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 запущен

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-клиент

# Установите 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 — создайте коллекцию

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

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 измерения)

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

---

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

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

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)

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 — поиск и запросы

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

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

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

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
)

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

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-пайплайн

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 — мониторинг и управление коллекциями

# Статистика коллекции
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)  # Принудительно немедленно начать индексацию
)

---

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

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

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

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

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

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

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

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

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

---

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

# Список коллекций
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

• Qdrant GitHub

• Python-клиент Qdrant

• Примеры Qdrant

• Бенчмарки векторных баз данных

• Sentence Transformers

---

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 GPU-серверах. Просматривайте доступные GPU и арендуйте по часам — без обязательств, с полным root-доступом.