Skip to main content
Glama

Manage Persistent Agent Memory Triplet Store

manage_memory_store
Destructive

Manage persistent agent semantic memory stores by listing, compressing, consolidating, exporting, resetting, or deleting episodic knowledge stored locally.

Instructions

Manages the complete lifecycle of persistent agent semantic memory stores, including compression, consolidation, export, listing, reset, and deletion, distinguishing from 'query_memory_store' and 'prune_code_snippet' by storing, compressing, and purging episodic memories rather than querying relations or pruning source code.

Parameters:

  • operation: Memory lifecycle operation: 'list' displays active memory stores and recent codes; 'compress' encodes text into semantic triples; 'decompress' decodes memory codes; 'consolidate' merges episodic memories; 'export' dumps graph to JSON or interactive HTML; 'reset' clears memory codes; 'delete' removes store file from disk.

  • content: Text document, knowledge snippet, or output file path depending on operation.

  • store_name: Unique identifier of the target memory store to manage (default: 'default').

  • project_root: Workspace directory where memory stores are persisted (default: current directory).

Behavior:

  • Mutability: State-modifying and destructive; writes, consolidates, resets, or deletes local memory store JSON files on disk.

  • Idempotency: Non-idempotent for write/reset operations; idempotent for 'list' and 'export' operations.

  • Privacy & Network: 100% offline local JSON storage; zero external network synchronization.

  • Performance & Resources: Executes in <50ms consuming <35MB RAM; thread-safe file handling.

  • Auth: Zero authentication or cloud credentials required.

  • Return Structure: Emits Markdown status report confirming memory consolidation, export file path, list of active memory stores, or deletion confirmation.

  • Error Handling: Validates operation parameter and returns clear error guidance for unrecognized modes.

Usage Guidelines:

  • When to use: Store new semantic knowledge, consolidate episodic memories, export knowledge graphs to JSON/HTML, list active memory stores, or clear/reset agent memories.

  • When NOT to use: Do not use for querying existing knowledge triples or causal chains from memory (use 'query_memory_store' instead); do not use for pruning source code snippets or diff streams (use 'prune_code_snippet' instead).

Returns: Status report confirming memory consolidation, export file path, list of active memory stores, or confirmation of reset/deletion.

Tool call template

This tool declares no required parameters. Add optional parameters from the input schema as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {},
    "name": "manage_memory_store"
  }
}

Input Schema

NameRequiredDescriptionDefault
contentNoText document or knowledge content to compress or store when operation is 'compress'.
operationNoMemory lifecycle operation: 'list' to show active memory stores, 'compress' to encode text into semantic triples, 'consolidate' to merge memory, 'export' to dump graph, 'reset' to clear all memory, 'delete' to remove a specific store.list
store_nameNoIdentifier of the target memory store to manage.default
project_rootNoWorkspace root where memory stores are managed (default: current directory)..

Output Schema

NameRequiredDescriptionDefault
resultYes

Schema Changelog

Changes observed during successful MCP inspections.

  1. Addedv7.3.2
  2. Removedv7.0.1
  3. Addedv7.0.0

TDQS

A4.7/5.0
Behavior5/5

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

Annotations already declare destructive=true, readOnly=false, idempotent=false, and openWorldHint=false, but the description adds concrete behavior: local JSON file writes/deletions, no network synchronization, no authentication, and operation-specific idempotency exceptions. It also describes error handling and return structure, which goes beyond the annotation-level safety profile.

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

Conciseness3/5

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

The description is front-loaded with purpose and sibling differentiation, but it is lengthy and includes details like specific latency/RAM figures and a duplicated 'Returns' section. Some behavioral and parameter details are repeated between the main description and the schema, reducing efficiency.

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

Completeness5/5

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

Given a multi-operation destructive lifecycle tool with four parameters, the description covers purpose, usage boundaries, mutability, idempotency, privacy, auth, performance, returns, and errors. Although an output schema exists, the description still provides enough context for an agent to select operations and understand consequences.

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?

Schema coverage is 100%, so the schema already documents all four parameters and the operation meanings. The description still adds some useful semantics, such as 'content' being a text document, knowledge snippet, or output file path depending on operation, though much of the operation list repeats the schema.

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 description states a specific verb and resource: managing the lifecycle of persistent agent semantic memory stores across compression, consolidation, export, listing, reset, and deletion. It explicitly distinguishes this tool from 'query_memory_store' and 'prune_code_snippet' by contrasting storage/compression/purging against querying and source-code pruning.

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

Usage Guidelines5/5

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

It gives explicit 'when to use' cases such as storing semantic knowledge, consolidating episodic memories, exporting graphs, listing stores, and resetting memories. It also gives explicit 'when NOT to use' cases and names the correct alternative tools for querying and source-code pruning.

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