Knowledge Graph Memory Server MCP Server

Knowledge Graph Memory Server

A basic implementation of persistent memory using a local knowledge graph powered by Kuzu embedded graph database.

Core Concepts

Entities

Entities are the primary nodes in the knowledge graph. Each entity has:

• A unique name (identifier)
• An entity type (e.g., "person", "organization", "event")
• A list of observations

Example:

{
  "name": "John_Smith",
  "entityType": "person",
  "observations": ["Speaks fluent Spanish"]
}

Relations

Relations define directed connections between entities. They are always stored in active voice and describe how entities interact or relate to each other.

Example:

{
  "from": "John_Smith",
  "to": "Anthropic",
  "relationType": "works_at"
}

Observations

Observations are discrete pieces of information about an entity. They are:

• Stored as strings
• Attached to specific entities
• Can be added or removed independently
• Should be atomic (one fact per observation)

Example:

{
  "entityName": "John_Smith",
  "observations": ["Speaks fluent Spanish", "Graduated in 2019", "Prefers morning meetings"]
}

Tags

Tags provide a flexible way to categorize and organize entities and observations. They enable:

• Cross-cutting classification of entities and observations
• Easy filtering and discovery of related information
• Hierarchical organization with optional categories
• Metadata storage with descriptions

Example:

{
  "name": "high-priority",
  "category": "priority",
  "description": "Items requiring immediate attention"
}

Tags can be applied to:

• Entities: For categorizing people, projects, concepts, etc.
• Observations: For marking specific facts with metadata like confidence, source, or relevance

API

Tools

• create_entities

  • Create multiple new entities in the knowledge graph
  • Input: entities (array of objects)
    • Each object contains:
      • name (string): Entity identifier
      • entityType (string): Type classification
      • observations (string[]): Associated observations
  • Ignores entities with existing names

• create_relations

  • Create multiple new relations between entities
  • Input: relations (array of objects)
    • Each object contains:
      • from (string): Source entity name
      • to (string): Target entity name
      • relationType (string): Relationship type in active voice
  • Skips duplicate relations

• add_observations

  • Add new observations to existing entities
  • Input: observations (array of objects)
    • Each object contains:
      • entityName (string): Target entity
      • contents (string[]): New observations to add
  • Returns added observations per entity
  • Fails if entity doesn't exist

• delete_entities

  • Remove entities and their relations
  • Input: entityNames (string[])
  • Cascading deletion of associated relations
  • Silent operation if entity doesn't exist

• delete_observations

  • Remove specific observations from entities
  • Input: deletions (array of objects)
    • Each object contains:
      • entityName (string): Target entity
      • observations (string[]): Observations to remove
  • Silent operation if observation doesn't exist

• delete_relations

  • Remove specific relations from the graph
  • Input: relations (array of objects)
    • Each object contains:
      • from (string): Source entity name
      • to (string): Target entity name
      • relationType (string): Relationship type
  • Silent operation if relation doesn't exist

• read_graph

  • Read the entire knowledge graph
  • No input required
  • Returns complete graph structure with all entities and relations

• search_nodes

  • Search for nodes based on query
  • Input: query (string)
  • Searches across:
    • Entity names
    • Entity types
    • Observation content
  • Returns matching entities and their relations

• open_nodes

  • Retrieve specific nodes by name
  • Input: names (string[])
  • Returns:
    • Requested entities
    • Relations between requested entities
  • Silently skips non-existent nodes

• tag_entity

  • Add tags to entities
  • Input: entityName (string), tagNames (string[])
  • Creates tags if they don't exist
  • Returns array of successfully added tags

• tag_observation

  • Add tags to specific observations
  • Input: entityName (string), observationContent (string), tagNames (string[])
  • Creates tags if they don't exist
  • Returns array of successfully added tags

• get_entities_by_tag

  • Find entities with a specific tag
  • Input: tagName (string)
  • Returns entities and their relations that have the specified tag

• get_all_tags

  • List all available tags
  • No input required
  • Returns all tags with their categories and descriptions

• get_tag_usage

  • Get usage statistics for tags
  • No input required
  • Returns tag usage counts for entit