Dropping User Memory (#3225)

* Dropping User Memory

* Dropping checks for user memory

* changed memory.mdx documentation removed user memory.

* Flaky Test Case Maybe

* Drop memory_config

* Fixed test cases

* Fixed some test cases

* Changed docs

* Changed BR docs

* Docs fixing

* Fix minor doc

* Fix minor doc

* Fix minor doc

* Added fallback mechanism in Mem0

tests/crew_test.py

@@ -4475,7 +4475,7 @@ def test_crew_copy_with_memory():
     )
     original_entity_id = id(crew._entity_memory) if crew._entity_memory else None
     original_external_id = id(crew._external_memory) if crew._external_memory else None
-    original_user_id = id(crew._user_memory) if crew._user_memory else None
+
 
     try:
         crew_copy = crew.copy()
@@ -4526,20 +4526,6 @@ def test_crew_copy_with_memory():
                 or crew_copy._external_memory is None
             ), "Copied _external_memory should be None if not originally present"
 
-        if original_user_id:
-            assert hasattr(
-                crew_copy, "_user_memory"
-            ), "Copied crew should have _user_memory"
-            assert (
-                crew_copy._user_memory is not None
-            ), "Copied _user_memory should not be None"
-            assert (
-                id(crew_copy._user_memory) != original_user_id
-            ), "Copied _user_memory should be a new object"
-        else:
-            assert (
-                not hasattr(crew_copy, "_user_memory") or crew_copy._user_memory is None
-            ), "Copied _user_memory should be None if not originally present"
 
     except pydantic_core.ValidationError as e:
         if "Input should be an instance of" in str(e) and ("Memory" in str(e)):

tests/memory/user_memory_test.py

@@ -1,67 +0,0 @@
-from unittest.mock import MagicMock, patch
-
-import pytest
-from mem0.memory.main import Memory
-
-from crewai.memory.user.user_memory import UserMemory
-from crewai.memory.user.user_memory_item import UserMemoryItem
-
-
-class MockCrew:
-    def __init__(self, memory_config):
-        self.memory_config = memory_config
-
-@pytest.fixture
-def user_memory():
-    """Fixture to create a UserMemory instance"""
-    crew = MockCrew(
-        memory_config={
-            "provider": "mem0",
-            "config": {"user_id": "john"},
-            "user_memory" : {}
-        }
-    )
-
-    user_memory = MagicMock(spec=UserMemory)
-
-    with patch.object(Memory,'__new__',return_value=user_memory):
-        user_memory_instance = UserMemory(crew=crew)
-    
-    return user_memory_instance
-
-def test_save_and_search(user_memory):
-    memory = UserMemoryItem(
-        data="""test value test value test value test value test value test value
-        test value test value test value test value test value test value
-        test value test value test value test value test value test value""",
-        user="test_user",
-        metadata={"task": "test_task"},
-    )
-
-    with patch.object(UserMemory, "save") as mock_save:
-        user_memory.save(
-            value=memory.data,
-            metadata=memory.metadata,
-            user=memory.user
-        )
-
-        mock_save.assert_called_once_with(
-            value=memory.data,
-            metadata=memory.metadata,
-            user=memory.user
-        )
-
-    expected_result = [
-        {
-            "context": memory.data,
-            "metadata": {"agent": "test_agent"},
-            "score": 0.95,
-        }
-    ]
-    expected_result = ["mocked_result"]
-
-    # Use patch.object to mock UserMemory's search method
-    with patch.object(UserMemory, 'search', return_value=expected_result) as mock_search:
-        find = UserMemory.search("test value", score_threshold=0.01)[0]
-        mock_search.assert_called_once_with("test value", score_threshold=0.01)
-        assert find == expected_result[0]

tests/storage/test_mem0_storage.py

@@ -9,8 +9,7 @@ from crewai.memory.storage.mem0_storage import Mem0Storage
 
 # Define the class (if not already defined)
 class MockCrew:
-    def __init__(self, memory_config):
-        self.memory_config = memory_config
+    def __init__(self):
         self.agents = [MagicMock(role="Test Agent")]
 
 
@@ -54,16 +53,12 @@ def mem0_storage_with_mocked_config(mock_mem0_memory):
             "custom_update_memory_prompt": "mock prompt 2",
         }
 
-        # Instantiate the class with memory_config
         # Parameters like run_id, includes, and excludes doesn't matter in Memory OSS
-        crew = MockCrew(
-            memory_config={
-                "provider": "mem0",
-                "config": {"user_id": "test_user", "local_mem0_config": config, "run_id": "my_run_id", "includes": "include1","excludes": "exclude1", "infer" : True},
-            }
-        )
+        crew = MockCrew()
 
-        mem0_storage = Mem0Storage(type="short_term", crew=crew)
+        embedder_config={"user_id": "test_user", "local_mem0_config": config, "run_id": "my_run_id", "includes": "include1","excludes": "exclude1", "infer" : True}
+
+        mem0_storage = Mem0Storage(type="short_term", crew=crew, config=embedder_config)
         return mem0_storage, mock_from_config, config
 
 
@@ -88,10 +83,9 @@ def mem0_storage_with_memory_client_using_config_from_crew(mock_mem0_memory_clie
 
     # We need to patch the MemoryClient before it's instantiated
     with patch.object(MemoryClient, "__new__", return_value=mock_mem0_memory_client):
-        crew = MockCrew(
-            memory_config={
-                "provider": "mem0",
-                "config": {
+        crew = MockCrew()
+
+        embedder_config={
                     "user_id": "test_user",
                     "api_key": "ABCDEFGH",
                     "org_id": "my_org_id",
@@ -100,11 +94,9 @@ def mem0_storage_with_memory_client_using_config_from_crew(mock_mem0_memory_clie
                     "includes": "include1",
                     "excludes": "exclude1",
                     "infer": True
-                },
-            }
-        )
+                }
 
-        mem0_storage = Mem0Storage(type="short_term", crew=crew)
+        mem0_storage = Mem0Storage(type="short_term", crew=crew, config=embedder_config)
         return mem0_storage
 
 
@@ -116,18 +108,7 @@ def mem0_storage_with_memory_client_using_explictly_config(mock_mem0_memory_clie
     with patch.object(MemoryClient, "__new__", return_value=mock_mem0_memory_client), \
          patch.object(Memory, "__new__", return_value=mock_mem0_memory):
 
-        crew = MockCrew(
-            memory_config={
-                "provider": "mem0",
-                "config": {
-                    "user_id": "test_user",
-                    "api_key": "ABCDEFGH",
-                    "org_id": "my_org_id",
-                    "project_id": "my_project_id",
-                },
-            }
-        )
-
+        crew = MockCrew()
         new_config = {"provider": "mem0", "config": {"api_key": "new-api-key"}}
 
         mem0_storage = Mem0Storage(type="short_term", crew=crew, config=new_config)
@@ -164,21 +145,18 @@ def test_mem0_storage_updates_project_with_custom_categories(mock_mem0_memory_cl
     {"lifestyle_management_concerns": "Tracks daily routines, habits, hobbies and interests including cooking, time management and work-life balance"},
     ]
 
-    crew = MockCrew(
-        memory_config={
-            "provider": "mem0",
-            "config": {
-                "user_id": "test_user",
-                "api_key": "ABCDEFGH",
-                "org_id": "my_org_id",
-                "project_id": "my_project_id",
-                "custom_categories": new_categories,
-            },
+    crew = MockCrew()
+
+    config={
+            "user_id": "test_user",
+            "api_key": "ABCDEFGH",
+            "org_id": "my_org_id",
+            "project_id": "my_project_id",
+            "custom_categories": new_categories
         }
-    )
 
     with patch.object(MemoryClient, "__new__", return_value=mock_mem0_memory_client):
-        _ = Mem0Storage(type="short_term", crew=crew)
+        _ = Mem0Storage(type="short_term", crew=crew, config=config)
 
     mock_mem0_memory_client.update_project.assert_called_once_with(
         custom_categories=new_categories
@@ -255,7 +233,7 @@ def test_save_method_with_memory_client(mem0_storage_with_memory_client_using_co
 def test_search_method_with_memory_oss(mem0_storage_with_mocked_config):
     """Test search method for different memory types"""
     mem0_storage, _, _ = mem0_storage_with_mocked_config
-    mock_results = {"results": [{"score": 0.9, "content": "Result 1"}, {"score": 0.4, "content": "Result 2"}]}
+    mock_results = {"results": [{"score": 0.9, "memory": "Result 1"}, {"score": 0.4, "memory": "Result 2"}]}
     mem0_storage.memory.search = MagicMock(return_value=mock_results)
 
     results = mem0_storage.search("test query", limit=5, score_threshold=0.5)
@@ -269,13 +247,13 @@ def test_search_method_with_memory_oss(mem0_storage_with_mocked_config):
     )
 
     assert len(results) == 2
-    assert results[0]["content"] == "Result 1"
+    assert results[0]["context"] == "Result 1"
 
 
 def test_search_method_with_memory_client(mem0_storage_with_memory_client_using_config_from_crew):
     """Test search method for different memory types"""
     mem0_storage = mem0_storage_with_memory_client_using_config_from_crew
-    mock_results = {"results": [{"score": 0.9, "content": "Result 1"}, {"score": 0.4, "content": "Result 2"}]}
+    mock_results = {"results": [{"score": 0.9, "memory": "Result 1"}, {"score": 0.4, "memory": "Result 2"}]}
     mem0_storage.memory.search = MagicMock(return_value=mock_results)
 
     results = mem0_storage.search("test query", limit=5, score_threshold=0.5)
@@ -293,23 +271,20 @@ def test_search_method_with_memory_client(mem0_storage_with_memory_client_using_
     )
 
     assert len(results) == 2
-    assert results[0]["content"] == "Result 1"
+    assert results[0]["context"] == "Result 1"
 
 
 def test_mem0_storage_default_infer_value(mock_mem0_memory_client):
     """Test that Mem0Storage sets infer=True by default for short_term memory."""
     with patch.object(MemoryClient, "__new__", return_value=mock_mem0_memory_client):
-        crew = MockCrew(
-            memory_config={
-                "provider": "mem0",
-                "config": {
-                    "user_id": "test_user",
-                    "api_key": "ABCDEFGH"
-                },
-            }
-        )
+        crew = MockCrew()
 
-        mem0_storage = Mem0Storage(type="short_term", crew=crew)
+        config={
+                "user_id": "test_user",
+                "api_key": "ABCDEFGH"
+            }
+
+        mem0_storage = Mem0Storage(type="short_term", crew=crew, config=config)
         assert mem0_storage.infer is True
 
 def test_save_memory_using_agent_entity(mock_mem0_memory_client):
@@ -329,37 +304,47 @@ def test_save_memory_using_agent_entity(mock_mem0_memory_client):
         )
 
 def test_search_method_with_agent_entity():
-    mem0_storage = Mem0Storage(type="external", config={"agent_id": "agent-123"})
-    mock_results = {"results": [{"score": 0.9, "content": "Result 1"}, {"score": 0.4, "content": "Result 2"}]}
-    mem0_storage.memory.search = MagicMock(return_value=mock_results)
+    config = {
+        "agent_id": "agent-123",
+    }
 
-    results = mem0_storage.search("test query", limit=5, score_threshold=0.5)
+    mock_memory = MagicMock(spec=Memory)
+    mock_results = {"results": [{"score": 0.9, "memory": "Result 1"}, {"score": 0.4, "memory": "Result 2"}]}
 
-    mem0_storage.memory.search.assert_called_once_with(
+    with patch.object(Memory, "__new__", return_value=mock_memory):
+        mem0_storage = Mem0Storage(type="external", config=config)
+
+        mem0_storage.memory.search = MagicMock(return_value=mock_results)
+        results = mem0_storage.search("test query", limit=5, score_threshold=0.5)
+
+        mem0_storage.memory.search.assert_called_once_with(
         query="test query",
         limit=5,
         filters={"AND": [{"agent_id": "agent-123"}]},
         threshold=0.5,
     )
 
-    assert len(results) == 2
-    assert results[0]["content"] == "Result 1"
+        assert len(results) == 2
+        assert results[0]["context"] == "Result 1"
 
 
 def test_search_method_with_agent_id_and_user_id():
-    mem0_storage = Mem0Storage(type="external", config={"agent_id": "agent-123", "user_id": "user-123"})
-    mock_results = {"results": [{"score": 0.9, "content": "Result 1"}, {"score": 0.4, "content": "Result 2"}]}
-    mem0_storage.memory.search = MagicMock(return_value=mock_results)
+    mock_memory = MagicMock(spec=Memory)
+    mock_results = {"results": [{"score": 0.9, "memory": "Result 1"}, {"score": 0.4, "memory": "Result 2"}]}
 
-    results = mem0_storage.search("test query", limit=5, score_threshold=0.5)
+    with patch.object(Memory, "__new__", return_value=mock_memory):
+        mem0_storage = Mem0Storage(type="external", config={"agent_id": "agent-123", "user_id": "user-123"})
 
-    mem0_storage.memory.search.assert_called_once_with(
-        query="test query",
-        limit=5,
-        user_id='user-123',
-        filters={"OR": [{"user_id": "user-123"}, {"agent_id": "agent-123"}]},
-        threshold=0.5,
-    )
+        mem0_storage.memory.search = MagicMock(return_value=mock_results)
+        results = mem0_storage.search("test query", limit=5, score_threshold=0.5)
 
-    assert len(results) == 2
-    assert results[0]["content"] == "Result 1"
+        mem0_storage.memory.search.assert_called_once_with(
+            query="test query",
+            limit=5,
+            user_id='user-123',
+            filters={"OR": [{"user_id": "user-123"}, {"agent_id": "agent-123"}]},
+            threshold=0.5,
+        )
+
+        assert len(results) == 2
+        assert results[0]["context"] == "Result 1"