MemoryMesh is a knowledge graph server designed for AI models, particularly for text-based RPGs and interactive storytelling. Its capabilities include:
Schema-Based Data Management: Define custom data structures and automatically generate tools for adding, updating, and deleting data.
Node & Edge Operations: Manage entities (nodes) and relationships (edges) in the knowledge graph with properties, types, and weights.
Domain-Specific Management: Handle game elements like artifacts, currencies, factions, inventories, locations, NPCs, player characters, quests, skills, temporal events, and transportation.
Search & Retrieval: Query the graph and retrieve specific nodes by name.
Visualization: Explore and visualize the knowledge graph through the Memory Viewer tool.
AI Integration: Connect with AI models (e.g., Claude Desktop) via MCP for AI interaction with the graph.
Event Tracking: Monitor knowledge graph modifications through an event system.
Schema Management: Use SchemaManager for visual schema creation and editing.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@MemoryMesh add a new NPC named Elara with the class of wizard and affiliation to the Arcane Council"
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.
MemoryMesh is an MCP server that gives AI models a structured, long-term memory in the form of a knowledge graph. You describe the kinds of things you want to remember in small schema files (people, projects, characters, locations, books...), and MemoryMesh turns each one into tools the AI uses to add, update and delete that information, linking related items as it goes.
It works for anything you can describe as things and the connections between them: a text-based RPG world, the people and teams at your company, a personal CRM, or your reading notes.
Based on the Knowledge Graph Memory Server from the MCP servers repository.
The memory is a graph of nodes and edges:
A node is a thing: {"name": "Mara", "nodeType": "npc", "metadata": ["role: Blacksmith", "status: injured"]}
An edge is a connection between two nodes: {"from": "Mara", "to": "Riverton", "edgeType": "located_in"}. Edges can have an optional weight from 0 to 1 (strength or confidence; treated as 1 when not set).
A schema describes one type of node. For a schema named add_npc, MemoryMesh creates three tools:
add_npc creates an NPC. Fields marked as relationships also create edges to the nodes they name.
update_npc changes the fields you pass and keeps everything else. Passing metadata replaces the whole list.
delete_npc removes the NPC and its edges.
Every call is all-or-nothing: if anything is wrong (a missing required field, a link to a node that doesn't exist), nothing is saved, and the AI gets a clear error it can act on.
Each schema is a JSON file ending in .schema.json. This is the npc example that ships with MemoryMesh:
{
"name": "add_npc",
"description": "Add a new character (NPC) to the knowledge graph",
"properties": {
"name": { "type": "string", "description": "The character's unique name", "required": true },
"description": { "type": "string", "description": "Who the character is", "required": true },
"status": { "type": "string", "description": "Current condition", "enum": ["alive", "injured", "dead", "missing"] },
"traits": { "type": "array", "description": "Personality traits" },
"currentLocation": {
"type": "string",
"description": "Where the character is now",
"relationship": { "edgeType": "located_in", "description": "Where the character is now (must already exist)" }
}
},
"additionalProperties": true
}Key | Meaning |
| Must start with |
| Description of the |
| The fields. Each has a |
↳ |
|
↳ | A list of allowed values. |
↳ | Creates an edge ( |
|
|
If a schema file is invalid, MemoryMesh skips it, logs the reason, and starts with the others.
The SchemaManager lets you create and edit schemas visually (guide).
MemoryMesh ships with two small examples, npc and location. Ready-made sets for different uses are shared in Discussions:
People & organization: people, teams, projects, places and events (who reports to whom, who's responsible for what, who went where, birthdays)
Personal CRM: contacts, companies, interactions and follow-ups
Research & reading notes: sources, authors, concepts and notes
RPG & storytelling: the full set of 11 schemas for text-based games
Feel free to share your own.
These are always available, whatever schemas you use:
Tool | Purpose |
| Return the whole graph |
| Find nodes by name, type or metadata, with their direct neighbours |
| Return specific nodes by name, with their direct neighbours |
| Work with nodes of any type |
| Work with edges |
| Add or remove individual metadata entries |
Related MCP server: ainative-memory-mcp
You need Node.js 18 or newer and an MCP client such as Claude Desktop.
Download and build MemoryMesh:
git clone https://github.com/CheMiguel23/MemoryMesh.gitcd MemoryMeshnpm installnpm install also builds the project into dist/.
Add MemoryMesh to Claude Desktop. Open Settings → Developer → Edit Config and add:
{
"mcpServers": {
"memorymesh": {
"command": "node",
"args": ["/ABSOLUTE/PATH/TO/MemoryMesh/dist/index.js"]
}
}
}On Windows, double every backslash: "C:\\Projects\\MemoryMesh\\dist\\index.js".
Fully quit and restart Claude Desktop. MemoryMesh and its tools (add_npc, read_graph, ...) appear in the tools menu of the chat box.
git pullnpm installThen restart your MCP client. Updating keeps your memory file and any schemas you edited.
Environment variable | What it sets | Default |
| Path of the memory file |
|
| Folder containing |
|
Set them in your Claude Desktop config:
"memorymesh": {
"command": "node",
"args": ["/ABSOLUTE/PATH/TO/MemoryMesh/dist/index.js"],
"env": {
"MEMORYMESH_MEMORY_FILE": "/ABSOLUTE/PATH/TO/my-project/memory.json",
"MEMORYMESH_SCHEMAS_DIR": "/ABSOLUTE/PATH/TO/my-project/schemas"
}
}Keeping your schemas and memory in a folder of your own keeps them separate from the MemoryMesh code. You can also run several MemoryMesh entries with different folders, for example one per campaign or project.
Docker: docker build -t memorymesh . then docker run -i --rm -v memorymesh-data:/data memorymesh. The memory file is /data/memory.json inside the container.
The memory file stores one JSON object per line. The MemoryViewer displays it as a searchable table with stats (guide): open it in Chrome or Edge, click Select Memory File, and pick your memory.json.
Tell the AI what the memory is for, for example in a Claude Project's instructions: "Use the memorymesh tools to record every person, team and project I mention, and check the graph before answering questions about them."
The AI can be hesitant to delete things. Ask explicitly when you want something removed.
When information conflicts, the latest update wins. To keep both versions, record the source or date in metadata ("source: tavern gossip", "as of: chapter 3"), or store competing claims as separate nodes.
MemoryMesh doesn't appear in Claude Desktop: check that the path in the config is absolute and points to dist/index.js (with doubled backslashes on Windows), and that npm install finished without errors.
Tools are missing: check that your schema files end in .schema.json and that their name starts with add_.
Check the log, where MemoryMesh reports which schemas it loaded and why any were skipped:
macOS: ~/Library/Logs/Claude/mcp-server-memorymesh.log
Windows: the logs folder inside %APPDATA%\Claude
npm install # also builds
npm test # runs the test suite
npm run watch # recompiles on changeFile | Purpose |
| Entry point: loads schemas and starts the server on stdio |
| Lists tools and routes each tool call to its handler |
| Definitions of the built-in tools |
| Loads schema files and implements the generated |
| The graph operations themselves, with input validation |
| Reads and writes the memory file, one change at a time |
| Paths and version |
| Shared types |
Contributions, feedback, ideas and schema sets are welcome. Open an issue, start a discussion, or send a pull request.
Add a new artifact or unique item to the knowledge graph
Inputs: artifact (required).
Represents a type of currency in the game world.
Inputs: currency (required).
Add multiple new edges between nodes in the knowledge graph. Edges should be in active voice
Inputs: edges (required).
A faction or organization operating within the game world.
Inputs: faction (required).
A collection of items or equipment belonging to a character, entity, or location.
Inputs: inventory (required).
Add a new location to the knowledge graph
Inputs: location (required).
Add new metadata to existing nodes in the knowledge graph
Inputs: metadata (required).
Add multiple new nodes in the knowledge graph
Inputs: nodes (required).
Add a new Non-Player Character (NPC) to the knowledge graph
Inputs: npc (required).
Add a new Player Character to the knowledge graph
Inputs: player_character (required).
Add a new Quest to the knowledge graph
Inputs: quest (required).
Defines list of skills or abilities a character can possess.
Inputs: skills (required).
Represents a specific point in time and its associated environmental conditions.
Inputs: temporal (required).
Represents a transportation owned or used by a character or entity.
Inputs: transportation (required).
Delete an existing artifact from the knowledge graph
Inputs: delete_artifact (required).
Delete an existing currency from the knowledge graph
Inputs: delete_currency (required).
Delete multiple edges from the knowledge graph
Inputs: edges (required).
Delete an existing faction from the knowledge graph
Inputs: delete_faction (required).
Delete an existing inventory from the knowledge graph
Inputs: delete_inventory (required).
Delete an existing location from the knowledge graph
Inputs: delete_location (required).
Delete specific metadata from nodes in the knowledge graph
Inputs: deletions (required).
Delete multiple nodes and their associated edges from the knowledge graph
Inputs: nodeNames (required).
Delete an existing npc from the knowledge graph
Inputs: delete_npc (required).
Delete an existing player_character from the knowledge graph
Inputs: delete_player_character (required).
Delete an existing quest from the knowledge graph
Inputs: delete_quest (required).
Delete an existing skills from the knowledge graph
Inputs: delete_skills (required).
Delete an existing temporal from the knowledge graph
Inputs: delete_temporal (required).
Delete an existing transportation from the knowledge graph
Inputs: delete_transportation (required).
Open specific nodes in the knowledge graph by their names
Inputs: names (required).
Read the entire knowledge graph
Inputs: no named parameters.
Search for nodes in the knowledge graph based on a query
Inputs: query (required).
Update an existing artifact in the knowledge graph
Inputs: update_artifact (required).
Update an existing currency in the knowledge graph
Inputs: update_currency (required).
Update existing edges in the knowledge graph
Inputs: edges (required).
Update an existing faction in the knowledge graph
Inputs: update_faction (required).
Update an existing inventory in the knowledge graph
Inputs: update_inventory (required).
Update an existing location in the knowledge graph
Inputs: update_location (required).
Update existing nodes in the knowledge graph
Inputs: nodes (required).
Update an existing npc in the knowledge graph
Inputs: update_npc (required).
Update an existing player_character in the knowledge graph
Inputs: update_player_character (required).
Update an existing quest in the knowledge graph
Inputs: update_quest (required).
Update an existing skills in the knowledge graph
Inputs: update_skills (required).
Update an existing temporal in the knowledge graph
Inputs: update_temporal (required).
Update an existing transportation in the knowledge graph
Inputs: update_transportation (required).
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 44 tools
Each tool has a clearly distinct purpose targeting specific entity types (e.g., artifact, currency, faction) or graph operations (e.g., add_edges, read_graph, search_nodes). The CRUD pattern per entity eliminates ambiguity, as tools are differentiated by both action (add/update/delete) and target resource.
All tools follow a consistent verb_noun pattern with snake_case, using verbs like add, delete, update, read, search, and open paired with specific nouns. This uniformity makes the tool set predictable and easy to navigate, with no deviations in naming conventions.
With 44 tools, the count is excessive for the server's purpose of managing a knowledge graph for game worlds. While the tools cover many entities, the high number could overwhelm agents and suggests over-specialization, as similar operations are duplicated across numerous entity types rather than generalized.
The tool set provides comprehensive CRUD coverage for all key game world entities (e.g., artifacts, currencies, factions, NPCs) and essential graph operations (e.g., add/update/delete nodes/edges, read, search). No obvious gaps exist; agents can fully manage the knowledge graph lifecycle without dead ends.
Repository knowledge graph MCP server for codebase understanding and debugging.
MCP server for querying BrainKB, a knowledge base for neuroscience knowledge graphs.
Personal knowledge graph as an AI memory layer over MCP - read, save, and link your memories.
Personal knowledge base MCP server with semantic search, auto-categorization, metadata extraction
