{
  "schema_version": 1,
  "server_id": "mnemoverse-mcp-memory-server",
  "package": "@mnemoverse/mcp-memory-server",
  "version": "0.18.1",
  "collected_at": "2026-11-16T22:44:12.723Z",
  "analyzed_at": "2026-11-16T22:44:12.723Z",
  "modelara_version": "v0.1.8",
  "fingerprint": "sha256:9b3522859fa37d1b5a5a67ec4f798e6f72d46e4d36cd83634520cb08123b1eb9",
  "tool_count": 11,
  "interface": {
    "format": "modelara.inspect/v0",
    "capability_set": {
      "source": {
        "type": "mcp",
        "name": "mnemoverse-memory",
        "version": "0.18.1",
        "protocol_version": "2025-11-25"
      },
      "discovered_at": "2026-11-16T22:44:12.394628877Z",
      "capabilities": [
        {
          "id": "mcp:mnemoverse-memory/memory_create_room",
          "name": "memory_create_room",
          "title": "Create shared room",
          "description": "Create a SHARED memory room — a space OTHER people's assistants can read, and write too when their membership scope is read_write, across the AI tools members connect to Mnemoverse. Members can access the room's existing history, including memories saved before they joined; joining does not expose their private account memory. Use when the user wants to share context or collaborate with someone else (e.g. 'make a room for me and my teammate'). Returns the room's address; pass that address as the `domain` on memory_write/memory_read to use it, and on memory_list_recent to catch up on what others added. People join through an invite minted with memory_invite_to_room.",
          "source": {
            "type": "mcp",
            "server": "mnemoverse-memory",
            "operation": "memory_create_room"
          },
          "input_schema": {
            "properties": {
              "description": {
                "description": "Optional description of the room.",
                "maxLength": 2000,
                "type": "string"
              },
              "name": {
                "description": "Room name, unique within your account (e.g. 'launch-team').",
                "maxLength": 200,
                "minLength": 1,
                "type": "string"
              }
            },
            "required": [
              "name"
            ],
            "type": "object"
          },
          "output_schema": {
            "additionalProperties": false,
            "properties": {
              "address": {
                "description": "Domain address (xroom:<id>); pass as `domain` on read/write.",
                "type": "string"
              },
              "name": {
                "description": "The room name as stored.",
                "type": "string"
              },
              "room_id": {
                "description": "The room's id (room_...); pass to memory_invite_to_room.",
                "type": "string"
              }
            },
            "required": [
              "room_id",
              "address"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "false",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "false"
          },
          "effects": {
            "kind": "write",
            "destructive": "false",
            "external": "false"
          },
          "safety": {
            "idempotent": "false",
            "retry_safe": "false"
          },
          "effect_assessment": {
            "kind": "write",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:679348585351b6aa9b79a5add209b3031bf086ca179734e3aedd5c52149757cf"
        },
        {
          "id": "mcp:mnemoverse-memory/memory_feedback",
          "name": "memory_feedback",
          "title": "Rate Memory Helpfulness",
          "description": "Rate memories returned by memory_read to help improve future retrieval ranking. Pass their IDs as memory_ids and an outcome from -1 (unhelpful) to 1 (helpful). Records feedback and updates ranking signals: positive feedback raises a memory's ranking; negative feedback lowers it so other memories out-rank it — nothing is erased. Saved text is not changed or deleted. For memories read from a shared room, pass that room's address as domain; your own memories need no domain. A read-only room member cannot rate the room's memories.",
          "source": {
            "type": "mcp",
            "server": "mnemoverse-memory",
            "operation": "memory_feedback"
          },
          "input_schema": {
            "properties": {
              "domain": {
                "description": "Only for memories read from a shared room: that room's address (xroom:...), exactly as you read it. Omit it for your own memories, which are rated by id alone.",
                "type": "string"
              },
              "memory_ids": {
                "description": "IDs of the memories to rate, the `id:` line of each memory_read result.",
                "items": {
                  "type": "string"
                },
                "minItems": 1,
                "type": "array"
              },
              "outcome": {
                "description": "How helpful was this? 1.0 = very helpful, 0 = neutral, -1.0 = harmful/wrong",
                "maximum": 1,
                "minimum": -1,
                "type": "number"
              }
            },
            "required": [
              "memory_ids",
              "outcome"
            ],
            "type": "object"
          },
          "output_schema": {
            "additionalProperties": false,
            "properties": {
              "avg_valence": {
                "description": "Average valence of the rated memories after the update. Reported as 0 in an asynchronous acknowledgement, where the real value is computed later — a 0 here is therefore not evidence of a neutral outcome.",
                "type": "number"
              },
              "coactivation_edges": {
                "description": "Number of links between query concepts and result concepts that this rating changed. This server does not send query_concepts, so live calls through this tool report 0; asynchronous acknowledgements also report 0.",
                "maximum": 9007199254740991,
                "minimum": 0,
                "type": "integer"
              },
              "updated_count": {
                "description": "How many memories the service reports it applied the rating to. Processed synchronously this is the real count of memories that existed and were updated; processed asynchronously it is a best-effort ACCEPTED-count estimate — the number of IDs submitted — and the authoritative number is not known until the background worker runs. Zero means no submitted ID matched in the service's resolved request scope.",
                "maximum": 9007199254740991,
                "minimum": 0,
                "type": "integer"
              }
            },
            "required": [
              "updated_count"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "false",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "false"
          },
          "effects": {
            "kind": "write",
            "destructive": "false",
            "external": "false"
          },
          "safety": {
            "idempotent": "false",
            "retry_safe": "false"
          },
          "effect_assessment": {
            "kind": "write",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:50616009afbb65275a2955c2b34328ca586fb6e36341e2e986bbc96c8148203a"
        },
        {
          "id": "mcp:mnemoverse-memory/memory_graph",
          "name": "memory_graph",
          "title": "Association graph",
          "description": "Reads the association edges around given concepts: which concepts the memory has linked together, with each link's weight, outcome valence and co-activation count. Use to inspect what a memory store has learned or to explain why a read expanded to a concept. Reads your own graph, or a shared room's when its address is passed as domain; any other domain value has no effect. At depth 2 or 3 the engine drops edges below weight 0.05 unless min_weight is set. Read-only.",
          "source": {
            "type": "mcp",
            "server": "mnemoverse-memory",
            "operation": "memory_graph"
          },
          "input_schema": {
            "properties": {
              "depth": {
                "description": "Hops to expand from the seeds (1-3, default 1). At depth 2 or 3, if min_weight is omitted the engine floors edge weight at 0.05 at EVERY hop — including the first — so a hub concept cannot fan out across the whole store before limit applies; pass min_weight explicitly (0 included) to see every edge anyway.",
                "maximum": 3,
                "minimum": 1,
                "type": "integer"
              },
              "domain": {
                "description": "Read a shared room's graph instead of your own: pass that room's address (e.g. 'xroom:room_01ABC'). Find room addresses with memory_list_rooms. Unlike memory_read, any OTHER value has no effect here — the association store has no domain column, so a plain domain name behaves exactly like omitting this field.",
                "type": "string"
              },
              "limit": {
                "description": "Max edges to return (1-500, default 100 — mirrors memory_read's top_k bounds).",
                "maximum": 500,
                "minimum": 1,
                "type": "integer"
              },
              "min_weight": {
                "description": "Only include edges at or above this weight (≥ 0). Omit for no floor at depth 1; at depth 2/3 the engine applies its own 0.05 floor when this is omitted (see depth) — pass 0 to see every edge at every depth.",
                "minimum": 0,
                "type": "number"
              },
              "seeds": {
                "description": "Concepts to center the graph on (1-20, each ≤200 chars, non-blank) — e.g. ['deploy', 'staging']. An unrecognised concept simply contributes no edges; it is not an error.",
                "items": {
                  "type": "string"
                },
                "maxItems": 20,
                "minItems": 1,
                "type": "array"
              }
            },
            "required": [
              "seeds"
            ],
            "type": "object"
          },
          "output_schema": {
            "additionalProperties": false,
            "properties": {
              "edges": {
                "description": "Association edges found within the requested depth.",
                "items": {
                  "additionalProperties": false,
                  "properties": {
                    "count": {
                      "description": "Co-activation count.",
                      "maximum": 9007199254740991,
                      "minimum": -9007199254740991,
                      "type": "integer"
                    },
                    "source": {
                      "description": "One side of the edge (storage order, not learn order).",
                      "type": "string"
                    },
                    "target": {
                      "description": "The other side of the edge (storage order, not learn order).",
                      "type": "string"
                    },
                    "updated_at": {
                      "description": "UTC instant this edge was last reinforced.",
                      "type": "string"
                    },
                    "valence": {
                      "description": "Outcome polarity, -1 to 1.",
                      "type": "number"
                    },
                    "weight": {
                      "description": "Co-activation strength, 0 and up.",
                      "type": "number"
                    }
                  },
                  "required": [
                    "source",
                    "target",
                    "weight",
                    "valence",
                    "count",
                    "updated_at"
                  ],
                  "type": "object"
                },
                "type": "array"
              },
              "min_weight_applied": {
                "description": "The weight floor actually used at every hop: your min_weight when you set one (0 included); otherwise 0.05 from depth 2, or 0 at depth 1.",
                "type": "number"
              },
              "nodes": {
                "description": "Concepts touched by edges below. A seed with no surviving edge (unrecognised concept, or every edge fell below the weight floor) is not listed.",
                "items": {
                  "additionalProperties": false,
                  "properties": {
                    "concept": {
                      "description": "The concept name.",
                      "type": "string"
                    },
                    "degree": {
                      "description": "Edges in THIS response touching this concept — not its total degree across the whole store, which limit/truncated may cut short.",
                      "maximum": 9007199254740991,
                      "minimum": -9007199254740991,
                      "type": "integer"
                    }
                  },
                  "required": [
                    "concept",
                    "degree"
                  ],
                  "type": "object"
                },
                "type": "array"
              },
              "truncated": {
                "description": "True when a per-hop server cap or limit cut the walk short — the store may hold more edges than are reported here.",
                "type": "boolean"
              }
            },
            "required": [
              "nodes",
              "edges",
              "truncated",
              "min_weight_applied"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "false",
            "idempotent": "true",
            "open_world": "false"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "false"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:7a859b7155d2d56a5d7b1150343b7dbc4fae23b49fc43a1c8673e920123d0876"
        },
        {
          "id": "mcp:mnemoverse-memory/memory_invite_to_room",
          "name": "memory_invite_to_room",
          "title": "Invite to room",
          "description": "Mint an invite for a room you own and get a ready-to-forward message. An invite is single-use by default; pass max_uses to let several people join with the same one. The user sends that message to the person they want to add (any messenger); the recipient opens the link or tells THEIR assistant the code to join. Use when the user asks to invite someone to a room they own, including one just created with memory_create_room.",
          "source": {
            "type": "mcp",
            "server": "mnemoverse-memory",
            "operation": "memory_invite_to_room"
          },
          "input_schema": {
            "properties": {
              "expires_in_days": {
                "description": "Days until the invite expires (default 7).",
                "maximum": 90,
                "minimum": 1,
                "type": "integer"
              },
              "max_uses": {
                "description": "How many people may join with this invite (default 1, single-use).",
                "maximum": 1000,
                "minimum": 1,
                "type": "integer"
              },
              "room_id": {
                "description": "The room's id (room_...), from memory_create_room.",
                "maxLength": 100,
                "minLength": 1,
                "type": "string"
              },
              "scope": {
                "description": "Role the invitee gets — 'read' or 'read_write' (default read_write).",
                "enum": [
                  "read",
                  "read_write"
                ],
                "type": "string"
              }
            },
            "required": [
              "room_id"
            ],
            "type": "object"
          },
          "output_schema": {
            "additionalProperties": false,
            "properties": {
              "code": {
                "description": "The invite code (mnvr_...). Single-use by default, with a configurable use limit. Shown once.",
                "type": "string"
              },
              "expires_at": {
                "description": "ISO 8601 expiry, or null.",
                "type": [
                  "string",
                  "null"
                ]
              },
              "join_url": {
                "description": "Landing URL the invitee can open to join.",
                "type": "string"
              },
              "room_address": {
                "description": "The room's domain address (xroom:<id>).",
                "type": "string"
              },
              "scope": {
                "description": "Role the invitee will get.",
                "type": "string"
              },
              "share_message": {
                "description": "Ready-to-forward invite text.",
                "type": "string"
              }
            },
            "required": [
              "share_message"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "false",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "false"
          },
          "effects": {
            "kind": "write",
            "destructive": "false",
            "external": "false"
          },
          "safety": {
            "idempotent": "false",
            "retry_safe": "false"
          },
          "effect_assessment": {
            "kind": "write",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:a79f3b75d7c758e452de696405dd73945d0ade61aa15aef89c9aad64851e211c"
        },
        {
          "id": "mcp:mnemoverse-memory/memory_join_room",
          "name": "memory_join_room",
          "title": "Join room",
          "description": "Join a shared memory room using an invite code (starts with 'mnvr_'). Use when the user pastes an invite code or says something like 'join room with code ...'. The result gives the room's address, which is the `domain` for reading the shared room with memory_read, and tells you what you may do with it: memory_write to that address is only allowed when your membership scope is read_write; a read-only membership has that write refused; and when the server does not report a scope, whether memory_write would succeed is stated as unknown rather than promised either way.",
          "source": {
            "type": "mcp",
            "server": "mnemoverse-memory",
            "operation": "memory_join_room"
          },
          "input_schema": {
            "properties": {
              "code": {
                "description": "The invite code (mnvr_...).",
                "maxLength": 200,
                "minLength": 1,
                "type": "string"
              }
            },
            "required": [
              "code"
            ],
            "type": "object"
          },
          "output_schema": {
            "additionalProperties": false,
            "properties": {
              "address": {
                "description": "Domain address (xroom:<id>); pass as `domain` on read/write.",
                "type": "string"
              },
              "already_member": {
                "description": "True if you were already a member (no-op join).",
                "type": "boolean"
              },
              "name": {
                "description": "The room name.",
                "type": "string"
              },
              "next_steps": {
                "description": "How to use the room now.",
                "type": "string"
              },
              "room_id": {
                "description": "The room's id (room_...).",
                "type": "string"
              },
              "scope": {
                "description": "Your role in the room ('read' | 'read_write').",
                "type": "string"
              }
            },
            "required": [
              "room_id",
              "address",
              "next_steps"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "false",
            "destructive": "false",
            "idempotent": "true",
            "open_world": "false"
          },
          "effects": {
            "kind": "write",
            "destructive": "false",
            "external": "false"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "write",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:20af6070ada609fd7222c9303a71ebe11fa488568de375100a1c393cdcf76730"
        },
        {
          "id": "mcp:mnemoverse-memory/memory_list_recent",
          "name": "memory_list_recent",
          "title": "List Recent Memories",
          "description": "List the NEWEST memories first — no search query needed. Semantic search answers 'what do I know about X'; this answers 'what happened lately': resuming work after a break, catching up on a shared room ('any new messages?'), or reviewing what was saved recently. Pass `since` (your last-seen time) to get only what's new, and page through older entries with the returned cursor. Complete by construction WITHIN ONE SCOPE — nothing is skipped there, unlike a semantic search. A page is also bounded by SIZE, so a page of long entries comes back shorter than `limit` and hands you a cursor for the rest — nothing is dropped, and following the cursor is how you get it. To catch up on a shared room you MUST pass its address as `domain`: rooms are separate stores and an unscoped call never covers them, though it names the ones you have (`rooms_not_searched`).",
          "source": {
            "type": "mcp",
            "server": "mnemoverse-memory",
            "operation": "memory_list_recent"
          },
          "input_schema": {
            "properties": {
              "cursor": {
                "description": "Opaque cursor from a previous page's 'More older entries exist' line — continues the listing without skips or duplicates.",
                "maxLength": 512,
                "type": "string"
              },
              "domain": {
                "description": "Restrict to one domain. REQUIRED to read a shared room — pass its address ('xroom:room_01ABC'), because rooms are separate stores that an unscoped feed does NOT cover. Omit only when you mean your own domains. Room addresses come from memory_list_rooms. Room entries are often long — a room feed usually reaches its size budget after a handful of them, so expect to page (see `limit`).",
                "type": "string"
              },
              "exclude_author": {
                "description": "Drop entries written by this author PRINCIPAL. ⚠️ NOT USABLE FROM HERE YET — the principal is never shown in these results, so there is no value you can get through this tool; a guess like 'me' filters nothing, silently. Same caveat as on memory_read.",
                "maxLength": 200,
                "type": "string"
              },
              "limit": {
                "description": "Most entries per page (default: 20). Newest first. ⚠️ A CEILING, not a promise: the page is ALSO bounded by size, so a page of long entries stops early and returns a cursor for the rest. In rooms whose entries run long, ask for 5–10 — a large `limit` there buys nothing the size budget will not take back, and costs round trips.",
                "maximum": 100,
                "minimum": 1,
                "type": "integer"
              },
              "since": {
                "description": "Only entries created at/after this ISO-8601 instant (naive = UTC) — your novelty watermark.",
                "type": "string"
              },
              "until": {
                "description": "Only entries created at/before this ISO-8601 instant (inclusive). Pair with `since` to read a closed window — 'what happened on Monday' — instead of paging back from now.",
                "type": "string"
              }
            },
            "type": "object"
          },
          "output_schema": {
            "additionalProperties": false,
            "properties": {
              "items": {
                "description": "Entries newest-first (creation time descending).",
                "items": {
                  "additionalProperties": false,
                  "properties": {
                    "author": {
                      "description": "Sanitized AGENT identity of the writer (never the human principal) — attribution in shared rooms.",
                      "type": "string"
                    },
                    "content": {
                      "description": "Stored memory content.",
                      "type": "string"
                    },
                    "created_at": {
                      "description": "UTC creation instant, ISO-8601; absent on legacy memories without a timestamp.",
                      "type": "string"
                    },
                    "domain": {
                      "description": "User-defined memory namespace or domain.",
                      "type": "string"
                    },
                    "memory_id": {
                      "description": "Identifier needed to rate or manage this saved memory.",
                      "type": "string"
                    }
                  },
                  "required": [
                    "memory_id",
                    "content",
                    "domain"
                  ],
                  "type": "object"
                },
                "type": "array"
              },
              "next_cursor": {
                "description": "Pass back as cursor for the next (older) page; null = listing complete. Absent when the service sent a continuation token this client will not pass on; the text then says the token could not be displayed.",
                "type": [
                  "string",
                  "null"
                ]
              },
              "rooms_not_searched": {
                "additionalProperties": false,
                "description": "Present only on a call WITHOUT `domain`, when you have shared rooms or they could not be checked: rooms are separate stores that call did not search.",
                "properties": {
                  "note": {
                    "description": "The same disclosure the text ends with.",
                    "type": "string"
                  },
                  "rooms": {
                    "description": "The live rooms this call did not search; present only when state is 'live'. A row missing room_id, address or role is omitted here and still named in `note`.",
                    "items": {
                      "additionalProperties": false,
                      "properties": {
                        "address": {
                          "description": "Domain address (xroom:<id>); pass as `domain` on read/write.",
                          "type": "string"
                        },
                        "archived": {
                          "description": "True if archived (owned rooms only).",
                          "type": "boolean"
                        },
                        "name": {
                          "description": "The room name.",
                          "type": "string"
                        },
                        "role": {
                          "description": "'owner' or 'member'.",
                          "type": "string"
                        },
                        "room_id": {
                          "description": "The room's id (room_...).",
                          "type": "string"
                        },
                        "scope": {
                          "description": "'read' or 'read_write'.",
                          "type": "string"
                        }
                      },
                      "required": [
                        "room_id",
                        "address",
                        "role",
                        "archived"
                      ],
                      "type": "object"
                    },
                    "type": "array"
                  },
                  "state": {
                    "description": "'live': the rooms listed can be read by passing an address as `domain`. 'archived-only': every room you have is archived and refuses reads. 'unknown': the room list could not be checked, so whether any room went unsearched is not known.",
                    "enum": [
                      "live",
                      "archived-only",
                      "unknown"
                    ],
                    "type": "string"
                  }
                },
                "required": [
                  "state",
                  "note"
                ],
                "type": "object"
              }
            },
            "required": [
              "items"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "false",
            "idempotent": "true",
            "open_world": "false"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "false"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:5dd9d26da351b440dceb7c9ef3eaf38c1bfe7319bf9ffc4f194f16644aa144a4"
        },
        {
          "id": "mcp:mnemoverse-memory/memory_list_rooms",
          "name": "memory_list_rooms",
          "title": "List rooms",
          "description": "List the shared memory rooms you can use — the ones you OWN plus the ones you've JOINED — each with the address to pass as `domain` on memory_read, and on memory_write too where your membership scope is read_write; a read-only membership has that write refused. Use this to RE-FIND a room in a new session (e.g. 'what rooms do I have?', 'resume the room with my teammate') instead of having to create or re-join it.",
          "source": {
            "type": "mcp",
            "server": "mnemoverse-memory",
            "operation": "memory_list_rooms"
          },
          "input_schema": {
            "properties": {},
            "type": "object"
          },
          "output_schema": {
            "additionalProperties": false,
            "properties": {
              "rooms": {
                "items": {
                  "additionalProperties": false,
                  "properties": {
                    "address": {
                      "description": "Domain address (xroom:<id>); pass as `domain` on read/write.",
                      "type": "string"
                    },
                    "archived": {
                      "description": "True if archived (owned rooms only).",
                      "type": "boolean"
                    },
                    "name": {
                      "description": "The room name.",
                      "type": "string"
                    },
                    "role": {
                      "description": "'owner' or 'member'.",
                      "type": "string"
                    },
                    "room_id": {
                      "description": "The room's id (room_...).",
                      "type": "string"
                    },
                    "scope": {
                      "description": "'read' or 'read_write'.",
                      "type": "string"
                    }
                  },
                  "required": [
                    "room_id",
                    "address",
                    "role",
                    "archived"
                  ],
                  "type": "object"
                },
                "type": "array"
              }
            },
            "required": [
              "rooms"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "false",
            "idempotent": "true",
            "open_world": "false"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "false"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:520b8c4ddd3dce6340041df3ca3202267117e99ae436fd7ca962c6e37d4dd1cc"
        },
        {
          "id": "mcp:mnemoverse-memory/memory_read",
          "name": "memory_read",
          "title": "Search Memories",
          "description": "Search long-term memory for user preferences, past decisions, project setup, people, or earlier context. The memory persists across sessions and across every AI tool the user has connected. It applies when an answer may depend on something from an earlier session or another tool; it is not needed for general world knowledge. Returns matches ranked by relevance (or newest-first with order_by: 'recency'); each result carries an id; after the answer, memory_feedback takes these ids to record which memories helped. A correction is a fresh memory_write. Without supersedes it is stored alongside the earlier memory, which stays as it was, unless it is too close to an existing memory, in which case the write is refused; with supersedes, the earlier memory is marked replaced, is hidden from reads when the account hides replaced memories, and include_history returns it. No MCP deletion tool is exposed; a user can permanently delete an individual personal memory through the REST API or with help from support.",
          "source": {
            "type": "mcp",
            "server": "mnemoverse-memory",
            "operation": "memory_read"
          },
          "input_schema": {
            "properties": {
              "diversity": {
                "description": "0 (default) returns the matches as ranked. Above 0, a match that is a near-copy of one already picked gives its slot to the next distinct memory (maximal marginal relevance); 1 lets similarity alone decide after the first pick. It changes which memories come back, not their scores, and applies only when there are more matches than top_k and top_k is below 200.",
                "maximum": 1,
                "minimum": 0,
                "type": "number"
              },
              "domain": {
                "description": "Restrict the search to one domain namespace (e.g. 'project:acme'). Omitting it searches your OWN domains — it does NOT include shared rooms, which are separate stores: to search a room, pass its address here (e.g. 'xroom:room_01ABC'). Find room addresses with memory_list_rooms, or in `rooms_not_searched`, which an answer without `domain` carries when you have rooms.",
                "type": "string"
              },
              "exclude_author": {
                "description": "Drop memories written by this author PRINCIPAL — the server-side identity. ⚠️ NOT USABLE FROM HERE YET: the principal is not shown in these results, so there is no value you can obtain through this tool, and a guess like 'me' silently matches nothing and filters nothing. Only pass it if your system knows the exact principal from elsewhere (e.g. the REST API).",
                "maxLength": 200,
                "type": "string"
              },
              "include_history": {
                "description": "Also return memories that were replaced by a later write; each one is marked with the id that replaced it. History is returned in the domain where the replaced memory is stored. This makes replaced memories eligible to appear under normal ranking and top_k; it is not a promise of the complete history.",
                "type": "boolean"
              },
              "order_by": {
                "description": "'relevance' (default) = ranking order. 'recency' = the matched set re-sorted newest-first. For a complete newest-first feed with no search at all, use memory_list_recent instead.",
                "enum": [
                  "relevance",
                  "recency"
                ],
                "type": "string"
              },
              "query": {
                "description": "Natural-language description of what you're looking for, e.g. 'database choice for the API' or 'user's preferred testing framework'.",
                "maxLength": 5000,
                "minLength": 1,
                "type": "string"
              },
              "since": {
                "description": "Only memories created at/after this ISO-8601 instant (naive = UTC) — e.g. your last-seen watermark in a shared room.",
                "maxLength": 40,
                "type": "string"
              },
              "top_k": {
                "description": "Requested number of results (default: 5, what this server asks for when you omit it; the engine's own default of 10 never applies, because the field is always sent). ⚠️ Not a hard cap: association expansion can return MORE than this, and the relevance floor can return fewer — raising it does not reliably widen the result set. For a complete, exactly-bounded listing use memory_list_recent instead.",
                "maximum": 500,
                "minimum": 1,
                "type": "integer"
              },
              "until": {
                "description": "Only memories created at/before this ISO-8601 instant.",
                "maxLength": 40,
                "type": "string"
              }
            },
            "required": [
              "query"
            ],
            "type": "object"
          },
          "output_schema": {
            "additionalProperties": false,
            "properties": {
              "items": {
                "description": "Matching memories, ordered per order_by.",
                "items": {
                  "additionalProperties": false,
                  "properties": {
                    "author": {
                      "description": "Sanitized AGENT identity of the writer (never the human principal) — attribution in shared rooms.",
                      "type": "string"
                    },
                    "content": {
                      "description": "Stored memory content.",
                      "type": "string"
                    },
                    "created_at": {
                      "description": "UTC creation instant, ISO-8601; absent on legacy memories without a timestamp.",
                      "type": "string"
                    },
                    "domain": {
                      "description": "User-defined memory namespace or domain.",
                      "type": "string"
                    },
                    "memory_id": {
                      "description": "Identifier needed to rate or manage this saved memory.",
                      "type": "string"
                    },
                    "superseded_by": {
                      "description": "Id of the memory that replaced this one. Present only on a replaced memory, which a read returns when include_history is true or when the account does not hide replaced memories.",
                      "type": "string"
                    }
                  },
                  "required": [
                    "memory_id",
                    "content",
                    "domain"
                  ],
                  "type": "object"
                },
                "type": "array"
              },
              "rooms_not_searched": {
                "additionalProperties": false,
                "description": "Present only on a call WITHOUT `domain`, when you have shared rooms or they could not be checked: rooms are separate stores that call did not search.",
                "properties": {
                  "note": {
                    "description": "The same disclosure the text ends with.",
                    "type": "string"
                  },
                  "rooms": {
                    "description": "The live rooms this call did not search; present only when state is 'live'. A row missing room_id, address or role is omitted here and still named in `note`.",
                    "items": {
                      "additionalProperties": false,
                      "properties": {
                        "address": {
                          "description": "Domain address (xroom:<id>); pass as `domain` on read/write.",
                          "type": "string"
                        },
                        "archived": {
                          "description": "True if archived (owned rooms only).",
                          "type": "boolean"
                        },
                        "name": {
                          "description": "The room name.",
                          "type": "string"
                        },
                        "role": {
                          "description": "'owner' or 'member'.",
                          "type": "string"
                        },
                        "room_id": {
                          "description": "The room's id (room_...).",
                          "type": "string"
                        },
                        "scope": {
                          "description": "'read' or 'read_write'.",
                          "type": "string"
                        }
                      },
                      "required": [
                        "room_id",
                        "address",
                        "role",
                        "archived"
                      ],
                      "type": "object"
                    },
                    "type": "array"
                  },
                  "state": {
                    "description": "'live': the rooms listed can be read by passing an address as `domain`. 'archived-only': every room you have is archived and refuses reads. 'unknown': the room list could not be checked, so whether any room went unsearched is not known.",
                    "enum": [
                      "live",
                      "archived-only",
                      "unknown"
                    ],
                    "type": "string"
                  }
                },
                "required": [
                  "state",
                  "note"
                ],
                "type": "object"
              }
            },
            "required": [
              "items"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "false",
            "idempotent": "true",
            "open_world": "false"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "false"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:ed452deb3a51622bc0adccd40a119f798d255fea705612be1ce083dd02b95411"
        },
        {
          "id": "mcp:mnemoverse-memory/memory_stats",
          "name": "memory_stats",
          "title": "Memory Statistics",
          "description": "Get an overview of the stored memory: total count, the number of learned concept associations, the list of domains, and average quality scores. This memory is shared across all AI tools the user has connected to Mnemoverse. Use it to orient yourself, to confirm the exact domain name before writing to it, or when the user asks what you remember. Read-only — changes nothing.",
          "source": {
            "type": "mcp",
            "server": "mnemoverse-memory",
            "operation": "memory_stats"
          },
          "input_schema": {
            "properties": {},
            "type": "object"
          },
          "output_schema": {
            "additionalProperties": false,
            "properties": {
              "avg_importance": {
                "description": "Average importance of stored memories, on a scale from 0 to 1.",
                "type": "number"
              },
              "avg_valence": {
                "description": "Average valence of stored memories: how well recalls turned out, on a scale from -1 to 1.",
                "type": "number"
              },
              "domains": {
                "description": "User-defined memory domains.",
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              "episodes": {
                "description": "Number of individual memories (not merged into a summary).",
                "maximum": 9007199254740991,
                "minimum": 0,
                "type": "integer"
              },
              "hebbian_edges": {
                "description": "Number of learned concept-to-concept associations; memory_graph reads them.",
                "maximum": 9007199254740991,
                "minimum": 0,
                "type": "integer"
              },
              "memory_count": {
                "description": "Number of saved memories.",
                "maximum": 9007199254740991,
                "minimum": 0,
                "type": "integer"
              },
              "prototypes": {
                "description": "Number of summary memories merged from several individual ones. Consolidation is not running on the hosted service, so this count does not currently grow.",
                "maximum": 9007199254740991,
                "minimum": 0,
                "type": "integer"
              }
            },
            "required": [
              "memory_count",
              "domains"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "false",
            "idempotent": "true",
            "open_world": "false"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "false"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:95dbde3cd5c4b29b736db632cc7af2d599272164fa9fad1a86b4c9841a964582"
        },
        {
          "id": "mcp:mnemoverse-memory/memory_write",
          "name": "memory_write",
          "title": "Store Memory",
          "description": "Store a long-term memory that persists across sessions and across every AI tool the user has connected to Mnemoverse. Suited to durable information: a stated preference, a decision, a fact about people, roles or project setup, a lesson learned; transient chatter that only matters this turn does not belong here. Never store passwords, API keys, payment data, MFA codes, government IDs, or health records. Behavior: outside shared rooms, a novelty gate refuses a write the embedder cannot tell apart from a memory already stored in the same domain, so the result tells you whether the memory was stored or refused. Write `content` as a self-contained statement that still makes sense when recalled out of context. To correct a memory you have checked is outdated, pass its memory_id in supersedes.",
          "source": {
            "type": "mcp",
            "server": "mnemoverse-memory",
            "operation": "memory_write"
          },
          "input_schema": {
            "properties": {
              "concepts": {
                "description": "Key concepts for linking related memories (e.g. ['deploy', 'friday', 'staging'])",
                "items": {
                  "type": "string"
                },
                "maxItems": 256,
                "type": "array"
              },
              "content": {
                "description": "The memory to store as a self-contained statement, e.g. 'User prefers TypeScript strict mode' or 'Decided to deploy the API on Cloudflare Workers (2026-06)'.",
                "maxLength": 10000,
                "minLength": 1,
                "type": "string"
              },
              "domain": {
                "description": "Namespace to organize memories (e.g. 'engineering', 'user:alice', 'project:acme'). Matched byte-for-byte — a leading space, a different case, or an invisible character opens a SEPARATE, permanent store, so reuse an exact name from memory_stats rather than retyping one. To write into a shared room, pass its address here instead (e.g. 'xroom:room_01ABC'). Find room addresses with memory_list_rooms.",
                "maxLength": 100,
                "type": "string"
              },
              "supersedes": {
                "description": "Pass the memory_id values of memories this write corrects or replaces. Use only for memories you have checked are outdated or wrong; the replaced memories stay recoverable with include_history. Not supported in shared rooms (xroom: domains). 1 to 32 distinct ids.",
                "items": {
                  "minLength": 1,
                  "type": "string"
                },
                "maxItems": 32,
                "minItems": 1,
                "type": "array"
              }
            },
            "required": [
              "content"
            ],
            "type": "object"
          },
          "output_schema": {
            "additionalProperties": false,
            "properties": {
              "importance": {
                "description": "Novelty score for this write (0-1): how much it adds over the nearest memories already saved in the same domain. Outside shared rooms, a write that scores below the service's importance threshold is not stored, and `reason` says why when the service sends one. The score is approximate and can read lower for non-English text. It is not a verdict on whether the memory was worth keeping. Absent when the service sent no score.",
                "type": "number"
              },
              "memory_id": {
                "description": "Identifier of the stored memory, or null when it was not stored.",
                "type": [
                  "string",
                  "null"
                ]
              },
              "reason": {
                "description": "The memory service's own explanation of this outcome, quoted as sent — when stored is false this is the ONLY statement of WHY, e.g. \"Below importance threshold (0.047 < 0.1)\". Ordinary text is preserved exactly; only control, bidi, zero-width, and repeated-whitespace characters are normalized before display, and the value is capped at 400 characters. Absent when the service sent no explanation, or when nothing remains after that normalization.",
                "type": "string"
              },
              "stored": {
                "description": "Whether the memory passed the novelty gate and was stored.",
                "type": "boolean"
              },
              "superseded": {
                "description": "The memory_id values this write replaced, in request order. Present only when the write replaced at least one memory.",
                "items": {
                  "type": "string"
                },
                "type": "array"
              }
            },
            "required": [
              "stored",
              "memory_id"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "false",
            "destructive": "false",
            "idempotent": "false",
            "open_world": "false"
          },
          "effects": {
            "kind": "write",
            "destructive": "false",
            "external": "false"
          },
          "safety": {
            "idempotent": "false",
            "retry_safe": "false"
          },
          "effect_assessment": {
            "kind": "write",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:927ca4634bc5eb7cffb98e43dfc1e57bc4f0ad4dede552bb58ce413f5fa6bd2e"
        },
        {
          "id": "mcp:mnemoverse-memory/vault_list",
          "name": "vault_list",
          "title": "List vault secrets",
          "description": "List the secrets stored in your Mnemoverse Vault — by ALIAS and purpose only; the secret VALUE is never returned or shown to you, and no tool on this server returns it. Use this to check WHICH secrets the user has stored and under what alias (e.g. the user says 'do I have a GitHub token saved?'). Only YOUR account's secrets are listed.",
          "source": {
            "type": "mcp",
            "server": "mnemoverse-memory",
            "operation": "vault_list"
          },
          "input_schema": {
            "properties": {},
            "type": "object"
          },
          "output_schema": {
            "additionalProperties": false,
            "properties": {
              "secrets": {
                "items": {
                  "additionalProperties": false,
                  "properties": {
                    "alias": {
                      "description": "The secret's alias — the reference you use, never the value.",
                      "type": "string"
                    },
                    "concepts": {
                      "description": "Concept tags.",
                      "items": {
                        "type": "string"
                      },
                      "type": "array"
                    },
                    "context": {
                      "description": "The secret's purpose/context — never the value.",
                      "type": "string"
                    }
                  },
                  "required": [
                    "alias",
                    "context",
                    "concepts"
                  ],
                  "type": "object"
                },
                "type": "array"
              }
            },
            "required": [
              "secrets"
            ],
            "type": "object"
          },
          "declared": {
            "read_only": "true",
            "destructive": "false",
            "idempotent": "true",
            "open_world": "false"
          },
          "effects": {
            "kind": "read",
            "destructive": "false",
            "external": "false"
          },
          "safety": {
            "idempotent": "true",
            "retry_safe": "true"
          },
          "effect_assessment": {
            "kind": "read",
            "basis": "declared"
          },
          "metadata": {
            "mcp.annotations": "present"
          },
          "fingerprint": "sha256:21dd12d952fb3c6cdff0e6aba7e00cf26f80f3479b74b7850fe2ac052208131a"
        }
      ],
      "discovery_order": [
        "mcp:mnemoverse-memory/memory_write",
        "mcp:mnemoverse-memory/memory_read",
        "mcp:mnemoverse-memory/memory_list_recent",
        "mcp:mnemoverse-memory/memory_feedback",
        "mcp:mnemoverse-memory/memory_stats",
        "mcp:mnemoverse-memory/memory_create_room",
        "mcp:mnemoverse-memory/memory_invite_to_room",
        "mcp:mnemoverse-memory/memory_join_room",
        "mcp:mnemoverse-memory/memory_list_rooms",
        "mcp:mnemoverse-memory/vault_list",
        "mcp:mnemoverse-memory/memory_graph"
      ],
      "fingerprint": "sha256:9b3522859fa37d1b5a5a67ec4f798e6f72d46e4d36cd83634520cb08123b1eb9"
    },
    "summary": {
      "total": 11,
      "read_only": 6,
      "potential_writes": 5,
      "destructive": 0,
      "unknown_effects": 0,
      "retry_safe": 7
    },
    "schema_stats": {
      "mcp:mnemoverse-memory/memory_create_room": {
        "input": {
          "properties": 2,
          "required": 1,
          "total_properties": 2,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 2
        },
        "output": {
          "properties": 3,
          "required": 2,
          "total_properties": 3,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 3
        }
      },
      "mcp:mnemoverse-memory/memory_feedback": {
        "input": {
          "properties": 3,
          "required": 2,
          "total_properties": 3,
          "nested_objects": 0,
          "arrays": 1,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 4
        },
        "output": {
          "properties": 3,
          "required": 1,
          "total_properties": 3,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 3
        }
      },
      "mcp:mnemoverse-memory/memory_graph": {
        "input": {
          "properties": 5,
          "required": 1,
          "total_properties": 5,
          "nested_objects": 0,
          "arrays": 1,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 6
        },
        "output": {
          "properties": 4,
          "required": 4,
          "total_properties": 12,
          "nested_objects": 2,
          "arrays": 2,
          "max_depth": 2,
          "combinators": 0,
          "refs": 0,
          "complexity": 16
        }
      },
      "mcp:mnemoverse-memory/memory_invite_to_room": {
        "input": {
          "properties": 4,
          "required": 1,
          "total_properties": 4,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 4
        },
        "output": {
          "properties": 6,
          "required": 1,
          "total_properties": 6,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 6
        }
      },
      "mcp:mnemoverse-memory/memory_join_room": {
        "input": {
          "properties": 1,
          "required": 1,
          "total_properties": 1,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 1
        },
        "output": {
          "properties": 6,
          "required": 3,
          "total_properties": 6,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 6
        }
      },
      "mcp:mnemoverse-memory/memory_list_recent": {
        "input": {
          "properties": 6,
          "required": 0,
          "total_properties": 6,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 6
        },
        "output": {
          "properties": 3,
          "required": 1,
          "total_properties": 17,
          "nested_objects": 3,
          "arrays": 2,
          "max_depth": 3,
          "combinators": 0,
          "refs": 0,
          "complexity": 22
        }
      },
      "mcp:mnemoverse-memory/memory_list_rooms": {
        "input": {
          "properties": 0,
          "required": 0,
          "total_properties": 0,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 0,
          "combinators": 0,
          "refs": 0,
          "complexity": 0
        },
        "output": {
          "properties": 1,
          "required": 1,
          "total_properties": 7,
          "nested_objects": 1,
          "arrays": 1,
          "max_depth": 2,
          "combinators": 0,
          "refs": 0,
          "complexity": 9
        }
      },
      "mcp:mnemoverse-memory/memory_read": {
        "input": {
          "properties": 9,
          "required": 1,
          "total_properties": 9,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 9
        },
        "output": {
          "properties": 2,
          "required": 1,
          "total_properties": 17,
          "nested_objects": 3,
          "arrays": 2,
          "max_depth": 3,
          "combinators": 0,
          "refs": 0,
          "complexity": 22
        }
      },
      "mcp:mnemoverse-memory/memory_stats": {
        "input": {
          "properties": 0,
          "required": 0,
          "total_properties": 0,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 0,
          "combinators": 0,
          "refs": 0,
          "complexity": 0
        },
        "output": {
          "properties": 7,
          "required": 2,
          "total_properties": 7,
          "nested_objects": 0,
          "arrays": 1,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 8
        }
      },
      "mcp:mnemoverse-memory/memory_write": {
        "input": {
          "properties": 4,
          "required": 1,
          "total_properties": 4,
          "nested_objects": 0,
          "arrays": 2,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 6
        },
        "output": {
          "properties": 5,
          "required": 2,
          "total_properties": 5,
          "nested_objects": 0,
          "arrays": 1,
          "max_depth": 1,
          "combinators": 0,
          "refs": 0,
          "complexity": 6
        }
      },
      "mcp:mnemoverse-memory/vault_list": {
        "input": {
          "properties": 0,
          "required": 0,
          "total_properties": 0,
          "nested_objects": 0,
          "arrays": 0,
          "max_depth": 0,
          "combinators": 0,
          "refs": 0,
          "complexity": 0
        },
        "output": {
          "properties": 1,
          "required": 1,
          "total_properties": 4,
          "nested_objects": 1,
          "arrays": 2,
          "max_depth": 2,
          "combinators": 0,
          "refs": 0,
          "complexity": 7
        }
      }
    }
  },
  "source": {
    "registry": "npm",
    "package": "@mnemoverse/mcp-memory-server",
    "version": "0.18.1",
    "published_at": "2026-11-13T23:33:35.723Z",
    "integrity": "sha512-lzJ8lhpCQIT7tdjUHkqp+osEwASnUyIsu+/1DHJJu9+7PS7eE7ZsfRKtdNZh9FFarPIz0o5mFT/IsWCFCZfhYQ==",
    "repository": "https://github.com/mnemoverse/mcp-memory-server"
  },
  "analyzer": {
    "name": "modelara",
    "version": "v0.1.8",
    "policy_version": null
  },
  "capability_hash_version": 2,
  "capability_hashes": {
    "mnemoverse-mcp-memory-server:tool:memory_create_room": {
      "description": "sha256:db4689643331b78128079cbc467fe42c5bba7a15c316ffe35d5e27f87d36d07b",
      "input_schema": "sha256:25c5aeed4c49844bb8261e76cccc0d0ffe9272ac0cf17bfdbc374c287df4835f",
      "output_schema": "sha256:910fc1b61a737225e27e9aeef6c164715b4adea1eaf682e75bf52a7e1f9eed9d",
      "interface": "sha256:b254025a20f018210d11fa7b25ceeef740f8f098480b95a90cebd025b3fc54b5"
    },
    "mnemoverse-mcp-memory-server:tool:memory_feedback": {
      "description": "sha256:6e997f32e4216a57697d352cdb3f79f50398b9815023fcb7734125acb99e669a",
      "input_schema": "sha256:bdf3b2ac91377b4848229a1cb4f15e563bb8ec427b50592f43a82066dff6b7d7",
      "output_schema": "sha256:c3c42da4a0f9bbb5318503bdaba6ac9043fd9836d01e21491578358068fe0cca",
      "interface": "sha256:6fc877243eeaa96362273ca2ab4cfc983b49556974e8cab4af92b91dd6b2725d"
    },
    "mnemoverse-mcp-memory-server:tool:memory_graph": {
      "description": "sha256:aedc7480f21d2d4bb6c11282791e472a78f2e973024c68d8c033fbe6ede7b5c4",
      "input_schema": "sha256:93bb83e92ae5f2fa68e678d5978a34ef54d895c4278eb05da4be9ed5be0e1b04",
      "output_schema": "sha256:c7afffd67deacfbc3dbd1ac250cd64d330565cb3151a44d748ca279bdf5a8d60",
      "interface": "sha256:c525961b916dec4edc4809d2e8837ee7d952a13859d98704c9a981b643b52888"
    },
    "mnemoverse-mcp-memory-server:tool:memory_invite_to_room": {
      "description": "sha256:6af5d512f062c0fb771601bc1e4d91699324d5e8e8bcd81856cb3a1ca3a8ad93",
      "input_schema": "sha256:0f09112d0bffdfa0820eed4f8a130ce42c103e7fb1610d583ee8c656466e658f",
      "output_schema": "sha256:de44cc6a2bf991af12731bb3a089e58719f84c98b4bee898a2f78c9454ece8c6",
      "interface": "sha256:c698cafd38ae0032c61653df176c9b2ec2e5a09c84a11ce9bbf7c2fc7176c7a0"
    },
    "mnemoverse-mcp-memory-server:tool:memory_join_room": {
      "description": "sha256:77a265860cf77780358713395c0cb22f57cd86079995d7fedbb7ca0d4606c6c0",
      "input_schema": "sha256:f821396d10f19bcf2b44ad5665e546b8d12a1ea11a23db4b560c568853e6dac8",
      "output_schema": "sha256:79cc6578ff7bd2e06c498e2f207cd1bf11fc6721fa924fcf91faee412f779efd",
      "interface": "sha256:76b91a501d1d4f2bcfe8b473b6ed10a902930acfd6dc3c142fedd2a3a731bff0"
    },
    "mnemoverse-mcp-memory-server:tool:memory_list_recent": {
      "description": "sha256:dcb545ebafeaa8749f2fdbba276d132608c2864688ca9139f7a587defcede086",
      "input_schema": "sha256:d06c9530e63097f321cf4993ddd24dbaf2bbbd0d1e386226186f5a4809bc6938",
      "output_schema": "sha256:3dc73568651f8ad39e3b90aed237014612ca45d29da610b514e28cb5f744ae5b",
      "interface": "sha256:dba8f3a25cd07a8bf39b5f3b21137fb057ecbf98d04710ed71ac0701b842071b"
    },
    "mnemoverse-mcp-memory-server:tool:memory_list_rooms": {
      "description": "sha256:4a6aa9805a705c4134b628284753a7e37cdf055897f9c4e5f4491f82af0e6d44",
      "input_schema": "sha256:3178d649f32f96ea850da50c27c062f5c20cbef86dec2f5af0587dff56ebdb67",
      "output_schema": "sha256:f03c2e3837530ee799b5cba5586600954c83a87621905af18954996a3a6e902f",
      "interface": "sha256:1378316e461b63ea9d33876494daed6cccbddd28691e41943ab56c437a9f490d"
    },
    "mnemoverse-mcp-memory-server:tool:memory_read": {
      "description": "sha256:f04734e48b53574899c75dca5c7ba93efbc480da4d55486991e5b8fe4b98cfcc",
      "input_schema": "sha256:298f6f8b1a0887a2f02765e476cf73cebbf88d453df5733662356cfeb5790ada",
      "output_schema": "sha256:dd3c288fa6d6e0797bbceb1c7697e1a722ea5d11a4226dfc6cda267a34622d55",
      "interface": "sha256:bc7178b1540fd9d813c85acbcbe0c6a0c77e9e15f94b91a5cfd996ec10d59300"
    },
    "mnemoverse-mcp-memory-server:tool:memory_stats": {
      "description": "sha256:b1f82e800d9321ae0f98aec16a4e0f2a82d00462190fa47a74f532068e23a5fa",
      "input_schema": "sha256:3178d649f32f96ea850da50c27c062f5c20cbef86dec2f5af0587dff56ebdb67",
      "output_schema": "sha256:7506974076d4533300cf82c80d75437ffd7fddef038f8e774f84d6b0aebf01ba",
      "interface": "sha256:b60e2c2fbe2dc75b5ade487646f20762a6edc6821f915ddd6c5959f68204594a"
    },
    "mnemoverse-mcp-memory-server:tool:memory_write": {
      "description": "sha256:4ea17bb1a31de6d7d2cee66f87f43640e7b667bb1e6b37f8a7c8c826031e5ff3",
      "input_schema": "sha256:25ced95bcad9a12919d0666c32d344c7d906b020c0d439e21f5bb6e8522210cc",
      "output_schema": "sha256:798a85d5bf9a3894e07a922feddf576a138027245b57bc0ecb79c1ac7ca310d6",
      "interface": "sha256:3f4c7b606d43df186c387913e18719ad304a17af12e220c0a56fe7b9fd4c4c2c"
    },
    "mnemoverse-mcp-memory-server:tool:vault_list": {
      "description": "sha256:984887157db91df509833b035e1b34357d22d9b45553835d1916a806ddf95019",
      "input_schema": "sha256:3178d649f32f96ea850da50c27c062f5c20cbef86dec2f5af0587dff56ebdb67",
      "output_schema": "sha256:c418d63ba54d5b0d89c86a1fb3d0e9a52c19dc9d2f14256f5930c6305a66b4f4",
      "interface": "sha256:d38039ca87e45aa6d421e36ccfe53bba0cfa893afce0e48f82ac6d9c1a20d614"
    }
  }
}
