Skip to content

Build and run agents you can see, understand and trust.

fix(rag): support float metadata filters in Qdrant (#2783)

Sunhybe8dbcb27284
diff --git a/src/agentscope/rag/_vdb/_qdrant.py b/src/agentscope/rag/_vdb/_qdrant.py
index a54471705..09af9a69c 100644
--- a/src/agentscope/rag/_vdb/_qdrant.py
+++ b/src/agentscope/rag/_vdb/_qdrant.py
@@ -13,6 +13,7 @@ constructor arguments:
- ``path="/path/to/db"`` — in-process, persisted to local disk
- ``url="http://localhost:6333"`` — remote Qdrant server / cloud
"""
+import math
import uuid
from typing import TYPE_CHECKING, Any, Literal
@@ -491,12 +492,24 @@ class QdrantStore(VectorStoreBase):
from qdrant_client import models
- return models.Filter(
- must=[
- models.FieldCondition(
- key=f"chunk.metadata.{key}",
+ conditions = []
+ for key, value in metadata_filter.items():
+ field = f"chunk.metadata.{key}"
+ if isinstance(value, float):
+ if not math.isfinite(value):
+ raise ValueError(
+ "Metadata filter float values must be finite.",
+ )
+ # MatchValue supports only strings, integers, and booleans.
+ condition = models.FieldCondition(
+ key=field,
+ range=models.Range(gte=value, lte=value),
+ )
+ else:
+ condition = models.FieldCondition(
+ key=field,
match=models.MatchValue(value=value),
)
- for key, value in metadata_filter.items()
- ],
- )
+ conditions.append(condition)
+
+ return models.Filter(must=conditions)
diff --git a/tests/rag_vdb_qdrant_test.py b/tests/rag_vdb_qdrant_test.py
index b78a35aad..cc3973071 100644
--- a/tests/rag_vdb_qdrant_test.py
+++ b/tests/rag_vdb_qdrant_test.py
@@ -444,6 +444,103 @@ class QdrantStoreTest(IsolatedAsyncioTestCase):
)
self.assertEqual([r.document_id for r in results], ["doc-2"])
+ async def test_float_metadata_filters(self) -> None:
+ """Every read operation matches finite floats without rounding."""
+ await self.store.create_collection("kb-1", dimensions=3)
+ values = [-0.75, 0.0, 0.75]
+ records = []
+ for index, value in enumerate(values):
+ record = _make_record(
+ f"note-{index}",
+ [1.0, 0.0, 0.0],
+ "doc-1",
+ chunk_index=index,
+ total_chunks=len(values),
+ )
+ record.chunk.metadata["confidence"] = value
+ records.append(record)
+ await self.store.insert("kb-1", records)
+
+ for index, value in enumerate(values):
+ metadata_filter = {"confidence": value}
+ with self.subTest(operation="search", value=value):
+ results = await self.store.search(
+ "kb-1",
+ [1.0, 0.0, 0.0],
+ metadata_filter=metadata_filter,
+ )
+ self.assertEqual(
+ [result.chunk.chunk_index for result in results],
+ [index],
+ )
+ with self.subTest(operation="list_documents", value=value):
+ documents = await self.store.list_documents(
+ "kb-1",
+ metadata_filter=metadata_filter,
+ )
+ self.assertEqual(
+ [(doc.document_id, doc.chunk_count) for doc in documents],
+ [("doc-1", 1)],
+ )
+ self.assertEqual(documents[0].metadata, metadata_filter)
+ with self.subTest(operation="list_chunks", value=value):
+ chunks = await self.store.list_chunks(
+ "kb-1",
+ "doc-1",
+ metadata_filter=metadata_filter,
+ )
+ self.assertEqual(
+ [chunk.chunk_index for chunk in chunks],
+ [index],
+ )
+
+ async def test_mixed_scalar_metadata_filter(self) -> None:
+ """Combine float equality with the existing scalar match types."""
+ await self.store.create_collection("kb-1", dimensions=3)
+ metadata_filter = {
+ "confidence": 0.75,
+ "category": "notes",
+ "version": 2,
+ "active": True,
+ }
+ records = []
+ for index, metadata in enumerate(
+ [
+ metadata_filter,
+ {**metadata_filter, "confidence": 0.5},
+ {**metadata_filter, "category": "other"},
+ {**metadata_filter, "version": 3},
+ {**metadata_filter, "active": False},
+ ],
+ ):
+ record = _make_record(
+ f"note-{index}",
+ [1.0, 0.0, 0.0],
+ f"doc-{index}",
+ )
+ record.chunk.metadata.update(metadata)
+ records.append(record)
+ await self.store.insert("kb-1", records)
+
+ results = await self.store.search(
+ "kb-1",
+ [1.0, 0.0, 0.0],
+ metadata_filter=metadata_filter,
+ )
+ self.assertEqual([result.document_id for result in results], ["doc-0"])
+
+ async def test_nonfinite_metadata_filter(self) -> None:
+ """Reject non-finite floats instead of widening a query."""
+ await self.store.create_collection("kb-1", dimensions=3)
+ for value in [float("nan"), float("inf"), float("-inf")]:
+ with self.subTest(value=value):
+ with self.assertRaisesRegex(ValueError, "finite"):
+ await self.store.search(
+ "kb-1",
+ [1.0, 0.0, 0.0],
+ metadata_filter={"confidence": value},
+ )
+
async def test_list_chunks_pagination_and_isolation(self) -> None:
"""list_chunks pages by chunk_index and isolates documents."""
await self.store.create_collection("kb-1", dimensions=3)