Memstack

MemStack

Persistent memory for AI agents. Claude Code and Codex share one memory per project, and your own agents get the same pipeline: store, retrieve, summarize, and prune.

Website and install guides: [memstack.stalewell.com](https://memstack.stalewell.com/)

Tell one agent how your project works. The other already knows. Claude Code learns a convention; a new Codex session recalls it and gets the task right:

npm install -g @memstack/cli @memstack/mcp better-sqlite3@^11.10.0   # MemStack never installs storage drivers

memstack init # LLM provider (optional) + store memstack connect claude-code memstack connect codex

Every session then starts with the project's key memories, and both agents save what you ask them to remember. How harness memory works.

Building your own agent?

# Use MemStack in your application

npm install @memstack/core

Give your coding agents the MemStack skill (-g: every project; omit it for this project only)

npx skills add isiomaC/memstack -g

@memstack/core is the runtime SDK; the Agent Skill teaches compatible coding agents how to integrate and operate MemStack correctly. Without -g, the skill installs into the current project (.agents/skills/, plus a .claude/skills/ link for Claude Code). Update it later with npx skills update.

The problem: AI agents forget. Every interaction starts from zero. You either stuff everything into the context window (expensive, slow, degrades output quality) or the agent has no memory of past conversations.

What MemStack does: A persistent memory pipeline that lives between your agent and the LLM. It stores every interaction, retrieves only what's relevant, summarizes old memories to save tokens, and prunes stale ones automatically. One method call, no infrastructure required.

Think of it as the open-source alternative to Mem0 — pluggable storage, bring your own LLM, zero vendor lock-in.

---

Table of Contents

• Why MemStack
• Quick Start
• Harness Memory (Claude Code & Codex)
• How it works
• Commands
• What connect changes
• Projects
• Storage
• Troubleshooting
• The Memory Pipeline
• Store
• Retrieve
• Compile Context
• Summarize
• Prune
• Real-World Use Cases
• Support Agent
• RAG Pipeline
• Multi-User Chatbot
• Memory Type Reference
• Retrieval Strategies
• Embeddings
• Adapters
• LLM Adapters
• Embedding Adapters
• Storage Adapters
• Full API Reference
• MemStack Client
• Memory Subsystem
• Export / Import
• Health & Close
• Harness Memory API
• Configuration
• Harness configuration file
• Advanced Usage
• Custom Storage
• Custom LLM / Embedding
• Event Hooks
• LongMemEval-S Retrieval Benchmark
• Development
• Setup & Tests
• Debugging
• Publishing to npm
• Contributing
• License

---

Why MemStack

LLMs have context windows, not memory. The difference matters.

What MemStack handles that raw vector DBs don't:

• Summarization — compress 100 old interactions into one paragraph, keep meaning, save tokens
• Recency weighting — recent memories matter more; MemStack sorts them higher
• Importance scoring — not all memories are equal; high-importance ones survive pruning
• Deduplication — identical or near-identical memories are collapsed in context assembly
• Token budget — compileContext() tells you how many tokens you're spending before the LLM call
• Memory-type routing — interactions, summaries, observations treated differently at retrieval time
• Auto-pruning — old, low-importance memories clean themselves up

---

Quick Start

Claude Code and Codex

Persistent memory across agent harnesses: what you tell Claude Code, Codex recalls in the same project, and the reverse.

npm install -g @memstack/cli @memstack/mcp better-sqlite3@^11.10.0  # MemStack never installs storage drivers for you

memstack init # choose an LLM provider and a store memstack connect claude-code memstack connect codex

Then, in Claude Code: "Remember that this project uses Hono." In Codex, in the same repository: "What framework does this project use?" Codex answers Hono. See Harness Memory for how it works.

As a library

npm install @memstack/core

OpenAI

import { MemStack, OpenAILLMAdapter, OpenAIEmbeddingAdapter, InMemoryStorageAdapter } from "@memstack/core";

const llm = new OpenAILLMAdapter({ apiKey: process.env.OPENAI_API_KEY! });

const memstack = new MemStack({ llm, embedding: new OpenAIEmbeddingAdapter({ apiKey: process.env.OPENAI_API_KEY! }), storage: new InMemoryStorageAdapter(), });

DeepSeek (no embeddings)

DeepSeek provides chat completions but has no embedding API. Use the OpenAI-compatible LLM adapter with baseURL and omit the embedding adapter — retrieval falls back to keyword + recency + importance ranking. You still get the full pipeline: store, summarize, prune, and compileContext.

import { MemStack, OpenAILLMAdapter, InMemoryStorageAdapter } from "@memstack/core";

const llm = new OpenAILLMAdapter({ apiKey: process.env.DEEPSEEK_API_KEY!, baseURL: "https://api.deepseek.com/v1", defaultModel: "deepseek-flash", });

const memstack = new MemStack({ llm, storage: new InMemoryStorageAdapter(), // No embedding adapter — retrieval uses keyword matching });

OpenRouter / Together AI / any OpenAI-compatible API

Same pattern — change baseURL and defaultModel:

// OpenRouter

const llm = new OpenAILLMAdapter({ apiKey: process.env.OPENROUTER_API_KEY!, baseURL: "https://openrouter.ai/api/v1", defaultModel: "openai/gpt-4o-mini", });

// Together AI const llm = new OpenAILLMAdapter({ apiKey: process.env.TOGETHER_API_KEY!, baseURL: "https://api.together.xyz/v1", defaultModel: "meta-llama/Llama-3.3-70B-Instruct-Turbo", });

// Gemini (OpenAI-compatible endpoint) const llm = new OpenAILLMAdapter({ apiKey: process.env.GEMINI_API_KEY!, baseURL: "https://generativelanguage.googleapis.com/v1beta/openai", defaultModel: "gemini-2.0-flash", });

Store and retrieve

// 1. Store what happened

await memstack.memory.store({ actorId: "support-bot-42", content: "User reports login failing with error 503 on Chrome 125.", tags: ["login", "bug", "chrome"], importance: 0.8, });

// 2. Later, retrieve relevant context const memories = await memstack.memory.retrieve({ actorId: "support-bot-42", query: "login error", strategy: "hybrid", });

// 3. Assemble an LLM-ready context const ctx = await memstack.memory.compileContext({ actorId: "support-bot-42", maxTokens: 2000, });

const response = await llm.complete({ system: You are a support bot. Here is what you remember:\n${ctx.systemPrompt}, user: "The user is back and still can't log in. What do you do?", });

console.log(response.text); // "Based on our history, the user has been experiencing 503 errors on Chrome 125..."

// 4. Every 100 interactions, summarization triggers automatically. // Old interactions are compressed into a paragraph. Token costs stay flat.

---

Harness Memory (Claude Code & Codex)

Coding agents forget everything between sessions, and they don't share what they learn with each other. MemStack gives Claude Code and Codex one memory per project: a decision made with one agent is known to the other, and to every later session.

How it works

• Saving. Each agent gets five MemStack tools (memory_store, memory_retrieve, memory_get, memory_delete, memory_stats) through the MCP harness profile. When you say "remember that…", or the agent learns a durable fact, decision, preference, or rule, it calls memory_store. MemStack asks your LLM for a few topic tags, so "uses Hono" can later be found by "which framework?". If tagging fails, the memory is still saved.
• Recalling. A session-start hook loads the project's most important memories into every new session, so the agent starts out knowing them. During a session the agent calls memory_retrieve with plain questions. Recall runs locally with keyword ranking (BM25 with stemming) and never calls the LLM, so it is fast and works offline.
• Scope. Memories belong to the current project. Preferences that apply everywhere can be saved as global (scope: "global") and are recalled in every project. One project can never read or delete another's memories.
• Safety. Agents don't get bulk or destructive tools, and the LLM key stays in ~/.memstack/config.json (readable only by you), never in agent configs. Agents are told never to store secrets, and MemStack checks too: a memory that contains a credential (a private key, a cloud or source-host token, a JWT, a password in a connection string, a password = "..." assignment) is refused before the LLM or the store sees it, and the error names the kind of secret without repeating it. The check is pattern-based, so a secret in a format it doesn't know will pass; MEMSTACK_SECRET_POLICY=redact stores the memory with `[REDACT