Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@SAE4U Memory remember that I prefer Python for backend projects"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
A persistent memory architecture for Claude — MCP server + hooks + rules + prompts + templates. Free and open source. MIT.
Claude forgets you every time you close the chat. SAE4U Memory fixes that, and goes further: it ships an opinionated architecture for how persistent memory should be organized — not just storage, but classification, periodic review, persona, cleanup, and session continuity.
Part of the SAE4U OSS family
alongside sae4u-agent.
Two-corpus recall — recall(query) searches BOTH SQLite facts
AND your markdown memory files (Claude Code auto-memory dirs +
~/.sae4u-memory/) in one call. No re-explaining yourself.
Hierarchical memory — remember(text, category) with 5
categories: user, feedback, project, reference, general.
Session journals — journal(text) for end-of-session notes
written to ~/.sae4u-memory/journals/YYYY-MM-DD.md for human reading.
Customizable persona — persona.md shapes the AI's identity.
Default: Simple, a peer-level coder friend who remembers things.
Local-first — your memory lives in ~/.sae4u-memory/ on your
machine. Nothing leaves.
--code-full)hooks/memory-tick.sh — UserPromptSubmit hook that fires every
10 min and forces a brief memory review. Catches borderline
observations before they fall out of context.
rules/ — 10 universal feedback rules covering memory
discipline, session continuity, anti-confabulation, hardcode
prevention, post-write review.
prompts/ — opinionated session-open and session-close prompts
that pair with the architecture.
templates/ — formats for MEMORY.md, feedback rules,
project facts, and tick logs.
commands/memory-distill.md — weekly distill ritual that
promotes tick-log items to permanent memory interactively.
Related MCP server: Claude Memory Server
git clone https://github.com/Simple4uhq/sae4u-memory
cd sae4u-memory
pip install -e .
sae4u-memory initThis wires the MCP server into Claude Desktop and Claude Code, and
appends a guidance block to ~/.claude/CLAUDE.md. Restart your
client and the memory tools are live.
sae4u-memory init --code-fullAdds:
Copy hooks/memory-tick.sh → ~/.claude/hooks/memory-tick.sh
Register the hook in ~/.claude/settings.json under hooks.UserPromptSubmit
Scaffold ~/.sae4u-memory/MEMORY.md
Drop default rules into ~/.sae4u-memory/rules/
Restart Claude Code. The tick will fire every 10 min and instruct the AI to review and classify recent context.
sae4u-memory init --desktop # Claude Desktop only
sae4u-memory init --code # Claude Code MCP only
sae4u-memory init --code-full # Claude Code MCP + hook + scaffold
sae4u-memory init --no-claude-md # skip CLAUDE.md guidance block
sae4u-memory init --dry-run # preview changes without applying
sae4u-memory uninstall # remove all config entriesTool | Purpose |
| Save a fact to long-term memory |
| Search across SQLite + markdown roots. |
| Browse what's remembered |
| Delete a wrong/outdated memory |
| Write an end-of-session note |
| Read recent journal entries |
| Return full persona + user context |
~/.sae4u-memory/
├── persona.md # Edit to customize behavior
├── memory.db # SQLite + FTS5
├── MEMORY.md # Index of permanent files (loaded at session start)
├── user/ # User context loaded by get_persona()
│ ├── identity.md
│ ├── projects.md
│ └── preferences.md
├── tick/ # Day-rolling tick log (NOT indexed in MEMORY.md)
│ └── 2026-05-07.md
├── archive/ # User-confirmed archived files
├── journals/ # End-of-session narratives
│ └── 2026-05-07.md
└── .last_tick # Epoch of last memory tickThe 4-type classification (user, feedback, project, reference)
plus the tick / permanent split is the architectural core. See
architecture.md for the
full explanation.
All architecture content lives under sae4u_memory/_assets/ so it ships with the wheel.
docs/architecture.md —
5 concepts, file layout, the 4 types, what NOT to save
docs/tick-protocol.md —
how the 10-min hook works, what gets written where
docs/persona-customization.md —
what's editable, what's loaded at session start
docs/episodic-bridge.md —
optional pattern for users with a remote dev box
prompts/session-open.md —
paste this at session start
prompts/session-close.md —
paste this at session end
commands/memory-distill.md —
weekly cleanup ritual
rules/ — 10 universal feedback rules
hooks/memory-tick.sh —
the UserPromptSubmit hook itself
templates/ — MEMORY.md, feedback rule, project fact, tick log
Edit ~/.sae4u-memory/persona.md to change the AI's identity, voice,
and rules. Edit ~/.sae4u-memory/user/*.md to pre-fill what the AI
knows about you. Both are loaded fresh on every session start.
The default persona is Simple — a peer-level coder friend. Rename, rewrite, or replace as you see fit.
SAE4U_MEMORY_HOME — override the data directory
(default ~/.sae4u-memory)
SAE4U_MARKDOWN_ROOTS — colon-separated list of markdown roots
that recall() should search. Defaults to all Claude Code
auto-memory dirs (globbed from ~/.claude/projects/*/memory/)
plus SAE4U_MEMORY_HOME.
sae4u-memory uninstall # remove configs from Claude Desktop + Code
rm ~/.claude/hooks/memory-tick.sh # if you ran --code-full
rm -rf ~/.sae4u-memory # optional — also delete stored memories
pip uninstall sae4u-memoryv0.2.0 — memory architecture release. Full export of the pattern
the project authors run in production: hooks + rules + prompts +
templates + persona + extended init for Claude Code. Renamed from
simple4u-memory to align with the SAE4U OSS family.
Previous: v0.1.3 (under the old name) shipped two-corpus recall and a working-rules persona. v0.1.x users on PyPI: install fresh from this repo; the old package is no longer maintained.
sae4u-agent —
multi-tenant control plane and agent runtime template. The
agents need memory; this is that memory.
MIT.
Delete a memory by its id.
Use this when a stored fact turns out to be wrong or outdated.
Args: memory_id: The id of the memory to remove.
| Name | Required | Description | Default |
|---|---|---|---|
| memory_id | Yes |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose behavior. It states 'Delete', which implies mutation and potential irreversibility, but does not discuss permissions, effects on linked data, or error states. For a simple delete, it provides basic transparency but could be more detailed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise, with three short sentences that front-load the purpose. Every sentence adds value, and there is no redundancy or extraneous text.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given a single required parameter and no nested objects, the description covers the core functionality. However, it does not mention the output or return value (despite an output schema existing), nor address error handling or idempotency. Basic completeness is achieved but not enhanced.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0% description coverage for 'memory_id', but the tool description explains the parameter as 'The id of the memory to remove', adding meaning beyond the schema's type and title. This compensates well for the schema gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Delete a memory by its id', using a specific verb and resource. Among siblings like 'remember' (create) and 'recall' (retrieve), this tool's purpose is distinct and unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says 'Use this when a stored fact turns out to be wrong or outdated', providing clear when-to-use guidance. It does not mention when not to use or alternatives, but the direct context is sufficient for an agent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Return the current persona + user context.
This gives the AI its identity and what it knows about the user. Call this at session start to load full context.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so description carries full burden. It discloses that the tool returns identity and user context, implying a read operation. This is adequate for a non-destructive retrieval tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two succinct sentences with no fluff. Critical information is front-loaded: purpose first, then usage context.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with no parameters and an existing output schema, the description is complete. It covers purpose, when to use, and what it returns without missing details.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Tool has 0 parameters, so baseline is 4. No param info needed; description focuses on purpose and usage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Return the current persona + user context', specifying verb and resource. It distinguishes from sibling tools that handle memory operations, making purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly advises 'Call this at session start to load full context', providing clear when-to-use guidance. Does not mention alternatives or when not to use, but context is sufficient.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Write an end-of-session journal entry.
Use this at the end of a significant conversation to record what happened, decisions made, and what to remember for next time. Journals are stored in ~/.sae4u-memory/journals/YYYY-MM-DD.md for human reading.
Args: text: The journal entry text.
| Name | Required | Description | Default |
|---|---|---|---|
| text | Yes |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It discloses storage location and format (~/.sae4u-memory/journals/YYYY-MM-DD.md) but does not detail permissions, side effects, or whether it overwrites. Adequate for a simple write operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short paragraphs plus an Args line; every sentence adds value. Purpose is front-loaded, no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple 1-parameter tool with output schema present, the description covers usage, content, and storage location. It does not explain return values, but the output schema exists so that is acceptable.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 0% description coverage (only title 'Text'), but the description adds 'The journal entry text.' via the Args section, providing meaning beyond the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Write' and the resource 'an end-of-session journal entry', distinguishing it from sibling memory tools like 'remember' and 'recall' by specifying the exact context (end of significant conversation).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly tells when to use: 'at the end of a significant conversation'. Implies when not to use (during conversation) but does not provide explicit alternatives or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List stored memories, optionally filtered by category.
Args: category: Filter by category (user/feedback/project/reference/general). limit: Max results to return.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | ||
| category | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description does not disclose any behavioral traits beyond the basic listing operation. It does not mention idempotency, read-only nature, or potential side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded with the main purpose. It includes parameter documentation in a clear list format, though the parenthesized category list could be streamlined.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers filtering and result limiting. With an output schema present, return values are defined elsewhere. However, it lacks details on ordering, pagination, or default behavior beyond what is in the schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds meaningful context to parameters: it lists the valid category values (user/feedback/project/reference/general) and explains the limit parameter. The schema has 0% coverage, so the description compensates well.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action (list), the resource (stored memories), and the optional filtering by category. It is specific and distinguishable from sibling tools like 'forget' or 'remember'. However, no explicit differentiation is made.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given on when to use this tool versus alternatives like 'recall' or 'journal'. There are no notes on prerequisites or scenarios where listing is appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search persistent memory for relevant facts.
Scans TWO corpora by default and merges results:
SQLite memories (written via remember tool)
Markdown memory files — Claude Code auto-memory + sae4u-memory home (configurable via SAE4U_MARKDOWN_ROOTS env, colon-separated paths)
Use this at the start of any substantive conversation to pull in prior context, feedback rules, project state, and recent session observations.
Args: query: Search terms. Empty string returns most recent entries. limit: Max results per source (default 5). category: Optional filter (SQLite only). sources: "all" (default), "sqlite", or "markdown".
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | ||
| query | Yes | ||
| sources | No | all | |
| category | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Discloses that it scans two corpora and merges results, mentions environment variable for configuration, and describes default behavior for empty query and limit. No annotation contradictions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Well-structured with a lead sentence, bullet-like explanation of corpora, usage advice, and parameter list. Slightly verbose but each part adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Covers all essential aspects: purpose, sources, parameters, and usage context. Output schema exists, so not detailing return values is acceptable. Could mention potential performance or pagination.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Despite 0% schema coverage, the description's Args block explains each parameter's meaning, defaults, and source-specific behavior (e.g., category applies only to SQLite).
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Search persistent memory for relevant facts' and specifies the two corpora scanned, distinguishing it from sibling tools like remember (write) and forget (delete).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly advises using 'at the start of any substantive conversation to pull in prior context', but does not mention when not to use or compare directly with alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Retrieve recent journal entries.
Args: days: Number of days back to search (default 7).
| Name | Required | Description | Default |
|---|---|---|---|
| days | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It only states 'Retrieve', suggesting read-only behavior, but omits details like ordering, pagination, limits, or side effects. The presence of an output schema provides some structure but not behavioral traits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise: one sentence plus an arg explanation. It is front-loaded with the core action and contains no extraneous information, earning its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple retrieval tool with one optional parameter and an output schema, the description covers the essential function. However, it could be more complete by specifying ordering (e.g., descending by date) or default behavior, especially given the lack of annotations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds meaning to the 'days' parameter by explaining it as 'Number of days back to search', which supplements the schema's type and default. Despite zero schema description coverage, this is a basic but adequate addition.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Retrieve recent journal entries', specifying a verb and a resource. Sibling tools like 'journal' (likely create), 'remember', 'forget', etc., are distinct, making the tool's purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for fetching recent entries with an optional days parameter. However, it does not explicitly state when to use this tool versus alternatives (e.g., 'journal' for creation, 'recall' for memories), leaving the distinction implicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Save a fact, observation, or piece of context to persistent memory.
Use this when you learn something important about the user, their projects, their preferences, or anything else worth recalling in future sessions.
Args: text: The fact or observation to remember. category: Optional category — "user", "feedback", "project", "reference", "general". Defaults to "general".
| Name | Required | Description | Default |
|---|---|---|---|
| text | Yes | ||
| category | No | general |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Without annotations, the description carries full burden. It states the data is saved to 'persistent memory,' indicating it persists across sessions. However, it does not disclose details like whether duplicates are avoided or if there are limits. The behavior is adequately but minimally described.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise: four sentences front-load the purpose, then provide usage guidance, then parameter details. No fluff or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (two parameters) and presence of an output schema, the description covers key aspects: purpose, when to use, and parameter meanings. It does not describe return values, but the output schema presumably handles that.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds significant value beyond the schema: for 'text', it explains what to store; for 'category', it lists the valid options and default. Since schema coverage is 0%, this fully compensates and clarifies usage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Save'), the resource ('a fact, observation, or piece of context'), and the destination ('persistent memory'). It effectively differentiates from siblings like 'recall' and 'forget' by specifying this tool is for storing information.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explicitly says 'Use this when you learn something important about the user...' giving clear context for usage. It does not provide explicit exclusions or mention alternatives, but the sibling list implies other tools serve different purposes.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v0.2.0forgetget_personajournallist_memoriesrecallrecent_journalsrememberEach tool has a clear, distinct purpose: create (remember), read (list_memories, recall, get_persona, recent_journals), delete (forget), and journaling (journal). No two tools appear to do the same thing, even list_memories and recall are differentiated by browsing vs. searching.
Names mix patterns: verbs alone (forget, recall, remember, journal), verb+noun (get_persona, list_memories), and adjective+noun (recent_journals). While still readable, the lack of a uniform convention introduces minor confusion.
7 tools cover the essential operations for a memory system—create, read, delete, and journaling—without being excessive. Each tool feels justified and contributes to the server's purpose.
Core CRUD is mostly present, but update is missing (memories and journals can only be overwritten by deletion+recreation). This is a minor gap that agents can work around, so the surface is nearly complete.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Persistent AI memory shared across Claude, ChatGPT, coding agents, and compatible MCP clients.
Persistent memory for Claude Code and Cursor. Stop re-explaining your project every session.
Private persistent memory for Claude, ChatGPT & Gemini via MCP - semantic search, zero-code setup.
Persistent memory for AI agents across Claude, ChatGPT and any MCP client.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/Simple4uhq/sae4u-memory'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
