vaultzero 0.1.4__tar.gz → 0.1.6__tar.gz

{vaultzero-0.1.4 → vaultzero-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: vaultzero
-Version: 0.1.4
+Version: 0.1.6
 Summary: MCP server for a privacy-first agent memory vault: memories are encrypted on the client before they reach the server.
 Project-URL: Homepage, https://vaultzero.cc
 Project-URL: Documentation, https://github.com/xo0ps/VaultZero-Client#readme

{vaultzero-0.1.4 → vaultzero-0.1.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "vaultzero"
-version = "0.1.4"
+version = "0.1.6"
 # This string is what MCP directories show next to the listing, so it names the thing a
 # prospective user is looking for (an MCP server) before the architecture behind it.
 description = "MCP server for a privacy-first agent memory vault: memories are encrypted on the client before they reach the server."

{vaultzero-0.1.4 → vaultzero-0.1.6}/vaultzero/client/mcp_server.py

@@ -65,8 +65,41 @@ def create_mcp_server(
     default_retention = choices[0]
     mcp = FastMCP(name)
 
+    # The permitted scopes and retention choices are known here, so they go in the
+    # description literally. Saying "the scopes this server was configured with" and
+    # pointing at a list that does not exist left the agent to guess and learn from an
+    # error; naming them costs a few tokens and removes a round trip.
+    scope_list = ", ".join(sorted(permitted))
+    retention_list = ", ".join(choices)
+
     @mcp.tool(
         title="Remember a fact",
+        description=(
+            "Store one durable fact in encrypted long-term memory, readable later by "
+            "recall_context.\n\n"
+            "Use this when the user states something worth keeping across sessions: a "
+            "preference, a decision, an identifier, a recurring constraint. Do NOT use it "
+            "for conversation that only matters in this session, for secrets or "
+            "credentials, or to restate something already stored — storing the same fact "
+            "twice creates two memories that both surface on recall.\n\n"
+            "The write is only reversible by a client holding the same key store, so the "
+            "fact cannot be read back from another machine or a hosted instance. A stored "
+            "fact can be deleted before it expires, but only by that same holder.\n\n"
+            "Args:\n"
+            "    fact_text: The fact to persist, as a self-contained sentence that still "
+            "makes sense alone: \"prefers oat milk in coffee\", not \"that one\". "
+            "Shorter text embeds more precisely and recalls better.\n"
+            f"    scope: One of: {scope_list}. A partition label deciding who and what can "
+            "read the fact back, so recall must ask for the same one. Any other label "
+            "stores nothing and returns an error.\n"
+            f"    retention: One of: {retention_list} (default {default_retention}). How "
+            "long the fact stays retrievable before the server expires and purges it. "
+            "Expiry is irreversible.\n\n"
+            "Returns the new memory id, or \"error: ...\" with nothing stored when the "
+            "scope or retention is rejected. An unusable credential, an unreachable API "
+            "or a rejected envelope all follow the same rule: an error and no partial "
+            "write."
+        ),
         annotations=ToolAnnotations(
             title="Remember a fact",
             # Writes durable state that survives this session. Not read-only, and two
@@ -78,37 +111,11 @@ def create_mcp_server(
         ),
     )
     async def remember_fact(fact_text: str, scope: str, retention: str = default_retention) -> str:
-        """Store one durable fact in encrypted long-term memory, so a later call to
-        recall_context can retrieve it by meaning.
-
-        Use this when the user states something worth keeping across sessions: a
-        preference, a decision, an identifier, a recurring constraint. Do NOT use it for
-        conversation that only matters in this session, for secrets or credentials, or to
-        restate something already stored — storing the same fact twice creates two
-        memories that both surface on recall.
+        """Store one durable fact in encrypted long-term memory, readable later by
+        recall_context.
 
-        Counterpart: recall_context (the read side). Every fact written here is only
-        readable by a client holding the same key store; it cannot be read back from a
-        different machine or a hosted instance.
-
-        Args:
-            fact_text: The fact to persist, as a self-contained sentence. Write it so it
-                still makes sense with no surrounding conversation, e.g. "prefers oat
-                milk in coffee" rather than "that one". Shorter text embeds more
-                precisely and recalls better.
-            scope: A partition label, chosen from the scopes this server was configured
-                with (see below). It restricts who and what can read the fact back, and
-                recall must ask for the same scope. If the label is not permitted, nothing
-                is stored and an error naming the allowed values is returned.
-            retention: One of the retention_choices configured for this server. Sets how
-                long the fact stays retrievable before it expires and is purged; expiry is
-                enforced by the server and cannot be undone. The default is the first
-                choice.
-
-        Returns the new memory id on success, or "error: ..." and stores nothing when the
-        scope or retention is not permitted. Failure modes: an unusable credential, an
-        unreachable API, or a rejected envelope all return an error with nothing stored —
-        there is no partial write.
+        The wire description is passed to @mcp.tool above, where the permitted scopes and
+        retention choices are interpolated. This docstring is the developer-facing summary.
         """
         if scope not in permitted:
             return f"error: scope is not permitted (allowed: {', '.join(sorted(permitted))})"
@@ -139,21 +146,16 @@ def create_mcp_server(
     )
     async def recall_context(query: str, scopes: list[str], limit: int = 5) -> str:
         """Retrieve facts previously written by remember_fact, ranked by similarity to
-        the query, and decrypt them for this call.
+        the query and decrypted for this call.
 
         Use this before answering a question that may depend on something the user told
         you earlier — preferences, past decisions, standing constraints. Do NOT use it to
         browse or audit everything stored: it ranks by relevance to one query and returns
         at most `limit` items, so it is a lookup, not a listing.
 
-        This is the read counterpart to remember_fact. Results are ranked nearest-first
-        and may be empty; "no memories found" is a successful answer, not an error.
-
-        Requires the key store that wrote the memories. If a matching key is not present,
-        the call returns "decryption key not found in the trusted key store" — that is
-        expected on a different machine, a hosted instance, or a fresh process without
-        VZ_KEY_STORE_PATH, and the memories are unreadable there by design rather than by
-        failure.
+        An empty result is a successful answer, not an error. Without the key store that
+        wrote the memories this returns "decryption key not found" — expected on another
+        machine or a hosted instance.
 
         Args:
             query: Natural-language description of what you are looking for. It is matched
@@ -191,9 +193,9 @@ def create_mcp_server(
             lines.append("</memory>")
         return "\n".join(lines)
 
-    # FastMCP ships __doc__ verbatim, indentation and all. Rewrite both descriptions with
-    # the dedented form so the schema a client reads is clean and costs fewer tokens.
-    mcp._tool_manager.get_tool("remember_fact").description = _doc(remember_fact)
+    # recall_context's description comes from its docstring, which FastMCP ships verbatim,
+    # indentation and all. Dedent it. remember_fact is not touched: its description was
+    # passed explicitly above, with the scope and retention values interpolated.
     mcp._tool_manager.get_tool("recall_context").description = _doc(recall_context)
 
     return mcp