Skip to main content
Glama

Memory Store

localnest_memory_store

Store durable local memory entries for AI agents to access knowledge and preferences from your codebase, keeping all data and processing on your local machine.

Instructions

Store a durable local memory entry.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
kindNoknowledge
titleYes
summaryNo
contentYes
statusNoactive
importanceNo
confidenceNo
tagsNo
linksNo
scopeNo
source_typeNomanual
source_refNo
change_noteNoInitial memory creation
response_formatNojson

Output Schema

TableJSON Schema
NameRequiredDescriptionDefault
dataYes
metaNo

Implementation Reference

  • Registration and handler implementation for the 'localnest_memory_store' tool.
    registerJsonTool(
      ['localnest_memory_store'],
      {
        title: 'Memory Store',
        description: 'Store a durable local memory entry.',
        inputSchema: {
          kind: MEMORY_KIND_SCHEMA,
          title: z.string().min(1).max(400),
          summary: z.string().max(4000).default(''),
          content: z.string().min(1).max(20000),
          status: MEMORY_STATUS_SCHEMA,
          importance: z.number().int().min(0).max(100).default(50),
          confidence: z.number().min(0).max(1).default(0.7),
          tags: z.array(z.string()).max(50).default([]),
          links: z.array(MEMORY_LINK_SCHEMA).max(50).default([]),
          scope: MEMORY_SCOPE_SCHEMA,
          source_type: z.string().max(60).default('manual'),
          source_ref: z.string().max(1000).default(''),
          change_note: z.string().max(400).default('Initial memory creation')
        },
        annotations: {
          readOnlyHint: false,
          destructiveHint: false,
          idempotentHint: false,
          openWorldHint: false
        }
      },
      async (args) => {
        const result = await memory.storeEntry(args);
        return normalizeMemoryEntryPayload(result?.memory || null, {
          created: Boolean(result?.created),
          duplicate: Boolean(result?.duplicate)
        });
      }
    );
Behavior3/5

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

The description adds 'durable' and 'local' context not present in annotations, indicating persistence characteristics. However, it fails to address the critical implications of 'idempotentHint: false' (risk of duplicates on retry), does not explain what constitutes a conflict or overwrite given the 'title' field, and omits any mention of the rich schema structure (scope, status, links).

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 single sentence is efficiently worded with no redundancy, but it is inappropriately brief for a tool with 14 parameters and nested object structures. It lacks the necessary elaboration to support the schema complexity, making the conciseness a liability rather than a virtue.

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

Completeness2/5

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

Given the high complexity (14 parameters, 3 enums, nested objects, output schema present), the description is inadequate. While the output schema absolves the need to describe return values, the 0% parameter coverage in the schema means the description must explain the data model (e.g., difference between summary and content, purpose of scope fields), which it completely omits.

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

Parameters1/5

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

With 0% schema description coverage across 14 complex parameters (including nested objects for scope and links), the description must compensate significantly but provides no parameter guidance whatsoever. It does not mention the two required fields (title, content), the enum options (kind, status), or the semantic purpose of importance/confidence scores.

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

Purpose4/5

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

The description uses a specific verb ('Store') and resource ('local memory entry') and qualifies it with 'durable,' giving a clear sense of persistence. However, it fails to distinguish from sibling memory tools like 'localnest_memory_update' or 'localnest_memory_capture_event', leaving ambiguity about when to use creation versus update versus event logging.

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

Usage Guidelines2/5

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

The description provides no guidance on when to use this tool versus its many siblings (e.g., localnest_memory_update, localnest_memory_capture_event). It does not mention prerequisites, required fields, or exclusion criteria, leaving the agent to infer usage patterns solely from the parameter names.

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

Install Server

Other Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/wmt-mobile/localnest'

If you have feedback or need assistance with the MCP directory API, please join our Discord server