Multi-Memory

This multi-memory MCP Server lets you build and query a multi-category knowledge graph stored in SQLite. You organize memories into isolated contexts (like work, personal, or projects), and you can connect pieces of information with flexible identities, custom properties, and searchable observations. It’s designed for reliability, fast lookups, and safe multi-context operations that scale with your needs.

How to use

You interact with the server through an MCP client. Start a server instance and point your client at the local or remote endpoint. Use distinct categories to keep memories isolated, and perform standard operations to create entities, define relations, attach observations, and query or read your graph. You can reference items by either their unique ID or by a human-friendly name/type pair. The server supports updating existing records with an override option, and it protects against SQL injection through parameterized queries.

In typical workflows you will: start a local or hosted MCP server, configure your client to connect to the server, create entities (with optional observations and properties), establish relations to model dependencies or associations, add or update observations, and then run read or search operations to explore the graph. You can also delete entities, observations, or relations when you need to prune the graph. When you expand memory by adding new categories, each category gets its own SQLite database, preserving isolation between contexts.

How to install

Prerequisites: Node.js and npm (or an environment that can run the MCP server). Ensure you have a compatible runtime installed before starting.

Option 1 — Run directly with npx (no installation required) You can try the server immediately from the code source without installing dependencies locally.

npx github:DanNsk/multi-memory-mcp

Using this in Claude Desktop or similar config is also supported. The MCP server can be configured through an environment with the base memory directory and a default category.

{
  "mcpServers": {
    "multi-memory": {
      "command": "npx",
      "args": ["github:DanNsk/multi-memory-mcp"],
      "env": {
        "MEMORY_BASE_DIR": "/path/to/.memory",
        "DEFAULT_CATEGORY": "default"
      }
    }
  }
}

Configuration

Environment variables you can set for a straightforward run are shown here. You can customize these values to fit your workspace.

MEMORY_BASE_DIR=/Users/you/.memory
DEFAULT_CATEGORY=default
SERIALIZATION_FORMAT=json

When using Claude Desktop or similar tooling, place the MCP server configuration in your client’s config directory or integration layer, pointing to the npx-based start as shown above.

Security and reliability notes

The server uses parameterized queries to prevent SQL injection, enforces foreign key constraints, and applies cascading deletes to keep data consistent when entities are removed. It also uses a Least Recently Used (LRU) cache for database connections to avoid memory leaks and cap concurrent connections at an application-friendly limit.

Each category stores its data in a separate SQLite database with indexing on key fields to speed up lookups. Transactions are ACID-compliant to ensure data integrity during complex operations.

Troubleshooting

Database locked errors are uncommon with WAL mode but can occur if another process writes to the database. Check that no other process is writing and verify directory permissions. If memory usage grows, the built-in LRU cache will evict the oldest connections once the limit is reached.

Use cases and examples

Code Dependency Tracking: keep modules, services, and libraries as entities with observations about versions and locations, then model how they depend on or use one another through relations.

Multi-Project Organization: separate memories per project, with clear boundaries between work, personal, and learning contexts.

Available tools

create_entities

Create new entities in the knowledge graph with optional properties and initial observations.

create_relations

Create relationships between entities, supporting identification by ID or by name/type, with optional properties and override behavior.

add_observations

Add observations to existing entities identified by ID or name/type, with options to override existing observations.

delete_entities

Delete entities and their associated observations and relations using ID or name/type.

delete_observations

Delete specific observations by ID or by entity ID/name/type plus observation type and source.

delete_relations

Delete graph relations by ID or by composite key (from/to and relation type).

read_graph

Retrieve the full graph for a given category, including entities and relations.

search_nodes

Search entities by name, type, observation content, or properties using full-text search.

open_nodes

Retrieve specific entities by ID or name/type along with related relations.

list_categories

List all available memory categories (databases).

delete_category

Remove an entire category and its database.