Knowledge Graph Memory Server

Knowledge Graph Memory Server

Una implementación básica de memoria persistente que utiliza un grafo de conocimiento local impulsado por la base de datos de grafos embebida Kuzu.

Conceptos principales

Entidades

Las entidades son los nodos principales del grafo de conocimiento. Cada entidad tiene:

• Un nombre único (identificador)
• Un tipo de entidad (por ejemplo, "persona", "organización", "evento")
• Una lista de observaciones

Ejemplo:

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

Relaciones

Las relaciones definen conexiones dirigidas entre entidades. Siempre se almacenan en voz activa y describen cómo interactúan o se relacionan las entidades entre sí.

Ejemplo:

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

Observaciones

Las observaciones son piezas discretas de información sobre una entidad. Son:

• Almacenadas como cadenas de texto
• Adjuntas a entidades específicas
• Pueden añadirse o eliminarse de forma independiente
• Deben ser atómicas (un dato por observación)

Ejemplo:

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

Etiquetas

Las etiquetas proporcionan una forma flexible de categorizar y organizar entidades y observaciones. Permiten:

• Clasificación transversal de entidades y observaciones
• Filtrado y descubrimiento sencillo de información relacionada
• Organización jerárquica con categorías opcionales
• Almacenamiento de metadatos con descripciones

Ejemplo:

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

Las etiquetas pueden aplicarse a:

• Entidades: Para categorizar personas, proyectos, conceptos, etc.
• Observaciones: Para marcar datos específicos con metadatos como confianza, fuente o relevancia

API

Herramientas

• create_entities

  • Crear múltiples entidades nuevas en el grafo de conocimiento
  • Entrada: entities (matriz de objetos)
    • Cada objeto contiene:
      • name (cadena): Identificador de la entidad
      • entityType (cadena): Clasificación de tipo
      • observations (cadena[]): Observaciones asociadas
  • Ignora entidades con nombres existentes

• create_relations

  • Crear múltiples relaciones nuevas entre entidades
  • Entrada: relations (matriz de objetos)
    • Cada objeto contiene:
      • from (cadena): Nombre de la entidad de origen
      • to (cadena): Nombre de la entidad de destino
      • relationType (cadena): Tipo de relación en voz activa
  • Omite relaciones duplicadas

• add_observations

  • Añadir nuevas observaciones a entidades existentes
  • Entrada: observations (matriz de objetos)
    • Cada objeto contiene:
      • entityName (cadena): Entidad de destino
      • contents (cadena[]): Nuevas observaciones a añadir
  • Devuelve las observaciones añadidas por entidad
  • Falla si la entidad no existe

• delete_entities

  • Eliminar entidades y sus relaciones
  • Entrada: entityNames (cadena[])
  • Eliminación en cascada de las relaciones asociadas
  • Operación silenciosa si la entidad no existe

• delete_observations

  • Eliminar observaciones específicas de entidades
  • Entrada: deletions (matriz de objetos)
    • Cada objeto contiene:
      • entityName (cadena): Entidad de destino
      • observations (cadena[]): Observaciones a eliminar
  • Operación silenciosa si la observación no existe

• delete_relations

  • Eliminar relaciones específicas del grafo
  • Entrada: relations (matriz de objetos)
    • Cada objeto contiene:
      • from (cadena): Nombre de la entidad de origen
      • to (cadena): Nombre de la entidad de destino
      • relationType (cadena): Tipo de relación
  • Operación silenciosa si la relación no existe

• read_graph

  • Leer el grafo de conocimiento completo
  • No requiere entrada
  • Devuelve la estructura completa del grafo con todas las entidades y relaciones

• search_nodes

  • Buscar nodos según una consulta
  • Entrada: query (cadena)
  • Busca en:
    • Nombres de entidades
    • Tipos de entidades
    • Contenido de observaciones
  • Devuelve las entidades coincidentes y sus relaciones

• open_nodes

  • Recuperar nodos específicos por nombre
  • Entrada: names (cadena[])
  • Devuelve:
    • Entidades solicitadas
    • Relaciones entre las entidades solicitadas
  • Omite silenciosamente los nodos inexistentes

• tag_entity

  • Añadir etiquetas a entidades
  • Entrada: entityName (cadena), tagNames (cadena[])
  • Crea etiquetas si no existen
  • Devuelve una matriz de etiquetas añadidas correctamente

• tag_observation

  • Añadir etiquetas a observaciones específicas
  • Entrada: entityName (cadena), observationContent (cadena), tagNames (cadena[])
  • Crea etiquetas si no existen
  • Devuelve una matriz de etiquetas añadidas correctamente

• get_entities_by_tag

  • Encontrar entidades con una etiqueta específica
  • Entrada: tagName (cadena)
  • Devuelve entidades y sus relaciones que tienen la etiqueta especificada

• get_all_tags

  • Listar todas las etiquetas disponibles
  • No requiere entrada
  • Devuelve todas las etiquetas con sus categorías y descripciones

• get_tag_usage

  • Obtener estadísticas de uso de las etiquetas
  • No requiere entrada
  • Devuelve los recuentos de uso de etiquetas para entidades y observaciones

• remove_tags_from_entity

  • Eliminar etiquetas específicas de una entidad
  • Entrada: entityName (cadena), tagNames (cadena[])
  • Devuelve una matriz de etiquetas eliminadas correctamente

Uso

Configuración

Añade esto a la configuración de tu servidor MCP:

NPX

{
  "mcpServers": {
    "knowledge-graph": {
      "command": "npx",
      "args": ["-y", "@deanacus/knowledge-graph-mcp", "/path/to/your/knowledge-graph.db"]
    }
  }
}

El archivo de base de datos se creará automáticamente si no existe. Elige una ubicación donde quieras almacenar de forma persistente los datos de tu grafo de conocimiento.

Configuración de VS Code

Opcionalmente, puedes añadirlo a un archivo llamado .vscode/mcp.json en tu espacio de trabajo. Esto te permitirá compartir la configuración con otras personas.

Ten en cuenta que la clave mcp no es necesaria en el archivo .vscode/mcp.json.

{
  "servers": {
    "knowledge-graph": {
      "command": "npx",
      "args": ["-y", "@deanacus/knowledge-graph-mcp", "/path/to/your/knowledge-graph.db"]
    }
  }
}

Ejemplos de uso

Gestión básica de entidades y relaciones

// Create entities
await create_entities({
  entities: [
    {
      name: 'John_Smith',
      entityType: 'person',
      observations: ['Senior developer', 'Works remotely'],
    },
  ],
});

// Add tags to organize information
await tag_entity({
  entityName: 'John_Smith',
  tagNames: ['team-member', 'senior', 'remote-worker'],
});

// Tag specific observations
await tag_observation({
  entityName: 'John_Smith',
  observationContent: 'Works remotely',
  tagNames: ['work-style', 'post-covid'],
});

Descubrimiento y organización

// Find all team members
await get_entities_by_tag({ tagName: 'team-member' });

// Get all available tags to understand the knowledge graph structure
await get_all_tags();

// See which tags are most commonly used
await get_tag_usage();

Prompt del sistema

El prompt para utilizar la memoria depende del caso de uso. Cambiar el prompt ayudará al modelo a determinar la frecuencia y los tipos de memorias creadas.

Aquí hay un ejemplo de prompt para la gestión del contexto de proyectos con etiquetado.

Follow these steps for each interaction:

1. Project Context Identification:
   - Identify the current project or codebase you are working with
   - If project context is unclear, ask clarifying questions about the project scope and purpose

2. Memory Retrieval:
   - Always begin your chat by saying only "Remembering..." and retrieve all relevant project information from your knowledge graph
   - Use tags to filter relevant information for the current context (e.g., current project, specific features)
   - Always refer to your knowledge graph as your "project memory"

3. Project Information Organization:
   - Use tags to organize information by:
     a) Project phases (e.g., "planning", "development", "testing", "deployed")
     b) Components (e.g., "frontend", "backend", "database", "auth")
     c) Priority levels (e.g., "critical", "high-priority", "nice-to-have")
     d) Status (e.g., "completed", "in-progress", "blocked", "deprecated")
     e) People and roles (e.g., "stakeholder", "developer", "user")

4. Information Capture:
   - Continuously build understanding of the project by capturing any relevant information discovered during our work together
   - Be comprehensive in what you consider worth remembering - technical details, context, decisions, patterns, constraints, or any insights that could be valuable later

5. Memory Update:
   - If any new project information was discovered during the interaction, update your memory as follows:
     a) Create entities for items you deem worthwhile, particularly components, modules, classes, functions, key concepts, and tasks
     b) Connect them using relations to show dependencies, inheritance, or workflows
     c) Store technical details, decisions, and context as observations
     d) Apply relevant tags to entities and observations for easy discovery and organization
     e) Use consistent tag naming conventions (e.g., kebab-case like "high-priority", "in-progress")

6. Context Switching:
   - When switching between different aspects of the project, use tags to filter your memory retrieval
   - Example: "Remembering frontend components..." then retrieve entities tagged with "frontend"

Compilación

npm run build

Licencia

Este servidor MCP está licenciado bajo la Licencia MIT. Esto significa que eres libre de usar, modificar y distribuir el software, sujeto a los términos y condiciones de la Licencia MIT. Para más detalles, consulta el archivo LICENSE en el repositorio del proyecto.