haystack-experimental 0.15.2__py3-none-any.whl → 0.17.0__py3-none-any.whl

haystack_experimental/memory_stores/mem0/memory_store.py

@@ -0,0 +1,323 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Any
+
+from haystack import default_from_dict, default_to_dict, logging
+from haystack.dataclasses.chat_message import ChatMessage
+from haystack.lazy_imports import LazyImport
+from haystack.utils import Secret, deserialize_secrets_inplace
+
+with LazyImport(message="Run 'pip install mem0ai'") as mem0_import:
+    from mem0 import MemoryClient  # pylint: disable=import-error
+
+logger = logging.getLogger(__name__)
+
+
+class Mem0MemoryStore:
+    """
+    A memory store implementation using Mem0 as the backend.
+    """
+
+    def __init__(
+        self,
+        *,
+        api_key: Secret = Secret.from_env_var("MEM0_API_KEY"),
+    ):
+        """
+        Initialize the Mem0 memory store.
+
+        :param api_key: The Mem0 API key. You can also set it using `MEM0_API_KEY` environment variable.
+        """
+
+        mem0_import.check()
+        self.api_key = api_key
+        self.client = MemoryClient(
+            api_key=self.api_key.resolve_value(),
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        """Serialize the store configuration to a dictionary."""
+        return default_to_dict(
+            self,
+            api_key=self.api_key.to_dict(),
+        )
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "Mem0MemoryStore":
+        """Deserialize the store from a dictionary."""
+        deserialize_secrets_inplace(data["init_parameters"], keys=["api_key"])
+
+        return default_from_dict(cls, data)
+
+    def add_memories(
+        self,
+        *,
+        messages: list[ChatMessage],
+        infer: bool = True,
+        user_id: str | None = None,
+        run_id: str | None = None,
+        agent_id: str | None = None,
+        async_mode: bool = False,
+        **kwargs: Any,
+    ) -> list[dict[str, Any]]:
+        """
+        Add ChatMessage memories to Mem0.
+
+        :param messages: List of ChatMessage objects with memory metadata
+        :param infer: Whether to infer facts from the messages. If False, the whole message will
+            be added as a memory.
+        :param user_id: The user ID to to store and retrieve memories from the memory store.
+        :param run_id: The run ID to to store and retrieve memories from the memory store.
+        :param agent_id: The agent ID to to store and retrieve memories from the memory store.
+            If you want Mem0 to store chat messages from the assistant, you need to set the agent_id.
+        :param async_mode: Whether to add memories asynchronously.
+            If True, the method will return immediately and the memories will be added in the background.
+        :param kwargs: Additional keyword arguments to pass to the Mem0 client.add method.
+            Note: ChatMessage.meta in the list of messages will be ignored because Mem0 doesn't allow
+            passing metadata for each message in the list. You can pass metadata for the whole memory
+            by passing the `metadata` keyword argument to the method.
+        :returns: List of objects with the memory_id and the memory
+        """
+        added_ids = []
+        ids = self._get_ids(user_id, run_id, agent_id)
+        instructions = """
+        Store all memories from the user and suggestions from the assistant.
+        """
+
+        self.client.project.update(custom_instructions=instructions)
+        mem0_messages = []
+        for message in messages:
+            if not message.text:
+                continue
+            # we save the role of the message in the metadata
+            mem0_messages.append({"content": message.text, "role": message.role.value})
+        try:
+            status = self.client.add(messages=mem0_messages, infer=infer, **ids, async_mode=async_mode, **kwargs)
+            if status:
+                for result in status["results"]:
+                    memory_id = {"memory_id": result.get("id"), "memory": result["memory"]}
+                    added_ids.append(memory_id)
+        except Exception as e:
+            raise RuntimeError(f"Failed to add memory message: {e}") from e
+        return added_ids
+
+    def search_memories(
+        self,
+        *,
+        query: str | None = None,
+        filters: dict[str, Any] | None = None,
+        top_k: int = 5,
+        user_id: str | None = None,
+        run_id: str | None = None,
+        agent_id: str | None = None,
+        include_memory_metadata: bool = False,
+        **kwargs: Any,
+    ) -> list[ChatMessage]:
+        """
+        Search for memories in Mem0.
+
+        If filters are not provided, at least one of user_id, run_id, or agent_id must be set.
+        If filters are provided, the search will be scoped to the provided filters and the other ids will be ignored.
+        :param query: Text query to search for. If not provided, all memories will be returned.
+        :param filters: Haystack filters to apply on search. For more details on Haystack filters, see https://docs.haystack.deepset.ai/docs/metadata-filtering
+        :param top_k: Maximum number of results to return
+        :param user_id: The user ID to to store and retrieve memories from the memory store.
+        :param run_id: The run ID to to store and retrieve memories from the memory store.
+        :param agent_id: The agent ID to to store and retrieve memories from the memory store.
+            If you want Mem0 to store chat messages from the assistant, you need to set the agent_id.
+        :param include_memory_metadata: Whether to include the mem0 related metadata for the
+            retrieved memory in the ChatMessage.
+            If True, the metadata will include the mem0 related metadata i.e. memory_id, score, etc.
+            in the `mem0_memory_metadata` key.
+            If False, the `ChatMessage.meta` will only contain the user defined metadata.
+        :param kwargs: Additional keyword arguments to pass to the Mem0 client.
+            If query is passed, the kwargs will be passed to the Mem0 client.search method.
+            If query is not passed, the kwargs will be passed to the Mem0 client.get_all method.
+        :returns: List of ChatMessage memories matching the criteria
+        """
+        # Prepare filters for Mem0
+
+        if filters:
+            mem0_filters = self.normalize_filters(filters)
+        else:
+            ids = self._get_ids(user_id, run_id, agent_id)
+            if len(ids) == 1:
+                mem0_filters = dict(ids)
+            else:
+                mem0_filters = {"AND": [{key: value} for key, value in ids.items()]}
+        try:
+            if not query:
+                memories = self.client.get_all(filters=mem0_filters, **kwargs)
+            else:
+                memories = self.client.search(
+                    query=query,
+                    top_k=top_k,
+                    filters=mem0_filters,
+                    **kwargs,
+                )
+            messages = []
+            for memory in memories["results"]:
+                meta = memory["metadata"].copy() if memory["metadata"] else {}
+                # we also include the mem0 related metadata i.e. memory_id, score, etc.
+                if include_memory_metadata:
+                    meta["retrieved_memory_metadata"] = memory.copy()
+                    meta["retrieved_memory_metadata"].pop("memory")
+                messages.append(ChatMessage.from_system(text=memory["memory"], meta=meta))
+            return messages
+
+        except Exception as e:
+            raise RuntimeError(f"Failed to search memories: {e}") from e
+
+    def search_memories_as_single_message(
+        self,
+        *,
+        query: str | None = None,
+        filters: dict[str, Any] | None = None,
+        top_k: int = 5,
+        user_id: str | None = None,
+        run_id: str | None = None,
+        agent_id: str | None = None,
+        **kwargs: Any,
+    ) -> ChatMessage:
+        """
+        Search for memories in Mem0 and return a single ChatMessage object.
+
+        If filters are not provided, at least one of user_id, run_id, or agent_id must be set.
+        If filters are provided, the search will be scoped to the provided filters and the other ids will be ignored.
+        :param query: Text query to search for. If not provided, all memories will be returned.
+        :param filters: Additional filters to apply on search. For more details on mem0 filters, see https://mem0.ai/docs/search/
+        :param top_k: Maximum number of results to return
+        :param user_id: The user ID to to store and retrieve memories from the memory store.
+        :param run_id: The run ID to to store and retrieve memories from the memory store.
+        :param agent_id: The agent ID to to store and retrieve memories from the memory store.
+            If you want Mem0 to store chat messages from the assistant, you need to set the agent_id.
+        :param kwargs: Additional keyword arguments to pass to the Mem0 client.
+            If query is passed, the kwargs will be passed to the Mem0 client.search method.
+            If query is not passed, the kwargs will be passed to the Mem0 client.get_all method.
+        :returns: A single ChatMessage object with the memories matching the criteria
+        """
+        # Prepare filters for Mem0
+        if filters:
+            mem0_filters = self.normalize_filters(filters)
+        else:
+            ids = self._get_ids(user_id, run_id, agent_id)
+            if len(ids) == 1:
+                mem0_filters = dict(ids)
+            else:
+                mem0_filters = {"AND": [{key: value} for key, value in ids.items()]}
+
+        try:
+            if not query:
+                memories = self.client.get_all(filters=mem0_filters, **kwargs)
+            else:
+                memories = self.client.search(
+                    query=query,
+                    top_k=top_k,
+                    filters=mem0_filters,
+                    **kwargs,
+                )
+
+            # we combine the memories into a single string
+            combined_memory = "\n".join(
+                f"- MEMORY #{idx + 1}: {memory['memory']}" for idx, memory in enumerate(memories["results"])
+            )
+
+            return ChatMessage.from_system(text=combined_memory)
+
+        except Exception as e:
+            raise RuntimeError(f"Failed to search memories: {e}") from e
+
+    def delete_all_memories(
+        self,
+        *,
+        user_id: str | None = None,
+        run_id: str | None = None,
+        agent_id: str | None = None,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Delete memory records from Mem0.
+
+        At least one of user_id, run_id, or agent_id must be set.
+        :param user_id: The user ID to delete memories from.
+        :param run_id: The run ID to delete memories from.
+        :param agent_id: The agent ID to delete memories from.
+        :param kwargs: Additional keyword arguments to pass to the Mem0 client.delete_all method.
+        """
+        ids = self._get_ids(user_id, run_id, agent_id)
+
+        try:
+            self.client.delete_all(**ids, **kwargs)
+            logger.info("All memories deleted successfully for scope {ids}", ids=ids)
+        except Exception as e:
+            raise RuntimeError(f"Failed to delete memories with scope {ids}: {e}") from e
+
+    def delete_memory(self, memory_id: str, **kwargs: Any) -> None:
+        """
+        Delete memory from Mem0.
+
+        :param memory_id: The ID of the memory to delete.
+        :param kwargs: Additional keyword arguments to pass to the Mem0 client.delete method.
+        """
+        try:
+            self.client.delete(memory_id=memory_id, **kwargs)
+            logger.info("Memory deleted successfully for memory_id {memory_id}", memory_id=memory_id)
+        except Exception as e:
+            raise RuntimeError(f"Failed to delete memory {memory_id}: {e}") from e
+
+    def _get_ids(
+        self, user_id: str | None = None, run_id: str | None = None, agent_id: str | None = None
+    ) -> dict[str, Any]:
+        """
+        Check that at least one of the ids is set.
+
+        Return the set ids as a dictionary.
+        """
+        if not user_id and not run_id and not agent_id:
+            raise ValueError("At least one of user_id, run_id, or agent_id must be set")
+        ids = {
+            "user_id": user_id,
+            "run_id": run_id,
+            "agent_id": agent_id,
+        }
+        return {key: value for key, value in ids.items() if value is not None}
+
+    @staticmethod
+    def normalize_filters(filters: dict[str, Any]) -> dict[str, Any]:
+        """
+        Convert Haystack filters to Mem0 filters.
+        """
+
+        def convert_comparison(condition: dict[str, Any]) -> dict[str, Any]:
+            operator_map = {
+                "==": lambda field, value: {field: value},
+                "!=": lambda field, value: {field: {"ne": value}},
+                ">": lambda field, value: {field: {"gt": value}},
+                ">=": lambda field, value: {field: {"gte": value}},
+                "<": lambda field, value: {field: {"lt": value}},
+                "<=": lambda field, value: {field: {"lte": value}},
+                "in": lambda field, value: {field: {"in": value if isinstance(value, list) else [value]}},
+                "not in": lambda field, value: {field: {"ne": value}},
+            }
+            field = condition["field"]
+            value = condition["value"]
+            operator = condition["operator"]
+            if operator not in operator_map:
+                raise ValueError(f"Unsupported operator {operator}")
+            return operator_map[operator](field, value)
+
+        def convert_logic(node: dict[str, Any]) -> dict[str, Any]:
+            operator = node["operator"].upper()
+            if operator not in ("AND", "OR", "NOT"):
+                raise ValueError(f"Unsupported logic operator {operator}")
+            mem0_conditions = [convert_node(cond) for cond in node["conditions"]]
+            return {operator: mem0_conditions}
+
+        def convert_node(node: dict[str, Any]) -> dict[str, Any]:
+            if "field" in node:
+                return convert_comparison(node)
+            return convert_logic(node)
+
+        return convert_node(filters)

haystack_experimental/memory_stores/types/__init__.py

@@ -0,0 +1,7 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from .protocol import MemoryStore
+
+__all__ = ["MemoryStore"]

haystack_experimental/memory_stores/types/protocol.py

@@ -0,0 +1,94 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Any, Protocol
+
+from haystack.dataclasses import ChatMessage
+
+# Ellipsis are needed for the type checker, it's safe to disable module-wide
+# pylint: disable=unnecessary-ellipsis
+
+
+class MemoryStore(Protocol):
+    """
+    Stores ChatMessage-based memories to be used by agents and components.
+
+    Implementations typically persist user- and agent-specific memories and
+    support adding, searching, and deleting memories.
+    """
+
+    def to_dict(self) -> dict[str, Any]:
+        """
+        Serializes this memory store to a dictionary.
+        """
+        ...
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "MemoryStore":
+        """
+        Deserializes the memory store from a dictionary.
+        """
+        ...
+
+    def add_memories(
+        self,
+        *,
+        messages: list[ChatMessage],
+        user_id: str | None = None,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Add ChatMessage memories to the store.
+
+        :param messages: List of ChatMessage objects with memory metadata.
+        :param user_id: User ID to scope memories.
+        :param kwargs: Additional keyword arguments to pass to the add method.
+        """
+        ...
+
+    def search_memories(
+        self,
+        *,
+        query: str | None = None,
+        filters: dict[str, Any] | None = None,
+        top_k: int = 5,
+        user_id: str | None = None,
+        **kwargs: Any,
+    ) -> list[ChatMessage]:
+        """
+        Search for memories in the store.
+
+        :param query: Text query to search for. If not provided, all memories may be returned.
+        :param filters: Haystack filters to apply on search.
+        :param top_k: Maximum number of results to return.
+        :param user_id: User ID to scope memories.
+        :param kwargs: Additional keyword arguments to pass to the search method.
+
+        :returns: List of ChatMessage memories matching the criteria.
+        """
+        ...
+
+    def delete_all_memories(
+        self,
+        *,
+        user_id: str | None = None,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Delete all memories in the given scope.
+
+        In case of multiple optional ids, one of the ids must be set.
+        :param user_id: User ID to delete memories.
+        :param kwargs: Additional keyword arguments to pass to the delete method.
+        """
+        ...
+
+    def delete_memory(self, memory_id: str, **kwargs: Any) -> None:
+        """
+        Delete a single memory by its ID.
+
+        :param memory_id: The ID of the memory to delete.
+        :param kwargs: Additional keyword arguments to pass to the delete method.
+        """
+        ...

haystack_experimental/utils/hallucination_risk_calculator/dataclasses.py

@@ -3,7 +3,7 @@
 # Modified by deepset, 2025.
 # Licensed under the Apache License, Version 2.0 (see LICENSE-APACHE).
 from dataclasses import dataclass
-from typing import Literal, Optional
+from typing import Literal
 
 
 @dataclass
@@ -51,13 +51,13 @@ class OpenAIItem:
     prompt: str
     n_samples: int = 3
     m: int = 6
-    seeds: Optional[list[int]] = None
-    fields_to_erase: Optional[list[str]] = None  # evidence-based mode
+    seeds: list[int] | None = None
+    fields_to_erase: list[str] | None = None  # evidence-based mode
     mask_token: str = "[…]"
     skeleton_policy: Literal["auto", "evidence_erase", "closed_book"] = "auto"
-    attempted: Optional[bool] = None
-    answered_correctly: Optional[bool] = None
-    meta: Optional[dict] = None
+    attempted: bool | None = None
+    answered_correctly: bool | None = None
+    meta: dict | None = None
 
 
 @dataclass
@@ -71,6 +71,6 @@ class ItemMetrics:
     roh_bound: float
     decision_answer: bool
     rationale: str
-    attempted: Optional[bool] = None
-    answered_correctly: Optional[bool] = None
-    meta: Optional[dict] = None
+    attempted: bool | None = None
+    answered_correctly: bool | None = None
+    meta: dict | None = None

haystack_experimental/utils/hallucination_risk_calculator/openai_planner.py

@@ -5,7 +5,7 @@
 import json
 import re
 import time
-from typing import Any, Optional, Sequence, Union
+from typing import Any, Sequence
 
 from haystack.components.generators.chat.openai import OpenAIChatGenerator
 from openai.types.chat import ChatCompletionSystemMessageParam, ChatCompletionUserMessageParam
@@ -24,7 +24,7 @@ _DECISION_ALLOWED = ("answer", "refuse")
 
 def _decision_messages_closed_book(
     user_prompt: str,
-) -> list[Union[ChatCompletionSystemMessageParam, ChatCompletionUserMessageParam]]:
+) -> list[ChatCompletionSystemMessageParam | ChatCompletionUserMessageParam]:
     system = (
         "You are a safety-critical QA assistant operating **without external evidence**. "
         "Decide whether to answer based on your pretrained knowledge and the prompt alone. "
@@ -36,7 +36,7 @@ def _decision_messages_closed_book(
 
 def _decision_messages_evidence(
     user_prompt: str,
-) -> list[Union[ChatCompletionSystemMessageParam, ChatCompletionUserMessageParam]]:
+) -> list[ChatCompletionSystemMessageParam | ChatCompletionUserMessageParam]:
     system = (
         "You are a safety-critical QA assistant. Decide whether to answer based on the "
         "provided prompt and its internal evidence/context. If evidence is insufficient or "
@@ -160,7 +160,7 @@ class OpenAIPlanner:
         backend: OpenAIChatGenerator,
         temperature: float = 0.5,
         max_tokens_decision: int = 8,
-        q_floor: Optional[float] = None,
+        q_floor: float | None = None,
     ) -> None:
         """
         Initialize OpenAIPlanner with given parameters.

haystack_experimental/utils/hallucination_risk_calculator/skeletonization.py

@@ -4,7 +4,7 @@
 # Licensed under the Apache License, Version 2.0 (see LICENSE-APACHE).
 import random
 import re
-from typing import Optional, Sequence
+from typing import Sequence
 
 _ERASE_DEFAULT_FIELDS = ["Evidence", "Context", "Citations", "References", "Notes", "Passage", "Snippet"]
 
@@ -14,7 +14,7 @@ _NUMBER = re.compile(r"\b\d+(?:\.\d+)?\b")
 _QUOTED = re.compile(r"([“\"'])(.+?)\1")
 
 
-def _skeletonize_prompt(text: str, fields_to_erase: Optional[Sequence[str]] = None, mask_token: str = "[…]") -> str:
+def _skeletonize_prompt(text: str, fields_to_erase: Sequence[str] | None = None, mask_token: str = "[…]") -> str:
     fields = list(fields_to_erase) if fields_to_erase else list(_ERASE_DEFAULT_FIELDS)
     out = text
     for field in fields:
@@ -105,7 +105,7 @@ def _make_skeletons_evidence_erase(
     text: str,
     m: int,
     seeds: Sequence[int],
-    fields_to_erase: Optional[Sequence[str]] = None,
+    fields_to_erase: Sequence[str] | None = None,
     mask_token: str = "[…]",
     preserve_roles: bool = True,
 ) -> list[str]:
@@ -130,8 +130,8 @@ def _make_skeleton_ensemble_auto(
     *,
     text: str,
     m: int = 6,
-    seeds: Optional[Sequence[int]] = None,
-    fields_to_erase: Optional[Sequence[str]] = None,
+    seeds: Sequence[int] | None = None,
+    fields_to_erase: Sequence[str] | None = None,
     mask_token: str = "[…]",
     skeleton_policy: str = "auto",
 ) -> list[str]:

{haystack_experimental-0.15.2.dist-info → haystack_experimental-0.17.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: haystack-experimental
-Version: 0.15.2
+Version: 0.17.0
 Summary: Experimental components and features for the Haystack LLM framework.
 Project-URL: CI: GitHub, https://github.com/deepset-ai/haystack-experimental/actions
 Project-URL: GitHub: issues, https://github.com/deepset-ai/haystack-experimental/issues
@@ -17,15 +17,13 @@ Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Requires-Dist: haystack-ai
-Requires-Dist: lazy-imports<1.2.0
 Requires-Dist: rich
 Description-Content-Type: text/markdown
 
@@ -74,19 +72,17 @@ that includes it. Once it reaches the end of its lifespan, the experiment will b
 
 | Name                                                                                                                                                                                    | Type                                  | Expected End Date | Dependencies | Cookbook                                                                                                                                                                                                                                                   | Discussion    |
 |-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------|-------------------|--------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------|
-| [`EmbeddingBasedDocumentSplitter`][8]                                                                                                                                                   | EmbeddingBasedDocumentSplitter        | August 2025       | None         | None                                                                                                                                                                                                                                                       | [Discuss][7]  |
 | [`OpenAIChatGenerator`][9]                                                                                                                                                              | Chat Generator Component              | November 2025     | None         | <a href="https://colab.research.google.com/github/deepset-ai/haystack-cookbook/blob/main/notebooks/hallucination_score_calculator.ipynb" target="_parent"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/>        | [Discuss][10] |
 | [`MarkdownHeaderLevelInferrer`][15]                                                                                                                                                     | Preprocessor                          | January 2025      | None         | None                                                                                                                                                                                                                                                       | [Discuss][16] |
 | [`Agent`][17]; [Confirmation Policies][18]; [ConfirmationUIs][19]; [ConfirmationStrategies][20]; [`ConfirmationUIResult` and `ToolExecutionDecision`][21] [HITLBreakpointException][22] | Human in the Loop                     | December 2025     | rich         | None                                                                                                                                                                                                                                                       | [Discuss][23] |
 | [`LLMSummarizer`][24]                                                                                                                                                                   | Document Summarizer                   | January 2025      | None         | None                                                                                                                                                                                                                                                       | [Discuss][25] |
 | [`InMemoryChatMessageStore`][1]; [`ChatMessageRetriever`][2]; [`ChatMessageWriter`][3]                                                                                                  | Chat Message Store, Retriever, Writer | February 2025     | None         | <a href="https://colab.research.google.com/github/deepset-ai/haystack-cookbook/blob/main/notebooks/conversational_rag_using_memory.ipynb" target="_parent"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/>       | [Discuss][4]  |
+| [`Mem0MemoryStore`][26]                                                                                                                                                                   | MemoryStore                   | February 2025      | mem0ai         | None                                                                                                                                                                                                                                                       | -- |
 
 [1]: https://github.com/deepset-ai/haystack-experimental/blob/main/haystack_experimental/chat_message_stores/in_memory.py
 [2]: https://github.com/deepset-ai/haystack-experimental/blob/main/haystack_experimental/components/retrievers/chat_message_retriever.py
 [3]: https://github.com/deepset-ai/haystack-experimental/blob/main/haystack_experimental/components/writers/chat_message_writer.py
 [4]: https://github.com/deepset-ai/haystack-experimental/discussions/75
-[7]: https://github.com/deepset-ai/haystack-experimental/discussions/356
-[8]: https://github.com/deepset-ai/haystack-experimental/blob/main/haystack_experimental/components/preprocessors/embedding_based_document_splitter.py
 [9]: https://github.com/deepset-ai/haystack-experimental/blob/main/haystack_experimental/components/generators/chat/openai.py
 [10]: https://github.com/deepset-ai/haystack-experimental/discussions/361
 [15]: https://github.com/deepset-ai/haystack-experimental/blob/main/haystack_experimental/components/preprocessors/md_header_level_inferrer.py  
@@ -100,6 +96,7 @@ that includes it. Once it reaches the end of its lifespan, the experiment will b
 [23]: https://github.com/deepset-ai/haystack-experimental/discussions/381
 [24]: https://github.com/deepset-ai/haystack-experimental/blob/main/haystack_experimental/components/sumarizers/llm_summarizer.py
 [25]: https://github.com/deepset-ai/haystack-experimental/discussions/382
+[26]: https://github.com/deepset-ai/haystack-experimental/blob/main/haystack_experimental/memory_stores/mem0/memory_store.py
 
 ### Adopted experiments
 | Name                                                                                                                                                                                                                                       | Type                                     | Final release |
@@ -112,10 +109,10 @@ that includes it. Once it reaches the end of its lifespan, the experiment will b
 | `SuperComponent`                                                                                                                                                                                                                           | Simplify Pipeline development            | 0.8.0         |
 | `Pipeline`                                                                                                                                                                                                                                 | Pipeline breakpoints for debugging       | 0.12.0        |
 | `ImageContent`; Image Converters; multimodal support in `OpenAIChatGenerator` and `AmazonBedrockChatGenerator`; `ChatPromptBuilder` refactoring; `SentenceTransformersDocumentImageEmbedder`; `LLMDocumentContentExtractor`; new `Routers` | Multimodality                            | 0.12.0        |
-| `QueryExpander`                                                                                                                                                                                                                            | Query Expansion Component                | 0.14.3       |
-| `MultiQueryEmbeddingRetriever`                                                                                                                                                                                                             | MultiQueryEmbeddingRetriever             | 0.14.3       |
-| `MultiQueryTextRetriever`                                                                                                                                                                                                                  | MultiQueryTextRetriever                  | 0.14.3       |
-
+| `QueryExpander`                                                                                                                                                                                                                            | Query Expansion Component                | 0.14.3        |
+| `MultiQueryEmbeddingRetriever`                                                                                                                                                                                                             | MultiQueryEmbeddingRetriever             | 0.14.3        |
+| `MultiQueryTextRetriever`                                                                                                                                                                                                                  | MultiQueryTextRetriever                  | 0.14.3        |
+| `EmbeddingBasedDocumentSplitter`                                                                                                                                                                                                             | Document Splitting                       | 0.15.2        |
 
 ### Discontinued experiments