Merge memtensor/dev: resolve conflict in product_models.py, keep dev branch version

Author: fancyboi999

examples/mem_agent/deepsearch_example.py

@@ -0,0 +1,191 @@
+"""
+DeepSearch Agent Usage Examples - Simplified Version
+
+This example demonstrates simplified initialization of DeepSearchMemAgent without
+external config builders, using APIConfig methods directly.
+"""
+
+import os
+
+from typing import Any
+
+from memos.api.config import APIConfig
+from memos.configs.embedder import EmbedderConfigFactory
+from memos.configs.graph_db import GraphDBConfigFactory
+from memos.configs.internet_retriever import InternetRetrieverConfigFactory
+from memos.configs.llm import LLMConfigFactory
+from memos.configs.mem_agent import MemAgentConfigFactory
+from memos.configs.mem_reader import MemReaderConfigFactory
+from memos.configs.reranker import RerankerConfigFactory
+from memos.embedders.factory import EmbedderFactory
+from memos.graph_dbs.factory import GraphStoreFactory
+from memos.llms.factory import LLMFactory
+from memos.log import get_logger
+from memos.mem_agent.deepsearch_agent import DeepSearchMemAgent
+from memos.mem_agent.factory import MemAgentFactory
+from memos.mem_cube.navie import NaiveMemCube
+from memos.mem_reader.factory import MemReaderFactory
+from memos.memories.textual.simple_tree import SimpleTreeTextMemory
+from memos.memories.textual.tree_text_memory.organize.manager import MemoryManager
+from memos.memories.textual.tree_text_memory.retrieve.internet_retriever_factory import (
+    InternetRetrieverFactory,
+)
+from memos.reranker.factory import RerankerFactory
+
+
+logger = get_logger(__name__)
+
+
+def build_minimal_components():
+    """
+    Build minimal components for DeepSearchMemAgent with simplified configuration.
+
+    This function creates all necessary components using APIConfig methods,
+    similar to config_builders.py but inline for easier customization.
+    """
+    logger.info("Initializing simplified MemOS components...")
+
+    # Build component configurations using APIConfig methods (like config_builders.py)
+
+    # Graph DB configuration - using APIConfig.get_nebular_config()
+    graph_db_backend = os.getenv("NEO4J_BACKEND", "polardb").lower()
+    graph_db_backend_map = {
+        "polardb": APIConfig.get_polardb_config(),
+    }
+    graph_db_config = GraphDBConfigFactory.model_validate(
+        {
+            "backend": graph_db_backend,
+            "config": graph_db_backend_map[graph_db_backend],
+        }
+    )
+
+    # LLM configuration - using APIConfig.get_openai_config()
+    llm_config = LLMConfigFactory.model_validate(
+        {
+            "backend": "openai",
+            "config": APIConfig.get_openai_config(),
+        }
+    )
+
+    # Embedder configuration - using APIConfig.get_embedder_config()
+    embedder_config = EmbedderConfigFactory.model_validate(APIConfig.get_embedder_config())
+
+    # Memory reader configuration - using APIConfig.get_product_default_config()
+    mem_reader_config = MemReaderConfigFactory.model_validate(
+        APIConfig.get_product_default_config()["mem_reader"]
+    )
+
+    # Reranker configuration - using APIConfig.get_reranker_config()
+    reranker_config = RerankerConfigFactory.model_validate(APIConfig.get_reranker_config())
+
+    # Internet retriever configuration - using APIConfig.get_internet_config()
+    internet_retriever_config = InternetRetrieverConfigFactory.model_validate(
+        APIConfig.get_internet_config()
+    )
+
+    logger.debug("Component configurations built successfully")
+
+    # Create component instances
+    graph_db = GraphStoreFactory.from_config(graph_db_config)
+    llm = LLMFactory.from_config(llm_config)
+    embedder = EmbedderFactory.from_config(embedder_config)
+    mem_reader = MemReaderFactory.from_config(mem_reader_config)
+    reranker = RerankerFactory.from_config(reranker_config)
+    internet_retriever = InternetRetrieverFactory.from_config(
+        internet_retriever_config, embedder=embedder
+    )
+
+    logger.debug("Core components instantiated")
+
+    # Get default cube configuration like component_init.py
+    default_cube_config = APIConfig.get_default_cube_config()
+
+    # Get default memory size from cube config (like component_init.py)
+    def get_memory_size_from_config(cube_config):
+        return getattr(cube_config.text_mem.config, "memory_size", None) or {
+            "WorkingMemory": 20,
+            "LongTermMemory": 1500,
+            "UserMemory": 480,
+        }
+
+    memory_size = get_memory_size_from_config(default_cube_config)
+    is_reorganize = getattr(default_cube_config.text_mem.config, "reorganize", False)
+
+    # Initialize memory manager with config from APIConfig
+    memory_manager = MemoryManager(
+        graph_db,
+        embedder,
+        llm,
+        memory_size=memory_size,
+        is_reorganize=is_reorganize,
+    )
+    text_memory_config = default_cube_config.text_mem.config
+    text_mem = SimpleTreeTextMemory(
+        llm=llm,
+        embedder=embedder,
+        mem_reader=mem_reader,
+        graph_db=graph_db,
+        reranker=reranker,
+        memory_manager=memory_manager,
+        config=text_memory_config,
+        internet_retriever=internet_retriever,
+    )
+
+    naive_mem_cube = NaiveMemCube(
+        text_mem=text_mem,
+        pref_mem=None,  # Simplified: no preference memory
+        act_mem=None,
+        para_mem=None,
+    )
+
+    return {
+        "llm": llm,
+        "naive_mem_cube": naive_mem_cube,
+        "embedder": embedder,
+        "graph_db": graph_db,
+        "mem_reader": mem_reader,
+    }
+
+
+def factory_initialization() -> tuple[DeepSearchMemAgent, dict[str, Any]]:
+    # Build necessary components with simplified setup
+    components = build_minimal_components()
+    llm = components["llm"]
+    naive_mem_cube = components["naive_mem_cube"]
+
+    # Create configuration Factory with simplified config
+    agent_config_factory = MemAgentConfigFactory(
+        backend="deep_search",
+        config={
+            "agent_name": "SimplifiedDeepSearchAgent",
+            "description": "Simplified intelligent agent for deep search",
+            "max_iterations": 3,  # Maximum number of iterations
+            "timeout": 60,  # Timeout in seconds
+        },
+    )
+
+    # Create Agent using Factory
+    # Pass text_mem as memory_retriever, it provides search method
+    deep_search_agent = MemAgentFactory.from_config(
+        config_factory=agent_config_factory, llm=llm, memory_retriever=naive_mem_cube.text_mem
+    )
+
+    logger.info("✓ DeepSearchMemAgent created successfully")
+    logger.info(f"  - Agent name: {deep_search_agent.config.agent_name}")
+    logger.info(f"  - Max iterations: {deep_search_agent.max_iterations}")
+    logger.info(f"  - Timeout: {deep_search_agent.timeout} seconds")
+
+    return deep_search_agent, components
+
+
+def main():
+    agent_factory, components_factory = factory_initialization()
+    results = agent_factory.run(
+        "Caroline met up with friends, family, and mentors in early July 2023.",
+        user_id="locomo_exp_user_0_speaker_b_ct-1118",
+    )
+    print(results)
+
+
+if __name__ == "__main__":
+    main()

examples/mem_scheduler/memos_w_scheduler.py

@@ -1,9 +1,10 @@
+import re
 import shutil
 import sys
 
+from datetime import datetime
 from pathlib import Path
 from queue import Queue
-from typing import TYPE_CHECKING
 
 from memos.configs.mem_cube import GeneralMemCubeConfig
 from memos.configs.mem_os import MOSConfig
@@ -12,12 +13,16 @@
 from memos.mem_cube.general import GeneralMemCube
 from memos.mem_os.main import MOS
 from memos.mem_scheduler.general_scheduler import GeneralScheduler
-
-
-if TYPE_CHECKING:
-    from memos.mem_scheduler.schemas.message_schemas import (
-        ScheduleLogForWebItem,
-    )
+from memos.mem_scheduler.schemas.general_schemas import (
+    ADD_LABEL,
+    ANSWER_LABEL,
+    MEM_ARCHIVE_LABEL,
+    MEM_ORGANIZE_LABEL,
+    MEM_UPDATE_LABEL,
+    QUERY_LABEL,
+)
+from memos.mem_scheduler.schemas.message_schemas import ScheduleLogForWebItem
+from memos.mem_scheduler.utils.filter_utils import transform_name_to_key
 
 
 FILE_PATH = Path(__file__).absolute()
@@ -70,6 +75,91 @@ def init_task():
     return conversations, questions
 
 
+def _truncate_with_rules(text: str) -> str:
+    has_cjk = bool(re.search(r"[\u4e00-\u9fff]", text))
+    limit = 32 if has_cjk else 64
+    normalized = text.strip().replace("\n", " ")
+    if len(normalized) <= limit:
+        return normalized
+    return normalized[:limit] + "..."
+
+
+def _format_title(ts: datetime, title_text: str) -> str:
+    return f"{ts.astimezone().strftime('%H:%M:%S')} {title_text}"
+
+
+def _cube_display_from(mem_cube_id: str) -> str:
+    if "public" in (mem_cube_id or "").lower():
+        return "PublicMemCube"
+    return "UserMemCube"
+
+
+_TYPE_SHORT = {
+    "LongTermMemory": "LTM",
+    "UserMemory": "User",
+    "WorkingMemory": "Working",
+    "ActivationMemory": "Activation",
+    "ParameterMemory": "Parameter",
+    "TextMemory": "Text",
+    "UserInput": "Input",
+    "NotApplicable": "NA",
+}
+
+
+def _format_entry(item: ScheduleLogForWebItem) -> tuple[str, str]:
+    cube_display = getattr(item, "memcube_name", None) or _cube_display_from(item.mem_cube_id)
+    label = item.label
+    content = item.log_content or ""
+    memcube_content = getattr(item, "memcube_log_content", None) or []
+    memory_len = getattr(item, "memory_len", None) or len(memcube_content) or 1
+
+    def _first_content() -> str:
+        if memcube_content:
+            return memcube_content[0].get("content", "") or content
+        return content
+
+    if label in ("addMessage", QUERY_LABEL, ANSWER_LABEL):
+        target_cube = cube_display.replace("MemCube", "")
+        title = _format_title(item.timestamp, f"addMessages to {target_cube} MemCube")
+        return title, _truncate_with_rules(_first_content())
+
+    if label in ("addMemory", ADD_LABEL):
+        title = _format_title(item.timestamp, f"{cube_display} added {memory_len} memories")
+        return title, _truncate_with_rules(_first_content())
+
+    if label in ("updateMemory", MEM_UPDATE_LABEL):
+        title = _format_title(item.timestamp, f"{cube_display} updated {memory_len} memories")
+        return title, _truncate_with_rules(_first_content())
+
+    if label in ("archiveMemory", MEM_ARCHIVE_LABEL):
+        title = _format_title(item.timestamp, f"{cube_display} archived {memory_len} memories")
+        return title, _truncate_with_rules(_first_content())
+
+    if label in ("mergeMemory", MEM_ORGANIZE_LABEL):
+        title = _format_title(item.timestamp, f"{cube_display} merged {memory_len} memories")
+        merged = [c for c in memcube_content if c.get("type") == "merged"]
+        post = [c for c in memcube_content if c.get("type") == "postMerge"]
+        parts = []
+        if merged:
+            parts.append("Merged: " + " | ".join(c.get("content", "") for c in merged))
+        if post:
+            parts.append("Result: " + " | ".join(c.get("content", "") for c in post))
+        detail = " ".join(parts) if parts else _first_content()
+        return title, _truncate_with_rules(detail)
+
+    if label == "scheduleMemory":
+        title = _format_title(item.timestamp, f"{cube_display} scheduled {memory_len} memories")
+        if memcube_content:
+            return title, _truncate_with_rules(memcube_content[0].get("content", ""))
+        key = transform_name_to_key(content)
+        from_short = _TYPE_SHORT.get(item.from_memory_type, item.from_memory_type)
+        to_short = _TYPE_SHORT.get(item.to_memory_type, item.to_memory_type)
+        return title, _truncate_with_rules(f"[{from_short}→{to_short}] {key}: {content}")
+
+    title = _format_title(item.timestamp, f"{cube_display} event")
+    return title, _truncate_with_rules(_first_content())
+
+
 def show_web_logs(mem_scheduler: GeneralScheduler):
     """Display all web log entries from the scheduler's log queue.
 
@@ -84,24 +174,25 @@ def show_web_logs(mem_scheduler: GeneralScheduler):
 
     # Create a temporary queue to preserve the original queue contents
     temp_queue = Queue()
-    log_count = 0
+    collected: list[ScheduleLogForWebItem] = []
 
     while not mem_scheduler._web_log_message_queue.empty():
         log_item: ScheduleLogForWebItem = mem_scheduler._web_log_message_queue.get()
+        collected.append(log_item)
         temp_queue.put(log_item)
-        log_count += 1
-
-        # Print log entry details
-        print(f"\nLog Entry #{log_count}:")
-        print(f'- "{log_item.label}" log: {log_item}')
 
+    for idx, log_item in enumerate(sorted(collected, key=lambda x: x.timestamp, reverse=True), 1):
+        title, content = _format_entry(log_item)
+        print(f"\nLog Entry #{idx}:")
+        print(title)
+        print(content)
         print("-" * 50)
 
     # Restore items back to the original queue
     while not temp_queue.empty():
         mem_scheduler._web_log_message_queue.put(temp_queue.get())
 
-    print(f"\nTotal {log_count} web log entries displayed.")
+    print(f"\nTotal {len(collected)} web log entries displayed.")
     print("=" * 110 + "\n")
 
 

src/memos/api/config.py

@@ -328,7 +328,9 @@ def get_memreader_config() -> dict[str, Any]:
                 "top_p": 0.95,
                 "top_k": 20,
                 "api_key": os.getenv("MEMRADER_API_KEY", "EMPTY"),
-                "api_base": os.getenv("MEMRADER_API_BASE"),
+                # Default to OpenAI base URL when env var is not provided to satisfy pydantic
+                # validation requirements during tests/import.
+                "api_base": os.getenv("MEMRADER_API_BASE", "https://api.openai.com/v1"),
                 "remove_think_prefix": True,
                 "extra_body": {"chat_template_kwargs": {"enable_thinking": False}},
             },
@@ -379,7 +381,7 @@ def get_reranker_config() -> dict[str, Any]:
                     "url": os.getenv("MOS_RERANKER_URL"),
                     "model": os.getenv("MOS_RERANKER_MODEL", "bge-reranker-v2-m3"),
                     "timeout": 10,
-                    "headers_extra": os.getenv("MOS_RERANKER_HEADERS_EXTRA"),
+                    "headers_extra": json.loads(os.getenv("MOS_RERANKER_HEADERS_EXTRA", "{}")),
                     "rerank_source": os.getenv("MOS_RERANK_SOURCE"),
                     "reranker_strategy": os.getenv("MOS_RERANKER_STRATEGY", "single_turn"),
                 },
@@ -405,6 +407,7 @@ def get_embedder_config() -> dict[str, Any]:
                     "provider": os.getenv("MOS_EMBEDDER_PROVIDER", "openai"),
                     "api_key": os.getenv("MOS_EMBEDDER_API_KEY", "sk-xxxx"),
                     "model_name_or_path": os.getenv("MOS_EMBEDDER_MODEL", "text-embedding-3-large"),
+                    "headers_extra": json.loads(os.getenv("MOS_EMBEDDER_HEADERS_EXTRA", "{}")),
                     "base_url": os.getenv("MOS_EMBEDDER_API_BASE", "http://openai.com"),
                 },
             }