Can teams share a claude-mem knowledge base?

Yes, through the optional cloud sync feature. Teams can sync memory databases to cmem.ai for shared context across team members. This is particularly powerful for onboarding new team members who benefit from accumulated team knowledge.

claude-mem: The Open-Source AI Agent Plugin With 92,000+ GitHub Stars That Gives Your Coding Agent Persistent Memory Across Sessions

Q: How much storage does claude-mem use on my machine?

claude-mem is remarkably storage-efficient. A typical development project accumulates roughly 50-200 KB per week of active development. Even after months of daily use, most developers find their data directory stays well under 50 MB.

Q: What happens to my data if I uninstall claude-mem?

Your data remains intact on your machine in standard SQLite format. Uninstalling the plugin simply stops the automatic capture and injection — it never deletes your accumulated knowledge. If you reinstall later, all your previous context is still available.

Q: How does claude-mem handle sensitive information like API keys?

claude-mem includes built-in privacy controls. Wrap sensitive content in private tags to exclude it from storage. The AI compression layer also recognizes and redacts common patterns like API keys and passwords. The local-first architecture means sensitive code never leaves your environment.

Q: Does claude-mem slow down my AI coding sessions?

No. claude-mem hooks are non-blocking. Observation capture happens asynchronously, and context injection adds approximately 200-500ms. The progressive disclosure system actually makes sessions faster by reducing total tokens needed for context.

Discover claude-mem, the breakthrough open-source plugin that solves AI agent amnesia by automatically capturing, compressing, and injecting persistent context across coding sessions. With 92,000+ GitHub stars, it works with Claude Code, OpenClaw, Codex, Gemini, and more.

CoddyKit TeamAug 27, 2026 · 13 min read · 2,506 words

claude-mem: The Open-Source AI Agent Plugin With 92,000+ GitHub Stars That Gives Your Coding Agent Persistent Memory Across Sessions

⚡ Quick Answer: claude-mem is an open-source plugin with 92,000+ GitHub stars that automatically captures everything your AI coding agent does during sessions, compresses it using AI-generated semantic summaries, and injects relevant context back into future sessions. It solves the "agent amnesia" problem that plagues every developer using Claude Code, OpenClaw, Codex, or other AI coding assistants — giving your agent persistent memory without any manual effort.

92K+

GitHub Stars

8K+

Forks

30+

Languages Supported

The AI Agent Memory Problem Every Developer Faces

If you've ever worked with AI coding assistants — Claude Code, GitHub Copilot, OpenClaw, Codex, or any other — you've hit the wall: session amnesia. Your agent spends 30 minutes understanding your codebase, fixing a complex bug, or building a feature... and then the session ends. The next time you start a new conversation, it's back to square one.

You re-explain the project architecture. You re-describe that tricky authentication flow. You re-contextualize why you chose PostgreSQL over MongoDB. It's exhausting, inefficient, and frankly, it defeats the purpose of having an intelligent coding partner.

This isn't just an inconvenience — it's a productivity killer. Every minute spent re-teaching your AI agent is a minute not spent shipping code. And in 2026, with AI agents handling increasingly complex tasks across multi-file refactors and architectural decisions, the memory gap has become the single biggest bottleneck in AI-assisted development.

Enter claude-mem: the open-source solution that's amassed over 92,000 GitHub stars by solving this exact problem. Let's dive deep into what makes it work, how to set it up, and why it's becoming essential infrastructure for every AI-powered development workflow.

What Is claude-mem and How Does It Work?

claude-mem is a persistent memory plugin for AI coding agents. It operates through an elegant system of lifecycle hooks, automatic observation capture, and intelligent context injection — all running silently in the background without any manual intervention from the developer.

Here's the core concept: instead of trying to store raw conversation logs (which would be massive and token-expensive), claude-mem captures observations — distilled, semantically meaningful insights about your project, your code, and the decisions made during each session. These observations are stored in a local SQLite database with full-text search capabilities and a Chroma vector database for semantic similarity matching.

🏗️ Core Architecture

5 Lifecycle Hooks → Observation Capture → SQLite + Chroma DB → Worker Service → Context Injection

SessionStart → UserPromptSubmit → PostToolUse → Stop → SessionEnd

The 5 Lifecycle Hooks Explained

claude-mem doesn't just dump everything into storage. It uses a sophisticated hook system that captures information at the right moments:

// 1. SessionStart - Injects relevant context from past sessions
// 2. UserPromptSubmit - Captures user intent and context
// 3. PostToolUse - Records tool execution observations
// 4. Stop - Generates session summary
// 5. SessionEnd - Finalizes and compresses data

// Example observation captured:
{
  "type": "architecture_decision",
  "content": "Chose Redis over Memcached for session storage because we need persistence across restarts and pub/sub for real-time notifications",
  "project": "e-commerce-api",
  "files": ["src/config/cache.ts", "src/middleware/session.ts"],
  "timestamp": "2026-08-27T14:32:00Z"
}

The key insight here is progressive disclosure — claude-mem doesn't inject everything into every new session. Instead, it uses a 3-layer retrieval system that starts with compact indexes (~50-100 tokens per result) and only fetches full details (~500-1,000 tokens) when the agent actually needs them. This keeps token costs manageable while ensuring relevant context is always available.

Installation: Getting Started in Under 60 Seconds

One of claude-mem's strongest selling points is how effortlessly it integrates into your existing workflow. There's no complex configuration, no API keys to manage, and no changes to how you interact with your AI agent.

For Claude Code Users

# One-line install — that's it
npx claude-mem install

# Or install from the plugin marketplace inside Claude Code:
/plugin marketplace add thedotmack/claude-mem
/plugin install claude-mem

# Restart Claude Code. Context from previous sessions
# will automatically appear in new sessions.

For OpenCode Users

npx claude-mem install --ide opencode

For OpenClaw Gateway Users

# Installs on your OpenClaw gateway with full integration
curl -fsSL https://install.cmem.ai/openclaw.sh | bash

# Handles dependencies, plugin setup, AI provider config,
# worker startup, and optional real-time observation feeds

For Antigravity CLI

npx claude-mem install --ide antigravity

⚠️ Important Note: While claude-mem is published on npm, running npm install -g claude-mem only installs the SDK/library — it does not register plugin hooks or set up the worker service. Always use npx claude-mem install or the /plugin commands for a full installation.

The 3-Layer Search Workflow: Token-Efficient Memory Retrieval

What truly sets claude-mem apart from naive "save everything" approaches is its 3-layer progressive disclosure workflow. This architecture was designed specifically to minimize token usage while maximizing context relevance — a critical balance for production AI agent workflows.

Layer 1: Search (Compact Index)

The search tool returns a compact index of results, each consuming only ~50-100 tokens. This gives the agent enough information to decide which memories are relevant without wasting context window on unnecessary details.

// Step 1: Search for relevant memories
search(
  query: "authentication bug OAuth",
  type: "bugfix",
  limit: 10
)

// Returns compact index with IDs:
// #123: "Fixed OAuth2 callback URL mismatch in production..."
// #456: "Resolved JWT token expiry race condition..."
// #789: "Debugged session cookie not persisting across..."

Layer 2: Timeline (Chronological Context)

Once the agent identifies interesting observations, the timeline tool reveals what was happening around those specific moments — providing temporal context that's often crucial for understanding why decisions were made.

Layer 3: Get Observations (Full Details)

Only when the agent has identified specific relevant IDs does it fetch full details, consuming ~500-1,000 tokens per result. This selective approach yields approximately 10x token savings compared to injecting all potentially relevant context.

// Step 3: Fetch full details ONLY for relevant IDs
get_observations(ids: [123, 456])

// Returns complete observations with:
// - Full content and context
// - Related files and code snippets
// - Decision rationale
// - Outcome and follow-up actions

💡 Why This Matters: With context windows still being a finite and expensive resource, the 10x token savings from progressive disclosure means your agent can maintain awareness of far more historical context without hitting token limits or incurring excessive API costs.

Real-World Example: Multi-Week Feature Development

Let's walk through a realistic scenario that demonstrates claude-mem's value in practice. Imagine you're building a real-time notification system for your e-commerce platform over the course of several weeks.

Week 1: Initial Architecture

// Session 1: You and your AI agent design the notification system
// claude-mem automatically captures:

Observation #1:
  "Chose WebSocket + Redis Pub/Sub architecture for real-time
   notifications. Considered SSE but needed bidirectional communication
   for delivery confirmations. Redis chosen over RabbitMQ for simpler
   deployment and existing Redis usage in the stack."

Observation #2:
  "Created NotificationService in src/services/notifications/
   with three event types: ORDER_UPDATE, PRICE_DROP, RESTOCK_ALERT.
   Each notification has priority levels: critical, normal, low."

Observation #3:
  "Decided to batch non-critical notifications (max 5 second delay)
   to reduce WebSocket message volume. Critical notifications
   (order issues) send immediately."

Week 2: Bug Fix Session (New Conversation)

Without claude-mem, you'd need to re-explain the entire architecture. With claude-mem, the agent automatically retrieves relevant context:

// Session 2: New conversation, 7 days later
// You: "Users are reporting delayed notifications for orders"

// claude-mem auto-injects from Session 1:
// - WebSocket + Redis Pub/Sub architecture context
// - Batch delay configuration (5 second max for non-critical)
// - Priority level definitions

// Agent immediately understands the system and diagnoses:
"Based on the notification batching system we set up last week,
the delay you're seeing is likely from the 5-second batch window
on non-critical notifications. Let me check if ORDER_UPDATE events
are being classified correctly..."

Week 3: Scaling Discussion (Yet Another New Conversation)

// Session 3: Different developer, same project
// You: "We need to handle 10x more concurrent users"

// claude-mem retrieves context from BOTH previous sessions:
// - Original architecture decisions (Week 1)
// - Bug fix insights (Week 2)

// Agent has full project history and can provide informed scaling advice:
"Given your WebSocket + Redis Pub/Sub setup and the batching
system we optimized last week, here are the scaling paths:
1. Redis Cluster for horizontal Pub/Sub scaling
2. Connection pooling with sticky sessions for WebSocket
3. Consider moving batch processing to a worker queue..."

This is the magic of persistent context: every session builds on every previous session, creating an ever-growing knowledge base that makes your AI agent exponentially more useful over time.

Key Benefits of claude-mem for Development Teams

🧠 Persistent Memory Across Sessions Context survives across sessions automatically. No more re-explaining your project architecture, tech stack decisions, or coding conventions every time you start a new conversation.

📊 Progressive Disclosure Architecture The 3-layer search workflow ensures token-efficient context retrieval, starting with compact indexes and only fetching full details when needed — saving up to 10x on token usage.

🔍 Intelligent Semantic Search Powered by Chroma vector database for semantic similarity matching combined with SQLite FTS5 for keyword search. Find relevant context whether you search by concept or exact terms.

🔒 Privacy Control with <private> Tags Wrap sensitive content in <private> tags to exclude it from storage. Perfect for API keys, passwords, or proprietary business logic you don't want persisted.

🤖 Zero-Configuration Operation Once installed, claude-mem works entirely automatically. No manual tagging, no explicit "save this" commands, no configuration files to maintain. It just works.

🌐 Universal Compatibility Works with Claude Code, OpenClaw, Codex, Gemini, Hermes, Copilot, OpenCode, Antigravity CLI, and more. One tool for your entire AI agent ecosystem.

🖥️ Web Viewer UI Browse your agent's memory stream in real-time through a built-in web interface. See exactly what's being captured, search history, and debug context injection.

☁️ Optional Cloud Sync Back up your memories to cmem.ai for cross-device access. The worker syncs on write — no daemon required for cloud synchronization.

Configuration and Customization

While claude-mem works out of the box with sensible defaults, power users can fine-tune every aspect of its behavior through the ~/.claude-mem/settings.json configuration file.

{
  "AI_MODEL": "claude-sonnet-4-20250514",
  "WORKER_PORT": 3456,
  "DATA_DIR": "~/.claude-mem/data",
  "LOG_LEVEL": "info",
  "CONTEXT_INJECTION": {
    "max_tokens": 4000,
    "relevance_threshold": 0.7,
    "include_timeline": true
  },
  "CLAUDE_MEM_MODE": "code"
}

Multi-Language and Multi-Mode Support

claude-mem supports multiple workflow modes and languages via the CLAUDE_MEM_MODE setting. This is particularly useful for international development teams:

// Available modes:
"code"      // Default English mode
"code--zh"  // Simplified Chinese (built-in)
"code--ja"  // Japanese mode

// Language-specific modes follow the pattern:
// code--[lang] where [lang] is ISO 639-1 code
// e.g., code--es (Spanish), code--tr (Turkish)

Privacy and Security Considerations

In an era where data privacy is paramount — especially for proprietary codebases and enterprise applications — claude-mem takes a privacy-first approach:

Local-first storage: All data is stored locally in SQLite and Chroma databases on your machine by default
Private tags: Wrap any content in <private> tags to exclude it from storage entirely
No external API calls for storage: The worker service runs locally, processing observations without sending data to external servers
Optional cloud sync: Cloud backup to cmem.ai is entirely opt-in, not default
Full data ownership: Your memories are stored in standard SQLite format — you can export, backup, or delete them at any time

🔐 Enterprise-Ready: For teams working on proprietary codebases, claude-mem's local-first architecture means sensitive code never leaves your development environment unless you explicitly opt into cloud sync.

Comparison: claude-mem vs. Manual Context Management

Before claude-mem, developers relied on various manual approaches to maintain context across AI coding sessions. Here's how claude-mem compares:

Approach	Effort	Reliability	Token Efficiency
Manual CLAUDE.md files	High (manual upkeep)	Low (easily outdated)	Poor (static content)
Copy-pasting context	Very High	Very Low	Worst (duplicate tokens)
Conversation exports	Medium	Medium	Poor (raw logs)
claude-mem	Zero (automatic)	High (AI-curated)	Excellent (10x savings)

🚀 Ready to Give Your AI Agent Persistent Memory?

Start building smarter with claude-mem today. Install in under 60 seconds and never lose context again.

📚 Level up your AI development skills with CoddyKit courses

Frequently Asked Questions

1. Does claude-mem work with AI agents other than Claude?

Yes! Despite its name, claude-mem is designed as a universal persistent memory solution. It works with Claude Code, OpenClaw, Codex, Gemini, Hermes, GitHub Copilot, OpenCode, Antigravity CLI, and any AI coding agent that supports plugin hooks. The core architecture is agent-agnostic — it captures observations from tool usage patterns that exist across all modern AI coding assistants.

2. How much storage does claude-mem use on my machine?

claude-mem is remarkably storage-efficient thanks to its AI-compressed observation format. A typical development project accumulates roughly 50-200 KB per week of active development. The SQLite database with FTS5 indexing adds minimal overhead. Even after months of daily use, most developers find their claude-mem data directory stays well under 50 MB — far smaller than a single git repository.

3. Can I use claude-mem across multiple projects simultaneously?

Absolutely. claude-mem automatically tags observations with project context, so memories from different codebases don't interfere with each other. When you start a session in Project A, the agent retrieves context primarily from Project A's history (while still having access to cross-project insights when relevant). The search tools support filtering by project, type, date range, and more.

4. What happens to my data if I uninstall claude-mem?

Your data remains intact on your machine in the ~/.claude-mem/data/ directory. claude-mem stores everything in standard SQLite format, so you can browse, export, or migrate your data using any SQLite client. Uninstalling the plugin simply stops the automatic capture and injection — it never deletes your accumulated knowledge. If you reinstall later, all your previous context is still available.

5. How does claude-mem handle sensitive information like API keys or passwords?

claude-mem includes built-in privacy controls. Wrap any sensitive content in <private> tags during your conversation, and it will be excluded from storage entirely. Additionally, the AI compression layer is trained to recognize and redact common patterns like API keys, passwords, and tokens. For enterprise users, the local-first architecture means sensitive code never leaves your development environment unless you explicitly opt into cloud sync.

6. Does claude-mem slow down my AI coding sessions?

No. claude-mem's hooks are designed to be non-blocking. Observation capture happens asynchronously via the worker service, so there's no perceptible latency during your coding sessions. Context injection at session start adds approximately 200-500ms — barely noticeable. The 3-layer progressive disclosure system actually makes sessions faster by reducing the total tokens needed for context, which means faster API responses.

Yes, through the optional cloud sync feature. Teams can sync their memory databases to cmem.ai, allowing shared context across team members working on the same project. This is particularly powerful for onboarding — new team members can benefit from the collective knowledge accumulated by the entire team. The sync is encrypted and access-controlled, with each team member maintaining their own local cache for fast access.

ProgrammingTutorialCoddyKit