MemoryOS 0.2.1__py3-none-any.whl → 0.2.2__py3-none-any.whl

memos/memories/textual/general.py

@@ -12,6 +12,7 @@ from memos.llms.factory import AzureLLM, LLMFactory, OllamaLLM, OpenAILLM
 from memos.log import get_logger
 from memos.memories.textual.base import BaseTextMemory
 from memos.memories.textual.item import TextualMemoryItem
+from memos.templates.mem_reader_prompts import SIMPLE_STRUCT_MEM_READER_PROMPT
 from memos.types import MessageList
 from memos.vec_dbs.factory import QdrantVecDB, VecDBFactory
 from memos.vec_dbs.item import VecDBItem
@@ -36,11 +37,7 @@ class GeneralTextMemory(BaseTextMemory):
         stop=stop_after_attempt(3),
         retry=retry_if_exception_type(json.JSONDecodeError),
         before_sleep=lambda retry_state: logger.warning(
-            EXTRACTION_RETRY_LOG.format(
-                error=retry_state.outcome.exception(),
-                attempt_number=retry_state.attempt_number,
-                max_attempt_number=3,
-            )
+            f"Extracting memory failed due to JSON decode error: {retry_state.outcome.exception()}, Attempt retry: {retry_state.attempt_number} / {3}"
         ),
     )
     def extract(self, messages: MessageList) -> list[TextualMemoryItem]:
@@ -52,14 +49,27 @@ class GeneralTextMemory(BaseTextMemory):
         Returns:
             List of TextualMemoryItem objects representing the extracted memories.
         """
-        str_messages = json.dumps(messages)
-        user_query = EXTRACTION_PROMPT_PART_1 + EXTRACTION_PROMPT_PART_2.format(
-            messages=str_messages
+
+        str_messages = "\n".join(
+            [message["role"] + ":" + message["content"] for message in messages]
         )
-        response = self.extractor_llm.generate([{"role": "user", "content": user_query}])
-        raw_extracted_memories = json.loads(response)
+
+        prompt = SIMPLE_STRUCT_MEM_READER_PROMPT.replace("${conversation}", str_messages)
+        messages = [{"role": "user", "content": prompt}]
+        response_text = self.extractor_llm.generate(messages)
+        response_json = self.parse_json_result(response_text)
+
         extracted_memories = [
-            TextualMemoryItem(**memory_dict) for memory_dict in raw_extracted_memories
+            TextualMemoryItem(
+                memory=memory_dict["value"],
+                metadata={
+                    "key": memory_dict["key"],
+                    "source": "conversation",
+                    "tags": memory_dict["tags"],
+                    "updated_at": datetime.now().isoformat(),
+                },
+            )
+            for memory_dict in response_json["memory list"]
         ]
 
         return extracted_memories
@@ -206,83 +216,17 @@ class GeneralTextMemory(BaseTextMemory):
         """Embed a single sentence."""
         return self.embedder.embed([sentence])[0]
 
-
-EXTRACTION_PROMPT_PART_1 = f"""You are a memory extractor. Your task is to extract memories from the given messages.
-* You will receive a list of messages, each with a role (user or assistant) and content.
-* Your job is to extract memories related to the user's long-term goals, interests, and emotional states.
-* Each memory should be a dictionary with the following keys:
-    - "memory": The content of the memory (string). Rephrase the content if necessary.
-    - "metadata": A dictionary containing additional information about the memory.
-* The metadata dictionary should include:
-    - "type": The type of memory (string), e.g., "procedure", "fact", "event", "opinion", etc.
-    - "memory_time": The time the memory occurred or refers to (string). Must be in standard `YYYY-MM-DD` format. Relative expressions such as "yesterday" or "tomorrow" are not allowed.
-    - "source": The origin of the memory (string), e.g., `"conversation"`, `"retrieved"`, `"web"`, `"file"`.
-    - "confidence": A numeric score (float between 0 and 100) indicating how certain you are about the accuracy or reliability of the memory.
-    - "entities": A list of key entities (array of strings) mentioned in the memory, e.g., people, places, organizations, e.g., `["Alice", "Paris", "OpenAI"]`.
-    - "tags": A list of keywords or thematic labels (array of strings) associated with the memory for categorization or retrieval, e.g., `["travel", "health", "project-x"]`.
-    - "visibility": The accessibility scope of the memory (string), e.g., `"private"`, `"public"`, `"session"`, determining who or what contexts can access it.
-    - "updated_at": The timestamp of the last modification to the memory (string). Useful for tracking memory freshness or change history. Format: ISO 8601 or natural language.
-* Current date and time is {datetime.now().isoformat()}.
-* Only return the list of memories in JSON format.
-* Do not include any explanations
-* Do not include any extra text
-* Do not include code blocks (```json```)
-
-## Example
-
-### Input
-
-[
-    {{"role": "user", "content": "I plan to visit Paris next week."}},
-    {{"role": "assistant", "content": "Paris is a beautiful city with many attractions."}},
-    {{"role": "user", "content": "I love the Eiffel Tower."}},
-    {{"role": "assistant", "content": "The Eiffel Tower is a must-see landmark in Paris."}}
-]
-
-### Output
-
-[
-  {{
-    "memory": "The user plans to visit Paris on 05-26-2025.",
-    "metadata": {{
-      "type": "event",
-      "memory_time": "2025-05-26",
-      "source": "conversation",
-      "confidence": 90.0,
-      "entities": ["Paris"],
-      "tags": ["travel", "plans"],
-      "visibility": "private",
-      "updated_at": "2025-05-19T00:00:00"
-    }}
-  }},
-  {{
-    "memory": "The user loves the Eiffel Tower.",
-    "metadata": {{
-      "type": "opinion",
-      "memory_time": "2025-05-19",
-      "source": "conversation",
-      "confidence": 100.0,
-      "entities": ["Eiffel Tower"],
-      "tags": ["opinions", "landmarks"],
-      "visibility": "session",
-      "updated_at": "2025-05-19T00:00:00"
-    }}
-  }}
-]
-
-"""
-
-EXTRACTION_PROMPT_PART_2 = """
-## Query
-
-### Input
-
-{messages}
-
-### Output
-
-"""
-
-EXTRACTION_RETRY_LOG = """Extracting memory failed due to JSON decode error: {error},
-Attempt retry: {attempt_number} / {max_attempt_number}
-"""
+    def parse_json_result(self, response_text):
+        try:
+            json_start = response_text.find("{")
+            response_text = response_text[json_start:]
+            response_text = response_text.replace("```", "").strip()
+            if response_text[-1] != "}":
+                response_text += "}"
+            response_json = json.loads(response_text)
+            return response_json
+        except json.JSONDecodeError as e:
+            logger.warning(
+                f"Failed to parse LLM response as JSON: {e}\nRaw response:\n{response_text}"
+            )
+            return {}

memos/memories/textual/item.py

@@ -27,23 +27,14 @@ class TextualMemoryMetadata(BaseModel):
         default="activated",
         description="The status of the memory, e.g., 'activated', 'archived', 'deleted'.",
     )
-    type: Literal["procedure", "fact", "event", "opinion", "topic", "reasoning"] | None = Field(
-        default=None
-    )
-    memory_time: str | None = Field(
-        default=None,
-        description='The time the memory occurred or refers to. Must be in standard `YYYY-MM-DD` format. Relative expressions such as "yesterday" or "tomorrow" are not allowed.',
-    )
-    source: Literal["conversation", "retrieved", "web", "file"] | None = Field(
-        default=None, description="The origin of the memory"
-    )
+    type: str | None = Field(default=None)
+    key: str | None = Field(default=None, description="Memory key or title.")
     confidence: float | None = Field(
         default=None,
         description="A numeric score (float between 0 and 100) indicating how certain you are about the accuracy or reliability of the memory.",
     )
-    entities: list[str] | None = Field(
-        default=None,
-        description='A list of key entities mentioned in the memory, e.g., people, places, organizations, e.g., `["Alice", "Paris", "OpenAI"]`.',
+    source: Literal["conversation", "retrieved", "web", "file"] | None = Field(
+        default=None, description="The origin of the memory"
     )
     tags: list[str] | None = Field(
         default=None,
@@ -59,23 +50,6 @@ class TextualMemoryMetadata(BaseModel):
 
     model_config = ConfigDict(extra="allow")
 
-    @field_validator("memory_time")
-    @classmethod
-    def validate_memory_time(cls, v):
-        try:
-            if v:
-                datetime.strptime(v, "%Y-%m-%d")
-        except ValueError as e:
-            raise ValueError("Invalid date format. Use YYYY-MM-DD.") from e
-        return v
-
-    @field_validator("confidence")
-    @classmethod
-    def validate_confidence(cls, v):
-        if v is not None and (v < 0 or v > 100):
-            raise ValueError("Confidence must be between 0 and 100.")
-        return v
-
     def __str__(self) -> str:
         """Pretty string representation of the metadata."""
         meta = self.model_dump(exclude_none=True)
@@ -85,10 +59,9 @@ class TextualMemoryMetadata(BaseModel):
 class TreeNodeTextualMemoryMetadata(TextualMemoryMetadata):
     """Extended metadata for structured memory, layered retrieval, and lifecycle tracking."""
 
-    memory_type: Literal["WorkingMemory", "LongTermMemory", "UserMemory"] = Field(
+    memory_type: Literal["WorkingMemory", "LongTermMemory", "UserMemory", "OuterMemory"] = Field(
         default="WorkingMemory", description="Memory lifecycle type."
     )
-    key: str | None = Field(default=None, description="Memory key or title.")
     sources: list[str] | None = Field(
         default=None, description="Multiple origins of the memory (e.g., URLs, notes)."
     )
@@ -148,7 +121,6 @@ class TextualMemoryItem(BaseModel):
 
     model_config = ConfigDict(extra="forbid")
 
-    @field_validator("id")
     @classmethod
     def validate_id(cls, v):
         try:

memos/memories/textual/tree.py

@@ -117,13 +117,19 @@ class TreeTextMemory(BaseTextMemory):
             logger.warning(
                 "Internet retriever is init by config , but  this search set manual_close_internet is True  and will close it"
             )
-            self.internet_retriever = None
-        searcher = Searcher(
-            self.dispatcher_llm,
-            self.graph_store,
-            self.embedder,
-            internet_retriever=self.internet_retriever,
-        )
+            searcher = Searcher(
+                self.dispatcher_llm,
+                self.graph_store,
+                self.embedder,
+                internet_retriever=None,
+            )
+        else:
+            searcher = Searcher(
+                self.dispatcher_llm,
+                self.graph_store,
+                self.embedder,
+                internet_retriever=self.internet_retriever,
+            )
         return searcher.search(query, top_k, info, mode, memory_type)
 
     def get_relevant_subgraph(

memos/memories/textual/tree_text_memory/organize/conflict.py

@@ -3,6 +3,8 @@ import re
 
 from datetime import datetime
 
+from dateutil import parser
+
 from memos.embedders.base import BaseEmbedder
 from memos.graph_dbs.neo4j import Neo4jGraphDB
 from memos.llms.base import BaseLLM
@@ -133,8 +135,8 @@ class ConflictHandler:
         """
         Hard update: compare updated_at, keep the newer one, overwrite the older one's metadata.
         """
-        time_a = datetime.fromisoformat(memory_a.metadata.updated_at)
-        time_b = datetime.fromisoformat(memory_b.metadata.updated_at)
+        time_a = parser.isoparse(memory_a.metadata.updated_at)
+        time_b = parser.isoparse(memory_b.metadata.updated_at)
 
         newer_mem = memory_a if time_a >= time_b else memory_b
         older_mem = memory_b if time_a >= time_b else memory_a

memos/memories/textual/tree_text_memory/organize/relation_reason_detector.py

@@ -1,4 +1,5 @@
 import json
+import traceback
 
 from memos.embedders.factory import OllamaEmbedder
 from memos.graph_dbs.item import GraphDBNode
@@ -30,53 +31,57 @@ class RelationAndReasoningDetector:
         3) Sequence links
         4) Aggregate concepts
         """
-        if node.metadata.type == "reasoning":
-            logger.info(f"Skip reasoning for inferred node {node.id}")
-            return {
-                "relations": [],
-                "inferred_nodes": [],
-                "sequence_links": [],
-                "aggregate_nodes": [],
-            }
-
         results = {
             "relations": [],
             "inferred_nodes": [],
             "sequence_links": [],
             "aggregate_nodes": [],
         }
+        try:
+            if node.metadata.type == "reasoning":
+                logger.info(f"Skip reasoning for inferred node {node.id}")
+                return {
+                    "relations": [],
+                    "inferred_nodes": [],
+                    "sequence_links": [],
+                    "aggregate_nodes": [],
+                }
+
+            nearest = self.graph_store.get_neighbors_by_tag(
+                tags=node.metadata.tags,
+                exclude_ids=exclude_ids,
+                top_k=top_k,
+                min_overlap=2,
+            )
+            nearest = [GraphDBNode(**cand_data) for cand_data in nearest]
+
+            """
+            # 1) Pairwise relations (including CAUSE/CONDITION/CONFLICT)
+            pairwise = self._detect_pairwise_causal_condition_relations(node, nearest)
+            results["relations"].extend(pairwise["relations"])
+            """
+
+            """
+            # 2) Inferred nodes (from causal/condition)
+            inferred = self._infer_fact_nodes_from_relations(pairwise)
+            results["inferred_nodes"].extend(inferred)
+            """
+
+            """
+            3) Sequence (optional, if you have timestamps)
+            seq = self._detect_sequence_links(node, nearest)
+            results["sequence_links"].extend(seq)
+            """
+
+            # 4) Aggregate
+            agg = self._detect_aggregate_node_for_group(node, nearest, min_group_size=5)
+            if agg:
+                results["aggregate_nodes"].append(agg)
 
-        nearest = self.graph_store.get_neighbors_by_tag(
-            tags=node.metadata.tags,
-            exclude_ids=exclude_ids,
-            top_k=top_k,
-            min_overlap=2,
-        )
-        nearest = [GraphDBNode(**cand_data) for cand_data in nearest]
-
-        """
-        # 1) Pairwise relations (including CAUSE/CONDITION/CONFLICT)
-        pairwise = self._detect_pairwise_causal_condition_relations(node, nearest)
-        results["relations"].extend(pairwise["relations"])
-        """
-
-        """
-        # 2) Inferred nodes (from causal/condition)
-        inferred = self._infer_fact_nodes_from_relations(pairwise)
-        results["inferred_nodes"].extend(inferred)
-        """
-
-        """
-        3) Sequence (optional, if you have timestamps)
-        seq = self._detect_sequence_links(node, nearest)
-        results["sequence_links"].extend(seq)
-        """
-
-        # 4) Aggregate
-        agg = self._detect_aggregate_node_for_group(node, nearest, min_group_size=5)
-        if agg:
-            results["aggregate_nodes"].append(agg)
-
+        except Exception as e:
+            logger.error(
+                f"Error {e} while process struct reorganize: trace: {traceback.format_exc()}"
+            )
         return results
 
     def _detect_pairwise_causal_condition_relations(
@@ -176,10 +181,9 @@ class RelationAndReasoningDetector:
         joined = "\n".join(f"- {n.memory}" for n in combined_nodes)
         prompt = AGGREGATE_PROMPT.replace("{joined}", joined)
         response_text = self._call_llm(prompt)
-        response_json = self._parse_json_result(response_text)
-        if not response_json:
+        summary = self._parse_json_result(response_text)
+        if not summary:
             return None
-        summary = json.loads(response_text)
         embedding = self.embedder.embed([summary["value"]])[0]
 
         parent_node = GraphDBNode(

memos/memories/textual/tree_text_memory/organize/reorganizer.py

@@ -125,8 +125,8 @@ class GraphStructureReorganizer:
         """
         import schedule
 
-        schedule.every(20).seconds.do(self.optimize_structure, scope="LongTermMemory")
-        schedule.every(20).seconds.do(self.optimize_structure, scope="UserMemory")
+        schedule.every(600).seconds.do(self.optimize_structure, scope="LongTermMemory")
+        schedule.every(600).seconds.do(self.optimize_structure, scope="UserMemory")
 
         logger.info("Structure optimizer schedule started.")
         while not getattr(self, "_stop_scheduler", False):
@@ -198,7 +198,7 @@ class GraphStructureReorganizer:
             logger.info(f"Already optimizing for {scope}. Skipping.")
             return
 
-        if self.graph_store.count_nodes(scope) == 0:
+        if self.graph_store.node_not_exist(scope):
             logger.debug(f"[GraphStructureReorganize] No nodes for scope={scope}. Skip.")
             return
 
@@ -251,7 +251,10 @@ class GraphStructureReorganizer:
                     try:
                         f.result()
                     except Exception as e:
-                        logger.warning(f"[Reorganize] Cluster processing failed: {e}")
+                        logger.warning(
+                            f"[Reorganize] Cluster processing "
+                            f"failed: {e}, trace: {traceback.format_exc()}"
+                        )
                 logger.info("[GraphStructure Reorganize] Structure optimization finished.")
 
         finally:
@@ -343,7 +346,7 @@ class GraphStructureReorganizer:
                         agg_node.metadata.model_dump(exclude_none=True),
                     )
                     for child_id in agg_node.metadata.sources:
-                        self.graph_store.add_edge(agg_node.id, child_id, "AGGREGATES")
+                        self.graph_store.add_edge(agg_node.id, child_id, "AGGREGATE_TO")
 
             logger.info("[Reorganizer] Cluster relation/reasoning done.")
 

memos/memories/textual/tree_text_memory/retrieve/internet_retriever.py

@@ -127,7 +127,7 @@ class InternetGoogleRetriever:
         self.embedder = embedder
 
     def retrieve_from_internet(
-        self, query: str, top_k: int = 10, parsed_goal=None
+        self, query: str, top_k: int = 10, parsed_goal=None, info=None
     ) -> list[TextualMemoryItem]:
         """
         Retrieve information from the internet and convert to TextualMemoryItem format
@@ -136,10 +136,13 @@ class InternetGoogleRetriever:
             query: Search query
             top_k: Number of results to return
             parsed_goal: Parsed task goal (optional)
+            info (dict): Leave a record of memory consumption.
 
         Returns:
             List of TextualMemoryItem
         """
+        if not info:
+            info = {"user_id": "", "session_id": ""}
         # Get search results
         search_results = self.google_api.get_all_results(query, max_results=top_k)
 
@@ -157,8 +160,8 @@ class InternetGoogleRetriever:
             memory_content = f"Title: {title}\nSummary: {snippet}\nSource: {link}"
             # Create metadata
             metadata = TreeNodeTextualMemoryMetadata(
-                user_id=None,
-                session_id=None,
+                user_id=info.get("user_id", ""),
+                session_id=info.get("session_id", ""),
                 status="activated",
                 type="fact",  # Internet search results are usually factual information
                 memory_time=datetime.now().strftime("%Y-%m-%d"),

memos/memories/textual/tree_text_memory/retrieve/internet_retriever_factory.py

@@ -4,6 +4,7 @@ from typing import Any, ClassVar
 
 from memos.configs.internet_retriever import InternetRetrieverConfigFactory
 from memos.embedders.base import BaseEmbedder
+from memos.mem_reader.factory import MemReaderFactory
 from memos.memories.textual.tree_text_memory.retrieve.internet_retriever import (
     InternetGoogleRetriever,
 )
@@ -66,6 +67,7 @@ class InternetRetrieverFactory:
                 access_key=config.api_key,  # Use api_key as access_key for xinyu
                 search_engine_id=config.search_engine_id,
                 embedder=embedder,
+                reader=MemReaderFactory.from_config(config.reader),
                 max_results=config.max_results,
             )
         else:

memos/memories/textual/tree_text_memory/retrieve/retrieval_mid_structs.py

@@ -10,4 +10,6 @@ class ParsedTaskGoal:
     memories: list[str] = field(default_factory=list)
     keys: list[str] = field(default_factory=list)
     tags: list[str] = field(default_factory=list)
+    rephrased_query: str | None = None
+    internet_search: bool = False
     goal_type: str | None = None  # e.g., 'default', 'explanation', etc.

memos/memories/textual/tree_text_memory/retrieve/searcher.py

@@ -6,6 +6,7 @@ from datetime import datetime
 from memos.embedders.factory import OllamaEmbedder
 from memos.graph_dbs.factory import Neo4jGraphDB
 from memos.llms.factory import AzureLLM, OllamaLLM, OpenAILLM
+from memos.log import get_logger
 from memos.memories.textual.item import SearchedTreeNodeTextualMemoryMetadata, TextualMemoryItem
 
 from .internet_retriever_factory import InternetRetrieverFactory
@@ -15,6 +16,9 @@ from .reranker import MemoryReranker
 from .task_goal_parser import TaskGoalParser
 
 
+logger = get_logger(__name__)
+
+
 class Searcher:
     def __init__(
         self,
@@ -53,7 +57,12 @@ class Searcher:
         Returns:
             list[TextualMemoryItem]: List of matching memories.
         """
-
+        if not info:
+            logger.warning(
+                "Please input 'info' when use tree.search so that "
+                "the database would store the consume history."
+            )
+            info = {"user_id": "", "session_id": ""}
         # Step 1: Parse task structure into topic, concept, and fact levels
         context = []
         if mode == "fine":
@@ -67,7 +76,18 @@ class Searcher:
             context = list(set(context))
 
         # Step 1a: Parse task structure into topic, concept, and fact levels
-        parsed_goal = self.task_goal_parser.parse(query, "\n".join(context))
+        parsed_goal = self.task_goal_parser.parse(
+            task_description=query,
+            context="\n".join(context),
+            conversation=info.get("chat_history", []),
+            mode=mode,
+        )
+
+        query = (
+            parsed_goal.rephrased_query
+            if parsed_goal.rephrased_query and len(parsed_goal.rephrased_query) > 0
+            else query
+        )
 
         if parsed_goal.memories:
             query_embedding = self.embedder.embed(list({query, *parsed_goal.memories}))
@@ -136,12 +156,12 @@ class Searcher:
             """
             Retrieve information from the internet using Google Custom Search API.
             """
-            if not self.internet_retriever:
+            if not self.internet_retriever or mode == "fast" or not parsed_goal.internet_search:
                 return []
             if memory_type not in ["All"]:
                 return []
             internet_items = self.internet_retriever.retrieve_from_internet(
-                query=query, top_k=top_k, parsed_goal=parsed_goal
+                query=query, top_k=top_k, parsed_goal=parsed_goal, info=info
             )
 
             # Convert to the format expected by reranker
@@ -149,21 +169,30 @@ class Searcher:
                 query=query,
                 query_embedding=query_embedding[0],
                 graph_results=internet_items,
-                top_k=top_k * 2,
+                top_k=min(top_k, 5),
                 parsed_goal=parsed_goal,
             )
             return ranked_memories
 
-        # Step 3: Parallel execution of all paths
-        with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
-            future_working = executor.submit(retrieve_from_working_memory)
-            future_hybrid = executor.submit(retrieve_ranked_long_term_and_user)
-            future_internet = executor.submit(retrieve_from_internet)
-
-            working_results = future_working.result()
-            hybrid_results = future_hybrid.result()
-            internet_results = future_internet.result()
-            searched_res = working_results + hybrid_results + internet_results
+        # Step 3: Parallel execution of all paths (enable internet search accoeding to parameter in the parsed goal)
+        if parsed_goal.internet_search:
+            with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
+                future_working = executor.submit(retrieve_from_working_memory)
+                future_hybrid = executor.submit(retrieve_ranked_long_term_and_user)
+                future_internet = executor.submit(retrieve_from_internet)
+
+                working_results = future_working.result()
+                hybrid_results = future_hybrid.result()
+                internet_results = future_internet.result()
+                searched_res = working_results + hybrid_results + internet_results
+        else:
+            with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:
+                future_working = executor.submit(retrieve_from_working_memory)
+                future_hybrid = executor.submit(retrieve_ranked_long_term_and_user)
+
+                working_results = future_working.result()
+                hybrid_results = future_hybrid.result()
+                searched_res = working_results + hybrid_results
 
         # Deduplicate by item.memory, keep higher score
         deduped_result = {}
@@ -184,16 +213,10 @@ class Searcher:
                 TextualMemoryItem(id=item.id, memory=item.memory, metadata=new_meta)
             )
 
-        # Step 4: Reasoning over all retrieved and ranked memory
-        if mode == "fine":
-            searched_res = self.reasoner.reason(
-                query=query,
-                ranked_memories=searched_res,
-                parsed_goal=parsed_goal,
-            )
-
         # Step 5: Update usage history with current timestamp
         now_time = datetime.now().isoformat()
+        if "chat_history" in info:
+            info.pop("chat_history")
         usage_record = json.dumps(
             {"time": now_time, "info": info}
         )  # `info` should be a serializable dict or string