memmachine-server 0.3.1__tar.gz → 0.3.3__tar.gz

{memmachine_server-0.3.1/src/memmachine_server.egg-info → memmachine_server-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memmachine-server
-Version: 0.3.1
+Version: 0.3.3
 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

{memmachine_server-0.3.1 → memmachine_server-0.3.3}/server_tests/memmachine_server/common/configuration/test_database_conf.py

@@ -166,6 +166,39 @@ def test_serialize_deserialize_database_conf(db_conf_dict):
     assert conf == conf_cp
 
 
+def test_neo4j_pool_lifecycle_fields():
+    # Defaults are None (use driver's internal defaults)
+    conf = Neo4jConf()
+    assert conf.max_connection_lifetime is None
+    assert conf.liveness_check_timeout is None
+
+    # Explicit values round-trip correctly
+    conf = Neo4jConf(max_connection_lifetime=3000.0, liveness_check_timeout=300.0)
+    assert conf.max_connection_lifetime == 3000.0
+    assert conf.liveness_check_timeout == 300.0
+
+
+def test_sqlalchemy_pool_lifecycle_fields():
+    # Defaults are None (use SQLAlchemy's internal defaults)
+    conf = SqlAlchemyConf(dialect="sqlite", driver="aiosqlite", path="test.db")
+    assert conf.pool_timeout is None
+    assert conf.pool_recycle is None
+    assert conf.pool_pre_ping is None
+
+    # Explicit values round-trip correctly
+    conf = SqlAlchemyConf(
+        dialect="sqlite",
+        driver="aiosqlite",
+        path="test.db",
+        pool_timeout=30,
+        pool_recycle=3000,
+        pool_pre_ping=True,
+    )
+    assert conf.pool_timeout == 30
+    assert conf.pool_recycle == 3000
+    assert conf.pool_pre_ping is True
+
+
 def test_neo4j_uri():
     conf = Neo4jConf(uri="bolt://localhost:1234")
     assert conf.get_uri() == "bolt://localhost:1234"

memmachine_server-0.3.3/server_tests/memmachine_server/common/embedder/test_openai_embedder.py

@@ -0,0 +1,126 @@
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import openai
+import pytest
+
+from memmachine_server.common.data_types import ExternalServiceAPIError
+from memmachine_server.common.embedder.openai_embedder import (
+    OpenAIEmbedder,
+    OpenAIEmbedderParams,
+)
+
+
+@pytest.fixture(
+    params=[
+        ["Are tomatoes fruits?", "Tomatoes are red."],
+        ["Are tomatoes fruits?", "Tomatoes are red.", ""],
+        ["."],
+        [" "],
+        [""],
+        [],
+    ],
+)
+def inputs(request):
+    return request.param
+
+
+@pytest.mark.integration
+@pytest.mark.asyncio
+async def test_ingest_embed(openai_embedder, inputs):
+    embeddings = await openai_embedder.ingest_embed(inputs)
+    assert isinstance(embeddings, list)
+    assert len(embeddings) == len(inputs)
+    assert all(len(embedding) == openai_embedder.dimensions for embedding in embeddings)
+
+
+@pytest.mark.integration
+@pytest.mark.asyncio
+async def test_search_embed(openai_embedder, inputs):
+    embeddings = await openai_embedder.search_embed(inputs)
+    assert isinstance(embeddings, list)
+    assert len(embeddings) == len(inputs)
+    assert all(len(embedding) == openai_embedder.dimensions for embedding in embeddings)
+
+
+@pytest.mark.integration
+@pytest.mark.asyncio
+async def test_large_input(openai_embedder):
+    input_text = "👩‍💻" * 10000
+
+    assert len(await openai_embedder.ingest_embed([input_text])) == 1
+    assert len(await openai_embedder.search_embed([input_text])) == 1
+
+
+@pytest.mark.integration
+@pytest.mark.asyncio
+async def test_many_inputs(openai_embedder):
+    input_texts = ["Hello, world!"] * 10000
+    assert len(await openai_embedder.ingest_embed(input_texts)) == 10000
+    assert len(await openai_embedder.search_embed(input_texts)) == 10000
+
+
+@pytest.mark.asyncio
+@patch("asyncio.sleep", new_callable=AsyncMock)
+async def test_embed_retry_on_internal_server_error(mock_sleep):
+    """Test retry logic on InternalServerError."""
+    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(
+        side_effect=[
+            openai.InternalServerError(
+                "internal server error", response=MagicMock(), body=None
+            ),
+            mock_response,
+        ]
+    )
+
+    embedder = OpenAIEmbedder(
+        OpenAIEmbedderParams(
+            client=mock_client,
+            model="test-model",
+            dimensions=256,
+        )
+    )
+
+    result = await embedder.ingest_embed(["test input"], max_attempts=2)
+
+    assert len(result) == 1
+    assert len(result[0]) == 256
+    assert mock_client.embeddings.create.call_count == 2
+    mock_sleep.assert_awaited_once_with(1)
+
+
+@pytest.mark.asyncio
+@patch("asyncio.sleep", new_callable=AsyncMock)
+async def test_embed_fail_after_max_retries_on_internal_server_error(mock_sleep):
+    """Test that ExternalServiceAPIError is raised after max_attempts on InternalServerError."""
+    mock_client = AsyncMock(spec=openai.AsyncOpenAI)
+    mock_client.embeddings.create = AsyncMock(
+        side_effect=openai.InternalServerError(
+            "internal server error", response=MagicMock(), body=None
+        ),
+    )
+
+    embedder = OpenAIEmbedder(
+        OpenAIEmbedderParams(
+            client=mock_client,
+            model="test-model",
+            dimensions=256,
+        )
+    )
+
+    with pytest.raises(ExternalServiceAPIError, match=r"max attempts"):
+        await embedder.ingest_embed(["test input"], max_attempts=3)
+
+    assert mock_client.embeddings.create.call_count == 3
+    assert mock_sleep.call_count == 2
+    mock_sleep.assert_any_await(1)
+    mock_sleep.assert_any_await(2)

{memmachine_server-0.3.1 → memmachine_server-0.3.3}/server_tests/memmachine_server/common/language_model/test_openai_chat_completions_language_model.py

@@ -397,6 +397,35 @@ async def test_generate_response_fail_after_max_retries(
     mock_sleep.assert_any_await(2)
 
 
+@pytest.mark.asyncio
+@patch("asyncio.sleep", new_callable=AsyncMock)
+async def test_generate_response_retry_on_internal_server_error(
+    mock_sleep,
+    mock_async_openai,
+    minimal_config,
+):
+    """Test retry logic on InternalServerError."""
+    mock_response = MagicMock()
+    mock_response.choices[0].message.content = "Success after retry"
+    mock_response.choices[0].message.tool_calls = None
+    mock_response.usage = None
+
+    mock_client = mock_async_openai.return_value
+    mock_client.chat.completions.create.side_effect = [
+        openai.InternalServerError(
+            "internal server error", response=MagicMock(), body=None
+        ),
+        mock_response,
+    ]
+
+    lm = OpenAIChatCompletionsLanguageModel(minimal_config)
+    content, _ = await lm.generate_response(max_attempts=2)
+
+    assert content == "Success after retry"
+    assert mock_client.chat.completions.create.call_count == 2
+    mock_sleep.assert_awaited_once_with(1)
+
+
 @pytest.mark.asyncio
 @pytest.mark.parametrize(
     "exception",

{memmachine_server-0.3.1 → memmachine_server-0.3.3}/server_tests/memmachine_server/common/language_model/test_openai_responses_language_model.py

@@ -353,6 +353,35 @@ async def test_generate_response_fail_after_max_retries(
     mock_sleep.assert_any_await(2)
 
 
+@pytest.mark.asyncio
+@patch("asyncio.sleep", new_callable=AsyncMock)
+async def test_generate_response_retry_on_internal_server_error(
+    mock_sleep,
+    mock_async_openai,
+    minimal_config,
+):
+    """Test retry logic on InternalServerError."""
+    mock_response = MagicMock()
+    mock_response.output_text = "Success after retry"
+    mock_response.output = None
+    mock_response.usage = None
+
+    mock_client = mock_async_openai.return_value
+    mock_client.responses.create.side_effect = [
+        openai.InternalServerError(
+            "internal server error", response=MagicMock(), body=None
+        ),
+        mock_response,
+    ]
+
+    lm = OpenAIResponsesLanguageModel(minimal_config)
+    content, _ = await lm.generate_response(max_attempts=2)
+
+    assert content == "Success after retry"
+    assert mock_client.responses.create.call_count == 2
+    mock_sleep.assert_awaited_once_with(1)
+
+
 @pytest.mark.asyncio
 @pytest.mark.asyncio
 @pytest.mark.parametrize(

memmachine_server-0.3.3/server_tests/memmachine_server/common/resource_manager/test_database_manager.py

@@ -0,0 +1,256 @@
+from typing import Any, cast
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+from pydantic import SecretStr
+from sqlalchemy.ext.asyncio import AsyncEngine
+
+from memmachine_server.common.configuration.database_conf import (
+    DatabasesConf,
+    Neo4jConf,
+    SqlAlchemyConf,
+)
+from memmachine_server.common.resource_manager.database_manager import DatabaseManager
+from memmachine_server.common.vector_graph_store import VectorGraphStore
+
+
+@pytest.fixture
+def mock_conf():
+    """Mock StoragesConf with dummy connection configurations."""
+    conf = MagicMock(spec=DatabasesConf)
+    conf.neo4j_confs = {
+        "neo1": Neo4jConf(
+            host="localhost", port=1234, user="neo", password=SecretStr("pw")
+        ),
+    }
+    conf.relational_db_confs = {
+        "pg1": SqlAlchemyConf(
+            dialect="postgresql",
+            driver="asyncpg",
+            host="localhost",
+            port=5432,
+            user="user",
+            password=SecretStr("password"),
+            db_name="testdb",
+        ),
+        "sqlite1": SqlAlchemyConf(
+            dialect="sqlite",
+            driver="aiosqlite",
+            path="test.db",
+        ),
+    }
+    conf.sqlite_confs = {}
+    conf.nebula_graph_confs = {}
+    return conf
+
+
+@pytest.mark.asyncio
+async def test_build_neo4j(mock_conf):
+    builder = DatabaseManager(mock_conf)
+    await builder._build_neo4j()
+
+    assert "neo1" in builder.graph_stores
+    driver = builder.graph_stores["neo1"]
+    assert isinstance(driver, VectorGraphStore)
+
+
+@pytest.mark.asyncio
+async def test_validate_neo4j(mock_conf):
+    builder = DatabaseManager(mock_conf)
+
+    mock_driver = MagicMock()
+    mock_session = AsyncMock()
+    mock_result = AsyncMock()
+    mock_record = {"ok": 1}
+
+    mock_driver.close = AsyncMock()
+    mock_result.single.return_value = mock_record
+    mock_session.run.return_value = mock_result
+
+    mock_driver.session.return_value.__aenter__ = AsyncMock(return_value=mock_session)
+    mock_driver.session.return_value.__aexit__ = AsyncMock(return_value=None)
+
+    builder.neo4j_drivers = {"neo1": mock_driver}
+
+    await builder._validate_neo4j_drivers()
+    mock_session.run.assert_awaited_once_with("RETURN 1 AS ok")
+
+
+@pytest.mark.asyncio
+async def test_build_sqlite(mock_conf):
+    builder = DatabaseManager(mock_conf)
+    await builder._build_sql_engines()
+
+    assert "sqlite1" in builder.sql_engines
+    assert isinstance(builder.sql_engines["sqlite1"], AsyncEngine)
+
+
+@pytest.mark.asyncio
+async def test_build_and_validate_sqlite():
+    conf = MagicMock(spec=DatabasesConf)
+    conf.neo4j_confs = {}
+    conf.nebula_graph_confs = {}
+    conf.relational_db_confs = {
+        "sqlite1": SqlAlchemyConf(
+            dialect="sqlite",
+            driver="aiosqlite",
+            path=":memory:",
+        )
+    }
+    builder = DatabaseManager(conf)
+    await builder.build_all(validate=True)
+    # If no exception is raised, validation passed
+    assert "sqlite1" in builder.sql_engines
+    await builder.close()
+    assert "sqlite1" not in builder.sql_engines
+
+
+@pytest.mark.asyncio
+async def test_build_all_without_validation(mock_conf):
+    builder = DatabaseManager(mock_conf)
+    builder_any = cast(Any, builder)
+    builder_any._build_neo4j = AsyncMock()
+    builder_any._build_sql_engines = AsyncMock()
+    builder_any._validate_neo4j_drivers = AsyncMock()
+    builder_any._validate_sql_engines = AsyncMock()
+
+    await builder.build_all(validate=False)
+
+    assert "sqlite1" in builder.sql_engines
+    assert "pg1" in builder.sql_engines
+    assert "neo1" in builder.graph_stores
+
+
+@pytest.mark.asyncio
+async def test_neo4j_pool_lifecycle_kwargs():
+    """max_connection_lifetime and liveness_check_timeout are forwarded to the driver."""
+    conf = MagicMock(spec=DatabasesConf)
+    neo4j_conf = Neo4jConf(
+        host="localhost",
+        port=7687,
+        user="neo4j",
+        password=SecretStr("pw"),
+        max_connection_lifetime=3000.0,
+        liveness_check_timeout=300.0,
+    )
+    conf.neo4j_confs = {"neo1": neo4j_conf}
+    conf.relational_db_confs = {}
+    conf.nebula_graph_confs = {}
+
+    mock_driver = MagicMock()
+    mock_driver.close = AsyncMock()
+
+    with (
+        patch(
+            "memmachine_server.common.resource_manager.database_manager.AsyncGraphDatabase.driver",
+            return_value=mock_driver,
+        ) as mock_driver_cls,
+        patch(
+            "memmachine_server.common.resource_manager.database_manager.Neo4jVectorGraphStoreParams",
+        ),
+        patch(
+            "memmachine_server.common.resource_manager.database_manager.Neo4jVectorGraphStore",
+        ),
+    ):
+        builder = DatabaseManager(conf)
+        await builder.async_get_neo4j_driver("neo1")
+
+    call_kwargs = mock_driver_cls.call_args.kwargs
+    assert call_kwargs["max_connection_lifetime"] == 3000.0
+    assert call_kwargs["liveness_check_timeout"] == 300.0
+
+
+@pytest.mark.asyncio
+async def test_sqlalchemy_pool_lifecycle_kwargs():
+    """pool_timeout, pool_recycle, and pool_pre_ping are forwarded to create_async_engine."""
+    conf = MagicMock(spec=DatabasesConf)
+    sql_conf = SqlAlchemyConf(
+        dialect="sqlite",
+        driver="aiosqlite",
+        path=":memory:",
+        pool_timeout=30,
+        pool_recycle=3000,
+        pool_pre_ping=True,
+    )
+    conf.neo4j_confs = {}
+    conf.nebula_graph_confs = {}
+    conf.relational_db_confs = {"db1": sql_conf}
+
+    mock_engine = MagicMock(spec=AsyncEngine)
+
+    with patch(
+        "memmachine_server.common.resource_manager.database_manager.create_async_engine",
+        return_value=mock_engine,
+    ) as mock_create:
+        builder = DatabaseManager(conf)
+        await builder.async_get_sql_engine("db1")
+
+    call_kwargs = mock_create.call_args.kwargs
+    assert call_kwargs["pool_timeout"] == 30
+    assert call_kwargs["pool_recycle"] == 3000
+    assert call_kwargs["pool_pre_ping"] is True
+
+
+@pytest.mark.asyncio
+async def test_neo4j_pool_lifecycle_kwargs_none_omitted():
+    """When pool lifecycle fields are None, they are not forwarded to the driver."""
+    conf = MagicMock(spec=DatabasesConf)
+    neo4j_conf = Neo4jConf(
+        host="localhost",
+        port=7687,
+        user="neo4j",
+        password=SecretStr("pw"),
+    )
+    conf.neo4j_confs = {"neo1": neo4j_conf}
+    conf.relational_db_confs = {}
+    conf.nebula_graph_confs = {}
+
+    mock_driver = MagicMock()
+    mock_driver.close = AsyncMock()
+
+    with (
+        patch(
+            "memmachine_server.common.resource_manager.database_manager.AsyncGraphDatabase.driver",
+            return_value=mock_driver,
+        ) as mock_driver_cls,
+        patch(
+            "memmachine_server.common.resource_manager.database_manager.Neo4jVectorGraphStoreParams",
+        ),
+        patch(
+            "memmachine_server.common.resource_manager.database_manager.Neo4jVectorGraphStore",
+        ),
+    ):
+        builder = DatabaseManager(conf)
+        await builder.async_get_neo4j_driver("neo1")
+
+    call_kwargs = mock_driver_cls.call_args.kwargs
+    assert "max_connection_lifetime" not in call_kwargs
+    assert "liveness_check_timeout" not in call_kwargs
+
+
+@pytest.mark.asyncio
+async def test_sqlalchemy_pool_lifecycle_kwargs_none_omitted():
+    """When pool lifecycle fields are None, they are not forwarded to create_async_engine."""
+    conf = MagicMock(spec=DatabasesConf)
+    sql_conf = SqlAlchemyConf(
+        dialect="sqlite",
+        driver="aiosqlite",
+        path=":memory:",
+    )
+    conf.neo4j_confs = {}
+    conf.nebula_graph_confs = {}
+    conf.relational_db_confs = {"db1": sql_conf}
+
+    mock_engine = MagicMock(spec=AsyncEngine)
+
+    with patch(
+        "memmachine_server.common.resource_manager.database_manager.create_async_engine",
+        return_value=mock_engine,
+    ) as mock_create:
+        builder = DatabaseManager(conf)
+        await builder.async_get_sql_engine("db1")
+
+    call_kwargs = mock_create.call_args.kwargs
+    assert "pool_timeout" not in call_kwargs
+    assert "pool_recycle" not in call_kwargs
+    assert "pool_pre_ping" not in call_kwargs

{memmachine_server-0.3.1 → memmachine_server-0.3.3}/server_tests/memmachine_server/episodic_memory/short_term_memory/test_short_term_memory.py

@@ -347,6 +347,78 @@ class TestSessionMemoryPublicAPI:
         # context window limit causes recursive splitting into 4 LLM calls
         assert mock_model.call_count == 4
 
+    @pytest.mark.asyncio
+    async def test_summary_exceed_context_window_single_episode(
+        self, mock_data_manager
+    ):
+        class ChunkingLanguageModel(LanguageModel):
+            def __init__(self) -> None:
+                self.call_count = 0
+
+            async def generate_response(
+                self,
+                system_prompt: str | None = None,
+                user_prompt: str | None = None,
+                tools: list[dict[str, Any]] | None = None,
+                tool_choice: str | dict[str, str] | None = None,
+                max_attempts: int = 1,
+            ) -> tuple[str, Any]:
+                prompt = user_prompt or ""
+                if len(prompt) > 10000:
+                    raise ValueError("User prompt exceeds context window")
+                self.call_count += 1
+                match = re.search(r"summary:(\d+)(?: \d+)?$", prompt)
+                prev_summary = int(match.group(1)) if match else 0
+                messages = re.findall(r'"([^"]*)"', prompt)
+                return (
+                    f"summary:{prev_summary + sum(len(message) for message in messages)}",
+                    "",
+                )
+
+            async def generate_response_with_token_usage(
+                self,
+                system_prompt: str | None = None,
+                user_prompt: str | None = None,
+                tools: list[dict[str, Any]] | None = None,
+                tool_choice: str | dict[str, str] | None = None,
+                max_attempts: int = 1,
+            ) -> tuple[str, Any, int, int]:
+                response, tool_output = await self.generate_response(
+                    system_prompt=system_prompt,
+                    user_prompt=user_prompt,
+                    tools=tools,
+                    tool_choice=tool_choice,
+                    max_attempts=max_attempts,
+                )
+                return response, tool_output, 0, 0
+
+            async def generate_parsed_response(
+                self,
+                output_format: type[T],
+                system_prompt: str | None = None,
+                user_prompt: str | None = None,
+                max_attempts: int = 1,
+            ) -> T:
+                return cast(T, "summary")
+
+        model = ChunkingLanguageModel()
+        params = ShortTermMemoryConsolidator.Params(
+            summary_user_prompt="User prompt: {episodes} {summary} {max_length}",
+            summary_system_prompt="System Prompt",
+            max_summary_length_words=100,
+            session_key="test_session",
+            model=model,
+            data_manager=mock_data_manager,
+        )
+        consolidator = ShortTermMemoryConsolidator(params)
+
+        oversized_content = "a" * 12000
+        episode = create_test_episode(content=oversized_content)
+        summary = await consolidator._create_summary("", [episode])
+
+        assert summary == "summary:12000"
+        assert model.call_count > 1
+
     @pytest.mark.asyncio
     async def test_summary_catch_up(self, mock_model, mock_data_manager):
         params = ShortTermMemoryConsolidator.Params(

{memmachine_server-0.3.1 → memmachine_server-0.3.3}/server_tests/memmachine_server/semantic_memory/mock_semantic_memory_objects.py

@@ -182,6 +182,9 @@ class MockSemanticStorage(SemanticStorage):
     ) -> list[SetIdT]:
         raise NotImplementedError
 
+    async def purge_ingested_rows(self, set_ids: list[SetIdT]) -> int:
+        raise NotImplementedError
+
     async def get_set_ids_starts_with(self, prefix: str) -> list[SetIdT]:
         raise NotImplementedError
 

{memmachine_server-0.3.1 → memmachine_server-0.3.3}/server_tests/memmachine_server/semantic_memory/storage/in_memory_semantic_storage.py

@@ -339,6 +339,34 @@ class InMemorySemanticStorage(SemanticStorage):
 
             return set_ids
 
+    async def purge_ingested_rows(self, set_ids: list[SetIdT]) -> int:
+        if not set_ids:
+            return 0
+        deleted = 0
+        async with self._lock:
+            for set_id in set_ids:
+                history_map = self._set_history_map.get(set_id)
+                if history_map is None:
+                    continue
+                # Skip sets that still have pending (uningested) messages
+                # to preserve the duplicate guard for in-flight work.
+                has_pending = any(not v for v in history_map.values())
+                if has_pending:
+                    continue
+                ingested_ids = list(history_map.keys())
+                for h_id in ingested_ids:
+                    del history_map[h_id]
+                    self._history_created_at.pop((set_id, h_id), None)
+                    h_sets = self._history_to_sets.get(h_id)
+                    if h_sets is not None:
+                        h_sets.pop(set_id, None)
+                        if not h_sets:
+                            self._history_to_sets.pop(h_id, None)
+                    deleted += 1
+                if not history_map:
+                    self._set_history_map.pop(set_id, None)
+        return deleted
+
     async def get_set_ids_starts_with(self, prefix: str) -> list[SetIdT]:
         async with self._lock:
             set_ids = {