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

{memmachine_server-0.3.5/src/memmachine_server.egg-info → memmachine_server-0.3.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memmachine-server
-Version: 0.3.5
+Version: 0.3.7
 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
@@ -24,12 +24,12 @@ Requires-Dist: boto3-stubs==1.40.64
 Requires-Dist: cohere>=5.20.0
 Requires-Dist: dotenv>=0.9.9
 Requires-Dist: fastapi>=0.116.1
-Requires-Dist: fastmcp>=3.0.2
+Requires-Dist: fastmcp>=3.2.0
 Requires-Dist: instructor[bedrock]>=1.12.0
 Requires-Dist: json-repair>=0.54
 Requires-Dist: langchain-aws>=0.2.33
 Requires-Dist: neo4j>=5.28.2
-Requires-Dist: nltk>=3.9.3
+Requires-Dist: nltk>=3.9.4
 Requires-Dist: openai>=2.21.0
 Requires-Dist: pgvector>=0.4.1
 Requires-Dist: prometheus-client>=0.22.1
@@ -46,6 +46,8 @@ Provides-Extra: gpu
 Requires-Dist: sentence-transformers>=5.1.0; extra == "gpu"
 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.5 → memmachine_server-0.3.7}/pyproject.toml

@@ -15,12 +15,12 @@ dependencies = [
     "cohere>=5.20.0",
     "dotenv>=0.9.9",
     "fastapi>=0.116.1",
-    "fastmcp>=3.0.2",
+    "fastmcp>=3.2.0",
     "instructor[bedrock]>=1.12.0",
     "json-repair>=0.54",
     "langchain-aws>=0.2.33",
     "neo4j>=5.28.2",
-    "nltk>=3.9.3",
+    "nltk>=3.9.4",
     "openai>=2.21.0",
     "pgvector>=0.4.1",
     "prometheus-client>=0.22.1",
@@ -57,6 +57,9 @@ gpu = [
 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.5 → memmachine_server-0.3.7}/server_tests/memmachine_server/common/configuration/test_database_conf.py

@@ -5,6 +5,7 @@ from pydantic import SecretStr
 from memmachine_server.common.configuration.database_conf import (
     DatabasesConf,
     Neo4jConf,
+    QdrantConf,
     SqlAlchemyConf,
     SupportedDB,
 )
@@ -14,23 +15,26 @@ 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
 
     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
+
 
 def test_sqlite_without_path_raises():
     message = "non-empty 'path'"
@@ -80,6 +84,18 @@ 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,
+                },
+            },
         },
     }
 
@@ -122,6 +138,17 @@ 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
+
 
 def test_read_db_password_from_env(monkeypatch, db_conf_dict):
     monkeypatch.setenv("MY_DB_PASSWORD", "env-db-password")
@@ -147,7 +174,7 @@ 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"
     with pytest.raises(ValueError, match=message):
         DatabasesConf.parse(input_dict)
 
@@ -212,3 +239,31 @@ 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

memmachine_server-0.3.7/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.5 → memmachine_server-0.3.7}/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()