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

{memmachine_server-0.3.6/src/memmachine_server.egg-info → memmachine_server-0.3.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memmachine-server
-Version: 0.3.6
+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,15 +37,23 @@ 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
+Requires-Dist: qdrant-client>=1.17.0; extra == "qdrant"
 Dynamic: license-file
 
 # MemMachine

{memmachine_server-0.3.6 → 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,9 +58,15 @@ license = "Apache-2.0"
 gpu = [
     "sentence-transformers>=5.1.0",
 ]
+hnswlib = [
+    "hnswlib>=0.8.0",
+]
 nebula = [
     "nebula5-python>=5.2.1",
 ]
+qdrant = [
+    "qdrant-client>=1.17.0",
+]
 
 [project.scripts]
 memmachine-server = "memmachine_server.server.app:main"

{memmachine_server-0.3.6 → memmachine_server-0.3.8}/server_tests/memmachine_server/common/configuration/test_database_conf.py

@@ -5,7 +5,11 @@ from pydantic import SecretStr
 from memmachine_server.common.configuration.database_conf import (
     DatabasesConf,
     Neo4jConf,
+    QdrantConf,
     SqlAlchemyConf,
+    SQLiteVectorStoreConf,
+    SQLiteVectorStoreEngine,
+    SQLiteVecVectorStoreConf,
     SupportedDB,
 )
 
@@ -14,23 +18,44 @@ def test_parse_supported_db_enums():
     assert SupportedDB.from_provider("neo4j") == SupportedDB.NEO4J
     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.is_neo4j
     assert neo4j_db.conf_cls == Neo4jConf
 
     pg_db = SupportedDB.POSTGRES
-    assert not pg_db.is_neo4j
     assert pg_db.conf_cls == SqlAlchemyConf
     assert pg_db.dialect == "postgresql"
     assert pg_db.driver == "asyncpg"
 
     sqlite_db = SupportedDB.SQLITE
-    assert not sqlite_db.is_neo4j
     assert sqlite_db.conf_cls == SqlAlchemyConf
     assert sqlite_db.dialect == "sqlite"
     assert sqlite_db.driver == "aiosqlite"
 
+    qdrant_db = SupportedDB.QDRANT
+    assert qdrant_db.conf_cls == QdrantConf
+    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'"
@@ -80,6 +105,33 @@ def db_conf_dict() -> dict:
                     "path": "local.db",
                 },
             },
+            "my_qdrant": {
+                "provider": "qdrant",
+                "config": {
+                    "host": "qdrant.example.com",
+                    "port": 6333,
+                    "grpc_port": 6334,
+                    "prefer_grpc": True,
+                    "api_key": "test-key",
+                    "is_distributed": True,
+                    "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",
+                },
+            },
         },
     }
 
@@ -122,6 +174,30 @@ def test_parse_valid_storage_dict(db_conf_dict):
     assert isinstance(sqlite_conf, SqlAlchemyConf)
     assert sqlite_conf.uri == "sqlite+aiosqlite:///local.db"
 
+    # Qdrant check
+    qdrant_conf = storage_conf.qdrant_confs["my_qdrant"]
+    assert isinstance(qdrant_conf, QdrantConf)
+    assert qdrant_conf.host == "qdrant.example.com"
+    assert qdrant_conf.port == 6333
+    assert qdrant_conf.grpc_port == 6334
+    assert qdrant_conf.prefer_grpc is True
+    assert qdrant_conf.api_key == SecretStr("test-key")
+    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")
@@ -147,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"
+    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)
 
@@ -157,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):
@@ -212,3 +295,74 @@ def test_neo4j_uri_with_host_and_port():
 def test_neo4j_uri_with_special_host():
     conf = Neo4jConf(host="neo4j+s://xyz", port=3456)
     assert conf.get_uri() == "neo4j+s://xyz"
+
+
+def test_qdrant_conf_defaults():
+    conf = QdrantConf()
+    assert conf.host == "localhost"
+    assert conf.port == 6333
+    assert conf.grpc_port == 6334
+    assert conf.prefer_grpc is False
+    assert conf.https is False
+    assert conf.is_distributed is False
+    assert conf.registry_replication_factor == 1
+    assert conf.api_key.get_secret_value() == ""
+
+
+def test_qdrant_conf_api_key_from_env(monkeypatch):
+    monkeypatch.setenv("QDRANT_API_KEY", "env-qdrant-key")
+    conf = QdrantConf(api_key=SecretStr("$QDRANT_API_KEY"))
+    assert conf.api_key == SecretStr("env-qdrant-key")
+
+
+def test_qdrant_build_config():
+    config = SupportedDB.QDRANT.build_config(
+        {"host": "qdrant.local", "port": 9333, "is_distributed": True}
+    )
+    assert isinstance(config, QdrantConf)
+    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.8/server_tests/memmachine_server/common/embedder/test_embedder.py

@@ -0,0 +1,91 @@
+"""Unit tests for the Embedder base class."""
+
+from typing import Any
+
+import pytest
+
+from memmachine_server.common.data_types import SimilarityMetric
+from memmachine_server.common.embedder.embedder import Embedder
+
+
+class MockEmbedder(Embedder):
+    """Mock implementation of Embedder for testing."""
+
+    def __init__(self, batch_size: int | None = None) -> None:
+        """Initialize the mock embedder."""
+        super().__init__(batch_size=batch_size)
+        self.ingest_calls: list[list[Any]] = []
+        self.search_calls: list[list[Any]] = []
+
+    async def _ingest_embed(
+        self,
+        inputs: list[Any],
+        max_attempts: int = 1,
+    ) -> list[list[float]]:
+        self.ingest_calls.append(inputs)
+        # Return dummy embeddings of dimension 2
+        return [[0.1, 0.2] for _ in inputs]
+
+    async def _search_embed(
+        self,
+        queries: list[Any],
+        max_attempts: int = 1,
+    ) -> list[list[float]]:
+        self.search_calls.append(queries)
+        # Return dummy embeddings of dimension 2
+        return [[0.3, 0.4] for _ in queries]
+
+    @property
+    def model_id(self) -> str:
+        return "mock-model"
+
+    @property
+    def dimensions(self) -> int:
+        return 2
+
+    @property
+    def similarity_metric(self) -> SimilarityMetric:
+        return SimilarityMetric.COSINE
+
+
+@pytest.mark.asyncio
+async def test_embedder_batching() -> None:
+    """Test that the embedder correctly batches inputs."""
+    batch_size = 2
+    embedder = MockEmbedder(batch_size=batch_size)
+
+    # Test ingest_embed batching
+    inputs = ["a", "b", "c", "d", "e"]
+    # Expected batches: ["a", "b"], ["c", "d"], ["e"]
+
+    embeddings = await embedder.ingest_embed(inputs)
+
+    assert len(embeddings) == 5
+    assert len(embedder.ingest_calls) == 3
+    assert embedder.ingest_calls[0] == ["a", "b"]
+    assert embedder.ingest_calls[1] == ["c", "d"]
+    assert embedder.ingest_calls[2] == ["e"]
+
+    # Test search_embed batching
+    queries = ["q1", "q2", "q3"]
+    # Expected batches: ["q1", "q2"], ["q3"]
+
+    search_embeddings = await embedder.search_embed(queries)
+
+    assert len(search_embeddings) == 3
+    assert len(embedder.search_calls) == 2
+    assert embedder.search_calls[0] == ["q1", "q2"]
+    assert embedder.search_calls[1] == ["q3"]
+
+
+@pytest.mark.asyncio
+async def test_embedder_no_batching() -> None:
+    """Test that the embedder works correctly without batching."""
+    embedder = MockEmbedder(batch_size=None)
+
+    inputs = ["a", "b", "c"]
+    embeddings = await embedder.ingest_embed(inputs)
+
+    assert len(embeddings) == 3
+    assert len(embedder.ingest_calls) == 1
+    assert embedder.ingest_calls[0] == ["a", "b", "c"]

{memmachine_server-0.3.6 → 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.6 → memmachine_server-0.3.8}/server_tests/memmachine_server/common/episode_store/test_sqlalchemy_episode_store_startup.py

@@ -102,7 +102,7 @@ async def _cleanup(engine: AsyncEngine) -> None:
 @pytest.mark.asyncio
 async def test_startup_wraps_operational_error():
     engine = _FakeAsyncEngine(OperationalError("select 1", {}, Exception("db down")))
-    store = SqlAlchemyEpisodeStore(engine)  # type: ignore[arg-type]
+    store = SqlAlchemyEpisodeStore(engine)  # type: ignore[arg-type]  # ty: ignore[invalid-argument-type]
 
     with pytest.raises(ConfigurationError) as exc_info:
         await store.startup()
@@ -113,7 +113,7 @@ async def test_startup_wraps_operational_error():
 @pytest.mark.asyncio
 async def test_startup_wraps_socket_gaierror():
     engine = _FakeAsyncEngine(socket.gaierror(8, "dns lookup failed"))
-    store = SqlAlchemyEpisodeStore(engine)  # type: ignore[arg-type]
+    store = SqlAlchemyEpisodeStore(engine)  # type: ignore[arg-type]  # ty: ignore[invalid-argument-type]
 
     with pytest.raises(ConfigurationError) as exc_info:
         await store.startup()