The Memory Layer for AI Agents - Drop-in memory infrastructure for AI agents and apps. Context that persists. Built for production.
Python agentic-memoryagentic-memory-systemagentsaiai-agentschatgptgenaillmlong-term-memorymemorymemory-managementpythonragstate-management
Added mulit id filters support for all vectorstores (#3269)
Parshva Daftari42e60d672448
diff --git a/mem0/vector_stores/chroma.py b/mem0/vector_stores/chroma.pyindex 1de95ad1a..681d4626c 100644--- a/mem0/vector_stores/chroma.py+++ b/mem0/vector_stores/chroma.py@@ -142,7 +142,8 @@ class ChromaDB(VectorStoreBase):Returns:List[OutputData]: Search results."""- results = self.collection.query(query_embeddings=vectors, where=filters, n_results=limit)+ where_clause = self._generate_where_clause(filters) if filters else None+ results = self.collection.query(query_embeddings=vectors, where=where_clause, n_results=limit)final_results = self._parse_output(results)return final_results@@ -219,7 +220,8 @@ class ChromaDB(VectorStoreBase):Returns:List[OutputData]: List of vectors."""- results = self.collection.get(where=filters, limit=limit)+ where_clause = self._generate_where_clause(filters) if filters else None+ results = self.collection.get(where=where_clause, limit=limit)return [self._parse_output(results)]def reset(self):@@ -227,3 +229,26 @@ class ChromaDB(VectorStoreBase):logger.warning(f"Resetting index {self.collection_name}...")self.delete_col()self.collection = self.create_col(self.collection_name)++ @staticmethod+ def _generate_where_clause(where: dict[str, any]) -> dict[str, any]:+ """+ Generate a properly formatted where clause for ChromaDB.++ Args:+ where (dict[str, any]): The filter conditions.++ Returns:+ dict[str, any]: Properly formatted where clause for ChromaDB.+ """+ # If only one filter is supplied, return it as is+ # (no need to wrap in $and based on chroma docs)+ if where is None:+ return {}+ if len(where.keys()) <= 1:+ return where+ where_filters = []+ for k, v in where.items():+ if isinstance(v, str):+ where_filters.append({k: v})+ return {"$and": where_filters}diff --git a/mem0/vector_stores/langchain.py b/mem0/vector_stores/langchain.pyindex f3fcf07e8..4fe06c1b1 100644--- a/mem0/vector_stores/langchain.py+++ b/mem0/vector_stores/langchain.py@@ -160,8 +160,9 @@ class Langchain(VectorStoreBase):if hasattr(self.client, "_collection") and hasattr(self.client._collection, "get"):# Convert mem0 filters to Chroma where clause if neededwhere_clause = None- if filters and "user_id" in filters:- where_clause = {"user_id": filters["user_id"]}+ if filters:+ # Handle all filters, not just user_id+ where_clause = filtersresult = self.client._collection.get(where=where_clause, limit=limit)diff --git a/mem0/vector_stores/mongodb.py b/mem0/vector_stores/mongodb.pyindex ef82c6e60..381bfde4e 100644--- a/mem0/vector_stores/mongodb.py+++ b/mem0/vector_stores/mongodb.py@@ -148,6 +148,17 @@ class MongoDB(VectorStoreBase):{"$set": {"score": {"$meta": "vectorSearchScore"}}},{"$project": {"embedding": 0}},]++ # Add filter stage if filters are provided+ if filters:+ filter_conditions = []+ for key, value in filters.items():+ filter_conditions.append({"payload." + key: value})++ if filter_conditions:+ # Add a $match stage after vector search to apply filters+ pipeline.insert(1, {"$match": {"$and": filter_conditions}})+results = list(collection.aggregate(pipeline))logger.info(f"Vector search completed. Found {len(results)} documents.")except Exception as e:@@ -271,7 +282,15 @@ class MongoDB(VectorStoreBase):List[OutputData]: List of vectors."""try:- query = filters or {}+ query = {}+ if filters:+ # Apply filters to the payload field+ filter_conditions = []+ for key, value in filters.items():+ filter_conditions.append({"payload." + key: value})+ if filter_conditions:+ query = {"$and": filter_conditions}+cursor = self.collection.find(query).limit(limit)results = [OutputData(id=str(doc["_id"]), score=None, payload=doc.get("payload")) for doc in cursor]logger.info(f"Retrieved {len(results)} documents from collection '{self.collection_name}'.")diff --git a/mem0/vector_stores/qdrant.py b/mem0/vector_stores/qdrant.pyindex 98604398c..273b61428 100644--- a/mem0/vector_stores/qdrant.py+++ b/mem0/vector_stores/qdrant.py@@ -148,6 +148,9 @@ class Qdrant(VectorStoreBase):Returns:Filter: The created Filter object."""+ if not filters:+ return None+conditions = []for key, value in filters.items():if isinstance(value, dict) and "gte" in value and "lte" in value:@@ -258,7 +261,7 @@ class Qdrant(VectorStoreBase):with_payload=True,with_vectors=False,)- return result+ return result.pointsdef reset(self):"""Reset the index by deleting and recreating it."""diff --git a/tests/vector_stores/test_chroma.py b/tests/vector_stores/test_chroma.pyindex 39ddfdca7..4339c8c74 100644--- a/tests/vector_stores/test_chroma.py+++ b/tests/vector_stores/test_chroma.py@@ -48,6 +48,73 @@ def test_search_vectors(chromadb_instance, mock_chromadb_client):assert results[0].payload == {"name": "vector1"}+def test_search_vectors_with_filters(chromadb_instance, mock_chromadb_client):+ """Test search with agent_id and run_id filters."""+ mock_result = {+ "ids": [["id1"]],+ "distances": [[0.1]],+ "metadatas": [[{"name": "vector1", "user_id": "alice", "agent_id": "agent1", "run_id": "run1"}]],+ }+ chromadb_instance.collection.query.return_value = mock_result++ vectors = [[0.1, 0.2, 0.3]]+ filters = {"user_id": "alice", "agent_id": "agent1", "run_id": "run1"}+ results = chromadb_instance.search(query="", vectors=vectors, limit=2, filters=filters)++ # Verify that _generate_where_clause was called with the filters+ expected_where = {"$and": [{"user_id": "alice"}, {"agent_id": "agent1"}, {"run_id": "run1"}]}+ chromadb_instance.collection.query.assert_called_once_with(+ query_embeddings=vectors, where=expected_where, n_results=2+ )++ assert len(results) == 1+ assert results[0].id == "id1"+ assert results[0].payload["user_id"] == "alice"+ assert results[0].payload["agent_id"] == "agent1"+ assert results[0].payload["run_id"] == "run1"+++def test_search_vectors_with_single_filter(chromadb_instance, mock_chromadb_client):+ """Test search with single filter (should not use $and)."""+ mock_result = {+ "ids": [["id1"]],+ "distances": [[0.1]],+ "metadatas": [[{"name": "vector1", "user_id": "alice"}]],+ }+ chromadb_instance.collection.query.return_value = mock_result++ vectors = [[0.1, 0.2, 0.3]]+ filters = {"user_id": "alice"}+ results = chromadb_instance.search(query="", vectors=vectors, limit=2, filters=filters)++ # Verify that single filter is passed as-is (no $and wrapper)+ chromadb_instance.collection.query.assert_called_once_with(+ query_embeddings=vectors, where=filters, n_results=2+ )++ assert len(results) == 1+ assert results[0].payload["user_id"] == "alice"+++def test_search_vectors_with_no_filters(chromadb_instance, mock_chromadb_client):+ """Test search with no filters."""+ mock_result = {+ "ids": [["id1"]],+ "distances": [[0.1]],+ "metadatas": [[{"name": "vector1"}]],+ }+ chromadb_instance.collection.query.return_value = mock_result++ vectors = [[0.1, 0.2, 0.3]]+ results = chromadb_instance.search(query="", vectors=vectors, limit=2, filters=None)++ chromadb_instance.collection.query.assert_called_once_with(+ query_embeddings=vectors, where=None, n_results=2+ )++ assert len(results) == 1++def test_delete_vector(chromadb_instance):vector_id = "id1"@@ -100,3 +167,81 @@ def test_list_vectors(chromadb_instance):assert len(results[0]) == 2assert results[0][0].id == "id1"assert results[0][1].id == "id2"+++def test_list_vectors_with_filters(chromadb_instance):+ """Test list with agent_id and run_id filters."""+ mock_result = {+ "ids": [["id1"]],+ "distances": [[0.1]],+ "metadatas": [[{"name": "vector1", "user_id": "alice", "agent_id": "agent1", "run_id": "run1"}]],+ }+ chromadb_instance.collection.get.return_value = mock_result++ filters = {"user_id": "alice", "agent_id": "agent1", "run_id": "run1"}+ results = chromadb_instance.list(filters=filters, limit=2)++ # Verify that _generate_where_clause was called with the filters+ expected_where = {"$and": [{"user_id": "alice"}, {"agent_id": "agent1"}, {"run_id": "run1"}]}+ chromadb_instance.collection.get.assert_called_once_with(where=expected_where, limit=2)++ assert len(results[0]) == 1+ assert results[0][0].payload["user_id"] == "alice"+ assert results[0][0].payload["agent_id"] == "agent1"+ assert results[0][0].payload["run_id"] == "run1"+++def test_list_vectors_with_single_filter(chromadb_instance):+ """Test list with single filter (should not use $and)."""+ mock_result = {+ "ids": [["id1"]],+ "distances": [[0.1]],+ "metadatas": [[{"name": "vector1", "user_id": "alice"}]],+ }+ chromadb_instance.collection.get.return_value = mock_result++ filters = {"user_id": "alice"}+ results = chromadb_instance.list(filters=filters, limit=2)++ # Verify that single filter is passed as-is (no $and wrapper)+ chromadb_instance.collection.get.assert_called_once_with(where=filters, limit=2)++ assert len(results[0]) == 1+ assert results[0][0].payload["user_id"] == "alice"+++def test_generate_where_clause_multiple_filters():+ """Test _generate_where_clause with multiple filters."""+ filters = {"user_id": "alice", "agent_id": "agent1", "run_id": "run1"}+ result = ChromaDB._generate_where_clause(filters)++ expected = {"$and": [{"user_id": "alice"}, {"agent_id": "agent1"}, {"run_id": "run1"}]}+ assert result == expected+++def test_generate_where_clause_single_filter():+ """Test _generate_where_clause with single filter."""+ filters = {"user_id": "alice"}+ result = ChromaDB._generate_where_clause(filters)++ # Single filter should be returned as-is+ assert result == filters+++def test_generate_where_clause_no_filters():+ """Test _generate_where_clause with no filters."""+ result = ChromaDB._generate_where_clause(None)+ assert result == {}++ result = ChromaDB._generate_where_clause({})+ assert result == {}+++def test_generate_where_clause_non_string_values():+ """Test _generate_where_clause with non-string values."""+ filters = {"user_id": "alice", "count": 5, "active": True}+ result = ChromaDB._generate_where_clause(filters)++ # Only string values should be included in $and array+ expected = {"$and": [{"user_id": "alice"}]}+ assert result == expecteddiff --git a/tests/vector_stores/test_langchain_vector_store.py b/tests/vector_stores/test_langchain_vector_store.pyindex 6e156ec22..5f1a8c544 100644--- a/tests/vector_stores/test_langchain_vector_store.py+++ b/tests/vector_stores/test_langchain_vector_store.py@@ -64,6 +64,66 @@ def test_search_vectors(langchain_instance):langchain_instance.client.similarity_search_by_vector.assert_called_with(embedding=vectors, k=2, filter=filters)+def test_search_vectors_with_agent_id_run_id_filters(langchain_instance):+ """Test search with agent_id and run_id filters."""+ # Mock search results+ mock_docs = [+ Mock(metadata={"user_id": "alice", "agent_id": "agent1", "run_id": "run1"}, id="id1"),+ Mock(metadata={"user_id": "bob", "agent_id": "agent2", "run_id": "run2"}, id="id2")+ ]+ langchain_instance.client.similarity_search_by_vector.return_value = mock_docs++ vectors = [[0.1, 0.2, 0.3]]+ filters = {"user_id": "alice", "agent_id": "agent1", "run_id": "run1"}+ results = langchain_instance.search(query="", vectors=vectors, limit=2, filters=filters)++ # Verify that filters were passed to the underlying vector store+ langchain_instance.client.similarity_search_by_vector.assert_called_once_with(+ embedding=vectors, k=2, filter=filters+ )++ assert len(results) == 2+ assert results[0].payload["user_id"] == "alice"+ assert results[0].payload["agent_id"] == "agent1"+ assert results[0].payload["run_id"] == "run1"+++def test_search_vectors_with_single_filter(langchain_instance):+ """Test search with single filter."""+ # Mock search results+ mock_docs = [Mock(metadata={"user_id": "alice"}, id="id1")]+ langchain_instance.client.similarity_search_by_vector.return_value = mock_docs++ vectors = [[0.1, 0.2, 0.3]]+ filters = {"user_id": "alice"}+ results = langchain_instance.search(query="", vectors=vectors, limit=2, filters=filters)++ # Verify that filters were passed to the underlying vector store+ langchain_instance.client.similarity_search_by_vector.assert_called_once_with(+ embedding=vectors, k=2, filter=filters+ )++ assert len(results) == 1+ assert results[0].payload["user_id"] == "alice"+++def test_search_vectors_with_no_filters(langchain_instance):+ """Test search with no filters."""+ # Mock search results+ mock_docs = [Mock(metadata={"name": "vector1"}, id="id1")]+ langchain_instance.client.similarity_search_by_vector.return_value = mock_docs++ vectors = [[0.1, 0.2, 0.3]]+ results = langchain_instance.search(query="", vectors=vectors, limit=2, filters=None)++ # Verify that no filters were passed to the underlying vector store+ langchain_instance.client.similarity_search_by_vector.assert_called_once_with(+ embedding=vectors, k=2+ )++ assert len(results) == 1++def test_get_vector(langchain_instance):# Mock get resultmock_doc = Mock(metadata={"name": "vector1"}, id="id1")@@ -81,3 +141,86 @@ def test_get_vector(langchain_instance):langchain_instance.client.get_by_ids.return_value = []result = langchain_instance.get("non_existent_id")assert result is None+++def test_list_with_filters(langchain_instance):+ """Test list with agent_id and run_id filters."""+ # Mock the _collection.get method+ mock_collection = Mock()+ mock_collection.get.return_value = {+ "ids": [["id1"]],+ "metadatas": [[{"user_id": "alice", "agent_id": "agent1", "run_id": "run1"}]],+ "documents": [["test document"]]+ }+ langchain_instance.client._collection = mock_collection++ filters = {"user_id": "alice", "agent_id": "agent1", "run_id": "run1"}+ results = langchain_instance.list(filters=filters, limit=10)++ # Verify that the collection.get method was called with the correct filters+ mock_collection.get.assert_called_once_with(where=filters, limit=10)++ # Verify the results+ assert len(results) == 1+ assert len(results[0]) == 1+ assert results[0][0].payload["user_id"] == "alice"+ assert results[0][0].payload["agent_id"] == "agent1"+ assert results[0][0].payload["run_id"] == "run1"+++def test_list_with_single_filter(langchain_instance):+ """Test list with single filter."""+ # Mock the _collection.get method+ mock_collection = Mock()+ mock_collection.get.return_value = {+ "ids": [["id1"]],+ "metadatas": [[{"user_id": "alice"}]],+ "documents": [["test document"]]+ }+ langchain_instance.client._collection = mock_collection++ filters = {"user_id": "alice"}+ results = langchain_instance.list(filters=filters, limit=10)++ # Verify that the collection.get method was called with the correct filter+ mock_collection.get.assert_called_once_with(where=filters, limit=10)++ # Verify the results+ assert len(results) == 1+ assert len(results[0]) == 1+ assert results[0][0].payload["user_id"] == "alice"+++def test_list_with_no_filters(langchain_instance):+ """Test list with no filters."""+ # Mock the _collection.get method+ mock_collection = Mock()+ mock_collection.get.return_value = {+ "ids": [["id1"]],+ "metadatas": [[{"name": "vector1"}]],+ "documents": [["test document"]]+ }+ langchain_instance.client._collection = mock_collection++ results = langchain_instance.list(filters=None, limit=10)++ # Verify that the collection.get method was called with no filters+ mock_collection.get.assert_called_once_with(where=None, limit=10)++ # Verify the results+ assert len(results) == 1+ assert len(results[0]) == 1+ assert results[0][0].payload["name"] == "vector1"+++def test_list_with_exception(langchain_instance):+ """Test list when an exception occurs."""+ # Mock the _collection.get method to raise an exception+ mock_collection = Mock()+ mock_collection.get.side_effect = Exception("Test exception")+ langchain_instance.client._collection = mock_collection++ results = langchain_instance.list(filters={"user_id": "alice"}, limit=10)++ # Verify that an empty list is returned when an exception occurs+ assert results == []diff --git a/tests/vector_stores/test_mongodb.py b/tests/vector_stores/test_mongodb.pyindex abb299e01..bb4b3f69f 100644--- a/tests/vector_stores/test_mongodb.py+++ b/tests/vector_stores/test_mongodb.py@@ -14,7 +14,12 @@ def mongo_vector_fixture(mock_mongo_client):mock_collection.list_search_indexes.return_value = []mock_collection.aggregate.return_value = []mock_collection.find_one.return_value = None- mock_collection.find.return_value = []++ # Create a proper mock cursor+ mock_cursor = MagicMock()+ mock_cursor.limit.return_value = mock_cursor+ mock_collection.find.return_value = mock_cursor+mock_db.list_collection_names.return_value = []mongo_vector = MongoDB(@@ -102,87 +107,247 @@ def test_search(mongo_vector_fixture):assert len(results) == 2assert results[0].id == "id1"assert results[0].score == 0.9- assert results[1].id == "id2"- assert results[1].score == 0.8+ assert results[0].payload == {"key": "value1"}+++def test_search_with_filters(mongo_vector_fixture):+ """Test search with agent_id and run_id filters."""+ mongo_vector, mock_collection, _ = mongo_vector_fixture+ query_vector = [0.1] * 1536+ mock_collection.aggregate.return_value = [+ {"_id": "id1", "score": 0.9, "payload": {"user_id": "alice", "agent_id": "agent1", "run_id": "run1"}},+ ]+ mock_collection.list_search_indexes.return_value = ["test_collection_vector_index"]++ filters = {"user_id": "alice", "agent_id": "agent1", "run_id": "run1"}+ results = mongo_vector.search("query_str", query_vector, limit=2, filters=filters)++ # Verify that the aggregation pipeline includes the filter stage+ mock_collection.aggregate.assert_called_once()+ pipeline = mock_collection.aggregate.call_args[0][0]++ # Check that the pipeline has the expected stages+ assert len(pipeline) == 4 # vectorSearch, match, set, project++ # Check that the match stage is present with the correct filters+ match_stage = pipeline[1]+ assert "$match" in match_stage+ assert match_stage["$match"]["$and"] == [+ {"payload.user_id": "alice"},+ {"payload.agent_id": "agent1"},+ {"payload.run_id": "run1"}+ ]++ assert len(results) == 1+ assert results[0].payload["user_id"] == "alice"+ assert results[0].payload["agent_id"] == "agent1"+ assert results[0].payload["run_id"] == "run1"+++def test_search_with_single_filter(mongo_vector_fixture):+ """Test search with single filter."""+ mongo_vector, mock_collection, _ = mongo_vector_fixture+ query_vector = [0.1] * 1536+ mock_collection.aggregate.return_value = [+ {"_id": "id1", "score": 0.9, "payload": {"user_id": "alice"}},+ ]+ mock_collection.list_search_indexes.return_value = ["test_collection_vector_index"]++ filters = {"user_id": "alice"}+ results = mongo_vector.search("query_str", query_vector, limit=2, filters=filters)++ # Verify that the aggregation pipeline includes the filter stage+ mock_collection.aggregate.assert_called_once()+ pipeline = mock_collection.aggregate.call_args[0][0]++ # Check that the match stage is present with the correct filter+ match_stage = pipeline[1]+ assert "$match" in match_stage+ assert match_stage["$match"]["$and"] == [{"payload.user_id": "alice"}]++ assert len(results) == 1+ assert results[0].payload["user_id"] == "alice"+++def test_search_with_no_filters(mongo_vector_fixture):+ """Test search with no filters."""+ mongo_vector, mock_collection, _ = mongo_vector_fixture+ query_vector = [0.1] * 1536+ mock_collection.aggregate.return_value = [+ {"_id": "id1", "score": 0.9, "payload": {"key": "value1"}},+ ]+ mock_collection.list_search_indexes.return_value = ["test_collection_vector_index"]++ results = mongo_vector.search("query_str", query_vector, limit=2, filters=None)++ # Verify that the aggregation pipeline does not include the filter stage+ mock_collection.aggregate.assert_called_once()+ pipeline = mock_collection.aggregate.call_args[0][0]++ # Check that the pipeline has only the expected stages (no match stage)+ assert len(pipeline) == 3 # vectorSearch, set, project++ assert len(results) == 1def test_delete(mongo_vector_fixture):mongo_vector, mock_collection, _ = mongo_vector_fixture- mock_delete_result = MagicMock()- mock_delete_result.deleted_count = 1- mock_collection.delete_one.return_value = mock_delete_result+ vector_id = "id1"+ mock_collection.delete_one.return_value = MagicMock(deleted_count=1)++ # Reset the mock to clear calls from fixture setup+ mock_collection.delete_one.reset_mock()++ mongo_vector.delete(vector_id=vector_id)- mongo_vector.delete("id1")- mock_collection.delete_one.assert_called_with({"_id": "id1"})+ mock_collection.delete_one.assert_called_once_with({"_id": vector_id})def test_update(mongo_vector_fixture):mongo_vector, mock_collection, _ = mongo_vector_fixture- mock_update_result = MagicMock()- mock_update_result.matched_count = 1- mock_collection.update_one.return_value = mock_update_result- idValue = "id1"- vectorValue = [0.2] * 1536- payloadValue = {"key": "updated"}-- mongo_vector.update(idValue, vector=vectorValue, payload=payloadValue)+ vector_id = "id1"+ updated_vector = [0.3] * 1536+ updated_payload = {"name": "updated_vector"}++ mock_collection.update_one.return_value = MagicMock(matched_count=1)++ mongo_vector.update(vector_id=vector_id, vector=updated_vector, payload=updated_payload)+mock_collection.update_one.assert_called_once_with(- {"_id": idValue},- {"$set": {"embedding": vectorValue, "payload": payloadValue}},+ {"_id": vector_id}, {"$set": {"embedding": updated_vector, "payload": updated_payload}})def test_get(mongo_vector_fixture):mongo_vector, mock_collection, _ = mongo_vector_fixture- mock_collection.find_one.return_value = {"_id": "id1", "payload": {"key": "value1"}}+ vector_id = "id1"+ mock_collection.find_one.return_value = {"_id": vector_id, "payload": {"key": "value"}}++ result = mongo_vector.get(vector_id=vector_id)- result = mongo_vector.get("id1")- assert result is not None- assert result.id == "id1"- assert result.payload == {"key": "value1"}+ mock_collection.find_one.assert_called_once_with({"_id": vector_id})+ assert result.id == vector_id+ assert result.payload == {"key": "value"}def test_list_cols(mongo_vector_fixture):mongo_vector, _, mock_db = mongo_vector_fixture- mock_db.list_collection_names.return_value = ["col1", "col2"]+ mock_db.list_collection_names.return_value = ["collection1", "collection2"]++ # Reset the mock to clear calls from fixture setup+ mock_db.list_collection_names.reset_mock()- collections = mongo_vector.list_cols()- assert collections == ["col1", "col2"]+ result = mongo_vector.list_cols()++ mock_db.list_collection_names.assert_called_once()+ assert result == ["collection1", "collection2"]def test_delete_col(mongo_vector_fixture):mongo_vector, mock_collection, _ = mongo_vector_fixturemongo_vector.delete_col()+mock_collection.drop.assert_called_once()def test_col_info(mongo_vector_fixture):- mongo_vector, _, mock_db = mongo_vector_fixture+ mongo_vector, mock_collection, mock_db = mongo_vector_fixturemock_db.command.return_value = {"count": 10, "size": 1024}- info = mongo_vector.col_info()+ result = mongo_vector.col_info()+mock_db.command.assert_called_once_with("collstats", "test_collection")- assert info["name"] == "test_collection"- assert info["count"] == 10- assert info["size"] == 1024+ assert result["name"] == "test_collection"+ assert result["count"] == 10+ assert result["size"] == 1024def test_list(mongo_vector_fixture):mongo_vector, mock_collection, _ = mongo_vector_fixture- mock_cursor = MagicMock()- mock_cursor.limit.return_value = [+ # Mock the cursor to return the expected data+ mock_cursor = mock_collection.find.return_value+ mock_cursor.__iter__.return_value = [{"_id": "id1", "payload": {"key": "value1"}},{"_id": "id2", "payload": {"key": "value2"}},]- mock_collection.find.return_value = mock_cursor- query_filters = {"_id": {"$in": ["id1", "id2"]}}- results = mongo_vector.list(filters=query_filters, limit=2)- mock_collection.find.assert_called_once_with(query_filters)+ results = mongo_vector.list(limit=2)++ mock_collection.find.assert_called_once_with({})mock_cursor.limit.assert_called_once_with(2)assert len(results) == 2assert results[0].id == "id1"assert results[0].payload == {"key": "value1"}- assert results[1].id == "id2"- assert results[1].payload == {"key": "value2"}+++def test_list_with_filters(mongo_vector_fixture):+ """Test list with agent_id and run_id filters."""+ mongo_vector, mock_collection, _ = mongo_vector_fixture+ # Mock the cursor to return the expected data+ mock_cursor = mock_collection.find.return_value+ mock_cursor.__iter__.return_value = [+ {"_id": "id1", "payload": {"user_id": "alice", "agent_id": "agent1", "run_id": "run1"}},+ ]++ filters = {"user_id": "alice", "agent_id": "agent1", "run_id": "run1"}+ results = mongo_vector.list(filters=filters, limit=2)++ # Verify that the find method was called with the correct query+ expected_query = {+ "$and": [+ {"payload.user_id": "alice"},+ {"payload.agent_id": "agent1"},+ {"payload.run_id": "run1"}+ ]+ }+ mock_collection.find.assert_called_once_with(expected_query)+ mock_cursor.limit.assert_called_once_with(2)++ assert len(results) == 1+ assert results[0].payload["user_id"] == "alice"+ assert results[0].payload["agent_id"] == "agent1"+ assert results[0].payload["run_id"] == "run1"+++def test_list_with_single_filter(mongo_vector_fixture):+ """Test list with single filter."""+ mongo_vector, mock_collection, _ = mongo_vector_fixture+ # Mock the cursor to return the expected data+ mock_cursor = mock_collection.find.return_value+ mock_cursor.__iter__.return_value = [+ {"_id": "id1", "payload": {"user_id": "alice"}},+ ]++ filters = {"user_id": "alice"}+ results = mongo_vector.list(filters=filters, limit=2)++ # Verify that the find method was called with the correct query+ expected_query = {+ "$and": [+ {"payload.user_id": "alice"}+ ]+ }+ mock_collection.find.assert_called_once_with(expected_query)+ mock_cursor.limit.assert_called_once_with(2)++ assert len(results) == 1+ assert results[0].payload["user_id"] == "alice"+++def test_list_with_no_filters(mongo_vector_fixture):+ """Test list with no filters."""+ mongo_vector, mock_collection, _ = mongo_vector_fixture+ # Mock the cursor to return the expected data+ mock_cursor = mock_collection.find.return_value+ mock_cursor.__iter__.return_value = [+ {"_id": "id1", "payload": {"key": "value1"}},+ ]++ results = mongo_vector.list(filters=None, limit=2)++ # Verify that the find method was called with empty query+ mock_collection.find.assert_called_once_with({})+ mock_cursor.limit.assert_called_once_with(2)++ assert len(results) == 1diff --git a/tests/vector_stores/test_qdrant.py b/tests/vector_stores/test_qdrant.pyindex 0a2bb444a..dfcf145dc 100644--- a/tests/vector_stores/test_qdrant.py+++ b/tests/vector_stores/test_qdrant.py@@ -3,7 +3,13 @@ import uuidfrom unittest.mock import MagicMockfrom qdrant_client import QdrantClient-from qdrant_client.models import Distance, PointIdsList, PointStruct, VectorParams+from qdrant_client.models import (+ Distance,+ Filter,+ PointIdsList,+ PointStruct,+ VectorParams,+)from mem0.vector_stores.qdrant import Qdrant@@ -64,6 +70,121 @@ class TestQdrant(unittest.TestCase):self.assertEqual(results[0].payload, {"key": "value"})self.assertEqual(results[0].score, 0.95)+ def test_search_with_filters(self):+ """Test search with agent_id and run_id filters."""+ vectors = [[0.1, 0.2]]+ mock_point = MagicMock(+ id=str(uuid.uuid4()),+ score=0.95,+ payload={"user_id": "alice", "agent_id": "agent1", "run_id": "run1"}+ )+ self.client_mock.query_points.return_value = MagicMock(points=[mock_point])++ filters = {"user_id": "alice", "agent_id": "agent1", "run_id": "run1"}+ results = self.qdrant.search(query="", vectors=vectors, limit=1, filters=filters)++ # Verify that _create_filter was called and query_filter was passed+ self.client_mock.query_points.assert_called_once()+ call_args = self.client_mock.query_points.call_args[1]+ self.assertEqual(call_args["collection_name"], "test_collection")+ self.assertEqual(call_args["query"], vectors)+ self.assertEqual(call_args["limit"], 1)++ # Verify that a Filter object was created+ query_filter = call_args["query_filter"]+ self.assertIsInstance(query_filter, Filter)+ self.assertEqual(len(query_filter.must), 3) # user_id, agent_id, run_id++ self.assertEqual(len(results), 1)+ self.assertEqual(results[0].payload["user_id"], "alice")+ self.assertEqual(results[0].payload["agent_id"], "agent1")+ self.assertEqual(results[0].payload["run_id"], "run1")++ def test_search_with_single_filter(self):+ """Test search with single filter."""+ vectors = [[0.1, 0.2]]+ mock_point = MagicMock(+ id=str(uuid.uuid4()),+ score=0.95,+ payload={"user_id": "alice"}+ )+ self.client_mock.query_points.return_value = MagicMock(points=[mock_point])++ filters = {"user_id": "alice"}+ results = self.qdrant.search(query="", vectors=vectors, limit=1, filters=filters)++ # Verify that a Filter object was created with single condition+ call_args = self.client_mock.query_points.call_args[1]+ query_filter = call_args["query_filter"]+ self.assertIsInstance(query_filter, Filter)+ self.assertEqual(len(query_filter.must), 1) # Only user_id++ self.assertEqual(len(results), 1)+ self.assertEqual(results[0].payload["user_id"], "alice")++ def test_search_with_no_filters(self):+ """Test search with no filters."""+ vectors = [[0.1, 0.2]]+ mock_point = MagicMock(id=str(uuid.uuid4()), score=0.95, payload={"key": "value"})+ self.client_mock.query_points.return_value = MagicMock(points=[mock_point])++ results = self.qdrant.search(query="", vectors=vectors, limit=1, filters=None)++ call_args = self.client_mock.query_points.call_args[1]+ self.assertIsNone(call_args["query_filter"])++ self.assertEqual(len(results), 1)++ def test_create_filter_multiple_filters(self):+ """Test _create_filter with multiple filters."""+ filters = {"user_id": "alice", "agent_id": "agent1", "run_id": "run1"}+ result = self.qdrant._create_filter(filters)++ self.assertIsInstance(result, Filter)+ self.assertEqual(len(result.must), 3)++ # Check that all conditions are present+ conditions = [cond.key for cond in result.must]+ self.assertIn("user_id", conditions)+ self.assertIn("agent_id", conditions)+ self.assertIn("run_id", conditions)++ def test_create_filter_single_filter(self):+ """Test _create_filter with single filter."""+ filters = {"user_id": "alice"}+ result = self.qdrant._create_filter(filters)++ self.assertIsInstance(result, Filter)+ self.assertEqual(len(result.must), 1)+ self.assertEqual(result.must[0].key, "user_id")+ self.assertEqual(result.must[0].match.value, "alice")++ def test_create_filter_no_filters(self):+ """Test _create_filter with no filters."""+ result = self.qdrant._create_filter(None)+ self.assertIsNone(result)++ result = self.qdrant._create_filter({})+ self.assertIsNone(result)++ def test_create_filter_with_range_values(self):+ """Test _create_filter with range values."""+ filters = {"user_id": "alice", "count": {"gte": 5, "lte": 10}}+ result = self.qdrant._create_filter(filters)++ self.assertIsInstance(result, Filter)+ self.assertEqual(len(result.must), 2)++ # Check that range condition is created+ range_conditions = [cond for cond in result.must if hasattr(cond, 'range') and cond.range is not None]+ self.assertEqual(len(range_conditions), 1)+ self.assertEqual(range_conditions[0].key, "count")++ # Check that string condition is created+ string_conditions = [cond for cond in result.must if hasattr(cond, 'match') and cond.match is not None]+ self.assertEqual(len(string_conditions), 1)+ self.assertEqual(string_conditions[0].key, "user_id")+def test_delete(self):vector_id = str(uuid.uuid4())self.qdrant.delete(vector_id=vector_id)@@ -103,6 +224,67 @@ class TestQdrant(unittest.TestCase):result = self.qdrant.list_cols()self.assertEqual(result.collections[0]["name"], "test_collection")+ def test_list_with_filters(self):+ """Test list with agent_id and run_id filters."""+ mock_point = MagicMock(+ id=str(uuid.uuid4()),+ score=0.95,+ payload={"user_id": "alice", "agent_id": "agent1", "run_id": "run1"}+ )+ self.client_mock.scroll.return_value = MagicMock(points=[mock_point])++ filters = {"user_id": "alice", "agent_id": "agent1", "run_id": "run1"}+ results = self.qdrant.list(filters=filters, limit=10)++ # Verify that _create_filter was called and scroll_filter was passed+ self.client_mock.scroll.assert_called_once()+ call_args = self.client_mock.scroll.call_args[1]+ self.assertEqual(call_args["collection_name"], "test_collection")+ self.assertEqual(call_args["limit"], 10)++ # Verify that a Filter object was created+ scroll_filter = call_args["scroll_filter"]+ self.assertIsInstance(scroll_filter, Filter)+ self.assertEqual(len(scroll_filter.must), 3) # user_id, agent_id, run_id++ self.assertEqual(len(results), 1)+ self.assertEqual(results[0].payload["user_id"], "alice")+ self.assertEqual(results[0].payload["agent_id"], "agent1")+ self.assertEqual(results[0].payload["run_id"], "run1")++ def test_list_with_single_filter(self):+ """Test list with single filter."""+ mock_point = MagicMock(+ id=str(uuid.uuid4()),+ score=0.95,+ payload={"user_id": "alice"}+ )+ self.client_mock.scroll.return_value = MagicMock(points=[mock_point])++ filters = {"user_id": "alice"}+ results = self.qdrant.list(filters=filters, limit=10)++ # Verify that a Filter object was created with single condition+ call_args = self.client_mock.scroll.call_args[1]+ scroll_filter = call_args["scroll_filter"]+ self.assertIsInstance(scroll_filter, Filter)+ self.assertEqual(len(scroll_filter.must), 1) # Only user_id++ self.assertEqual(len(results), 1)+ self.assertEqual(results[0].payload["user_id"], "alice")++ def test_list_with_no_filters(self):+ """Test list with no filters."""+ mock_point = MagicMock(id=str(uuid.uuid4()), score=0.95, payload={"key": "value"})+ self.client_mock.scroll.return_value = MagicMock(points=[mock_point])++ results = self.qdrant.list(filters=None, limit=10)++ call_args = self.client_mock.scroll.call_args[1]+ self.assertIsNone(call_args["scroll_filter"])++ self.assertEqual(len(results), 1)+def test_delete_col(self):self.qdrant.delete_col()self.client_mock.delete_collection.assert_called_once_with(collection_name="test_collection")