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

src/crewai/agent.py

@@ -222,11 +222,9 @@ class Agent(BaseAgent):
 
         memory_attributes = [
             "memory",
-            "memory_config",
             "_short_term_memory",
             "_long_term_memory",
             "_entity_memory",
-            "_user_memory",
             "_external_memory",
         ]
 
@@ -316,11 +314,9 @@ class Agent(BaseAgent):
 
             start_time = time.time()
             contextual_memory = ContextualMemory(
-                self.crew.memory_config,
                 self.crew._short_term_memory,
                 self.crew._long_term_memory,
                 self.crew._entity_memory,
-                self.crew._user_memory,
                 self.crew._external_memory,
             )
             memory = contextual_memory.build_context_for_task(task, context)

src/crewai/crew.py

@@ -47,7 +47,6 @@ from crewai.memory.entity.entity_memory import EntityMemory
 from crewai.memory.external.external_memory import ExternalMemory
 from crewai.memory.long_term.long_term_memory import LongTermMemory
 from crewai.memory.short_term.short_term_memory import ShortTermMemory
-from crewai.memory.user.user_memory import UserMemory
 from crewai.process import Process
 from crewai.security import Fingerprint, SecurityConfig
 from crewai.task import Task
@@ -95,7 +94,6 @@ class Crew(FlowTrackable, BaseModel):
         manager_llm: The language model that will run manager agent.
         manager_agent: Custom agent that will be used as manager.
         memory: Whether the crew should use memory to store memories of it's execution.
-        memory_config: Configuration for the memory to be used for the crew.
         cache: Whether the crew should use a cache to store the results of the tools execution.
         function_calling_llm: The language model that will run the tool calling for all the agents.
         process: The process flow that the crew will follow (e.g., sequential, hierarchical).
@@ -121,7 +119,6 @@ class Crew(FlowTrackable, BaseModel):
     _short_term_memory: Optional[InstanceOf[ShortTermMemory]] = PrivateAttr()
     _long_term_memory: Optional[InstanceOf[LongTermMemory]] = PrivateAttr()
     _entity_memory: Optional[InstanceOf[EntityMemory]] = PrivateAttr()
-    _user_memory: Optional[InstanceOf[UserMemory]] = PrivateAttr()
     _external_memory: Optional[InstanceOf[ExternalMemory]] = PrivateAttr()
     _train: Optional[bool] = PrivateAttr(default=False)
     _train_iteration: Optional[int] = PrivateAttr()
@@ -143,10 +140,6 @@ class Crew(FlowTrackable, BaseModel):
         default=False,
         description="Whether the crew should use memory to store memories of it's execution",
     )
-    memory_config: Optional[Dict[str, Any]] = Field(
-        default=None,
-        description="Configuration for the memory to be used for the crew.",
-    )
     short_term_memory: Optional[InstanceOf[ShortTermMemory]] = Field(
         default=None,
         description="An Instance of the ShortTermMemory to be used by the Crew",
@@ -159,10 +152,6 @@ class Crew(FlowTrackable, BaseModel):
         default=None,
         description="An Instance of the EntityMemory to be used by the Crew",
     )
-    user_memory: Optional[InstanceOf[UserMemory]] = Field(
-        default=None,
-        description="DEPRECATED: Will be removed in version 0.156.0 or on 2025-08-04, whichever comes first. Use external_memory instead.",
-    )
     external_memory: Optional[InstanceOf[ExternalMemory]] = Field(
         default=None,
         description="An Instance of the ExternalMemory to be used by the Crew",
@@ -291,20 +280,6 @@ class Crew(FlowTrackable, BaseModel):
 
         return self
 
-    def _initialize_user_memory(self):
-        if (
-            self.memory_config
-            and "user_memory" in self.memory_config
-            and self.memory_config.get("provider") == "mem0"
-        ):  # Check for user_memory in config
-            user_memory_config = self.memory_config["user_memory"]
-            if isinstance(
-                user_memory_config, dict
-            ):  # Check if it's a configuration dict
-                self._user_memory = UserMemory(crew=self)
-            else:
-                raise TypeError("user_memory must be a configuration dictionary")
-
     def _initialize_default_memories(self):
         self._long_term_memory = self._long_term_memory or LongTermMemory()
         self._short_term_memory = self._short_term_memory or ShortTermMemory(
@@ -327,12 +302,8 @@ class Crew(FlowTrackable, BaseModel):
         self._short_term_memory = self.short_term_memory
         self._entity_memory = self.entity_memory
 
-        # UserMemory will be removed in version 0.156.0 or on 2025-08-04, whichever comes first
-        self._user_memory = None
-
         if self.memory:
             self._initialize_default_memories()
-            self._initialize_user_memory()
 
         return self
 
@@ -1254,9 +1225,7 @@ class Crew(FlowTrackable, BaseModel):
             copied_data["entity_memory"] = self.entity_memory.model_copy(deep=True)
         if self.external_memory:
             copied_data["external_memory"] = self.external_memory.model_copy(deep=True)
-        if self.user_memory:
-            # DEPRECATED: UserMemory will be removed in version 0.156.0 or on 2025-08-04
-            copied_data["user_memory"] = self.user_memory.model_copy(deep=True)
+
 
         copied_data.pop("agents", None)
         copied_data.pop("tasks", None)

src/crewai/memory/__init__.py

@@ -1,11 +1,9 @@
 from .entity.entity_memory import EntityMemory
 from .long_term.long_term_memory import LongTermMemory
 from .short_term.short_term_memory import ShortTermMemory
-from .user.user_memory import UserMemory
 from .external.external_memory import ExternalMemory
 
 __all__ = [
-    "UserMemory",
     "EntityMemory",
     "LongTermMemory",
     "ShortTermMemory",

src/crewai/memory/contextual/contextual_memory.py

@@ -1,32 +1,24 @@
-from typing import Any, Dict, Optional
+from typing import Optional
 
 from crewai.memory import (
     EntityMemory,
     ExternalMemory,
     LongTermMemory,
     ShortTermMemory,
-    UserMemory,
 )
 
 
 class ContextualMemory:
     def __init__(
         self,
-        memory_config: Optional[Dict[str, Any]],
         stm: ShortTermMemory,
         ltm: LongTermMemory,
         em: EntityMemory,
-        um: UserMemory,
         exm: ExternalMemory,
     ):
-        if memory_config is not None:
-            self.memory_provider = memory_config.get("provider")
-        else:
-            self.memory_provider = None
         self.stm = stm
         self.ltm = ltm
         self.em = em
-        self.um = um
         self.exm = exm
 
     def build_context_for_task(self, task, context) -> str:
@@ -44,8 +36,6 @@ class ContextualMemory:
         context.append(self._fetch_stm_context(query))
         context.append(self._fetch_entity_context(query))
         context.append(self._fetch_external_context(query))
-        if self.memory_provider == "mem0":
-            context.append(self._fetch_user_context(query))
         return "\n".join(filter(None, context))
 
     def _fetch_stm_context(self, query) -> str:
@@ -60,7 +50,7 @@ class ContextualMemory:
         stm_results = self.stm.search(query)
         formatted_results = "\n".join(
             [
-                f"- {result['memory'] if self.memory_provider == 'mem0' else result['context']}"
+                f"- {result['context']}"
                 for result in stm_results
             ]
         )
@@ -100,34 +90,12 @@ class ContextualMemory:
         em_results = self.em.search(query)
         formatted_results = "\n".join(
             [
-                f"- {result['memory'] if self.memory_provider == 'mem0' else result['context']}"
+                f"- {result['context']}"
                 for result in em_results
             ]  # type: ignore #  Invalid index type "str" for "str"; expected type "SupportsIndex | slice"
         )
         return f"Entities:\n{formatted_results}" if em_results else ""
 
-    def _fetch_user_context(self, query: str) -> str:
-        """
-        DEPRECATED: Will be removed in version 0.156.0 or on 2025-08-04, whichever comes first.
-        Fetches and formats relevant user information from User Memory.
-        Args:
-            query (str): The search query to find relevant user memories.
-        Returns:
-            str: Formatted user memories as bullet points, or an empty string if none found.
-        """
-
-        if self.um is None:
-            return ""
-
-        user_memories = self.um.search(query)
-        if not user_memories:
-            return ""
-
-        formatted_memories = "\n".join(
-            f"- {result['memory']}" for result in user_memories
-        )
-        return f"User memories/preferences:\n{formatted_memories}"
-
     def _fetch_external_context(self, query: str) -> str:
         """
         Fetches and formats relevant information from External Memory.
@@ -145,6 +113,6 @@ class ContextualMemory:
             return ""
 
         formatted_memories = "\n".join(
-            f"- {result['memory']}" for result in external_memories
+            f"- {result['context']}" for result in external_memories
         )
         return f"External memories:\n{formatted_memories}"

src/crewai/memory/entity/entity_memory.py

@@ -27,11 +27,7 @@ class EntityMemory(Memory):
     _memory_provider: Optional[str] = PrivateAttr()
 
     def __init__(self, crew=None, embedder_config=None, storage=None, path=None):
-        if crew and hasattr(crew, "memory_config") and crew.memory_config is not None:
-            memory_provider = crew.memory_config.get("provider")
-        else:
-            memory_provider = None
-
+        memory_provider = embedder_config.get("provider") if embedder_config else None
         if memory_provider == "mem0":
             try:
                 from crewai.memory.storage.mem0_storage import Mem0Storage
@@ -39,7 +35,8 @@ class EntityMemory(Memory):
                 raise ImportError(
                     "Mem0 is not installed. Please install it with `pip install mem0ai`."
                 )
-            storage = Mem0Storage(type="entities", crew=crew)
+            config = embedder_config.get("config")
+            storage = Mem0Storage(type="short_term", crew=crew, config=config)
         else:
             storage = (
                 storage

src/crewai/memory/short_term/short_term_memory.py

@@ -29,11 +29,7 @@ class ShortTermMemory(Memory):
     _memory_provider: Optional[str] = PrivateAttr()
 
     def __init__(self, crew=None, embedder_config=None, storage=None, path=None):
-        if crew and hasattr(crew, "memory_config") and crew.memory_config is not None:
-            memory_provider = crew.memory_config.get("provider")
-        else:
-            memory_provider = None
-
+        memory_provider = embedder_config.get("provider") if embedder_config else None
         if memory_provider == "mem0":
             try:
                 from crewai.memory.storage.mem0_storage import Mem0Storage
@@ -41,7 +37,8 @@ class ShortTermMemory(Memory):
                 raise ImportError(
                     "Mem0 is not installed. Please install it with `pip install mem0ai`."
                 )
-            storage = Mem0Storage(type="short_term", crew=crew)
+            config = embedder_config.get("config")
+            storage = Mem0Storage(type="short_term", crew=crew, config=config)
         else:
             storage = (
                 storage

src/crewai/memory/storage/mem0_storage.py

@@ -19,32 +19,24 @@ class Mem0Storage(Storage):
         self._validate_type(type)
         self.memory_type = type
         self.crew = crew
+        self.config = config or {}
 
-        # TODO: Memory config will be removed in the future the config will be passed as a parameter
-        self.config = config or getattr(crew, "memory_config", {}).get("config", {}) or {}
-
-        self._validate_user_id()
         self._extract_config_values()
         self._initialize_memory()
 
     def _validate_type(self, type):
-        supported_types = {"user", "short_term", "long_term", "entities", "external"}
+        supported_types = {"short_term", "long_term", "entities", "external"}
         if type not in supported_types:
             raise ValueError(
                 f"Invalid type '{type}' for Mem0Storage. Must be one of: {', '.join(supported_types)}"
             )
 
-    def _validate_user_id(self):
-        if self.memory_type == "user" and not self.config.get("user_id", ""):
-            raise ValueError("User ID is required for user memory type")
-
     def _extract_config_values(self):
-        cfg = self.config
-        self.mem0_run_id = cfg.get("run_id")
-        self.includes = cfg.get("includes")
-        self.excludes = cfg.get("excludes")
-        self.custom_categories = cfg.get("custom_categories")
-        self.infer = cfg.get("infer", True)
+        self.mem0_run_id = self.config.get("run_id")
+        self.includes = self.config.get("includes")
+        self.excludes = self.config.get("excludes")
+        self.custom_categories = self.config.get("custom_categories")
+        self.infer = self.config.get("infer", True)
 
     def _initialize_memory(self):
         api_key = self.config.get("api_key") or os.getenv("MEM0_API_KEY")
@@ -164,6 +156,11 @@ class Mem0Storage(Storage):
                 del params["run_id"]
 
         results = self.memory.search(**params)
+
+        # This makes it compatible for Contextual Memory to retrieve
+        for result in results["results"]:
+            result["context"] = result["memory"]
+        
         return [r for r in results["results"]]
 
     def reset(self):

src/crewai/memory/user/user_memory.py

@@ -1,59 +0,0 @@
-import warnings
-from typing import Any, Dict, Optional
-
-from crewai.memory.memory import Memory
-
-
-class UserMemory(Memory):
-    """
-    UserMemory class for handling user memory storage and retrieval.
-    Inherits from the Memory class and utilizes an instance of a class that
-    adheres to the Storage for data storage, specifically working with
-    MemoryItem instances.
-    """
-
-    def __init__(self, crew=None):
-        warnings.warn(
-            "UserMemory is deprecated and will be removed in version 0.156.0 "
-            "or on 2025-08-04, whichever comes first. "
-            "Please use ExternalMemory instead.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        try:
-            from crewai.memory.storage.mem0_storage import Mem0Storage
-        except ImportError:
-            raise ImportError(
-                "Mem0 is not installed. Please install it with `pip install mem0ai`."
-            )
-        storage = Mem0Storage(type="user", crew=crew)
-        super().__init__(storage)
-
-    def save(
-        self,
-        value,
-        metadata: Optional[Dict[str, Any]] = None,
-        agent: Optional[str] = None,
-    ) -> None:
-        # TODO: Change this function since we want to take care of the case where we save memories for the usr
-        data = f"Remember the details about the user: {value}"
-        super().save(data, metadata)
-
-    def search(
-        self,
-        query: str,
-        limit: int = 3,
-        score_threshold: float = 0.35,
-    ):
-        results = self.storage.search(
-            query=query,
-            limit=limit,
-            score_threshold=score_threshold,
-        )
-        return results
-
-    def reset(self) -> None:
-        try:
-            self.storage.reset()
-        except Exception as e:
-            raise Exception(f"An error occurred while resetting the user memory: {e}")

src/crewai/memory/user/user_memory_item.py

@@ -1,16 +0,0 @@
-import warnings
-from typing import Any, Dict, Optional
-
-
-class UserMemoryItem:
-    def __init__(self, data: Any, user: str, metadata: Optional[Dict[str, Any]] = None):
-        warnings.warn(
-            "UserMemoryItem is deprecated and will be removed in version 0.156.0 "
-            "or on 2025-08-04, whichever comes first. "
-            "Please use ExternalMemory instead.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        self.data = data
-        self.user = user
-        self.metadata = metadata if metadata is not None else {}