Which integrations are available for this server?

Supports configuration through environment variables for database path, port, HTTP/SSE usage, and log level settings Uses the E5 embedding model from Hugging Face for semantic search capabilities, allowing context items to be found based on meaning rather than just exact key matches Uses npm for package management and provides npm scripts for installation, starting the server, development, and code formatting Requires Python dependencies that are automatically installed for supporting the semantic search functionality Stores context items in an SQLite database, allowing persistence of memory across sessions

How do I use Simple Memory Extension MCP Server?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Simple Memory Extension MCP Server store the API key for the weather service in the 'credentials' namespace" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

en es ja ko zh

Simple Memory Extension MCP Server

by gmacev

Overview Schema Related Servers Score Discussions

TypeScript

Hybrid

Simple Memory

Simple Memory is a local, persistent memory layer for AI agents using the Model Context Protocol (MCP).

It gives agents a place to store and recall information across separate chats, tasks, and applications. Memories can contain any JSON data, so the server does not impose a specific workflow or domain.

What is it for?

Simple Memory can help an agent remember:

Decisions, facts, risks, and ongoing work across multiple conversations
Business operations, customers, agreements, and organizational knowledge
Research findings together with their sources and confidence
Plans, preferences, notes, and long-running personal projects
Relationships and dependencies between stored information

Memories stay local and persistent. Agents can search, revise, connect, archive, and flag them for review over time. Multiple agents can coordinate safely with logical keys and revision checks, while optional access isolation can limit who may use each space.

Related MCP server: elephantasm-mcp

Models

Simple Memory uses two local models:

Qwen3-Embedding-0.6B converts memories and queries into vectors for multilingual semantic retrieval.
Qwen3-Reranker-0.6B reviews the best candidates and improves their final ordering.

They were selected because they provide strong multilingual retrieval in a relatively small size that remains practical to run locally. Inference automatically prefers a supported GPU and falls back to CPU.

Where is memory stored?

Memories are stored locally in a SQLite database named memory.db.

Operating system	Default location
Windows	`%LOCALAPPDATA%\simple-memory\memory.db`
macOS	`~/Library/Application Support/simple-memory/memory.db`
Linux	`$XDG_DATA_HOME/simple-memory/memory.db`, or `~/.local/share/simple-memory/memory.db`

The location can be changed with:

SIMPLE_MEMORY_DATA_DIR for a different data directory
SIMPLE_MEMORY_DB_PATH for a specific database file

Model files are stored separately in the standard Hugging Face cache.

Installation

Requirements:

Node.js 22 or newer (latest LTS recommended)
npm 10 or newer
Internet access during the first model download

Clone the repository and run the setup command:

git clone https://github.com/gmacev/Simple-Memory-Extension-MCP-Server.git
cd Simple-Memory-Extension-MCP-Server
npm run setup

Or ask your agent to set up Simple Memory from this repository.

The first setup downloads the models if they are not already cached.

Updating

Completely stop the MCP client that is using Simple Memory, then update the repository and installation. The server must not be running because loaded native dependencies may need to be replaced:

git pull
npm run update

Restart the MCP client afterward.

Connect your agent

Configure your MCP client to launch the server through stdio. The client starts the server automatically; you do not need to run npm start separately.

Run:

codex mcp add simple-memory -- node /absolute/path/to/Simple-Memory-Extension-MCP-Server/dist/index.js

Run:

claude mcp add --scope user simple-memory -- node /absolute/path/to/Simple-Memory-Extension-MCP-Server/dist/index.js

Add this to ~/.gemini/config/mcp_config.json:

{
  "mcpServers": {
    "simple-memory": {
      "command": "node",
      "args": ["/absolute/path/to/Simple-Memory-Extension-MCP-Server/dist/index.js"]
    }
  }
}

Available tools

Tool	Purpose
`space_create`	Create a memory space and optional access boundary.
`space_list`	List memory spaces.
`memory_create`	Store a new memory.
`memory_revise`	Add a new immutable revision.
`memory_merge`	Redirect confirmed duplicates to one canonical memory while preserving them.
`memory_get`	Read a current or historical memory.
`memory_get_by_key`	Resolve an exact logical key to its canonical memory.
`memory_history`	Read revision history.
`memory_list`	List active memory summaries by default, with filters and pagination.
`memory_search`	Search by exact text, meaning, metadata, provenance, state, or time.
`memory_archive`	Reversibly remove a memory from normal recall while preserving it.
`memory_restore`	Return an archived memory to normal recall.
`memory_delete`	Permanently erase a memory and all related data.
`memory_link`	Idempotently create a relationship between memories.
`memory_unlink`	Remove a relationship.
`memory_traverse`	Explore connected memories with paths, filters, ranking, and pagination.
`memory_feedback`	Record standardized content or query-specific retrieval feedback for a revision.
`memory_feedback_list`	Read compact or detailed feedback history.
`memory_status`	Inspect storage, indexing, and model health.

Agents can also read complete memories and revision histories through MCP resources.

Environment variables

All configuration is optional; the defaults are suitable for a normal local installation.

General

Variable	Purpose	Default
`SIMPLE_MEMORY_DATA_DIR`	Memory data directory	Platform location listed above
`SIMPLE_MEMORY_DB_PATH`	Complete SQLite database path	`<data-dir>/memory.db`
`SIMPLE_MEMORY_MODELS`	Set to `disabled` for lexical-only operation	`enabled`
`SIMPLE_MEMORY_DEVICE`	Runtime device such as `cuda`, `xpu`, `mps`, or `cpu`	`auto`
`SIMPLE_MEMORY_LOCAL_FILES_ONLY`	Prevent model downloads and use the local cache only	`false`
`SIMPLE_MEMORY_LOG_LEVEL`	`debug`, `info`, `warn`, or `error`	`info`
`SIMPLE_MEMORY_MODEL_TIMEOUT_MS`	Model request timeout	`600000`

Transport

Variable	Purpose	Default
`SIMPLE_MEMORY_TRANSPORT`	`stdio` or Streamable `http`	`stdio`
`SIMPLE_MEMORY_HTTP_HOST`	HTTP bind address	`127.0.0.1`
`SIMPLE_MEMORY_HTTP_PORT`	HTTP port	`3000`
`SIMPLE_MEMORY_HTTP_ALLOWED_ORIGINS`	Comma-separated browser origins allowed to call HTTP	Local server origins; required for wildcard bind addresses
`SIMPLE_MEMORY_ACCESS_MODE`	`open`, stdio `fixed`, or HTTP `oauth` access	`open`
`SIMPLE_MEMORY_FIXED_PRINCIPAL`	Trusted actor identity used by a fixed stdio process	Required in `fixed` mode
`SIMPLE_MEMORY_FIXED_ACCESS`	JSON object containing fixed per-space `read`, `write`, or `manage` grants	Required in `fixed` mode
`SIMPLE_MEMORY_HTTP_PUBLIC_URL`	Public MCP resource URL, including `/mcp`	Required in `oauth` mode
`SIMPLE_MEMORY_OAUTH_ISSUER`	OAuth/OIDC issuer discovered for metadata and JWKS	Required in `oauth` mode
`SIMPLE_MEMORY_OAUTH_AUDIENCE`	Required JWT audience	Public MCP URL
`SIMPLE_MEMORY_OAUTH_ACCESS_CLAIM`	JWT claim containing the `spaces` grant map	`simple_memory_access`
`SIMPLE_MEMORY_HTTP_ALLOW_UNAUTHENTICATED_NON_LOOPBACK`	Explicitly allow unsafe open HTTP outside loopback	`false`

Open HTTP is allowed on loopback only. OAuth public URLs and issuers must use HTTPS except during loopback development. The former SIMPLE_MEMORY_HTTP_TOKEN shared-secret setting is not supported.

Access control for shared use

Most local installations do not need this: a stdio server is open to the trusted agent that starts it.

Use fixed when separate local agent configurations share one database but should be limited to particular spaces. Give each configuration a trusted identity and its allowed spaces:

SIMPLE_MEMORY_ACCESS_MODE=fixed
SIMPLE_MEMORY_FIXED_PRINCIPAL=agent-a
SIMPLE_MEMORY_FIXED_ACCESS={"spaces":{"agent-a-private":"write","project-shared":"read"}}

Use oauth when a shared HTTP server serves separate users or agents. Your identity provider authenticates callers; Simple Memory enforces the access grants carried by their tokens.

Retrieval and models

Variable	Purpose	Default
`SIMPLE_MEMORY_EMBEDDING_MODEL`	Embedding model	`Qwen/Qwen3-Embedding-0.6B`
`SIMPLE_MEMORY_EMBEDDING_REVISION`	Embedding model revision	Built-in pinned revision
`SIMPLE_MEMORY_RERANKER_MODEL`	Reranking model	`Qwen/Qwen3-Reranker-0.6B`
`SIMPLE_MEMORY_RERANKER_REVISION`	Reranking model revision	Built-in pinned revision
`SIMPLE_MEMORY_EMBEDDING_DIMENSION`	Stored vector dimensions	`1024`
`SIMPLE_MEMORY_QUERY_INSTRUCTION`	Embedding retrieval instruction	Built-in generic instruction
`SIMPLE_MEMORY_RERANK_INSTRUCTION`	Reranking instruction	Built-in generic instruction
`SIMPLE_MEMORY_EMBED_BATCH_SIZE`	Embedding batch size	`8`
`SIMPLE_MEMORY_RERANK_BATCH_SIZE`	Reranking batch size	`4`
`SIMPLE_MEMORY_LEXICAL_CANDIDATES`	Lexical candidates considered	`100`
`SIMPLE_MEMORY_SEMANTIC_CANDIDATES`	Semantic candidates considered	`100`
`SIMPLE_MEMORY_RERANK_CANDIDATES`	Candidates sent to the reranker	`30`

Setup and Python

Variable	Purpose	Default
`SIMPLE_MEMORY_TORCH_BACKEND`	PyTorch backend selected during setup or update	Automatically detected
`SIMPLE_MEMORY_UV`	Path to a specific `uv` executable	Automatically located
`SIMPLE_MEMORY_PYTHON`	Path to the Python executable used by the server	Bundled virtual environment
`SIMPLE_MEMORY_PYTHON_PROJECT`	Path to the model-runtime project	Repository `python` directory

Standard Hugging Face variables such as HF_HOME can also be used to relocate the shared model cache.

License

MIT

This server cannot be installed

license - permissive license

quality - not tested

maintenance

How are these scores calculated?

Maintenance

–Maintainers

–Response time

–Release cycle

–Releases (12mo)

Commit activity

Resources

GitHub Repository

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Appeared in Searches

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/gmacev/Simple-Memory-Extension-MCP-Server'

If you have feedback or need assistance with the MCP directory API, please join our Discord server