存储

集合中的所有数据都被划分为多个分段（segments）。每个分段都有其独立的向量和负载（payload）存储以及索引。

存储在分段中的数据通常不会重叠。然而，即使在不同的分段中存储相同的点也不会产生问题，因为搜索过程中包含去重机制。

分段由向量和负载存储、向量和负载索引以及 ID 映射器组成，ID 映射器用于存储内部 ID 和外部 ID 之间的关系。

根据所使用的存储和索引类型，分段可以是 appendable（可追加）或 non-appendable（不可追加）。您可以在 appendable 分段中自由添加、删除和查询数据。而在 non-appendable 分段中，仅能读取和删除数据。

集合中各分段的配置可以是不同且相互独立的，但集合中必须至少存在一个 `appendable` 分段。

向量存储

根据应用程序的需求，Qdrant 可以使用多种数据存储选项之一。您需要在搜索速度和 RAM 使用空间之间做出选择。

内存存储（In-memory storage） - 将所有向量存储在 RAM 中，具有最高的速度，因为仅在需要持久化时才会访问磁盘。

内存映射存储（Memmap storage） - 创建与磁盘文件关联的虚拟地址空间。维基百科。内存映射文件不会直接加载到 RAM 中。相反，它们使用页面缓存来访问文件内容。这种方案允许灵活使用可用内存。在 RAM 充足的情况下，它的速度几乎与内存存储一样快。

配置内存映射（Memmap）存储

有两种方式配置内存映射（也称为磁盘存储）的使用

在集合创建 API 中为向量设置 on_disk 选项
自 v1.2.0 起可用

PUT /collections/{collection_name}
{
    "vectors": {
      "size": 768,
      "distance": "Cosine",
      "on_disk": true
    }
}

from qdrant_client import QdrantClient, models

client = QdrantClient(url="https://:6333")

client.create_collection(
    collection_name="{collection_name}",
    vectors_config=models.VectorParams(
        size=768, distance=models.Distance.COSINE, on_disk=True
    ),
)

import { QdrantClient } from "@qdrant/js-client-rest";

const client = new QdrantClient({ host: "localhost", port: 6333 });

client.createCollection("{collection_name}", {
  vectors: {
    size: 768,
    distance: "Cosine",
    on_disk: true,
  },
});

use qdrant_client::qdrant::{CreateCollectionBuilder, Distance, VectorParamsBuilder};
use qdrant_client::Qdrant;

let client = Qdrant::from_url("https://:6334").build()?;

client
    .create_collection(
        CreateCollectionBuilder::new("{collection_name}")
            .vectors_config(VectorParamsBuilder::new(768, Distance::Cosine).on_disk(true)),
    )
    .await?;

import io.qdrant.client.QdrantClient;
import io.qdrant.client.QdrantGrpcClient;
import io.qdrant.client.grpc.Collections.Distance;
import io.qdrant.client.grpc.Collections.VectorParams;

QdrantClient client =
    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());

client
    .createCollectionAsync(
        "{collection_name}",
        VectorParams.newBuilder()
            .setSize(768)
            .setDistance(Distance.Cosine)
            .setOnDisk(true)
            .build())
    .get();

using Qdrant.Client;
using Qdrant.Client.Grpc;

var client = new QdrantClient("localhost", 6334);

await client.CreateCollectionAsync(
	"{collection_name}",
	new VectorParams
	{
		Size = 768,
		Distance = Distance.Cosine,
		OnDisk = true
	}
);

import (
	"context"

	"github.com/qdrant/go-client/qdrant"
)

client, err := qdrant.NewClient(&qdrant.Config{
	Host: "localhost",
	Port: 6334,
})

client.CreateCollection(context.Background(), &qdrant.CreateCollection{
	CollectionName: "{collection_name}",
	VectorsConfig: qdrant.NewVectorsConfig(&qdrant.VectorParams{
		Size:     768,
		Distance: qdrant.Distance_Cosine,
		OnDisk:   qdrant.PtrOf(true),
	}),
})

这将创建一个所有向量立即存储在内存映射存储中的集合。如果您使用的 Qdrant 实例配备高速磁盘且正在处理大型集合，则推荐使用此方式。

设置 memmap_threshold 选项。该选项将设置一个阈值，超过此阈值后，分段将被转换为内存映射存储。
有两种设置方式
1. 您可以在配置文件中全局设置该阈值。参数名称为 memmap_threshold（之前为 memmap_threshold_kb）。
2. 您可以在创建或更新每个集合时分别设置阈值。

PUT /collections/{collection_name}
{
    "vectors": {
      "size": 768,
      "distance": "Cosine"
    },
    "optimizers_config": {
        "indexing_threshold": 20000
    }
}

from qdrant_client import QdrantClient, models

client = QdrantClient(url="https://:6333")

client.create_collection(
    collection_name="{collection_name}",
    vectors_config=models.VectorParams(size=768, distance=models.Distance.COSINE),
    optimizers_config=models.OptimizersConfigDiff(indexing_threshold=20000),
)

import { QdrantClient } from "@qdrant/js-client-rest";

const client = new QdrantClient({ host: "localhost", port: 6333 });

client.createCollection("{collection_name}", {
  vectors: {
    size: 768,
    distance: "Cosine",
  },
  optimizers_config: {
    indexing_threshold: 20000,
  },
});

use qdrant_client::qdrant::{
    CreateCollectionBuilder, Distance, OptimizersConfigDiffBuilder, VectorParamsBuilder,
};
use qdrant_client::Qdrant;

let client = Qdrant::from_url("https://:6334").build()?;

client
    .create_collection(
        CreateCollectionBuilder::new("{collection_name}")
            .vectors_config(VectorParamsBuilder::new(768, Distance::Cosine))
            .optimizers_config(OptimizersConfigDiffBuilder::default().indexing_threshold(20000)),
    )
    .await?;

import io.qdrant.client.QdrantClient;
import io.qdrant.client.QdrantGrpcClient;
import io.qdrant.client.grpc.Collections.CreateCollection;
import io.qdrant.client.grpc.Collections.Distance;
import io.qdrant.client.grpc.Collections.OptimizersConfigDiff;
import io.qdrant.client.grpc.Collections.VectorParams;
import io.qdrant.client.grpc.Collections.VectorsConfig;

QdrantClient client =
    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());

client
    .createCollectionAsync(
        CreateCollection.newBuilder()
            .setCollectionName("{collection_name}")
            .setVectorsConfig(
                VectorsConfig.newBuilder()
                    .setParams(
                        VectorParams.newBuilder()
                            .setSize(768)
                            .setDistance(Distance.Cosine)
                            .build())
                    .build())
            .setOptimizersConfig(
                OptimizersConfigDiff.newBuilder().setIndexingThreshold(20000).build())
            .build())
    .get();

using Qdrant.Client;
using Qdrant.Client.Grpc;

var client = new QdrantClient("localhost", 6334);

await client.CreateCollectionAsync(
	collectionName: "{collection_name}",
	vectorsConfig: new VectorParams { Size = 768, Distance = Distance.Cosine },
	optimizersConfig: new OptimizersConfigDiff { IndexingThreshold = 20000 }
);

import (
	"context"

	"github.com/qdrant/go-client/qdrant"
)

client, err := qdrant.NewClient(&qdrant.Config{
	Host: "localhost",
	Port: 6334,
})

client.CreateCollection(context.Background(), &qdrant.CreateCollection{
	CollectionName: "{collection_name}",
	VectorsConfig: qdrant.NewVectorsConfig(&qdrant.VectorParams{
		Size:     768,
		Distance: qdrant.Distance_Cosine,
	}),
	OptimizersConfig: &qdrant.OptimizersConfigDiff{
		IndexingThreshold: qdrant.PtrOf(uint64(20000)),
	},
})

设置内存映射阈值参数的经验法则很简单

如果您处于均衡使用场景，请将内存映射阈值设置为与 indexing_threshold 相同（默认值为 10000）。在这种情况下，优化器不会进行额外的运行，并将同时优化所有阈值。
如果您有高写入负载且 RAM 较小，请将内存映射阈值设置得低于 indexing_threshold（例如 5000）。在这种情况下，优化器会先将分段转换为内存映射存储，然后再应用索引。

此外，您不仅可以将内存映射存储用于向量，还可以用于 HNSW 索引。要启用此功能，您需要在集合创建或更新期间将 hnsw_config.on_disk 参数设置为 true。

PUT /collections/{collection_name}
{
    "vectors": {
      "size": 768,
      "distance": "Cosine",
      "on_disk": true
    },
    "hnsw_config": {
        "on_disk": true
    }
}

from qdrant_client import QdrantClient, models

client = QdrantClient(url="https://:6333")

client.create_collection(
    collection_name="{collection_name}",
    vectors_config=models.VectorParams(size=768, distance=models.Distance.COSINE, on_disk=True),
    hnsw_config=models.HnswConfigDiff(on_disk=True),
)

import { QdrantClient } from "@qdrant/js-client-rest";

const client = new QdrantClient({ host: "localhost", port: 6333 });

client.createCollection("{collection_name}", {
  vectors: {
    size: 768,
    distance: "Cosine",
    on_disk: true,
  },
  hnsw_config: {
    on_disk: true,
  },
});

use qdrant_client::qdrant::{
    CreateCollectionBuilder, Distance, HnswConfigDiffBuilder,
    VectorParamsBuilder,
};
use qdrant_client::Qdrant;

let client = Qdrant::from_url("https://:6334").build()?;

client
    .create_collection(
        CreateCollectionBuilder::new("{collection_name}")
            .vectors_config(VectorParamsBuilder::new(768, Distance::Cosine).on_disk(true))
            .hnsw_config(HnswConfigDiffBuilder::default().on_disk(true)),
    )
    .await?;

import io.qdrant.client.QdrantClient;
import io.qdrant.client.QdrantGrpcClient;
import io.qdrant.client.grpc.Collections.CreateCollection;
import io.qdrant.client.grpc.Collections.Distance;
import io.qdrant.client.grpc.Collections.HnswConfigDiff;
import io.qdrant.client.grpc.Collections.VectorParams;
import io.qdrant.client.grpc.Collections.VectorsConfig;

QdrantClient client =
    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());

client
    .createCollectionAsync(
        CreateCollection.newBuilder()
            .setCollectionName("{collection_name}")
            .setVectorsConfig(
                VectorsConfig.newBuilder()
                    .setParams(
                        VectorParams.newBuilder()
                            .setSize(768)
                            .setDistance(Distance.Cosine)
                            .setOnDisk(true)
                            .build())
                    .build())
            .setHnswConfig(HnswConfigDiff.newBuilder().setOnDisk(true).build())
            .build())
    .get();

using Qdrant.Client;
using Qdrant.Client.Grpc;

var client = new QdrantClient("localhost", 6334);

await client.CreateCollectionAsync(
	collectionName: "{collection_name}",
	vectorsConfig: new VectorParams { Size = 768, Distance = Distance.Cosine, OnDisk = true },
	hnswConfig: new HnswConfigDiff { OnDisk = true }
);

import (
	"context"

	"github.com/qdrant/go-client/qdrant"
)

client, err := qdrant.NewClient(&qdrant.Config{
	Host: "localhost",
	Port: 6334,
})

client.CreateCollection(context.Background(), &qdrant.CreateCollection{
	CollectionName: "{collection_name}",
	VectorsConfig: qdrant.NewVectorsConfig(&qdrant.VectorParams{
		Size:     768,
		Distance: qdrant.Distance_Cosine,
		OnDisk:   qdrant.PtrOf(true),
	}),
	HnswConfig: &qdrant.HnswConfigDiff{
		OnDisk: qdrant.PtrOf(true),
	},
})

负载（Payload）存储

Qdrant 支持两种类型的负载存储：InMemory（内存）和 OnDisk（磁盘）。

InMemory 负载存储的组织方式与内存向量相同。负载数据在服务启动时加载到 RAM 中，而磁盘和 Gridstore 仅用于持久化。这种存储类型运行速度很快，但如果负载包含较大的值（如文本摘要或图像），则可能需要大量空间将所有数据保存在 RAM 中。

对于较大的负载值，使用 OnDisk 负载存储可能更好。此存储类型会直接读取和写入 RocksDB 中的负载，因此不需要占用大量 RAM。然而，缺点是访问延迟。如果您需要根据某些基于负载的条件查询向量，检查存储在磁盘上的值可能会耗费太多时间。在这种情况下，我们建议为过滤条件中使用的每个字段创建负载索引，以避免磁盘访问。一旦创建了字段索引，无论使用哪种负载存储类型，Qdrant 都会在 RAM 中保留索引字段的所有值。

您可以通过配置文件或在创建集合时使用集合参数 on_disk_payload 来指定所需的负载存储类型。

版本控制

为确保数据完整性，Qdrant 分两个阶段执行所有数据更改。第一步，将数据写入预写日志 (WAL)，该日志对所有操作进行排序并分配序列号。

一旦更改被添加到 WAL，即使断电也不会丢失。然后更改进入分段。每个分段存储应用于它的最新更改版本以及每个独立点的版本。如果新更改的序列号小于该点的当前版本，更新程序将忽略该更改。这种机制允许 Qdrant 在异常关机的情况下安全且高效地从 WAL 恢复存储。

存储

向量存储

配置内存映射（Memmap）存储

负载（Payload）存储

版本控制

此页面有用吗？