文本搜索
Qdrant 是一个向量搜索引擎，是进行语义搜索的绝佳工具。然而，Qdrant 的功能远不止向量搜索。它还支持一系列词法搜索功能，包括对文本字段进行过滤，以及使用 BM25 等流行算法进行全文搜索。
语义搜索
语义搜索是一种侧重于文本含义而非仅仅匹配关键字的搜索技术。它是通过使用机器学习模型将文本转换为向量（嵌入）来实现的。这些向量捕获了文本的语义含义，使您能够找到含义相似的文本，即使它们并不共享完全相同的关键字。
例如，要搜索书籍集合，您可以使用像 all-MiniLM-L6-v2 这样的句子转换模型。首先，创建一个集合并为书籍描述配置一个稠密向量。
PUT /collections/books
{
"vectors": {
"description-dense": {
"size": 384,
"distance": "Cosine"
}
}
}
from qdrant_client import QdrantClient, models
client = QdrantClient(
url="https://xyz-example.qdrant.io:6333",
api_key="<your-api-key>",
cloud_inference=True,
)
client.create_collection(
collection_name="books",
vectors_config={
"description-dense": models.VectorParams(size=384, distance=models.Distance.COSINE)
},
)
client.createCollection("books", {
vectors: {
"description-dense": { size: 384, distance: "Cosine" },
},
});
use qdrant_client::Qdrant;
use qdrant_client::qdrant::{
CreateCollectionBuilder, Distance, VectorParamsBuilder, VectorsConfigBuilder,
};
let mut vectors_config = VectorsConfigBuilder::default();
vectors_config.add_named_vector_params(
"description-dense",
VectorParamsBuilder::new(384, Distance::Cosine),
);
client
.create_collection(CreateCollectionBuilder::new("books").vectors_config(vectors_config))
.await?;
import io.qdrant.client.QdrantClient;
import io.qdrant.client.QdrantGrpcClient;
import io.qdrant.client.grpc.Collections.*;
QdrantClient client =
client
.createCollectionAsync(
CreateCollection.newBuilder()
.setCollectionName("books")
.setVectorsConfig(
VectorsConfig.newBuilder()
.setParamsMap(
VectorParamsMap.newBuilder()
.putMap(
"description-dense",
VectorParams.newBuilder()
.setSize(384)
.setDistance(Distance.Cosine)
.build())
.build())
.build())
.build())
.get();
using Qdrant.Client;
using Qdrant.Client.Grpc;
await client.CreateCollectionAsync(
collectionName: "books",
vectorsConfig: new VectorParamsMap
{
Map =
{
["description-dense"] = new VectorParams
{
Size = 384,
Distance = Distance.Cosine,
},
},
}
);
client.CreateCollection(context.Background(), &qdrant.CreateCollection{
CollectionName: "books",
VectorsConfig: qdrant.NewVectorsConfigMap(
map[string]*qdrant.VectorParams{
"description-dense": {
Size: 384,
Distance: qdrant.Distance_Cosine,
},
}),
})
接下来，您可以摄取数据。
PUT /collections/books/points?wait=true
{
"points": [
{
"id": 1,
"vector": {
"description-dense": {
"text": "A Victorian scientist builds a device to travel far into the future and observes the dim trajectories of humanity. He discovers evolutionary divergence and the consequences of class division. Wells's novella established time travel as a vehicle for social commentary.",
"model": "sentence-transformers/all-minilm-l6-v2"
}
},
"payload": {
"title": "The Time Machine",
"author": "H.G. Wells",
"isbn": "9780553213515"
}
}
]
}
from qdrant_client import QdrantClient, models
client = QdrantClient(
url="https://xyz-example.qdrant.io:6333",
api_key="<your-api-key>",
cloud_inference=True,
)
client.upsert(
collection_name="books",
points=[
models.PointStruct(
id=1,
vector={
"description-dense": models.Document(
text="A Victorian scientist builds a device to travel far into the future and observes the dim trajectories of humanity. He discovers evolutionary divergence and the consequences of class division. Wells's novella established time travel as a vehicle for social commentary.",
model="sentence-transformers/all-minilm-l6-v2",
)
},
payload={
"title": "The Time Machine",
"author": "H.G. Wells",
"isbn": "9780553213515",
},
)
],
)
client.upsert("books", {
wait: true,
points: [
{
id: 1,
vector: {
"description-dense": {
text: "A Victorian scientist builds a device to travel far into the future and observes the dim trajectories of humanity. He discovers evolutionary divergence and the consequences of class division. Wells's novella established time travel as a vehicle for social commentary.",
model: "sentence-transformers/all-minilm-l6-v2",
},
},
payload: {
title: "The Time Machine",
author: "H.G. Wells",
isbn: "9780553213515",
},
},
],
});
use std::collections::HashMap;
use qdrant_client::qdrant::{Document, PointStruct, UpsertPointsBuilder};
use qdrant_client::{Payload, Qdrant};
use serde_json::json;
let point = PointStruct::new(
1,
HashMap::from([(
"description-dense".to_string(),
Document::new(
"A Victorian scientist builds a device to travel far into the future and observes the dim trajectories of humanity. He discovers evolutionary divergence and the consequences of class division. Wells's novella established time travel as a vehicle for social commentary.",
"sentence-transformers/all-minilm-l6-v2",
),
)]),
Payload::try_from(json!({
"title": "The Time Machine",
"author": "H.G. Wells",
"isbn": "9780553213515",
}))
.unwrap(),
);
client
.upsert_points(UpsertPointsBuilder::new("books", vec![point]).wait(true))
.await?;
import static io.qdrant.client.ConditionFactory.*;
import static io.qdrant.client.PointIdFactory.id;
import static io.qdrant.client.ValueFactory.value;
import static io.qdrant.client.VectorFactory.vector;
import static io.qdrant.client.VectorsFactory.namedVectors;
import io.qdrant.client.QdrantClient;
import io.qdrant.client.QdrantGrpcClient;
import io.qdrant.client.grpc.Collections.*;
import io.qdrant.client.grpc.Points.*;
import java.util.*;
QdrantClient client =
PointStruct point =
PointStruct.newBuilder()
.setId(id(1))
.setVectors(
namedVectors(
Map.of(
"description-dense",
vector(
Document.newBuilder()
.setText(
"A Victorian scientist builds a device to travel far into the future and observes the dim trajectories of humanity. He discovers evolutionary divergence and the consequences of class division. Wells's novella established time travel as a vehicle for social commentary.")
.setModel("sentence-transformers/all-minilm-l6-v2")
.build()))))
.putAllPayload(
Map.of(
"title", value("The Time Machine"),
"author", value("H.G. Wells"),
"isbn", value("9780553213515")))
.build();
client.upsertAsync("books", List.of(point)).get();
using Qdrant.Client;
using Qdrant.Client.Grpc;
await client.UpsertAsync(
collectionName: "books",
wait: true,
points: new List<PointStruct>
{
new()
{
Id = 1,
Vectors = new Dictionary<string, Vector>
{
["description-dense"] = new Document
{
Text =
"A Victorian scientist builds a device to travel far into the future and observes the dim trajectories of humanity. He discovers evolutionary divergence and the consequences of class division. Wells's novella established time travel as a vehicle for social commentary.",
Model = "sentence-transformers/all-minilm-l6-v2",
},
},
Payload =
{
["title"] = "The Time Machine",
["author"] = "H.G. Wells",
["isbn"] = "9780553213515",
},
},
}
);
client.Upsert(context.Background(), &qdrant.UpsertPoints{
CollectionName: "books",
Points: []*qdrant.PointStruct{
{
Id: qdrant.NewIDNum(uint64(1)),
Vectors: qdrant.NewVectorsMap(map[string]*qdrant.Vector{
"description-dense": qdrant.NewVectorDocument(&qdrant.Document{
Model: "sentence-transformers/all-minilm-l6-v2",
Text: "A Victorian scientist builds a device to travel far into the future and observes the dim trajectories of humanity. He discovers evolutionary divergence and the consequences of class division. Wells's novella established time travel as a vehicle for social commentary.",
}),
}),
Payload: qdrant.NewValueMap(map[string]any{
"title": "The Time Machine",
"author": "H.G. Wells",
"isbn": "9780553213515",
}),
},
},
})
要查找与“time travel”（时间旅行）相关的书籍，请使用以下查询。
POST /collections/books/points/query
{
"query": {
"text": "time travel",
"model": "sentence-transformers/all-minilm-l6-v2"
},
"using": "description-dense",
"with_payload": true
}
from qdrant_client import QdrantClient, models
client = QdrantClient(
url="https://xyz-example.qdrant.io:6333",
api_key="<your-api-key>",
cloud_inference=True,
)
client.query_points(
collection_name="books",
query=models.Document(text="time travel", model="sentence-transformers/all-minilm-l6-v2"),
using="description-dense",
with_payload=True,
)
client.query("books", {
query: {
text: "time travel",
model: "sentence-transformers/all-minilm-l6-v2",
},
using: "description-dense",
with_payload: true,
});
use qdrant_client::Qdrant;
use qdrant_client::qdrant::{Document, Query, QueryPointsBuilder};
client
.query(
QueryPointsBuilder::new("books")
.query(Query::new_nearest(Document::new(
"time travel",
"sentence-transformers/all-minilm-l6-v2",
)))
.using("description-dense")
.with_payload(true)
.build(),
)
.await?;
import static io.qdrant.client.QueryFactory.nearest;
import static io.qdrant.client.WithPayloadSelectorFactory.enable;
import io.qdrant.client.QdrantClient;
import io.qdrant.client.QdrantGrpcClient;
import io.qdrant.client.grpc.Points.*;
QdrantClient client =
client
.queryAsync(
QueryPoints.newBuilder()
.setCollectionName("books")
.setQuery(
nearest(
Document.newBuilder()
.setText("time travel")
.setModel("sentence-transformers/all-minilm-l6-v2")
.build()))
.setUsing("description-dense")
.setWithPayload(enable(true))
.build())
.get();
using Qdrant.Client;
using Qdrant.Client.Grpc;
await client.QueryAsync(
collectionName: "books",
query: new Document
{
Text = "time travel",
Model = "sentence-transformers/all-minilm-l6-v2",
},
usingVector: "description-dense",
payloadSelector: true
);
client.Query(context.Background(), &qdrant.QueryPoints{
CollectionName: "books",
Query: qdrant.NewQueryNearest(
qdrant.NewVectorInputDocument(&qdrant.Document{
Model: "sentence-transformers/all-minilm-l6-v2",
Text: "time travel",
}),
),
Using: qdrant.PtrOf("description-dense"),
WithPayload: qdrant.NewWithPayload(true),
})
在这些示例中，Qdrant 使用推理，通过指定的 model 从请求中提供的 text 生成向量。或者，您也可以使用像 FastEmbed 这样的库在客户端生成显式向量。
词法搜索
词法搜索（也称为基于关键字的搜索）是一种传统的搜索技术，依赖于匹配文本中的单词或短语。许多应用程序需要结合语义搜索和传统词法搜索。一个很好的例子是在电子商务中，用户可能希望使用产品 ID 来搜索产品。ID 值不适合向量化，但能够搜索它们对于良好的搜索体验至关重要。为了促进这些用例，Qdrant 使您能够将词法搜索与语义搜索结合使用。
过滤与查询
在 Qdrant 中进行词法搜索时，区分过滤（Filtering）和查询（Querying）非常重要。过滤用于根据精确匹配或特定条件缩小结果范围，而查询则涉及根据文本内容查找相关文档。换句话说，过滤是为了提高精度，而查询是为了提高召回率。过滤器不会影响搜索结果的排名，因为过滤器不计算分数。查询会为每个匹配的文档计算相关性分数，该分数用于对搜索结果进行排名。
| 过滤器 | 查询 (Query) |
|---|---|
| 不影响排名 | 影响排名 |
| 通过缩小结果范围来提高精度 | 通过查找相关数据来提高召回率 |
筛选
Qdrant 支持对多种数据类型进行过滤：数字、日期、布尔值、地理位置和字符串。在 Qdrant 中，过滤器通常与向量查询结合使用。向量查询用于对结果进行评分和排名，而过滤器用于根据特定标准缩小结果范围。
文本和关键字字符串
在对字符串进行过滤时，了解 Qdrant 中两种字符串类型（文本和关键字）的区别非常重要。这两种字符串类型专为不同的用例而设计：过滤精确的字符串值或过滤单个搜索词。要过滤精确的字符串值，Qdrant 使用 关键字 (keyword) 字符串。关键字字符串非常适合过滤 ID、类别或标签等字符串。要过滤较大文本主体中的单个词条或短语，Qdrant 使用 文本 (text) 字符串。
例如，以“United States”这样的字符串为例。如果您想过滤有效负载中包含此精确字符串的所有点，请使用关键字过滤器。另一方面，如果您想过滤包含单词“united”的所有点（匹配“United States”以及“United Kingdom”），则应使用文本过滤器。
| 关键字 (Keyword) | 文本 (Text) |
|---|---|
| 用于精确字符串匹配 | 用于过滤单个词条 |
| 适合 ID、类别、标签 | 适合大型文本字段 |
| 不进行分词 | 分词 (Tokenized) 成单个词条 |
| 区分大小写 | 默认不区分大小写 |
过滤精确字符串
要过滤精确字符串，首先为您要过滤的字段创建一个类型为 keyword 的有效负载索引。有效负载索引使过滤速度更快，并减轻系统负载。
例如，要按作者姓名过滤书籍，请在“author”字段上创建关键字索引。
PUT /collections/books/index?wait=true
{
"field_name": "author",
"field_schema": "keyword"
}
from qdrant_client import QdrantClient, models
client = QdrantClient(
url="https://xyz-example.qdrant.io:6333",
api_key="<your-api-key>",
cloud_inference=True,
)
client.create_payload_index(
collection_name="books",
field_name="author",
field_schema=models.PayloadSchemaType.KEYWORD
)
client.createPayloadIndex("books", {
field_name: "author",
field_schema: "keyword",
});
use qdrant_client::Qdrant;
use qdrant_client::qdrant::{CreateFieldIndexCollectionBuilder, FieldType};
client
.create_field_index(CreateFieldIndexCollectionBuilder::new(
"books",
"author",
FieldType::Keyword,
))
.await?;
import io.qdrant.client.QdrantClient;
import io.qdrant.client.QdrantGrpcClient;
import io.qdrant.client.grpc.Collections.PayloadSchemaType;
QdrantClient client =
client
.createPayloadIndexAsync(
"books", "author", PayloadSchemaType.Keyword, null, null, null, null)
.get();
using Qdrant.Client;
using Qdrant.Client.Grpc;
await client.CreatePayloadIndexAsync(
collectionName: "books",
fieldName: "author",
schemaType: PayloadSchemaType.Keyword
);
client.CreateFieldIndex(context.Background(), &qdrant.CreateFieldIndexCollection{
CollectionName: "books",
FieldName: "author",
FieldType: qdrant.FieldType_FieldTypeKeyword.Enum(),
})
接下来，在查询数据时，您还可以向请求添加过滤子句。以下示例搜索与“time travel”相关的书籍，但仅返回由 H.G. Wells 撰写的书籍。
POST /collections/books/points/query
{
"query": {
"text": "time travel",
"model": "sentence-transformers/all-minilm-l6-v2"
},
"using": "description-dense",
"with_payload": true,
"filter": {
"must": [
{
"key": "author",
"match": {
"value": "H.G. Wells"
}
}
]
}
}
from qdrant_client import QdrantClient, models
client = QdrantClient(
url="https://xyz-example.qdrant.io:6333",
api_key="<your-api-key>",
cloud_inference=True,
)
client.query_points(
collection_name="books",
query=models.Document(text="time travel", model="sentence-transformers/all-minilm-l6-v2"),
using="description-dense",
with_payload=True,
query_filter=models.Filter(
must=[models.FieldCondition(key="author", match=models.MatchValue(value="H.G. Wells"))]
),
)
client.query("books", {
query: {
text: "time travel",
model: "sentence-transformers/all-minilm-l6-v2",
},
using: "description-dense",
with_payload: true,
filter: {
must: [
{
key: "author",
match: {
value: "H.G. Wells",
},
},
],
},
});
use qdrant_client::Qdrant;
use qdrant_client::qdrant::{Condition, Document, Filter, Query, QueryPointsBuilder};
let filter = Filter::must([Condition::matches("author", "H.G. Wells".to_string())]);
client
.query(
QueryPointsBuilder::new("books")
.query(Query::new_nearest(Document::new(
"time travel",
"sentence-transformers/all-minilm-l6-v2",
)))
.using("description-dense")
.filter(filter)
.with_payload(true)
.build(),
)
.await?;
import static io.qdrant.client.ConditionFactory.*;
import static io.qdrant.client.QueryFactory.nearest;
import static io.qdrant.client.WithPayloadSelectorFactory.enable;
import io.qdrant.client.QdrantClient;
import io.qdrant.client.QdrantGrpcClient;
import io.qdrant.client.grpc.Common.Filter;
import io.qdrant.client.grpc.Points.*;
QdrantClient client =
Filter filter = Filter.newBuilder().addMust(matchKeyword("author", "H.G. Wells")).build();
client
.queryAsync(
QueryPoints.newBuilder()
.setCollectionName("books")
.setQuery(
nearest(
Document.newBuilder()
.setText("time travel")
.setModel("sentence-transformers/all-minilm-l6-v2")
.build()))
.setUsing("description-dense")
.setFilter(filter)
.setWithPayload(enable(true))
.build())
.get();
using Qdrant.Client;
using Qdrant.Client.Grpc;
using static Qdrant.Client.Grpc.Conditions;
await client.QueryAsync(
collectionName: "books",
query: new Document
{
Text = "time travel",
Model = "sentence-transformers/all-minilm-l6-v2",
},
usingVector: "description-dense",
filter: MatchKeyword("author", "H.G. Wells"),
payloadSelector: true
);
client.Query(context.Background(), &qdrant.QueryPoints{
CollectionName: "books",
Query: qdrant.NewQueryNearest(
qdrant.NewVectorInputDocument(&qdrant.Document{
Model: "sentence-transformers/all-minilm-l6-v2",
Text: "time travel",
}),
),
Using: qdrant.PtrOf("description-dense"),
WithPayload: qdrant.NewWithPayload(true),
Filter: &qdrant.Filter{
Must: []*qdrant.Condition{
qdrant.NewMatch("author", "H.G. Wells"),
},
},
})
此请求的结果排名基于查询的向量相似度。过滤器仅将结果缩小到 author 字段与 H.G. Wells 完全匹配的点。此外，过滤器区分大小写。过滤小写值 h.g. wells 将不会返回任何结果。
前面的示例仅返回匹配过滤值的点。如果您想要相反的效果：排除具有特定值的点，请使用 must_not 子句而不是 must。以下示例仅返回非 H.G. Wells 撰写的书籍。
POST /collections/books/points/query
{
"query": {
"text": "time travel",
"model": "sentence-transformers/all-minilm-l6-v2"
},
"using": "description-dense",
"with_payload": true,
"filter": {
"must_not": [
{
"key": "author",
"match": {
"value": "H.G. Wells"
}
}
]
}
}
from qdrant_client import QdrantClient, models
client = QdrantClient(
url="https://xyz-example.qdrant.io:6333",
api_key="<your-api-key>",
cloud_inference=True,
)
client.query_points(
collection_name="books",
query=models.Document(text="time travel", model="sentence-transformers/all-minilm-l6-v2"),
using="description-dense",
with_payload=True,
query_filter=models.Filter(
must_not=[models.FieldCondition(key="author", match=models.MatchValue(value="H.G. Wells"))]
),
)
client.query("books", {
query: {
text: "time travel",
model: "sentence-transformers/all-minilm-l6-v2",
},
using: "description-dense",
with_payload: true,
filter: {
must_not: [
{ key: "author", match: { value: "H.G. Wells" } },
],
},
});
use qdrant_client::Qdrant;
use qdrant_client::qdrant::{Condition, Document, Filter, Query, QueryPointsBuilder};
let filter = Filter::must_not([Condition::matches("author", "H.G. Wells".to_string())]);
client
.query(
QueryPointsBuilder::new("books")
.query(Query::new_nearest(Document::new(
"time travel",
"sentence-transformers/all-minilm-l6-v2",
)))
.using("description-dense")
.filter(filter)
.with_payload(true)
.build(),
)
.await?;
import static io.qdrant.client.ConditionFactory.*;
import static io.qdrant.client.QueryFactory.nearest;
import static io.qdrant.client.WithPayloadSelectorFactory.enable;
import io.qdrant.client.QdrantClient;
import io.qdrant.client.QdrantGrpcClient;
import io.qdrant.client.grpc.Common.Filter;
import io.qdrant.client.grpc.Points.*;
QdrantClient client =
Filter filter = Filter.newBuilder().addMustNot(matchKeyword("author", "H.G. Wells")).build();
client
.queryAsync(
QueryPoints.newBuilder()
.setCollectionName("books")
.setQuery(
nearest(
Document.newBuilder()
.setText("time travel")
.setModel("sentence-transformers/all-minilm-l6-v2")
.build()))
.setUsing("description-dense")
.setFilter(filter)
.setWithPayload(enable(true))
.build())
.get();
using Qdrant.Client;
using Qdrant.Client.Grpc;
using static Qdrant.Client.Grpc.Conditions;
var excludeFilter = new Filter { MustNot = { MatchKeyword("author", "H.G. Wells") } };
await client.QueryAsync(
collectionName: "books",
query: new Document
{
Text = "time travel",
Model = "sentence-transformers/all-minilm-l6-v2",
},
usingVector: "description-dense",
filter: excludeFilter,
payloadSelector: true
);
excludeFilter := qdrant.Filter{
MustNot: []*qdrant.Condition{
qdrant.NewMatch("author", "H.G. Wells"),
},
}
client.Query(context.Background(), &qdrant.QueryPoints{
CollectionName: "books",
Query: qdrant.NewQueryNearest(
qdrant.NewVectorInputDocument(&qdrant.Document{
Model: "sentence-transformers/all-minilm-l6-v2",
Text: "time travel",
}),
),
Using: qdrant.PtrOf("description-dense"),
WithPayload: qdrant.NewWithPayload(true),
Filter: &excludeFilter,
})
过滤多个精确字符串
您可以提供多个过滤子句。例如，要查找 Larry Niven 和 Jerry Pournelle 合著的所有书籍，请使用以下过滤器。
POST /collections/books/points/query
{
"query": {
"text": "space opera",
"model": "sentence-transformers/all-minilm-l6-v2"
},
"using": "description-dense",
"with_payload": true,
"filter": {
"must": [
{
"key": "author",
"match": {
"value": "Larry Niven"
}
},
{
"key": "author",
"match": {
"value": "Jerry Pournelle"
}
}
]
}
}
from qdrant_client import QdrantClient, models
client = QdrantClient(
url="https://xyz-example.qdrant.io:6333",
api_key="<your-api-key>",
cloud_inference=True,
)
client.query_points(
collection_name="books",
query=models.Document(text="space opera", model="sentence-transformers/all-minilm-l6-v2"),
using="description-dense",
with_payload=True,
query_filter=models.Filter(
must=[
models.FieldCondition(key="author", match=models.MatchValue(value="Larry Niven")),
models.FieldCondition(key="author", match=models.MatchValue(value="Jerry Pournelle")),
]
),
)
client.query("books", {
query: {
text: "space opera",
model: "sentence-transformers/all-minilm-l6-v2",
},
using: "description-dense",
with_payload: true,
filter: {
must: [
{ key: "author", match: { value: "Larry Niven" } },
{ key: "author", match: { value: "Jerry Pournelle" } },
],
},
});
use qdrant_client::Qdrant;
use qdrant_client::qdrant::{Condition, Document, Filter, Query, QueryPointsBuilder};
let filter = Filter::must([
Condition::matches("author", "Larry Niven".to_string()),
Condition::matches("author", "Jerry Pournelle".to_string()),
]);
client
.query(
QueryPointsBuilder::new("books")
.query(Query::new_nearest(Document::new(
"space opera",
"sentence-transformers/all-minilm-l6-v2",
)))
.using("description-dense")
.filter(filter)
.with_payload(true)
.build(),
)
.await?;
import static io.qdrant.client.ConditionFactory.*;
import static io.qdrant.client.QueryFactory.nearest;
import static io.qdrant.client.WithPayloadSelectorFactory.enable;
import io.qdrant.client.QdrantClient;
import io.qdrant.client.QdrantGrpcClient;
import io.qdrant.client.grpc.Common.Filter;
import io.qdrant.client.grpc.Points.*;
QdrantClient client =
Filter filter =
Filter.newBuilder()
.addMust(matchKeyword("author", "Larry Niven"))
.addMust(matchKeyword("author", "Jerry Pournelle"))
.build();
client
.queryAsync(
QueryPoints.newBuilder()
.setCollectionName("books")
.setQuery(
nearest(
Document.newBuilder()
.setText("space opera")
.setModel("sentence-transformers/all-minilm-l6-v2")
.build()))
.setUsing("description-dense")
.setFilter(filter)
.setWithPayload(enable(true))
.build())
.get();
using Qdrant.Client;
using Qdrant.Client.Grpc;
using static Qdrant.Client.Grpc.Conditions;
var andFilter = new Filter
{
Must =
{
MatchKeyword("author", "Larry Niven"),
MatchKeyword("author", "Jerry Pournelle"),
},
};
await client.QueryAsync(
collectionName: "books",
query: new Document
{
Text = "space opera",
Model = "sentence-transformers/all-minilm-l6-v2",
},
usingVector: "description-dense",
filter: andFilter,
payloadSelector: true
);
andFilter := qdrant.Filter{
Must: []*qdrant.Condition{
qdrant.NewMatch("author", "Larry Niven"),
qdrant.NewMatch("author", "Jerry Pournelle"),
},
}
client.Query(context.Background(), &qdrant.QueryPoints{
CollectionName: "books",
Query: qdrant.NewQueryNearest(
qdrant.NewVectorInputDocument(&qdrant.Document{
Model: "sentence-transformers/all-minilm-l6-v2",
Text: "space opera",
}),
),
Using: qdrant.PtrOf("description-dense"),
WithPayload: qdrant.NewWithPayload(true),
Filter: &andFilter,
})
请注意，一个点要包含在结果中，两个过滤子句都必须为真，因为 must 子句的操作类似于逻辑 AND。如果您想查找由其中任何一位作者（或两位作者）撰写的书籍，请使用 should 子句，它类似于逻辑 OR。
POST /collections/books/points/query
{
"query": {
"text": "space opera",
"model": "sentence-transformers/all-minilm-l6-v2"
},
"using": "description-dense",
"with_payload": true,
"filter": {
"should": [
{
"key": "author",
"match": {
"value": "Larry Niven"
}
},
{
"key": "author",
"match": {
"value": "Jerry Pournelle"
}
}
]
}
}
from qdrant_client import QdrantClient, models
client = QdrantClient(
url="https://xyz-example.qdrant.io:6333",
api_key="<your-api-key>",
cloud_inference=True,
)
client.query_points(
collection_name="books",
query=models.Document(text="space opera", model="sentence-transformers/all-minilm-l6-v2"),
using="description-dense",
with_payload=True,
query_filter=models.Filter(
should=[
models.FieldCondition(key="author", match=models.MatchValue(value="Larry Niven")),
models.FieldCondition(key="author", match=models.MatchValue(value="Jerry Pournelle")),
]
),
)
client.query("books", {
query: {
text: "space opera",
model: "sentence-transformers/all-minilm-l6-v2",
},
using: "description-dense",
with_payload: true,
filter: {
should: [
{ key: "author", match: { value: "Larry Niven" } },
{ key: "author", match: { value: "Jerry Pournelle" } },
],
},
});
use qdrant_client::Qdrant;
use qdrant_client::qdrant::{Condition, Document, Filter, Query, QueryPointsBuilder};
let filter = Filter::should([
Condition::matches("author", "Larry Niven".to_string()),
Condition::matches("author", "Jerry Pournelle".to_string()),
]);
client
.query(
QueryPointsBuilder::new("books")
.query(Query::new_nearest(Document::new(
"space opera",
"sentence-transformers/all-minilm-l6-v2",
)))
.using("description-dense")
.filter(filter)
.with_payload(true)
.build(),
)
.await?;
import static io.qdrant.client.ConditionFactory.*;
import static io.qdrant.client.QueryFactory.nearest;
import static io.qdrant.client.WithPayloadSelectorFactory.enable;
import io.qdrant.client.QdrantClient;
import io.qdrant.client.QdrantGrpcClient;
import io.qdrant.client.grpc.Common.Filter;
import io.qdrant.client.grpc.Points.*;
QdrantClient client =
Filter filter =
Filter.newBuilder()
.addShould(matchKeyword("author", "Larry Niven"))
.addShould(matchKeyword("author", "Jerry Pournelle"))
.build();
client
.queryAsync(
QueryPoints.newBuilder()
.setCollectionName("books")
.setQuery(
nearest(
Document.newBuilder()
.setText("space opera")
.setModel("sentence-transformers/all-minilm-l6-v2")
.build()))
.setUsing("description-dense")
.setFilter(filter)
.setWithPayload(enable(true))
.build())
.get();
using Qdrant.Client;
using Qdrant.Client.Grpc;
using static Qdrant.Client.Grpc.Conditions;
var orFilter = new Filter
{
Should =
{
MatchKeyword("author", "Larry Niven"),
MatchKeyword("author", "Jerry Pournelle"),
},
};
await client.QueryAsync(
collectionName: "books",
query: new Document
{
Text = "space opera",
Model = "sentence-transformers/all-minilm-l6-v2",
},
usingVector: "description-dense",
filter: orFilter,
payloadSelector: true
);
orFilter := qdrant.Filter{
Should: []*qdrant.Condition{
qdrant.NewMatch("author", "Larry Niven"),
qdrant.NewMatch("author", "Jerry Pournelle"),
},
}
client.Query(context.Background(), &qdrant.QueryPoints{
CollectionName: "books",
Query: qdrant.NewQueryNearest(
qdrant.NewVectorInputDocument(&qdrant.Document{
Model: "sentence-transformers/all-minilm-l6-v2",
Text: "space opera",
}),
),
Using: qdrant.PtrOf("description-dense"),
WithPayload: qdrant.NewWithPayload(true),
Filter: &orFilter,
})
或者，当您想过滤单个键的一个或多个值时，可以使用 any 条件。
POST /collections/books/points/query
{
"query": {
"text": "space opera",
"model": "sentence-transformers/all-minilm-l6-v2"
},
"using": "description-dense",
"with_payload": true,
"filter": {
"must": [
{
"key": "author",
"match": {
"any": ["Larry Niven", "Jerry Pournelle"]
}
}
]
}
}
from qdrant_client import QdrantClient, models
client = QdrantClient(
url="https://xyz-example.qdrant.io:6333",
api_key="<your-api-key>",
cloud_inference=True,
)
client.query_points(
collection_name="books",
query=models.Document(text="space opera", model="sentence-transformers/all-minilm-l6-v2"),
using="description-dense",
with_payload=True,
query_filter=models.Filter(
must=[
models.FieldCondition(
key="author",
match=models.MatchAny(any=["Larry Niven", "Jerry Pournelle"]),
)
]
),
)
client.query("books", {
query: {
text: "space opera",
model: "sentence-transformers/all-minilm-l6-v2",
},
using: "description-dense",
with_payload: true,
filter: {
must: [
{
key: "author",
match: { any: ["Larry Niven", "Jerry Pournelle"] },
},
],
},
});
use qdrant_client::Qdrant;
use qdrant_client::qdrant::{Condition, Document, Filter, Query, QueryPointsBuilder};
let filter = Filter::should([
Condition::matches("author", "Larry Niven".to_string()),
Condition::matches("author", "Jerry Pournelle".to_string()),
]);
client
.query(
QueryPointsBuilder::new("books")
.query(Query::new_nearest(Document::new(
"space opera",
"sentence-transformers/all-minilm-l6-v2",
)))
.using("description-dense")
.filter(filter)
.with_payload(true)
.build(),
)
.await?;
import static io.qdrant.client.ConditionFactory.*;
import static io.qdrant.client.QueryFactory.nearest;
import static io.qdrant.client.WithPayloadSelectorFactory.enable;
import io.qdrant.client.QdrantClient;
import io.qdrant.client.QdrantGrpcClient;
import io.qdrant.client.grpc.Common.Filter;
import io.qdrant.client.grpc.Points.*;
QdrantClient client =
Filter filter =
Filter.newBuilder()
.addShould(matchKeyword("author", "Larry Niven"))
.addShould(matchKeyword("author", "Jerry Pournelle"))
.build();
client
.queryAsync(
QueryPoints.newBuilder()
.setCollectionName("books")
.setQuery(
nearest(
Document.newBuilder()
.setText("space opera")
.setModel("sentence-transformers/all-minilm-l6-v2")
.build()))
.setUsing("description-dense")
.setFilter(filter)
.setWithPayload(enable(true))
.build())
.get();
using Qdrant.Client;
using Qdrant.Client.Grpc;
using static Qdrant.Client.Grpc.Conditions;
var anyFilter = new Filter
{
Should =
{
MatchKeyword("author", "Larry Niven"),
MatchKeyword("author", "Jerry Pournelle"),
},
};
await client.QueryAsync(
collectionName: "books",
query: new Document
{
Text = "space opera",
Model = "sentence-transformers/all-minilm-l6-v2",
},
usingVector: "description-dense",
filter: anyFilter,
payloadSelector: true
);
anyFilter := qdrant.Filter{
Should: []*qdrant.Condition{
qdrant.NewMatch("author", "Larry Niven"),
qdrant.NewMatch("author", "Jerry Pournelle"),
},
}
client.Query(context.Background(), &qdrant.QueryPoints{
CollectionName: "books",
Query: qdrant.NewQueryNearest(
qdrant.NewVectorInputDocument(&qdrant.Document{
Model: "sentence-transformers/all-minilm-l6-v2",
Text: "space opera",
}),
),
Using: qdrant.PtrOf("description-dense"),
WithPayload: qdrant.NewWithPayload(true),
Filter: &anyFilter,
})
全文过滤
与关键字过滤相比，对文本字符串进行过滤使您能够以不区分大小写的方式过滤较大文本字段中的单个单词。要了解其工作原理，了解文本字符串在索引时和查询时如何处理非常重要。
文本处理
为了实现高效的全文过滤，Qdrant 通过将文本字符串分解为单个令牌（单词）并应用多个归一化步骤来处理它们。此过程确保搜索更加灵活，并且可以匹配单词的变化形式。在查询时，Qdrant 对过滤字符串应用相同的处理步骤，确保过滤器正确匹配索引后的令牌。
以下文本处理步骤应用于文本字符串：
- 使用称为分词 (tokenization) 的过程将字符串分解为单个令牌（单词）。默认情况下，Qdrant 使用
word分词器，它使用单词边界拆分字符串，并丢弃空格、标点符号和特殊字符。 - 默认情况下，每个单词都会被转换为小写。将令牌转换为小写允许 Qdrant 忽略大小写，从而使全文过滤器不区分大小写。
- 可选地，Qdrant 可以使用称为 ASCII 折叠 (ASCII folding) 的过程从字符中删除变音符号（重音）。这确保了变音符号被忽略。因此，过滤单词“cafe”可以匹配“café”。
- 可选地，可以使用词干提取器 (stemmer) 将令牌还原为其根形式。这确保了过滤“running”也可以匹配“run”和“ran”。由于词干提取是特定于语言的，如果启用，必须针对特定语言进行配置。
- 像“the”、“is”和“and”这样的词在文本中非常常见，对文本含义贡献不大。这些词称为停用词 (stopwords)，可以在索引期间选择性地删除。与词干提取一样，停用词删除也是特定于语言的。您可以配置特定语言进行停用词删除和/或提供自定义的停用词列表。
- 可选地，您可以启用短语匹配 (phrase matching)，以允许过滤原始文本中以完全相同顺序出现的多个单词。
这些文本处理步骤可以在创建全文索引时进行配置。例如，要在启用了 ASCII 折叠的 title 字段上创建文本索引：
PUT /collections/books/index?wait=true
{
"field_name": "title",
"field_schema": {
"type": "text",
"ascii_folding": true
}
}
from qdrant_client import QdrantClient, models
client = QdrantClient(
url="https://xyz-example.qdrant.io:6333",
api_key="<your-api-key>",
cloud_inference=True,
)
client.create_payload_index(
collection_name="books",
field_name="title",
field_schema=models.TextIndexParams(type=models.TextIndexType.TEXT, ascii_folding=True),
)
client.createPayloadIndex("books", {
field_name: "title",
field_schema: {
type: "text",
ascii_folding: true,
},
});
use qdrant_client::Qdrant;
use qdrant_client::qdrant::{
CreateFieldIndexCollectionBuilder, FieldType, TextIndexParamsBuilder, TokenizerType,
};
let params = TextIndexParamsBuilder::new(TokenizerType::Word)
.ascii_folding(true)
.lowercase(true)
.build();
client
.create_field_index(
CreateFieldIndexCollectionBuilder::new("books", "title", FieldType::Text)
.field_index_params(params),
)
.await?;
import io.qdrant.client.QdrantClient;
import io.qdrant.client.QdrantGrpcClient;
import io.qdrant.client.grpc.Collections.PayloadIndexParams;
import io.qdrant.client.grpc.Collections.PayloadSchemaType;
import io.qdrant.client.grpc.Collections.TextIndexParams;
import io.qdrant.client.grpc.Collections.TokenizerType;
QdrantClient client =
client
.createPayloadIndexAsync(
"books",
"title",
PayloadSchemaType.Text,
PayloadIndexParams.newBuilder()
.setTextIndexParams(
TextIndexParams.newBuilder()
.setTokenizer(TokenizerType.Word)
.setAsciiFolding(true)
.setLowercase(true)
.build())
.build(),
null,
null,
null)
.get();
using Qdrant.Client;
using Qdrant.Client.Grpc;
await client.CreatePayloadIndexAsync(
collectionName: "books",
fieldName: "title",
schemaType: PayloadSchemaType.Text,
indexParams: new PayloadIndexParams
{
TextIndexParams = new TextIndexParams
{
Tokenizer = TokenizerType.Word,
AsciiFolding = true,
Lowercase = true,
},
}
);
client.CreateFieldIndex(context.Background(), &qdrant.CreateFieldIndexCollection{
CollectionName: "books",
FieldName: "title",
FieldType: qdrant.FieldType_FieldTypeText.Enum(),
FieldIndexParams: qdrant.NewPayloadIndexParamsText(
&qdrant.TextIndexParams{
Tokenizer: qdrant.TokenizerType_Word,
Lowercase: qdrant.PtrOf(true),
AsciiFolding: qdrant.PtrOf(true),
}),
})
使用此索引查询时，Qdrant 会自动对过滤字符串应用相同的文本处理步骤，然后再将其与索引后的令牌进行匹配。
过滤文本字符串
要过滤有效负载字段中的文本值，首先为该字段创建一个全文索引。接下来，您可以使用 text 条件查询集合，过滤包含单词“space”的标题。
POST /collections/books/points/query
{
"query": {
"text": "space opera",
"model": "sentence-transformers/all-minilm-l6-v2"
},
"using": "description-dense",
"with_payload": true,
"filter": {
"must": [
{
"key": "title",
"match": {
"text": "space"
}
}
]
}
}
from qdrant_client import QdrantClient, models
client = QdrantClient(
url="https://xyz-example.qdrant.io:6333",
api_key="<your-api-key>",
cloud_inference=True,
)
client.query_points(
collection_name="books",
query=models.Document(text="space opera", model="sentence-transformers/all-minilm-l6-v2"),
using="description-dense",
with_payload=True,
query_filter=models.Filter(
must=[models.FieldCondition(key="title", match=models.MatchText(text="space"))]
),
)
client.query("books", {
query: {
text: "space opera",
model: "sentence-transformers/all-minilm-l6-v2",
},
using: "description-dense",
with_payload: true,
filter: {
must: [
{ key: "title", match: { text: "space" } },
],
},
});
use qdrant_client::Qdrant;
use qdrant_client::qdrant::{Condition, Document, Filter, Query, QueryPointsBuilder};
let filter = Filter::must([Condition::matches("title", "space".to_string())]);
client
.query(
QueryPointsBuilder::new("books")
.query(Query::new_nearest(Document::new(
"space opera",
"sentence-transformers/all-minilm-l6-v2",
)))
.using("description-dense")
.filter(filter)
.with_payload(true)
.build(),
)
.await?;
import static io.qdrant.client.ConditionFactory.*;
import static io.qdrant.client.QueryFactory.nearest;
import static io.qdrant.client.WithPayloadSelectorFactory.enable;
import io.qdrant.client.QdrantClient;
import io.qdrant.client.QdrantGrpcClient;
import io.qdrant.client.grpc.Common.Filter;
import io.qdrant.client.grpc.Points.*;
QdrantClient client =
Filter filter = Filter.newBuilder().addMust(matchText("title", "space")).build();
client
.queryAsync(
QueryPoints.newBuilder()
.setCollectionName("books")
.setQuery(
nearest(
Document.newBuilder()
.setText("space opera")
.setModel("sentence-transformers/all-minilm-l6-v2")
.build()))
.setUsing("description-dense")
.setFilter(filter)
.setWithPayload(enable(true))
.build())
.get();
using Qdrant.Client;
using Qdrant.Client.Grpc;
using static Qdrant.Client.Grpc.Conditions;
await client.QueryAsync(
collectionName: "books",
query: new Document
{
Text = "space opera",
Model = "sentence-transformers/all-minilm-l6-v2",
},
usingVector: "description-dense",
filter: MatchText("title", "space"),
payloadSelector: true
);
client.Query(context.Background(), &qdrant.QueryPoints{
CollectionName: "books",
Query: qdrant.NewQueryNearest(
qdrant.NewVectorInputDocument(&qdrant.Document{
Model: "sentence-transformers/all-minilm-l6-v2",
Text: "space opera",
}),
),
Using: qdrant.PtrOf("description-dense"),
WithPayload: qdrant.NewWithPayload(true),
Filter: &qdrant.Filter{
Must: []*qdrant.Condition{qdrant.NewMatchText("title", "space")},
},
})
过滤多个词条时，text 过滤器仅匹配包含所有指定词条的字段（逻辑 AND）。要匹配包含任何指定词条的字段（逻辑 OR），请使用 text_any 条件。
POST /collections/books/points/query
{
"query": {
"text": "space opera",
"model": "sentence-transformers/all-minilm-l6-v2"
},
"using": "description-dense",
"with_payload": true,
"filter": {
"must": [
{
"key": "title",
"match": {
"text_any": "space war"
}
}
]
}
}
from qdrant_client import QdrantClient, models
client = QdrantClient(
url="https://xyz-example.qdrant.io:6333",
api_key="<your-api-key>",
cloud_inference=True,
)
client.query_points(
collection_name="books",
query=models.Document(text="space opera", model="sentence-transformers/all-minilm-l6-v2"),
using="description-dense",
with_payload=True,
query_filter=models.Filter(
must=[models.FieldCondition(key="title", match=models.MatchTextAny(text_any="space war"))]
),
)
client.query("books", {
query: {
text: "space opera",
model: "sentence-transformers/all-minilm-l6-v2",
},
using: "description-dense",
with_payload: true,
filter: {
must: [
{ key: "title", match: { text_any: "space war" } },
],
},
});
use qdrant_client::Qdrant;
use qdrant_client::qdrant::{Condition, Document, Filter, Query, QueryPointsBuilder};
let filter = Filter::must([Condition::matches("title", "space war".to_string())]);
client
.query(
QueryPointsBuilder::new("books")
.query(Query::new_nearest(Document::new(
"space opera",
"sentence-transformers/all-minilm-l6-v2",
)))
.using("description-dense")
.filter(filter)
.with_payload(true)
.build(),
)
.await?;
import static io.qdrant.client.ConditionFactory.*;
import static io.qdrant.client.QueryFactory.nearest;
import static io.qdrant.client.WithPayloadSelectorFactory.enable;
import io.qdrant.client.QdrantClient;
import io.qdrant.client.QdrantGrpcClient;
import io.qdrant.client.grpc.Common.Filter;
import io.qdrant.client.grpc.Points.*;
QdrantClient client =
Filter filter = Filter.newBuilder().addMust(matchTextAny("title", "space war")).build();
client
.queryAsync(
QueryPoints.newBuilder()
.setCollectionName("books")
.setQuery(
nearest(
Document.newBuilder()
.setText("space opera")
.setModel("sentence-transformers/all-minilm-l6-v2")
.build()))
.setUsing("description-dense")
.setFilter(filter)
.setWithPayload(enable(true))
.build())
.get();
using Qdrant.Client;
using Qdrant.Client.Grpc;
using static Qdrant.Client.Grpc.Conditions;
await client.QueryAsync(
collectionName: "books",
query: new Document
{
Text = "space opera",
Model = "sentence-transformers/all-minilm-l6-v2",
},
usingVector: "description-dense",
filter: MatchTextAny("title", "space war"),
payloadSelector: true
);
client.Query(context.Background(), &qdrant.QueryPoints{
CollectionName: "books",
Query: qdrant.NewQueryNearest(
qdrant.NewVectorInputDocument(&qdrant.Document{
Model: "sentence-transformers/all-minilm-l6-v2",
Text: "space opera",
}),
),
Using: qdrant.PtrOf("description-dense"),
WithPayload: qdrant.NewWithPayload(true),
Filter: &qdrant.Filter{
Must: []*qdrant.Condition{qdrant.NewMatchTextAny("title", "space war")},
},
})
Qdrant 还支持短语过滤，使您能够搜索以原始文本中完全相同顺序出现的多个单词，且中间没有其他单词。例如，短语过滤器“time machine”可以匹配标题“The Time Machine”，但不会匹配“The Time Travel Machine”（“time”和“machine”之间有一个单词），也不会匹配“Machine Time”（单词顺序不正确）。
短语过滤和关键字过滤的区别在于，短语过滤应用文本处理，因此不区分大小写，而关键字过滤区分大小写，且仅匹配精确字符串。此外，关键字过滤必须匹配整个字符串，而短语过滤可以匹配较长字符串的一部分。因此，关键字过滤器“Space War”无法匹配“The Space War”，因为它不匹配“The”，但短语过滤器“Space War”可以。
总结四种过滤方法对“Space War”进行多词过滤的区别：
| 方法 | 实际查询 | 匹配 Space War? | 匹配 The Space War? | 匹配 War in Space? | 匹配 War of the Worlds? |
|---|---|---|---|---|---|
| text_any | space 或 war | 是 | 是 | 是 | 是 |
| text | space 和 war | 是 | 是 | 是 | 否 |
| phrase | "space war" | 是 | 是 | 否 | 否 |
| keyword | "Space War" | 是 | 否 | 否 | 否 |
要过滤短语，请使用 phrase 条件。这要求在创建全文索引时启用短语搜索。
PUT /collections/books/index?wait=true
{
"field_name": "title",
"field_schema": {
"type": "text",
"ascii_folding": true,
"phrase_matching": true
}
}
from qdrant_client import QdrantClient, models
client = QdrantClient(
url="https://xyz-example.qdrant.io:6333",
api_key="<your-api-key>",
cloud_inference=True,
)
client.create_payload_index(
collection_name="books",
field_name="title",
field_schema=models.TextIndexParams(type=models.TextIndexType.TEXT, ascii_folding=True, phrase_matching=True),
)
client.createPayloadIndex("books", {
field_name: "title",
field_schema: {
type: "text",
ascii_folding: true,
phrase_matching: true,
},
});
use qdrant_client::Qdrant;
use qdrant_client::qdrant::{
CreateFieldIndexCollectionBuilder, FieldType, TextIndexParamsBuilder, TokenizerType,
};
let params = TextIndexParamsBuilder::new(TokenizerType::Word)
.ascii_folding(true)
.phrase_matching(true)
.lowercase(true)
.build();
client
.create_field_index(
CreateFieldIndexCollectionBuilder::new("books", "title", FieldType::Text)
.field_index_params(params),
)
.await?;
import io.qdrant.client.QdrantClient;
import io.qdrant.client.QdrantGrpcClient;
import io.qdrant.client.grpc.Collections.PayloadIndexParams;
import io.qdrant.client.grpc.Collections.PayloadSchemaType;
import io.qdrant.client.grpc.Collections.TextIndexParams;
import io.qdrant.client.grpc.Collections.TokenizerType;
QdrantClient client =
client
.createPayloadIndexAsync(
"books",
"title",
PayloadSchemaType.Text,
PayloadIndexParams.newBuilder()
.setTextIndexParams(
TextIndexParams.newBuilder()
.setTokenizer(TokenizerType.Word)
.setAsciiFolding(true)
.setPhraseMatching(true)
.setLowercase(true)
.build())
.build(),
null,
null,
null)
.get();
using Qdrant.Client;
using Qdrant.Client.Grpc;
await client.CreatePayloadIndexAsync(
collectionName: "books",
fieldName: "title",
schemaType: PayloadSchemaType.Text,
indexParams: new PayloadIndexParams
{
TextIndexParams = new TextIndexParams
{
Tokenizer = TokenizerType.Word,
AsciiFolding = true,
PhraseMatching = true,
Lowercase = true,
},
}
);
client.CreateFieldIndex(context.Background(), &qdrant.CreateFieldIndexCollection{
CollectionName: "books",
FieldName: "title",
FieldType: qdrant.FieldType_FieldTypeText.Enum(),
FieldIndexParams: qdrant.NewPayloadIndexParamsText(
&qdrant.TextIndexParams{
Tokenizer: qdrant.TokenizerType_Word,
Lowercase: qdrant.PtrOf(true),
AsciiFolding: qdrant.PtrOf(true),
PhraseMatching: qdrant.PtrOf(true),
}),
})
接下来，您可以使用 phrase 条件来过滤包含精确短语“time machine”的标题。
POST /collections/books/points/query
{
"query": {
"text": "time travel",
"model": "sentence-transformers/all-minilm-l6-v2"
},
"using": "description-dense",
"with_payload": true,
"filter": {
"must": [
{
"key": "title",
"match": {
"phrase": "time machine"
}
}
]
}
}
from qdrant_client import QdrantClient, models
client = QdrantClient(
url="https://xyz-example.qdrant.io:6333",
api_key="<your-api-key>",
cloud_inference=True,
)
client.query_points(
collection_name="books",
query=models.Document(text="time travel", model="sentence-transformers/all-minilm-l6-v2"),
using="description-dense",
with_payload=True,
query_filter=models.Filter(
must=[models.FieldCondition(key="title", match=models.MatchPhrase(phrase="time machine"))]
),
)
client.query("books", {
query: {
text: "time travel",
model: "sentence-transformers/all-minilm-l6-v2",
},
using: "description-dense",
with_payload: true,
filter: {
must: [
{ key: "title", match: { phrase: "time machine" } },
],
},
});
use qdrant_client::Qdrant;
use qdrant_client::qdrant::{Condition, Document, Filter, Query, QueryPointsBuilder};
let filter = Filter::must([Condition::matches("title", "time machine".to_string())]);
client
.query(
QueryPointsBuilder::new("books")
.query(Query::new_nearest(Document::new(
"time travel",
"sentence-transformers/all-minilm-l6-v2",
)))
.using("description-dense")
.filter(filter)
.with_payload(true)
.build(),
)
.await?;
import static io.qdrant.client.ConditionFactory.*;
import static io.qdrant.client.QueryFactory.nearest;
import static io.qdrant.client.WithPayloadSelectorFactory.enable;
import io.qdrant.client.QdrantClient;
import io.qdrant.client.QdrantGrpcClient;
import io.qdrant.client.grpc.Collections.*;
import io.qdrant.client.grpc.Common.Filter;
import io.qdrant.client.grpc.Points.*;
import java.util.*;
QdrantClient client =
Filter filter = Filter.newBuilder().addMust(matchPhrase("title", "time machine")).build();
client
.queryAsync(
QueryPoints.newBuilder()
.setCollectionName("books")
.setQuery(
nearest(
Document.newBuilder()
.setText("time travel")
.setModel("sentence-transformers/all-minilm-l6-v2")
.build()))
.setUsing("description-dense")
.setFilter(filter)
.setWithPayload(enable(true))
.build())
.get();
using Qdrant.Client;
using Qdrant.Client.Grpc;
using static Qdrant.Client.Grpc.Conditions;
await client.QueryAsync(
collectionName: "books",
query: new Document
{
Text = "time travel",
Model = "sentence-transformers/all-minilm-l6-v2",
},
usingVector: "description-dense",
filter: MatchPhrase("title", "time machine"),
payloadSelector: true
);
client.Query(context.Background(), &qdrant.QueryPoints{
CollectionName: "books",
Query: qdrant.NewQueryNearest(
qdrant.NewVectorInputDocument(&qdrant.Document{
Model: "sentence-transformers/all-minilm-l6-v2",
Text: "time travel",
}),
),
Using: qdrant.PtrOf("description-dense"),
WithPayload: qdrant.NewWithPayload(true),
Filter: &qdrant.Filter{
Must: []*qdrant.Condition{qdrant.NewMatchPhrase("title", "time machine")},
},
})
使用批量搜索 API 进行渐进式过滤
尽管过滤器不用于对结果进行排名，但您可以使用批量搜索 API 来逐步放宽过滤器。当您有严格的过滤标准但可能没有返回结果时，这非常有用。通过批量处理多个具有渐进式放宽过滤器的搜索请求，即使最严格的过滤器没有返回结果，您也可以获得结果。
例如，以下批量搜索请求首先尝试查找标题中匹配所有搜索词的书籍。第二个搜索请求放宽过滤器以匹配任何搜索词。第三个搜索请求完全移除过滤器。
POST /collections/books/points/query/batch
{
"searches": [
{
"query": {
"text": "time travel",
"model": "sentence-transformers/all-minilm-l6-v2"
},
"using": "description-dense",
"with_payload": true,
"filter": {
"must": [
{
"key": "title",
"match": {
"text": "time travel"
}
}
]
}
},
{
"query": {
"text": "time travel",
"model": "sentence-transformers/all-minilm-l6-v2"
},
"using": "description-dense",
"with_payload": true,
"filter": {
"must": [
{
"key": "title",
"match": {
"text_any": "time travel"
}
}
]
}
},
{
"query": {
"text": "time travel",
"model": "sentence-transformers/all-minilm-l6-v2"
},
"using": "description-dense",
"with_payload": true
}
]
}
from qdrant_client import QdrantClient, models
client = QdrantClient(
url="https://xyz-example.qdrant.io:6333",
api_key="<your-api-key>",
cloud_inference=True,
)
client.query_batch_points(
collection_name="books",
requests=[
models.QueryRequest(
query=models.Document(text="time travel", model="sentence-transformers/all-minilm-l6-v2"),
using="description-dense",
with_payload=True,
filter=models.Filter(
must=[models.FieldCondition(key="title", match=models.MatchText(text="time travel"))]
),
),
models.QueryRequest(
query=models.Document(text="time travel", model="sentence-transformers/all-minilm-l6-v2"),
using="description-dense",
with_payload=True,
filter=models.Filter(
must=[models.FieldCondition(key="title", match=models.MatchTextAny(text_any="time travel"))]
),
),
models.QueryRequest(
query=models.Document(text="time travel", model="sentence-transformers/all-minilm-l6-v2"),
using="description-dense",
with_payload=True,
),
],
)
client.queryBatch("books", {
searches: [
{
query: { text: "time travel", model: "sentence-transformers/all-minilm-l6-v2" },
using: "description-dense",
with_payload: true,
filter: {
must: [{ key: "title", match: { text: "time travel" } }],
},
},
{
query: { text: "time travel", model: "sentence-transformers/all-minilm-l6-v2" },
using: "description-dense",
with_payload: true,
filter: {
must: [{ key: "title", match: { text_any: "time travel" } }],
},
},
{
query: { text: "time travel", model: "sentence-transformers/all-minilm-l6-v2" },
using: "description-dense",
with_payload: true,
},
],
});
use qdrant_client::Qdrant;
use qdrant_client::qdrant::{
Condition, Document, Filter, Query, QueryBatchPointsBuilder, QueryPointsBuilder,
};
let strict_filter = Filter::must([Condition::matches("title", "time travel".to_string())]);
let relaxed_filter = Filter::must([Condition::matches("title", "time travel".to_string())]);
let searches = vec![
QueryPointsBuilder::new("books")
.query(Query::new_nearest(Document::new(
"time travel",
"sentence-transformers/all-minilm-l6-v2",
)))
.using("description-dense")
.filter(strict_filter)
.with_payload(true)
.build(),
QueryPointsBuilder::new("books")
.query(Query::new_nearest(Document::new(
"time travel",
"sentence-transformers/all-minilm-l6-v2",
)))
.using("description-dense")
.filter(relaxed_filter)
.with_payload(true)
.build(),
QueryPointsBuilder::new("books")
.query(Query::new_nearest(Document::new(
"time travel",
"sentence-transformers/all-minilm-l6-v2",
)))
.using("description-dense")
.with_payload(true)
.build(),
];
client
.query_batch(QueryBatchPointsBuilder::new("books", searches))
.await?;
import static io.qdrant.client.ConditionFactory.*;
import static io.qdrant.client.QueryFactory.nearest;
import static io.qdrant.client.WithPayloadSelectorFactory.enable;
import io.qdrant.client.QdrantClient;
import io.qdrant.client.QdrantGrpcClient;
import io.qdrant.client.grpc.Common.Filter;
import io.qdrant.client.grpc.Points.*;
import java.util.*;
QdrantClient client =
QueryPoints searchStrict =
QueryPoints.newBuilder()
.setCollectionName("books")
.setQuery(
nearest(
Document.newBuilder()
.setText("time travel")
.setModel("sentence-transformers/all-minilm-l6-v2")
.build()))
.setUsing("description-dense")
.setFilter(Filter.newBuilder().addMust(matchText("title", "time travel")).build())
.setWithPayload(enable(true))
.build();
QueryPoints searchRelaxed =
QueryPoints.newBuilder()
.setCollectionName("books")
.setQuery(
nearest(
Document.newBuilder()
.setText("time travel")
.setModel("sentence-transformers/all-minilm-l6-v2")
.build()))
.setUsing("description-dense")
.setFilter(Filter.newBuilder().addMust(matchTextAny("title", "time travel")).build())
.setWithPayload(enable(true))
.build();
QueryPoints searchVectorOnly =
QueryPoints.newBuilder()
.setCollectionName("books")
.setQuery(
nearest(
Document.newBuilder()
.setText("time travel")
.setModel("sentence-transformers/all-minilm-l6-v2")
.build()))
.setUsing("description-dense")
.setWithPayload(enable(true))
.build();
client.queryBatchAsync("books", List.of(searchStrict, searchRelaxed, searchVectorOnly)).get();
using Qdrant.Client;
using Qdrant.Client.Grpc;
using static Qdrant.Client.Grpc.Conditions;
var searchStrict = new QueryPoints
{
CollectionName = "books",
Query = new Document
{
Text = "time travel",
Model = "sentence-transformers/all-minilm-l6-v2",
},
Using = "description-dense",
Filter = new Filter { Must = { MatchText("title", "time travel") } },
};
var searchRelaxed = new QueryPoints
{
CollectionName = "books",
Query = new Document
{
Text = "time travel",
Model = "sentence-transformers/all-minilm-l6-v2",
},
Using = "description-dense",
Filter = new Filter { Must = { MatchTextAny("title", "time travel") } },
};
var searchVectorOnly = new QueryPoints
{
CollectionName = "books",
Query = new Document
{
Text = "time travel",
Model = "sentence-transformers/all-minilm-l6-v2",
},
Using = "description-dense",
};
await client.QueryBatchAsync(
collectionName: "books",
queries: new List<QueryPoints> { searchStrict, searchRelaxed, searchVectorOnly }
);
strict := &qdrant.QueryPoints{
CollectionName: "books",
Query: qdrant.NewQueryNearest(
qdrant.NewVectorInputDocument(&qdrant.Document{Model: "sentence-transformers/all-minilm-l6-v2", Text: "time travel"}),
),
Using: qdrant.PtrOf("description-dense"),
Filter: &qdrant.Filter{Must: []*qdrant.Condition{qdrant.NewMatchText("title", "time travel")}},
}
relaxed := &qdrant.QueryPoints{
CollectionName: "books",
Query: qdrant.NewQueryNearest(
qdrant.NewVectorInputDocument(&qdrant.Document{Model: "sentence-transformers/all-minilm-l6-v2", Text: "time travel"}),
),
Using: qdrant.PtrOf("description-dense"),
Filter: &qdrant.Filter{Must: []*qdrant.Condition{qdrant.NewMatchTextAny("title", "time travel")}},
}
vectorOnly := &qdrant.QueryPoints{
CollectionName: "books",
Query: qdrant.NewQueryNearest(
qdrant.NewVectorInputDocument(&qdrant.Document{Model: "sentence-transformers/all-minilm-l6-v2", Text: "time travel"}),
),
Using: qdrant.PtrOf("description-dense"),
}
client.QueryBatch(context.Background(), &qdrant.QueryBatchPoints{
CollectionName: "books",
QueryPoints: []*qdrant.QueryPoints{strict, relaxed, vectorOnly},
})
响应包含三个单独的结果集。您可以将第一个非空结果集返回给用户，或者使用这三个集合组装单个排名列表。
全文搜索
全文搜索类似于全文过滤，主要区别在于全文查询用于排名。对于匹配搜索词的每个文档，Qdrant 会根据文档与搜索词的匹配程度计算相关性分数。该分数用于对结果进行排名。Qdrant 支持多种全文搜索评分算法。
Qdrant 中的全文搜索由稀疏向量 (sparse vectors) 提供支持。为什么选择稀疏向量？因为它们是一种灵活的搜索数据表示方式，从经典的基于 BM25 的搜索，到语义搜索和协同过滤。词汇表中的每个词条对应稀疏向量的一个或多个维度，这些维度中的值代表该词条在文档中的权重。可以使用文档统计信息为 BM25 排名算法计算权重，或者您可以使用能够捕捉语义含义的基于转换器的模型，如 SPLADE++ 和 miniCOIL。
BM25
BM25 (Best Matching 25) 是一种流行的排名算法，它采用概率方法进行分数计算。对于每个搜索词，BM25 会考虑关于该词条和文档的若干统计数据来计算相关性分数：
- 词频 (TF)：一个词条在文档中出现的频率越高，该文档的相关性就可能越高。
- 逆文档频率 (IDF)：一个词条在所有文档中出现得越少，该词条的权重就越高。
- 文档长度：出现在较短文档中的词条比出现在较长文档中的相同词条更具相关性。
Qdrant 通过生成稀疏向量的推理模型提供对 BM25 的原生支持，或者您可以使用 FastEmbed 库在客户端生成向量。
BM25 模型支持与文本索引相同的文本处理选项，包括分词、小写转换、ASCII 折叠、词干提取和停用词删除。与文本索引的一个显着区别是，BM25 默认使用英语词干提取和停用词删除。如果您使用的不是英语，请确保相应地配置模型。
要使用 BM25，请配置稀疏向量。
PUT /collections/books
{
"sparse_vectors": {
"title-bm25": {
"modifier": "idf"
}
}
}
from qdrant_client import QdrantClient, models
client = QdrantClient(
url="https://xyz-example.qdrant.io:6333",
api_key="<your-api-key>",
cloud_inference=True,
)
client.create_collection(
collection_name="books",
sparse_vectors_config={
"title-bm25": models.SparseVectorParams(modifier=models.Modifier.IDF)
},
)
client.createCollection("books", {
sparse_vectors: {
"title-bm25": { modifier: "idf" },
},
});
use qdrant_client::Qdrant;
use qdrant_client::qdrant::{
CreateCollectionBuilder, Modifier, SparseVectorParamsBuilder, SparseVectorsConfigBuilder,
};
let mut sparse = SparseVectorsConfigBuilder::default();
sparse.add_named_vector_params(
"title-bm25",
SparseVectorParamsBuilder::default().modifier(Modifier::Idf),
);
client
.create_collection(CreateCollectionBuilder::new("books").sparse_vectors_config(sparse))
.await?;
import io.qdrant.client.QdrantClient;
import io.qdrant.client.QdrantGrpcClient;
import io.qdrant.client.grpc.Collections.*;
QdrantClient client =
client
.createCollectionAsync(
CreateCollection.newBuilder()
.setCollectionName("books")
.setSparseVectorsConfig(
SparseVectorConfig.newBuilder()
.putMap(
"title-bm25",
SparseVectorParams.newBuilder().setModifier(Modifier.Idf).build())
.build())
.build())
.get();
using Qdrant.Client;
using Qdrant.Client.Grpc;
await client.CreateCollectionAsync(
collectionName: "books",
sparseVectorsConfig: ("title-bm25", new SparseVectorParams { Modifier = Modifier.Idf })
);
client.CreateCollection(context.Background(), &qdrant.CreateCollection{
CollectionName: "books",
SparseVectorsConfig: qdrant.NewSparseVectorsConfig(
map[string]*qdrant.SparseVectorParams{
"title-bm25": {Modifier: qdrant.Modifier_Idf.Enum()},
}),
})
请注意 IDF 修饰符，它为使用逆文档频率 (IDF) 的查询配置稀疏向量。
现在您可以摄取数据。以下示例摄取了一本书，其标题表示为由 BM25 模型生成的稀疏向量。
PUT /collections/books/points?wait=true
{
"points": [
{
"id": 1,
"vector": {
"title-bm25": {
"text": "The Time Machine",
"model": "qdrant/bm25"
}
},
"payload": {
"title": "The Time Machine",
"author": "H.G. Wells",
"isbn": "9780553213515"
}
}
]
}
from qdrant_client import QdrantClient, models
client = QdrantClient(
url="https://xyz-example.qdrant.io:6333",
api_key="<your-api-key>",
cloud_inference=True,
)
client.upsert(
collection_name="books",
points=[
models.PointStruct(
id=1,
vector={
"title-bm25": models.Document(
text="The Time Machine",
model="qdrant/bm25",
)
},
payload={
"title": "The Time Machine",
"author": "H.G. Wells",
"isbn": "9780553213515",
},
)
],
)
client.upsert("books", {
wait: true,
points: [
{
id: 1,
vector: {
"title-bm25": {
text: "The Time Machine",
model: "qdrant/bm25",
},
},
payload: {
title: "The Time Machine",
author: "H.G. Wells",
isbn: "9780553213515",
},
},
],
});
use std::collections::HashMap;
use qdrant_client::qdrant::{Document, PointStruct, UpsertPointsBuilder};
use qdrant_client::{Payload, Qdrant};
use serde_json::json;
let point = PointStruct::new(
1,
HashMap::from([(
"title-bm25".to_string(),
Document::new("The Time Machine", "qdrant/bm25"),
)]),
Payload::try_from(json!({
"title": "The Time Machine",
"author": "H.G. Wells",
"isbn": "9780553213515",
}))
.unwrap(),
);
client
.upsert_points(UpsertPointsBuilder::new("books", vec![point]).wait(true))
.await?;
import static io.qdrant.client.PointIdFactory.id;
import static io.qdrant.client.ValueFactory.value;
import static io.qdrant.client.VectorFactory.vector;
import static io.qdrant.client.VectorsFactory.namedVectors;
import io.qdrant.client.QdrantClient;
import io.qdrant.client.QdrantGrpcClient;
import io.qdrant.client.grpc.Points.*;
import java.util.*;
QdrantClient client =
PointStruct point =
PointStruct.newBuilder()
.setId(id(1))
.setVectors(
namedVectors(
Map.of(
"title-bm25",
vector(
Document.newBuilder()
.setText("The Time Machine")
.setModel("qdrant/bm25")
.build()))))
.putAllPayload(
Map.of(
"title", value("The Time Machine"),
"author", value("H.G. Wells"),
"isbn", value("9780553213515")))
.build();
client.upsertAsync("books", List.of(point)).get();
using Qdrant.Client;
using Qdrant.Client.Grpc;
await client.UpsertAsync(
collectionName: "books",
wait: true,
points: new List<PointStruct>
{
new()
{
Id = 1,
Vectors = new Dictionary<string, Vector>
{
["title-bm25"] = new Document
{
Text = "The Time Machine",
Model = "qdrant/bm25",
},
},
Payload =
{
["title"] = "The Time Machine",
["author"] = "H.G. Wells",
["isbn"] = "9780553213515",
},
},
}
);
client.Upsert(context.Background(), &qdrant.UpsertPoints{
CollectionName: "books",
Points: []*qdrant.PointStruct{
{
Id: qdrant.NewIDNum(uint64(1)),
Vectors: qdrant.NewVectorsMap(map[string]*qdrant.Vector{
"title-bm25": qdrant.NewVectorDocument(&qdrant.Document{
Model: "qdrant/bm25",
Text: "The Time Machine",
}),
}),
Payload: qdrant.NewValueMap(map[string]any{
"title": "The Time Machine",
"author": "H.G. Wells",
"isbn": "9780553213515",
}),
},
},
})
摄取数据后，您可以查询稀疏向量。以下示例使用 BM25 模型搜索标题中包含“time travel”的书籍。
POST /collections/books/points/query
{
"query": {
"text": "time travel",
"model": "qdrant/bm25"
},
"using": "title-bm25",
"limit": 10,
"with_payload": true
}
from qdrant_client import QdrantClient, models
client = QdrantClient(
url="https://xyz-example.qdrant.io:6333",
api_key="<your-api-key>",
cloud_inference=True,
)
client.query_points(
collection_name="books",
query=models.Document(text="time travel", model="qdrant/bm25"),
using="title-bm25",
limit=10,
with_payload=True,
)
client.query("books", {
query: {
text: "time travel",
model: "qdrant/bm25",
},
using: "title-bm25",
limit: 10,
with_payload: true,
});
use qdrant_client::Qdrant;
use qdrant_client::qdrant::{Document, Query, QueryPointsBuilder};
client
.query(
QueryPointsBuilder::new("books")
.query(Query::new_nearest(Document::new("time travel", "qdrant/bm25")))
.using("title-bm25")
.limit(10)
.with_payload(true)
.build(),
)
.await?;
import static io.qdrant.client.QueryFactory.nearest;
import static io.qdrant.client.WithPayloadSelectorFactory.enable;
import io.qdrant.client.QdrantClient;
import io.qdrant.client.QdrantGrpcClient;
import io.qdrant.client.grpc.Points.*;
QdrantClient client =
client
.queryAsync(
QueryPoints.newBuilder()
.setCollectionName("books")
.setQuery(
nearest(
Document.newBuilder()
.setText("time travel")
.setModel("qdrant/bm25")
.build()))
.setUsing("title-bm25")
.setLimit(10)
.setWithPayload(enable(true))
.build())
.get();
using Qdrant.Client;
using Qdrant.Client.Grpc;
await client.QueryAsync(
collectionName: "books",
query: new Document { Text = "time travel", Model = "qdrant/bm25" },
usingVector: "title-bm25",
payloadSelector: true,
limit: 10
);
client.Query(context.Background(), &qdrant.QueryPoints{
CollectionName: "books",
Query: qdrant.NewQueryNearest(
qdrant.NewVectorInputDocument(&qdrant.Document{
Model: "qdrant/bm25",
Text: "time travel",
}),
),
Using: qdrant.PtrOf("title-bm25"),
WithPayload: qdrant.NewWithPayload(true),
Limit: qdrant.PtrOf(uint64(10)),
})
配置 BM25 参数
BM25 排名函数包含三个可调参数，您可以在摄取时设置这些参数，以针对您的特定用例优化搜索结果：
k。控制词频饱和度。值越高，词频的影响越大。默认为 1.2。b。控制文档长度归一化。范围从 0（无归一化）到 1（完全归一化）。值越高意味着较长文档的影响越小。默认为 0.75。avg_len。查询字段中的平均单词数。默认为 256。
例如，书名通常短于 256 个单词。为了在搜索书名时获得更准确的评分，您可以计算或估计平均标题长度，并相应地设置 avg_len 参数。
PUT /collections/books/points?wait=true
{
"points": [
{
"id": 1,
"vector": {
"title-bm25": {
"text": "The Time Machine",
"model": "qdrant/bm25",
"options": {
"avg_len": 5.0
}
}
},
"payload": {
"title": "The Time Machine",
"author": "H.G. Wells",
"isbn": "9780553213515"
}
}
]
}
from qdrant_client import QdrantClient, models
client = QdrantClient(
url="https://xyz-example.qdrant.io:6333",
api_key="<your-api-key>",
cloud_inference=True,
)
client.upsert(
collection_name="books",
points=[
models.PointStruct(
id=1,
vector={
"title-bm25": models.Document(
text="The Time Machine",
model="qdrant/bm25",
options={"avg_len": 5.0}
)
},
payload={
"title": "The Time Machine",
"author": "H.G. Wells",
"isbn": "9780553213515",
},
)
],
)
client.upsert("books", {
wait: true,
points: [
{
id: 1,
vector: {
"title-bm25": {
text: "The Time Machine",
model: "qdrant/bm25",
options: { avg_len: 5.0 },
},
},
payload: {
title: "The Time Machine",
author: "H.G. Wells",
isbn: "9780553213515",
},
},
],
});
use std::collections::HashMap;
use qdrant_client::qdrant::{DocumentBuilder, PointStruct, UpsertPointsBuilder, Value};
use qdrant_client::{Payload, Qdrant};
use serde_json::json;
let mut options = HashMap::new();
options.insert("avg_len".to_string(), Value::from(5.0));
let point = PointStruct::new(
1,
HashMap::from([(
"title-bm25".to_string(),
DocumentBuilder::new("The Time Machine", "qdrant/bm25")
.options(options)
.build(),
)]),
Payload::try_from(json!({
"title": "The Time Machine",
"author": "H.G. Wells",
"isbn": "9780553213515",
}))
.unwrap(),
);
client
.upsert_points(UpsertPointsBuilder::new("books", vec![point]).wait(true))
.await?;
import static io.qdrant.client.PointIdFactory.id;
import static io.qdrant.client.ValueFactory.value;
import static io.qdrant.client.VectorFactory.vector;
import static io.qdrant.client.VectorsFactory.namedVectors;
import io.qdrant.client.QdrantClient;
import io.qdrant.client.QdrantGrpcClient;
import io.qdrant.client.grpc.Points.*;
import java.util.*;
QdrantClient client =
PointStruct point =
PointStruct.newBuilder()
.setId(id(1))
.setVectors(
namedVectors(
Map.of(
"title-bm25",
vector(
Document.newBuilder()
.setText("The Time Machine")
.setModel("qdrant/bm25")
.putOptions("avg_len", value(5.0))
.build()))))
.putAllPayload(
Map.of(
"title", value("The Time Machine"),
"author", value("H.G. Wells"),
"isbn", value("9780553213515")))
.build();
client.upsertAsync("books", List.of(point)).get();
using Qdrant.Client;
using Qdrant.Client.Grpc;
await client.UpsertAsync(
collectionName: "books",
wait: true,
points: new List<PointStruct>
{
new()
{
Id = 1,
Vectors = new Dictionary<string, Vector>
{
["title-bm25"] = new Document
{
Text = "The Time Machine",
Model = "qdrant/bm25",
Options = { ["avg_len"] = 5.0 },
},
},
Payload =
{
["title"] = "The Time Machine",
["author"] = "H.G. Wells",
["isbn"] = "9780553213515",
},
},
}
);
client.Upsert(context.Background(), &qdrant.UpsertPoints{
CollectionName: "books",
Points: []*qdrant.PointStruct{
{
Id: qdrant.NewIDNum(uint64(1)),
Vectors: qdrant.NewVectorsMap(map[string]*qdrant.Vector{
"title-bm25": qdrant.NewVectorDocument(&qdrant.Document{
Model: "qdrant/bm25",
Text: "The Time Machine",
Options: qdrant.NewValueMap(map[string]any{"avg_len": 5.0}),
}),
}),
Payload: qdrant.NewValueMap(map[string]any{
"title": "The Time Machine",
"author": "H.G. Wells",
"isbn": "9780553213515",
}),
},
},
})
在设计多表示集合（结合书名和标签等短字段与较长的正文文本）时，实际的默认做法是对较短的结构化字段使用 BM25，而对较长的字段使用稠密向量。BM25F 是针对不同长度的多字段文本的原则性扩展；Qdrant 目前不支持原生 BM25F，但多表示搜索教程展示了替代方案：每个字段使用单独的稀疏向量，通过查询 API 进行融合。
特定于语言的设置
默认情况下，BM25 使用特定于英语的设置进行分词、词干提取和停用词删除。单词被简化为英语词根形式，常见的英语停用词被删除。如果您的数据不是英语，这将导致搜索结果不佳。为了获得其他语言的最佳结果，请配置特定于语言的 BM25 设置。
词干提取和停用词
要配置词干提取和停用词删除，请使用以下选项：
language：设置词干提取和停用词删除的语言。默认为english。要禁用词干提取和停用词删除，请将language设置为none。stemmer：默认为language（如果已设置）的词干提取，但可以独立配置。stopwords：默认为language（如果已设置）的一组停用词，但可以独立配置。您可以配置特定的language和/或配置一组显式的停用词，这些停用词将与已配置语言的停用词集合并。
例如，要在数据摄取期间使用西班牙语词干提取和停用词：
PUT /collections/books/points?wait=true
{
"points": [
{
"id": 1,
"vector": {
"title-bm25": {
"text": "La Máquina del Tiempo",
"model": "qdrant/bm25",
"options": {
"language": "spanish"
}
}
},
"payload": {
"title": "La Máquina del Tiempo",
"author": "H.G. Wells",
"isbn": "9788411486880"
}
}
]
}
from qdrant_client import QdrantClient, models
client = QdrantClient(
url="https://xyz-example.qdrant.io:6333",
api_key="<your-api-key>",
cloud_inference=True,
)
client.upsert(
collection_name="books",
points=[
models.PointStruct(
id=1,
vector={
"title-bm25": models.Document(
text="La Máquina del Tiempo",
model="qdrant/bm25",
options={"language": "spanish"},
)
},
payload={
"title": "La Máquina del Tiempo",
"author": "H.G. Wells",
"isbn": "9788411486880",
},
)
],
)
client.upsert("books", {
wait: true,
points: [
{
id: 1,
vector: {
"title-bm25": {
text: "La Máquina del Tiempo",
model: "qdrant/bm25",
options: { language: "spanish" },
},
},
payload: {
title: "La Máquina del Tiempo",
author: "H.G. Wells",
isbn: "9788411486880",
},
},
],
});
use std::collections::HashMap;
use qdrant_client::qdrant::{DocumentBuilder, PointStruct, UpsertPointsBuilder, Value};
use qdrant_client::{Payload, Qdrant};
use serde_json::json;
let mut options = HashMap::new();
options.insert("language".to_string(), Value::from("spanish"));
let point = PointStruct::new(
1,
HashMap::from([(
"title-bm25".to_string(),
DocumentBuilder::new("La Máquina del Tiempo", "qdrant/bm25")
.options(options)
.build(),
)]),
Payload::try_from(json!({
"title": "La Máquina del Tiempo",
"author": "H.G. Wells",
"isbn": "9788411486880",
}))
.unwrap(),
);
client
.upsert_points(UpsertPointsBuilder::new("books", vec![point]).wait(true))
.await?;
import static io.qdrant.client.PointIdFactory.id;
import static io.qdrant.client.ValueFactory.value;
import static io.qdrant.client.VectorFactory.vector;
import static io.qdrant.client.VectorsFactory.namedVectors;
import io.qdrant.client.QdrantClient;
import io.qdrant.client.QdrantGrpcClient;
import io.qdrant.client.grpc.Points.*;
import java.util.*;
QdrantClient client =
PointStruct point =
PointStruct.newBuilder()
.setId(id(1))
.setVectors(
namedVectors(
Map.of(
"title-bm25",
vector(
Document.newBuilder()
.setText("La Máquina del Tiempo")
.setModel("qdrant/bm25")
.build()))))
.putAllPayload(
Map.of(
"title", value("La Máquina del Tiempo"),
"author", value("H.G. Wells"),
"isbn", value("9788411486880")))
.build();
client.upsertAsync("books", List.of(point)).get();
using Qdrant.Client;
using Qdrant.Client.Grpc;
await client.UpsertAsync(
collectionName: "books",
wait: true,
points: new List<PointStruct>
{
new()
{
Id = 1,
Vectors = new Dictionary<string, Vector>
{
["title-bm25"] = new Document
{
Text = "La Máquina del Tiempo",
Model = "qdrant/bm25",
},
},
Payload =
{
["title"] = "La Máquina del Tiempo",
["author"] = "H.G. Wells",
["isbn"] = "9788411486880",
},
},
}
);
client.Upsert(context.Background(), &qdrant.UpsertPoints{
CollectionName: "books",
Points: []*qdrant.PointStruct{
{
Id: qdrant.NewIDNum(uint64(1)),
Vectors: qdrant.NewVectorsMap(map[string]*qdrant.Vector{
"title-bm25": qdrant.NewVectorDocument(&qdrant.Document{
Model: "qdrant/bm25",
Text: "La Máquina del Tiempo",
}),
}),
Payload: qdrant.NewValueMap(map[string]any{
"title": "La Máquina del Tiempo",
"author": "H.G. Wells",
"isbn": "9788411486880",
}),
},
},
})
在查询时，使用完全相同的参数以确保文本处理的一致性。
POST /collections/books/points/query
{
"query": {
"text": "tiempo",
"model": "qdrant/bm25",
"options": {
"language": "spanish"
}
},
"using": "title-bm25",
"limit": 10,
"with_payload": true
}
from qdrant_client import QdrantClient, models
client = QdrantClient(
url="https://xyz-example.qdrant.io:6333",
api_key="<your-api-key>",
cloud_inference=True,
)
client.query_points(
collection_name="books",
query=models.Document(text="tiempo", model="qdrant/bm25", options={"language": "spanish"}),
using="title-bm25",
limit=10,
with_payload=True,
)
client.query("books", {
query: {
text: "tiempo",
model: "qdrant/bm25",
options: { language: "spanish" },
},
using: "title-bm25",
limit: 10,
with_payload: true,
});
use std::collections::HashMap;
use qdrant_client::Qdrant;
use qdrant_client::qdrant::{DocumentBuilder, Query, QueryPointsBuilder, Value};
let mut options = HashMap::new();
options.insert("language".to_string(), Value::from("spanish"));
client
.query(
QueryPointsBuilder::new("books")
.query(Query::new_nearest(
DocumentBuilder::new("tiempo", "qdrant/bm25")
.options(options)
.build(),
))
.using("title-bm25")
.limit(10)
.with_payload(true)
.build(),
)
.await?;
import static io.qdrant.client.QueryFactory.nearest;
import static io.qdrant.client.WithPayloadSelectorFactory.enable;
import io.qdrant.client.QdrantClient;
import io.qdrant.client.QdrantGrpcClient;
import io.qdrant.client.grpc.Points.*;
QdrantClient client =
client
.queryAsync(
QueryPoints.newBuilder()
.setCollectionName("books")
.setQuery(
nearest(
Document.newBuilder().setText("tiempo").setModel("qdrant/bm25").build()))
.setUsing("title-bm25")
.setLimit(10)
.setWithPayload(enable(true))
.build())
.get();
using Qdrant.Client;
using Qdrant.Client.Grpc;
await client.QueryAsync(
collectionName: "books",
query: new Document
{
Text = "tiempo",
Model = "qdrant/bm25",
Options = { ["language"] = "spanish" },
},
usingVector: "title-bm25",
payloadSelector: true,
limit: 10
);
client.Query(context.Background(), &qdrant.QueryPoints{
CollectionName: "books",
Query: qdrant.NewQueryNearest(
qdrant.NewVectorInputDocument(&qdrant.Document{
Model: "qdrant/bm25",
Text: "tiempo",
Options: qdrant.NewValueMap(map[string]any{"language": "spanish"}),
}),
),
Using: qdrant.PtrOf("title-bm25"),
WithPayload: qdrant.NewWithPayload(true),
Limit: qdrant.PtrOf(uint64(10)),
})
要仅配置词干提取器或停用词集，而不是两者都配置，请将 language 设置为 none，并指定所需词干提取器或停用词的配置。
ASCII 折叠
ASCII 折叠是从字符中删除变音符号（重音）的过程。通过删除变音符号，ASCII 折叠使您能够在搜索时忽略重音。例如，在启用 ASCII 折叠的情况下，搜索“cafe”可以同时匹配“cafe”和“café”。
要启用 ASCII 折叠，请在摄取和查询时将 ascii_folding 选项设置为 true。
POST /collections/books/points/query
{
"query": {
"text": "Mieville",
"model": "qdrant/bm25",
"options": {
"ascii_folding": true
}
},
"using": "author-bm25",
"limit": 10,
"with_payload": true
}
from qdrant_client import QdrantClient, models
client = QdrantClient(
url="https://xyz-example.qdrant.io:6333",
api_key="<your-api-key>",
cloud_inference=True,
)
# Note: the ascii_folding option is not supported by FastEmbed
client.query_points(
collection_name="books",
query=models.Document(text="Mieville", model="qdrant/bm25", options={"ascii_folding": True}),
using="author-bm25",
limit=10,
with_payload=True,
)
client.query("books", {
query: {
text: "Mieville",
model: "qdrant/bm25",
options: { ascii_folding: true },
},
using: "author-bm25",
limit: 10,
with_payload: true,
});
use std::collections::HashMap;
use qdrant_client::Qdrant;
use qdrant_client::qdrant::{DocumentBuilder, Query, QueryPointsBuilder, Value};
let mut options = HashMap::new();
options.insert("ascii_folding".to_string(), Value::from(true));
client
.query(
QueryPointsBuilder::new("books")
.query(Query::new_nearest(
DocumentBuilder::new("Mieville", "qdrant/bm25")
.options(options)
.build(),
))
.using("author-bm25")
.limit(10)
.with_payload(true)
.build(),
)
.await?;
import static io.qdrant.client.QueryFactory.nearest;
import static io.qdrant.client.WithPayloadSelectorFactory.enable;
import io.qdrant.client.QdrantClient;
import io.qdrant.client.QdrantGrpcClient;
import io.qdrant.client.grpc.Points.*;
QdrantClient client =
client
.queryAsync(
QueryPoints.newBuilder()
.setCollectionName("books")
.setQuery(
nearest(
Document.newBuilder().setText("Mieville").setModel("qdrant/bm25").build()))
.setUsing("author-bm25")
.setLimit(10)
.setWithPayload(enable(true))
.build())
.get();
using Qdrant.Client;
using Qdrant.Client.Grpc;
await client.QueryAsync(
collectionName: "books",
query: new Document
{
Text = "Mieville",
Model = "qdrant/bm25",
Options = { ["ascii_folding"] = true },
},
usingVector: "author-bm25",
payloadSelector: true,
limit: 10
);
client.Query(context.Background(), &qdrant.QueryPoints{
CollectionName: "books",
Query: qdrant.NewQueryNearest(
qdrant.NewVectorInputDocument(&qdrant.Document{
Model: "qdrant/bm25",
Text: "Mieville",
Options: qdrant.NewValueMap(map[string]any{"ascii_folding": true}),
}),
),
Using: qdrant.PtrOf("author-bm25"),
WithPayload: qdrant.NewWithPayload(true),
Limit: qdrant.PtrOf(uint64(10)),
})
分词器
分词器将文本分解为单个令牌（单词）。默认情况下，BM25 模型使用 word 分词器，它根据空格和标点符号等单词边界拆分文本。此方法对于基于拉丁语的语言非常有效，但对于非拉丁字母的语言或不使用空格分隔单词的语言可能效果不佳。对于这些语言，请使用 multilingual 分词器。该分词器支持多种语言，包括具有非拉丁字母和非空格分隔符的语言。
POST /collections/books/points/query
{
"query": {
"text": "村上春樹",
"model": "qdrant/bm25",
"options": {
"tokenizer": "multilingual"
}
},
"using": "author-bm25",
"limit": 10,
"with_payload": true
}
from qdrant_client import QdrantClient, models
client = QdrantClient(
url="https://xyz-example.qdrant.io:6333",
api_key="<your-api-key>",
cloud_inference=True,
)
# Note: the tokenizer option is not supported by FastEmbed
client.query_points(
collection_name="books",
query=models.Document(text="村上春樹", model="qdrant/bm25", options={"tokenizer": "multilingual"}),
using="author-bm25",
limit=10,
with_payload=True,
)
client.query("books", {
query: {
text: "村上春樹",
model: "qdrant/bm25",
options: { tokenizer: "multilingual" },
},
using: "author-bm25",
limit: 10,
with_payload: true,
});
use std::collections::HashMap;
use qdrant_client::Qdrant;
use qdrant_client::qdrant::{DocumentBuilder, Query, QueryPointsBuilder, Value};
let mut options = HashMap::new();
options.insert("tokenizer".to_string(), Value::from("multilingual"));
client
.query(
QueryPointsBuilder::new("books")
.query(Query::new_nearest(
DocumentBuilder::new("村上春樹", "qdrant/bm25")
.options(options)
.build(),
))
.using("author-bm25")
.limit(10)
.with_payload(true)
.build(),
)
.await?;
import static io.qdrant.client.QueryFactory.nearest;
import static io.qdrant.client.WithPayloadSelectorFactory.enable;
import io.qdrant.client.QdrantClient;
import io.qdrant.client.QdrantGrpcClient;
import io.qdrant.client.grpc.Points.*;
QdrantClient client =
client
.queryAsync(
QueryPoints.newBuilder()
.setCollectionName("books")
.setQuery(
nearest(Document.newBuilder().setText("村上春樹").setModel("qdrant/bm25").build()))
.setUsing("author-bm25")
.setLimit(10)
.setWithPayload(enable(true))
.build())
.get();
using Qdrant.Client;
using Qdrant.Client.Grpc;
await client.QueryAsync(
collectionName: "books",
query: new Document
{
Text = "村上春樹",
Model = "qdrant/bm25",
Options = { ["tokenizer"] = "multilingual" },
},
usingVector: "author-bm25",
payloadSelector: true,
limit: 10
);
client.Query(context.Background(), &qdrant.QueryPoints{
CollectionName: "books",
Query: qdrant.NewQueryNearest(
qdrant.NewVectorInputDocument(&qdrant.Document{
Model: "qdrant/bm25",
Text: "村上春樹",
Options: qdrant.NewValueMap(map[string]any{"tokenizer": "multilingual"}),
}),
),
Using: qdrant.PtrOf("author-bm25"),
WithPayload: qdrant.NewWithPayload(true),
Limit: qdrant.PtrOf(uint64(10)),
})
语言中立的文本处理
在某些情况下，您可能希望完全禁用特定于语言的处理。例如，在搜索不一定符合特定语言规则的作者姓名时。
要禁用特定于语言的处理，请设置以下选项：
language：设置为none以禁用特定于语言的词干提取和停用词删除。tokenizer：设置为multilingual以进行多语言分词和词形还原。- 可选地，将
ascii_folding设置为true以启用 ASCII 折叠并忽略变音符号。
POST /collections/books/points/query
{
"query": {
"text": "Mieville",
"model": "qdrant/bm25",
"options": {
"language": "none",
"tokenizer": "multilingual",
"ascii_folding": true
}
},
"using": "author-bm25",
"limit": 10,
"with_payload": true
}
from qdrant_client import QdrantClient, models
client = QdrantClient(
url="https://xyz-example.qdrant.io:6333",
api_key="<your-api-key>",
cloud_inference=True,
)
# Note: these BM25 options are not supported by FastEmbed
client.query_points(
collection_name="books",
query=models.Document(
text="Mieville",
model="qdrant/bm25",
options={"language": "none", "tokenizer": "multilingual", "ascii_folding": True},
),
using="author-bm25",
limit=10,
with_payload=True,
)
client.query("books", {
query: {
text: "Mieville",
model: "qdrant/bm25",
options: { language: "none", tokenizer: "multilingual", ascii_folding: true },
},
using: "author-bm25",
limit: 10,
with_payload: true,
});
use std::collections::HashMap;
use qdrant_client::Qdrant;
use qdrant_client::qdrant::{DocumentBuilder, Query, QueryPointsBuilder, Value};
let mut options = HashMap::new();
options.insert("language".to_string(), Value::from("none"));
options.insert("tokenizer".to_string(), Value::from("multilingual"));
options.insert("ascii_folding".to_string(), Value::from(true));
client
.query(
QueryPointsBuilder::new("books")
.query(Query::new_nearest(
DocumentBuilder::new("Mieville", "qdrant/bm25")
.options(options)
.build(),
))
.using("author-bm25")
.limit(10)
.with_payload(true)
.build(),
)
.await?;
import static io.qdrant.client.QueryFactory.nearest;
import static io.qdrant.client.WithPayloadSelectorFactory.enable;
import io.qdrant.client.QdrantClient;
import io.qdrant.client.QdrantGrpcClient;
import io.qdrant.client.grpc.Points.*;
QdrantClient client =
client
.queryAsync(
QueryPoints.newBuilder()
.setCollectionName("books")
.setQuery(
nearest(
Document.newBuilder().setText("Mieville").setModel("qdrant/bm25").build()))
.setUsing("author-bm25")
.setLimit(10)
.setWithPayload(enable(true))
.build())
.get();
using Qdrant.Client;
using Qdrant.Client.Grpc;
await client.QueryAsync(
collectionName: "books",
query: new Document
{
Text = "Mieville",
Model = "qdrant/bm25",
Options =
{
["language"] = "none",
["tokenizer"] = "multilingual",
["ascii_folding"] = true,
},
},
usingVector: "author-bm25",
payloadSelector: true,
limit: 10
);
client.Query(context.Background(), &qdrant.QueryPoints{
CollectionName: "books",
Query: qdrant.NewQueryNearest(
qdrant.NewVectorInputDocument(&qdrant.Document{
Model: "qdrant/bm25",
Text: "Mieville",
Options: qdrant.NewValueMap(map[string]any{"language": "none", "tokenizer": "multilingual", "ascii_folding": true}),
}),
),
Using: qdrant.PtrOf("author-bm25"),
WithPayload: qdrant.NewWithPayload(true),
Limit: qdrant.PtrOf(uint64(10)),
})
SPLADE++
SPLADE（稀疏词法和稠密）系列模型是基于转换器的模型，可从文本生成稀疏向量。这些模型通过考虑同音异义词和同义词，结合了传统词法搜索的优势和基于转换器模型的功能。SPLADE 模型通过使用来自转换器模型的上下文嵌入扩展输入文本的词汇来实现这一点。例如，在处理输入文本“time travel”时，SPLADE 模型可以将输入扩展为包含相关词条，如“temporal”、“journey”和“chronology”。这种扩展允许 SPLADE 模型在利用词法搜索优势的同时，捕捉文本的语义含义。
使用 SPLADE 模型的优势在于它们的性能优于传统的 BM25。然而，它们也有一些缺点。首先，由于它们使用固定的词汇表，您无法使用 SPLADE 模型查找词汇表中不存在的词条，例如产品 ID 和领域外语言（训练中未见过的词）。其次，由于它们是基于转换器的模型，SPLADE 模型比传统的 BM25 模型更慢，并且需要更多的计算资源。
在 Qdrant Cloud 上，您可以将 SPLADE++ 模型与推理一起使用。或者，您也可以使用 FastEmbed 库在客户端生成向量。
POST /collections/books/points/query
{
"query": {
"text": "time travel",
"model": "prithivida/splade_pp_en_v1"
},
"using": "title-splade",
"limit": 10,
"with_payload": true
}
from qdrant_client import QdrantClient, models
client = QdrantClient(
url="https://xyz-example.qdrant.io:6333",
api_key="<your-api-key>",
cloud_inference=True,
)
client.query_points(
collection_name="books",
query=models.Document(text="time travel", model="prithivida/splade_pp_en_v1"),
using="title-splade",
limit=10,
with_payload=True,
)
client.query("books", {
query: {
text: "time travel",
model: "prithivida/splade_pp_en_v1",
},
using: "title-splade",
limit: 10,
with_payload: true,
});
use qdrant_client::Qdrant;
use qdrant_client::qdrant::{Document, Query, QueryPointsBuilder};
client
.query(
QueryPointsBuilder::new("books")
.query(Query::new_nearest(Document::new(
"time travel",
"prithivida/splade_pp_en_v1",
)))
.using("title-splade")
.limit(10)
.with_payload(true)
.build(),
)
.await?;
import static io.qdrant.client.QueryFactory.nearest;
import static io.qdrant.client.WithPayloadSelectorFactory.enable;
import io.qdrant.client.QdrantClient;
import io.qdrant.client.QdrantGrpcClient;
import io.qdrant.client.grpc.Points.*;
QdrantClient client =
client
.queryAsync(
QueryPoints.newBuilder()
.setCollectionName("books")
.setQuery(
nearest(
Document.newBuilder()
.setText("time travel")
.setModel("prithivida/splade_pp_en_v1")
.build()))
.setUsing("title-splade")
.setLimit(10)
.setWithPayload(enable(true))
.build())
.get();
using Qdrant.Client;
using Qdrant.Client.Grpc;
await client.QueryAsync(
collectionName: "books",
query: new Document { Text = "time travel", Model = "prithivida/splade_pp_en_v1" },
usingVector: "title-splade",
payloadSelector: true,
limit: 10
);
client.Query(context.Background(), &qdrant.QueryPoints{
CollectionName: "books",
Query: qdrant.NewQueryNearest(
qdrant.NewVectorInputDocument(&qdrant.Document{
Model: "prithivida/splade_pp_en_v1",
Text: "time travel",
}),
),
Using: qdrant.PtrOf("title-splade"),
WithPayload: qdrant.NewWithPayload(true),
Limit: qdrant.PtrOf(uint64(10)),
})
有关将 SPLADE++ 与 FastEmbed 结合使用的教程，请参阅如何使用 SPLADE 生成稀疏向量。
miniCOIL
miniCOIL 在 BM25 的灵活性和 SPLADE++ 的性能之间取得了平衡。miniCOIL 是一个基于转换器的模型，可以为文本生成稀疏向量。与 SPLADE++ 不同，它不使用词汇扩展机制。为了捕获词条的上下文和含义，模型为每个词条生成一个四维向量。miniCOIL 不使用固定的词汇表，使其成为一种基于关键字上下文含义对结果进行排名的有效词法搜索模型。
miniCOIL 可以与 FastEmbed 库结合使用。
通过混合搜索结合语义和词法搜索
混合搜索使您能够将语义和词法搜索结合在单个查询中，返回匹配语义含义、精确关键字或两者的结果。当您不知道用户是在寻找特定关键字还是语义相似的文档时，这非常有用。例如，在搜索书籍时，用户可能会输入“time travel”来查找与时间旅行概念相关的书籍，但他们也可能输入书籍的 ISBN 来查找特定书籍。混合查询使您能够在单个查询中为这两种情况返回结果。
混合查询利用了 Qdrant 在单个点中存储多个命名向量的能力。例如，您可以在同一点存储用于语义搜索的稠密向量和用于词法搜索的稀疏向量。为此，首先创建一个既有稠密向量又有稀疏向量的集合：
PUT /collections/books
{
"vectors": {
"description-dense": {
"size": 384,
"distance": "Cosine"
}
},
"sparse_vectors": {
"isbn-bm25": {
"modifier": "idf"
}
}
}
from qdrant_client import QdrantClient, models
client = QdrantClient(
url="https://xyz-example.qdrant.io:6333",
api_key="<your-api-key>",
cloud_inference=True,
)
client.create_collection(
collection_name="books",
vectors_config={
"description-dense": models.VectorParams(size=384, distance=models.Distance.COSINE)
},
sparse_vectors_config={
"isbn-bm25": models.SparseVectorParams(modifier=models.Modifier.IDF)
},
)
client.createCollection("books", {
vectors: {
"description-dense": { size: 384, distance: "Cosine" },
},
sparse_vectors: {
"isbn-bm25": { modifier: "idf" },
},
});
use qdrant_client::Qdrant;
use qdrant_client::qdrant::{
CreateCollectionBuilder, Distance, Modifier, SparseVectorParamsBuilder,
SparseVectorsConfigBuilder, VectorParamsBuilder, VectorsConfigBuilder,
};
let mut vectors = VectorsConfigBuilder::default();
vectors.add_named_vector_params(
"description-dense",
VectorParamsBuilder::new(384, Distance::Cosine),
);
let mut sparse = SparseVectorsConfigBuilder::default();
sparse.add_named_vector_params(
"isbn-bm25",
SparseVectorParamsBuilder::default().modifier(Modifier::Idf),
);
client
.create_collection(
CreateCollectionBuilder::new("books")
.vectors_config(vectors)
.sparse_vectors_config(sparse),
)
.await?;
import io.qdrant.client.QdrantClient;
import io.qdrant.client.QdrantGrpcClient;
import io.qdrant.client.grpc.Collections.*;
QdrantClient client =
client
.createCollectionAsync(
CreateCollection.newBuilder()
.setCollectionName("books")
.setVectorsConfig(
VectorsConfig.newBuilder()
.setParamsMap(
VectorParamsMap.newBuilder()
.putMap(
"description-dense",
VectorParams.newBuilder()
.setSize(384)
.setDistance(Distance.Cosine)
.build())
.build())
.build())
.setSparseVectorsConfig(
SparseVectorConfig.newBuilder()
.putMap(
"isbn-bm25",
SparseVectorParams.newBuilder().setModifier(Modifier.Idf).build())
.build())
.build())
.get();
using Qdrant.Client;
using Qdrant.Client.Grpc;
await client.CreateCollectionAsync(
collectionName: "books",
vectorsConfig: new VectorParamsMap
{
Map =
{
["description-dense"] = new VectorParams
{
Size = 384,
Distance = Distance.Cosine,
},
},
},
sparseVectorsConfig: new SparseVectorConfig
{
Map = { ["isbn-bm25"] = new SparseVectorParams { Modifier = Modifier.Idf } },
}
);
client.CreateCollection(context.Background(), &qdrant.CreateCollection{
CollectionName: "books",
VectorsConfig: qdrant.NewVectorsConfigMap(
map[string]*qdrant.VectorParams{
"description-dense": {Size: 384, Distance: qdrant.Distance_Cosine},
}),
SparseVectorsConfig: qdrant.NewSparseVectorsConfig(
map[string]*qdrant.SparseVectorParams{
"isbn-bm25": {Modifier: qdrant.Modifier_Idf.Enum()},
}),
})
在摄取同时包含这两个向量的数据后，您可以使用预取 (prefetch) 功能在单个请求中运行语义和词法查询。然后，使用互惠排名融合 (RRF) 等融合方法将这两个查询的结果进行合并。
POST /collections/books/points/query
{
"prefetch": [
{
"query": {
"text": "9780553213515",
"model": "sentence-transformers/all-minilm-l6-v2"
},
"using": "description-dense",
"score_threshold": 0.5
},
{
"query": {
"text": "9780553213515",
"model": "Qdrant/bm25"
},
"using": "isbn-bm25"
}
],
"query": {
"fusion": "rrf"
},
"limit": 10,
"with_payload": true
}
from qdrant_client import QdrantClient, models
client = QdrantClient(
url="https://xyz-example.qdrant.io:6333",
api_key="<your-api-key>",
cloud_inference=True,
)
client.query_points(
collection_name="books",
prefetch=[
models.Prefetch(
query=models.Document(
text="9780553213515",
model="sentence-transformers/all-minilm-l6-v2"
),
using="description-dense",
score_threshold=0.5,
),
models.Prefetch(
query=models.Document(
text="9780553213515",
model="Qdrant/bm25",
),
using="isbn-bm25",
),
],
query=models.FusionQuery(fusion=models.Fusion.RRF),
limit=10,
with_payload=True,
)
client.query("books", {
prefetch: [
{
query: { text: "9780553213515", model: "sentence-transformers/all-minilm-l6-v2" },
using: "description-dense",
score_threshold: 0.5,
},
{
query: { text: "9780553213515", model: "Qdrant/bm25" },
using: "isbn-bm25",
},
],
query: { fusion: "rrf" },
limit: 10,
with_payload: true,
});
use qdrant_client::Qdrant;
use qdrant_client::qdrant::{Document, Fusion, PrefetchQueryBuilder, Query, QueryPointsBuilder};
let dense_prefetch = PrefetchQueryBuilder::default()
.query(Query::new_nearest(Document::new(
"9780553213515",
"sentence-transformers/all-minilm-l6-v2",
)))
.using("description-dense")
.score_threshold(0.5)
.build();
let bm25_prefetch = PrefetchQueryBuilder::default()
.query(Query::new_nearest(Document::new(
"9780553213515",
"Qdrant/bm25",
)))
.using("isbn-bm25")
.build();
client
.query(
QueryPointsBuilder::new("books")
.add_prefetch(dense_prefetch)
.add_prefetch(bm25_prefetch)
.query(Query::new_fusion(Fusion::Rrf))
.limit(10)
.with_payload(true)
.build(),
)
.await?;
import static io.qdrant.client.QueryFactory.nearest;
import static io.qdrant.client.WithPayloadSelectorFactory.enable;
import io.qdrant.client.QdrantClient;
import io.qdrant.client.QdrantGrpcClient;
import io.qdrant.client.grpc.Points.*;
QdrantClient client =
PrefetchQuery densePrefetch =
PrefetchQuery.newBuilder()
.setUsing("description-dense")
.setScoreThreshold(0.5f)
.setQuery(
nearest(
Document.newBuilder()
.setText("9780553213515")
.setModel("sentence-transformers/all-minilm-l6-v2")
.build()))
.build();
PrefetchQuery bm25Prefetch =
PrefetchQuery.newBuilder()
.setUsing("isbn-bm25")
.setQuery(
nearest(
Document.newBuilder().setText("9780553213515").setModel("Qdrant/bm25").build()))
.build();
client
.queryAsync(
QueryPoints.newBuilder()
.setCollectionName("books")
.addPrefetch(densePrefetch)
.addPrefetch(bm25Prefetch)
.setQuery(Query.newBuilder().setFusion(Fusion.RRF).build())
.setLimit(10)
.setWithPayload(enable(true))
.build())
.get();
using Qdrant.Client;
using Qdrant.Client.Grpc;
await client.QueryAsync(
collectionName: "books",
prefetch: new List<PrefetchQuery>
{
new()
{
Using = "description-dense",
Query = new Document
{
Text = "9780553213515",
Model = "sentence-transformers/all-minilm-l6-v2",
},
ScoreThreshold = 0.5f,
},
new()
{
Using = "isbn-bm25",
Query = new Document { Text = "9780553213515", Model = "Qdrant/bm25" },
},
},
query: Fusion.Rrf,
payloadSelector: true,
limit: 10
);
client.Query(context.Background(), &qdrant.QueryPoints{
CollectionName: "books",
Prefetch: []*qdrant.PrefetchQuery{
{
Using: qdrant.PtrOf("description-dense"),
Query: qdrant.NewQueryDocument(&qdrant.Document{
Text: "9780553213515",
Model: "sentence-transformers/all-minilm-l6-v2",
}),
},
{
Using: qdrant.PtrOf("isbn-bm25"),
Query: qdrant.NewQueryDocument(&qdrant.Document{
Text: "9780553213515",
Model: "qdrant/bm25",
}),
},
},
Query: qdrant.NewQueryFusion(qdrant.Fusion_RRF),
WithPayload: qdrant.NewWithPayload(true),
Limit: qdrant.PtrOf(uint64(10)),
})
此查询搜索 ISBN，只有词法搜索会返回结果。语义查询的 score_threshold 会阻止返回低分结果（0.5 只是一个示例阈值；您需要针对您的数据和模型调整什么是好的阈值）。因此在这种情况下，仅将词法结果返回给用户。如果用户搜索“time travel”，则只有语义搜索会返回结果，并将其返回给用户。如果用户搜索同时匹配语义和词法向量的词条，则会将这两个搜索的结果合并，以提供更全面的结果集。
您不限于仅预取两个查询。示例包括但不限于：
- 将
title、author和isbn字段的多个词法查询与语义查询进行融合，以实现跨所有数据的全面搜索。 - 使用稀疏或稠密向量和/或过滤器进行预取，并使用稠密向量进行重排。
- 使用稠密和稀疏向量进行预取，并使用后期交互嵌入进行重排。.
结论
Qdrant 的文本搜索功能使您能够构建强大的搜索应用程序，结合了语义和词法搜索的优点。通过利用稠密和稀疏向量，以及 Qdrant 灵活的查询功能，您可以创建满足各种用户需求的搜索体验。