Knowledge Graph Memory Server for AI Assistants

Overview

The Knowledge Graph Memory Server is a Swift implementation of a Model Context Protocol (MCP) server designed to manage knowledge graphs for AI assistants. It enables large language models (LLMs) to create, read, update, and delete entities and relationships in a persistent knowledge graph, allowing AI assistants to maintain memory across conversations.

Features

• Knowledge Graph Storage: Maintain a persistent graph of entities and their relationships.
• Entity Management: Create, retrieve, update, and delete entities with custom types.
• Relation Tracking: Define and manage relationships between entities in active voice.
• Observation System: Add and remove observations about entities over time.
• Powerful Search: Find relevant nodes by name, type, or observation content.
• Persistent Storage: Data persists between sessions in a simple JSON format.

Available Tools

• create_entities: Create multiple new entities in the knowledge graph.
• create_relations: Create multiple new relations between entities.
• add_observations: Add new observations to existing entities.
• delete_entities: Delete multiple entities and their associated relations.
• delete_observations: Delete specific observations from entities.
• delete_relations: Delete multiple relations from the knowledge graph.
• read_graph: Read the entire knowledge graph.
• search_nodes: Search for nodes in the knowledge graph based on a query.
• open_nodes: Open specific nodes in the knowledge graph by their names.

Installation

Option 1: One-Line Installation (curl)

curl -fsSL https://raw.githubusercontent.com/okooo5km/memory-mcp-server/main/install.sh | bash

Option 2: Build from Source

1. Clone the repository:
   shell git clone https://github.com/okooo5km/memory-mcp-server.git cd memory-mcp-server
2. Build the project:
   shell swift build -c release
3. Install the binary:
   shell mkdir -p ~/.local/bin cp $(swift build -c release --show-bin-path)/memory-mcp-server ~/.local/bin/

Configuration

Environment Variables

• MEMORY_FILE_PATH: Custom path for storing the knowledge graph (defaults to memory.json in the current working directory).

Configure for Claude.app

"mcpServers": {
  "memory": {
    "command": "memory-mcp-server",
    "env": {
      "MEMORY_FILE_PATH": "/path/to/your/memory.json"
    }
  }
}

Configure for Cursor

{
  "mcpServers": {
    "memory": {
      "command": "memory-mcp-server",
      "env": {
        "MEMORY_FILE_PATH": "/path/to/your/memory.json"
      }
    }
  }
}

Example System Prompt

You have access to a Knowledge Graph memory system, which can store and retrieve information across conversations. Use it to remember important details about the user, their preferences, and any facts they've shared.

Knowledge Graph Structure

• Entities: Nodes in the graph with a name, type, and list of observations.
• Relations: Edges between entities with a relation type in active voice.
• Observations: Facts or details associated with entities.

Usage Examples

Creating Entities

{
  "entities": [
    {
      "name": "John Smith",
      "entityType": "Person",
      "observations": ["Software engineer", "Lives in San Francisco", "Enjoys hiking"]
    }
  ]
}

Creating Relations

{
  "relations": [
    {
      "from": "John Smith",
      "to": "Acme Corp",
      "relationType": "works at"
    }
  ]
}

Adding Observations

{
  "observations": [
    {
      "entityName": "John Smith",
      "contents": ["Recently promoted to Senior Engineer", "Working on AI projects"]
    }
  ]
}

Use Cases

• Long-term Memory for AI Assistants: Remember user preferences and past interactions.
• Knowledge Management: Organize information about people, places, and concepts.
• Relationship Tracking: Maintain networks of relationships between entities.
• Context Persistence: Preserve important context across multiple sessions.

Version History

See GitHub Releases for version history and changelog.

Support the Project

• ⭐️ Star the project on GitHub.
• 🐛 Report bugs or suggest features.
• 💝 Support via Buy Me a Coffee.

License

Licensed under the MIT License.

About

A Swift implementation of a knowledge graph memory server for Model Context Protocol (MCP), based on the official TypeScript implementation.