Update

Author: dirkbrnd

libs/agno/agno/agent/agent.py

@@ -5282,7 +5282,7 @@ def get_relevant_docs_from_knowledge(
         """
         from agno.document import Document
 
-        if num_documents is None:
+        if num_documents is None and self.knowledge is not None:
             num_documents = self.knowledge.num_documents
         # Validate the filters against known valid filter keys
         if self.knowledge is not None:
@@ -5343,7 +5343,7 @@ async def aget_relevant_docs_from_knowledge(
         """Get relevant documents from knowledge base asynchronously."""
         from agno.document import Document
 
-        if num_documents is None:
+        if num_documents is None and self.knowledge is not None:
             num_documents = self.knowledge.num_documents
 
         # Validate the filters against known valid filter keys

libs/agno/agno/embedder/openai.py

@@ -30,7 +30,6 @@ def __post_init__(self):
         if self.dimensions is None:
             self.dimensions = 3072 if self.id == "text-embedding-3-large" else 1536
 
-
     @property
     def client(self) -> OpenAIClient:
         if self.openai_client:

libs/agno/agno/team/team.py

@@ -7372,7 +7372,7 @@ def get_relevant_docs_from_knowledge(
         """Return a list of references from the knowledge base"""
         from agno.document import Document
 
-        if num_documents is None:
+        if num_documents is None and self.knowledge is not None:
             num_documents = self.knowledge.num_documents
 
         # Validate the filters against known valid filter keys
@@ -7429,7 +7429,7 @@ async def aget_relevant_docs_from_knowledge(
         """Get relevant documents from knowledge base asynchronously."""
         from agno.document import Document
 
-        if num_documents is None:
+        if num_documents is None and self.knowledge is not None:
             num_documents = self.knowledge.num_documents
 
         # Validate the filters against known valid filter keys

libs/agno/agno/tools/zep.py

@@ -118,7 +118,7 @@ def initialize(self) -> bool:
 
             # Create session associated with the user
             try:
-                self.zep_client.memory.add_session(session_id=self.session_id, user_id=self.user_id)
+                self.zep_client.thread.create(thread_id=self.session_id, user_id=self.user_id)
                 log_debug(f"Created session {self.session_id} for user {self.user_id}")
             except Exception as e:
                 log_debug(f"Session may already exist: {e}")
@@ -156,8 +156,8 @@ def add_zep_message(self, role: str, content: str) -> str:
             ignore_roles_list = ["assistant"] if self.ignore_assistant_messages else None
 
             # Add message to Zep memory
-            self.zep_client.memory.add(  # type: ignore
-                session_id=self.session_id,
+            self.zep_client.thread.add_messages(  # type: ignore
+                thread_id=self.session_id,
                 messages=[zep_message],
                 ignore_roles=ignore_roles_list,
             )
@@ -171,7 +171,7 @@ def get_zep_memory(self, memory_type: str = "context") -> str:
         """
         Retrieves the memory for the current Zep session.
         Args:
-            memory_type: The type of memory to retrieve ('context', 'messages', 'relevant_facts').
+            memory_type: The type of memory to retrieve ('context', 'messages').
         Returns:
             The requested memory content as a string, or an error string.
         """
@@ -181,21 +181,16 @@ def get_zep_memory(self, memory_type: str = "context") -> str:
 
         try:
             log_debug(f"Getting Zep memory for session {self.session_id}")
-            memory_data = self.zep_client.memory.get(session_id=self.session_id)  # type: ignore
 
             if memory_type == "context":
                 # Ensure context is a string
-                return memory_data.context or "No context available."
+                user_context = self.zep_client.thread.get_user_context(thread_id=self.session_id, mode="basic")  # type: ignore
+                log_debug(f"Memory data: {user_context}")
+                return user_context.context or "No context available."
             elif memory_type == "messages":
+                messages_list = self.zep_client.thread.get(thread_id=self.session_id)  # type: ignore
                 # Ensure messages string representation is returned
-                return str(memory_data.messages) if memory_data.messages else "No messages available."
-            elif memory_type == "relevant_facts":
-                # Return all relevant facts from memory
-                if memory_data.relevant_facts:
-                    facts_str = "\n".join([f"- {fact.fact}" for fact in memory_data.relevant_facts])
-                    return f"Relevant facts:\n{facts_str}"
-                else:
-                    return "No relevant facts available."
+                return str(messages_list.messages) if messages_list.messages else "No messages available."
             else:
                 warning_msg = f"Unsupported memory_type requested: {memory_type}. Returning empty string."
                 log_warning(warning_msg)
@@ -328,7 +323,7 @@ async def initialize(self) -> bool:
 
             # Create session associated with the user
             try:
-                await self.zep_client.memory.add_session(session_id=self.session_id, user_id=self.user_id)  # type: ignore
+                await self.zep_client.thread.create(thread_id=self.session_id, user_id=self.user_id)  # type: ignore
                 log_debug(f"Created session {self.session_id} for user {self.user_id}")
             except Exception as e:
                 log_debug(f"Session may already exist: {e}")
@@ -369,8 +364,8 @@ async def add_zep_message(self, role: str, content: str) -> str:
             ignore_roles_list = ["assistant"] if self.ignore_assistant_messages else None
 
             # Add message to Zep memory
-            await self.zep_client.memory.add(  # type: ignore
-                session_id=self.session_id,
+            await self.zep_client.thread.add_messages(  # type: ignore
+                thread_id=self.session_id,
                 messages=[zep_message],
                 ignore_roles=ignore_roles_list,
             )
@@ -384,7 +379,7 @@ async def get_zep_memory(self, memory_type: str = "context") -> str:
         """
         Retrieves the memory for the current Zep session.
         Args:
-            memory_type: The type of memory to retrieve ('context', 'messages', 'relevant_facts').
+            memory_type: The type of memory to retrieve ('context', 'messages').
         Returns:
             The requested memory content as a string, or an error string.
         """
@@ -396,25 +391,19 @@ async def get_zep_memory(self, memory_type: str = "context") -> str:
             return "Error: Zep client/session not initialized."
 
         try:
-            memory_data = await self.zep_client.memory.get(session_id=self.session_id)  # type: ignore
-
             if memory_type == "context":
                 # Ensure context is a string
-                return memory_data.context or "No context available."
+                user_context = await self.zep_client.thread.get_user_context(thread_id=self.session_id, mode="basic")  # type: ignore
+                log_debug(f"Memory data: {user_context}")
+                return user_context.context or "No context available."
             elif memory_type == "messages":
                 # Ensure messages string representation is returned
-                return str(memory_data.messages) if memory_data.messages else "No messages available."
-            elif memory_type == "relevant_facts":
-                # Return relevant facts from memory
-                if memory_data.relevant_facts:
-                    facts_str = "\n".join([f"- {fact.fact}" for fact in memory_data.relevant_facts])
-                    return f"Relevant facts:\n{facts_str}"
-                else:
-                    return "No relevant facts available."
+                messages_list = await self.zep_client.thread.get(thread_id=self.session_id)  # type: ignore
+                return str(messages_list.messages) if messages_list.messages else "No messages available."
             else:
                 warning_msg = f"Unsupported memory_type requested: {memory_type}. Returning context."
                 log_warning(warning_msg)
-                return memory_data.context or "No context available."
+                return "No context available."
 
         except Exception as e:
             error_msg = f"Failed to get Zep memory for session {self.session_id}: {e}"

libs/agno/tests/unit/tools/test_zep.py

@@ -49,10 +49,10 @@ def test_initialization_no_api_key(monkeypatch):
 def test_add_zep_message(zep_tools):
     result = zep_tools.add_zep_message(role="user", content="test message")
     assert result == f"Message from 'user' added successfully to session {MOCK_SESSION_ID}."
-    zep_tools.zep_client.memory.add.assert_called_once()
+    zep_tools.zep_client.thread.add_messages.assert_called_once()
 
     # Check that ZepMessage was created with correct parameters
-    call_args = zep_tools.zep_client.memory.add.call_args
+    call_args = zep_tools.zep_client.thread.add_messages.call_args
     messages = call_args[1]["messages"]
     assert len(messages) == 1
     assert messages[0].role == "user"
@@ -71,40 +71,26 @@ def test_get_zep_memory_context(zep_tools):
     mock_memory.context = "test context"
     mock_memory.relevant_facts = None
     mock_memory.messages = None
-    zep_tools.zep_client.memory.get.return_value = mock_memory
+    zep_tools.zep_client.thread.get_user_context.return_value = mock_memory
 
     result = zep_tools.get_zep_memory("context")
     assert result == "test context"
-    zep_tools.zep_client.memory.get.assert_called_once()
+    zep_tools.zep_client.thread.get_user_context.assert_called_once()
 
 
 def test_get_zep_memory_messages(zep_tools):
     mock_memory = Mock()
     mock_memory.messages = ["msg1", "msg2"]
-    zep_tools.zep_client.memory.get.return_value = mock_memory
+    zep_tools.zep_client.thread.get.return_value = mock_memory
 
     result = zep_tools.get_zep_memory("messages")
     assert result == "['msg1', 'msg2']"
 
 
-def test_get_zep_memory_relevant_facts(zep_tools):
-    mock_fact1 = Mock()
-    mock_fact1.fact = "fact 1"
-    mock_fact2 = Mock()
-    mock_fact2.fact = "fact 2"
-
-    mock_memory = Mock()
-    mock_memory.relevant_facts = [mock_fact1, mock_fact2]
-    zep_tools.zep_client.memory.get.return_value = mock_memory
-
-    result = zep_tools.get_zep_memory("relevant_facts")
-    assert result == "Relevant facts:\n- fact 1\n- fact 2"
-
-
 def test_get_zep_memory_unsupported_type(zep_tools):
     mock_memory = Mock()
     mock_memory.context = "fallback context"
-    zep_tools.zep_client.memory.get.return_value = mock_memory
+    zep_tools.zep_client.thread.get_user_context.return_value = mock_memory
 
     result = zep_tools.get_zep_memory("unsupported")
     assert "Unsupported memory_type requested: unsupported" in result
@@ -207,10 +193,10 @@ async def test_async_initialization(async_zep_tools):
 async def test_async_add_zep_message(async_zep_tools):
     result = await async_zep_tools.add_zep_message(role="user", content="test message")
     assert result == f"Message from 'user' added successfully to session {MOCK_SESSION_ID}."
-    async_zep_tools.zep_client.memory.add.assert_called_once()
+    async_zep_tools.zep_client.thread.add_messages.assert_called_once()
 
     # Check that ZepMessage was created with correct parameters
-    call_args = async_zep_tools.zep_client.memory.add.call_args
+    call_args = async_zep_tools.zep_client.thread.add_messages.call_args
     messages = call_args[1]["messages"]
     assert len(messages) == 1
     assert messages[0].role == "user"
@@ -221,11 +207,11 @@ async def test_async_add_zep_message(async_zep_tools):
 async def test_async_get_zep_memory(async_zep_tools):
     mock_memory = Mock()
     mock_memory.context = "test context"
-    async_zep_tools.zep_client.memory.get.return_value = mock_memory
+    async_zep_tools.zep_client.thread.get_user_context.return_value = mock_memory
 
     result = await async_zep_tools.get_zep_memory()
     assert result == "test context"
-    async_zep_tools.zep_client.memory.get.assert_called_once()
+    async_zep_tools.zep_client.thread.get_user_context.assert_called_once()
 
 
 @pytest.mark.asyncio