memmachine-server 0.3.7__tar.gz → 0.3.9__tar.gz

{memmachine_server-0.3.7 → memmachine_server-0.3.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memmachine-server
-Version: 0.3.7
+Version: 0.3.9
 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
@@ -31,19 +31,25 @@ 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: 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
+Requires-Dist: babel>=2.18.0
 Provides-Extra: gpu
 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"
 Provides-Extra: qdrant

{memmachine_server-0.3.7 → memmachine_server-0.3.9}/pyproject.toml

@@ -22,17 +22,21 @@ 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",
+    "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",
+    "babel>=2.18.0",
 ]
 requires-python = ">= 3.12"
 authors = [
@@ -54,6 +58,9 @@ license = "Apache-2.0"
 gpu = [
     "sentence-transformers>=5.1.0",
 ]
+hnswlib = [
+    "hnswlib>=0.8.0",
+]
 nebula = [
     "nebula5-python>=5.2.1",
 ]

{memmachine_server-0.3.7 → memmachine_server-0.3.9}/server_tests/memmachine_server/common/configuration/test_configuration.py

@@ -10,8 +10,13 @@ from memmachine_server.common.configuration import (
     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
 
@@ -34,6 +39,7 @@ def test_update_long_term_memory_conf(long_term_memory_conf: LongTermMemoryConfP
     )
 
     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"
@@ -219,3 +225,168 @@ def test_save_raises_error_when_no_path():
 
     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"

{memmachine_server-0.3.7 → memmachine_server-0.3.9}/server_tests/memmachine_server/common/configuration/test_database_conf.py

@@ -7,6 +7,9 @@ from memmachine_server.common.configuration.database_conf import (
     Neo4jConf,
     QdrantConf,
     SqlAlchemyConf,
+    SQLiteVectorStoreConf,
+    SQLiteVectorStoreEngine,
+    SQLiteVecVectorStoreConf,
     SupportedDB,
 )
 
@@ -16,6 +19,14 @@ def test_parse_supported_db_enums():
     assert SupportedDB.from_provider("postgres") == SupportedDB.POSTGRES
     assert SupportedDB.from_provider("sqlite") == SupportedDB.SQLITE
     assert SupportedDB.from_provider("qdrant") == SupportedDB.QDRANT
+    assert (
+        SupportedDB.from_provider("sqlite_vector_store")
+        == SupportedDB.SQLITE_VECTOR_STORE
+    )
+    assert (
+        SupportedDB.from_provider("sqlite_vec_vector_store")
+        == SupportedDB.SQLITE_VEC_VECTOR_STORE
+    )
 
     neo4j_db = SupportedDB.NEO4J
     assert neo4j_db.conf_cls == Neo4jConf
@@ -35,6 +46,16 @@ def test_parse_supported_db_enums():
     assert qdrant_db.dialect is None
     assert qdrant_db.driver is None
 
+    sqlite_vs_db = SupportedDB.SQLITE_VECTOR_STORE
+    assert sqlite_vs_db.conf_cls == SQLiteVectorStoreConf
+    assert sqlite_vs_db.dialect is None
+    assert sqlite_vs_db.driver is None
+
+    sqlite_vec_vs_db = SupportedDB.SQLITE_VEC_VECTOR_STORE
+    assert sqlite_vec_vs_db.conf_cls == SQLiteVecVectorStoreConf
+    assert sqlite_vec_vs_db.dialect is None
+    assert sqlite_vec_vs_db.driver is None
+
 
 def test_sqlite_without_path_raises():
     message = "non-empty 'path'"
@@ -96,6 +117,21 @@ def db_conf_dict() -> dict:
                     "registry_replication_factor": 3,
                 },
             },
+            "my_sqlite_vs": {
+                "provider": "sqlite_vector_store",
+                "config": {
+                    "path": "vs.db",
+                    "vector_search_engine": "hnswlib",
+                    "index_directory": "/tmp/vs_indexes",
+                    "save_threshold": 500,
+                },
+            },
+            "my_sqlite_vec_vs": {
+                "provider": "sqlite_vec_vector_store",
+                "config": {
+                    "path": "vec_vs.db",
+                },
+            },
         },
     }
 
@@ -149,6 +185,19 @@ def test_parse_valid_storage_dict(db_conf_dict):
     assert qdrant_conf.is_distributed is True
     assert qdrant_conf.registry_replication_factor == 3
 
+    # SQLiteVectorStore (hnswlib engine)
+    sqlite_vs_conf = storage_conf.sqlite_vector_store_confs["my_sqlite_vs"]
+    assert isinstance(sqlite_vs_conf, SQLiteVectorStoreConf)
+    assert sqlite_vs_conf.path == "vs.db"
+    assert sqlite_vs_conf.vector_search_engine == SQLiteVectorStoreEngine.HNSWLIB
+    assert sqlite_vs_conf.index_directory == "/tmp/vs_indexes"
+    assert sqlite_vs_conf.save_threshold == 500
+
+    # SQLiteVecVectorStore
+    sqlite_vec_vs_conf = storage_conf.sqlite_vec_vector_store_confs["my_sqlite_vec_vs"]
+    assert isinstance(sqlite_vec_vs_conf, SQLiteVecVectorStoreConf)
+    assert sqlite_vec_vs_conf.path == "vec_vs.db"
+
 
 def test_read_db_password_from_env(monkeypatch, db_conf_dict):
     monkeypatch.setenv("MY_DB_PASSWORD", "env-db-password")
@@ -174,7 +223,10 @@ def test_parse_unknown_provider_raises():
     input_dict = {
         "databases": {"bad_storage": {"provider": "unknown_db", "host": "localhost"}},
     }
-    message = "Supported providers are: neo4j, postgres, sqlite, nebula_graph, qdrant"
+    message = (
+        "Supported providers are: neo4j, postgres, sqlite, nebula_graph, qdrant, "
+        "sqlite_vector_store, sqlite_vec_vector_store"
+    )
     with pytest.raises(ValueError, match=message):
         DatabasesConf.parse(input_dict)
 
@@ -184,6 +236,10 @@ def test_parse_empty_storage_returns_empty_conf():
     storage_conf = DatabasesConf.parse(input_dict)
     assert storage_conf.neo4j_confs == {}
     assert storage_conf.relational_db_confs == {}
+    assert storage_conf.nebula_graph_confs == {}
+    assert storage_conf.qdrant_confs == {}
+    assert storage_conf.sqlite_vector_store_confs == {}
+    assert storage_conf.sqlite_vec_vector_store_confs == {}
 
 
 def test_serialize_deserialize_database_conf(db_conf_dict):
@@ -267,3 +323,46 @@ def test_qdrant_build_config():
     assert config.host == "qdrant.local"
     assert config.port == 9333
     assert config.is_distributed is True
+
+
+def test_sqlite_vector_store_conf_defaults():
+    conf = SQLiteVectorStoreConf(path="local.db")
+    assert conf.path == "local.db"
+    # USearch is the default search engine provider.
+    assert conf.vector_search_engine == SQLiteVectorStoreEngine.USEARCH
+    # Index persistence is opt-in.
+    assert conf.index_directory is None
+    assert conf.save_threshold == 1000
+
+
+def test_sqlite_vector_store_conf_does_not_expose_engine_tuning_knobs():
+    """Per-engine tuning knobs (M, ef_*) must not leak into configuration."""
+    fields = SQLiteVectorStoreConf.model_fields
+    assert "m" not in fields
+    assert "ef_construction" not in fields
+    assert "ef_search" not in fields
+
+
+def test_sqlite_vector_store_conf_requires_path():
+    with pytest.raises(ValueError, match="non-empty 'path'"):
+        SQLiteVectorStoreConf(path="")
+
+
+def test_sqlite_vec_vector_store_conf_requires_path():
+    with pytest.raises(ValueError, match="non-empty 'path'"):
+        SQLiteVecVectorStoreConf(path="")
+
+
+def test_sqlite_vector_store_build_config():
+    config = SupportedDB.SQLITE_VECTOR_STORE.build_config(
+        {"path": "vs.db", "vector_search_engine": "hnswlib"}
+    )
+    assert isinstance(config, SQLiteVectorStoreConf)
+    assert config.path == "vs.db"
+    assert config.vector_search_engine == SQLiteVectorStoreEngine.HNSWLIB
+
+
+def test_sqlite_vec_vector_store_build_config():
+    config = SupportedDB.SQLITE_VEC_VECTOR_STORE.build_config({"path": "vec.db"})
+    assert isinstance(config, SQLiteVecVectorStoreConf)
+    assert config.path == "vec.db"

{memmachine_server-0.3.7 → memmachine_server-0.3.9}/server_tests/memmachine_server/common/episode_store/test_episode_model.py

@@ -1,5 +1,6 @@
 """Test for the Episode models."""
 
+import json
 from datetime import UTC, datetime
 
 import pytest
@@ -60,3 +61,51 @@ def test_episodes_to_string_with_episode_response(base_episode_data):
     assert len(lines) == 1
     line0 = '[Wednesday, January 14, 2026 at 01:30 PM] user_1: "Hello world"'
     assert lines[0] == line0
+
+
+def test_episodes_to_string_message_preserves_non_ascii(base_episode_data):
+    """Non-ASCII content must appear literally in the LLM context, not as
+    ``\\uXXXX`` escapes — escapes inflate the prompt token count and
+    obscure semantic content."""
+    base_episode_data["content"] = "寿司 café 🍕 Привет"
+    ep = Episode(**base_episode_data)
+    result = episodes_to_string([ep])
+
+    assert "寿司" in result
+    assert "café" in result
+    assert "🍕" in result
+    assert "Привет" in result
+    assert "\\u" not in result
+
+    # The JSON-quoted content must round-trip back to the original string.
+    line = result.rstrip("\n")
+    json_part = line.split(": ", 1)[1]
+    assert json.loads(json_part) == "寿司 café 🍕 Привет"
+
+
+def test_episodes_to_string_non_message_preserves_non_ascii(base_episode_data):
+    """The ``case _:`` fallback (e.g. an EpisodeResponse with no episode
+    type) must also preserve Unicode literally."""
+    fallback_data = {k: v for k, v in base_episode_data.items() if k != "session_key"}
+    fallback_data["episode_type"] = None
+    fallback_data["content"] = "要約: ☕ résumé"
+    er = EpisodeResponse(**fallback_data)
+    result = episodes_to_string([er])
+
+    assert "要約" in result
+    assert "☕" in result
+    assert "résumé" in result
+    assert "\\u" not in result
+    assert json.loads(result.rstrip("\n")) == "要約: ☕ résumé"
+
+
+def test_episodes_to_string_output_is_utf8_encodable(base_episode_data):
+    """The formatted string is the exact text fed to LanguageModel prompts;
+    it must be losslessly UTF-8 encodable (no surrogate pairs from broken
+    escaping)."""
+    base_episode_data["content"] = "ASCII + 中文 + 🚀 + emoji modifier 👨‍👩‍👧‍👦"
+    ep = Episode(**base_episode_data)
+    result = episodes_to_string([ep])
+
+    encoded = result.encode("utf-8")
+    assert encoded.decode("utf-8") == result

{memmachine_server-0.3.7 → memmachine_server-0.3.9}/server_tests/memmachine_server/common/episode_store/test_episode_storage.py

@@ -105,6 +105,26 @@ async def test_add_and_get_history(episode_storage: EpisodeStorage):
     assert history.episode_type == EpisodeType.MESSAGE
 
 
+@pytest.mark.asyncio
+async def test_get_episodes_batch(episode_storage: EpisodeStorage):
+    first = await create_history_entry(episode_storage, content="first")
+    second = await create_history_entry(episode_storage, content="second")
+    third = await create_history_entry(episode_storage, content="third")
+
+    try:
+        # All present; duplicates are deduped; missing IDs are absent.
+        fetched = await episode_storage.get_episodes([first, third, first, "999999999"])
+        by_uid = {ep.uid: ep for ep in fetched}
+        assert set(by_uid.keys()) == {first, third}
+        assert by_uid[first].content == "first"
+        assert by_uid[third].content == "third"
+
+        # Empty input returns empty list without hitting the DB.
+        assert await episode_storage.get_episodes([]) == []
+    finally:
+        await episode_storage.delete_episodes([first, second, third])
+
+
 @pytest.mark.asyncio
 async def test_add_multiple_episodes_returns_models(
     episode_storage: EpisodeStorage,

memmachine_server-0.3.9/server_tests/memmachine_server/common/payload_codec/__init__.py

@@ -0,0 +1 @@
+"""Tests for payload codecs."""

memmachine_server-0.3.9/server_tests/memmachine_server/common/payload_codec/test_payload_codec.py

@@ -0,0 +1,16 @@
+"""Tests for payload codecs."""
+
+from memmachine_server.common.payload_codec.plaintext_payload_codec import (
+    PlaintextPayloadCodec,
+)
+
+
+def test_plaintext_payload_codec_round_trip() -> None:
+    codec = PlaintextPayloadCodec()
+    value = b'{"type":"message","source":"User"}'
+
+    encoded = codec.encode(value)
+    decoded = codec.decode(encoded)
+
+    assert encoded == value
+    assert decoded == value

memmachine_server-0.3.9/server_tests/memmachine_server/common/payload_codec/test_payload_codec_config.py

@@ -0,0 +1,18 @@
+"""Tests for payload codec configuration."""
+
+from memmachine_server.common.payload_codec import (
+    decode_payload_codec_config,
+    encode_payload_codec_config,
+)
+from memmachine_server.common.payload_codec.payload_codec_config import (
+    PlaintextPayloadCodecConfig,
+)
+
+
+def test_plaintext_payload_codec_config_round_trip() -> None:
+    config = PlaintextPayloadCodecConfig()
+
+    serialized = encode_payload_codec_config(config)
+    deserialized = decode_payload_codec_config(serialized)
+
+    assert deserialized == config