name: knowledge-graph
description: Expert in using ALL search & memory MCPs together. Combines Memory, Context7, NotebookLM for persistent knowledge. Use for storing learnings, cross-session context, and intelligent recall across ALL projects.

🧠 Knowledge Graph Expert Skill (Full MCP Integration)

Master of knowledge persistence using 5 MCP servers together.

MCP Knowledge Stack

Advanced Knowledge Patterns

1. Session Initialization (Load Everything)

// Start of EVERY session - parallel load
Promise.all([
  mcp_Memory_read_graph(),                    // Full knowledge graph
  mcp_Memory_search_nodes("current project"), // Relevant entities
  mcp_NotebookLM_list_notebooks(),            // Available research
  mcp_Notion_API-post-search("project")       // Notion pages
])

2. Multi-Source Research Pipeline

// When researching a topic
const topic = "authentication patterns";

// Phase 1: Internal knowledge (parallel)
const [memoryResults, notebookResults] = await Promise.all([
  mcp_Memory_search_nodes(topic),
  mcp_NotebookLM_search_notebooks(topic)
]);

// Phase 2: External docs
const docs = await mcp_Context7_query-docs(
  libraryId,
  topic,
  // 50K tokens of documentation!
);

// Phase 3: Synthesize with deep thinking
const synthesis = await mcp_UltraThink_ultrathink({
  thought: `Synthesizing knowledge from:
    - Memory: ${memoryResults.length} entities
    - Notebooks: ${notebookResults.length} matches
    - Docs: ${docs.length} tokens

    Key insights: ...`,
  total_thoughts: 20,
  confidence: 0.9
});

3. Knowledge Capture (During Work)

// Capture insights as you work
await mcp_Memory_add_observations([{
  entityName: "CurrentProject",
  contents: [
    `[${new Date().toISOString()}] Discovered: ${insight}`,
    `Solution applied: ${solution}`,
    `Key learning: ${learning}`
  ]
}]);

4. Knowledge Persistence (After Success)

// After solving a problem - create full entity
await mcp_Memory_create_entities([{
  name: `Solution_${problemName}_${date}`,
  entityType: "Solution",
  observations: [
    `Problem: ${problemDescription}`,
    `Context: ${context}`,
    `Approach: ${approach}`,
    `Code pattern: ${codeSnippet}`,
    `Gotchas: ${gotchas}`,
    `Verified: ${verificationMethod}`
  ]
}]);

// Link to related concepts
await mcp_Memory_create_relations([
  { from: "Solution_Auth", to: "Pattern_JWT", relationType: "implements" },
  { from: "Solution_Auth", to: "Project_Main", relationType: "belongs_to" },
  { from: "Solution_Auth", to: "Learning_Security", relationType: "taught" }
]);

Entity Design Patterns

Standard Entity Types

Project      - Projects with tech stack, patterns used
Technology   - Languages, frameworks, libraries  
Pattern      - Reusable code patterns
Solution     - Solved problems with context
Learning     - Insights and lessons learned
Decision     - Key choices with rationale
Bug          - Encountered bugs and fixes
Person       - Team members, contacts

Entity Template

{
  "name": "UniqueIdentifier_Context",
  "entityType": "Solution|Pattern|Learning|...",
  "observations": [
    "[2026-01-28] Context: what was happening",
    "Problem: specific issue faced",
    "Solution: how it was solved",
    "Code: `key code snippet`",
    "Gotcha: what to watch out for",
    "Verified: how we know it works"
  ]
}

Relation Types (Active Voice)

implements   - Solution implements Pattern
uses         - Project uses Technology
solves       - Solution solves Bug
extends      - Pattern extends Pattern
requires     - Technology requires Technology
created_by   - Solution created_by Person
belongs_to   - Entity belongs_to Project
learned_from - Learning learned_from Bug

Cross-MCP Knowledge Flows

Memory ↔ Notion Sync

// Export Memory to Notion
const graph = await mcp_Memory_read_graph();
for (const entity of graph.entities) {
  await mcp_Notion_API-post-page({
    parent: { database_id: knowledgeDbId },
    properties: {
      title: [{ text: { content: entity.name } }],
      Type: { select: { name: entity.entityType } }
    },
    children: entity.observations.map(obs => ({
      object: "block",
      type: "bulleted_list_item",
      bulleted_list_item: {
        rich_text: [{ text: { content: obs } }]
      }
    }))
  });
}

Memory ↔ MongoDB Backup

// Backup full graph to MongoDB
const graph = await mcp_Memory_read_graph();
await mcp_MongoDB_insert-many(
  "knowledge",
  "graphs",
  [{
    timestamp: new Date(),
    entities: graph.entities,
    relations: graph.relations
  }]
);

NotebookLM → Memory Import

// Extract key learnings from notebook
const answer = await mcp_NotebookLM_ask_question(
  "What are the key patterns and best practices?",
  notebook_id
);

// Store in Memory
await mcp_Memory_create_entities([{
  name: `NotebookLearnings_${notebookName}`,
  entityType: "Learning",
  observations: extractBulletPoints(answer)
}]);

Secret Knowledge Techniques

1. Semantic Graph Traversal

// Follow relations to discover connected knowledge
const node = await mcp_Memory_open_nodes(["JWTAuth"]);
const related = node.relations.map(r => r.to);
const fullContext = await mcp_Memory_open_nodes(related);
// Now have full context graph

2. Temporal Knowledge Tracking

// Add timestamps to all observations
const obs = `[${new Date().toISOString()}] ${insight}`;
// Enables: "What did we learn last week?"

3. Confidence-Weighted Storage

// Store with confidence from UltraThink
const result = await mcp_UltraThink_ultrathink({...});
await mcp_Memory_add_observations([{
  entityName: "Solution_X",
  contents: [`[confidence: ${result.confidence}] ${result.thought}`]
}]);

4. Cross-Project Learning Transfer

// Find patterns that worked in other projects
const patterns = await mcp_Memory_search_nodes("Pattern");
const applicable = patterns.filter(p => 
  p.observations.some(o => o.includes(currentTechStack))
);

5. Knowledge Invalidation

// When something is proven wrong
await mcp_Memory_delete_observations([{
  entityName: "OldPattern",
  observations: ["This approach works for X"]
}]);
await mcp_Memory_add_observations([{
  entityName: "OldPattern", 
  contents: ["[DEPRECATED] Original approach. See NewPattern instead."]
}]);

6. 50K Token Context Injection

// Before complex task - load maximum context
const docs = await mcp_Context7_query-docs(
  "/vercel/next.js",
  "app router server components data fetching caching",
  // Returns up to 50,000 tokens!
);
// Now agent has full framework context

7. Deep Research → Knowledge Pipeline

// NotebookLM for research, Memory for persistence
const research = await mcp_NotebookLM_ask_question(q, nb);
const analysis = await mcp_UltraThink_ultrathink({
  thought: `Analyzing research: ${research}`,
  total_thoughts: 15
});
await mcp_Memory_create_entities([{
  name: "Research_" + topic,
  entityType: "Learning",
  observations: analysis.insights
}]);