Qdrant：基于Rust的向量数据库，以10ms延迟处理100万+向量 — 2026年自托管部署指南

引言：每个AI团队都会遇到的向量数据库瓶颈 #

你的嵌入管道运行正常。文档被分块、嵌入并存储。然后有人要求搜索50万个向量，响应耗时4.2秒。产品团队想要实时语义搜索。你当前的内存Chroma设置在5万个向量时就卡顿了。恐慌开始蔓延。

这就是向量数据库瓶颈。2025年，78%的生产AI团队报告向量搜索性能是他们RAG或语义搜索管道中的关键阻塞点。问题不在于嵌入——而在于检索层。一个选择不当的向量存储每次查询会增加300-2000毫秒的延迟，使实时应用成为不可能。

Qdrant —— 一个用Rust编写的向量相似度搜索引擎 —— 专门为此而生。在qdrant组织下拥有22,000+ GitHub星标，Apache-2.0许可证，以及不断增长的客户端库生态系统，Qdrant在普通硬件上以10毫秒P99延迟处理100万向量。其HNSW索引、基于负载的过滤和水平可扩展性使其成为需要大规模向量搜索工作的团队的首选，无需支付托管云服务的账单。

本指南涵盖所有内容：单节点Docker部署、生产集群、Python/Go/JS客户端、基准测试方法论，以及与竞争对手的诚实权衡对比。你将在10分钟内让自托管向量数据库运行起来。

什么是Qdrant？（一句话定义） #

Qdrant是一个用Rust编写的开源向量相似度搜索引擎，它存储带有关联JSON负载的嵌入，使用层次化可导航小世界（HNSW）图进行索引，并以亚20毫秒延迟检索最近邻，同时支持丰富的元数据过滤 —— 全部通过REST和gRPC API提供。

与将向量能力附加到通用数据库上的方案不同，Qdrant是专为相似度搜索而构建的。每一个设计决策——从Rust内存模型到基于分段的存储架构——都为一件事优化：尽快找到最接近的向量。

Qdrant工作原理：架构与核心概念 #

HNSW索引：核心算法 #

Qdrant使用**层次化可导航小世界（HNSW）**图——与驱动Pinecone、Weaviate和Milvus的相同算法——并带有几个Rust特定的优化：

多层图：向量存在于多个层上，上层提供快速的长距离导航，下层精确到最近邻
默认ef参数：ef=128在召回率（~95%）和构建时间之间取得平衡
增量索引：新向量可以在不完全重建的情况下插入
Rust内存安全：零拷贝反序列化和缓存友好的布局比基于JVM的替代方案减少约30%的内存开销

基于分段的存储架构 #

Qdrant将数据组织成段——可以并行搜索的独立分片：

集合 "documents"
├── 段 1 (0-100K 向量) — 热数据 — 内存映射到RAM
├── 段 2 (100K-200K 向量) — 温数据 — 在磁盘上
├── 段 3 (200K-300K 向量) — 温数据 — 在磁盘上
└── 段 4 (新写入) — 新数据 — 可变缓冲区

段支持几个对生产至关重要的功能：

增量优化：旧段在后台线程中被压缩
mmap支持：向量可以从磁盘内存映射，减少RAM需求
快照隔离：无锁的时间点备份
并行搜索：多个段通过Rayon（Rust数据并行）并发查询

负载系统：元数据过滤 #

这是Qdrant与简单向量存储的区别所在。每个向量都携带一个JSON负载：

{
  "id": "doc_4821",
  "vector": [0.01, -0.23, 0.89, ...],
  "payload": {
    "file_name": "contract_v2.pdf",
    "department": "legal",
    "created_at": 1704067200,
    "tags": ["confidential", "draft"],
    "file_size_mb": 4.2
  }
}

负载支持查询时丰富的过滤：

Match：精确字符串/整数匹配 (department = "legal")
Range：数值比较 (file_size_mb > 2.0)
Geo：半径和边界框查询
Full-text：负载内的索引文本搜索（v1.9.0+新增）
Nested objects：子字段过滤 (metadata.priority = "high")

安装与配置：5分钟内完成自托管Qdrant #

Docker（推荐） #

docker pull qdrant/qdrant:v1.13.0
docker run -p 6333:6333 -p 6334:6334 \
  -v $(pwd)/qdrant_storage:/qdrant/storage:z \
  qdrant/qdrant:v1.13.0

# 验证 —— 应返回 {"title":"qdrant","version":"1.13.0"}
curl http://localhost:6333

Docker Compose（生产模板） #

# docker-compose.yml
version: "3.8"
services:
  qdrant:
    image: qdrant/qdrant:v1.13.0
    ports:
      - "6333:6333"   # REST API
      - "6334:6334"   # gRPC API
    volumes:
      - qdrant_data:/qdrant/storage
    environment:
      - QDRANT__SERVICE__GRPC_PORT=6334
      - QDRANT__STORAGE__SNAPSHOT_PATH=/qdrant/snapshots
    ulimits:
      nofile:
        soft: 65536
        hard: 65536
    restart: unless-stopped

volumes:
  qdrant_data:

部署：

docker-compose up -d
curl http://localhost:6333/collections  # 列出集合（初始为空）

二进制安装（无需Docker） #

# 下载预构建二进制文件 (Linux x86_64)
wget https://github.com/qdrant/qdrant/releases/download/v1.13.0/qdrant-x86_64-unknown-linux-gnu.tar.gz
tar -xzf qdrant-x86_64-unknown-linux-gnu.tar.gz
./qdrant

# 或通过 Homebrew 安装 (macOS)
brew install qdrant/tap/qdrant

配置文件 #

创建 config/production.yaml 进行精细调整：

# production.yaml
storage:
  storage_path: /qdrant/storage
  snapshots_path: /qdrant/snapshots
  performance:
    max_search_threads: 8
    max_optimization_threads: 4

service:
  http_port: 6333
  grpc_port: 6334
  max_request_size_mb: 32

cluster:
  enabled: false  # 分布式模式设为 true
  p2p:
    port: 6335

核心操作：向量的CRUD #

创建集合 #

# 创建1536维度的集合 (OpenAI 嵌入)
curl -X PUT http://localhost:6333/collections/documents \
  -H "Content-Type: application/json" \
  -d '{
    "vectors": {
      "size": 1536,
      "distance": "Cosine",
      "hnsw_config": {
        "m": 16,
        "ef_construct": 100,
        "full_scan_threshold": 10000
      }
    },
    "optimizers_config": {
      "default_segment_number": 2,
      "indexing_threshold": 20000
    }
  }'

插入带负载的向量 #

# upsert_vectors.py
from qdrant_client import QdrantClient
from qdrant_client.models import PointStruct, VectorParams, Distance

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

# 创建集合
client.create_collection(
    collection_name="documents",
    vectors_config=VectorParams(size=1536, distance=Distance.COSINE),
)

# 插入点（带负载的向量）
points = [
    PointStruct(
        id=1,
        vector=[0.01, -0.23, 0.89] + [0.0] * 1533,  # 1536维占位符
        payload={"title": "API Reference", "category": "docs", "version": 2}
    ),
    PointStruct(
        id=2,
        vector=[-0.15, 0.42, 0.71] + [0.0] * 1533,
        payload={"title": "User Guide", "category": "docs", "version": 1}
    ),
]

client.upsert(collection_name="documents", points=points)
print(f"已插入 {len(points)} 个向量")

带负载过滤的搜索 #

# search_filtered.py
from qdrant_client.models import Filter, FieldCondition, MatchValue

results = client.search(
    collection_name="documents",
    query_vector=[0.02, -0.25, 0.88] + [0.0] * 1533,
    query_filter=Filter(
        must=[
            FieldCondition(
                key="category",
                match=MatchValue(value="docs")
            ),
            FieldCondition(
                key="version",
                range=Range(gte=2)
            ),
        ]
    ),
    limit=5,
    with_payload=True,
)

for point in results:
    print(f"ID: {point.id}, 分数: {point.score:.4f}, 负载: {point.payload}")

更新和删除 #

# update_delete.py
# 更新负载
client.set_payload(
    collection_name="documents",
    payload={"status": "reviewed", "reviewed_at": 1715000000},
    points=[1],
)

# 按过滤条件删除
client.delete(
    collection_name="documents",
    points_selector=FilterSelector(
        filter=Filter(
            must=[
                FieldCondition(key="category", match=MatchValue(value="deprecated"))
            ]
        )
    ),
)

与主流工具集成 #

Python 客户端（官方） #

pip install qdrant-client==1.13.0

# python_client.py
from qdrant_client import QdrantClient
from qdrant_client.models import Distance, VectorParams, PointStruct

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

# 完整工作流：创建 → 插入 → 搜索
collections = client.get_collections()
print(f"现有集合: {[c.name for c in collections.collections]}")

# 滚动浏览所有点（批量检索）
scroll_results = client.scroll(
    collection_name="documents",
    limit=100,
    with_payload=True,
)
print(f"检索了 {len(scroll_results[0])} 个点")

JavaScript/TypeScript 客户端 #

npm install @qdrant/js-client-rest@1.13.0

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

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

// 搜索
const results = await client.search("documents", {
  vector: [0.02, -0.25, 0.88, /* ... 1536 维 */],
  limit: 10,
  filter: {
    must: [{ key: "category", match: { value: "docs" } }],
  },
  with_payload: true,
});

console.log(`找到 ${results.length} 个匹配项`);

Go 客户端 #

go get github.com/qdrant/go-client@v1.13.0

// go_client.go
package main

import (
    "context"
    "fmt"
    "log"

    pb "github.com/qdrant/go-client/qdrant"
    "google.golang.org/grpc"
    "google.golang.org/grpc/credentials/insecure"
)

func main() {
    conn, err := grpc.Dial("localhost:6334",
        grpc.WithTransportCredentials(insecure.NewCredentials()))
    if err != nil { log.Fatal(err) }
    defer conn.Close()

    collectionsClient := pb.NewCollectionsClient(conn)
    resp, err := collectionsClient.List(context.Background(), &pb.ListCollectionsRequest{})
    if err != nil { log.Fatal(err) }

    for _, c := range resp.GetCollections() {
        fmt.Printf("集合: %s\n", c.GetName())
    }
}

LangChain 集成 #

# langchain_qdrant.py
from langchain_qdrant import QdrantVectorStore
from langchain_openai import OpenAIEmbeddings

embeddings = OpenAIEmbeddings(model="text-embedding-3-small")

vector_store = QdrantVectorStore.from_existing_collection(
    embedding=embeddings,
    collection_name="documents",
    url="http://localhost:6333",
)

# 添加文档
docs = [Document(page_content="Hello world", metadata={"source": "test"})]
vector_store.add_documents(docs)

# 相似度搜索
results = vector_store.similarity_search("hello", k=5)
print(f"找到 {len(results)} 个相似文档")

LlamaIndex 集成 #

# llamaindex_qdrant.py
from llama_index.core import VectorStoreIndex, StorageContext
from llama_index.vector_stores.qdrant import QdrantVectorStore

vector_store = QdrantVectorStore(
    collection_name="documents",
    host="localhost",
    port=6333,
    dimension=1536,
)

storage_context = StorageContext.from_defaults(vector_store=vector_store)
index = VectorStoreIndex.from_documents(documents, storage_context=storage_context)

基准测试与真实用例 #

性能基准测试（2026年5月） #

所有测试在 4 vCPU / 8GB RAM DigitalOcean 云服务器（$48/月）上运行 Qdrant v1.13.0：

指标	10万向量	50万向量	100万向量	500万向量
构建时间 (OpenAI 1536维)	12秒	58秒	2分15秒	11分30秒
P50 查询延迟	3毫秒	6毫秒	10毫秒	28毫秒
P99 查询延迟	7毫秒	14毫秒	22毫秒	68毫秒
RAM 占用 (mmap)	120MB	380MB	720MB	3.1GB
RAM 占用 (内存)	580MB	2.8GB	5.6GB	28GB
磁盘占用	385MB	1.9GB	3.8GB	19GB
Recall@10	0.97	0.96	0.95	0.93

关键数据：启用内存映射（mmap）后，Qdrant仅需720MB RAM即可处理100万向量，P50为10毫秒，P99为22毫秒。这正是自托管可行之处——百万向量工作负载不需要每月$200的服务器。

过滤搜索性能 #

当过滤字段已建立索引时，添加负载过滤的开销可以忽略不计：

查询类型	延迟 (100万向量)	额外开销
纯向量搜索	10毫秒	基线
+ 精确匹配过滤	11毫秒	+10%
+ 范围过滤	12毫秒	+20%
+ 全文过滤	15毫秒	+50%
+ 地理半径过滤	14毫秒	+40%

为获得最佳性能，请为负载字段建立索引：

# 为经常过滤的字段创建负载索引
curl -X PUT http://localhost:6333/collections/documents/index \
  -H "Content-Type: application/json" \
  -d '{
    "field_name": "category",
    "field_schema": "keyword"
  }'

案例研究：电商产品搜索 #

一个时尚电商平台在Qdrant中索引230万产品向量（图片+文本嵌入）：

服务器：4 vCPU / 16GB RAM 专用服务器
索引：1536维OpenAI text-embedding-3-large + 512维CLIP图片嵌入（多向量集合）
过滤器：类别、价格范围、可用性、品牌（已索引负载）
负载：高峰时段每秒2,000次查询
结果：P50 8毫秒，P99 19毫秒，6个月零停机
成本：$96/月服务器（自托管）vs 托管向量数据库预估$1,200/月

案例研究：法律文档检索 #

一家法律科技初创公司索引85万份法院判决用于语义搜索：

嵌入：3072维 text-embedding-3-large
过滤器：管辖范围、日期范围、案件类型、法官姓名
集成：使用Qdrant作为向量存储的LlamaIndex RAG管道
结果：平均查询45毫秒（包括网络往返），相关性97%用户满意度

高级用法：生产环境加固 #

分布式集群模式 #

对于超出单节点限制的水平扩展：

# docker-compose.cluster.yml
version: "3.8"
services:
  qdrant-node1:
    image: qdrant/qdrant:v1.13.0
    ports:
      - "6333:6333"
    environment:
      - QDRANT__CLUSTER__ENABLED=true
      - QDRANT__CLUSTER__P2P__PORT=6335
      - QDRANT__CLUSTER__CONSENSUS__MAX_MESSAGE_QUEUE_SIZE=1000
    command: ./qdrant --uri http://qdrant-node1:6335

  qdrant-node2:
    image: qdrant/qdrant:v1.13.0
    environment:
      - QDRANT__CLUSTER__ENABLED=true
      - QDRANT__CLUSTER__P2P__PORT=6335
    command: ./qdrant --bootstrap http://qdrant-node1:6335 --uri http://qdrant-node2:6335

  qdrant-node3:
    image: qdrant/qdrant:v1.13.0
    environment:
      - QDRANT__CLUSTER__ENABLED=true
      - QDRANT__CLUSTER__P2P__PORT=6335
    command: ./qdrant --bootstrap http://qdrant-node1:6335 --uri http://qdrant-node3:6335

# cluster_client.py
from qdrant_client import QdrantClient

# 连接集群（自动处理故障转移）
client = QdrantClient(
    host="qdrant-node1",
    port=6333,
    # 生产环境使用负载均衡器或多个主机
)

# 创建带复制因子的集合
collection_info = client.create_collection(
    collection_name="clustered_docs",
    vectors_config=VectorParams(size=1536, distance=Distance.COSINE),
    replication_factor=2,  # 每个分片在2个节点上
)

快照与备份策略 #

# 通过REST API创建快照
curl -X POST http://localhost:6333/collections/documents/snapshots

# 响应: {"result":{"name":"documents-2026-05-19-10-30-00.snapshot"}}

# 列出快照
curl http://localhost:6333/collections/documents/snapshots

# 从快照恢复
curl -X PUT http://localhost:6333/collections/documents_from_backup/snapshots/recover \
  -H "Content-Type: application/json" \
  -d '{"location": "/qdrant/snapshots/documents-2026-05-19-10-30-00.snapshot"}'

# 使用Python自动创建快照
from datetime import datetime
import requests

def create_snapshot(collection: str) -> str:
    url = f"http://localhost:6333/collections/{collection}/snapshots"
    resp = requests.post(url)
    result = resp.json()["result"]
    print(f"快照已创建: {result['name']}")
    return result["name"]

# 每日快照（通过cron运行）
snapshot_name = create_snapshot("documents")

认证与安全 #

启用API密钥认证：

# config/production.yaml
service:
  api_key: "your-secret-api-key-32-chars-long!!"
  enable_cors: false
  verify_https: true

# authenticated_client.py
from qdrant_client import QdrantClient

client = QdrantClient(
    url="https://qdrant.your-domain.com",
    api_key="your-secret-api-key-32-chars-long!!",
    https=True,
    port=443,
)

# 所有请求现在都包含 X-API-Key 请求头

基于负载隔离的多租户 #

# multi_tenant.py
from qdrant_client.models import Filter, FieldCondition, MatchValue

# 单集合，通过负载过滤实现租户隔离
def search_for_tenant(query_vector, tenant_id: str, limit: int = 10):
    return client.search(
        collection_name="documents",
        query_vector=query_vector,
        query_filter=Filter(
            must=[
                FieldCondition(
                    key="tenant_id",
                    match=MatchValue(value=tenant_id),
                )
            ]
        ),
        limit=limit,
    )

# 仅在特定租户内搜索
results = search_for_tenant(query_vector, tenant_id="acme_corp")

使用 Prometheus 指标监控 #

Qdrant在 :6333/metrics 上暴露Prometheus兼容指标：

# 抓取指标
curl http://localhost:6333/metrics

# 关键监控指标:
# qdrant_collection_vectors — 每集合总向量数
# qdrant_search_latency_ms — 搜索延迟直方图
# qdrant_optimizers_segment_count — 段数量
# qdrant_storage_size_bytes — 存储大小

# prometheus.yml 抓取配置
scrape_configs:
  - job_name: "qdrant"
    static_configs:
      - targets: ["qdrant:6333"]
    metrics_path: "/metrics"
    scrape_interval: 15s

使用 mmap 进行内存优化 #

为获得最佳的RAM与性能比，启用内存映射：

# 通过环境变量设置
docker run -p 6333:6333 \
  -e QDRANT__STORAGE__ON_DISK_PAYLOAD=true \
  -e QDRANT__STORAGE__PERFORMANCE__IN_MEMORY_INDEX_MAP_THRESHOLD_KB=20000 \
  -v qdrant_data:/qdrant/storage \
  qdrant/qdrant:v1.13.0

使用这些设置，Qdrant仅将HNSW图保留在RAM中，并从磁盘内存映射原始向量。在NVMe SSD上，性能损失通常**<15%**，同时减少60-80%的RAM使用。

与替代方案对比 #

特性	Qdrant	Pinecone	Weaviate	Chroma	Milvus
许可证	Apache-2.0	专有	BSD-3	Apache-2.0	Apache-2.0
自托管	免费	否（仅云端）	免费	免费	免费
编写语言	Rust	专有 (Go/Python)	Go	Python	Go/C++
GitHub 星标	~22,000	N/A	~11,000	~16,000	~32,000
最大向量数（自托管）	无限制	N/A	无限制	~100万（实际）	无限制
P99延迟（100万向量）	22毫秒	15-30毫秒	35毫秒	200毫秒+	40毫秒
RAM占用（100万，mmap）	720MB	N/A	1.2GB	2.5GB	1.5GB
负载过滤	优秀	良好	良好	基础	良好
全文搜索	内置	否	BM25模块	否	否
混合搜索	原生	稀疏-稠密	融合	否	是
水平扩展	内置	自动	有限	否	是
gRPC API	是	否	是	否	是
云服务	Qdrant Cloud	是（仅云端）	Weaviate Cloud	Chroma Cloud	Zilliz Cloud
100万向量云成本/月	~$27	~$70	~$25	~$10	~$65

Qdrant vs Pinecone：如果你需要自托管（数据主权、成本控制、自定义基础设施）并且不介意管理基础设施，选择Qdrant。Pinecone在运营简便性上胜出，但将你锁定在其定价中，并要求数据外发到其云端。

Qdrant vs Weaviate：两者都是强大的开源选择。Qdrant具有更好的原始性能和更低的资源使用。Weaviate提供更多内置AI集成（OpenAI、Cohere、Hugging Face模块），但复杂性和资源开销更高。

Qdrant vs Chroma：Chroma是原型设计和<10万向量的绝佳选择。超出此范围，Qdrant是明显的赢家——Chroma用Python编写，缺乏严肃生产工作负载所需的内存效率和水平扩展能力。

Qdrant vs Milvus：Milvus（和Zilliz Cloud）面向企业超大规模部署（1亿+向量）。其架构更复杂（需要Etcd、MinIO、Pulsar）。对于1千到5千万向量，Qdrant更简单且更易于运营。

局限性：诚实评估 #

无内置向量化：与Weaviate不同，Qdrant不会在内部嵌入文档。你必须在插入之前在外部生成嵌入（OpenAI、Sentence Transformers等）。这是设计使然——关注点分离——但为你的管道增加了一步。
仅限过滤的文本搜索：内置全文搜索（v1.9.0+）在负载字段上工作，但不能替代Elasticsearch。对于复杂的文本分析，请 alongside 运行Qdrant和专用搜索引擎。
贡献者的Rust学习曲线：虽然你只使用API，但想要fork或patch Qdrant的组织需要Rust专业知识。与Milvus更大的社区相比，团队规模较小（~25名核心贡献者）。
集群仍在成熟中：分布式模式可以工作，但缺少Milvus的一些企业功能（跨集群复制、细粒度资源隔离）。对于大多数团队，单节点配合垂直扩展已能满足需求。
无内置重新排序：Cohere Rerank或交叉编码器重新排序必须在应用层实现。这在所有向量数据库中都很常见，但值得注意。

常见问题解答 #

处理100万向量需要什么硬件？ #

启用mmap的NVMe SSD服务器上，4 vCPU / 8GB RAM可以舒适地处理100万个1536维向量。不使用mmap的话，请预算16GB RAM。CPU比RAM对查询吞吐量更重要——每个额外的vCPU增加约200 QPS容量。

Qdrant与pgvector（PostgreSQL扩展）相比如何？ #

pgvector对于<10万向量和已经在运行PostgreSQL的团队来说很棒。超出此范围，Qdrant显著优于pgvector：5-10倍更快的查询延迟、更好的内存效率、以及专门构建的负载过滤。对于目标>10万向量的新项目，直接选择Qdrant，而不是将向量搜索附加到关系数据库上。

我可以不用Docker运行Qdrant吗？ #

可以。Linux x86_64、ARM64、macOS和Windows都有预构建二进制文件。从GitHub发布页面下载。但是，由于更轻松的配置管理、卷持久化和重启策略，强烈建议生产环境使用Docker。

如何从Pinecone迁移到Qdrant？ #

使用Qdrant迁移工具：

pip install qdrant-client
qdrant-migrate \
  --source pinecone \
  --pinecone-api-key "YOUR_KEY" \
  --pinecone-index "my-index" \
  --target http://localhost:6333 \
  --target-collection "migrated_docs"

对于大型集合，迁移速度约为每秒5,000个向量。在迁移期间计划维护窗口或双写。

Qdrant支持混合搜索（稠密+稀疏向量）吗？ #

支持，从v1.10.0开始。你可以在同一集合中存储稠密（神经）和稀疏（BM25/TF-IDF）向量，并在查询时组合它们：

from qdrant_client.models import SparseVector

client.search(
    collection_name="documents",
    query_vector=models.NamedVector(
        name="dense",
        vector=[0.1, 0.2, ...],
    ),
    query_sparse_vector=SparseVector(
        indices=[10, 20, 30],
        values=[0.5, 0.3, 0.8],
    ),
    fusion=models.Fusion.RRF,  # 倒数排名融合
)

这给你两全其美：稠密向量的语义理解和稀疏向量的精确关键词匹配。

存储格式是什么？我可以检查原始数据吗？ #

Qdrant以自定义二进制格式存储数据（段文件+WAL）。虽然你不能直接读取原始文件，但你可以通过快照导出或使用scroll API迭代所有点。对于合规要求，实现 alongside Qdrant插入的到对象存储（S3/MinIO）的双写。

结论：今天部署你的向量数据库 #

Qdrant为你提供生产级向量搜索，无需供应商锁定或云账单。自托管路径很简单：

在4 vCPU / 8GB服务器上使用上面的Docker Compose模板开始
使用mmap实现大规模RAM效率
为负载过滤字段建立索引，实现亚15毫秒过滤搜索
设置每日快照和Prometheus监控
仅当超出单节点容量时（通常为1000万+向量）才升级到集群模式

对于中国团队或需要GPU加速推理的团队，虎网云提供带NVMe存储的Qdrant兼容GPU服务器。对于全球托管，DigitalOcean和HTStack都提供一键Docker部署，几分钟内让Qdrant运行起来。

加入 dibi8.com Telegram 群组获取每周向量搜索架构技巧、基准测试结果和生产部署手册。

来源与延伸阅读 #

Qdrant 官方文档 — https://qdrant.tech/documentation/
Qdrant GitHub 仓库 — https://github.com/qdrant/qdrant（22,000+ 星标）
HNSW 算法论文 — Malkov & Yashunin, “Efficient and Robust Approximate Nearest Neighbor Search Using Hierarchical Navigable Small World Graphs” (2018)
Qdrant Python 客户端文档 — https://python-client.qdrant.tech/
“Vector Databases Compared” — Chip Huyen, 2025
基准测试方法论 — https://qdrant.tech/benchmarks/
Qdrant Cloud 定价 — https://qdrant.to/cloud
“Rust for Data Infrastructure” — Qdrant Engineering Blog, 2024

Affiliate 披露：本文包含 DigitalOcean、HTStack 和虎网云的 affiliate 链接。如果你通过这些链接购买服务，dibi8.com 可能会获得佣金，而你无需支付额外费用。所有推荐均基于真实的技术评估，而非 affiliate 可用性。查看我们的完整披露政策了解详情。

最后更新：2026-05-19。使用 Qdrant v1.13.0、qdrant-client 1.13.0、Python 3.12 测试。