Recall output should be LLM-friendly

[qwertyuiop1379]

Problem

I've been using mnemon for a little while now, and I'm impressed with the results. I went back to a few previous coding sessions, then asked the agent to reflect its own experience using mnemon – one emergent pattern suggests that the recall command is introducing a bottleneck.

Specifically, the core complaint is that recall command is too verbose in all the wrong areas. The verbosity is useful for debugging and disambiguating, but it's not optimized for standard operation, as most of the information is not actually relevant. This negatively impacts an agent's performance in at least two significant ways:

1. The unneeded tokens are still processed, wasting precious usage budget.
2. Including irrelevant context is distracting to the LLM's attention and reasoning processes, which pretty consistently degrades output quality.

Proposed solution

The recall command should default to a more LLM-friendly response shape, perhaps introducing a CLI flag to output the full payload. The easy win here is to make the output less verbose unless explicitly requested. Another small-but-real gain could be to truncate float digits dynamically, using higher precision when it makes sense.

According to the feedback analysis, the most desired information for recall is:

• the memory contents
• a summarization of the memory
• reason for match
• a confidence metric / grounds for inclusion

As far as I know, mnemon doesn't have native summarization, rationale, nor confidence/grounding mechanisms. In practice, however, even some simple heuristics could be quite impactful here if tuned properly.

Alternatives considered

Another idea here is adding support for other serialization methods, such as YAML and CSV/TSV. Recent evaluations suggest that JSON is not an efficient I/O format for LLMs. Here's a relevant article: https://medium.com/better-programming/yaml-vs-json-which-is-more-efficient-for-language-models-5bc11dd0f6df

(I haven't tested this, but I would also bet that rendering the content into natural-ish language could promote the integration of memories into the reasoning process.)

Additional context

Here are a few quotes from a few separate feedback responses. The consensus is clear:

The JSON shape is more verbose than helpful for live use. score, intent, via, signals, access_count, timestamps, traversed counts, etc. are useful for debugging the system, but not for fast agent consumption. What I want first is: (a) the memory, (b) why it matched, and (c) how confident I should be

I get full JSON objects with signals, intent, via, entities, access counts, timestamps, and often truncated content. That is more detail than I usually need in the moment. What I actually want first is: (a) short insight text, (b) why it matched, and (c) maybe category/importance

The current recall output is too heavy for routine use. The scores, signals, timestamps, access counts, and graph metadata are useful for debugging retrieval quality, but they are expensive when I’m just trying to get oriented. I’d prefer: (a) default compact mode: id, one-line summary, why it matched; (b) optional verbose/debug mode with the scoring internals

Happy to work on a PR for this, if you think it's a valuable addition.

[Grivn]

Thanks, I agree this makes sense.

A PR would be very welcome. Feel free to take a first pass and we can discuss the details in review.

If you’d rather settle the shape first, you can also post a few possible output examples here and we can discuss before implementation.

Main thing is: default recall should be lighter for agents, while the current full/debug payload should still be available somehow.