Knowledge Graph Memory Server

Permite memória de projeto usando um grafo de conhecimento alimentado por Kuzu.

GitHubExperimente este MCPPatrocinado

Documentação

Knowledge Graph Memory Server

Uma implementação básica de memória persistente usando um grafo de conhecimento local alimentado pelo banco de dados de grafo embarcado Kuzu.

Conceitos Principais

Entidades

Entidades são os nós primários no grafo de conhecimento. Cada entidade possui:

  • Um nome único (identificador)
  • Um tipo de entidade (ex.: "pessoa", "organização", "evento")
  • Uma lista de observações

Exemplo:

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

Relações

Relações definem conexões direcionadas entre entidades. Elas são sempre armazenadas na voz ativa e descrevem como as entidades interagem ou se relacionam entre si.

Exemplo:

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

Observações

Observações são informações discretas sobre uma entidade. Elas são:

  • Armazenadas como strings
  • Anexadas a entidades específicas
  • Podem ser adicionadas ou removidas independentemente
  • Devem ser atômicas (um fato por observação)

Exemplo:

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

Tags

Tags fornecem uma maneira flexível de categorizar e organizar entidades e observações. Elas permitem:

  • Classificação transversal de entidades e observações
  • Filtragem e descoberta fáceis de informações relacionadas
  • Organização hierárquica com categorias opcionais
  • Armazenamento de metadados com descrições

Exemplo:

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

Tags podem ser aplicadas a:

  • Entidades: Para categorizar pessoas, projetos, conceitos, etc.
  • Observações: Para marcar fatos específicos com metadados como confiança, fonte ou relevância

API

Ferramentas

  • create_entities

    • Cria múltiplas novas entidades no grafo de conhecimento
    • Entrada: entities (array de objetos)
      • Cada objeto contém:
        • name (string): Identificador da entidade
        • entityType (string): Classificação de tipo
        • observations (string[]): Observações associadas
    • Ignora entidades com nomes existentes

  • create_relations

    • Cria múltiplas novas relações entre entidades
    • Entrada: relations (array de objetos)
      • Cada objeto contém:
        • from (string): Nome da entidade de origem
        • to (string): Nome da entidade de destino
        • relationType (string): Tipo de relacionamento na voz ativa
    • Ignora relações duplicadas

  • add_observations

    • Adiciona novas observações a entidades existentes
    • Entrada: observations (array de objetos)
      • Cada objeto contém:
        • entityName (string): Entidade de destino
        • contents (string[]): Novas observações a adicionar
    • Retorna observações adicionadas por entidade
    • Falha se a entidade não existir

  • delete_entities

    • Remove entidades e suas relações
    • Entrada: entityNames (string[])
    • Exclusão em cascata das relações associadas
    • Operação silenciosa se a entidade não existir

  • delete_observations

    • Remove observações específicas de entidades
    • Entrada: deletions (array de objetos)
      • Cada objeto contém:
        • entityName (string): Entidade de destino
        • observations (string[]): Observações a remover
    • Operação silenciosa se a observação não existir

  • delete_relations

    • Remove relações específicas do grafo
    • Entrada: relations (array de objetos)
      • Cada objeto contém:
        • from (string): Nome da entidade de origem
        • to (string): Nome da entidade de destino
        • relationType (string): Tipo de relacionamento
    • Operação silenciosa se a relação não existir

  • read_graph

    • Lê todo o grafo de conhecimento
    • Nenhuma entrada necessária
    • Retorna a estrutura completa do grafo com todas as entidades e relações

  • search_nodes

    • Busca por nós com base na consulta
    • Entrada: query (string)
    • Busca em:
      • Nomes de entidades
      • Tipos de entidades
      • Conteúdo das observações
    • Retorna entidades correspondentes e suas relações

  • open_nodes

    • Recupera nós específicos pelo nome
    • Entrada: names (string[])
    • Retorna:
      • Entidades solicitadas
      • Relações entre as entidades solicitadas
    • Ignora silenciosamente nós inexistentes

  • tag_entity

    • Adiciona tags a entidades
    • Entrada: entityName (string), tagNames (string[])
    • Cria tags se elas não existirem
    • Retorna array de tags adicionadas com sucesso

  • tag_observation

    • Adiciona tags a observações específicas
    • Entrada: entityName (string), observationContent (string), tagNames (string[])
    • Cria tags se elas não existirem
    • Retorna array de tags adicionadas com sucesso

  • get_entities_by_tag

    • Encontra entidades com uma tag específica
    • Entrada: tagName (string)
    • Retorna entidades e suas relações que possuem a tag especificada

  • get_all_tags

    • Lista todas as tags disponíveis
    • Nenhuma entrada necessária
    • Retorna todas as tags com suas categorias e descrições

  • get_tag_usage

    • Obtém estatísticas de uso das tags
    • Nenhuma entrada necessária
    • Retorna contagens de uso de tags para entidades e observações

  • remove_tags_from_entity

    • Remove tags específicas de uma entidade
    • Entrada: entityName (string), tagNames (string[])
    • Retorna array de tags removidas com sucesso

Uso

Configuração

Adicione isso à configuração do seu servidor MCP:

NPX

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

O arquivo de banco de dados será criado automaticamente se não existir. Escolha um local onde você deseja armazenar persistentemente os dados do seu grafo de conhecimento.

Configuração do VS Code

Opcionalmente, você pode adicioná-lo a um arquivo chamado .vscode/mcp.json no seu workspace. Isso permitirá que você compartilhe a configuração com outras pessoas.

Observe que a chave mcp não é necessária no arquivo .vscode/mcp.json.

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

Exemplos de Uso

Gerenciamento Básico de Entidades e Relações

// 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'],
});

Descoberta e Organização

// 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 do Sistema

O prompt para utilizar a memória depende do caso de uso. Alterar o prompt ajudará o modelo a determinar a frequência e os tipos de memórias criadas.

Aqui está um exemplo de prompt para gerenciamento de contexto de projeto com tags.

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"

Compilação

npm run build

Licença

Este servidor MCP é licenciado sob a Licença MIT. Isso significa que você é livre para usar, modificar e distribuir o software, sujeito aos termos e condições da Licença MIT. Para mais detalhes, consulte o arquivo LICENSE no repositório do projeto.