Конспект 3: Qdrant в N8N

Qdrant Instance (Инстанс)
    │
    ├─ Collection 1 (Коллекция)
    │   ├─ Point 1 (Точка)
    │   │   ├─ Vector (Вектор) [0.23, -0.15, 0.87, ...]
    │   │   └─ Payload (Метаданные) {name, date, category...}
    │   ├─ Point 2
    │   └─ Point N
    │
    ├─ Collection 2
    │   └─ [Points...]
    │
    └─ Collection N
        └─ [Points...]

{
  "id": "12345",
  "vector": [0.23, -0.15, 0.87, ..., 0.42],
  "payload": {
    "title": "N8N - платформа автоматизации",
    "author": "Иван",
    "date": "2025-11-26",
    "category": "AI",
    "language": "ru",
    "embedding_model": "text-embedding-3-small"
  }
}

Qdrant Storage
├─ collection_name/
│   ├─ vectors.dat (сами векторы)
│   ├─ vectors.idx (индекс для быстрого поиска)
│   ├─ payload/ (метаданные)
│   └─ config.json (параметры коллекции)
└─ [другие коллекции...]

{
  "m": 16,              // Количество соединений на каждом уровне
  "ef_construct": 200,  // Качество построения индекса
  "ef": 150             // Глубина поиска при запросе
}

ef параметр увеличиваем → точность ↑, скорость ↓
ef параметр уменьшаем → точность ↓, скорость ↑

docker run -it --rm \
  -p 6333:6333 \
  -v qdrant_storage:/qdrant/storage \
  qdrant/qdrant

docker run -it --rm \
  -p 6333:6333 \
  -v qdrant_storage:/qdrant/storage \
  -e QDRANT_API_KEY=test_key_12345 \
  qdrant/qdrant

version: '3.8'

services:
  n8n:
    image: n8nio/n8n
    ports:
      - "5678:5678"
    environment:
      - N8N_BASIC_AUTH_ACTIVE=true
      - N8N_BASIC_AUTH_USER=admin
      - N8N_BASIC_AUTH_PASSWORD=password123
    networks:
      - demo

  qdrant:
    image: qdrant/qdrant
    hostname: qdrant
    ports:
      - "6333:6333"
    environment:
      - QDRANT_API_KEY=test
    volumes:
      - qdrant_storage:/qdrant/storage
    networks:
      - demo

volumes:
  qdrant_storage:

networks:
  demo:
    driver: bridge

docker-compose up -d

Qdrant Node
├─ Credentials (учетные данные)
├─ Resource (тип операции)
├─ Operation (конкретная операция)
└─ Parameters (параметры)

{
  "collectionName": "documents",
  "vectorSize": 1536,
  "distanceMetric": "Cosine",
  "onVectorSizeMismatch": "error"
}

from qdrant_client import QdrantClient, models

client = QdrantClient(url="http://localhost:6333", api_key="test")

client.create_collection(
    collection_name="documents",
    vectors_config=models.VectorParams(
        size=1536,
        distance=models.Distance.COSINE
    )
)

{
  "name": "documents",
  "vectors": 1000,
  "status": "green",
  "config": {
    "params": {
      "vectors": {
        "size": 1536,
        "distance": "Cosine"
      }
    }
  }
}

{
  "collectionName": "documents",
  "hnsw": {
    "ef": 200,
    "m": 16
  }
}

{
  "collectionName": "documents"
}

{
  "collectionName": "documents",
  "points": [
    {
      "id": 1,
      "vector": [0.23, -0.15, 0.87, ..., 0.42],
      "payload": {
        "title": "N8N - платформа автоматизации",
        "author": "Иван",
        "date": "2025-11-26",
        "category": "AI",
        "embedding_model": "text-embedding-3-small"
      }
    },
    {
      "id": 2,
      "vector": [0.45, 0.12, -0.34, ..., 0.21],
      "payload": {
        "title": "Qdrant для N8N",
        "author": "Мария",
        "date": "2025-11-25",
        "category": "Database"
      }
    }
  ]
}

{
  "collectionName": "documents",
  "pointId": 1
}

{
  "id": 1,
  "vector": [0.23, -0.15, 0.87, ..., 0.42],
  "payload": {
    "title": "N8N - платформа автоматизации",
    ...
  }
}

{
  "collectionName": "documents",
  "pointIds": [1, 2, 3, 5]
}

{
  "points": [
    { "id": 1, "vector": [...], "payload": {...} },
    { "id": 2, "vector": [...], "payload": {...} },
    { "id": 3, "vector": [...], "payload": {...} },
    { "id": 5, "vector": [...], "payload": {...} }
  ]
}

{
  "collectionName": "documents",
  "pointIds": [1, 2, 3]
}

{
  "collectionName": "documents",
  "filter": {
    "must": [
      {
        "key": "category",
        "match": { "value": "old_content" }
      }
    ]
  }
}

{
  "collectionName": "documents"
}

{
  "collectionName": "documents",
  "filter": {
    "must": [
      {
        "key": "is_active",
        "match": { "value": true }
      }
    ]
  }
}

{
  "collectionName": "documents",
  "points": [
    {
      "id": 1,
      "vector": [0.23, -0.15, 0.87, ..., 0.42],
      "payload": {
        "status": "updated",
        "updated_at": "2025-11-26"
      }
    }
  ]
}

{
  "collectionName": "documents",
  "vector": [0.23, -0.15, 0.87, ..., 0.42],
  "limit": 10,
  "scoreThreshold": 0.7
}

{
  "result": [
    {
      "id": 5,
      "score": 0.92,
      "payload": {
        "title": "N8N - платформа автоматизации",
        "category": "AI"
      }
    },
    {
      "id": 3,
      "score": 0.85,
      "payload": {
        "title": "Qdrant для N8N",
        "category": "Database"
      }
    }
  ]
}

{
  "collectionName": "documents",
  "vector": {
    "name": "description_vector",
    "vector": [0.23, -0.15, 0.87, ..., 0.42]
  },
  "limit": 5
}

{
  "collectionName": "documents",
  "pointId": 1,
  "limit": 5
}

{
  "collectionName": "documents",
  "searches": [
    {
      "vector": [0.23, -0.15, 0.87, ..., 0.42],
      "limit": 5
    },
    {
      "vector": [0.45, 0.12, -0.34, ..., 0.21],
      "limit": 3
    }
  ]
}

{
  "results": [
    {
      "result": [
        { "id": 5, "score": 0.92, "payload": {...} }
      ]
    },
    {
      "result": [
        { "id": 3, "score": 0.88, "payload": {...} }
      ]
    }
  ]
}

{
  "collectionName": "documents",
  "vector": [0.23, -0.15, 0.87, ..., 0.42],
  "groupBy": "category",
  "groupSize": 2,
  "limit": 10
}

{
  "groups": [
    {
      "id": "AI",
      "hits": [
        { "id": 5, "score": 0.92, "payload": {...} },
        { "id": 8, "score": 0.87, "payload": {...} }
      ]
    },
    {
      "id": "Database",
      "hits": [
        { "id": 3, "score": 0.88, "payload": {...} }
      ]
    }
  ]
}

{
  "must": [
    // Все условия должны быть истинны (AND)
  ],
  "should": [
    // Хотя бы одно условие должно быть истинно (OR)
  ],
  "must_not": [
    // Эти условия НЕ должны быть истинны (NOT)
  ]
}

{
  "key": "category",
  "match": {
    "value": "AI"
  }
}

{
  "key": "price",
  "range": {
    "gte": 100,
    "lte": 1000
  }
}

{
  "key": "tags",
  "match": {
    "any": ["automation", "AI", "python"]
  }
}

{
  "key": "location",
  "geo_radius": {
    "center": {
      "lat": 52.52,
      "lon": 13.40
    },
    "radius": 2000  // в метрах
  }
}

{
  "key": "content",
  "text": {
    "query": "N8N автоматизация"
  }
}

{
  "must": [
    {
      "key": "category",
      "match": { "value": "AI" }
    },
    {
      "key": "date",
      "range": {
        "gte": "2025-01-01",
        "lte": "2025-12-31"
      }
    }
  ],
  "should": [
    { "key": "author", "match": { "value": "Иван" } },
    { "key": "author", "match": { "value": "Мария" } }
  ],
  "must_not": [
    { "key": "status", "match": { "value": "archived" } }
  ]
}

{
  "collectionName": "documents",
  "vector": [0.23, -0.15, 0.87, ..., 0.42],
  "filter": {
    "must": [
      { "key": "category", "match": { "value": "AI" } }
    ]
  },
  "limit": 10
}

{
  "collectionName": "documents",
  "pointIds": [1, 2, 3],
  "payload": {
    "status": "processed",
    "last_updated": "2025-11-26"
  }
}

{
  "collectionName": "documents",
  "pointIds": [1, 2, 3],
  "payload": {
    "status": "archived",
    "reason": "old content"
  }
}

{
  "collectionName": "documents",
  "pointIds": [1, 2, 3],
  "keys": ["status", "last_updated"]
}

{
  "collectionName": "documents",
  "fieldName": "category",
  "fieldSchema": "keyword"
}

{
  "collectionName": "documents",
  "field": "category"
}

{
  "facets": [
    { "value": "AI", "count": 150 },
    { "value": "Database", "count": 87 },
    { "value": "Automation", "count": 203 }
  ]
}

{
  "hnsw": {
    "m": 16,              // Quantity connections per node (8-64)
    "ef_construct": 200,  // Indexing quality (128-2048)
    "ef": 150,            // Search depth (128-4096)
    "full_scan_threshold": 10000,  // Когда перейти на полный поиск
    "max_indexing_threads": 4      // Потоки для индексирования
  }
}

{
  "quantization": {
    "scalar": {
      "type": "int8",
      "quantile": 0.99,
      "always_ram": false
    }
  }
}

// Создать индексы
- category (keyword)
- date (datetime)
- author (keyword)
- is_active (bool)

[Webhook trigger]
    ↓
[HTTP Request → OpenAI Embedding]
    ↓
[Qdrant Query Points]
    ↓
[Function → Формирование контекста]
    ↓
[HTTP Request → OpenAI Chat]
    ↓
[HTTP Request → Отправка ответа]

Method: POST
Authentication: None

Используем: Function node или HTTP Request
Input: $json.body.question
Output: vector array

Resource: Query
Operation: Query Points

collectionName: "kb_documents"
vector: $json.embedding
limit: 5
scoreThreshold: 0.7

filter: {
  "must": [
    { "key": "status", "match": { "value": "active" } }
  ]
}

// Формирование контекста из результатов
const items = $input.all()[0].json.result;
const context = items
  .map(item => `${item.payload.title}\n${item.payload.content}`)
  .join('\n\n');

return { context };

System prompt: "Ты помощник. Ответь на вопрос используя контекст"
Context: $json.context
Question: $json.body.question

[Google Drive New File Trigger]
    ↓
[PDF Parser]
    ↓
[Function → Чанкирование текста]
    ↓
[HTTP Request → OpenAI Embedding]
    ↓
[Qdrant Upsert Points]
    ↓
[Notification → Email]

Input: file from trigger
Output: raw text

const text = $input.first().json.text;
const chunkSize = 1024; // токены
const chunkOverlap = 100;

const chunks = [];
let start = 0;

while (start < text.length) {
  let end = start + chunkSize;
  if (end < text.length && text[end] !== ' ') {
    end = text.lastIndexOf(' ', end);
  }
  chunks.push(text.substring(start, end));
  start = end - chunkOverlap;
}

return chunks.map((chunk, i) => ({
  "chunk_id": i,
  "content": chunk,
  "source": $input.first().json.fileName
}));

Method: POST
URL: https://api.openai.com/v1/embeddings
Headers: Authorization: Bearer sk-...

Body: {
  "input": $json.content,
  "model": "text-embedding-3-small"
}

Resource: Points
Operation: Upsert Points

collectionName: "documents"

points: [
  {
    "id": $json.chunk_id,
    "vector": $input.previous().json.data[0].embedding,
    "payload": {
      "content": $json.content,
      "source": $json.source,
      "indexed_at": new Date().toISOString(),
      "document_id": $input.first().json.fileId
    }
  }
]

[Webhook trigger с параметрами]
    ↓
[Qdrant Query Points + Filter]
    ↓
[Presentation форматирования]
    ↓
[HTTP Response]

collectionName: "documents"
vector: $json.embedding

filter: {
  "must": [
    {
      "key": "category",
      "match": { "value": $json.category }
    },
    {
      "key": "date",
      "range": {
        "gte": $json.startDate,
        "lte": $json.endDate
      }
    }
  ]
}

limit: 10
scoreThreshold: 0.75

[Schedule trigger (ежедневно)]
    ↓
[Qdrant Scroll Points]
    ↓
[Function → Проверка актуальности]
    ↓
[Qdrant Set Payload (обновить метаданные)]
    ↓
[Logging]

collectionName: "documents"
limit: 100

const today = new Date();
const oneMonthAgo = new Date(today.getTime() - 30 * 24 * 60 * 60 * 1000);

const oldItems = $input.all()
  .filter(item => {
    const docDate = new Date(item.json.payload.indexed_at);
    return docDate < oneMonthAgo;
  });

return oldItems.map(item => ({
  pointId: item.json.id,
  status: "stale",
  needs_review: true
}));

collectionName: "documents"

pointIds: $json.pointIds

payload: {
  "status": "stale",
  "needs_review": true,
  "last_checked": new Date().toISOString()
}

[User view event webhook]
    ↓
[Qdrant Retrieve Point (получить вектор просмотренного документа)]
    ↓
[Qdrant Query Points (найти похожие)]
    ↓
[Filter excluding similar (исключить само себя)]
    ↓
[HTTP Response → Recommendations]

{
  "user_id": "123",
  "document_id": 5
}

collectionName: "documents"
pointId: $json.document_id

collectionName: "documents"
vector: $input.previous().json.vector

filter: {
  "must_not": [
    { "key": "id", "match": { "value": $json.document_id } }
  ]
}

limit: 5

version: '3.8'

services:
  qdrant:
    image: qdrant/qdrant:latest
    container_name: qdrant
    ports:
      - "6333:6333"
    volumes:
      - ./qdrant_storage:/qdrant/storage
    environment:
      QDRANT_HTTP_API_KEY: "test_api_key_12345"
    restart: unless-stopped

  n8n:
    image: n8nio/n8n:latest
    container_name: n8n
    ports:
      - "5678:5678"
    environment:
      - N8N_BASIC_AUTH_ACTIVE=true
      - N8N_BASIC_AUTH_USER=admin
      - N8N_BASIC_AUTH_PASSWORD=password123
      - N8N_HOST=localhost
      - N8N_PORT=5678
    volumes:
      - ./n8n_data:/home/node/.n8n
    depends_on:
      - qdrant
    restart: unless-stopped

volumes:
  qdrant_storage:
  n8n_data:

docker-compose up -d

# Проверка
docker ps
docker logs qdrant
docker logs n8n

http://localhost:6333/dashboard

docker logs -f n8n

docker logs -f qdrant

Qdrant node → "List Collections"
Если пусто → проверить credentials

// Проверка перед Upsert
if (embedding.length !== 1536) {
  throw new Error("Vector size mismatch");
}

Qdrant Query → Try/Catch → Fallback action

# Снятие снимка
curl -X POST http://localhost:6333/collections/documents/snapshots

# Восстановление
curl -X PUT http://localhost:6333/collections/documents/snapshots/restore \
  -F snapshot=@snapshot.tar

Не сохранять в коде
Использовать N8N credentials
Ротировать ежемесячно

List Collections → Получить все коллекции
Create Collection → Создать новую (указать имя, размер вектора, метрику)
Get Collection → Информация о коллекции
Delete Collection → Удалить (необратимо!)

Upsert Points → Вставить или обновить точки
Structure: {id, vector, payload}

Query Points → Поиск похожих
+ Filter → ограничение по условиям

Set Payload → добавить/обновить поля
Create Payload Index → ускорить фильтрацию
Faceted Search → статистика по полям

Индексы на часто фильтруемые поля
Квантизация для экономии памяти
Батчинг для массовых операций

pip install qdrant-client