Skip to main content
Glama

Save to memory

memory_add
DestructiveIdempotent

Save to this person's long-term memory (Alexein), which their other apps read too. They connected this so it would remember: as you go, save what they tell you about themselves, their work and the people and things around them - preferences, facts, decisions, plans, dates, names. Save those facts, not the conversation. Write access was given on purpose; the memory is theirs alone, and they can see and erase anything saved under My memory in the Alexein app.

One fact per item, as a note, in their words. Mark what the person says with author: {"self": true} and role: "user", and name anyone else who said it: only the person's own items set a rule for every reply. One session id for the items you save together. Send an item's id again to correct it: memory keeps the earlier version. Set expires when it stops being true. Never save secrets, passwords, keys or payment details, or your own suggestions as facts about them.

Tool call template

Replace each placeholder with a value matching the input schema. Only required parameters are included; add optional parameters as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {
      "items": "<items>"
    },
    "name": "memory_add"
  }
}

Input Schema

NameRequiredDescriptionDefault
itemsYes

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observed

TDQS

A4.5/5.0
Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Beyond the annotations, it discloses that memory is user-visible and erasable, that write permission was granted deliberately, that corrections are versioned rather than overwriting ('memory keeps the earlier version'), and that `expires` governs staleness. These are exactly the traits an agent needs to act safely on a destructive, idempotent, non-open-world write, and none of them are derivable from the annotation flags.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Purpose and the authorization rationale are front-loaded, followed by a second paragraph of field mechanics and a closing safety rule, so the ordering serves a scanning agent. It is dense with backticked field names in prose and could be tightened, but no sentence is filler.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a batch write with no output schema, it covers what to save, what never to save, and how corrections work. The notable gap is that it never says what the call returns — the agent is told to 'send an item's `id` again to correct it' without being told that ids come back from this tool, nor anything about the 500-item cap or partial failures.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

With schema coverage reported at 0%, the description carries the burden and mostly does: it explains `author`/`role` conventions ('self': true, role 'user', naming other speakers), `session` grouping, `id` reuse for correction, `kind: note` as the default form, and `expires` for time-bounded facts. It leaves `at` and `about` (kind:name tagging) entirely to the schema, so a couple of nested fields remain semantically thin.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The first sentence names a specific verb and resource ('Save to this person's long-term memory (Alexein)') and adds distinguishing scope that no sibling shares: the memory is shared across the person's other apps. An agent can tell this is the write counterpart to the memory_* read tools without opening any schema.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

It gives concrete inclusion criteria ('preferences, facts, decisions, plans, dates, names', 'as you go'), a positive framing of when writing is appropriate ('Write access was given on purpose'), and explicit exclusions ('Never save secrets, passwords, keys or payment details, or your own suggestions'). What is missing is any named alternative among the siblings (e.g. feedback vs add), so routing between memory write tools is still inferred.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Try in Browser

Glama MCP Gateway

Add one secure layer between your agents and this server.

Resources