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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memmachine-server
-Version: 0.3.7
+Version: 0.3.8
 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
@@ -37,13 +37,19 @@ 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.8}/pyproject.toml

@@ -28,11 +28,15 @@ dependencies = [
     "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.8}/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.8}/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.8/server_tests/memmachine_server/common/payload_codec/__init__.py

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

memmachine_server-0.3.8/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.8/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