memwal 0.1.1.dev0__tar.gz → 0.1.2__tar.gz

memwal-0.1.2/CHANGELOG.md

@@ -0,0 +1,34 @@
+# memwal
+
+## 0.1.2
+
+### Added
+
+- Added `max_distance` to async and sync `recall()`.
+- Added credential verification helper.
+
+### Changed
+
+- Updated docs/examples to use `MEMWAL_PRIVATE_KEY`.
+- Rebranded package metadata and documentation from MemWal to Walrus Memory.
+
+### Fixed
+
+- Made `401` relayer errors more actionable.
+
+## 0.1.1
+
+### Added
+
+- Added relayer `env` presets.
+- Added compatibility checks and `compatibility()` helpers.
+
+## 0.1.0
+
+### Initial Release
+
+- `MemWal` async client and `MemWalSync` sync wrapper
+- Memory APIs: `remember`, `recall`, `analyze`, `ask`, `restore`, `health`
+- Async job helpers for remember, bulk remember, and analyze
+- LangChain/OpenAI middleware and delegate-key utilities
+- Ed25519 delegate-key auth with namespace-scoped memory isolation

{memwal-0.1.1.dev0 → memwal-0.1.2}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: memwal
-Version: 0.1.1.dev0
-Summary: Python SDK for MemWal — Privacy-first AI memory with Ed25519 signing
+Version: 0.1.2
+Summary: Python SDK for Walrus Memory — Privacy-first AI memory with Ed25519 signing
 Project-URL: Homepage, https://memwal.ai
 Project-URL: Documentation, https://docs.memwal.ai
 Project-URL: Repository, https://github.com/MystenLabs/MemWal
-Author: MemWal Team
+Author: Walrus Memory Team
 License-Expression: MIT
-Keywords: ai,ed25519,memory,memwal,privacy,sui,walrus
+Keywords: ai,ed25519,memory,memwal,privacy,sui,walrus,walrus-memory
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -37,9 +37,9 @@ Provides-Extra: openai
 Requires-Dist: openai>=1.0.0; extra == 'openai'
 Description-Content-Type: text/markdown
 
-# memwal
+# Walrus Memory Python SDK
 
-Python SDK for [MemWal](https://memwal.ai) — Privacy-first AI memory with Ed25519 signing.
+Python SDK for [Walrus Memory](https://memwal.ai) — Privacy-first AI memory with Ed25519 signing.
 
 All data processing (encryption, embedding, Walrus storage) happens server-side in a TEE. The SDK signs requests with your Ed25519 delegate key and sends text over HTTPS.
 
@@ -62,11 +62,14 @@ pip install memwal[all]         # Everything
 Set your environment variables first:
 
 ```bash
-export MEMWAL_KEY="your-ed25519-delegate-key-hex"
-export MEMWAL_ACCOUNT_ID="0x-your-memwal-account-id"
+export MEMWAL_PRIVATE_KEY="your-ed25519-delegate-private-key-hex"
+export MEMWAL_ACCOUNT_ID="0x-your-walrus-memory-account-id"
 export MEMWAL_SERVER_URL="https://relayer.memwal.ai"
 ```
 
+`MEMWAL_PRIVATE_KEY` is the delegate private key from the Walrus Memory dashboard and
+must stay server-side.
+
 ### Async (recommended)
 
 ```python
@@ -76,7 +79,7 @@ from memwal import MemWal
 
 async def main():
     memwal = MemWal.create(
-        key=os.environ["MEMWAL_KEY"],
+        key=os.environ["MEMWAL_PRIVATE_KEY"],
         account_id=os.environ["MEMWAL_ACCOUNT_ID"],
         server_url=os.environ.get("MEMWAL_SERVER_URL", "https://relayer.memwal.ai"),
     )
@@ -86,7 +89,7 @@ async def main():
     print(result.blob_id)
 
     # Recall memories
-    matches = await memwal.recall("food allergies")
+    matches = await memwal.recall("food allergies", limit=10, max_distance=0.7)
     for memory in matches.results:
         print(f"{memory.text} (relevance: {1 - memory.distance:.2f})")
 
@@ -107,7 +110,7 @@ import os
 from memwal import MemWalSync
 
 client = MemWalSync.create(
-    key=os.environ["MEMWAL_KEY"],
+    key=os.environ["MEMWAL_PRIVATE_KEY"],
     account_id=os.environ["MEMWAL_ACCOUNT_ID"],
     server_url=os.environ.get("MEMWAL_SERVER_URL", "https://relayer.memwal.ai"),
 )
@@ -124,7 +127,7 @@ import os
 from memwal import MemWal
 
 async with MemWal.create(
-    key=os.environ["MEMWAL_KEY"],
+    key=os.environ["MEMWAL_PRIVATE_KEY"],
     account_id=os.environ["MEMWAL_ACCOUNT_ID"],
 ) as memwal:
     await memwal.remember("I prefer dark mode")
@@ -139,7 +142,7 @@ Same shorthand as the TypeScript SDK and MCP package.
 from memwal import MemWal
 
 memwal = MemWal.create(
-    key=os.environ["MEMWAL_KEY"],
+    key=os.environ["MEMWAL_PRIVATE_KEY"],
     account_id=os.environ["MEMWAL_ACCOUNT_ID"],
     env="prod",   # prod | dev | staging | local
 )
@@ -169,7 +172,7 @@ from memwal import with_memwal_langchain
 llm = ChatOpenAI(model="gpt-4o")
 smart_llm = with_memwal_langchain(
     llm,
-    key=os.environ["MEMWAL_KEY"],
+    key=os.environ["MEMWAL_PRIVATE_KEY"],
     account_id=os.environ["MEMWAL_ACCOUNT_ID"],
     server_url=os.environ.get("MEMWAL_SERVER_URL", "https://relayer.memwal.ai"),
     max_memories=5,
@@ -190,7 +193,7 @@ from memwal import with_memwal_openai
 client = AsyncOpenAI()
 smart_client = with_memwal_openai(
     client,
-    key=os.environ["MEMWAL_KEY"],
+    key=os.environ["MEMWAL_PRIVATE_KEY"],
     account_id=os.environ["MEMWAL_ACCOUNT_ID"],
     server_url=os.environ.get("MEMWAL_SERVER_URL", "https://relayer.memwal.ai"),
 )
@@ -213,7 +216,7 @@ Create a new async client.
 | Method | Description |
 |--------|-------------|
 | `await remember(text, namespace?)` | Store a memory |
-| `await recall(query, limit?, namespace?)` | Search memories |
+| `await recall(query, limit?, namespace?, max_distance?)` | Search memories, optionally filtering by distance |
 | `await analyze(text, namespace?)` | Extract and store facts |
 | `await ask(question, limit?, namespace?)` | Ask a question answered using memories |
 | `await restore(namespace, limit?)` | Restore a namespace |

{memwal-0.1.1.dev0 → memwal-0.1.2}/README.md

@@ -1,6 +1,6 @@
-# memwal
+# Walrus Memory Python SDK
 
-Python SDK for [MemWal](https://memwal.ai) — Privacy-first AI memory with Ed25519 signing.
+Python SDK for [Walrus Memory](https://memwal.ai) — Privacy-first AI memory with Ed25519 signing.
 
 All data processing (encryption, embedding, Walrus storage) happens server-side in a TEE. The SDK signs requests with your Ed25519 delegate key and sends text over HTTPS.
 
@@ -23,11 +23,14 @@ pip install memwal[all]         # Everything
 Set your environment variables first:
 
 ```bash
-export MEMWAL_KEY="your-ed25519-delegate-key-hex"
-export MEMWAL_ACCOUNT_ID="0x-your-memwal-account-id"
+export MEMWAL_PRIVATE_KEY="your-ed25519-delegate-private-key-hex"
+export MEMWAL_ACCOUNT_ID="0x-your-walrus-memory-account-id"
 export MEMWAL_SERVER_URL="https://relayer.memwal.ai"
 ```
 
+`MEMWAL_PRIVATE_KEY` is the delegate private key from the Walrus Memory dashboard and
+must stay server-side.
+
 ### Async (recommended)
 
 ```python
@@ -37,7 +40,7 @@ from memwal import MemWal
 
 async def main():
     memwal = MemWal.create(
-        key=os.environ["MEMWAL_KEY"],
+        key=os.environ["MEMWAL_PRIVATE_KEY"],
         account_id=os.environ["MEMWAL_ACCOUNT_ID"],
         server_url=os.environ.get("MEMWAL_SERVER_URL", "https://relayer.memwal.ai"),
     )
@@ -47,7 +50,7 @@ async def main():
     print(result.blob_id)
 
     # Recall memories
-    matches = await memwal.recall("food allergies")
+    matches = await memwal.recall("food allergies", limit=10, max_distance=0.7)
     for memory in matches.results:
         print(f"{memory.text} (relevance: {1 - memory.distance:.2f})")
 
@@ -68,7 +71,7 @@ import os
 from memwal import MemWalSync
 
 client = MemWalSync.create(
-    key=os.environ["MEMWAL_KEY"],
+    key=os.environ["MEMWAL_PRIVATE_KEY"],
     account_id=os.environ["MEMWAL_ACCOUNT_ID"],
     server_url=os.environ.get("MEMWAL_SERVER_URL", "https://relayer.memwal.ai"),
 )
@@ -85,7 +88,7 @@ import os
 from memwal import MemWal
 
 async with MemWal.create(
-    key=os.environ["MEMWAL_KEY"],
+    key=os.environ["MEMWAL_PRIVATE_KEY"],
     account_id=os.environ["MEMWAL_ACCOUNT_ID"],
 ) as memwal:
     await memwal.remember("I prefer dark mode")
@@ -100,7 +103,7 @@ Same shorthand as the TypeScript SDK and MCP package.
 from memwal import MemWal
 
 memwal = MemWal.create(
-    key=os.environ["MEMWAL_KEY"],
+    key=os.environ["MEMWAL_PRIVATE_KEY"],
     account_id=os.environ["MEMWAL_ACCOUNT_ID"],
     env="prod",   # prod | dev | staging | local
 )
@@ -130,7 +133,7 @@ from memwal import with_memwal_langchain
 llm = ChatOpenAI(model="gpt-4o")
 smart_llm = with_memwal_langchain(
     llm,
-    key=os.environ["MEMWAL_KEY"],
+    key=os.environ["MEMWAL_PRIVATE_KEY"],
     account_id=os.environ["MEMWAL_ACCOUNT_ID"],
     server_url=os.environ.get("MEMWAL_SERVER_URL", "https://relayer.memwal.ai"),
     max_memories=5,
@@ -151,7 +154,7 @@ from memwal import with_memwal_openai
 client = AsyncOpenAI()
 smart_client = with_memwal_openai(
     client,
-    key=os.environ["MEMWAL_KEY"],
+    key=os.environ["MEMWAL_PRIVATE_KEY"],
     account_id=os.environ["MEMWAL_ACCOUNT_ID"],
     server_url=os.environ.get("MEMWAL_SERVER_URL", "https://relayer.memwal.ai"),
 )
@@ -174,7 +177,7 @@ Create a new async client.
 | Method | Description |
 |--------|-------------|
 | `await remember(text, namespace?)` | Store a memory |
-| `await recall(query, limit?, namespace?)` | Search memories |
+| `await recall(query, limit?, namespace?, max_distance?)` | Search memories, optionally filtering by distance |
 | `await analyze(text, namespace?)` | Extract and store facts |
 | `await ask(question, limit?, namespace?)` | Ask a question answered using memories |
 | `await restore(namespace, limit?)` | Restore a namespace |

memwal-0.1.2/examples/.env.example

@@ -0,0 +1,10 @@
+# Local server (default) or remote relayer
+MEMWAL_SERVER_URL=http://localhost:8000
+# Ed25519 delegate private key (64-hex). Get from Walrus Memory dashboard.
+MEMWAL_PRIVATE_KEY=21b423e72282dcc47805de48ef9130331b642667b7b2a5cd621767928205e360
+# Optional: paste the dashboard delegate public key so verification can catch mismatches.
+MEMWAL_DELEGATE_PUBLIC_KEY=
+# Walrus Memory account object ID on Sui (the wallet's account)
+MEMWAL_ACCOUNT_ID=0x8a1121b8f95d79e68bd07efaf71689ce6fd832b369cdb1b2a943ec7beb822392
+# Namespace for these test memories
+MEMWAL_NAMESPACE=python-sdk-example

{memwal-0.1.1.dev0 → memwal-0.1.2}/examples/async_remember_demo.py

@@ -65,13 +65,13 @@ def _ms(start: float) -> int:
 
 
 async def main() -> None:
-    server_url = os.environ.get("MEMWAL_SERVER_URL", "http://localhost:3001")
-    key = os.environ.get("MEMWAL_KEY")
+    server_url = os.environ.get("MEMWAL_SERVER_URL", "http://localhost:8000")
+    key = os.environ.get("MEMWAL_PRIVATE_KEY")
     account_id = os.environ.get("MEMWAL_ACCOUNT_ID")
     namespace = os.environ.get("MEMWAL_NAMESPACE", "python-sdk-example")
 
     if not key or not account_id:
-        print("ERROR: set MEMWAL_KEY + MEMWAL_ACCOUNT_ID in examples/.env")
+        print("ERROR: set MEMWAL_PRIVATE_KEY + MEMWAL_ACCOUNT_ID in examples/.env")
         sys.exit(2)
 
     print(f"server      : {server_url}")

{memwal-0.1.1.dev0 → memwal-0.1.2}/examples/interactive_demo.py

@@ -94,13 +94,13 @@ def _log_offset() -> int:
 
 
 async def main() -> None:
-    server_url = os.environ.get("MEMWAL_SERVER_URL", "http://localhost:3001")
-    key = os.environ.get("MEMWAL_KEY")
+    server_url = os.environ.get("MEMWAL_SERVER_URL", "http://localhost:8000")
+    key = os.environ.get("MEMWAL_PRIVATE_KEY")
     account_id = os.environ.get("MEMWAL_ACCOUNT_ID")
     namespace = os.environ.get("MEMWAL_NAMESPACE", "python-sdk-example")
 
     if not key or not account_id:
-        print("ERROR: set MEMWAL_KEY + MEMWAL_ACCOUNT_ID in examples/.env")
+        print("ERROR: set MEMWAL_PRIVATE_KEY + MEMWAL_ACCOUNT_ID in examples/.env")
         sys.exit(2)
 
     print(f"server      : {server_url}")

memwal-0.1.2/examples/verify_credentials.py

@@ -0,0 +1,67 @@
+"""Verify MemWal example credentials before calling the relayer.
+
+Usage:
+    MEMWAL_PRIVATE_KEY=<hex> MEMWAL_ACCOUNT_ID=0x... python examples/verify_credentials.py
+
+Optional:
+    Set MEMWAL_DELEGATE_PUBLIC_KEY to the dashboard public key to fail on
+    public/private key mismatch.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import sys
+
+import nacl.signing
+
+HEX_32_BYTES = re.compile(r"^(0x)?[0-9a-fA-F]{64}$")
+ACCOUNT_ID = re.compile(r"^0x[0-9a-fA-F]{64}$")
+
+
+def normalize_hex(value: str) -> str:
+    value = value.strip()
+    return value[2:] if value.lower().startswith("0x") else value
+
+
+def main() -> None:
+    private_key = os.environ.get("MEMWAL_PRIVATE_KEY") or ""
+    account_id = os.environ.get("MEMWAL_ACCOUNT_ID") or ""
+    expected_public_key = os.environ.get("MEMWAL_DELEGATE_PUBLIC_KEY") or ""
+    server_url = os.environ.get("MEMWAL_SERVER_URL") or ""
+
+    if not private_key:
+        raise SystemExit("MEMWAL_PRIVATE_KEY is required")
+    if not HEX_32_BYTES.match(private_key):
+        raise SystemExit("MEMWAL_PRIVATE_KEY must be a 64-character Ed25519 private key hex string")
+    if account_id and not ACCOUNT_ID.match(account_id):
+        raise SystemExit("MEMWAL_ACCOUNT_ID must be a 0x-prefixed 32-byte Sui object ID")
+
+    signing_key = nacl.signing.SigningKey(bytes.fromhex(normalize_hex(private_key)))
+    derived_public_key = signing_key.verify_key.encode().hex()
+
+    if expected_public_key and derived_public_key != normalize_hex(expected_public_key).lower():
+        raise SystemExit(
+            "MEMWAL_PRIVATE_KEY does not derive MEMWAL_DELEGATE_PUBLIC_KEY. "
+            "You may have pasted a public key or a key from another account."
+        )
+
+    print("Walrus Memory credentials look parseable.")
+    print(f"Derived delegate public key: {derived_public_key}")
+    if account_id:
+        print(f"Account ID: {account_id}")
+    if server_url:
+        print(f"Relayer URL: {server_url}")
+    if not expected_public_key:
+        print("Set MEMWAL_DELEGATE_PUBLIC_KEY to fail on public/private key mismatch.")
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except SystemExit:
+        raise
+    except Exception as exc:
+        print(exc, file=sys.stderr)
+        raise SystemExit(1) from exc

{memwal-0.1.1.dev0 → memwal-0.1.2}/memwal/__init__.py

@@ -1,5 +1,5 @@
 """
-memwal — Privacy-first AI memory SDK
+Walrus Memory — Privacy-first AI memory SDK
 
 Ed25519 delegate key auth + server-side TEE processing.
 
@@ -32,7 +32,6 @@ from .client import (
     MemWalSync,
 )
 from .middleware import with_memwal_langchain, with_memwal_openai
-from .utils import delegate_key_to_sui_address, delegate_key_to_public_key
 from .types import (
     ENV_PRESETS,
     AnalyzedFact,
@@ -61,7 +60,9 @@ from .types import (
     RememberManualResult,
     RememberResult,
     RestoreResult,
+    ScoringWeights,
 )
+from .utils import delegate_key_to_public_key, delegate_key_to_sui_address
 
 # JS-style alias for developers coming from the TypeScript SDK
 withMemWal = with_memwal_langchain
@@ -105,6 +106,7 @@ __all__ = [
     "AnalyzedFact",
     "HealthResult",
     "RestoreResult",
+    "ScoringWeights",
     "RememberManualOptions",
     "RememberManualResult",
     "RecallManualOptions",
@@ -112,4 +114,4 @@ __all__ = [
     "RecallManualResult",
 ]
 
-__version__ = "0.1.1.dev0"
+__version__ = "0.1.2"

{memwal-0.1.1.dev0 → memwal-0.1.2}/memwal/client.py

@@ -1,7 +1,7 @@
 """
-memwal — SDK Client
+Walrus Memory — SDK Client
 
-Ed25519 delegate key based client that communicates with the MemWal
+Ed25519 delegate key based client that communicates with the Walrus Memory
 Rust server (TEE). All data processing (encryption, embedding, Walrus)
 happens server-side -- the SDK just signs requests and sends text.
 
@@ -58,7 +58,6 @@ from .types import (
     RememberBulkResult,
     RememberBulkStatusItem,
     RememberBulkStatusResult,
-    RememberJobStatus,
     RememberManualOptions,
     RememberManualResult,
     RememberResult,
@@ -79,6 +78,11 @@ from .utils import (
 T = TypeVar("T")
 SEAL_SESSION_TTL_MIN = 5
 SEAL_SESSION_SAFETY_MARGIN_MS = 30_000
+AUTH_REJECTED_MESSAGE = (
+    "401 from relayer: typically wrong private key, key not registered on this "
+    "account, account ID mismatch, or staging/mainnet mismatch. Check .env.local "
+    "and dashboard credentials."
+)
 
 
 # ============================================================
@@ -119,7 +123,7 @@ def _is_transient_polling_status(status: int) -> bool:
 
 
 class MemWal:
-    """Async-native MemWal client.
+    """Async-native Walrus Memory client.
 
     All API methods are ``async``. For synchronous usage, wrap calls with
     ``asyncio.run()`` or use the :class:`MemWalSync` convenience wrapper.
@@ -147,11 +151,11 @@ class MemWal:
         namespace: str = "default",
         env: Optional[str] = None,
     ) -> "MemWal":
-        """Create a new MemWal client instance.
+        """Create a new Walrus Memory client instance.
 
         Args:
             key: Ed25519 private key hex string (the delegate key).
-            account_id: MemWalAccount object ID on Sui.
+            account_id: Walrus Memory account object ID on Sui.
             server_url: Server URL (default: ``http://localhost:8000``).
             namespace: Default namespace for memory isolation (default: ``"default"``).
             env: Optional relayer preset — ``"prod"``, ``"dev"``, ``"staging"``,
@@ -472,6 +476,7 @@ class MemWal:
         query: str,
         limit: int = 10,
         namespace: Optional[str] = None,
+        max_distance: Optional[float] = None,
     ) -> RecallResult:
         """Recall memories similar to a query.
 
@@ -481,6 +486,8 @@ class MemWal:
             query: Search query.
             limit: Max number of results (default: 10).
             namespace: Override the default namespace.
+            max_distance: Optional client-side relevance threshold. Memories with
+                ``distance >= max_distance`` are dropped.
 
         Returns:
             :class:`RecallResult` with decrypted text results.
@@ -498,6 +505,9 @@ class MemWal:
             )
             for m in data.get("results", [])
         ]
+        if max_distance is not None:
+            memories = [m for m in memories if m.distance < max_distance]
+            return RecallResult(results=memories, total=len(memories))
         return RecallResult(results=memories, total=data.get("total", len(memories)))
 
     async def analyze(self, text: str, namespace: Optional[str] = None) -> AnalyzeResult:
@@ -717,14 +727,18 @@ class MemWal:
         Returns:
             :class:`RecallManualResult` with blob_id + distance pairs.
         """
+        body: Dict[str, Any] = {
+            "vector": opts.vector,
+            "limit": opts.limit,
+            "namespace": opts.namespace or self._namespace,
+        }
+        if opts.scoring_weights is not None:
+            body["scoring_weights"] = opts.scoring_weights.to_wire()
+
         data = await self._signed_request(
             "POST",
             "/api/recall/manual",
-            {
-                "vector": opts.vector,
-                "limit": opts.limit,
-                "namespace": opts.namespace or self._namespace,
-            },
+            body,
             include_seal_session=False,
         )
         hits = [
@@ -763,14 +777,14 @@ class MemWal:
                 health_response = await self._http.get(f"{self._server_url}/health")
                 if health_response.status_code != 200:
                     raise MemWalError(
-                        "MemWal compatibility check failed: "
+                        "Walrus Memory compatibility check failed: "
                         f"GET /version returned {version_response.status_code}, "
                         f"and GET /health returned {health_response.status_code}"
                     )
                 metadata = health_response.json()
             else:
                 raise MemWalError(
-                    "MemWal compatibility check failed: "
+                    "Walrus Memory compatibility check failed: "
                     f"GET /version returned {version_response.status_code}"
                 )
 
@@ -829,7 +843,8 @@ class MemWal:
                     version = obj.get("version")
         if str(version) != "1":
             raise MemWalError(
-                f"SEAL package {package_id} must be at version 1 to build x-seal-session, got {version!r}"
+                f"SEAL package {package_id} must be at version 1 to build "
+                f"x-seal-session, got {version!r}"
             )
 
     async def _build_seal_session_inner(self) -> str:
@@ -909,7 +924,7 @@ class MemWal:
             - ``x-timestamp``: Unix seconds string
             - ``x-nonce``: UUID v4 replay-protection nonce
             - ``x-seal-session``: Base64-encoded exported session envelope
-            - ``x-account-id``: MemWalAccount object ID
+            - ``x-account-id``: Walrus Memory account object ID
             - ``Content-Type``: application/json
         """
         import uuid
@@ -958,7 +973,7 @@ class MemWal:
             err_text = response.text
             if response.status_code == 426:
                 raise MemWalCompatibilityError(
-                    "MemWal relayer rejected this SDK as unsupported "
+                    "Walrus Memory relayer rejected this SDK as unsupported "
                     f"(HTTP 426 Upgrade Required). Relayer response: "
                     f"{err_text[:300] or 'upgrade required'}"
                 )
@@ -971,7 +986,7 @@ class MemWal:
 
 
 class MemWalError(Exception):
-    """Exception raised for MemWal API errors."""
+    """Exception raised for Walrus Memory API errors."""
 
     pass
 
@@ -991,7 +1006,10 @@ class _HttpStatusError(MemWalError):
     """
 
     def __init__(self, status: int, body: str) -> None:
-        super().__init__(f"MemWal API error ({status}): {body}")
+        if status == 401:
+            super().__init__(AUTH_REJECTED_MESSAGE)
+        else:
+            super().__init__(f"Walrus Memory API error ({status}): {body}")
         self.status = status
         self.body = body
 
@@ -1054,7 +1072,7 @@ class MemWalSync:
         namespace: str = "default",
         env: Optional[str] = None,
     ) -> "MemWalSync":
-        """Create a synchronous MemWal client.
+        """Create a synchronous Walrus Memory client.
 
         Same parameters as :meth:`MemWal.create` (including the ``env``
         relayer preset).
@@ -1170,10 +1188,14 @@ class MemWalSync:
         return self._run(self._inner.remember_bulk_and_wait(items, opts))
 
     def recall(
-        self, query: str, limit: int = 10, namespace: Optional[str] = None
+        self,
+        query: str,
+        limit: int = 10,
+        namespace: Optional[str] = None,
+        max_distance: Optional[float] = None,
     ) -> RecallResult:
         """Synchronous version of :meth:`MemWal.recall`."""
-        return self._run(self._inner.recall(query, limit, namespace))
+        return self._run(self._inner.recall(query, limit, namespace, max_distance))
 
     def analyze(self, text: str, namespace: Optional[str] = None) -> AnalyzeResult:
         """Synchronous version of :meth:`MemWal.analyze`."""

{memwal-0.1.1.dev0 → memwal-0.1.2}/memwal/compatibility.py

@@ -18,33 +18,33 @@ def compatibility_error(metadata: Dict[str, Any], server_url: str) -> Optional[s
 
     if not api_version or not relayer_version or not isinstance(min_supported, dict):
         return (
-            f"MemWal relayer at {server_url} does not expose compatibility metadata. "
+            f"Walrus Memory relayer at {server_url} does not expose compatibility metadata. "
             "Upgrade the relayer to a version that serves GET /version, or use an older SDK."
         )
 
     api_major = _semver_major(str(api_version))
     if api_major is None:
-        return f'MemWal relayer at {server_url} returned invalid apiVersion "{api_version}".'
+        return f'Walrus Memory relayer at {server_url} returned invalid apiVersion "{api_version}".'
 
     if api_major != SUPPORTED_RELAYER_API_MAJOR:
         return (
-            "This MemWal Python SDK supports relayer API "
+            "This Walrus Memory Python SDK supports relayer API "
             f"{SUPPORTED_RELAYER_API_MAJOR}.x, but {server_url} reports apiVersion "
             f"{api_version}. Upgrade or downgrade the SDK/relayer pair."
         )
 
     min_python = min_supported.get("python")
     if not isinstance(min_python, str):
-        return f"MemWal relayer at {server_url} did not report minSupportedSdk.python."
+        return f"Walrus Memory relayer at {server_url} did not report minSupportedSdk.python."
     if _parse_semver(min_python) is None:
         return (
-            f'MemWal relayer at {server_url} returned invalid '
+            f'Walrus Memory relayer at {server_url} returned invalid '
             f'minSupportedSdk.python "{min_python}".'
         )
 
     if _compare_semver(MEMWAL_PYTHON_COMPATIBILITY_VERSION, min_python) < 0:
         return (
-            f"MemWal relayer at {server_url} requires Python SDK >= {min_python}, "
+            f"Walrus Memory relayer at {server_url} requires Python SDK >= {min_python}, "
             f"but this package supports the {MEMWAL_PYTHON_COMPATIBILITY_VERSION} "
             "compatibility baseline. Upgrade memwal or use an older compatible relayer."
         )

{memwal-0.1.1.dev0 → memwal-0.1.2}/memwal/middleware.py

@@ -1,5 +1,5 @@
 """
-memwal — AI Middleware
+Walrus Memory — AI Middleware
 
 Wraps LangChain and OpenAI SDK clients with automatic memory management.
 Before each LLM call, relevant memories are recalled and injected.
@@ -145,7 +145,7 @@ def with_memwal_langchain(
     debug: bool = False,
     env: Optional[str] = None,
 ) -> "BaseChatModel":
-    """Wrap a LangChain ``BaseChatModel`` with MemWal memory management.
+    """Wrap a LangChain ``BaseChatModel`` with Walrus Memory management.
 
     Before each call:
         - Recall relevant memories for the last user message
@@ -157,8 +157,8 @@ def with_memwal_langchain(
     Args:
         llm: A LangChain ``BaseChatModel`` instance.
         key: Ed25519 delegate key (hex).
-        account_id: MemWalAccount object ID.
-        server_url: MemWal server URL.
+        account_id: Walrus Memory account object ID.
+        server_url: Walrus Memory server URL.
         namespace: Default namespace.
         max_memories: Max memories to inject per request.
         auto_save: Auto-save new facts from conversation.
@@ -168,7 +168,7 @@ def with_memwal_langchain(
             ``"local"``). Same precedence as :meth:`MemWal.create`.
 
     Returns:
-        A wrapped ``BaseChatModel`` that automatically uses MemWal memory.
+        A wrapped ``BaseChatModel`` that automatically uses Walrus Memory.
     """
     try:
         from langchain_core.messages import HumanMessage, SystemMessage  # noqa: F811
@@ -208,7 +208,7 @@ def with_memwal_langchain(
                 return messages
 
             memory_context = _format_memories(relevant)
-            log(f"[MemWal] Found {len(relevant)} relevant memories")
+            log(f"[Walrus Memory] Found {len(relevant)} relevant memories")
 
             # Insert memory system message before the last user message
             result = list(messages)
@@ -226,7 +226,7 @@ def with_memwal_langchain(
 
             return result
         except Exception as e:
-            log(f"[MemWal] Memory search failed: {e}")
+            log(f"[Walrus Memory] Memory search failed: {e}")
             return messages
 
     async def _post_analyze(messages: List[BaseMessage]) -> None:
@@ -238,7 +238,7 @@ def with_memwal_langchain(
             try:
                 await memwal.analyze(user_text, namespace)
             except Exception as e:
-                log(f"[MemWal] Auto-save failed: {e}")
+                log(f"[Walrus Memory] Auto-save failed: {e}")
 
     async def patched_agenerate(
         messages: List[List[BaseMessage]], *args: Any, **kwargs: Any
@@ -304,7 +304,7 @@ def with_memwal_openai(
     debug: bool = False,
     env: Optional[str] = None,
 ) -> Any:
-    """Wrap an OpenAI client with MemWal memory management.
+    """Wrap an OpenAI client with Walrus Memory management.
 
     Works with both ``openai.OpenAI`` (sync) and ``openai.AsyncOpenAI`` (async).
 
@@ -318,8 +318,8 @@ def with_memwal_openai(
     Args:
         client: An ``openai.OpenAI`` or ``openai.AsyncOpenAI`` instance.
         key: Ed25519 delegate key (hex).
-        account_id: MemWalAccount object ID.
-        server_url: MemWal server URL.
+        account_id: Walrus Memory account object ID.
+        server_url: Walrus Memory server URL.
         namespace: Default namespace.
         max_memories: Max memories to inject per request.
         auto_save: Auto-save new facts from conversation.
@@ -329,7 +329,7 @@ def with_memwal_openai(
             ``"local"``). Same precedence as :meth:`MemWal.create`.
 
     Returns:
-        The same client, with ``chat.completions.create`` wrapped to use MemWal.
+        The same client, with ``chat.completions.create`` wrapped to use Walrus Memory.
     """
     memwal = MemWal.create(
         key=key,
@@ -379,14 +379,14 @@ def _wrap_async_openai(
                 ]
                 if relevant:
                     memory_context = _format_memories(relevant)
-                    log(f"[MemWal] Found {len(relevant)} relevant memories")
+                    log(f"[Walrus Memory] Found {len(relevant)} relevant memories")
                     messages = _inject_openai_memory(list(messages), memory_context)
                     if "messages" in kwargs:
                         kwargs["messages"] = messages
                     elif args:
                         args = (messages,) + args[1:]
             except Exception as e:
-                log(f"[MemWal] Memory search failed: {e}")
+                log(f"[Walrus Memory] Memory search failed: {e}")
 
         result = await original_create(*args, **kwargs)
 
@@ -396,7 +396,7 @@ def _wrap_async_openai(
                 try:
                     await memwal.analyze(user_text, namespace)
                 except Exception as e:
-                    log(f"[MemWal] Auto-save failed: {e}")
+                    log(f"[Walrus Memory] Auto-save failed: {e}")
 
             _fire_and_forget(_analyze())
 
@@ -437,14 +437,14 @@ def _wrap_sync_openai(
                 ]
                 if relevant:
                     memory_context = _format_memories(relevant)
-                    log(f"[MemWal] Found {len(relevant)} relevant memories")
+                    log(f"[Walrus Memory] Found {len(relevant)} relevant memories")
                     messages = _inject_openai_memory(list(messages), memory_context)
                     if "messages" in kwargs:
                         kwargs["messages"] = messages
                     elif args:
                         args = (messages,) + args[1:]
             except Exception as e:
-                log(f"[MemWal] Memory search failed: {e}")
+                log(f"[Walrus Memory] Memory search failed: {e}")
 
         result = original_create(*args, **kwargs)
 
@@ -454,7 +454,7 @@ def _wrap_sync_openai(
                 try:
                     await memwal.analyze(user_text, namespace)
                 except Exception as e:
-                    log(f"[MemWal] Auto-save failed: {e}")
+                    log(f"[Walrus Memory] Auto-save failed: {e}")
 
             _fire_and_forget(_analyze())
 

{memwal-0.1.1.dev0 → memwal-0.1.2}/memwal/types.py

@@ -1,9 +1,9 @@
 """
-memwal — Core Types
+Walrus Memory — Core Types
 
 Dataclasses for all API request options and response types.
 Ed25519 delegate key based SDK that communicates with
-the MemWal Rust server (TEE).
+the Walrus Memory Rust server (TEE).
 """
 
 from __future__ import annotations
@@ -22,7 +22,7 @@ DEFAULT_SERVER_URL = "http://localhost:8000"
 
 #: Named relayer environments. Mirrors the TypeScript SDK / MCP package
 #: ``--prod`` / ``--dev`` / ``--staging`` / ``--local`` presets so the same
-#: shorthand works across every MemWal client.
+#: shorthand works across every Walrus Memory client.
 ENV_PRESETS = {
     "prod": "https://relayer.memwal.ai",
     "dev": "https://relayer.dev.memwal.ai",
@@ -33,11 +33,12 @@ ENV_PRESETS = {
 
 @dataclass
 class MemWalConfig:
-    """Configuration for creating a MemWal client.
+    """Configuration for creating a Walrus Memory client.
 
     Attributes:
-        key: Ed25519 private key (hex string). This is the delegate key from app.memwal.com.
-        account_id: MemWalAccount object ID on Sui.
+        key: Ed25519 private key (hex string). This is the delegate key from the
+            Walrus Memory dashboard.
+        account_id: Walrus Memory account object ID on Sui.
         server_url: Server URL (default: http://localhost:8000). An explicit
             non-default value always wins over ``env``.
         namespace: Default namespace for memory isolation (default: "default").
@@ -99,6 +100,37 @@ class RecallResult:
     total: int
 
 
+@dataclass
+class ScoringWeights:
+    """Optional composite-scoring weights for recall ranking.
+
+    Attributes:
+        semantic: Weight applied to semantic similarity (default: 1).
+        recency: Weight applied to recency decay (default: 0).
+        recency_half_life_days: Half-life for the recency term, in days (default: 30).
+        importance: Weight applied to memory importance (default: 0).
+    """
+
+    semantic: Optional[float] = None
+    recency: Optional[float] = None
+    recency_half_life_days: Optional[float] = None
+    importance: Optional[float] = None
+
+    def to_wire(self) -> Dict[str, float]:
+        """Return the snake_case payload expected by the relayer."""
+
+        payload: Dict[str, float] = {}
+        if self.semantic is not None:
+            payload["semantic"] = self.semantic
+        if self.recency is not None:
+            payload["recency"] = self.recency
+        if self.recency_half_life_days is not None:
+            payload["recency_half_life_days"] = self.recency_half_life_days
+        if self.importance is not None:
+            payload["importance"] = self.importance
+        return payload
+
+
 @dataclass
 class AnalyzedFact:
     """A single extracted fact."""
@@ -212,11 +244,13 @@ class RecallManualOptions:
         vector: Pre-computed query embedding vector.
         limit: Max number of results (default: 10).
         namespace: Namespace (default: config namespace or "default").
+        scoring_weights: Optional composite-scoring weights applied before returning hits.
     """
 
     vector: List[float]
     limit: int = 10
     namespace: Optional[str] = None
+    scoring_weights: Optional[ScoringWeights] = None
 
 
 @dataclass

{memwal-0.1.1.dev0 → memwal-0.1.2}/memwal/utils.py

@@ -1,5 +1,5 @@
 """
-memwal — Shared Utilities
+Walrus Memory — Shared Utilities
 
 Crypto and encoding helpers for Ed25519 signing and SHA-256 hashing.
 Uses PyNaCl (nacl.signing) as the primary Ed25519 implementation.
@@ -119,7 +119,7 @@ def build_signature_message(
         path: URL path with query (e.g. ``"/api/remember"``).
         body_sha256: SHA-256 hex digest of the JSON body string.
         nonce: UUID v4 sent as the ``x-nonce`` header (required).
-        account_id: MemWalAccount object ID sent as ``x-account-id``
+        account_id: Walrus Memory account object ID sent as ``x-account-id``
             (required; empty string here will mismatch on server).
     """
     return f"{timestamp}.{method}.{path}.{body_sha256}.{nonce}.{account_id}"

{memwal-0.1.1.dev0 → memwal-0.1.2}/pyproject.toml

@@ -4,15 +4,15 @@ build-backend = "hatchling.build"
 
 [project]
 name = "memwal"
-version = "0.1.1.dev0"
-description = "Python SDK for MemWal — Privacy-first AI memory with Ed25519 signing"
+version = "0.1.2"
+description = "Python SDK for Walrus Memory — Privacy-first AI memory with Ed25519 signing"
 readme = "README.md"
 license = "MIT"
 requires-python = ">=3.9"
 authors = [
-    { name = "MemWal Team" },
+    { name = "Walrus Memory Team" },
 ]
-keywords = ["memwal", "ai", "memory", "ed25519", "privacy", "walrus", "sui"]
+keywords = ["memwal", "walrus-memory", "ai", "memory", "ed25519", "privacy", "walrus", "sui"]
 classifiers = [
     "Development Status :: 4 - Beta",
     "Intended Audience :: Developers",

{memwal-0.1.1.dev0 → memwal-0.1.2}/run_tests.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """
-MemWal Python SDK — Test Runner
+Walrus Memory Python SDK — Test Runner
 
 Runs all tests grouped by category and prints a clean summary.
 
@@ -8,7 +8,7 @@ Usage:
     python3 run_tests.py
 
 With dev server (integration tests):
-    MEMWAL_KEY=<hex> MEMWAL_ACCOUNT_ID=0x... MEMWAL_SERVER_URL=https://... python3 run_tests.py
+    MEMWAL_PRIVATE_KEY=<hex> MEMWAL_ACCOUNT_ID=0x... MEMWAL_SERVER_URL=https://... python3 run_tests.py
 """
 
 from __future__ import annotations
@@ -27,7 +27,7 @@ DIM    = "\033[2m"
 RESET  = "\033[0m"
 
 SERVER_URL  = os.environ.get("MEMWAL_SERVER_URL", "https://relayer.dev.memwal.ai")
-PRIVATE_KEY = os.environ.get("MEMWAL_KEY", "")
+PRIVATE_KEY = os.environ.get("MEMWAL_PRIVATE_KEY", "")
 ACCOUNT_ID  = os.environ.get("MEMWAL_ACCOUNT_ID", "")
 HAS_KEY     = bool(PRIVATE_KEY and ACCOUNT_ID)
 
@@ -77,7 +77,7 @@ def status(passed: int, failed: int) -> str:
 
 def print_header() -> None:
     print()
-    print(f"{BOLD}{CYAN}  MemWal Python SDK — Test Suite{RESET}")
+    print(f"{BOLD}{CYAN}  Walrus Memory Python SDK — Test Suite{RESET}")
     print(f"  {DIM}Server: {SERVER_URL}{RESET}")
     print(f"  {DIM}Auth:   {'✓ credentials set' if HAS_KEY else '✗ no key (integration tests skipped)'}{RESET}")
     print()
@@ -192,7 +192,7 @@ def main() -> None:
     print(f"  {'─' * 78}")
 
     if not HAS_KEY:
-        print(f"\n  {YELLOW}Integration tests skipped — set MEMWAL_KEY + MEMWAL_ACCOUNT_ID to run them{RESET}")
+        print(f"\n  {YELLOW}Integration tests skipped — set MEMWAL_PRIVATE_KEY + MEMWAL_ACCOUNT_ID to run them{RESET}")
         print_totals(total_passed, total_failed, all_failures)
         return
 

{memwal-0.1.1.dev0 → memwal-0.1.2}/tests/test_client.py

@@ -17,7 +17,7 @@ import pytest
 import respx
 
 from memwal.client import MemWal, MemWalCompatibilityError, MemWalError
-from memwal.types import RecallManualOptions, RememberManualOptions
+from memwal.types import RecallManualOptions, RememberManualOptions, ScoringWeights
 from memwal.utils import build_signature_message, bytes_to_hex, sha256_hex
 
 # ============================================================
@@ -95,7 +95,7 @@ def decode_seal_session_header(request: httpx.Request) -> dict[str, Any]:
 
 @pytest.fixture
 def memwal_client() -> MemWal:
-    """Create a MemWal client with a test key."""
+    """Create a Walrus Memory client with a test key."""
     return MemWal.create(
         key=_TEST_KEY_HEX,
         account_id=_TEST_ACCOUNT_ID,
@@ -290,6 +290,31 @@ class TestRecall:
         assert "x-seal-session" in headers
         assert "x-delegate-key" not in headers
 
+    @respx.mock
+    async def test_max_distance_filters_results(self, memwal_client: MemWal) -> None:
+        """recall() should filter weak matches when max_distance is provided."""
+        mock_seal_session_prereqs()
+        route = respx.post(f"{_TEST_SERVER}/api/recall").mock(
+            return_value=httpx.Response(
+                200,
+                json={
+                    "results": [
+                        {"blob_id": "b1", "text": "I love coffee", "distance": 0.2},
+                        {"blob_id": "b2", "text": "I live in Tokyo", "distance": 0.7},
+                    ],
+                    "total": 2,
+                },
+            )
+        )
+
+        result = await memwal_client.recall("coffee", limit=10, max_distance=0.7)
+
+        body = json.loads(route.calls[0].request.content)
+        assert body["limit"] == 10
+        assert len(result.results) == 1
+        assert result.total == 1
+        assert result.results[0].blob_id == "b1"
+
     @respx.mock
     async def test_get_signed_request_uses_empty_body_hash_and_no_wire_body(
         self, memwal_client: MemWal
@@ -302,7 +327,11 @@ class TestRecall:
             )
         )
 
-        result = await memwal_client.wait_for_remember_job("job-1", poll_interval_ms=0, timeout_ms=100)
+        result = await memwal_client.wait_for_remember_job(
+            "job-1",
+            poll_interval_ms=0,
+            timeout_ms=100,
+        )
 
         request = route.calls[0].request
         assert request.content == b""
@@ -341,6 +370,22 @@ class TestErrorHandling:
         with pytest.raises(MemWalError, match="401"):
             await memwal_client.remember("test")
 
+    @respx.mock
+    async def test_empty_401_uses_workshop_friendly_message(
+        self, memwal_client: MemWal
+    ) -> None:
+        """Empty-body auth failures should still give actionable guidance."""
+        mock_seal_session_prereqs()
+        respx.post(f"{_TEST_SERVER}/api/recall").mock(
+            return_value=httpx.Response(401, text="")
+        )
+
+        with pytest.raises(
+            MemWalError,
+            match="wrong private key.*account ID mismatch.*staging/mainnet mismatch",
+        ):
+            await memwal_client.recall("test")
+
     @respx.mock
     async def test_500_raises_memwal_error(self, memwal_client: MemWal) -> None:
         """Server errors should raise MemWalError."""
@@ -542,6 +587,33 @@ class TestManualAPI:
         assert len(result.results) == 1
         assert result.results[0].blob_id == "b1"
 
+    @respx.mock
+    async def test_recall_manual_forwards_scoring_weights(self, memwal_client: MemWal) -> None:
+        _mock_version()
+        route = respx.post(f"{_TEST_SERVER}/api/recall/manual").mock(
+            return_value=httpx.Response(200, json={"results": [], "total": 0})
+        )
+
+        opts = RecallManualOptions(
+            vector=[0.1, 0.2, 0.3],
+            limit=5,
+            scoring_weights=ScoringWeights(
+                semantic=1.0,
+                recency=0.5,
+                recency_half_life_days=7.0,
+                importance=2.0,
+            ),
+        )
+        await memwal_client.recall_manual(opts)
+
+        body = json.loads(route.calls[0].request.content)
+        assert body["scoring_weights"] == {
+            "semantic": 1.0,
+            "recency": 0.5,
+            "recency_half_life_days": 7.0,
+            "importance": 2.0,
+        }
+
 
 class TestPublicKey:
     async def test_get_public_key_hex(self, memwal_client: MemWal) -> None:

{memwal-0.1.1.dev0 → memwal-0.1.2}/tests/test_integration.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """
-Integration tests for the MemWal Python SDK against a live server.
+Integration tests for the Walrus Memory Python SDK against a live server.
 
 Targets MEMWAL_SERVER_URL (default: https://relayer.dev.memwal.ai).
 
@@ -12,7 +12,7 @@ No-auth tests (always run, no env vars needed):
   - Future timestamp → 401
   - Unregistered key → SDK raises MemWalError
 
-Authenticated tests (require MEMWAL_KEY + MEMWAL_ACCOUNT_ID):
+Authenticated tests (require MEMWAL_PRIVATE_KEY + MEMWAL_ACCOUNT_ID):
   - remember() acceptance
   - remember_and_wait()
   - recall()
@@ -26,10 +26,10 @@ Usage:
   python -m pytest tests/test_integration.py -v -m "not requires_key"
 
   # Run full suite with real credentials
-  MEMWAL_KEY=<hex> MEMWAL_ACCOUNT_ID=0x... python -m pytest tests/test_integration.py -v
+  MEMWAL_PRIVATE_KEY=<hex> MEMWAL_ACCOUNT_ID=0x... python -m pytest tests/test_integration.py -v
 
   # Run against dev server using env vars
-  export MEMWAL_KEY="944aa24c09d8b6d6cc6a8fbedc6dc0942a46e49db7d36596e1b6af6061ec9261"
+  export MEMWAL_PRIVATE_KEY="944aa24c09d8b6d6cc6a8fbedc6dc0942a46e49db7d36596e1b6af6061ec9261"
   export MEMWAL_ACCOUNT_ID="0x70f9a6ff2df0ef6a9ecbfdc3f44c27c289ec3eb0cab5e10a5c07ca6165528565"
   export MEMWAL_SERVER_URL="https://relayer.dev.memwal.ai"
   python -m pytest tests/test_integration.py -v
@@ -53,14 +53,14 @@ from memwal.utils import build_signature_message, bytes_to_hex
 # ── Config ───────────────────────────────────────────────────────────────────
 
 SERVER_URL = os.environ.get("MEMWAL_SERVER_URL", "https://relayer.dev.memwal.ai")
-PRIVATE_KEY_HEX = os.environ.get("MEMWAL_KEY", "")
+PRIVATE_KEY_HEX = os.environ.get("MEMWAL_PRIVATE_KEY", "")
 ACCOUNT_ID = os.environ.get("MEMWAL_ACCOUNT_ID", "")
 
 HAS_KEY = bool(PRIVATE_KEY_HEX and ACCOUNT_ID)
 
 requires_key = pytest.mark.skipif(
     not HAS_KEY,
-    reason="MEMWAL_KEY and MEMWAL_ACCOUNT_ID not set",
+    reason="MEMWAL_PRIVATE_KEY and MEMWAL_ACCOUNT_ID not set",
 )
 
 # ── Helpers ───────────────────────────────────────────────────────────────────

{memwal-0.1.1.dev0 → memwal-0.1.2}/tests/test_middleware.py

@@ -9,7 +9,7 @@ Covers:
   - _format_memories: output format
   - _inject_openai_memory: insertion position
 
-No actual LLM or MemWal server calls are made — all network traffic is mocked
+No actual LLM or Walrus Memory server calls are made — all network traffic is mocked
 with ``respx`` and all LLM responses are mocked with ``unittest.mock``.
 """
 

memwal-0.1.1.dev0/examples/.env.example

@@ -1,8 +0,0 @@
-# Local server (default) or remote relayer
-MEMWAL_SERVER_URL=http://localhost:3001
-# Ed25519 delegate private key (64-hex). Get from MemWal dashboard.
-MEMWAL_KEY=21b423e72282dcc47805de48ef9130331b642667b7b2a5cd621767928205e360
-# MemWalAccount object ID on Sui (the wallet's account)
-MEMWAL_ACCOUNT_ID=0x8a1121b8f95d79e68bd07efaf71689ce6fd832b369cdb1b2a943ec7beb822392
-# Namespace for these test memories
-MEMWAL_NAMESPACE=python-sdk-example