memmachine-server 0.3.8__tar.gz → 0.4.0__tar.gz

{memmachine_server-0.3.8 → memmachine_server-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memmachine-server
-Version: 0.3.8
+Version: 0.4.0
 Summary: MemMachine Server - The complete MemMachine memory system server with episodic and profile memory
 Author-email: MemMachine <noreply@memmachine.ai>
 License-Expression: Apache-2.0
@@ -20,9 +20,8 @@ Requires-Dist: alembic>=1.17.1
 Requires-Dist: asyncpg>=0.31.0
 Requires-Dist: aiosqlite>=0.20.0
 Requires-Dist: boto3>=1.40.40
-Requires-Dist: boto3-stubs==1.40.64
 Requires-Dist: cohere>=5.20.0
-Requires-Dist: dotenv>=0.9.9
+Requires-Dist: python-dotenv>=1.2.2
 Requires-Dist: fastapi>=0.116.1
 Requires-Dist: fastmcp>=3.2.0
 Requires-Dist: instructor[bedrock]>=1.12.0
@@ -31,17 +30,15 @@ Requires-Dist: langchain-aws>=0.2.33
 Requires-Dist: neo4j>=5.28.2
 Requires-Dist: nltk>=3.9.4
 Requires-Dist: openai>=2.21.0
-Requires-Dist: pgvector>=0.4.1
+Requires-Dist: pgvector>=0.4.2
 Requires-Dist: prometheus-client>=0.22.1
 Requires-Dist: pydantic>=2.11.7
 Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: rank-bm25>=0.2.2
-Requires-Dist: regex>=2023.0.0
 Requires-Dist: sqlite-vec>=0.1.9
-Requires-Dist: sqlalchemy>=2.0.43
+Requires-Dist: sqlalchemy[asyncio]>=2.0.43
 Requires-Dist: usearch>=2.25.1
 Requires-Dist: uvicorn>=0.35.0
-Requires-Dist: greenlet>=3.2.4
 Requires-Dist: tzdata>=2024.1; sys_platform == "win32"
 Requires-Dist: psutil>=7.1.0
 Requires-Dist: langchain-text-splitters>=1.1.1
@@ -51,9 +48,14 @@ Requires-Dist: sentence-transformers>=5.1.0; extra == "gpu"
 Provides-Extra: hnswlib
 Requires-Dist: hnswlib>=0.8.0; extra == "hnswlib"
 Provides-Extra: nebula
-Requires-Dist: nebula5-python>=5.2.1; extra == "nebula"
+Requires-Dist: nebula5-python<5.3,>=5.2.1; extra == "nebula"
 Provides-Extra: qdrant
 Requires-Dist: qdrant-client>=1.17.0; extra == "qdrant"
+Provides-Extra: milvus
+Requires-Dist: pymilvus>=3.0.0; extra == "milvus"
+Requires-Dist: milvus-lite>=3.0.0; extra == "milvus"
+Provides-Extra: litellm
+Requires-Dist: litellm>=1.93.0; extra == "litellm"
 Dynamic: license-file
 
 # MemMachine

{memmachine_server-0.3.8 → memmachine_server-0.4.0}/pyproject.toml

@@ -11,9 +11,8 @@ dependencies = [
     "asyncpg>=0.31.0",
     "aiosqlite>=0.20.0",
     "boto3>=1.40.40",
-    "boto3-stubs==1.40.64",
     "cohere>=5.20.0",
-    "dotenv>=0.9.9",
+    "python-dotenv>=1.2.2",
     "fastapi>=0.116.1",
     "fastmcp>=3.2.0",
     "instructor[bedrock]>=1.12.0",
@@ -22,17 +21,15 @@ dependencies = [
     "neo4j>=5.28.2",
     "nltk>=3.9.4",
     "openai>=2.21.0",
-    "pgvector>=0.4.1",
+    "pgvector>=0.4.2",
     "prometheus-client>=0.22.1",
     "pydantic>=2.11.7",
     "pyyaml>=6.0.2",
     "rank-bm25>=0.2.2",
-    "regex>=2023.0.0",
     "sqlite-vec>=0.1.9",
-    "sqlalchemy>=2.0.43",
+    "sqlalchemy[asyncio]>=2.0.43",
     "usearch>=2.25.1",
     "uvicorn>=0.35.0",
-    "greenlet>=3.2.4",
     "tzdata>=2024.1 ; sys_platform == 'win32'",
     "psutil>=7.1.0",
     "langchain-text-splitters>=1.1.1",
@@ -62,11 +59,25 @@ hnswlib = [
     "hnswlib>=0.8.0",
 ]
 nebula = [
-    "nebula5-python>=5.2.1",
+    # 5.3 removed the public async client this backend is written against:
+    # NebulaAsyncClient, SessionConfig and SessionPoolConfig are gone, and the
+    # AsyncNebulaClient that replaces NebulaAsyncClient has no public way to
+    # open a connection -- only the private _init_client(). Until it does, the
+    # async backend cannot move past 5.2.
+    "nebula5-python>=5.2.1,<5.3",
 ]
 qdrant = [
     "qdrant-client>=1.17.0",
 ]
+milvus = [
+    "pymilvus>=3.0.0",
+    "milvus-lite>=3.0.0",
+]
+litellm = [
+    # 1.93 is the first release that supports Python 3.14; 1.83.8 through
+    # 1.92 cap themselves at <3.14.
+    "litellm>=1.93.0",
+]
 
 [project.scripts]
 memmachine-server = "memmachine_server.server.app:main"
@@ -98,6 +109,14 @@ extra-paths = ["../common/src", "../client/src"]
 [tool.ty.src]
 exclude = ["build/**"]
 
+[tool.ty.analysis]
+# spaCy is an optional dependency (the ``multihop`` dependency-group) and is not
+# installed in the type-checking environments (notably the Python 3.14 matrix,
+# where spaCy 3.8.x has no wheels). Suppress unresolved-import for spaCy so the
+# static checks pass without it; the decomposer falls back to LLM splitting at
+# runtime when spaCy is absent.
+allowed-unresolved-imports = ["spacy.**"]
+
 [tool.ruff]
 extend = "../../pyproject.toml"
 target-version = "py312"

memmachine_server-0.4.0/server_tests/memmachine_server/common/api/test_version.py

@@ -0,0 +1,8 @@
+"""test version information."""
+
+from memmachine_common.api.spec import Version
+
+
+def test_version_string():
+    version = Version(server_version="0.2.2", client_version="0.2.2")
+    assert str(version) == "server: 0.2.2\nclient: 0.2.2"

memmachine_server-0.4.0/server_tests/memmachine_server/common/configuration/test_configuration.py

@@ -0,0 +1,457 @@
+import logging
+from pathlib import Path
+
+import pytest
+import yaml
+from pydantic import SecretStr
+
+from memmachine_server.common.configuration import (
+    Configuration,
+    EpisodicMemoryConfPartial,
+)
+from memmachine_server.common.configuration.episodic_config import (
+    DeclarativeLongTermMemoryConf,
+    EpisodicMemoryConf,
+    EventLongTermMemoryConf,
+    LongTermMemoryConfPartial,
+    PassthroughSegmenterConf,
+    ShortTermMemoryConfPartial,
+    WholeTextDeriverConf,
+)
+from memmachine_server.common.configuration.log_conf import LogLevel
+
+logger = logging.getLogger(__name__)
+
+
+@pytest.fixture
+def long_term_memory_conf() -> LongTermMemoryConfPartial:
+    return LongTermMemoryConfPartial(
+        embedder="embedder_v1",
+        reranker="reranker_v1",
+        vector_graph_store="store_v1",
+    )
+
+
+def test_update_long_term_memory_conf(long_term_memory_conf: LongTermMemoryConfPartial):
+    specific = LongTermMemoryConfPartial(
+        session_id="session_123",
+        embedder="embedder_v2",
+    )
+
+    updated = specific.merge(long_term_memory_conf)
+    assert isinstance(updated, DeclarativeLongTermMemoryConf)
+    assert updated.session_id == "session_123"
+    assert updated.embedder == "embedder_v2"
+    assert updated.reranker == "reranker_v1"
+    assert updated.vector_graph_store == "store_v1"
+
+
+@pytest.fixture
+def short_term_memory_conf() -> ShortTermMemoryConfPartial:
+    return ShortTermMemoryConfPartial(
+        llm_model="model_v1",
+        message_capacity=12345,
+        summary_prompt_user="Summarize the following:",
+        summary_prompt_system="You are a helpful assistant.",
+    )
+
+
+def test_update_session_memory_conf(short_term_memory_conf: ShortTermMemoryConfPartial):
+    specific = ShortTermMemoryConfPartial(
+        session_key="session_123",
+        message_capacity=3000,
+    )
+
+    updated = specific.merge(short_term_memory_conf)
+    assert updated.session_key == "session_123"
+    assert updated.llm_model == "model_v1"
+    assert updated.message_capacity == 3000
+
+
+def test_update_episodic_memory_conf(
+    long_term_memory_conf: LongTermMemoryConfPartial,
+    short_term_memory_conf: ShortTermMemoryConfPartial,
+):
+    base = EpisodicMemoryConfPartial(
+        short_term_memory=short_term_memory_conf,
+        long_term_memory=long_term_memory_conf,
+        metrics_factory_id="metrics_factory_id",
+    )
+    specific = EpisodicMemoryConfPartial(
+        session_key="session_123",
+        long_term_memory=LongTermMemoryConfPartial(embedder="embedder_v2"),
+    )
+
+    updated = specific.merge(base)
+    assert updated.long_term_memory is not None
+    assert updated.short_term_memory is not None
+    assert updated.long_term_memory.embedder == "embedder_v2"
+    assert updated.long_term_memory.reranker == "reranker_v1"
+    assert updated.short_term_memory is not None
+    assert updated.short_term_memory.session_key == "session_123"
+    assert updated.short_term_memory.message_capacity == 12345
+
+
+def find_config_file(filename: str, start_path: Path | None = None) -> Path:
+    """Search parent directories for `sample_configs/filename`."""
+    if start_path is None:
+        start_path = Path(__file__).resolve()
+
+    current = start_path.parent
+
+    while current != current.parent:  # until we reach root
+        candidate = current / "sample_configs" / filename
+        if candidate.is_file():
+            return candidate
+        current = current.parent
+
+    raise FileNotFoundError(
+        f"Could not find '{filename}' in any parent 'sample_configs' folder.",
+    )
+
+
+def test_load_sample_cpu_config():
+    config_path = find_config_file("episodic_memory_config.cpu.sample")
+    conf = Configuration.load_yml_file(str(config_path))
+    resources_conf = conf.resources
+    assert conf.logging.level == LogLevel.INFO
+    assert conf.session_manager.database == "profile_storage"
+    assert (
+        len(resources_conf.language_models.openai_chat_completions_language_model_confs)
+        > 0
+    )
+    assert (
+        resources_conf.language_models.openai_chat_completions_language_model_confs[
+            "ollama_model"
+        ].model
+        == "llama3"
+    )
+    postgres_conf = resources_conf.databases.relational_db_confs["profile_storage"]
+    assert postgres_conf.password == SecretStr("<YOUR_PASSWORD_HERE>")
+    assert conf.semantic_memory.database == "profile_storage"
+    embedder_conf = resources_conf.embedders.openai["openai_embedder"]
+    assert embedder_conf.api_key == SecretStr("<YOUR_API_KEY>")
+    reranker_conf = resources_conf.rerankers.amazon_bedrock["aws_reranker_id"]
+    assert reranker_conf.aws_access_key_id == SecretStr("<AWS_ACCESS_KEY_ID>")
+    assert isinstance(conf.prompt.episode_summary_user_prompt, str)
+    assert len(conf.prompt.episode_summary_user_prompt) > 0
+    assert "concise" in conf.prompt.episode_summary_system_prompt
+
+
+def test_load_sample_gpu_config():
+    config_path = find_config_file("episodic_memory_config.gpu.sample")
+    conf = Configuration.load_yml_file(str(config_path))
+    assert conf.logging.level == LogLevel.INFO
+
+
+def test_serialize_and_deserialize_configuration():
+    config_path = find_config_file("episodic_memory_config.gpu.sample")
+    conf = Configuration.load_yml_file(str(config_path))
+    yaml_str = conf.to_yaml()
+    logger.debug("configuration yaml string:\n%s", yaml_str)
+    data = yaml.safe_load(yaml_str)
+    conf_cp = Configuration(**data)
+    # Compare YAML output since _config_file_path differs (set vs None)
+    assert conf_cp.to_yaml() == yaml_str
+
+
+def test_load_yml_file_sets_config_file_path():
+    """Test that load_yml_file stores the file path in the configuration."""
+    config_path = find_config_file("episodic_memory_config.gpu.sample")
+    conf = Configuration.load_yml_file(str(config_path))
+    assert conf.config_file_path == str(config_path)
+
+
+def test_config_file_path_none_when_not_loaded_from_file():
+    """Test that config_file_path is None when configuration is created directly."""
+    config_path = find_config_file("episodic_memory_config.gpu.sample")
+    conf = Configuration.load_yml_file(str(config_path))
+    # Create a new configuration from the same data (not from file)
+    yaml_str = conf.to_yaml()
+    data = yaml.safe_load(yaml_str)
+    conf_direct = Configuration(**data)
+    assert conf_direct.config_file_path is None
+
+
+def test_save_configuration_to_file(tmp_path):
+    """Test that save() writes configuration to a file."""
+    config_path = find_config_file("episodic_memory_config.gpu.sample")
+    conf = Configuration.load_yml_file(str(config_path))
+
+    # Save to a new file
+    save_path = tmp_path / "saved_config.yml"
+    conf.save(str(save_path))
+
+    # Verify file was created and can be loaded
+    assert save_path.exists()
+    loaded_conf = Configuration.load_yml_file(str(save_path))
+    # Compare YAML output since _config_file_path differs between instances
+    assert loaded_conf.to_yaml() == conf.to_yaml()
+
+
+def test_save_configuration_to_original_path(tmp_path):
+    """Test that save() writes to original path when no path is provided."""
+    # First, create a config file in tmp_path
+    config_path = find_config_file("episodic_memory_config.gpu.sample")
+    original_conf = Configuration.load_yml_file(str(config_path))
+
+    temp_config_path = tmp_path / "test_config.yml"
+    temp_config_path.write_text(original_conf.to_yaml(), encoding="utf-8")
+
+    # Load from temp path
+    conf = Configuration.load_yml_file(str(temp_config_path))
+    assert conf.config_file_path == str(temp_config_path)
+
+    # Modify something (just to ensure save works)
+    conf.server.port = 9999
+
+    # Save without providing path (should use original path)
+    conf.save()
+
+    # Reload and verify
+    reloaded = Configuration.load_yml_file(str(temp_config_path))
+    assert reloaded.server.port == 9999
+
+
+def test_save_raises_error_when_no_path():
+    """Test that save() raises ValueError when no path is available."""
+    config_path = find_config_file("episodic_memory_config.gpu.sample")
+    conf = Configuration.load_yml_file(str(config_path))
+
+    # Create a new configuration without file path
+    yaml_str = conf.to_yaml()
+    data = yaml.safe_load(yaml_str)
+    conf_no_path = Configuration(**data)
+
+    with pytest.raises(ValueError, match="No path provided"):
+        conf_no_path.save()
+
+
+# --- Backwards-compat: long-term-memory backend discriminator ---
+
+
+def _ltm_minimal_short_term_block() -> dict:
+    return {
+        "session_key": "s",
+        "llm_model": "m",
+        "summary_prompt_system": "x",
+        "summary_prompt_user": "y",
+    }
+
+
+def test_old_param_data_without_backend_loads_as_declarative():
+    """Old persisted session param_data (no `backend`) round-trips as declarative.
+
+    Reproduces the historical session_data_manager_sql_impl.py:306 path:
+    `EpisodicMemoryConf(**session.param_data)` for a row written before the
+    backend discriminator existed.
+    """
+    old_param_data = {
+        "session_key": "old_session",
+        "long_term_memory": {
+            "session_id": "old_session",
+            "embedder": "openai_embedder",
+            "reranker": "my_reranker_id",
+            "vector_graph_store": "my_storage_id",
+        },
+        "short_term_memory": _ltm_minimal_short_term_block(),
+        "long_term_memory_enabled": True,
+        "short_term_memory_enabled": True,
+        "enabled": True,
+    }
+
+    conf = EpisodicMemoryConf.model_validate(old_param_data)
+    assert isinstance(conf.long_term_memory, DeclarativeLongTermMemoryConf)
+    assert conf.long_term_memory.backend == "declarative"
+    assert conf.long_term_memory.embedder == "openai_embedder"
+    assert conf.long_term_memory.vector_graph_store == "my_storage_id"
+
+
+def test_episodic_memory_conf_with_explicit_event_backend_loads_as_event():
+    data = {
+        "session_key": "s",
+        "long_term_memory": {
+            "backend": "event",
+            "session_id": "s",
+            "vector_store": "vstore",
+            "segment_store": "pg_engine",
+            "embedder": "openai_embedder",
+        },
+        "short_term_memory": _ltm_minimal_short_term_block(),
+    }
+
+    conf = EpisodicMemoryConf.model_validate(data)
+    assert isinstance(conf.long_term_memory, EventLongTermMemoryConf)
+    assert conf.long_term_memory.vector_store == "vstore"
+    assert conf.long_term_memory.segment_store == "pg_engine"
+    # Default sub-configs.
+    assert isinstance(conf.long_term_memory.segmenter, PassthroughSegmenterConf)
+    assert isinstance(conf.long_term_memory.deriver, WholeTextDeriverConf)
+    # Reranker is optional on the event backend.
+    assert conf.long_term_memory.reranker is None
+
+
+def test_episodic_memory_conf_with_explicit_declarative_backend_loads_as_declarative():
+    data = {
+        "session_key": "s",
+        "long_term_memory": {
+            "backend": "declarative",
+            "session_id": "s",
+            "vector_graph_store": "g",
+            "embedder": "e",
+            "reranker": "r",
+        },
+        "short_term_memory": _ltm_minimal_short_term_block(),
+    }
+
+    conf = EpisodicMemoryConf.model_validate(data)
+    assert isinstance(conf.long_term_memory, DeclarativeLongTermMemoryConf)
+    assert conf.long_term_memory.vector_graph_store == "g"
+
+
+def test_partial_merge_with_no_backend_resolves_to_declarative():
+    """LongTermMemoryConfPartial.merge() defaults missing backend to declarative."""
+    base = LongTermMemoryConfPartial(
+        session_id="s",
+        embedder="e",
+        reranker="r",
+        vector_graph_store="g",
+    )
+    override = LongTermMemoryConfPartial(embedder="e2")
+
+    merged = override.merge(base)
+    assert isinstance(merged, DeclarativeLongTermMemoryConf)
+    assert merged.embedder == "e2"
+    assert merged.reranker == "r"
+    assert merged.vector_graph_store == "g"
+
+
+def test_partial_merge_with_event_backend_resolves_to_event():
+    base = LongTermMemoryConfPartial(
+        backend="event",
+        session_id="s",
+        embedder="e",
+        vector_store="v",
+        segment_store="seg",
+    )
+    override = LongTermMemoryConfPartial()
+
+    merged = override.merge(base)
+    assert isinstance(merged, EventLongTermMemoryConf)
+    assert merged.vector_store == "v"
+    assert merged.segment_store == "seg"
+    assert merged.embedder == "e"
+    assert merged.reranker is None
+
+
+def test_partial_merge_explicit_declarative_backend():
+    base = LongTermMemoryConfPartial(
+        backend="declarative",
+        session_id="s",
+        embedder="e",
+        reranker="r",
+        vector_graph_store="g",
+    )
+    merged = LongTermMemoryConfPartial().merge(base)
+    assert isinstance(merged, DeclarativeLongTermMemoryConf)
+
+
+def test_partial_merge_primary_backend_wins_over_fallback():
+    """Primary backend takes precedence over fallback."""
+    primary = LongTermMemoryConfPartial(
+        backend="event",
+        session_id="s",
+        embedder="e",
+        vector_store="v",
+        segment_store="seg",
+    )
+    fallback = LongTermMemoryConfPartial(
+        backend="declarative",
+        session_id="s",
+        embedder="e",
+        reranker="r",
+        vector_graph_store="g",
+    )
+    merged = primary.merge(fallback)
+    assert isinstance(merged, EventLongTermMemoryConf)
+
+
+def test_existing_sample_yaml_loads_as_declarative_via_full_configuration():
+    """Existing sample YAMLs (no `backend` field) load through Configuration."""
+    config_path = find_config_file("episodic_memory_config.cpu.sample")
+    conf = Configuration.load_yml_file(str(config_path))
+    assert conf.episodic_memory.long_term_memory is not None
+    # Configuration.episodic_memory is the partial; backend stays None on load.
+    assert conf.episodic_memory.long_term_memory.backend is None
+    # ...and merging the LTM partial alone resolves to declarative.
+    ltm_merged = LongTermMemoryConfPartial(session_id="test_session").merge(
+        conf.episodic_memory.long_term_memory
+    )
+    assert isinstance(ltm_merged, DeclarativeLongTermMemoryConf)
+    assert ltm_merged.embedder == "openai_embedder"
+    assert ltm_merged.vector_graph_store == "my_storage_id"
+
+
+def _sample_config_data() -> dict:
+    config_path = find_config_file("episodic_memory_config.cpu.sample")
+    return yaml.safe_load(config_path.read_text(encoding="utf-8"))
+
+
+def test_configuration_loads_without_semantic_memory_section():
+    data = _sample_config_data()
+    data.pop("semantic_memory")
+
+    conf = Configuration(**data)
+
+    assert conf.semantic_memory.enabled is False
+    assert conf.semantic_memory.config_database is None
+
+
+def test_configuration_semantic_memory_disabled_with_enabled_false_alone():
+    data = _sample_config_data()
+    data["semantic_memory"] = {"enabled": False}
+
+    conf = Configuration(**data)
+
+    assert conf.semantic_memory.enabled is False
+
+
+@pytest.mark.parametrize("section", [None, {}])
+def test_configuration_empty_semantic_section_is_disabled(section, caplog):
+    """A null or empty section is disabled silently, like an omitted one."""
+    data = _sample_config_data()
+    data["semantic_memory"] = section
+
+    with caplog.at_level(logging.WARNING):
+        conf = Configuration(**data)
+
+    assert conf.semantic_memory.enabled is False
+    assert "auto-disabled" not in caplog.text
+
+
+def test_disabled_semantic_memory_round_trips_through_yaml():
+    """A complete-but-disabled section keeps enabled: false across save + reload."""
+    data = _sample_config_data()
+    data["semantic_memory"]["enabled"] = False
+    conf = Configuration(**data)
+
+    dumped = yaml.safe_load(conf.to_yaml())
+    conf_cp = Configuration(**dumped)
+
+    assert dumped["semantic_memory"]["enabled"] is False
+    assert dumped["semantic_memory"]["config_database"] == "profile_storage"
+    assert conf_cp.semantic_memory.enabled is False
+
+
+def test_bare_disabled_semantic_memory_round_trips_through_yaml():
+    """The minimal {enabled: false} section survives the serializer's empty-value drop."""
+    data = _sample_config_data()
+    data["semantic_memory"] = {"enabled": False}
+    conf = Configuration(**data)
+
+    dumped = yaml.safe_load(conf.to_yaml())
+    conf_cp = Configuration(**dumped)
+
+    assert dumped["semantic_memory"]["enabled"] is False
+    assert "config_database" not in dumped["semantic_memory"]
+    assert conf_cp.semantic_memory.enabled is False