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]