Persistent memory for AI coding agents using Supermemory.

Your agent remembers what you tell it - across sessions, across projects.

• OpenCode - Plugin with hooks and tool integration
• Kimi CLI - Skill-based approach with CLI tool

OpenCode plugin for persistent memory.

bunx my-supermemory@latest install

Then get your API key from console.supermemory.ai and set it:

export SUPERMEMORY_API_KEY="sm_..."

Or let your agent do it - paste this into OpenCode:

Install my-supermemory by following https://raw.githubusercontent.com/dpolishuk/my-supermemory/main/README.md

bunx my-supermemory@latest install --no-tui

cat ~/.config/opencode/opencode.jsonc

{
  "plugin": ["my-supermemory"]
}

{
  "plugin": [
    "my-supermemory"
    // ... other plugins
  ]
}

{
  "plugin": ["my-supermemory"]
}

export SUPERMEMORY_API_KEY="sm_..."

{
  "apiKey": "sm_..."
}

opencode -c

On first message, the agent receives (invisible to user):

• User profile (cross-project preferences)
• Project memories (all project knowledge)
• Relevant user memories (semantic search)

Example of what the agent sees:

[SUPERMEMORY]

User Profile:
- Prefers concise responses
- Expert in TypeScript

Project Knowledge:
- [100%] Uses Bun, not Node.js
- [100%] Build: bun run build

Relevant Memories:
- [82%] Build fails if .env.local missing

The agent uses this context automatically - no manual prompting needed.

Say "remember", "save this", "don't forget" etc. and the agent auto-saves to memory.

You: "Remember that this project uses bun"
Agent: [saves to project memory]

Add custom triggers via keywordPatterns config.

Run /supermemory-init to explore and memorize your codebase structure, patterns, and conventions.

When context hits 80% capacity:

1. Triggers OpenCode's summarization
2. Injects project memories into summary context
3. Saves session summary as a memory

This preserves conversation context across compaction events.

API key is <private>sk-abc123</private>

Content in <private> tags is never stored.

The supermemory tool is available to the agent:

Scopes: user (cross-project), project (default)

Types: project-config, architecture, error-solution, preference, learned-pattern, conversation

Create ~/.config/opencode/supermemory.jsonc:

{
  // API key (can also use SUPERMEMORY_API_KEY env var)
  "apiKey": "sm_...",
  
  // Min similarity for memory retrieval (0-1)
  "similarityThreshold": 0.6,
  
  // Max memories injected per request
  "maxMemories": 5,
  
  // Max project memories listed
  "maxProjectMemories": 10,
  
  // Max profile facts injected
  "maxProfileItems": 5,
  
  // Include user profile in context
  "injectProfile": true,
  
  // Prefix for container tags
  "containerTagPrefix": "opencode",
  
  // Extra keyword patterns for memory detection (regex)
  "keywordPatterns": ["log\\s+this", "write\\s+down"],
  
  // Context usage ratio that triggers compaction (0-1)
  "compactionThreshold": 0.80
}

All fields optional. Env var SUPERMEMORY_API_KEY takes precedence over config file.

If you're using Oh My OpenCode, disable its built-in auto-compact hook to let supermemory handle context compaction:

Add to ~/.config/opencode/oh-my-opencode.json:

{
  "disabled_hooks": ["anthropic-context-window-limit-recovery"]
}

bun install
bun run build
bun run typecheck

Local install:

{
  "plugin": ["file:///path/to/my-supermemory"]
}

tail -f ~/.my-supermemory.log

Kimi CLI skill for persistent memory using Supermemory.

# 1. Install CLI tool
bun add -g kimi-supermemory

# 2. Set API key (get from console.supermemory.ai)
export SUPERMEMORY_API_KEY="sm_..."

# 3. Install skill
mkdir -p ~/.codex/skills/kimi-supermemory
curl -o ~/.codex/skills/kimi-supermemory/SKILL.md \
  https://raw.githubusercontent.com/dpolishuk/my-supermemory/main/kimi-supermemory/SKILL.md

Or let your agent do it - paste this into Kimi CLI:

Install my-supermemory by following https://raw.githubusercontent.com/dpolishuk/my-supermemory/main/README.md

# Step 1: Install CLI tool
bun add -g kimi-supermemory

# Step 2: Configure API key (ask user for key from console.supermemory.ai)
export SUPERMEMORY_API_KEY="sm_..."

# Step 3: Install skill file
mkdir -p ~/.codex/skills/kimi-supermemory
curl -o ~/.codex/skills/kimi-supermemory/SKILL.md \
  https://raw.githubusercontent.com/dpolishuk/my-supermemory/main/kimi-supermemory/SKILL.md

# Step 4: Verify installation
kimi-supermemory help
kimi-supermemory add "Test memory from setup" --type project-config
kimi-supermemory list

Unlike OpenCode's plugin system with automatic hooks, kimi-supermemory uses a skill-based approach:

1. SKILL.md - Contains instructions that teach the LLM when to save memories and how to use the CLI
2. CLI Tool - The kimi-supermemory command provides memory operations
3. LLM-Driven - The LLM reads the skill and decides when to save/retrieve memories

User: Remember that this project uses Bun instead of Node.js

LLM: [reads SKILL.md, sees "remember" trigger]
LLM: [executes] bunx kimi-supermemory@latest add "Uses Bun runtime 
      and package manager. Commands: bun install, bun run dev, bun test" 
      --type project-config
LLM: Got it! I've saved that this project uses Bun. I'll remember the 
      key commands: bun install, bun run dev, and bun test.

• project (default): Project-specific knowledge (build commands, architecture, conventions)
• user: Cross-project preferences (coding style, communication preferences)

• project-config: Tech stack, commands, tooling
• architecture: Codebase structure, components, data flow
• error-solution: Known issues and their fixes
• preference: Coding style preferences
• learned-pattern: Conventions specific to this codebase
• conversation: Session summaries

At the start of each session, the LLM should fetch context:

kimi-supermemory context

This returns formatted context including:

• User profile (cross-project preferences)
• Project knowledge (all project memories)
• Relevant user memories (semantic search based on session)

Example output:

[SUPERMEMORY]

User Profile:
- Prefers concise responses
- Expert in TypeScript

Project Knowledge:
- [100%] Uses Bun, not Node.js
- [100%] Build: bun run build

Relevant Memories:
- [82%] Build fails if .env.local missing

The skill teaches the LLM to detect trigger words:

• "remember", "memorize"
• "save this", "note this"
• "keep in mind", "don't forget"
• "learn this", "store this"
• "record this", "make a note"
• "take note", "jot down"
• "commit to memory"
• "remember that", "never forget"
• "always remember"

Custom patterns can be added via config.

API key is <private>sk-abc123</private>

Content in <private> tags is never stored.

Create ~/.config/kimi/supermemory.json:

{
  "apiKey": "sm_...",
  "similarityThreshold": 0.6,
  "maxMemories": 5,
  "maxProjectMemories": 10,
  "keywordPatterns": ["log\\s+this", "write\\s+down"]
}

All fields optional. Environment variable SUPERMEMORY_API_KEY takes precedence.

tail -f ~/.local/share/kimi-supermemory/log.txt

Both provide the same core memory capabilities!

MIT