Knowledge Organize

Knowledge Organize

This skill helps users maintain a healthy, well-connected knowledge graph. As notes accumulate, it becomes valuable to periodically organize, link, and curate the knowledge base.

When to Use

Use this skill when:

• User asks to organize their notes
• User wants to find connections between notes
• User mentions orphan or unlinked notes
• User wants to clean up or improve their knowledge base
• User asks about duplicate or similar notes
• User wants help with folder organization
• User asks to review or audit their notes
• Phrases like "help me organize", "find related notes", "what's not linked", "clean up my notes"

Organization Capabilities

1. Find Orphan Notes

Identify notes that have no relations to other notes - they're isolated in the knowledge graph.

# Get all notes
mcp__basic-memory__search_notes(
    query="*",
    page_size=50,
    project="main"
)

# For each note, check if it has relations
# Orphans have empty Relations sections

What to do with orphans:

• Suggest potential relations based on content similarity
• Ask if they should be linked to existing topics
• Propose creating hub notes to connect related orphans

2. Suggest Relations

Analyze note content and suggest meaningful connections.

# Read a note
mcp__basic-memory__read_note(
    identifier="note-to-analyze",
    project="main"
)

# Search for potentially related notes
mcp__basic-memory__search_notes(
    query="key terms from the note",
    project="main"
)

# Suggest relations based on:
# - Shared topics or concepts
# - Complementary content (problem/solution, question/answer)
# - Sequential relationship (part 1, part 2)
# - Hierarchical (parent concept, child detail)

Relation types to suggest:

• relates-to - General topical connection
• extends - Builds upon or expands
• implements - Realizes a concept
• depends-on - Requires understanding of
• contradicts - Presents alternative view
• learned-from - Source of insight
• enables - Makes something possible

3. Identify Similar/Duplicate Notes

Find notes that may cover the same topic.

# Search for notes with similar titles or content
mcp__basic-memory__search_notes(
    query="topic keywords",
    project="main"
)

# Compare results for overlap
# Look for:
# - Similar titles
# - Overlapping observations
# - Same tags
# - Related timestamps (created around same time)

Actions for duplicates:

• Merge into a single comprehensive note
• Link them with supersedes or updates relations
• Differentiate by adding context about their distinct focus

4. Folder Organization Review

Analyze folder structure and suggest improvements.

# List directory structure
mcp__basic-memory__list_directory(
    dir_name="/",
    depth=3,
    project="main"
)

# Identify:
# - Overcrowded folders
# - Single-note folders
# - Inconsistent naming
# - Notes that might belong elsewhere

Organization suggestions:

• Group related notes into topic folders
• Create subfolders for large categories
• Suggest consistent naming conventions
• Move misplaced notes

5. Tag Consistency

Review and normalize tags across notes.

# Search notes to analyze tag patterns
mcp__basic-memory__search_notes(
    query="*",
    page_size=100,
    project="main"
)

# Look for:
# - Similar tags (architecture vs arch)
# - Unused tags
# - Over-used generic tags
# - Missing tags on relevant notes

Tag improvements:

• Suggest tag standardization (pick one variant)
• Propose new tags for common themes
• Identify notes missing obvious tags

6. Create Index/Hub Notes

Generate notes that serve as navigation hubs for related topics.

# After identifying a cluster of related notes
mcp__basic-memory__write_note(
    title="Architecture Decisions Index",
    content="""---
title: Architecture Decisions Index
type: index
tags:
- architecture
- index
---

# Architecture Decisions Index

A hub linking all architecture-related decisions and patterns.

## Decisions

- [[Database Selection Decision]]
- [[API Design Patterns]]
- [[Authentication Architecture]]

## Patterns

- [[Repository Pattern]]
- [[Async Client Pattern]]

## Observations

- [index] Central hub for architecture knowledge #navigation

## Relations

- indexes [[Architecture]]
""",
    folder="indexes",
    project="main"
)

7. Enrich Sparse Notes

Find notes lacking observations or structure and suggest improvements.

# Read a sparse note
mcp__basic-memory__read_note(
    identifier="sparse-note",
    project="main"
)

# If missing:
# - Observations section → suggest categories
# - Relations section → suggest links
# - Tags → suggest relevant tags
# - Context → suggest adding background

Organization Workflows

Quick Health Check

A fast overview of knowledge base status:

1. Count total notes
2. Identify orphan count
3. List recently modified
4. Check for obvious duplicates
5. Report folder distribution

Deep Organization Session

Thorough review and improvement:

1. Audit phase - Catalog all notes, identify issues
2. Orphan phase - Address unlinked notes
3. Relation phase - Suggest new connections
4. Duplicate phase - Merge or differentiate similar notes
5. Structure phase - Reorganize folders if needed
6. Index phase - Create hub notes for major topics

Topic-Focused Organization

Organize around a specific subject:

1. Find all notes related to topic
2. Map existing relations
3. Identify gaps in the topic graph
4. Suggest new notes to fill gaps
5. Create topic index note

Best Practices

1. Work incrementally - Don't reorganize everything at once
2. Confirm before changing - Always ask before moving/editing notes
3. Preserve permalinks - Moving is okay, changing permalinks breaks links
4. Show the graph - Help user visualize connections
5. Explain suggestions - Say why a relation makes sense
6. Respect user's system - Enhance their organization, don't impose a new one

Example Conversations

User: "Help me organize my notes"

Claude:

1. Runs health check on the knowledge base
2. Reports: "You have 47 notes. I found 12 orphan notes and 3 potential duplicates."
3. Asks: "Would you like to start by connecting the orphan notes, or review the duplicates first?"

User: "Find notes that should be linked to my API design note"

Claude:

1. Reads the API design note
2. Searches for related content
3. Suggests: "I found 5 notes that could relate:
   • 'REST Best Practices' → relates-to
   • 'Authentication Flow' → implements
   • 'Rate Limiting Decision' → extends Would you like me to add any of these relations?"

User: "Are there any notes about similar topics?"

Claude:

1. Analyzes note titles and content
2. Identifies clusters of similar notes
3. Reports: "I found these potential overlaps:
   • 'Auth Flow' and 'Authentication Design' cover similar ground
   • 'DB Schema v1' and 'DB Schema v2' might need a 'supersedes' relation Would you like to review any of these?"