Skip to content
Skills Library
AI & agents · Tool integration

remember

/remember

Save a durable fact, decision, or preference to memini. Use this skill proactively — do not wait to be asked — when the user says "remember this" or corrects you, after discovering a bug's root cause, after making an architectural decision, after learning a project convention or environment quirk, or whenever something learned in this session should outlive the session itself. The MCP tool is `memory_remember` on the bundled `memini` server.

Repository
memini ↗
Licence
AGPL-3.0
Last repository change
26.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
1
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 26.10.2026, without references to retired models or APIs.

Licence

AGPL-3.0, copyleft: przeróbki udostępniane innym muszą mieć tę samą licencję.

What to check before installing
  • SKILL.md zawiera komentarze HTML (1). Nie widać ich w podglądzie Markdown, a model je czyta.

What it does and when to use it

Save a durable fact, decision, or preference to memini. Use this skill proactively — do not wait to be asked — when the user says "remember this" or corrects you, after discovering a bug's root cause, after making an architectural decision, after learning a project convention or environment quirk, or whenever something learned in this session should outlive the session itself. The MCP tool is `memory_remember` on the bundled `memini` server.

Triggers from the description

remember this
Original author description

Save a durable fact, decision, or preference to memini. Use this skill proactively — do not wait to be asked — when the user says "remember this" or corrects you, after discovering a bug's root cause, after making an architectural decision, after learning a project convention or environment quirk, or whenever something learned in this session should outlive the session itself. The MCP tool is `memory_remember` on the bundled `memini` server.

How it works

  1. Result fields to check
  2. When to call
  3. When NOT to call
  4. Examples
Original SKILL.md headings · 128 lines, 1,128 words
SKILL.md preview
---
name: remember
description: >-
  Save a durable fact, decision, or preference to memini. Use this skill
  proactively — do not wait to be asked — when the user says "remember this"
  or corrects you, after discovering a bug's root cause, after making an
  architectural decision, after learning a project convention or environment
  quirk, or whenever something learned in this session should outlive the
  session itself. The MCP tool is `memory_remember` on the bundled `memini` server.
---

<!-- Save-policy invariants (when to call, when not, secrets exclusion) are
canonical in internal/api/mcp/mcp.go serverInstructions; keep this in sync. -->

# remember (memini)

memini is a memory service. To save a fact, call the `memory_remember` MCP
tool with:

- `content` (required) — the fact itself, atomic and self-contained
- `tier` — `semantic` for durable knowledge, `procedural` for how-to,
  `episodic` for events, `working` for transient notes; omit to let the server
  auto-classify
- `tags` (optional) — array of keywords for later search; tag a critical,
  always-relevant fact (the user's identity, a hard constraint) `pinned` so it
  surfaces in every session briefing
- `metadata.category` (optional) — a topic bucket so the memory can be browsed
  and filtered by subject later. This is orthogonal to `tier`: tier is the
  memory's _kind_, category is its _topic_. Any string is accepted, but pick one
  of the canonical values so filtering keeps working: `architecture_decisions`,
  `anti_patterns`, `task_learnings`, `tooling_setup`, `bug_fixes`,
  `coding_conventions`, `user_preferences`, `dependency_decisions`,
  `performance_findings`, `security_constraints`, `testing_patterns`,
  `data_model`, `api_contracts`, `deployment_runbook`, `team_norms`,
  `domain_glossary`, `experiment_results`.
- `visibility` (optional) — who should know this: `project` (default, this
  project only), `personal` (about the user, follows them everywhere), or an
  ancestor namespace name read off the `memory_briefing` Scope line (e.g. the
  team or org level) to share it up that chain. An unrecognized ancestor name
  errors listing the valid chain. Ignored for `episodic`/`working` writes —
  those always stay in the project regardless of `visibility`, so a session
  digest can never pollute a shared ancestor or the user's personal namespace.
- `summary` (optional) — short summary; defaults to first 200 chars of content
- `confidence` (optional) — 0..1 for durable (`semantic`/`procedural`) facts;
  omit to let it start uncorroborated and earn trust as the fact recurs. Durable
  facts gain confidence each time they're re-observed and lose it if never
  recalled, so saving a real, lasting fact as `semantic` (not `working`) is what
  lets it rise above one-off noise over time.
- `importance` (optional) — 0..1, and a deliberate marker rather than a rating. **Omit it for ordinary facts**: the tier seed (0.6 durable, 0.3 episodic) is the correct default, and the server may assess a value itself. Set it only to mark a fact as unusually load-bearing — `>= 0.75` is a real threshold that reserves scarce reranker-pool slots at recall time and grants immunity from staleness demotion, so spend it on a standing directive, a hard constraint, a bug's root cause, or a user correction, and leave ordinary decisions and observations unset. Inflating it is worse than omitting it: the reserved band is small and fixed, so marking everything important crowds out what genuinely is. An explicit value always wins and permanently clears the server's own assessment (`assessed_importance`), so it is the one signal a model authoring a memory can set that will never be second-guessed.

## Result fields to check

- `stored: false` — the write was dropped by the episodic value gate (low-signal
  content, e.g. too short); not an error, just not saved. Rephrase with more
  substance if it's actually worth keeping.
- `reinforced: true` — the fact was already known: no new memory was created, the
  existing one was strengthened, and `id` names that pre-existing memory rather
  than anything you just wrote. Don't report it to the user as a new save, and be
  careful updating or forgetting that id.
- `merge_hint` — present when the content nearly duplicates an existing memory
  (`merge_hint.similar_id`, `.similar_content`, `.score`). The new content was
  still stored as its own memory; call the `memory_update` MCP tool with
  `id: merge_hint.similar_id` to fold the new information into the existing
  memory instead of leaving two near-duplicates, or ignore the hint to keep
  both as-is.
- `degraded: "pending_embed"` — embeddings were unavailable at write time, so
  the memory was stored without a vector (still keyword-searchable). It is
  backfilled with a vector automatically in the background — don't retry the
  write or treat this as a failure.

## When to call

Do not wait to be asked. Capture at the moment of learning, not at session end.

- The user says "remember this", "save this", "don't forget", "note that",
  "next time", "going forward", "always/never do X". Call `memory_remember`
  FIRST, then acknowledge. On an explicit request, save unconditionally —
  even if it seems trivial, fleeting, or already stored (the server
  reinforces or merges near-duplicates; that is its job, not yours).
- The user corrects you. A correction IS a preference — capture it.
- You make an architectural decision (e.g. "we chose jose over jsonwebtoken
  for Edge compatibility"). Capture the _why_, not just the _what_.
- You discover a non-obvious bug or root cause worth flagging next time.
- You learn a project convention (test layout, deploy command, code style).
- You hit an environment or tool quirk (e.g. "tests need DOCKER_HOST unset
  on this machine").
- You learn a non-obvious command or workflow the project depends on.

## When NOT to call

- Secrets, credentials, API keys, tokens — never, even on explicit request
  (this outranks the save-unconditionally rule; explain and point to a
  secret manager instead).
- Transient session state (what file you just opened, the branch you happen
  to be on mid-task).
- Task progress or TODO state — the plugin's session digests capture
  activity automatically; memories are for what stays true.
- Facts already in `CLAUDE.md`, `.cursorrules`, or project docs, or
  trivially recoverable from the codebase.
- Text the user is merely asking you to translate, edit, or summarize —
  content passing through your hands is not a fact about the user or
  project.

## Examples

Call with tier `semantic`, `metadata.category` `architecture_decisions`:

> The auth middleware uses `jose` rather than `jsonwebtoken` because we
> deploy to Cloudflare Workers, which can't run jsonwebtoken's C++ bindings.

Call with tier `procedural`:

> To regenerate the embedding cache, run `mise run embeddings:warm`.

Call with tier `episodic`:

> The 2026-06-09 outage was caused by a Postgres connection-pool
> exhaustion under load. The fix was raising `max_connections` to 200
> and adding pgbouncer.

State facts, not commands — a memory is a claim about the world, not an
instruction to your future self:

- Good: "User prefers pnpm over npm in all their projects" (declarative,
  visibility `personal`)
- Bad: "Always use pnpm" (a command — future recall cannot tell where it
  applies or why)
- Good: "TestAuthRefresh flakes because of a hard-coded 100ms timeout in
  auth/refresh_test.go; the fix pattern is deadline-based waiting"
- Bad: "Fixed a flaky test today" (not self-contained, no future value)

If a stored memory turns out to be wrong or outdated, fix it immediately:
correct it in place with `memory_update`, or delete it with `memory_forget`
if it should not exist. Never leave a memory you know is incorrect in place.

Keep memories atomic — one fact per call. Search works better on small,
focused records than on walls of text.

Versions

RepositoryScoreLicence
This page · eleboucher/memini100AGPL-3.0
yonatangross/orchestkit100MIT
langchain-ai/deepagents100MIT
zereight/gitlab-mcp100MIT
stxrmik/antigravity-plus100MIT
rohitg00/agentmemory100Apache-2.0
ffMathy/hey-jarvis100MIT
alirezarezvani/claude-skills100MIT
cristobaltormo/cortex-md100MIT

Database snapshot: 13.11.2026 · package version c8a6ba9c24fa (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100traceary-memory-remember
    Use ONLY when the user explicitly asks to remember a specific durable fact, decision, constraint, or preference. Trigger phrases — "覚えておいて", "remember that", "for the record", "save this as", "記憶しておいて", "メモして". Do NOT use for generic notes, status updates, or session summaries.…
  • 100memory
    Persistent long-term memory via memini. Use to remember durable facts, decisions, and preferences, and to recall relevant context before acting. Triggers when the user says "remember", "what do you know about", or when starting a task that may have prior context.
  • 90recap
    Summarize what's known about a project, area, or topic from memini. Use this skill when the user asks "catch me up on X", "what's the state of Y", or "summarize what we know about Z". Builds on recall with a larger limit and tiered grouping. The MCP tool is `memory_recall` on…
  • 100mem0-remember
    Stores a memory verbatim from user input with appropriate type classification and metadata. Use when the user says remember this, save this, store this, note that, or explicitly asks to record a decision, preference, convention, or learning.
  • 100capture
    Save a memory to Wenlan in flow, or save something from this conversation as one note when the user asks for a note. Use proactively when the user states a preference, makes a decision, corrects you, or shares a durable fact. Invoked as `/capture <content>`.
  • 100capture
    Save a memory to Wenlan in flow, or save something from this conversation as one note when the user asks for a note. Use proactively when the user states a preference, makes a decision, corrects you, or shares a durable fact. Invoked as `/capture <content>`.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.