Skip to main content
Glama

live_memory_read

Retrieve recent memory readings from an active STM32 live memory session by session ID, returning the last N buffered entries without reading the JSONL file.

Instructions

Read recent entries from a live memory session.

Returns the last N entries from the in-memory ring buffer without touching the JSONL file.

Args: session_id: Session ID from live_memory_start. last_n: Number of recent entries to return (default 10, max 100).

Returns: Recent memory readings formatted as text.

Input Schema

NameRequiredDescriptionDefault
last_nNo
session_idYes

Output Schema

NameRequiredDescriptionDefault
resultYes

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv0.1.0

TDQS

A3.8/5.0
Behavior4/5

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

With no annotations, the description carries the burden and does real work: 'read' plus 'without touching the JSONL file' establishes non-destructive, non-persistent semantics, and 'in-memory ring buffer' with 'max 100' discloses bounded retention. It leaves gaps on error behavior (unknown/stopped session_id, empty buffer) and on whether reads consume or advance a cursor.

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?

The core statement is front-loaded in the first two sentences, with param and return notes following. The Returns section ('formatted as text') is low value given an output schema exists, but the Args section carries the undocumented max=100 detail, so little is truly wasted.

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 2-parameter read tool with an existing output schema, the description covers purpose, scope, prerequisite session, and parameter bounds. The remaining gap is edge-case behavior when the session is absent or the buffer is empty, which an agent calling this would benefit from knowing.

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 0% and the schema titles are bare ('Session Id', 'Last N'), so the description is the only source of meaning. It explains the provenance of session_id (from live_memory_start) and adds the max of 100 for last_n, which the schema does not state. Both parameters are covered, though not the behavior for out-of-range last_n.

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?

States a specific verb and resource: 'Read recent entries from a live memory session'. The second sentence sharpens the scope by naming the mechanism ('in-memory ring buffer') and what it does not touch ('the JSONL file'), which implicitly separates it from stm32_read_memory and the persistent-log siblings. It stops short of naming a sibling alternative explicitly, so not a 5.

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

Usage Guidelines3/5

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

The only usage signal is embedded in the parameter note: 'Session ID from live_memory_start', which implies the session must be started first. There is no explicit statement of when to prefer this over stm32_read_memory, debug_mem, or live_memory_write, and no exclusions or failure conditions.

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