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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memmachine-client
-Version: 0.3.4
+Version: 0.3.6
 Summary: MemMachine REST Client - A lightweight Python client library for MemMachine memory system
 Author-email: MemMachine <noreply@memmachine.ai>
 License-Expression: Apache-2.0
@@ -19,7 +19,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: memmachine-common
 Requires-Dist: pydantic>=2.0.0
-Requires-Dist: requests>=2.31.0
+Requires-Dist: requests>=2.33.0
 Requires-Dist: typing-extensions>=4.0.0
 Requires-Dist: urllib3>=2.6.3
 Dynamic: license-file

memmachine_client-0.3.6/client_tests/test_format.py

@@ -0,0 +1,261 @@
+"""Unit tests for LLM-friendly memory formatting functions."""
+
+import json
+from datetime import datetime, timezone
+
+from memmachine_common.api.spec import (
+    Episode,
+    EpisodeResponse,
+    EpisodicSearchLongTermMemory,
+    EpisodicSearchResult,
+    EpisodicSearchShortTermMemory,
+    SearchResult,
+    SearchResultContent,
+    SemanticFeature,
+)
+
+from memmachine_client.format import (
+    format_episodes,
+    format_search_result,
+    format_semantic_memories,
+)
+
+
+class TestFormatEpisodes:
+    """Tests for format_episodes."""
+
+    def test_empty(self):
+        assert format_episodes([]) == ""
+
+    def test_single_episode_response(self):
+        ep = EpisodeResponse(
+            uid="1",
+            content="Hello world",
+            producer_id="user_1",
+            producer_role="user",
+            created_at=datetime(2024, 1, 15, 13, 30, tzinfo=timezone.utc),
+        )
+        result = format_episodes([ep])
+        assert (
+            result == '[Monday, January 15, 2024 at 01:30 PM] user_1: "Hello world"\n'
+        )
+
+    def test_multiple_episodes(self):
+        eps = [
+            EpisodeResponse(
+                uid="1",
+                content="First message",
+                producer_id="user_1",
+                producer_role="user",
+                created_at=datetime(2024, 3, 5, 9, 0, tzinfo=timezone.utc),
+            ),
+            EpisodeResponse(
+                uid="2",
+                content="Second message",
+                producer_id="assistant_1",
+                producer_role="assistant",
+                created_at=datetime(2024, 3, 5, 9, 1, tzinfo=timezone.utc),
+            ),
+        ]
+        result = format_episodes(eps)
+        lines = result.strip().split("\n")
+        assert len(lines) == 2
+        assert "user_1" in lines[0]
+        assert "assistant_1" in lines[1]
+
+    def test_episode_without_created_at(self):
+        ep = EpisodeResponse(
+            uid="1",
+            content="No timestamp",
+            producer_id="user_1",
+            producer_role="user",
+            created_at=None,
+        )
+        result = format_episodes([ep])
+        assert result == 'user_1: "No timestamp"\n'
+
+    def test_list_episode_type(self):
+        ep = Episode(
+            uid="1",
+            content="Listed episode",
+            session_key="sess_1",
+            producer_id="user_1",
+            producer_role="user",
+            created_at=datetime(2024, 6, 1, 14, 0, tzinfo=timezone.utc),
+        )
+        result = format_episodes([ep])
+        assert (
+            result == '[Saturday, June 01, 2024 at 02:00 PM] user_1: "Listed episode"\n'
+        )
+
+    def test_content_json_escaped(self):
+        ep = EpisodeResponse(
+            uid="1",
+            content='She said "hello"',
+            producer_id="user_1",
+            producer_role="user",
+            created_at=datetime(2024, 1, 1, 0, 0, tzinfo=timezone.utc),
+        )
+        result = format_episodes([ep])
+        assert json.dumps('She said "hello"') in result
+
+
+class TestFormatSemanticMemories:
+    """Tests for format_semantic_memories."""
+
+    def test_empty(self):
+        result = format_semantic_memories([])
+        assert result == "{}"
+
+    def test_single_feature(self):
+        feature = SemanticFeature(
+            category="profile",
+            tag="preferences",
+            feature_name="favorite_food",
+            value="pizza",
+        )
+        result = format_semantic_memories([feature])
+        parsed = json.loads(result)
+        assert parsed == {"preferences": {"favorite_food": "pizza"}}
+
+    def test_groups_by_tag(self):
+        features = [
+            SemanticFeature(
+                category="profile",
+                tag="preferences",
+                feature_name="food",
+                value="pizza",
+            ),
+            SemanticFeature(
+                category="profile",
+                tag="preferences",
+                feature_name="color",
+                value="blue",
+            ),
+            SemanticFeature(
+                category="profile",
+                tag="background",
+                feature_name="role",
+                value="engineer",
+            ),
+        ]
+        result = format_semantic_memories(features)
+        parsed = json.loads(result)
+        assert parsed == {
+            "preferences": {"food": "pizza", "color": "blue"},
+            "background": {"role": "engineer"},
+        }
+
+    def test_metadata_excluded(self):
+        feature = SemanticFeature(
+            set_id="set_1",
+            category="profile",
+            tag="info",
+            feature_name="name",
+            value="Alice",
+            metadata=SemanticFeature.Metadata(
+                id="feat_1",
+                citations=["ep_1", "ep_2"],
+                other={"source": "conversation"},
+            ),
+        )
+        result = format_semantic_memories([feature])
+        parsed = json.loads(result)
+        # Only tag/feature_name/value should appear
+        assert parsed == {"info": {"name": "Alice"}}
+        assert "set_id" not in result
+        assert "citations" not in result
+        assert "feat_1" not in result
+
+
+class TestFormatSearchResult:
+    """Tests for format_search_result."""
+
+    def test_empty_result(self):
+        result = SearchResult(
+            status=0,
+            content=SearchResultContent(
+                episodic_memory=None,
+                semantic_memory=None,
+            ),
+        )
+        assert format_search_result(result) == ""
+
+    def test_episodic_only(self):
+        ep = EpisodeResponse(
+            uid="1",
+            content="Hello",
+            producer_id="user_1",
+            producer_role="user",
+            created_at=datetime(2024, 1, 1, 12, 0, tzinfo=timezone.utc),
+        )
+        result = SearchResult(
+            status=0,
+            content=SearchResultContent(
+                episodic_memory=EpisodicSearchResult(
+                    long_term_memory=EpisodicSearchLongTermMemory(episodes=[ep]),
+                    short_term_memory=EpisodicSearchShortTermMemory(
+                        episodes=[], episode_summary=[]
+                    ),
+                ),
+                semantic_memory=None,
+            ),
+        )
+        formatted = format_search_result(result)
+        assert formatted.startswith("[Episodic Memory]\n")
+        assert "user_1" in formatted
+        assert '"Hello"' in formatted
+        assert "[Semantic Memory]" not in formatted
+
+    def test_semantic_only(self):
+        feature = SemanticFeature(
+            category="profile",
+            tag="prefs",
+            feature_name="food",
+            value="pizza",
+        )
+        result = SearchResult(
+            status=0,
+            content=SearchResultContent(
+                episodic_memory=None,
+                semantic_memory=[feature],
+            ),
+        )
+        formatted = format_search_result(result)
+        assert formatted.startswith("[Semantic Memory]\n")
+        assert "[Episodic Memory]" not in formatted
+        semantic_json = formatted.removeprefix("[Semantic Memory]\n")
+        assert json.loads(semantic_json) == {"prefs": {"food": "pizza"}}
+
+    def test_combined(self):
+        ep = EpisodeResponse(
+            uid="1",
+            content="I like pizza",
+            producer_id="user_1",
+            producer_role="user",
+            created_at=datetime(2024, 1, 1, 12, 0, tzinfo=timezone.utc),
+        )
+        feature = SemanticFeature(
+            category="profile",
+            tag="prefs",
+            feature_name="food",
+            value="pizza",
+        )
+        result = SearchResult(
+            status=0,
+            content=SearchResultContent(
+                episodic_memory=EpisodicSearchResult(
+                    long_term_memory=EpisodicSearchLongTermMemory(episodes=[ep]),
+                    short_term_memory=EpisodicSearchShortTermMemory(
+                        episodes=[], episode_summary=[]
+                    ),
+                ),
+                semantic_memory=[feature],
+            ),
+        )
+        formatted = format_search_result(result)
+        assert "[Episodic Memory]" in formatted
+        assert "[Semantic Memory]" in formatted
+        assert formatted.index("[Episodic Memory]") < formatted.index(
+            "[Semantic Memory]"
+        )

{memmachine_client-0.3.4 → memmachine_client-0.3.6}/client_tests/test_integration_complete.py

@@ -45,6 +45,7 @@ def check_server_available():
 
 
 TEST_BASE_URL = os.environ.get("MEMORY_BACKEND_URL", "http://localhost:8080")
+CLIENT_TIMEOUT_SECONDS = 180
 
 
 @pytest.mark.integration
@@ -58,7 +59,7 @@ class TestMemMachineIntegration:
     @pytest.fixture
     def client(self):
         """Create a MemMachine client instance."""
-        return MemMachineClient(base_url=TEST_BASE_URL, timeout=60)
+        return MemMachineClient(base_url=TEST_BASE_URL, timeout=CLIENT_TIMEOUT_SECONDS)
 
     @pytest.fixture
     def unique_test_ids(self):
@@ -1644,7 +1645,7 @@ class TestConfigIntegration:
     @pytest.fixture
     def client(self):
         """Create a MemMachine client instance."""
-        return MemMachineClient(base_url=TEST_BASE_URL, timeout=60)
+        return MemMachineClient(base_url=TEST_BASE_URL, timeout=CLIENT_TIMEOUT_SECONDS)
 
     @pytest.fixture
     def config(self, client):

{memmachine_client-0.3.4 → memmachine_client-0.3.6}/pyproject.toml

@@ -8,7 +8,7 @@ dynamic = ["version"]
 dependencies = [
     "memmachine-common",
     "pydantic>=2.0.0",
-    "requests>=2.31.0",
+    "requests>=2.33.0",
     "typing-extensions>=4.0.0",
     "urllib3>=2.6.3",
 ]

{memmachine_client-0.3.4 → memmachine_client-0.3.6}/src/memmachine_client/__init__.py

@@ -7,7 +7,20 @@ episodic and profile memory systems.
 
 from .client import MemMachineClient
 from .config import Config
+from .format import (
+    format_episodes,
+    format_search_result,
+    format_semantic_memories,
+)
 from .memory import Memory
 from .project import Project
 
-__all__ = ["Config", "MemMachineClient", "Memory", "Project"]
+__all__ = [
+    "Config",
+    "MemMachineClient",
+    "Memory",
+    "Project",
+    "format_episodes",
+    "format_search_result",
+    "format_semantic_memories",
+]

memmachine_client-0.3.6/src/memmachine_client/format.py

@@ -0,0 +1,101 @@
+"""LLM-friendly formatting for memory search and list results.
+
+These functions mirror the server's internal formatting logic so that
+client-side consumers get the same compact representation the server
+uses when feeding memories into language models.
+
+Episodic format matches ``string_from_episode_context`` in the server.
+Semantic format matches ``_features_to_llm_format`` in the server.
+"""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Iterable
+
+from memmachine_common.api.spec import (
+    Episode,
+    EpisodeResponse,
+    SearchResult,
+    SemanticFeature,
+)
+
+
+def format_episodes(episodes: Iterable[EpisodeResponse | Episode]) -> str:
+    """Format episodic memories as an LLM-friendly string.
+
+    Each episode is rendered as::
+
+        [Monday, January 01, 2024 at 01:30 PM] producer_id: "content"
+
+    This mirrors the server's ``string_from_episode_context`` output.
+
+    Args:
+        episodes: Episodic memory entries from a search or list result.
+
+    Returns:
+        Newline-terminated formatted string (empty string when *episodes*
+        is empty).
+
+    """
+    result = ""
+    for episode in episodes:
+        if episode.created_at is not None:
+            date_str = episode.created_at.strftime("%A, %B %d, %Y")
+            time_str = episode.created_at.strftime("%I:%M %p")
+            result += f"[{date_str} at {time_str}] {episode.producer_id}: {json.dumps(episode.content)}\n"
+        else:
+            result += f"{episode.producer_id}: {json.dumps(episode.content)}\n"
+    return result
+
+
+def format_semantic_memories(features: Iterable[SemanticFeature]) -> str:
+    """Format semantic memories as a compact JSON string.
+
+    Produces a ``{tag: {feature_name: value}}`` structure, omitting all
+    metadata for context efficiency.  This mirrors the server's
+    ``_features_to_llm_format`` output.
+
+    Args:
+        features: Semantic memory entries from a search or list result.
+
+    Returns:
+        JSON string of the grouped features.
+
+    """
+    structured: dict[str, dict[str, str]] = {}
+    for feature in features:
+        structured.setdefault(feature.tag, {})[feature.feature_name] = feature.value
+    return json.dumps(structured)
+
+
+def format_search_result(result: SearchResult) -> str:
+    """Format a search result as an LLM-friendly string.
+
+    Combines episodic and semantic memories from a
+    :class:`~memmachine_common.api.spec.SearchResult` returned by
+    ``Memory.search()``.
+
+    Args:
+        result: A ``SearchResult`` object.
+
+    Returns:
+        Formatted string combining both memory types.
+
+    """
+    sections: list[str] = []
+
+    if result.content.episodic_memory is not None:
+        episodes = (
+            result.content.episodic_memory.long_term_memory.episodes
+            + result.content.episodic_memory.short_term_memory.episodes
+        )
+        if episodes:
+            sections.append(f"[Episodic Memory]\n{format_episodes(episodes)}")
+
+    if result.content.semantic_memory:
+        sections.append(
+            f"[Semantic Memory]\n{format_semantic_memories(result.content.semantic_memory)}"
+        )
+
+    return "\n".join(sections)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memmachine-client
-Version: 0.3.4
+Version: 0.3.6
 Summary: MemMachine REST Client - A lightweight Python client library for MemMachine memory system
 Author-email: MemMachine <noreply@memmachine.ai>
 License-Expression: Apache-2.0
@@ -19,7 +19,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: memmachine-common
 Requires-Dist: pydantic>=2.0.0
-Requires-Dist: requests>=2.31.0
+Requires-Dist: requests>=2.33.0
 Requires-Dist: typing-extensions>=4.0.0
 Requires-Dist: urllib3>=2.6.3
 Dynamic: license-file

{memmachine_client-0.3.4 → memmachine_client-0.3.6}/src/memmachine_client.egg-info/SOURCES.txt

@@ -4,12 +4,14 @@ pyproject.toml
 client_tests/__init__.py
 client_tests/test_client.py
 client_tests/test_config.py
+client_tests/test_format.py
 client_tests/test_integration_complete.py
 client_tests/test_langgraph.py
 client_tests/test_memory.py
 src/memmachine_client/__init__.py
 src/memmachine_client/client.py
 src/memmachine_client/config.py
+src/memmachine_client/format.py
 src/memmachine_client/langgraph.py
 src/memmachine_client/memory.py
 src/memmachine_client/project.py

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

@@ -1,5 +1,5 @@
 memmachine-common
 pydantic>=2.0.0
-requests>=2.31.0
+requests>=2.33.0
 typing-extensions>=4.0.0
 urllib3>=2.6.3