Skip to main content
Glama

Enhanced Knowledge Graph Memory Server

by danielsimonjr
OverviewSchemaRelated ServersScoreDiscussions
TypeScript
Local
MIT License
12

Memory MCP Server

Version NPM License MCP TypeScript Changelog

An enhanced fork of the official Model Context Protocol memory server with advanced features for hierarchical nesting, intelligent compression, archiving, advanced search, and multi-format import/export.

Enterprise-grade knowledge graph with 45 tools, hierarchical organization, duplicate detection, smart archiving, and sophisticated search capabilities for long-term memory management.

Table of Contents

Features

Core Memory Capabilities

  • Knowledge Graph Storage: Entity-Relation-Observation model for structured memory

  • Persistent Memory: Information persists across chat sessions with JSONL storage

  • Full CRUD Operations: Create, read, update, delete entities and relations

  • Flexible Search: Text-based, fuzzy, boolean, and TF-IDF ranked search

Advanced Features

  • Hierarchical Nesting: Parent-child relationships for organizing tree structures (8 tools)

  • Memory Compression: Intelligent duplicate detection and merging with similarity scoring (3 tools)

  • Smart Archiving: Criteria-based archiving by age, importance, or tags (1 tool)

  • Advanced Search: TF-IDF ranking, boolean queries, fuzzy matching (3 tools)

  • Import/Export: 7 formats (JSON, CSV, GraphML, GEXF, DOT, Markdown, Mermaid)

  • Tag Management: Aliases, bulk operations, and validation (11 tools)

  • Saved Searches: Store and execute frequent queries (5 tools)

  • Graph Validation: Integrity checks and orphan detection (1 tool)

Data Management

  • Automatic Timestamps: createdAt and lastModified fields with smart updates

  • Date Range Search: Filter entities/relations by creation or modification date

  • Graph Statistics: Comprehensive analytics with counts, types, and temporal data

  • Tags System: Categorize entities with case-insensitive tags and aliases

  • Importance Levels: 0-10 scale for entity prioritization

  • Advanced Filtering: Combine text, tags, importance, and date ranges

Comparison with Official Memory Server

Feature

Official

Enhanced (This Fork)

Entity Management

✅

✅

Relation Management

✅

✅

Observation Tracking

✅

✅

Basic Search

✅

✅

Hierarchical Nesting

❌

✅ Parent-child trees

Memory Compression

❌

✅ Duplicate detection (50x faster)

Smart Archiving

❌

✅ Criteria-based

Advanced Search

❌

✅ TF-IDF + Boolean

Fuzzy Search

❌

✅ Typo-tolerant

Saved Searches

❌

✅ Store queries

Tag Aliases

❌

✅ Synonyms

Graph Validation

❌

✅ Integrity checks

Timestamps

❌

✅ createdAt + lastModified

Importance Levels

❌

✅ 0-10 scale

Export Formats

❌

✅ 7 formats

Import

❌

✅ 3 formats + merge

Input Validation

❌

✅ Zod schemas (14 validators)

Caching Layer

❌

✅ In-memory (instant reads)

Backup & Restore

❌

✅ Point-in-time recovery

Transactions

❌

✅ ACID guarantees

Security

Basic

✅ Input validation

Reliability

Basic

✅ Backups & Transactions

Performance

Basic

✅ Caching & Optimizations

Total Tools

11

45

(+309%)

Code Structure

Monolithic

Modular

(40+ files)

Key Features

Production-Ready Enterprise Capabilities

🔐 Security & Data Integrity

  • Input Validation: Zod-based schemas validate all inputs, preventing malformed data and injection attacks

  • Transaction Support: ACID-compliant transactions with automatic rollback on failures

  • Backup & Restore: Point-in-time recovery with timestamped backups and metadata

  • Data Protection: Comprehensive validation with size limits, range checks, and format enforcement

⚡ Performance Optimizations

  • Smart Caching: In-memory cache with write-through invalidation for instant reads

  • Optimized Algorithms: 50x faster duplicate detection using two-level bucketing (O(n²) → O(n·k))

  • Efficient Storage: JSONL format with modular architecture for better tree-shaking

🏗️ Architecture

  • Modular Design: Clean separation of concerns across 40+ focused modules

  • Type Safety: Full TypeScript strict mode with comprehensive type definitions

  • Dependency Injection: Flexible, testable design with clear module boundaries

  • Developer Experience: Barrel exports, JSDoc documentation, and comprehensive test coverage

Quick Start

1. Install from NPM (Recommended)

npm install -g @danielsimonjr/memory-mcp

Or use with npx (no installation required):

npx @danielsimonjr/memory-mcp

2. Configure Claude Desktop

Add to claude_desktop_config.json:

Using NPM Global Install:

{ "mcpServers": { "memory": { "command": "mcp-server-memory" } } }

Using NPX:

{ "mcpServers": { "memory": { "command": "npx", "args": ["-y", "@danielsimonjr/memory-mcp"] } } }

3. Restart Claude Desktop

Restart Claude Desktop to load the enhanced memory server.

4. Start Using

Tell Claude:

Please remember that I prefer TypeScript over JavaScript. Tag this as "preferences" with importance 8. Create a parent entity called "Development Preferences" and nest this under it.

Claude will automatically use the enhanced tools!

Installation

Local Build (Recommended)

# Clone repository git clone https://github.com/danielsimonjr/memory-mcp.git cd memory-mcp # Install and build npm install npm run build # Run tests npm test # Type check npm run typecheck

Claude Desktop Configuration

Add to ~/Library/Application Support/Claude/claude_desktop_config.json (Mac) or %APPDATA%\Claude\claude_desktop_config.json (Windows):

{ "mcpServers": { "memory": { "command": "node", "args": ["<PATH_TO>/memory-mcp/src/memory/dist/index.js"], "env": { "MEMORY_FILE_PATH": "<PATH_TO>/memory.jsonl" } } } }

Replace <PATH_TO> with your actual paths.

VS Code

Add to .vscode/mcp.json:

{ "servers": { "memory": { "command": "node", "args": ["/path/to/memory-mcp/src/memory/dist/index.js"] } } }

Core Concepts

Entities

Primary nodes in the knowledge graph.

Fields:

  • name (string): Unique identifier

  • entityType (string): Classification

  • observations (string[]): Facts about the entity

  • parentId (string, optional): Parent entity name for hierarchical nesting

  • createdAt (string, optional): ISO 8601 timestamp

  • lastModified (string, optional): ISO 8601 timestamp

  • tags (string[], optional): Lowercase tags for categorization

  • importance (number, optional): 0-10 scale for prioritization

Example:

{ "name": "John_Smith", "entityType": "person", "observations": ["Speaks fluent Spanish", "Senior developer"], "parentId": "Engineering_Team", "createdAt": "2025-01-15T10:30:00.000Z", "tags": ["colleague", "engineering"], "importance": 7 }

Relations

Directed connections between entities.

Fields:

  • from (string): Source entity name

  • to (string): Target entity name

  • relationType (string): Relationship type

  • createdAt (string, optional): ISO 8601 timestamp

  • lastModified (string, optional): ISO 8601 timestamp

Example:

{ "from": "John_Smith", "to": "Anthropic", "relationType": "works_at", "createdAt": "2025-01-15T10:30:00.000Z" }

Observations

Discrete facts about entities.

Principles:

  • One fact per observation

  • Atomic information

  • Independently manageable

API Reference

Complete Tool List (45 Tools)

Core Entity & Relation Management (9 tools)

  • create_entities - Create multiple new entities

  • create_relations - Create multiple new relations

  • add_observations - Add observations to entities

  • delete_entities - Remove entities and their relations

  • delete_observations - Remove specific observations

  • delete_relations - Remove specific relations

  • read_graph - Read entire knowledge graph

  • search_nodes - Search for nodes by query

  • open_nodes - Retrieve specific nodes by name

Hierarchical Nesting (8 tools)

  • set_entity_parent - Set or remove parent relationship

  • get_children - Get immediate children

  • get_parent - Get parent entity

  • get_ancestors - Get all ancestors (parent chain)

  • get_descendants - Get all descendants (recursive)

  • get_subtree - Get entity + descendants with relations

  • get_root_entities - Get all entities with no parent

  • get_entity_depth - Get depth in hierarchy (0 = root)

Memory Compression (3 tools)

  • find_duplicates - Find similar entities by threshold

  • merge_entities - Merge multiple entities into one

  • compress_graph - Automated compression with dry-run

Memory Archiving (1 tool)

  • archive_entities - Archive by age, importance, or tags

Advanced Search (3 tools)

  • search_nodes_ranked - TF-IDF relevance ranking

  • boolean_search - Boolean queries (AND/OR/NOT)

  • fuzzy_search - Typo-tolerant search

Search Management (6 tools)

  • save_search - Save search query

  • list_saved_searches - List all saved searches

  • get_saved_search - Get saved search details

  • execute_saved_search - Execute saved search

  • delete_saved_search - Delete saved search

  • update_saved_search - Update saved search

  • get_search_suggestions - Get "Did you mean?" suggestions

Tag Management (8 tools)

  • add_tags - Add tags to entity

  • remove_tags - Remove tags from entity

  • add_tags_to_multiple - Add tags to multiple entities

  • replace_tag - Replace tag globally

  • merge_tags - Merge two tags into one

  • add_tag_alias - Create tag synonym

  • list_tag_aliases - List all tag aliases

  • get_aliases_for_tag - Get aliases for tag

  • remove_tag_alias - Remove tag alias

  • resolve_tag - Resolve alias to canonical form

Graph Analytics & Validation (3 tools)

  • get_graph_stats - Get comprehensive graph statistics

  • search_by_date_range - Filter by date range

  • validate_graph - Validate graph integrity

  • set_importance - Set entity importance (0-10)

Import & Export (2 tools)

  • export_graph - Export in 7 formats

  • import_graph - Import from JSON/CSV/GraphML

Detailed API Documentation

Create multiple new entities in the knowledge graph.

Input:

{ entities: Array<{ name: string; entityType: string; observations: string[]; parentId?: string; // NEW in v0.8.0 tags?: string[]; importance?: number; // 0-10 }> }

Returns: Array of created entities with timestamps

Example:

{ "entities": [{ "name": "Project_Alpha", "entityType": "project", "observations": ["Web application rewrite"], "tags": ["high-priority"], "importance": 8 }] }

Create multiple new relations between entities.

Input:

{ relations: Array<{ from: string; to: string; relationType: string; }> }

Returns: Array of created relations with timestamps

Example:

{ "relations": [{ "from": "John_Smith", "to": "Project_Alpha", "relationType": "works_on" }] }

Add new observations to existing entities.

Input:

{ observations: Array<{ entityName: string; contents: string[]; }> }

Returns: Array with added observations per entity

Example:

{ "observations": [{ "entityName": "John_Smith", "contents": ["Certified AWS architect", "Speaks German"] }] }

Remove entities and all their relations from the graph.

Input:

{ entityNames: string[] }

Returns: Confirmation

Note: Cascade deletes all relations to/from these entities.

Remove specific observations from entities.

Input:

{ deletions: Array<{ entityName: string; observations: string[]; }> }

Returns: Confirmation

Remove specific relations from the graph.

Input:

{ relations: Array<{ from: string; to: string; relationType: string; }> }

Returns: Confirmation

Read the entire knowledge graph (all entities and relations).

Input: None

Returns: Complete knowledge graph

{ entities: Entity[]; relations: Relation[]; }

Search for nodes by query string with optional filters.

Input:

{ query: string; tags?: string[]; minImportance?: number; maxImportance?: number; }

Returns: Matching entities and their relations

Example:

{ "query": "typescript", "tags": ["programming"], "minImportance": 5 }

Retrieve specific nodes by exact name match.

Input:

{ names: string[] }

Returns: Requested entities and relations between them

Example:

{ "names": ["John_Smith", "Project_Alpha"] }

Set or remove parent-child relationship for hierarchical nesting.

Input:

{ entityName: string; parentName: string | null; // null removes parent }

Returns: Updated entity

Features:

  • Automatic cycle detection

  • Updates lastModified timestamp

Example:

{ "entityName": "Feature_Auth", "parentName": "Project_Alpha" }

Get immediate children of an entity.

Input:

{ entityName: string; }

Returns: Array of child entities

Example:

{ "entityName": "Project_Alpha" }

Get parent entity (or null if root).

Input:

{ entityName: string; }

Returns: Parent entity or null

Get all ancestors (parent chain to root).

Input:

{ entityName: string; }

Returns: Array of ancestors (closest to furthest)

Example: Task → Feature → Project → Root

Get all descendants recursively (BFS traversal).

Input:

{ entityName: string; }

Returns: Array of all descendant entities

Get entity + all descendants with their relations.

Input:

{ entityName: string; }

Returns: Subtree (entities + relations)

{ entities: Entity[]; relations: Relation[]; }

Use cases: Export branches, analyze sections, filter by scope

Get all entities with no parent (top-level entities).

Input: None

Returns: Array of root entities

Get depth in hierarchy (0 = root, 1 = child of root, etc.).

Input:

{ entityName: string; }

Returns:

{ entityName: string; depth: number; }

Find similar entities using multi-factor similarity scoring.

Input:

{ threshold?: number; // Default 0.8 (80% similar) }

Returns: Array of duplicate entity name groups

Algorithm:

  • Name similarity: 40% (Levenshtein distance)

  • Type match: 20% (exact match)

  • Observation overlap: 30% (Jaccard similarity)

  • Tag overlap: 10% (Jaccard similarity)

Example:

{ "threshold": 0.85 }

Merge multiple entities into one target entity.

Input:

{ entityNames: string[]; targetName?: string; // Auto-selects if not provided }

Returns: Merged entity

Merge behavior:

  • Combines unique observations and tags

  • Keeps highest importance

  • Redirects all relations to target

  • Preserves earliest createdAt

Example:

{ "entityNames": ["Project Alpha", "project-alpha", "Project-Alpha"], "targetName": "Project Alpha" }

Automated duplicate detection and merging.

Input:

{ threshold?: number; // Default 0.8 dryRun?: boolean; // Default false (preview only) }

Returns: Compression statistics

{ duplicatesFound: number; entitiesMerged: number; observationsCompressed: number; relationsConsolidated: number; spaceFreed: number; mergedEntities: Array<{ kept: string; merged: string[] }>; }

Example:

{ "threshold": 0.8, "dryRun": true }

Archive entities based on criteria (OR logic).

Input:

{ olderThan?: string; // ISO date importanceLessThan?: number; // 0-10 tags?: string[]; // Any match }

Second parameter: dryRun (boolean, default false)

Returns:

{ archived: number; entityNames: string[]; }

Criteria (OR logic): Archive if ANY criterion matches

Example:

{ "olderThan": "2025-01-01T00:00:00.000Z", "importanceLessThan": 3, "tags": ["completed", "deprecated"] }

Full-text search with TF-IDF relevance ranking.

Input:

{ query: string; limit?: number; // Default 50, max 200 }

Returns: Ranked results with scores

Array<{ entityName: string; score: number; matchedIn: string[]; // Fields matched }>

Example:

{ "query": "machine learning algorithms", "limit": 10 }

Advanced boolean queries with logical operators.

Input:

{ query: string; // Boolean expression }

Operators:

  • AND, OR, NOT, ()

  • Field-specific: name:, type:, observation:, tag:

  • Quoted strings: "exact phrase"

Example:

{ "query": "type:project AND (frontend OR backend) NOT deprecated" }

Typo-tolerant search using Levenshtein distance.

Input:

{ query: string; threshold?: number; // Default 0.7 (70% match) }

Returns: Matching entities (sorted by similarity)

Example:

{ "query": "projekt", "threshold": 0.8 }

Save a search query for reuse.

Input:

{ name: string; query: string; filters?: object; description?: string; }

Returns: Saved search object

List all saved searches.

Input: None

Returns: Array of saved searches with metadata

Get details of a saved search.

Input:

{ name: string; }

Returns: Saved search object

Execute a saved search (updates usage count).

Input:

{ name: string; }

Returns: Search results

Delete a saved search.

Input:

{ name: string; }

Returns: Confirmation

Update a saved search.

Input:

{ name: string; query?: string; filters?: object; description?: string; }

Returns: Updated saved search

Get "Did you mean?" suggestions for typos.

Input:

{ query: string; limit?: number; // Default 5 }

Returns: Array of suggestions with scores

Add tags to an entity (normalized to lowercase).

Input:

{ entityName: string; tags: string[]; }

Returns: Entity with added tags

Remove tags from an entity.

Input:

{ entityName: string; tags: string[]; }

Returns: Entity with remaining tags

Add tags to multiple entities at once (bulk operation).

Input:

{ entityNames: string[]; tags: string[]; }

Returns: Array of results per entity

Replace a tag globally across all entities.

Input:

{ oldTag: string; newTag: string; }

Returns: Count of entities updated

Merge two tags into one (all entities with tag1 get tag2).

Input:

{ sourceTag: string; targetTag: string; }

Returns: Count of entities updated

Create a tag synonym (alias → canonical).

Input:

{ alias: string; canonical: string; description?: string; }

Example: "ai" → "artificial-intelligence"

Returns: Tag alias object

List all tag aliases.

Input: None

Returns: Array of tag aliases

Get all aliases for a canonical tag.

Input:

{ canonical: string; }

Returns: Array of aliases

Remove a tag alias.

Input:

{ alias: string; }

Returns: Confirmation

Resolve an alias to its canonical form.

Input:

{ tag: string; }

Returns: Canonical tag name (or original if no alias)

Get comprehensive graph statistics.

Input: None

Returns:

{ totalEntities: number; totalRelations: number; entityTypesCounts: { [type: string]: number }; relationTypesCounts: { [type: string]: number }; oldestEntity: { name: string; date: string }; newestEntity: { name: string; date: string }; oldestRelation: { from: string; to: string; date: string }; newestRelation: { from: string; to: string; date: string }; entityDateRange: { start: string; end: string }; relationDateRange: { start: string; end: string }; }

Filter entities and relations by date range.

Input:

{ startDate?: string; // ISO 8601 endDate?: string; // ISO 8601 entityType?: string; tags?: string[]; }

Returns: Filtered knowledge graph

Example:

{ "startDate": "2025-01-01T00:00:00.000Z", "endDate": "2025-01-31T23:59:59.999Z", "tags": ["project"] }

Validate graph integrity and detect issues.

Input: None

Returns:

{ isValid: boolean; errors: string[]; // Critical issues warnings: string[]; // Non-critical issues }

Checks:

  • Orphaned relations

  • Duplicate entities

  • Invalid data

  • Isolated entities (warning)

  • Empty observations (warning)

Set importance level for an entity (0-10).

Input:

{ entityName: string; importance: number; // 0-10 }

Returns: Updated entity

Scale:

  • 9-10: Critical

  • 7-8: High

  • 5-6: Medium

  • 3-4: Low

  • 0-2: Minimal

Export knowledge graph in multiple formats.

Input:

{ format: "json" | "csv" | "graphml" | "gexf" | "dot" | "markdown" | "mermaid"; filter?: { startDate?: string; endDate?: string; entityType?: string; tags?: string[]; } }

Formats:

  • JSON: Pretty-printed with all data

  • CSV: Entities + relations sections

  • GraphML: XML for Gephi, Cytoscape, yEd

  • GEXF: Gephi native format

  • DOT: GraphViz for publication

  • Markdown: Human-readable documentation

  • Mermaid: Embedded diagrams

Example:

{ "format": "gexf", "filter": { "entityType": "person", "tags": ["colleague"] } }

Import knowledge graph from JSON, CSV, or GraphML.

Input:

{ format: "json" | "csv" | "graphml"; data: string; strategy?: "replace" | "skip" | "merge" | "fail"; // Default "merge" dryRun?: boolean; // Default false }

Merge strategies:

  • replace: Overwrite existing entities

  • skip: Keep existing, skip imports

  • merge: Combine observations/tags

  • fail: Error on conflicts

Returns: Import statistics

{ entitiesImported: number; relationsImported: number; entitiesSkipped: number; relationsSkipped: number; errors: string[]; }

Data Model

Entity Schema

interface Entity { name: string; // Unique identifier entityType: string; // Classification observations: string[]; // Facts about the entity parentId?: string; // Parent entity (v0.8.0) createdAt?: string; // ISO 8601 timestamp lastModified?: string; // ISO 8601 timestamp tags?: string[]; // Lowercase tags importance?: number; // 0-10 scale }

Relation Schema

interface Relation { from: string; // Source entity name to: string; // Target entity name relationType: string; // Relationship type createdAt?: string; // ISO 8601 timestamp lastModified?: string; // ISO 8601 timestamp }

Storage Files

The server automatically creates and manages these files:

  • memory.jsonl: Main knowledge graph storage (entities and relations)

  • memory-saved-searches.jsonl: Saved search queries with metadata

  • memory-tag-aliases.jsonl: Tag synonym mappings (alias → canonical)

  • .backups/: Backup directory with timestamped snapshots

All files use JSONL (JSON Lines) format where each line is a valid JSON object.

Custom path: Set MEMORY_FILE_PATH environment variable (see Configuration)

Usage Examples

Example 1: Hierarchical Project Structure

// Create entities { "entities": [ { "name": "Project_Alpha", "entityType": "project", "observations": ["Web app rewrite"] }, { "name": "Feature_Auth", "entityType": "feature", "observations": ["User authentication"] }, { "name": "Task_Login", "entityType": "task", "observations": ["Implement login UI"] } ] } // Set hierarchy { "entityName": "Feature_Auth", "parentName": "Project_Alpha" } { "entityName": "Task_Login", "parentName": "Feature_Auth" } // Navigate { "entityName": "Project_Alpha" } // get_children → [Feature_Auth] { "entityName": "Task_Login" } // get_ancestors → [Feature_Auth, Project_Alpha]

Example 2: Duplicate Detection and Merging

// Find duplicates { "threshold": 0.8 } // find_duplicates // Merge duplicates { "entityNames": ["Project Alpha", "project-alpha", "Project-Alpha"], "targetName": "Project Alpha" } // merge_entities // Auto-compress { "threshold": 0.8, "dryRun": true } // compress_graph (preview) { "threshold": 0.8, "dryRun": false } // compress_graph (execute)

Example 3: Smart Archiving

// Archive old, low-priority, or completed entities { "olderThan": "2025-01-01T00:00:00.000Z", "importanceLessThan": 3, "tags": ["completed", "deprecated"] } // archive_entities (OR logic)

Example 4: Advanced Search

// Boolean search { "query": "type:project AND (frontend OR backend) NOT deprecated" } // TF-IDF ranking { "query": "machine learning algorithms", "limit": 10 } // Fuzzy search { "query": "projekt", "threshold": 0.8 }

Example 5: Tag Management

// Bulk tag operations { "entityNames": ["Entity1", "Entity2", "Entity3"], "tags": ["new-tag"] } // add_tags_to_multiple // Tag aliases { "alias": "ai", "canonical": "artificial-intelligence" } // add_tag_alias // Merge tags { "sourceTag": "ml", "targetTag": "machine-learning" } // merge_tags

Comprehensive Guides

Detailed documentation for advanced features:

Configuration

Environment Variables

  • MEMORY_FILE_PATH: Path to the main memory storage file

    • Default: memory.jsonl in the current working directory

    • Format: JSONL (JSON Lines) format

    • Sets the location for the primary knowledge graph storage

Storage File Organization

When you set MEMORY_FILE_PATH, the server automatically creates related files in the same directory:

/your/data/directory/ ├── memory.jsonl # Main knowledge graph (active entities & relations) ├── memory-saved-searches.jsonl # Saved search queries ├── memory-tag-aliases.jsonl # Tag synonym mappings └── .backups/ # Timestamped backup directory ├── backup_2025-11-24_10-30-00-123.jsonl ├── backup_2025-11-24_10-30-00-123.jsonl.meta.json └── ...

Note: All auxiliary files use the same base filename as MEMORY_FILE_PATH with descriptive suffixes.

Example Configuration

Claude Desktop (

{ "mcpServers": { "memory": { "command": "node", "args": ["/path/to/memory-mcp/src/memory/dist/index.js"], "env": { "MEMORY_FILE_PATH": "/path/to/data/memory.jsonl" } } } }

Default behavior (no environment variable):

{ "mcpServers": { "memory": { "command": "node", "args": ["/path/to/memory-mcp/src/memory/dist/index.js"] } } }

Creates memory.jsonl in the current working directory.

Development

Prerequisites

  • Node.js 18+

  • npm 9+

  • TypeScript 5.6+

Build

npm install npm run build # Production build npm run watch # Development watch mode

Test

npm test # Run test suite with coverage npm run typecheck # TypeScript type checking

Project Structure

memory-mcp/ ├── src/memory/ │ ├── types/ # Type definitions │ ├── utils/ # Utility functions │ ├── core/ # Storage & managers │ ├── search/ # Search implementations │ ├── features/ # Feature managers │ ├── dist/ # Compiled output │ ├── __tests__/ # Test files │ └── package.json ├── CHANGELOG.md # Version history ├── HIERARCHY_GUIDE.md # Nesting guide ├── COMPRESSION_GUIDE.md # Compression guide ├── ARCHIVING_GUIDE.md # Archiving guide ├── QUERY_LANGUAGE.md # Boolean search reference ├── MIGRATION_GUIDE.md # Upgrade guide ├── package.json # Root package └── README.md # This file

Scripts

npm run build # Build production npm run watch # Watch mode npm test # Run tests npm run typecheck # Type check npm run clean # Clean dist

Contributing

We welcome contributions!

See:

Ways to Help:

  • 🐛 Report bugs

  • ✨ Request features

  • 🔧 Submit pull requests

  • 📚 Improve documentation

  • 🧪 Add tests

  • 🌍 Translate guides

Changelog

All notable changes to this project are documented in CHANGELOG.md.

The changelog follows Keep a Changelog format and tracks:

  • Added: New features and capabilities

  • Changed: Changes to existing functionality

  • Deprecated: Soon-to-be removed features

  • Removed: Removed features

  • Fixed: Bug fixes

  • Security: Security improvements

Current version: v0.11.6 - View full changelog →

License

MIT License - see LICENSE

You are free to use, modify, and distribute this software.

Acknowledgments

Original Project

Enhanced fork of Model Context Protocol memory server by Anthropic.

Original License: MIT

Enhancements

Developer: Daniel Simon Jr.

Major Features Added:

  • Hierarchical nesting with parent-child relationships

  • Memory compression with intelligent duplicate detection

  • Smart archiving with criteria-based filtering

  • Advanced search: TF-IDF, boolean, and fuzzy matching

  • Multi-format import/export with merge strategies

  • Enhanced tag management with aliases and bulk operations

  • Saved searches with usage tracking

  • Graph validation and integrity checks

  • Transaction support with ACID guarantees

  • Backup and restore capabilities

  • Input validation and security hardening

  • Performance optimizations and caching

  • Comprehensive documentation and guides

Community

Thanks to:

  • 🛠️ MCP Specification

  • 📚 MCP community and contributors

  • Technologies: Vitest, TypeScript, Node.js

Repository: https://github.com/danielsimonjr/memory-mcp Issues: https://github.com/danielsimonjr/memory-mcp/issues NPM: https://www.npmjs.com/package/@danielsimonjr/memory-mcp

Made with ❤️ for the MCP community

This server cannot be installed

-
security - not tested
A
license - permissive license
-
quality - not tested

How are these scores calculated?

Resources

New MCP Servers

Latest Blog Posts

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/danielsimonjr/memory-mcp'

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