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

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

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

{memmachine_server-0.3.4 → memmachine_server-0.3.6}/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",

{memmachine_server-0.3.4 → memmachine_server-0.3.6}/server_tests/memmachine_server/common/embedder/test_openai_embedder.py

@@ -124,3 +124,48 @@ async def test_embed_fail_after_max_retries_on_internal_server_error(mock_sleep)
     assert mock_sleep.call_count == 2
     mock_sleep.assert_any_await(1)
     mock_sleep.assert_any_await(2)
+
+
+@pytest.mark.asyncio
+async def test_embed_oversized_input_with_no_max_input_length():
+    """Regression for #1298: text > 75,000 chars must not raise ValueError.
+
+    When max_input_length is None, _embed() must fall back to
+    max_total_input_length_per_request (75,000) as the chunking bound so that
+    cluster_texts() never receives a text that exceeds its hard limit.
+    Prior to the fix, this raised ValueError("Text length ... exceeds
+    max_total_length_per_cluster ..."), which surfaced as HTTP 500.
+    """
+    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=None,  # default — reproduces the crash scenario
+        )
+    )
+
+    # 80,000 chars exceeds the 75,000-char cluster hard limit by 5,000.
+    long_text = "x" * 80_000
+
+    # Before the fix this raised:
+    #   ValueError: Text length 80000 exceeds max_total_length_per_cluster 75000
+    result = await embedder.ingest_embed([long_text])
+
+    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.
+    assert mock_client.embeddings.create.call_count >= 2

{memmachine_server-0.3.4 → memmachine_server-0.3.6}/server_tests/memmachine_server/common/language_model/test_openai_chat_completions_language_model.py

@@ -819,6 +819,25 @@ async def test_generate_response_runtime_exception_mapping(
         await lm.generate_response()
 
 
+@pytest.mark.asyncio
+async def test_generate_response_preserves_original_error_message(
+    mock_async_openai,
+    minimal_config,
+):
+    # Regression for #1309: the wrapped ExternalServiceAPIError must carry the
+    # original LLM error text so _is_exceed_context_window_error can key off it.
+    mock_client = mock_async_openai.return_value
+    mock_client.chat.completions.create.side_effect = openai.BadRequestError(
+        "This model's maximum context length is 202752 tokens...",
+        response=MagicMock(),
+        body=None,
+    )
+
+    lm = OpenAIChatCompletionsLanguageModel(minimal_config)
+    with pytest.raises(ExternalServiceAPIError, match="context length"):
+        await lm.generate_response()
+
+
 @pytest.mark.asyncio
 async def test_metrics_collection(mock_async_openai, full_config):
     """Test that metrics are collected on a successful call."""

{memmachine_server-0.3.4 → memmachine_server-0.3.6}/server_tests/memmachine_server/semantic_memory/test_semantic_ingestion.py

@@ -1003,3 +1003,354 @@ async def test_user_tags_preserved_after_ingestion_and_consolidation(
     # "bugfix" and "decision" survive (each had < 2 entries)
     assert "bugfix" in remaining_tags
     assert "decision" in remaining_tags
+
+
+@pytest.mark.asyncio
+async def test_consolidation_retries_on_none_response(
+    ingestion_service: IngestionService,
+    semantic_storage: SemanticStorage,
+    episode_storage: EpisodeStorage,
+    resources: Resources,
+    semantic_category: SemanticCategory,
+    monkeypatch,
+):
+    """When llm_consolidate_features returns None on the first attempt but
+    succeeds on the second, consolidation completes and features are removed."""
+    hist1 = await add_history(episode_storage, content="msg1")
+    hist2 = await add_history(episode_storage, content="msg2")
+
+    id1 = await semantic_storage.add_feature(
+        set_id="user-retry-none",
+        category_name=semantic_category.name,
+        feature="feat_x",
+        value="value x",
+        tag="retry_tag",
+        embedding=np.array([1.0, 0.0]),
+    )
+    id2 = await semantic_storage.add_feature(
+        set_id="user-retry-none",
+        category_name=semantic_category.name,
+        feature="feat_y",
+        value="value y",
+        tag="retry_tag",
+        embedding=np.array([0.0, 1.0]),
+    )
+    await semantic_storage.add_citations(id1, [hist1])
+    await semantic_storage.add_citations(id2, [hist2])
+
+    filter_str = f"set_id IN ('user-retry-none') AND category_name IN ('{semantic_category.name}')"
+    memories = await _collect(
+        semantic_storage.get_feature_set(
+            filter_expr=parse_filter(filter_str),
+            load_citations=True,
+        )
+    )
+
+    valid_response = SemanticConsolidateMemoryRes(
+        consolidated_memories=[
+            LLMReducedFeature(tag="retry_tag", feature="combined", value="combined x+y")
+        ],
+        keep_memories=[],
+    )
+    llm_mock = AsyncMock(side_effect=[None, valid_response])
+    monkeypatch.setattr(
+        "memmachine_server.semantic_memory.semantic_ingestion.llm_consolidate_features",
+        llm_mock,
+    )
+
+    await ingestion_service._deduplicate_features(
+        set_id="user-retry-none",
+        memories=memories,
+        semantic_category=semantic_category,
+        resources=resources,
+    )
+
+    assert llm_mock.await_count == 2
+    assert await semantic_storage.get_feature(id1) is None
+    assert await semantic_storage.get_feature(id2) is None
+    remaining = await _collect(
+        semantic_storage.get_feature_set(filter_expr=parse_filter(filter_str))
+    )
+    assert len(remaining) == 1
+    assert remaining[0].value == "combined x+y"
+
+
+@pytest.mark.asyncio
+async def test_consolidation_exhausts_retries_and_returns(
+    ingestion_service: IngestionService,
+    semantic_storage: SemanticStorage,
+    episode_storage: EpisodeStorage,
+    resources: Resources,
+    semantic_category: SemanticCategory,
+    monkeypatch,
+):
+    """When llm_consolidate_features always returns None, _deduplicate_features
+    logs a warning and returns without raising and without touching features."""
+    id1 = await semantic_storage.add_feature(
+        set_id="user-retry-exhaust",
+        category_name=semantic_category.name,
+        feature="feat_a",
+        value="value a",
+        tag="exhaust_tag",
+        embedding=np.array([1.0, 0.0]),
+    )
+    id2 = await semantic_storage.add_feature(
+        set_id="user-retry-exhaust",
+        category_name=semantic_category.name,
+        feature="feat_b",
+        value="value b",
+        tag="exhaust_tag",
+        embedding=np.array([0.0, 1.0]),
+    )
+
+    filter_str = f"set_id IN ('user-retry-exhaust') AND category_name IN ('{semantic_category.name}')"
+    memories = await _collect(
+        semantic_storage.get_feature_set(filter_expr=parse_filter(filter_str))
+    )
+
+    llm_mock = AsyncMock(return_value=None)
+    monkeypatch.setattr(
+        "memmachine_server.semantic_memory.semantic_ingestion.llm_consolidate_features",
+        llm_mock,
+    )
+
+    await ingestion_service._deduplicate_features(
+        set_id="user-retry-exhaust",
+        memories=memories,
+        semantic_category=semantic_category,
+        resources=resources,
+    )
+
+    assert llm_mock.await_count == 2
+    assert await semantic_storage.get_feature(id1) is not None
+    assert await semantic_storage.get_feature(id2) is not None
+
+
+@pytest.mark.asyncio
+async def test_consolidation_skips_context_length_error(
+    ingestion_service: IngestionService,
+    semantic_storage: SemanticStorage,
+    episode_storage: EpisodeStorage,
+    resources: Resources,
+    semantic_category: SemanticCategory,
+    monkeypatch,
+):
+    """A context-length exception during consolidation is handled gracefully:
+    no exception propagates and features are left unchanged."""
+
+    class ContextLengthExceededError(Exception):
+        code = "context_length_exceeded"
+
+    id1 = await semantic_storage.add_feature(
+        set_id="user-consolidate-ctx",
+        category_name=semantic_category.name,
+        feature="feat_p",
+        value="value p",
+        tag="ctx_tag",
+        embedding=np.array([1.0, 0.0]),
+    )
+    id2 = await semantic_storage.add_feature(
+        set_id="user-consolidate-ctx",
+        category_name=semantic_category.name,
+        feature="feat_q",
+        value="value q",
+        tag="ctx_tag",
+        embedding=np.array([0.0, 1.0]),
+    )
+
+    filter_str = f"set_id IN ('user-consolidate-ctx') AND category_name IN ('{semantic_category.name}')"
+    memories = await _collect(
+        semantic_storage.get_feature_set(filter_expr=parse_filter(filter_str))
+    )
+
+    async def raise_ctx_error(*args, **kwargs):
+        raise ExternalServiceAPIError(
+            "context window exceeded"
+        ) from ContextLengthExceededError("input exceeds context window")
+
+    monkeypatch.setattr(
+        "memmachine_server.semantic_memory.semantic_ingestion.llm_consolidate_features",
+        raise_ctx_error,
+    )
+
+    await ingestion_service._deduplicate_features(
+        set_id="user-consolidate-ctx",
+        memories=memories,
+        semantic_category=semantic_category,
+        resources=resources,
+    )
+
+    assert await semantic_storage.get_feature(id1) is not None
+    assert await semantic_storage.get_feature(id2) is not None
+
+
+@pytest.mark.asyncio
+async def test_consolidation_retries_on_exception(
+    ingestion_service: IngestionService,
+    semantic_storage: SemanticStorage,
+    episode_storage: EpisodeStorage,
+    resources: Resources,
+    semantic_category: SemanticCategory,
+    semantic_prompt,
+    monkeypatch,
+):
+    """A non-context exception on the first call must not short-circuit the
+    loop — the helper retries once and proceeds with the successful response."""
+    id1 = await semantic_storage.add_feature(
+        set_id="user-retry-exc",
+        category_name=semantic_category.name,
+        feature="feat_a",
+        value="value a",
+        tag="exc_tag",
+        embedding=np.array([1.0, 0.0]),
+    )
+    await semantic_storage.add_feature(
+        set_id="user-retry-exc",
+        category_name=semantic_category.name,
+        feature="feat_b",
+        value="value b",
+        tag="exc_tag",
+        embedding=np.array([0.0, 1.0]),
+    )
+
+    valid_response = SemanticConsolidateMemoryRes(
+        consolidated_memories=[
+            LLMReducedFeature(tag="exc_tag", feature="combined", value="combined a+b")
+        ],
+        keep_memories=[id1],
+    )
+
+    async def flaky(*args, **kwargs):
+        if llm_mock.await_count == 1:
+            raise ValueError("structured-output validation failed")
+        return valid_response
+
+    llm_mock = AsyncMock(side_effect=flaky)
+    monkeypatch.setattr(
+        "memmachine_server.semantic_memory.semantic_ingestion.llm_consolidate_features",
+        llm_mock,
+    )
+
+    result = await ingestion_service._try_consolidate(
+        set_id="user-retry-exc",
+        features=[],
+        model=resources.language_model,
+        consolidation_prompt=semantic_prompt.consolidation_prompt,
+    )
+
+    assert llm_mock.await_count == 2
+    assert result is valid_response
+
+
+@pytest.mark.asyncio
+async def test_consolidation_exhausted_exceptions_respects_debug_fail_loudly(
+    semantic_storage: SemanticStorage,
+    episode_storage: EpisodeStorage,
+    resource_retriever: MockResourceRetriever,
+    resources: Resources,
+    semantic_category: SemanticCategory,
+    semantic_prompt,
+    monkeypatch,
+):
+    """When every attempt raises a non-context exception, _try_consolidate
+    re-raises under debug_fail_loudly only after the retry is exhausted."""
+    ingestion_service = IngestionService(
+        IngestionService.Params(
+            semantic_storage=semantic_storage,
+            history_store=episode_storage,
+            resource_retriever=resource_retriever.get_resources,
+            consolidated_threshold=2,
+            debug_fail_loudly=True,
+        )
+    )
+
+    async def always_raise(*args, **kwargs):
+        raise ValueError("structured-output validation failed")
+
+    llm_mock = AsyncMock(side_effect=always_raise)
+    monkeypatch.setattr(
+        "memmachine_server.semantic_memory.semantic_ingestion.llm_consolidate_features",
+        llm_mock,
+    )
+
+    with pytest.raises(ValueError, match="structured-output validation failed"):
+        await ingestion_service._try_consolidate(
+            set_id="user-exc-loud",
+            features=[],
+            model=resources.language_model,
+            consolidation_prompt=semantic_prompt.consolidation_prompt,
+        )
+
+    # Retry must still happen before the loud re-raise.
+    assert llm_mock.await_count == 2
+
+
+@pytest.mark.asyncio
+async def test_deduplicate_features_context_length_does_not_raise_in_debug_mode(
+    semantic_storage: SemanticStorage,
+    episode_storage: EpisodeStorage,
+    resource_retriever: MockResourceRetriever,
+    resources: Resources,
+    semantic_category: SemanticCategory,
+    monkeypatch,
+):
+    """Context-length errors during consolidation must be handled gracefully
+    even when debug_fail_loudly is True, matching the feature-update path."""
+
+    class ContextLengthExceededError(Exception):
+        code = "context_length_exceeded"
+
+    ingestion_service = IngestionService(
+        IngestionService.Params(
+            semantic_storage=semantic_storage,
+            history_store=episode_storage,
+            resource_retriever=resource_retriever.get_resources,
+            consolidated_threshold=2,
+            debug_fail_loudly=True,
+        )
+    )
+
+    id1 = await semantic_storage.add_feature(
+        set_id="user-ctx-loud",
+        category_name=semantic_category.name,
+        feature="feat_p",
+        value="value p",
+        tag="ctx_tag",
+        embedding=np.array([1.0, 0.0]),
+    )
+    id2 = await semantic_storage.add_feature(
+        set_id="user-ctx-loud",
+        category_name=semantic_category.name,
+        feature="feat_q",
+        value="value q",
+        tag="ctx_tag",
+        embedding=np.array([0.0, 1.0]),
+    )
+
+    filter_str = (
+        f"set_id IN ('user-ctx-loud') AND category_name IN ('{semantic_category.name}')"
+    )
+    memories = await _collect(
+        semantic_storage.get_feature_set(filter_expr=parse_filter(filter_str))
+    )
+
+    async def raise_ctx_error(*args, **kwargs):
+        raise ExternalServiceAPIError(
+            "context window exceeded"
+        ) from ContextLengthExceededError("input exceeds context window")
+
+    monkeypatch.setattr(
+        "memmachine_server.semantic_memory.semantic_ingestion.llm_consolidate_features",
+        raise_ctx_error,
+    )
+
+    # Must not raise even though debug_fail_loudly=True.
+    await ingestion_service._deduplicate_features(
+        set_id="user-ctx-loud",
+        memories=memories,
+        semantic_category=semantic_category,
+        resources=resources,
+    )
+
+    assert await semantic_storage.get_feature(id1) is not None
+    assert await semantic_storage.get_feature(id2) is not None

{memmachine_server-0.3.4 → memmachine_server-0.3.6}/src/memmachine_server/common/embedder/openai_embedder.py

@@ -150,11 +150,11 @@ class OpenAIEmbedder(Embedder):
             for input_text in inputs
         ]
 
+        effective_max = (
+            self._max_input_length or self.max_total_input_length_per_request
+        )
         inputs_chunks = [
-            chunk_text_balanced(input_text, self._max_input_length)
-            if self._max_input_length is not None
-            else [input_text]
-            for input_text in inputs
+            chunk_text_balanced(input_text, effective_max) for input_text in inputs
         ]
 
         chunks = [chunk for input_chunks in inputs_chunks for chunk in input_chunks]

{memmachine_server-0.3.4 → memmachine_server-0.3.6}/src/memmachine_server/common/language_model/openai_chat_completions_language_model.py

@@ -269,7 +269,7 @@ class OpenAIChatCompletionsLanguageModel(LanguageModel):
                     f"[call uuid: {generate_response_call_uuid}] "
                     "Giving up generating response "
                     f"after failed attempt {attempt} "
-                    f"due to non-retryable {type(e).__name__}"
+                    f"due to non-retryable {type(e).__name__}: {e}"
                 )
                 logger.exception(error_message)
                 raise ExternalServiceAPIError(error_message) from e

{memmachine_server-0.3.4 → memmachine_server-0.3.6}/src/memmachine_server/semantic_memory/semantic_ingestion.py

@@ -12,8 +12,10 @@ from pydantic import BaseModel, Field, InstanceOf, TypeAdapter
 from memmachine_server.common.embedder import Embedder
 from memmachine_server.common.episode_store import Episode, EpisodeIdT, EpisodeStorage
 from memmachine_server.common.filter.filter_parser import And, Comparison
+from memmachine_server.common.language_model import LanguageModel
 from memmachine_server.semantic_memory.semantic_llm import (
     LLMReducedFeature,
+    SemanticConsolidateMemoryRes,
     llm_consolidate_features,
     llm_feature_update,
 )
@@ -30,6 +32,17 @@ from memmachine_server.semantic_memory.storage.storage_base import SemanticStora
 
 logger = logging.getLogger(__name__)
 
+_MAX_CONSOLIDATION_ATTEMPTS = 2
+
+
+class _ConsolidationContextLengthError(Exception):
+    """Signals that consolidation must be skipped due to a context-length error.
+
+    Caught inside the ingestion service to distinguish the graceful-skip path
+    from genuine consolidation failure, so that `debug_fail_loudly` does not
+    raise for scenarios the feature-update path already handles silently.
+    """
+
 
 def _is_context_length_exceeded_error(error: Exception) -> bool:
     seen: set[int] = set()
@@ -370,6 +383,67 @@ class IngestionService:
 
         await asyncio.gather(*category_tasks)
 
+    async def _try_consolidate(
+        self,
+        *,
+        set_id: str,
+        features: list[SemanticFeature],
+        model: LanguageModel,
+        consolidation_prompt: str,
+    ) -> SemanticConsolidateMemoryRes | None:
+        """Call llm_consolidate_features with retry on transient failures.
+
+        Retries on parse/validation exceptions and on ``None`` returns (which
+        indicate a structured-output parse failure upstream). A context-length
+        exception is raised as :class:`_ConsolidationContextLengthError` so
+        the caller can skip the group without tripping ``debug_fail_loudly``.
+        Returns ``None`` once retries are exhausted, raising instead when
+        ``self._debug_fail_loudly`` is True and the last failure was not a
+        context-length error.
+        """
+        for attempt in range(1, _MAX_CONSOLIDATION_ATTEMPTS + 1):
+            try:
+                result = await llm_consolidate_features(
+                    features=features,
+                    model=model,
+                    consolidate_prompt=consolidation_prompt,
+                )
+            except Exception as err:
+                if _is_context_length_exceeded_error(err):
+                    logger.warning(
+                        "Skipping consolidation for set %s due to non-retryable context length error",
+                        set_id,
+                    )
+                    raise _ConsolidationContextLengthError from err
+                if attempt < _MAX_CONSOLIDATION_ATTEMPTS:
+                    logger.warning(
+                        "Consolidation raised %s on attempt %d/%d for set %s, retrying",
+                        type(err).__name__,
+                        attempt,
+                        _MAX_CONSOLIDATION_ATTEMPTS,
+                        set_id,
+                    )
+                    continue
+                logger.exception(
+                    "Failed to consolidate features while calling LLM for set %s on attempt %d/%d",
+                    set_id,
+                    attempt,
+                    _MAX_CONSOLIDATION_ATTEMPTS,
+                )
+                if self._debug_fail_loudly:
+                    raise
+                return None
+            if result is not None:
+                return result
+            if attempt < _MAX_CONSOLIDATION_ATTEMPTS:
+                logger.warning(
+                    "Consolidation returned None on attempt %d/%d for set %s, retrying",
+                    attempt,
+                    _MAX_CONSOLIDATION_ATTEMPTS,
+                    set_id,
+                )
+        return None
+
     async def _deduplicate_features(
         self,
         *,
@@ -379,19 +453,20 @@ class IngestionService:
         resources: InstanceOf[Resources],
     ) -> None:
         try:
-            consolidate_resp = await llm_consolidate_features(
+            consolidate_resp = await self._try_consolidate(
+                set_id=set_id,
                 features=list(memories),
                 model=resources.language_model,
-                consolidate_prompt=semantic_category.prompt.consolidation_prompt,
+                consolidation_prompt=semantic_category.prompt.consolidation_prompt,
             )
-        except (ValueError, TypeError):
-            logger.exception("Failed to update features while calling LLM")
-            if self._debug_fail_loudly:
-                raise
+        except _ConsolidationContextLengthError:
             return
 
         if consolidate_resp is None or consolidate_resp.keep_memories is None:
-            logger.warning("Failed to consolidate features")
+            logger.warning(
+                "Failed to consolidate features after %d attempts",
+                _MAX_CONSOLIDATION_ATTEMPTS,
+            )
             if self._debug_fail_loudly:
                 raise ValueError("Failed to consolidate features")
             return

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

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

{memmachine_server-0.3.4 → memmachine_server-0.3.6}/src/memmachine_server.egg-info/requires.txt

@@ -7,12 +7,12 @@ boto3-stubs==1.40.64
 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