Skip to content

armgit / camel

Public Imported from GitHub
0

🐫 CAMEL: The first and the best multi-agent framework. Finding the Scaling Law of Agents. https://www.camel-ai.org

mem0 api v2 update (#2959)

Parth Sharmaf032eec606a3
diff --git a/camel/storages/key_value_storages/mem0_cloud.py b/camel/storages/key_value_storages/mem0_cloud.py
index e5fc0cdf0..36b0302df 100644
--- a/camel/storages/key_value_storages/mem0_cloud.py
+++ b/camel/storages/key_value_storages/mem0_cloud.py
@@ -136,6 +136,7 @@ class Mem0Storage(BaseKeyValueStorage):
agent_id=self.agent_id,
user_id=self.user_id,
metadata=self.metadata,
+ version="v2",
)
self.client.add(messages, **options)
except Exception as e:
@@ -149,32 +150,31 @@ class Mem0Storage(BaseKeyValueStorage):
represents a stored record.
"""
try:
- # Build kwargs for get_all
- kwargs = {}
+ # Build filters for get_all using proper Mem0 filter format
+ filters = {}
if self.agent_id:
- kwargs['agent_id'] = self.agent_id
+ filters = {"AND": [{"user_id": self.agent_id}]}
if self.user_id:
- kwargs['user_id'] = self.user_id
-
- # If no filters available, return empty list
- if not kwargs:
- return []
+ filters = {"AND": [{"user_id": self.user_id}]}
- results = self.client.get_all(**kwargs)
+ results = self.client.get_all(version="v2", filters=filters)
# Transform results into MemoryRecord objects
transformed_results = []
for result in results:
+ # Ensure metadata is a dictionary, not None
+ metadata = result.get("metadata") or {}
+
memory_record = MemoryRecord(
uuid=UUID(result["id"]),
message=BaseMessage(
role_name="memory",
role_type=RoleType.USER,
- meta_dict=result.get("metadata", {}),
+ meta_dict=metadata,
content=result["memory"],
),
role_at_backend=OpenAIBackendRole.USER,
- extra_info=result.get("metadata", {}),
+ extra_info=metadata,
timestamp=datetime.fromisoformat(
result["created_at"].replace('Z', '+00:00')
).timestamp(),
diff --git a/test/storages/key_value_storages/test_mem0_cloud.py b/test/storages/key_value_storages/test_mem0_cloud.py
index ae4018fb5..2365cb8ef 100644
--- a/test/storages/key_value_storages/test_mem0_cloud.py
+++ b/test/storages/key_value_storages/test_mem0_cloud.py
@@ -110,14 +110,14 @@ class TestMem0Storage(unittest.TestCase):
"id": "123e4567-e89b-12d3-a456-426614174000",
"memory": "test memory 1",
"metadata": {"key1": "value1"},
- "created_at": "2023-01-01T00:00:00",
+ "created_at": "2023-01-01T00:00:00Z",
"agent_id": self.agent_id,
},
{
"id": "123e4567-e89b-12d3-a456-426614174001",
"memory": "test memory 2",
- "metadata": {"key2": "value2"},
- "created_at": "2023-01-02T00:00:00",
+ "metadata": None, # Test None metadata handling
+ "created_at": "2023-01-02T00:00:00Z",
"agent_id": self.agent_id,
},
]
@@ -126,8 +126,14 @@ class TestMem0Storage(unittest.TestCase):
# Call load method
results = self.storage.load()
- # Verify client.get_all was called
+ # Verify client.get_all was called with proper filter format
self.mock_mem0_client.get_all.assert_called_once()
+ args, kwargs = self.mock_mem0_client.get_all.call_args
+
+ # Check that filters are in proper Mem0 format
+ expected_filters = {"AND": [{"user_id": self.user_id}]}
+ self.assertEqual(kwargs.get("filters"), expected_filters)
+ self.assertEqual(kwargs.get("version"), "v2")
# Check that results were transformed correctly
self.assertEqual(len(results), 2)
@@ -145,6 +151,15 @@ class TestMem0Storage(unittest.TestCase):
result["message"]["content"], mock_results[idx]["memory"]
)
+ # Verify metadata handling (should be dict, not None)
+ self.assertIsInstance(result["extra_info"], dict)
+ if idx == 0:
+ self.assertEqual(result["extra_info"], {"key1": "value1"})
+ else:
+ self.assertEqual(
+ result["extra_info"], {}
+ ) # None should become empty dict
+
def test_clear(self):
r"""Test clearing all records from Mem0 storage."""
# Call clear method
@@ -226,6 +241,123 @@ class TestMem0Storage(unittest.TestCase):
self.assertEqual(messages, expected_messages)
+ def test_load_with_only_agent_id(self):
+ r"""Test loading records when only agent_id is set (no user_id)."""
+ # Create storage with only agent_id
+ storage = Mem0Storage(api_key=self.api_key, agent_id=self.agent_id)
+
+ mock_results = [
+ {
+ "id": "123e4567-e89b-12d3-a456-426614174000",
+ "memory": "test memory",
+ "metadata": {"key1": "value1"},
+ "created_at": "2023-01-01T00:00:00Z",
+ "agent_id": self.agent_id,
+ }
+ ]
+ self.mock_mem0_client.get_all.return_value = mock_results
+
+ storage.load()
+
+ # Verify client.get_all was called with agent_id filter
+ self.mock_mem0_client.get_all.assert_called_once()
+ args, kwargs = self.mock_mem0_client.get_all.call_args
+
+ expected_filters = {"AND": [{"user_id": self.agent_id}]}
+ self.assertEqual(kwargs.get("filters"), expected_filters)
+
+ def test_load_with_no_filters(self):
+ r"""Test loading records when neither agent_id nor user_id is set."""
+ # Create storage with no agent_id or user_id
+ storage = Mem0Storage(api_key=self.api_key, agent_id=None)
+
+ # Mock empty results from the API
+ self.mock_mem0_client.get_all.return_value = []
+
+ results = storage.load()
+
+ # Should return empty list when no filters are available
+ self.assertEqual(results, [])
+ # Client should be called with empty filters
+ self.mock_mem0_client.get_all.assert_called_once()
+ args, kwargs = self.mock_mem0_client.get_all.call_args
+ self.assertEqual(kwargs.get("filters"), {})
+ self.assertEqual(kwargs.get("version"), "v2")
+
+ def test_load_with_both_agent_and_user_id(self):
+ r"""Test loading records when both agent_id and user_id are set."""
+ # Create storage with both agent_id and user_id
+ storage = Mem0Storage(
+ api_key=self.api_key, agent_id=self.agent_id, user_id=self.user_id
+ )
+
+ mock_results = [
+ {
+ "id": "123e4567-e89b-12d3-a456-426614174000",
+ "memory": "test memory",
+ "metadata": {"key1": "value1"},
+ "created_at": "2023-01-01T00:00:00Z",
+ "agent_id": self.agent_id,
+ }
+ ]
+ self.mock_mem0_client.get_all.return_value = mock_results
+
+ storage.load()
+
+ # Verify client.get_all was called with both filters
+ self.mock_mem0_client.get_all.assert_called_once()
+ args, kwargs = self.mock_mem0_client.get_all.call_args
+
+ # Should use user_id filter (as per current implementation)
+ expected_filters = {"AND": [{"user_id": self.user_id}]}
+ self.assertEqual(kwargs.get("filters"), expected_filters)
+
+ def test_load_with_none_metadata(self):
+ r"""Test loading records with None metadata values."""
+ mock_results = [
+ {
+ "id": "123e4567-e89b-12d3-a456-426614174000",
+ "memory": "test memory",
+ "metadata": None, # Explicitly None
+ "created_at": "2023-01-01T00:00:00Z",
+ "agent_id": self.agent_id,
+ }
+ ]
+ self.mock_mem0_client.get_all.return_value = mock_results
+
+ results = self.storage.load()
+
+ # Should handle None metadata gracefully
+ self.assertEqual(len(results), 1)
+ result = results[0]
+ self.assertIsInstance(result["extra_info"], dict)
+ self.assertEqual(
+ result["extra_info"], {}
+ ) # None should become empty dict
+
+ def test_load_with_missing_metadata_key(self):
+ r"""Test loading records with missing metadata key."""
+ mock_results = [
+ {
+ "id": "123e4567-e89b-12d3-a456-426614174000",
+ "memory": "test memory",
+ # No metadata key at all
+ "created_at": "2023-01-01T00:00:00Z",
+ "agent_id": self.agent_id,
+ }
+ ]
+ self.mock_mem0_client.get_all.return_value = mock_results
+
+ results = self.storage.load()
+
+ # Should handle missing metadata gracefully
+ self.assertEqual(len(results), 1)
+ result = results[0]
+ self.assertIsInstance(result["extra_info"], dict)
+ self.assertEqual(
+ result["extra_info"], {}
+ ) # Missing key should become empty dict
+
@pytest.mark.skip(
reason="Integration test is flaky due to API timing/behavior"
)
diff --git a/test/toolkits/test_file_write_toolkit.py b/test/toolkits/test_file_write_toolkit.py
index 929079c30..96a7f079d 100644
--- a/test/toolkits/test_file_write_toolkit.py
+++ b/test/toolkits/test_file_write_toolkit.py
@@ -201,7 +201,8 @@ def test_write_to_file_csv_list(file_write_toolkit):
def test_write_to_file_html(file_write_toolkit):
r"""Test writing HTML content to a file."""
- content = "<html><body><h1>Hello, world!</h1></body></html>"
+ content = '<head>\n <meta charset="utf-8"><body><h1>Hello, '
+ 'world!</h1></body></html>'
filename = "test.html"
result = file_write_toolkit.write_to_file(