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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memmachine-server
-Version: 0.3.9
+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
@@ -36,12 +35,10 @@ 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.9 → 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",
@@ -27,12 +26,10 @@ dependencies = [
     "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.3.9 → memmachine_server-0.4.0}/server_tests/memmachine_server/common/configuration/test_configuration.py

@@ -390,3 +390,68 @@ def test_existing_sample_yaml_loads_as_declarative_via_full_configuration():
     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

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

@@ -4,6 +4,7 @@ from pydantic import SecretStr
 
 from memmachine_server.common.configuration.database_conf import (
     DatabasesConf,
+    MilvusConf,
     Neo4jConf,
     QdrantConf,
     SqlAlchemyConf,
@@ -46,6 +47,12 @@ def test_parse_supported_db_enums():
     assert qdrant_db.dialect is None
     assert qdrant_db.driver is None
 
+    milvus_db = SupportedDB.MILVUS
+    assert SupportedDB.from_provider("milvus") == milvus_db
+    assert milvus_db.conf_cls == MilvusConf
+    assert milvus_db.dialect is None
+    assert milvus_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
@@ -113,10 +120,18 @@ def db_conf_dict() -> dict:
                     "grpc_port": 6334,
                     "prefer_grpc": True,
                     "api_key": "test-key",
-                    "is_distributed": True,
                     "registry_replication_factor": 3,
                 },
             },
+            "my_milvus": {
+                "provider": "milvus",
+                "config": {
+                    "uri": "https://example.zillizcloud.com",
+                    "token": "test-token",
+                    "db_name": "memory",
+                    "consistency_level": "Strong",
+                },
+            },
             "my_sqlite_vs": {
                 "provider": "sqlite_vector_store",
                 "config": {
@@ -138,7 +153,13 @@ def db_conf_dict() -> dict:
 
 @pytest.fixture(autouse=True)
 def clear_env(monkeypatch):
-    for var in ["MY_NEO4J_PASSWORD", "MY_DB_PASSWORD"]:
+    for var in [
+        "MY_NEO4J_PASSWORD",
+        "MY_DB_PASSWORD",
+        "MILVUS_URI",
+        "MILVUS_TOKEN",
+        "MILVUS_DB_NAME",
+    ]:
         monkeypatch.delenv(var, raising=False)
 
 
@@ -182,9 +203,16 @@ def test_parse_valid_storage_dict(db_conf_dict):
     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
 
+    # Milvus check
+    milvus_conf = storage_conf.milvus_confs["my_milvus"]
+    assert isinstance(milvus_conf, MilvusConf)
+    assert milvus_conf.uri == "https://example.zillizcloud.com"
+    assert milvus_conf.token == SecretStr("test-token")
+    assert milvus_conf.db_name == "memory"
+    assert milvus_conf.consistency_level == "Strong"
+
     # SQLiteVectorStore (hnswlib engine)
     sqlite_vs_conf = storage_conf.sqlite_vector_store_confs["my_sqlite_vs"]
     assert isinstance(sqlite_vs_conf, SQLiteVectorStoreConf)
@@ -225,7 +253,7 @@ def test_parse_unknown_provider_raises():
     }
     message = (
         "Supported providers are: neo4j, postgres, sqlite, nebula_graph, qdrant, "
-        "sqlite_vector_store, sqlite_vec_vector_store"
+        "milvus, sqlite_vector_store, sqlite_vec_vector_store"
     )
     with pytest.raises(ValueError, match=message):
         DatabasesConf.parse(input_dict)
@@ -238,6 +266,7 @@ def test_parse_empty_storage_returns_empty_conf():
     assert storage_conf.relational_db_confs == {}
     assert storage_conf.nebula_graph_confs == {}
     assert storage_conf.qdrant_confs == {}
+    assert storage_conf.milvus_confs == {}
     assert storage_conf.sqlite_vector_store_confs == {}
     assert storage_conf.sqlite_vec_vector_store_confs == {}
 
@@ -249,6 +278,35 @@ def test_serialize_deserialize_database_conf(db_conf_dict):
     assert conf == conf_cp
 
 
+def test_milvus_conf_defaults():
+    conf = MilvusConf()
+    assert conf.uri == "./milvus.db"
+    assert conf.token == SecretStr("")
+    assert conf.db_name == ""
+    assert conf.consistency_level == "Session"
+
+
+def test_milvus_conf_reads_env(monkeypatch):
+    monkeypatch.setenv("MILVUS_URI", "https://example.zillizcloud.com")
+    monkeypatch.setenv("MILVUS_TOKEN", "env-token")
+    monkeypatch.setenv("MILVUS_DB_NAME", "memory")
+    conf = MilvusConf(
+        uri="$MILVUS_URI",
+        token=SecretStr("${MILVUS_TOKEN}"),
+        db_name="$MILVUS_DB_NAME",
+    )
+    assert conf.uri == "https://example.zillizcloud.com"
+    assert conf.token == SecretStr("env-token")
+    assert conf.db_name == "memory"
+
+
+def test_milvus_conf_rejects_invalid_values():
+    with pytest.raises(ValueError, match="non-empty 'uri'"):
+        MilvusConf(uri="")
+    with pytest.raises(ValueError, match="consistency_level"):
+        MilvusConf(consistency_level="Linearizable")
+
+
 def test_neo4j_pool_lifecycle_fields():
     # Defaults are None (use driver's internal defaults)
     conf = Neo4jConf()
@@ -304,7 +362,6 @@ def test_qdrant_conf_defaults():
     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() == ""
 
@@ -317,12 +374,12 @@ def test_qdrant_conf_api_key_from_env(monkeypatch):
 
 def test_qdrant_build_config():
     config = SupportedDB.QDRANT.build_config(
-        {"host": "qdrant.local", "port": 9333, "is_distributed": True}
+        {"host": "qdrant.local", "port": 9333, "registry_replication_factor": 2}
     )
     assert isinstance(config, QdrantConf)
     assert config.host == "qdrant.local"
     assert config.port == 9333
-    assert config.is_distributed is True
+    assert config.registry_replication_factor == 2
 
 
 def test_sqlite_vector_store_conf_defaults():

{memmachine_server-0.3.9 → memmachine_server-0.4.0}/server_tests/memmachine_server/common/configuration/test_mixin_confs.py

@@ -200,7 +200,7 @@ def test_password_mixin_without_env():
 
 def test_password_mixin_invalid_type():
     with pytest.raises(ValidationError) as exc:
-        ApiKeyMixin(api_key=12345)  # type: ignore
+        ApiKeyMixin.model_validate({"api_key": 12345})
     assert "should be a valid string" in str(exc.value)
 
 

{memmachine_server-0.3.9 → memmachine_server-0.4.0}/server_tests/memmachine_server/common/configuration/test_semantic_conf.py

@@ -1,6 +1,9 @@
 from datetime import timedelta
 from typing import Any
 
+import pytest
+from pydantic import ValidationError
+
 from memmachine_server.common.configuration import SemanticMemoryConf
 
 
@@ -31,3 +34,39 @@ def test_semantic_config_timedelta_float():
     conf = SemanticMemoryConf(**raw_conf)
     assert conf.ingestion_trigger_messages == 24
     assert conf.ingestion_trigger_age == timedelta(minutes=2, milliseconds=500)
+
+
+def test_semantic_config_disabled_needs_no_config_database():
+    conf = SemanticMemoryConf(enabled=False)
+    assert conf.enabled is False
+    assert conf.config_database is None
+
+
+def test_semantic_config_auto_disables_when_config_database_missing():
+    conf = SemanticMemoryConf(
+        database="database",
+        llm_model="llm",
+        embedding_model="embedding",
+    )
+    assert conf.enabled is False
+
+
+def test_semantic_config_stays_enabled_when_complete():
+    conf = SemanticMemoryConf(
+        database="database",
+        config_database="database",
+        llm_model="llm",
+        embedding_model="embedding",
+    )
+    assert conf.enabled is True
+
+
+def test_semantic_config_sets_missing_episode_grace_period():
+    conf = SemanticMemoryConf(
+        enabled=False,
+        missing_episode_grace_period_sec=45,
+    )
+    assert conf.missing_episode_grace_period_sec == 45
+
+    with pytest.raises(ValidationError):
+        SemanticMemoryConf(enabled=False, missing_episode_grace_period_sec=-1)

{memmachine_server-0.3.9 → memmachine_server-0.4.0}/server_tests/memmachine_server/common/embedder/test_openai_embedder.py

@@ -166,6 +166,46 @@ async def test_embed_oversized_input_with_no_max_input_length():
 
     assert len(result) == 1
     assert len(result[0]) == 256
-    # The text must have been split: balanced chunks of 80,000 chars at limit
-    # 75,000 produce two chunks of 40,000 each, each in its own cluster.
+    # The text must have been split: greedy chunks of 80,000 chars at limit
+    # 75,000 produce chunks of 75,000 and 5,000, each in its own cluster.
     assert mock_client.embeddings.create.call_count >= 2
+
+
+@pytest.mark.asyncio
+async def test_embed_max_input_length_above_request_cap():
+    """max_input_length above max_total_input_length_per_request must not raise.
+
+    A configured chunk limit above the per-request cap can never be honored
+    (no chunk larger than the cap fits in any request), so chunking clamps
+    to the cap instead of handing cluster_texts() a chunk it rejects.
+    """
+    mock_client = AsyncMock(spec=openai.AsyncOpenAI)
+
+    mock_embedding = MagicMock()
+    mock_embedding.embedding = [0.1] * 256
+
+    mock_response = MagicMock()
+    mock_response.data = [mock_embedding]
+    mock_response.usage.prompt_tokens = 10
+    mock_response.usage.total_tokens = 10
+
+    mock_client.embeddings.create = AsyncMock(return_value=mock_response)
+
+    embedder = OpenAIEmbedder(
+        OpenAIEmbedderParams(
+            client=mock_client,
+            model="test-model",
+            dimensions=256,
+            max_input_length=80_000,  # above the 75,000-char per-request cap
+        )
+    )
+
+    long_text = "x" * 100_000
+
+    result = await embedder.ingest_embed([long_text])
+
+    assert len(result) == 1
+    assert len(result[0]) == 256
+    # Clamped to 75,000, the text splits into 75,000 + 25,000 chars, which
+    # exceed one request's total together, so each chunk gets its own call.
+    assert mock_client.embeddings.create.call_count == 2

{memmachine_server-0.3.9 → memmachine_server-0.4.0}/server_tests/memmachine_server/common/episode_store/test_count_caching_episode_storage.py

@@ -1,4 +1,5 @@
 from unittest.mock import AsyncMock, MagicMock
+from uuid import uuid4
 
 import pytest
 
@@ -80,7 +81,8 @@ async def test_deletes_clear_cached_counts(wrapped_store):
         filter_expr=session_filter
     )
 
-    await storage.delete_episodes(["1", "2"])
+    ids = [uuid4(), uuid4()]
+    await storage.delete_episodes(ids)
     after_delete_ids = await storage.get_episode_messages_count(
         filter_expr=session_filter
     )
@@ -93,7 +95,7 @@ async def test_deletes_clear_cached_counts(wrapped_store):
         start_time=None,
         end_time=None,
     )
-    wrapped_store.delete_episodes.assert_awaited_once_with(["1", "2"])
+    wrapped_store.delete_episodes.assert_awaited_once_with(ids)
 
 
 @pytest.mark.asyncio

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

@@ -2,11 +2,12 @@
 
 import json
 from datetime import UTC, datetime
+from uuid import UUID
 
 import pytest
 from memmachine_common.api import EpisodeType
 
-from memmachine_server.common.episode_store import Episode
+from memmachine_server.common.episode_store import Episode, EpisodeEntry
 from memmachine_server.common.episode_store.episode_model import (
     EpisodeResponse,
     episodes_to_string,
@@ -17,7 +18,7 @@ from memmachine_server.common.episode_store.episode_model import (
 def base_episode_data():
     """Provides common data for creating Episode instances."""
     return {
-        "uid": "msg_123",
+        "uid": UUID("550e8400-e29b-41d4-a716-446655440123"),
         "content": "Hello world",
         "session_key": "session_abc",
         "created_at": datetime(2026, 1, 14, 13, 30, tzinfo=UTC),  # Wednesday
@@ -32,11 +33,37 @@ def test_episodes_to_string_empty():
     assert episodes_to_string([]) == ""
 
 
+def test_episode_entry_assigns_distinct_uuid4_ids_before_storage():
+    first = EpisodeEntry(content="first", producer_id="user", producer_role="user")
+    second = EpisodeEntry(content="second", producer_id="user", producer_role="user")
+
+    first_uuid = first.uid
+    second_uuid = second.uid
+
+    assert first_uuid.version == 4
+    assert second_uuid.version == 4
+    assert isinstance(first_uuid, UUID)
+    assert isinstance(second_uuid, UUID)
+    assert first.uid != second.uid
+
+
+def test_episode_entry_preserves_explicit_internal_id():
+    supplied_id = "550e8400-e29b-41d4-a716-446655440000"
+    entry = EpisodeEntry(
+        uid=supplied_id,
+        content="message",
+        producer_id="user",
+        producer_role="user",
+    )
+
+    assert entry.uid == UUID(supplied_id)
+
+
 def test_episodes_to_string_multiple_mixed(base_episode_data):
     """Verify that multiple episodes are concatenated with newlines."""
     ep1 = Episode(**base_episode_data)
 
-    base_episode_data["uid"] = "msg_456"
+    base_episode_data["uid"] = UUID("550e8400-e29b-41d4-a716-446655440456")
     base_episode_data["episode_type"] = EpisodeType.MESSAGE
     base_episode_data["content"] = "Brief summary"
     ep2 = Episode(**base_episode_data)