refactor(plugin): rename mem0-codex skill to mem0-mcp

The skill content is runtime-agnostic — same protocol applies to Claude Code, Cursor, and Codex. The "codex" name was a vestige from when Codex was the only runtime delivering this guidance via skill (because Codex didn't have hooks yet). Now all three runtimes run the same hook plus load the same skill, so name it after the surface it actually documents: the mem0 MCP tool protocol.
2026-04-30 15:29:19 -07:00
parent efd33d9791
commit 875eedfbac
1 changed files with 6 additions and 5 deletions
@@ -0,0 +1,123 @@
+---
+name: mem0-mcp
+description: >
+  Mem0 memory protocol for agents using the mem0 MCP tools (Claude Code, Cursor,
+  Codex, and any other MCP-aware runtime). Decide deliberately when memory context
+  would help, run targeted searches with metadata filters when it would, and store
+  key learnings as work completes. Use the mem0 MCP tools (add_memory,
+  search_memories, get_memories, etc.) for all memory operations.
+---
+
+# Mem0 MCP Memory Protocol
+
+You have access to persistent memory via the mem0 MCP tools. Follow this protocol to maintain context across sessions.
+
+## On every new task
+
+Decide whether persistent memory context would improve your response, then act accordingly. Don't search by default — search deliberately.
+
+### Decide: search or skip?
+
+**Search WHEN** the user:
+- references past work, decisions, or things "we" built
+- asks "how should we...", "best way to...", or any decision-style question
+- hits an error, bug, or asks for debugging help
+- requests work that touches their stack, tools, conventions, or preferences
+- starts a non-trivial task in a known project
+
+**Skip WHEN:**
+- the prompt is an acknowledgement or continuation ("ok", "thanks", "continue")
+- the user is *stating* new info — that's a write trigger (`add_memory`), not a search
+- it's a pure syntax / factual question answerable from general knowledge
+- you already searched this scope earlier in the turn
+
+Empty results are normal. Proceed without context — they don't mean the system is broken.
+
+### How to search well
+
+When you do search, run **2–4 parallel** `search_memories` calls at different angles instead of one query echoing the user's prompt.
+
+**Query phrasing:**
+- Use **nouns**, not sentences. `"auth module decisions"` beats `"what did we decide about auth"`.
+- Strip conversational filler. *"remember when we picked Postgres?"* → search `"Postgres choice"`.
+- Use entity names, not pronouns. Resolve "that thing" from recent context first.
+- Don't search on meta-questions ("what was that?") — use recent context or `get_memories` ordered by `created_at`.
+
+**Metadata filters** match the same `metadata.type` values written under "After completing significant work" below:
+
+| Filter | Use for |
+|--------|---------|
+| `{"metadata.type": "decision"}` | design / architecture / "how should we" questions |
+| `{"metadata.type": "anti_pattern"}` | debugging, error handling, things that failed before |
+| `{"metadata.type": "user_preference"}` | tooling, stack, style — always include for code work |
+| `{"metadata.type": "convention"}` | established patterns in this project |
+
+Combine with `user_id` using AND:
+```python
+filters={"AND": [{"user_id": "alice"}, {"metadata.type": "decision"}]}
+```
+
+### Worked example
+
+User asks: *"Refactor the auth module to use JWT."*
+
+Don't:
+```python
+search_memories(query="Refactor the auth module to use JWT")
+# Hits whatever shares words. Misses prior decisions and preferences.
+```
+
+Do (parallel):
+```python
+search_memories(query="auth module decisions",
+                filters={"AND": [{"user_id": "alice"}, {"metadata.type": "decision"}]})
+search_memories(query="JWT", filters={"user_id": "alice"})
+search_memories(query="auth refactor failures",
+                filters={"AND": [{"user_id": "alice"}, {"metadata.type": "anti_pattern"}]})
+search_memories(query="auth",
+                filters={"AND": [{"user_id": "alice"}, {"metadata.type": "user_preference"}]})
+```
+
+## After completing significant work
+
+Extract key learnings and store them using the `add_memory` tool:
+
+- **Decisions made** -> Include metadata `{"type": "decision"}`
+- **Strategies that worked** -> Include metadata `{"type": "task_learning"}`
+- **Failed approaches** -> Include metadata `{"type": "anti_pattern"}`
+- **User preferences observed** -> Include metadata `{"type": "user_preference"}`
+- **Environment/setup discoveries** -> Include metadata `{"type": "environmental"}`
+- **Conventions established** -> Include metadata `{"type": "convention"}`
+
+Memories can be as detailed as needed -- include full context, reasoning, code snippets, file paths, and examples. Longer, searchable memories are more valuable than vague one-liners.
+
+## Before losing context
+
+If context is about to be compacted or the session is ending, store a comprehensive session summary:
+
+```
+## Session Summary
+
+### User's Goal
+[What the user originally asked for]
+
+### What Was Accomplished
+[Numbered list of tasks completed]
+
+### Key Decisions Made
+[Architectural choices, trade-offs discussed]
+
+### Files Created or Modified
+[Important file paths with what changed]
+
+### Current State
+[What is in progress, pending items, next steps]
+```
+
+Include metadata: `{"type": "session_state"}`
+
+## Memory hygiene
+
+- Do NOT write to MEMORY.md or any file-based memory. Use mem0 MCP tools exclusively.
+- Only store genuinely useful learnings. Skip trivial interactions.
+- Use specific, searchable language in memory content.