MemoryOS 1.0.0__py3-none-any.whl → 1.0.1__py3-none-any.whl

memos/mem_os/utils/reference_utils.py

@@ -1,3 +1,8 @@
+from memos.memories.textual.item import (
+    TextualMemoryItem,
+)
+
+
 def split_continuous_references(text: str) -> str:
     """
     Split continuous reference tags into individual reference tags.
@@ -131,3 +136,18 @@ def process_streaming_references_complete(text_buffer: str) -> tuple[str, str]:
     # No reference-like patterns found, process all text
     processed_text = split_continuous_references(text_buffer)
     return processed_text, ""
+
+
+def prepare_reference_data(memories_list: list[TextualMemoryItem]) -> list[dict]:
+    # Prepare reference data
+    reference = []
+    for memories in memories_list:
+        memories_json = memories.model_dump()
+        memories_json["metadata"]["ref_id"] = f"{memories.id.split('-')[0]}"
+        memories_json["metadata"]["embedding"] = []
+        memories_json["metadata"]["sources"] = []
+        memories_json["metadata"]["memory"] = memories.memory
+        memories_json["metadata"]["id"] = memories.id
+        reference.append({"metadata": memories_json["metadata"]})
+
+    return reference

memos/mem_reader/simple_struct.py

@@ -1,10 +1,14 @@
 import concurrent.futures
 import copy
 import json
+import os
+import re
 
 from abc import ABC
 from typing import Any
 
+from tqdm import tqdm
+
 from memos import log
 from memos.chunkers import ChunkerFactory
 from memos.configs.mem_reader import SimpleStructMemReaderConfig
@@ -16,12 +20,79 @@ from memos.memories.textual.item import TextualMemoryItem, TreeNodeTextualMemory
 from memos.parsers.factory import ParserFactory
 from memos.templates.mem_reader_prompts import (
     SIMPLE_STRUCT_DOC_READER_PROMPT,
+    SIMPLE_STRUCT_DOC_READER_PROMPT_ZH,
     SIMPLE_STRUCT_MEM_READER_EXAMPLE,
+    SIMPLE_STRUCT_MEM_READER_EXAMPLE_ZH,
     SIMPLE_STRUCT_MEM_READER_PROMPT,
+    SIMPLE_STRUCT_MEM_READER_PROMPT_ZH,
 )
 
 
 logger = log.get_logger(__name__)
+PROMPT_DICT = {
+    "chat": {
+        "en": SIMPLE_STRUCT_MEM_READER_PROMPT,
+        "zh": SIMPLE_STRUCT_MEM_READER_PROMPT_ZH,
+        "en_example": SIMPLE_STRUCT_MEM_READER_EXAMPLE,
+        "zh_example": SIMPLE_STRUCT_MEM_READER_EXAMPLE_ZH,
+    },
+    "doc": {"en": SIMPLE_STRUCT_DOC_READER_PROMPT, "zh": SIMPLE_STRUCT_DOC_READER_PROMPT_ZH},
+}
+
+
+def detect_lang(text):
+    try:
+        if not text or not isinstance(text, str):
+            return "en"
+        chinese_pattern = r"[\u4e00-\u9fff\u3400-\u4dbf\U00020000-\U0002a6df\U0002a700-\U0002b73f\U0002b740-\U0002b81f\U0002b820-\U0002ceaf\uf900-\ufaff]"
+        chinese_chars = re.findall(chinese_pattern, text)
+        if len(chinese_chars) / len(re.sub(r"[\s\d\W]", "", text)) > 0.3:
+            return "zh"
+        return "en"
+    except Exception:
+        return "en"
+
+
+def _build_node(idx, message, info, scene_file, llm, parse_json_result, embedder):
+    # generate
+    raw = llm.generate(message)
+    if not raw:
+        return None
+
+    # parse_json_result
+    chunk_res = parse_json_result(raw)
+    if not chunk_res:
+        return None
+
+    value = chunk_res.get("value")
+    if not value:
+        return None
+
+    # embed
+    embedding = embedder.embed([value])[0]
+
+    # TextualMemoryItem
+    tags = chunk_res["tags"] if isinstance(chunk_res.get("tags"), list) else []
+    key = chunk_res.get("key", None)
+
+    node_i = TextualMemoryItem(
+        memory=value,
+        metadata=TreeNodeTextualMemoryMetadata(
+            user_id=info.get("user_id"),
+            session_id=info.get("session_id"),
+            memory_type="LongTermMemory",
+            status="activated",
+            tags=tags,
+            key=key,
+            embedding=embedding,
+            usage=[],
+            sources=[f"{scene_file}_{idx}"],
+            background="",
+            confidence=0.99,
+            type="fact",
+        ),
+    )
+    return node_i
 
 
 class SimpleStructMemReader(BaseMemReader, ABC):
@@ -40,11 +111,13 @@ class SimpleStructMemReader(BaseMemReader, ABC):
         self.chunker = ChunkerFactory.from_config(config.chunker)
 
     def _process_chat_data(self, scene_data_info, info):
-        prompt = SIMPLE_STRUCT_MEM_READER_PROMPT.replace(
-            "${conversation}", "\n".join(scene_data_info)
-        )
+        lang = detect_lang("\n".join(scene_data_info))
+        template = PROMPT_DICT["chat"][lang]
+        examples = PROMPT_DICT["chat"][f"{lang}_example"]
+
+        prompt = template.replace("${conversation}", "\n".join(scene_data_info))
         if self.config.remove_prompt_example:
-            prompt = prompt.replace(SIMPLE_STRUCT_MEM_READER_EXAMPLE, "")
+            prompt = prompt.replace(examples, "")
 
         messages = [{"role": "user", "content": prompt}]
 
@@ -180,7 +253,7 @@ class SimpleStructMemReader(BaseMemReader, ABC):
         elif type == "doc":
             for item in scene_data:
                 try:
-                    if not isinstance(item, str):
+                    if os.path.exists(item):
                         parsed_text = parser.parse(item)
                         results.append({"file": "pure_text", "text": parsed_text})
                     else:
@@ -193,46 +266,42 @@ class SimpleStructMemReader(BaseMemReader, ABC):
 
     def _process_doc_data(self, scene_data_info, info):
         chunks = self.chunker.chunk(scene_data_info["text"])
-        messages = [
-            [
-                {
-                    "role": "user",
-                    "content": SIMPLE_STRUCT_DOC_READER_PROMPT.replace("{chunk_text}", chunk.text),
-                }
-            ]
-            for chunk in chunks
-        ]
-
-        processed_chunks = []
-        with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
-            futures = [executor.submit(self.llm.generate, message) for message in messages]
-            for future in concurrent.futures.as_completed(futures):
-                chunk_result = future.result()
-                if chunk_result:
-                    processed_chunks.append(chunk_result)
+        messages = []
+        for chunk in chunks:
+            lang = detect_lang(chunk.text)
+            template = PROMPT_DICT["doc"][lang]
+            prompt = template.replace("{chunk_text}", chunk.text)
+            message = [{"role": "user", "content": prompt}]
+            messages.append(message)
 
-        processed_chunks = [self.parse_json_result(r) for r in processed_chunks]
         doc_nodes = []
-        for i, chunk_res in enumerate(processed_chunks):
-            if chunk_res:
-                node_i = TextualMemoryItem(
-                    memory=chunk_res["value"],
-                    metadata=TreeNodeTextualMemoryMetadata(
-                        user_id=info.get("user_id"),
-                        session_id=info.get("session_id"),
-                        memory_type="LongTermMemory",
-                        status="activated",
-                        tags=chunk_res["tags"] if type(chunk_res["tags"]) is list else [],
-                        key=chunk_res["key"],
-                        embedding=self.embedder.embed([chunk_res["value"]])[0],
-                        usage=[],
-                        sources=[f"{scene_data_info['file']}_{i}"],
-                        background="",
-                        confidence=0.99,
-                        type="fact",
-                    ),
-                )
-                doc_nodes.append(node_i)
+        scene_file = scene_data_info["file"]
+
+        with concurrent.futures.ThreadPoolExecutor(max_workers=50) as executor:
+            futures = {
+                executor.submit(
+                    _build_node,
+                    idx,
+                    msg,
+                    info,
+                    scene_file,
+                    self.llm,
+                    self.parse_json_result,
+                    self.embedder,
+                ): idx
+                for idx, msg in enumerate(messages)
+            }
+            total = len(futures)
+
+            for future in tqdm(
+                concurrent.futures.as_completed(futures), total=total, desc="Processing"
+            ):
+                try:
+                    node = future.result()
+                    if node:
+                        doc_nodes.append(node)
+                except Exception as e:
+                    tqdm.write(f"[ERROR] {e}")
         return doc_nodes
 
     def parse_json_result(self, response_text):

memos/mem_user/mysql_user_manager.py

@@ -55,7 +55,9 @@ class User(Base):
 
     user_id = Column(String(255), primary_key=True, default=lambda: str(uuid.uuid4()))
     user_name = Column(String(255), unique=True, nullable=False)
-    role = Column(String(20), default=UserRole.USER.value, nullable=False)
+    role = Column(
+        String(20), default=UserRole.USER.value, nullable=False
+    )  # for sqlite backend this is SQLEnum
     created_at = Column(DateTime, default=datetime.now, nullable=False)
     updated_at = Column(DateTime, default=datetime.now, onupdate=datetime.now, nullable=False)
     is_active = Column(Boolean, default=True, nullable=False)
@@ -65,7 +67,7 @@ class User(Base):
     owned_cubes = relationship("Cube", back_populates="owner", cascade="all, delete-orphan")
 
     def __repr__(self):
-        return f"<User(user_id='{self.user_id}', user_name='{self.user_name}', role='{self.role.value}')>"
+        return f"<User(user_id='{self.user_id}', user_name='{self.user_name}', role='{self.role}')>"
 
 
 class Cube(Base):

memos/memories/textual/item.py

@@ -33,7 +33,7 @@ class TextualMemoryMetadata(BaseModel):
         default=None,
         description="A numeric score (float between 0 and 100) indicating how certain you are about the accuracy or reliability of the memory.",
     )
-    source: Literal["conversation", "retrieved", "web", "file"] | None = Field(
+    source: Literal["conversation", "retrieved", "web", "file", "system"] | None = Field(
         default=None, description="The origin of the memory"
     )
     tags: list[str] | None = Field(

memos/memories/textual/tree.py

@@ -8,6 +8,7 @@ from pathlib import Path
 from typing import Any
 
 from memos.configs.memory import TreeTextMemoryConfig
+from memos.configs.reranker import RerankerConfigFactory
 from memos.embedders.factory import EmbedderFactory, OllamaEmbedder
 from memos.graph_dbs.factory import GraphStoreFactory, Neo4jGraphDB
 from memos.llms.factory import AzureLLM, LLMFactory, OllamaLLM, OpenAILLM
@@ -19,6 +20,7 @@ from memos.memories.textual.tree_text_memory.retrieve.internet_retriever_factory
     InternetRetrieverFactory,
 )
 from memos.memories.textual.tree_text_memory.retrieve.searcher import Searcher
+from memos.reranker.factory import RerankerFactory
 from memos.types import MessageList
 
 
@@ -39,10 +41,33 @@ class TreeTextMemory(BaseTextMemory):
         )
         self.embedder: OllamaEmbedder = EmbedderFactory.from_config(config.embedder)
         self.graph_store: Neo4jGraphDB = GraphStoreFactory.from_config(config.graph_db)
+        if config.reranker is None:
+            default_cfg = RerankerConfigFactory.model_validate(
+                {
+                    "backend": "cosine_local",
+                    "config": {
+                        "level_weights": {"topic": 1.0, "concept": 1.0, "fact": 1.0},
+                        "level_field": "background",
+                    },
+                }
+            )
+            self.reranker = RerankerFactory.from_config(default_cfg)
+        else:
+            self.reranker = RerankerFactory.from_config(config.reranker)
+
         self.is_reorganize = config.reorganize
 
         self.memory_manager: MemoryManager = MemoryManager(
-            self.graph_store, self.embedder, self.extractor_llm, is_reorganize=self.is_reorganize
+            self.graph_store,
+            self.embedder,
+            self.extractor_llm,
+            memory_size=config.memory_size
+            or {
+                "WorkingMemory": 20,
+                "LongTermMemory": 1500,
+                "UserMemory": 480,
+            },
+            is_reorganize=self.is_reorganize,
         )
 
         # Create internet retriever if configured
@@ -96,6 +121,7 @@ class TreeTextMemory(BaseTextMemory):
         mode: str = "fast",
         memory_type: str = "All",
         manual_close_internet: bool = False,
+        moscube: bool = False,
     ) -> list[TextualMemoryItem]:
         """Search for memories based on a query.
         User query -> TaskGoalParser -> MemoryPathResolver ->
@@ -121,14 +147,18 @@ class TreeTextMemory(BaseTextMemory):
                 self.dispatcher_llm,
                 self.graph_store,
                 self.embedder,
+                self.reranker,
                 internet_retriever=None,
+                moscube=moscube,
             )
         else:
             searcher = Searcher(
                 self.dispatcher_llm,
                 self.graph_store,
                 self.embedder,
+                self.reranker,
                 internet_retriever=self.internet_retriever,
+                moscube=moscube,
             )
         return searcher.search(query, top_k, info, mode, memory_type)
 

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

@@ -218,7 +218,9 @@ class BochaAISearchRetriever:
         memory_items = []
         for read_item_i in read_items[0]:
             read_item_i.memory = (
-                f"Title: {title}\nNewsTime: {publish_time}\nSummary: {summary}\n"
+                f"[Outer internet view] Title: {title}\nNewsTime:"
+                f" {publish_time}\nSummary:"
+                f" {summary}\n"
                 f"Content: {read_item_i.memory}"
             )
             read_item_i.metadata.source = "web"

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

@@ -74,6 +74,51 @@ class GraphMemoryRetriever:
 
         return list(combined.values())
 
+    def retrieve_from_cube(
+        self,
+        top_k: int,
+        memory_scope: str,
+        query_embedding: list[list[float]] | None = None,
+        cube_name: str = "memos_cube01",
+    ) -> list[TextualMemoryItem]:
+        """
+        Perform hybrid memory retrieval:
+        - Run graph-based lookup from dispatch plan.
+        - Run vector similarity search from embedded query.
+        - Merge and return combined result set.
+
+        Args:
+            top_k (int): Number of candidates to return.
+            memory_scope (str): One of ['working', 'long_term', 'user'].
+            query_embedding(list of embedding): list of embedding of query
+            cube_name: specify cube_name
+
+        Returns:
+            list: Combined memory items.
+        """
+        if memory_scope not in ["WorkingMemory", "LongTermMemory", "UserMemory"]:
+            raise ValueError(f"Unsupported memory scope: {memory_scope}")
+
+        graph_results = self._vector_recall(
+            query_embedding, memory_scope, top_k, cube_name=cube_name
+        )
+
+        for result_i in graph_results:
+            result_i.metadata.memory_type = "OuterMemory"
+        # Merge and deduplicate by ID
+        combined = {item.id: item for item in graph_results}
+
+        graph_ids = {item.id for item in graph_results}
+        combined_ids = set(combined.keys())
+        lost_ids = graph_ids - combined_ids
+
+        if lost_ids:
+            print(
+                f"[DEBUG] The following nodes were in graph_results but missing in combined: {lost_ids}"
+            )
+
+        return list(combined.values())
+
     def _graph_recall(
         self, parsed_goal: ParsedTaskGoal, memory_scope: str
     ) -> list[TextualMemoryItem]:
@@ -134,7 +179,8 @@ class GraphMemoryRetriever:
         query_embedding: list[list[float]],
         memory_scope: str,
         top_k: int = 20,
-        max_num: int = 5,
+        max_num: int = 3,
+        cube_name: str | None = None,
     ) -> list[TextualMemoryItem]:
         """
         # TODO: tackle with post-filter and pre-filter(5.18+) better.
@@ -144,7 +190,9 @@ class GraphMemoryRetriever:
 
         def search_single(vec):
             return (
-                self.graph_store.search_by_embedding(vector=vec, top_k=top_k, scope=memory_scope)
+                self.graph_store.search_by_embedding(
+                    vector=vec, top_k=top_k, scope=memory_scope, cube_name=cube_name
+                )
                 or []
             )
 
@@ -159,6 +207,8 @@ class GraphMemoryRetriever:
 
         # Step 3: Extract matched IDs and retrieve full nodes
         unique_ids = set({r["id"] for r in all_matches})
-        node_dicts = self.graph_store.get_nodes(list(unique_ids), include_embedding=True)
+        node_dicts = self.graph_store.get_nodes(
+            list(unique_ids), include_embedding=True, cube_name=cube_name
+        )
 
         return [TextualMemoryItem.from_dict(record) for record in node_dicts]

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

@@ -8,12 +8,12 @@ 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 memos.reranker.base import BaseReranker
 from memos.utils import timed
 
 from .internet_retriever_factory import InternetRetrieverFactory
 from .reasoner import MemoryReasoner
 from .recall import GraphMemoryRetriever
-from .reranker import MemoryReranker
 from .task_goal_parser import TaskGoalParser
 
 
@@ -26,18 +26,25 @@ class Searcher:
         dispatcher_llm: OpenAILLM | OllamaLLM | AzureLLM,
         graph_store: Neo4jGraphDB,
         embedder: OllamaEmbedder,
+        reranker: BaseReranker,
         internet_retriever: InternetRetrieverFactory | None = None,
+        moscube: bool = False,
     ):
         self.graph_store = graph_store
         self.embedder = embedder
 
         self.task_goal_parser = TaskGoalParser(dispatcher_llm)
         self.graph_retriever = GraphMemoryRetriever(self.graph_store, self.embedder)
-        self.reranker = MemoryReranker(dispatcher_llm, self.embedder)
+        self.reranker = reranker
         self.reasoner = MemoryReasoner(dispatcher_llm)
 
         # Create internet retriever from config if provided
         self.internet_retriever = internet_retriever
+        self.moscube = moscube
+
+        self._usage_executor = concurrent.futures.ThreadPoolExecutor(
+            max_workers=4, thread_name_prefix="usage"
+        )
 
     @timed
     def search(
@@ -80,6 +87,12 @@ class Searcher:
         self._update_usage_history(final_results, info)
 
         logger.info(f"[SEARCH] Done. Total {len(final_results)} results.")
+        res_results = ""
+        for _num_i, result in enumerate(final_results):
+            res_results += "\n" + (
+                result.id + "|" + result.metadata.memory_type + "|" + result.memory
+            )
+        logger.info(f"[SEARCH] Results. {res_results}")
         return final_results
 
     @timed
@@ -101,9 +114,10 @@ class Searcher:
             context = list({node["memory"] for node in related_nodes})
 
             # optional: supplement context with internet knowledge
-            if self.internet_retriever:
+            """if self.internet_retriever:
                 extra = self.internet_retriever.retrieve_from_internet(query=query, top_k=3)
                 context.extend(item.memory.partition("\nContent: ")[-1] for item in extra)
+            """
 
         # parse goal using LLM
         parsed_goal = self.task_goal_parser.parse(
@@ -157,6 +171,17 @@ class Searcher:
                     memory_type,
                 )
             )
+            if self.moscube:
+                tasks.append(
+                    executor.submit(
+                        self._retrieve_from_memcubes,
+                        query,
+                        parsed_goal,
+                        query_embedding,
+                        top_k,
+                        "memos_cube01",
+                    )
+                )
 
             results = []
             for t in tasks:
@@ -212,7 +237,26 @@ class Searcher:
             query=query,
             query_embedding=query_embedding[0],
             graph_results=results,
+            top_k=top_k,
+            parsed_goal=parsed_goal,
+        )
+
+    @timed
+    def _retrieve_from_memcubes(
+        self, query, parsed_goal, query_embedding, top_k, cube_name="memos_cube01"
+    ):
+        """Retrieve and rerank from LongTermMemory and UserMemory"""
+        results = self.graph_retriever.retrieve_from_cube(
+            query_embedding=query_embedding,
             top_k=top_k * 2,
+            memory_scope="LongTermMemory",
+            cube_name=cube_name,
+        )
+        return self.reranker.rerank(
+            query=query,
+            query_embedding=query_embedding[0],
+            graph_results=results,
+            top_k=top_k,
             parsed_goal=parsed_goal,
         )
 
@@ -271,14 +315,30 @@ class Searcher:
     def _update_usage_history(self, items, info):
         """Update usage history in graph DB"""
         now_time = datetime.now().isoformat()
-        info.pop("chat_history", None)
-        # `info` should be a serializable dict or string
-        usage_record = json.dumps({"time": now_time, "info": info})
-        for item in items:
-            if (
-                hasattr(item, "id")
-                and hasattr(item, "metadata")
-                and hasattr(item.metadata, "usage")
-            ):
-                item.metadata.usage.append(usage_record)
-                self.graph_store.update_node(item.id, {"usage": item.metadata.usage})
+        info_copy = dict(info or {})
+        info_copy.pop("chat_history", None)
+        usage_record = json.dumps({"time": now_time, "info": info_copy})
+        payload = []
+        for it in items:
+            try:
+                item_id = getattr(it, "id", None)
+                md = getattr(it, "metadata", None)
+                if md is None:
+                    continue
+                if not hasattr(md, "usage") or md.usage is None:
+                    md.usage = []
+                md.usage.append(usage_record)
+                if item_id:
+                    payload.append((item_id, list(md.usage)))
+            except Exception:
+                logger.exception("[USAGE] snapshot item failed")
+
+        if payload:
+            self._usage_executor.submit(self._update_usage_history_worker, payload, usage_record)
+
+    def _update_usage_history_worker(self, payload, usage_record: str):
+        try:
+            for item_id, usage_list in payload:
+                self.graph_store.update_node(item_id, {"usage": usage_list})
+        except Exception:
+            logger.exception("[USAGE] update usage failed")

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

@@ -8,18 +8,20 @@ You are a task parsing expert. Given a user task instruction, optional former co
 5. Need for internet search: If the user's task instruction only involves objective facts or can be completed without introducing external knowledge, set "internet_search" to False. Otherwise, set it to True.
 6. Memories: Provide 2–5 short semantic expansions or rephrasings of the rephrased/original user task instruction. These are used for improved embedding search coverage. Each should be clear, concise, and meaningful for retrieval.
 
-Task description:
-\"\"\"$task\"\"\"
-
 Former conversation (if any):
 \"\"\"
 $conversation
 \"\"\"
 
+Task description(User Question):
+\"\"\"$task\"\"\"
+
 Context (if any):
 \"\"\"$context\"\"\"
 
-Return strictly in this JSON format:
+Return strictly in this JSON format, note that the
+keys/tags/rephrased_instruction/memories should use the same language as the
+input query:
 {
   "keys": [...],
   "tags": [...],

memos/memos_tools/notification_utils.py

@@ -2,6 +2,7 @@
 Notification utilities for MemOS product.
 """
 
+import asyncio
 import logging
 
 from collections.abc import Callable
@@ -51,6 +52,51 @@ def send_online_bot_notification(
         logger.warning(f"Failed to send online bot notification: {e}")
 
 
+async def send_online_bot_notification_async(
+    online_bot: Callable | None,
+    header_name: str,
+    sub_title_name: str,
+    title_color: str,
+    other_data1: dict[str, Any],
+    other_data2: dict[str, Any],
+    emoji: dict[str, str],
+) -> None:
+    """
+    Send notification via online_bot asynchronously if available.
+
+    Args:
+        online_bot: The online_bot function or None
+        header_name: Header name for the report
+        sub_title_name: Subtitle for the report
+        title_color: Title color
+        other_data1: First data dict
+        other_data2: Second data dict
+        emoji: Emoji configuration dict
+    """
+    if online_bot is None:
+        return
+
+    try:
+        # Run the potentially blocking notification in a thread pool
+        loop = asyncio.get_event_loop()
+        await loop.run_in_executor(
+            None,
+            lambda: online_bot(
+                header_name=header_name,
+                sub_title_name=sub_title_name,
+                title_color=title_color,
+                other_data1=other_data1,
+                other_data2=other_data2,
+                emoji=emoji,
+            ),
+        )
+
+        logger.info(f"Online bot notification sent successfully (async): {header_name}")
+
+    except Exception as e:
+        logger.warning(f"Failed to send online bot notification (async): {e}")
+
+
 def send_error_bot_notification(
     error_bot: Callable | None,
     err: str,

memos/reranker/__init__.py

@@ -0,0 +1,4 @@
+from .factory import RerankerFactory
+
+
+__all__ = ["RerankerFactory"]