From 5fe3f0932d4b6ed88e434dbc364ae9b557e92679 Mon Sep 17 00:00:00 2001 From: VANDRANKI Date: Sun, 8 Nov 2026 14:59:23 -0500 Subject: [PATCH] Python: key Qdrant records by storage name when serializing and deserializing (#14754) Dict and dataclass records reach the Qdrant serializer keyed by storage name and pydantic models keyed by field name. The serializer popped the key and vector fields by declared name, so dict and dataclass records with a storage_name on the key or vector field failed to upsert with a KeyError. Pydantic payloads were stored under the declared names, so filters on storage names did not match them. The deserializer returned the key and an unnamed vector under the declared names, which the data model step does not read for dict and dataclass records. Closes #14754 Co-authored-by: VANDRANKI --- python/semantic_kernel/connectors/qdrant.py | 42 ++++++++---- .../connectors/memory/test_qdrant_local.py | 67 ++++++++++++++++++- 2 files changed, 94 insertions(+), 15 deletions(-) diff --git a/python/semantic_kernel/connectors/qdrant.py b/python/semantic_kernel/connectors/qdrant.py index 95f4110e4563..01533723cd4b 100644 --- a/python/semantic_kernel/connectors/qdrant.py +++ b/python/semantic_kernel/connectors/qdrant.py @@ -440,24 +440,38 @@ def _lambda_parser(self, node: ast.AST) -> Any: return [self._lambda_parser(elt) for elt in node.elts] raise NotImplementedError(f"Unsupported AST node: {type(node)}") + def _storage_keyed(self, record: dict[str, Any]) -> dict[str, Any]: + """Return the record keyed by storage names. + + Dict and dataclass records arrive keyed by storage name, pydantic models keyed by field name. + """ + keyed = dict(record) + for field in self.definition.fields: + storage_name = field.storage_name or field.name + if storage_name != field.name and storage_name not in keyed and field.name in keyed: + keyed[storage_name] = keyed.pop(field.name) + return keyed + @override def _serialize_dicts_to_store_models( self, records: Sequence[dict[str, Any]], **kwargs: Any, ) -> Sequence[PointStruct]: - return [ - PointStruct( - id=record.pop(self._key_field_name), - vector=record.pop(self.definition.vector_field_names[0]) - if not self.named_vectors - else { - field.storage_name or field.name: record.pop(field.name) for field in self.definition.vector_fields - }, - payload=record, + key_name = self.definition.key_field_storage_name + vector_names = [field.storage_name or field.name for field in self.definition.vector_fields] + points = [] + for record in map(self._storage_keyed, records): + points.append( + PointStruct( + id=record.pop(key_name), + vector=record.pop(vector_names[0]) + if not self.named_vectors + else {name: record.pop(name) for name in vector_names}, + payload=record, + ) ) - for record in records - ] + return points @override def _deserialize_store_models_to_dicts( @@ -465,16 +479,18 @@ def _deserialize_store_models_to_dicts( records: Sequence[PointStruct] | Sequence[ScoredPoint], **kwargs: Any, ) -> Sequence[dict[str, Any]]: + key_name = self.definition.key_field_storage_name + vector_name = self.definition.vector_fields[0].storage_name or self.definition.vector_field_names[0] return [ { - self._key_field_name: record.id, + key_name: record.id, **(record.payload if record.payload else {}), **( {} if not record.vector else record.vector if isinstance(record.vector, dict) - else {self.definition.vector_field_names[0]: record.vector} + else {vector_name: record.vector} ), } for record in records diff --git a/python/tests/unit/connectors/memory/test_qdrant_local.py b/python/tests/unit/connectors/memory/test_qdrant_local.py index 6e308e379af7..eddba4c1af36 100644 --- a/python/tests/unit/connectors/memory/test_qdrant_local.py +++ b/python/tests/unit/connectors/memory/test_qdrant_local.py @@ -3,10 +3,11 @@ from dataclasses import dataclass from typing import Annotated -from pytest import fixture +from pydantic import BaseModel +from pytest import fixture, mark from semantic_kernel.connectors.qdrant import QdrantCollection -from semantic_kernel.data.vector import VectorStoreField, vectorstoremodel +from semantic_kernel.data.vector import VectorStoreCollectionDefinition, VectorStoreField, vectorstoremodel @vectorstoremodel @@ -61,3 +62,65 @@ async def test_local_hybrid_search_single_comparison_filter(named_local_collecti filter="lambda x: x.temperature > 1", ) assert sorted([r.record.id async for r in results.results]) == [2, 3] + + +@dataclass +class AliasedDataclass: + id: int + text: str + vector: list[float] | None = None + + +class AliasedModel(BaseModel): + id: int + text: str + vector: list[float] | None = None + + +def _aliased_definition() -> VectorStoreCollectionDefinition: + return VectorStoreCollectionDefinition( + fields=[ + VectorStoreField("key", name="id", type="int", storage_name="point_id"), + VectorStoreField("data", name="text", type="str", storage_name="doc_text", is_indexed=True), + VectorStoreField("vector", name="vector", dimensions=2, type="float", storage_name="doc_vector"), + ] + ) + + +@mark.parametrize("named_vectors", [True, False], ids=["named_vectors", "unnamed_vectors"]) +@mark.parametrize("record_type", [dict, AliasedDataclass, AliasedModel]) +async def test_local_storage_names_round_trip(record_type, named_vectors): + def make(record_id: int, text: str, vector: list[float]): + values = {"id": record_id, "text": text, "vector": vector} + return values if record_type is dict else record_type(**values) + + def as_dict(record): + return ( + record + if isinstance(record, dict) + else vars(record) + if record_type is AliasedDataclass + else record.model_dump() + ) + + async with QdrantCollection( + record_type=record_type, + definition=_aliased_definition(), + collection_name="test", + location=":memory:", + named_vectors=named_vectors, + ) as collection: + await collection.ensure_collection_exists() + await collection.upsert([make(1, "a", [1.0, 0.0]), make(2, "b", [0.0, 1.0])]) + + stored = as_dict(await collection.get(1, include_vectors=True)) + assert stored == {"id": 1, "text": "a", "vector": [1.0, 0.0]} + + results = await collection.search(vector=[0.0, 1.0], include_vectors=True) + found = [as_dict(r.record) async for r in results.results] + assert [r["id"] for r in found] == [2, 1] + assert found[0] == {"id": 2, "text": "b", "vector": [0.0, 1.0]} + + # filters use the storage names, so the payload must be stored under them for every record type + results = await collection.search(vector=[0.0, 1.0], filter="lambda x: x.doc_text == 'a'") + assert [as_dict(r.record)["id"] async for r in results.results] == [1]