@raajvamsy/memorylayer

memorylayer

Persistent, searchable memory for AI agents — shared across every agent, chat, and machine. Local-first. MCP-native. One command, no Docker.

Quickstart

npx memorylayer

First run downloads the embedding model once (~130 MB, cached in ~/.cache). Every run after that boots in under a second.

Then point any MCP client at the SSE endpoint:

{
  "mcpServers": {
    "memorylayer": {
      "url": "http://localhost:7400/sse"
    }
  }
}

Works with Claude Code, Cursor, Windsurf, Antigravity, and any MCP-compatible agent — same URL, no extra config.

IDE setup (one command)

Wire up your IDE — hooks, rules, and a skill file — automatically:

memorylayer setup                        # interactive: pick IDE + toggle components
memorylayer setup --ide all --yes        # silent, all detected IDEs

# Component flags
memorylayer setup --ide claude --no-hooks   # rules + skill only, no hook
memorylayer setup --ide all --remove --yes  # uninstall everything

Supports Claude Code, Cursor, Windsurf, and Antigravity. See memorylayer.in/docs/quickstart for manual setup.

Options

memorylayer [options]

  -p, --port <number>    Port to listen on (default: 7400)
      --host <string>    Host to bind (default: 127.0.0.1; use 0.0.0.0 for Docker)
  -k, --key <string>     API key — or set MEMORY_API_KEY env var
  -d, --data <path>      Data directory (default: ~/.memorylayer)
      --model <string>   Embedding model (default: Xenova/bge-small-en-v1.5)
      --stdio            Run as stdio MCP server (for Claude desktop)
      --log-level        debug | info | warn | error (default: info)

With an API key (higher limits)

npx memorylayer --key sk-ml-your-key-here
# or
MEMORY_API_KEY=sk-ml-your-key-here npx memorylayer

Get a free key at memorylayer.in.

Docker / remote access

npx memorylayer --host 0.0.0.0 --port 7400

Claude desktop (stdio)

{
  "mcpServers": {
    "memorylayer": {
      "command": "npx",
      "args": ["memorylayer", "--stdio"]
    }
  }
}

What it does

MemoryLayer gives AI agents a persistent, searchable memory store that survives across conversations, agents, and machines.

• Shared memory — Claude, Cursor, and Windsurf all read and write the same namespace. What one agent learns, every agent knows.
• Code intelligence — index a codebase with code_ingest, then ask questions. memory_answer returns the right symbol + its siblings + imports in one round trip.
• Semantic + keyword search — hybrid BM25 + HNSW vector search with time decay and priority weighting.
• Local-first — all content stays on your machine. Only license validation pings our servers.

MCP tools

Core memory

Tool	Description
memory_upsert	Store or update — deduplicates automatically. Prefer over memory_store.
memory_search	Hybrid semantic+keyword search. Supports progressive, weave, browse modes.
memory_answer	One-call answer engine. Give it a question; it runs the search internally and returns a curated bundle. Replaces 3-5 tool calls in most cases.
memory_store	Raw store (no dedup).
memory_load	Load full content by ID.
memory_list	List memories sorted by recency.
memory_update	Update an existing memory by ID.
memory_delete	Delete by ID.
memory_similar	Find semantically similar memories to a given ID.
memory_weave	Search + expand to related memories via shared tags/time/semantics.
memory_synthesize	Synthesize memories into a coherent answer using Claude (requires ANTHROPIC_API_KEY).
memory_related	Walk the relation graph from a memory ID.
memory_chunked_store	Chunk a long document and store each chunk with a parent link.
memory_batch_store	Store up to 100 memories in one call.

Code intelligence

Tool	Description
code_ingest	Index a file or directory (Python, JS, TS). Run once; re-runs are incremental.
code_search	Natural language search over indexed symbols.
code_grep	Regex search over indexed symbol bodies — returns line snippets only.
code_file_read	All symbols from one file as a sorted bundle.
code_load_symbol	Exact-name lookup — symbol body + same-file siblings + imports.
skill_load	Load a named skill by exact metadata.skill_name.

Filesystem

Tool	Description
fs_read	Read a local file (system paths blocked).
fs_list	List a directory (skips node_modules, .git, etc.).
fs_grep	Regex search over files on disk.

Operations

Tool	Description
pruner_run	Manually run the TTL pruner — deletes expired memories.

Plans

Plan	Monthly calls	Extra tools
Free	1,000	Basic toolset + 50 memory_answer, 5 code_ingest, 50 memory_related
Pro ($19/mo)	5,000	500 memory_answer, 20 code_ingest, 200 memory_related
Pro+ ($49/mo)	10,000	memory_weave, memory_chunked_store, memory_batch_store (unlimited)
Enterprise	Custom	Per-seat keys, org billing, SLA

REST API

The same server also exposes a REST API on the same port:

# Store a memory
curl -X POST http://localhost:7400/memory \
  -H "Content-Type: application/json" \
  -d '{"content": "User prefers TypeScript strict mode", "namespace": "prefs"}'

# Search
curl -X POST http://localhost:7400/memory/search \
  -H "Content-Type: application/json" \
  -d '{"query": "coding preferences", "namespace": "prefs"}'

# Health check
curl http://localhost:7400/health

Registry

Share memory packages (versioned, integrity-signed) with your team:

memorylayer login --token sk-ml-your-key
memorylayer init                         # creates memory.json
memorylayer publish                      # publish to registry
memorylayer add @yourname/package        # install a package

memorylayer sync push --namespace work   # encrypted backup
memorylayer sync pull --namespace work   # restore on another machine

Full registry docs at memorylayer.in/docs/registry.

Data

Everything lives in ~/.memorylayer:

• memories.db — SQLite (source of truth)
• HNSW index — rebuilt from the embeddings table on startup; never treat it as durable

Back up by copying the directory:

cp -r ~/.memorylayer ~/memorylayer-backup

Run with a custom data directory:

npx memorylayer --data /Volumes/external/ml-data

Links

• Docs
• Registry
• Pricing
• GitHub
• Issues

License

MIT © Raaj Vamsy