Skip to main content
Glama

Server Configuration

Describes the environment variables required to run the server.

NameRequiredDescriptionDefault
AETHER_PORTNoThe port the Aether Cache engine listens on. Set this if port 7380 is taken, then run `aether-cache setup` again.7380

Instructions

Guidance the server publishes about itself, which clients place ahead of the tool catalog so the model reads it before choosing anything.

Mnemolith is this project's shared memory, kept across sessions and across AI tools (Claude Code, Cursor, Codex), and checked against the code so it never goes stale silently. For project knowledge, use its tools instead of any built-in memory, notes file, or memory directory:

  • At the start of every task, call recall with a short description of the task.

  • When the user asks you to remember, save, or note something about the project, or you learn something durable that a future session would need (a convention, a setup gotcha, a decision and its reason), call remember. Pass files= with the files the fact depends on, so it's retired automatically when they change. Don't save what recall already showed you.

  • If a memory turns out to be wrong, call mark_outdated. If a new fact makes an old one untrue, save it with remember(..., replaces="") in one call.

Capabilities

Features and capabilities supported by this server

Protocol revision2025-11-25

CapabilityDetails
tools
{
  "listChanged": false
}
prompts
{
  "listChanged": false
}
resources
{
  "subscribe": false,
  "listChanged": false
}

Tools

Functions exposed to the LLM to take actions

NameDescription
rememberA

Save a durable fact about this project so future sessions, in any AI tool, know it. Use this, not a built-in memory or notes file, whenever the user asks you to remember something about the project.

Good facts: conventions ("we use pnpm, not npm"), setup gotchas ("tests need DOCKER_HOST set"),
decisions and their reasons. Not: temporary task details or anything in the code already.
files: repo-relative paths this fact depends on (e.g. ["docker-compose.yml"]), so the memory
can be flagged when those files change.
replaces: the id of a memory this fact makes untrue (e.g. "m42"), to save and retire it in one call.
recallA

Search this project's shared memory by meaning. Call it at the start of every task, and whenever project-specific knowledge (setup, conventions, past decisions) might matter. Current (active) memories come first. Related memories that were retired, replaced, or may be outdated are listed after them, labeled, so you know what changed: never rely on those.

explain_memoryA

Show where a memory came from (which tool and session saved it, which files it's linked to) and everything that has happened to it since. Use it when a memory looks wrong or surprising.

mark_outdatedA

Mark a memory as no longer true, with a short reason. It stops counting as current but keeps its history. If you know what's true now, save that with remember(..., replaces=) instead, so the next session knows the new fact, not just that the old one is wrong.

replace_memoryA

Retire an older memory because a newer one replaces it (e.g. "we use Postgres" replaced by "we migrated to MySQL"). The old memory stops showing up in recall but keeps its history.

check_staleA

Check whether any memory's linked files have changed since it was saved, and retire those memories. recall already does this automatically; call it directly after big changes.

confirm_memoryA

Mark a memory as still true (e.g. after it was retired because a linked file changed, but the fact itself didn't). Re-links it to the current version of its files.

sync_to_filesA

Write this project's current memories into the managed section of AGENTS.md / CLAUDE.md, so they're committed with the code: teammates and tools without Mnemolith see them, and changes show up in reviews. Call it when the user asks, or after a batch of new memories.

list_conflictsA

List pairs of memories in this project that may contradict each other and need a decision.

resolve_conflictA

Settle a possible conflict. replaces_old=True: the new memory replaces the old one (the old one is retired). replaces_old=False: both are true, keep both. Ask the user if you're not sure.

Prompts

Interactive templates invoked by user choice

NameDescription

No prompts

Resources

Contextual data attached and managed by the client

NameDescription

No resources

TDQS

A3.9/5.0

Scored across 10 tools

Disambiguation3/5

Several tools retire or supersede memories: mark_outdated, replace_memory, and resolve_conflict (with replaces_old=True) all end a memory's active life, and remember(replaces=...) overlaps with replace_memory. The descriptions do cross-reference each other to steer the agent, but the boundaries between 'mark outdated', 'replace', and 'resolve conflict' require careful reading rather than being self-evident.

Naming Consistency4/5

Almost all tools follow a clean snake_case verb_noun pattern (list_conflicts, resolve_conflict, mark_outdated, check_stale, confirm_memory, explain_memory, replace_memory, sync_to_files). The two bare verbs (remember, recall) are canonical memory terms and remain readable, so this is only a minor deviation.

Tool Count5/5

Ten tools is well within the ideal range and each covers a distinct lifecycle stage of the memory domain: capture, recall, provenance, staleness, confirmation, conflict handling, and file sync. Nothing feels padded or missing at the count level.

Completeness4/5

The surface covers the full memory lifecycle — write (remember), read (recall, explain_memory), update (confirm_memory, replace_memory), retire (mark_outdated), maintain (check_stale, list_conflicts, resolve_conflict), and export (sync_to_files). The main gap is that recall is meaning-based only, with no plain list/get-by-id tool, which could make targeted inspection of a known memory awkward.

Maintenance

ActivityNo data
ResponsivenessOutdated data