---
name: knowledge
description: >
  Unified knowledge management with intelligent routing across Dify KB, WikiJS, Supabase, Context7 and local docs. Detects gaps and suggests content creation.
  Use when searching documentation, looking for best practices, researching solutions, or when user mentions
  "how to", "documentation", "knowledge base", "search docs", "find information", "best practices", "procedures", "guides".
author: Descomplicar® Crescimento Digital
version: 1.1.0
user_invocable: true
tags: [knowledge, kb, dify, wikijs, supabase, context7, search, documentation]
desk_task: 1474
allowed-tools: Read, Grep, mcp__notebooklm__notebook_query, mcp__dify-kb__dify_kb_retrieve_segments, mcp__wikijs__search_pages, mcp__memory-supabase__search_memories, mcp__context7__get-library-docs
category: productivity
quality_score: 85
updated: "2026-02-04T18:00:00Z"
---

# /knowledge - Gestão Unificada de Conhecimento

Pesquisa inteligente com routing automático entre todas as fontes de conhecimento.

## Arquitectura

```
Pergunta → Router → Fonte Adequada → Resultado Agregado
                ↓
           Detecta Lacunas → Sugere Criação
```

| Fonte | MCP | Tipo de Conhecimento |
|-------|-----|---------------------|
| **Dify KB** | dify-kb | RAG, 74 datasets temáticos |
| **WikiJS** | wikijs | Documentação estruturada, procedimentos |
| **Supabase** | memory-supabase | Memória sessões, decisões, contexto |
| **Context7** | context7 | Docs bibliotecas externas |
| **Docs Locais** | filesystem | Ficheiros GDrive, Obsidian |

---

## Comandos

| Comando | Uso |
|---------|-----|
| `/knowledge [termo]` | Pesquisa inteligente com routing |
| `/kb [termo]` | Alias curto |
| `/kb-sync` | Sincronizar índice com Dify KB (actualiza IDs e docs) |
| `/kb-save [tema]` | Guardar conhecimento na fonte adequada |
| `/kb-gaps` | Listar lacunas identificadas |
| `/kb-new [tema]` | Criar novo dataset Dify |

---

## Routing por Tema

### Marketing e Conteúdo
```
Tema: marketing, SEO, copywriting, redes sociais
1ª Fonte: Dify (Marketing Digital, SEO, Neil Patel, Copywriting)
2ª Fonte: WikiJS (estratégias)
3ª Fonte: Supabase (decisões passadas)
```

### WordPress e Web
```
Tema: WordPress, Elementor, WooCommerce, plugins
1ª Fonte: Dify (WordPress, Elementor, Crocoblock)
2ª Fonte: Context7 (docs oficiais)
3ª Fonte: Docs Locais (código)
```

### CRM e Clientes
```
Tema: clientes, Perfex, projectos, facturação
1ª Fonte: Supabase (contexto recente)
2ª Fonte: Dify (PerfexCRM)
3ª Fonte: WikiJS (procedimentos)
```

### Desenvolvimento
```
Tema: código, API, PHP, React, Node
1ª Fonte: Context7 (docs bibliotecas)
2ª Fonte: Dify (TI, Dev Software)
3ª Fonte: Docs Locais (projectos)
```

### Infraestrutura
```
Tema: servidor, CWP, Linux, deploy
1ª Fonte: WikiJS (procedimentos)
2ª Fonte: Dify (TI, CWP, Linux)
3ª Fonte: Supabase (configurações)
```

### Estratégia e Gestão
```
Tema: estratégia, projectos, processos
1ª Fonte: Dify (Estratégia, Gestão Projetos)
2ª Fonte: WikiJS (planos)
3ª Fonte: Supabase (decisões)
```

### Decisões e Contexto
```
Tema: decisão, porque, contexto, histórico
1ª Fonte: Supabase (memória longo prazo)
2ª Fonte: Obsidian (notas)
3ª Fonte: Dify (Data Lake)
```

---

## Workflow Completo

### Passo 1: Análise do Termo

```javascript
// Input: "/knowledge como configurar crocoblock filters"

function analisarQuery(query) {
  const keywords = {
    tecnico: /código|api|php|react|node|servidor|linux|deploy|git/i,
    wordpress: /wordpress|elementor|crocoblock|woocommerce|plugin/i,
    marketing: /seo|marketing|copywriting|redes sociais|instagram/i,
    crm: /cliente|perfex|crm|facturação|orçamento/i,
    estrategia: /estratégia|plano|decisão|porque|contexto/i,
    procedimento: /como|tutorial|guia|passo a passo|procedimento/i
  };

  for (const [categoria, pattern] of Object.entries(keywords)) {
    if (pattern.test(query)) {
      return categoria;
    }
  }

  return 'geral';  // Default se não detectar categoria
}

const categoria = analisarQuery(query);  // 'wordpress'
```

### Passo 2: Determinar Fontes Prioritárias

```javascript
const routing = {
  wordpress: [
    { fonte: 'dify', datasets: ['crocoblock-kb', 'elementor', 'wordpress'] },
    { fonte: 'context7', libraries: ['elementor', 'woocommerce'] },
    { fonte: 'docs-locais', paths: ['/Projectos/*/wp-content/'] }
  ],
  marketing: [
    { fonte: 'dify', datasets: ['marketing-digital', 'seo', 'copywriting'] },
    { fonte: 'wikijs', tags: ['marketing', 'estrategia'] },
    { fonte: 'supabase', tags: ['decisao', 'marketing'] }
  ],
  crm: [
    { fonte: 'supabase', tags: ['cliente', 'crm'] },
    { fonte: 'dify', datasets: ['perfexcrm'] },
    { fonte: 'wikijs', tags: ['procedimento', 'crm'] }
  ],
  tecnico: [
    { fonte: 'context7', libraries: ['auto-detect'] },
    { fonte: 'dify', datasets: ['ti', 'desenvolvimento-software'] },
    { fonte: 'docs-locais', paths: ['/Dev/'] }
  ],
  estrategia: [
    { fonte: 'supabase', tags: ['decisao', 'contexto'] },
    { fonte: 'obsidian', folders: ['01-Projectos/', '02-Areas/'] },
    { fonte: 'dify', datasets: ['data-lake-descomplicar'] }
  ],
  procedimento: [
    { fonte: 'wikijs', all: true },
    { fonte: 'dify', datasets: ['procedimentos'] },
    { fonte: 'obsidian', folders: ['03-Recursos/Procedimentos/'] }
  ]
};

const fontes_prioritarias = routing[categoria];
```

### Passo 3: Pesquisa Sequencial

```javascript
async function pesquisar(query, categoria) {
  const fontes = routing[categoria];
  let resultados = [];

  for (const fonte of fontes) {
    let resultado;

    switch (fonte.fonte) {
      case 'dify':
        // Pesquisar em paralelo nos datasets
        const promessas = fonte.datasets.map(ds_id =>
          mcp__dify-kb__dify_kb_retrieve_segments({
            dataset_id: resolverDatasetID(ds_id),
            query: query,
            top_k: 3
          })
        );
        resultado = await Promise.all(promessas);
        break;

      case 'wikijs':
        resultado = await mcp__wikijs__search_pages({ query });
        break;

      case 'supabase':
        resultado = await mcp__memory-supabase__search_memories({
          query,
          tags: fonte.tags
        });
        break;

      case 'context7':
        // Detectar bibliotecas mencionadas no query
        const libs = detectarBibliotecas(query);
        resultado = await Promise.all(
          libs.map(lib => mcp__context7__get-library-docs({ library: lib }))
        );
        break;

      case 'docs-locais':
        // Grep nos paths
        resultado = await Grep({
          pattern: extrairKeywords(query).join('|'),
          path: fonte.paths[0],
          output_mode: 'content'
        });
        break;

      case 'obsidian':
        // Pesquisa nos folders
        resultado = await Promise.all(
          fonte.folders.map(folder =>
            Grep({
              pattern: extrairKeywords(query).join('|'),
              path: `/media/ealmeida/Dados/Hub/${folder}`,
              output_mode: 'content'
            })
          )
        );
        break;
    }

    // Avaliar relevância
    const relevante = avaliarRelevancia(resultado, query);

    if (relevante.score > 70) {
      // Resultado suficiente, parar pesquisa
      return { resultados: relevante.data, fonte: fonte.fonte };
    } else if (relevante.score > 30) {
      // Adicionar mas continuar pesquisando
      resultados.push({ ...relevante, fonte: fonte.fonte });
    }
  }

  // Retornar agregado se nenhuma fonte teve score >70
  return {
    resultados: agregrarResultados(resultados),
    fonte: 'multiplas',
    lacuna: resultados.length === 0
  };
}
```

### Passo 4: Resposta Estruturada

```markdown
## Resultado: como configurar crocoblock filters

### Encontrado em Dify KB (Crocoblock)

**Configuração Filters JetEngine:**

1. Criar Query Builder no JetEngine
2. Definir filtros (taxonomy, meta fields, search)
3. Criar Filter Widget no Elementor
4. Conectar filtro ao Listing Grid
5. Configurar AJAX para loading dinâmico

**Documentação oficial:** [link]

### Relacionado

- [[JetEngine-Query-Builder|Guia Query Builder]]
- Dify KB: Elementor > Filtros Dinâmicos
- WikiJS: Procedimentos > Crocoblock Setup

### Qualidade da Resposta

✅ Completo (score: 85/100)
📊 3 segments de Dify KB
🔗 2 links relacionados
⏱️ Tempo de pesquisa: 1.2s
```

### Passo 5: Detectar e Reportar Lacunas

```javascript
if (resultado.lacuna || resultado.score < 50) {
  // Registar lacuna
  await mcp__memory-supabase__save_memory({
    content: `LACUNA: Query "${query}" não encontrou informação adequada.`,
    metadata: {
      type: 'lacuna-kb',
      categoria: categoria,
      query: query,
      score: resultado.score,
      date: new Date().toISOString()
    }
  });

  // Sugerir criação de conteúdo
  console.log(`
> [!warning] Lacuna Detectada
> Tema "${query}" tem informação insuficiente (score: ${resultado.score}).
>
> **Sugestões:**
> - [ ] Criar dataset Dify: "${categoria}-${extrairTema(query)}"
> - [ ] Criar página WikiJS: "Procedimentos/${extrairTema(query)}"
> - [ ] Guardar em Supabase se for decisão importante
  `);
}
```

---

## MCPs Disponíveis

### Knowledge Sources

**Primario:** NotebookLM
**Fallback:** Dify KB
```
mcp__dify-kb__dify_kb_list_datasets          # Listar datasets
mcp__dify-kb__dify_kb_retrieve_segments      # Pesquisar (dataset_id, query)
mcp__dify-kb__dify_kb_create_dataset         # Criar dataset
mcp__dify-kb__dify_kb_create_document_text   # Adicionar documento
```

### WikiJS
```
mcp__wikijs__search_pages    # Pesquisar (query)
mcp__wikijs__get_page_by_id  # Obter página
mcp__wikijs__get_all_pages   # Listar todas
```

### Supabase Memory
```
mcp__memory-supabase__search_memories  # Pesquisar (query)
mcp__memory-supabase__save_memory      # Guardar (content, metadata)
mcp__memory-supabase__get_all_memories # Listar todas
```

### Context7
```
mcp__context7__resolve-library-id  # Resolver biblioteca
mcp__context7__get-library-docs    # Obter docs
```

### Filesystem (Docs Locais)
```
Grep/Glob em:
- /media/ealmeida/Dados/Hub/ (Obsidian vault)
- /media/ealmeida/Dados/GDrive/Projectos/
```

---

## Datasets Dify Principais

### Por Categoria
| Categoria | Datasets | Total Docs |
|-----------|----------|------------|
| Marketing | Marketing Digital, SEO, Copywriting, Neil Patel | 200+ |
| WordPress | WordPress, Elementor, Crocoblock | 470+ |
| Gestão | Gestão Projetos, Estratégia, Produtividade | 50+ |
| Técnico | TI, Dev Software, Linux, AWS | 130+ |
| Clientes | ESP, SNT, Espiral Senior | 140+ |

### IDs Frequentes
Ver mapeamento completo em: `config/sources.json`

---

## Detecção de Lacunas

### Quando Detectar
- Pesquisa retorna 0 resultados
- Resultados irrelevantes para o contexto
- Tema recorrente sem documentação
- Decisão importante não registada

### Acção Sugerida
```markdown
> [!warning] Lacuna Detectada
> Tema "[X]" não tem documentação adequada.
>
> Sugestão:
> - [ ] Criar dataset Dify: [nome sugerido]
> - [ ] Criar página WikiJS: [path sugerido]
> - [ ] Guardar em Supabase: [se for decisão/contexto]
```

---

## Lacunas Conhecidas

### Datasets Dify em Falta
- [ ] Claude Code (boas práticas, skills, hooks)
- [ ] MCP Servers (configuração, troubleshooting)
- [ ] Obsidian (workflows, plugins, templates)
- [ ] Git/Gitea (workflows, CI/CD)
- [ ] EasyPanel (deploy, containers)

### Páginas WikiJS em Falta
- [ ] Arquitectura do Sistema (Stack completo)
- [ ] Guia MCPs Disponíveis
- [ ] Procedimentos de Backup
- [ ] Onboarding Novos Projectos

---

## Sincronização (/kb-sync)

O comando `/kb-sync` actualiza automaticamente o índice de datasets Dify.

### O que faz
1. Lista todos os datasets via `mcp__dify-kb__dify_kb_list_datasets`
2. Compara com `config/sources.json`
3. Actualiza IDs, nomes e contagem de documentos
4. Detecta datasets novos (não mapeados)
5. Detecta datasets removidos
6. Actualiza timestamp `last_sync`

### Quando usar
- Após criar/remover datasets no Dify
- Periodicamente (semanal recomendado)
- Quando pesquisas falham por ID inválido

### Output esperado
```markdown
## Sync Concluído

**Datasets:** 73 (anterior: 74)
**Actualizados:** 5
**Novos:** 0
**Removidos:** 1 (Demo Teste Agosto 2025)

### Alterações
| Dataset | Mudança |
|---------|---------|
| marketing-digital | docs: 81 → 85 |
| crocoblock-kb | docs: 403 → 410 |
```

### Estrutura do sources.json
```json
{
  "version": "1.1.0",
  "updated": "2026-01-25T15:30:00Z",
  "last_sync": "2026-01-25T15:30:00Z",
  "total_datasets": 73,
  "dify_datasets": {
    "nome-slug": {
      "id": "uuid-do-dify",
      "name": "Nome Original",
      "docs": 123
    }
  }
}
```

---

## Workflow Guardar Conhecimento

### /kb-save [tema]
```
1. Analisar tipo de conhecimento
2. Determinar destino:
   - Decisão/Contexto → Supabase
   - Procedimento → WikiJS
   - Conhecimento temático → Dify KB
3. Formatar conteúdo
4. Guardar com metadata adequada
5. Confirmar gravação
```

---

## Exemplos de Uso

### Pesquisa Técnica
```
/kb como configurar crocoblock filters
→ Dify (Crocoblock) → Context7 (docs) → resultado agregado
```

### Pesquisa Contexto
```
/kb porque escolhemos easypanel
→ Supabase (decisões) → Obsidian (notas) → resultado
```

### Pesquisa Procedimento
```
/kb como fazer backup wordpress
→ WikiJS (procedimentos) → Dify (WordPress) → resultado
```

### Guardar Decisão
```
/kb-save decisão
"Escolhemos Remotion para vídeos porque..."
→ Supabase com tags: [decisão, video, remotion]
```

---

## Referências

- [[03-Recursos/Indice-Conhecimento]] - Inventário completo de fontes
- [[StackUpdate]] - Roadmap do sistema

---

---

## Datasets Dify (Consulta Obrigatória)

Esta skill já faz routing automático para datasets Dify, mas em caso de dúvidas técnicas sobre a própria gestão de conhecimento:

| Dataset | ID | Prioridade |
|---------|----|-----------:|
| **Data Lake Descomplicar** | `b4e233d6-0d78-42f6-aef4-a56280600fe8` | 1 |
| **Dify** | `44d1517b-65b8-4d81-8253-5683ff0b8830` | 2 |
| **Obsidian + Claude Code** | `e38a510f-ca93-4407-8b44-c4c66efe01f8` | 2 |

### Como Consultar

```javascript
# PRIMARIO: NotebookLM (Gemini 2.5 RAG)
# mcp__notebooklm__notebook_query({notebook_id: "0c9c079c-a426-486c-99eb-1564d42d37ad", query: "<tema>"})  // Gestao de Projectos e Agile
# mcp__notebooklm__notebook_query({notebook_id: "f9dc59c2-718b-4b12-bd06-095d4bfa3e34", query: "<tema>"})  // Gestao de Operacoes
# mcp__notebooklm__notebook_query({notebook_id: "79d43410-0e29-4be1-881d-84db6bdc239a", query: "<tema>"})  // Estrategia e Empreendedorismo
# mcp__notebooklm__notebook_query({notebook_id: "ebee9fe1-78fd-4f85-8938-f19f3ea32131", query: "<tema>"})  // Obsidian + Claude
# FALLBACK: Dify KB (se NotebookLM insuficiente)

// Pesquisar no Data Lake geral
mcp__dify-kb__dify_kb_retrieve_segments({
  dataset_id: "b4e233d6-0d78-42f6-aef4-a56280600fe8",
  query: "[termo de pesquisa]"
})

// Configuração e uso do Dify
mcp__dify-kb__dify_kb_retrieve_segments({
  dataset_id: "44d1517b-65b8-4d81-8253-5683ff0b8830",
  query: "dataset segment retrieval"
})

// Integração Obsidian + Claude
mcp__dify-kb__dify_kb_retrieve_segments({
  dataset_id: "e38a510f-ca93-4407-8b44-c4c66efe01f8",
  query: "vault workflow dataview"
})
```

### Quando Consultar

- Configurar novo dataset Dify
- Optimizar estratégia de retrieval
- Integrar Obsidian com Claude Code
- Criar workflows de gestão de conhecimento

---

## Checklist de Pesquisa

Antes de responder ao utilizador:

- [ ] Categoria correctamente identificada
- [ ] Fontes prioritárias consultadas
- [ ] Score de relevância >70 (ou >30 agregado)
- [ ] Lacunas detectadas e reportadas
- [ ] Resultados formatados correctamente
- [ ] Links relacionados incluídos

---

## Changelog

### v1.1.0 (2026-02-03)
- **Workflow completo** - 5 passos detalhados com código
- **Routing inteligente** - Mapeamento categoria → fontes
- **Pesquisa paralela** - Múltiplos datasets Dify simultâneos
- **Score de relevância** - Avaliação automática (0-100)
- **Detecção de lacunas** - Auto-report e sugestões
- **Checklist** - Validação antes de responder

### v1.0.0 (2026-01-25)
- Versão inicial
- Routing manual por tema
- Datasets Dify mapeados
- Integração com 5 fontes

---

**Versão**: 1.1.0 | **Data**: 2026-02-03 | **Autor**: Descomplicar®