/palace-diagram

name: palace-diagram
description: Generates Mermaid and ASCII diagrams of palace structure, knowledge topology, and synapse connectivity. Use when inspecting or presenting a palace visually.
alwaysApply: false
category: visualization
tags:
- memory
- visualization
- mermaid
- diagram
- graph
dependencies:
- memory-palace-architect
usage_patterns:
- palace-visualization
- knowledge-topology
complexity: intermediate
model_hint: standard
estimated_tokens: 400

Palace Diagram

Generate Mermaid and ASCII diagrams from the knowledge graph, showing palace structure, entity relationships, synapse connectivity, and tier assignments.

> **Status: wired**. Invoke via `/palace diagram <palace-id> > [--type map|ascii|entity|heatmap]`, which calls > `Skill(memory-palace:palace-diagram)`. The renderer lives in > `memory_palace.palace_renderer.PalaceRenderer`; see the Usage > section below for direct programmatic access.

When To Use

• Inspecting palace structure after creation or migration
• Understanding knowledge topology and connections
• Identifying strong and weak synapses (heatmap)
• Reviewing entity relationships and triples
• Getting an ASCII overview for inline display

When NOT To Use

• Creating palaces: use memory-palace-architect
• Searching knowledge: use knowledge-locator
• Code architecture diagrams: use cartograph

Diagram Types

| Type | Format | Description | |------|--------|-------------| | Palace map | Mermaid flowchart | Rooms as subgraphs, entities as nodes, synapses as edges | | Entity graph | Mermaid flowchart | Single entity's connections and triples | | Synapse heatmap | Mermaid flowchart | Edge styling by strength (thick=strong, dotted=weak) | | ASCII overview | Text | Box-drawing palace layout with entity counts |

Workflow

1. **Identify palace** by ID or name 2. **Choose diagram type** based on what you want to see 3. **Generate diagram** using `PalaceRenderer` 4. **Render** via Mermaid Chart MCP (for Mermaid) or display inline (for ASCII)

Usage

Palace Map

from memory_palace.knowledge_graph import KnowledgeGraph
from memory_palace.palace_renderer import PalaceRenderer

graph = KnowledgeGraph("path/to/knowledge_graph.db")
renderer = PalaceRenderer(graph)
mermaid = renderer.palace_map("palace_id")

Then call `mcp__claude_ai_Mermaid_Chart__validate_and_render_mermaid_diagram` with the generated Mermaid string.

ASCII Overview

ascii_art = renderer.ascii_overview("palace_id")
print(ascii_art)

Entity Graph

mermaid = renderer.entity_graph("entity_id")

Synapse Heatmap

mermaid = renderer.synapse_heatmap("palace_id")

Edge Styling

| Strength | Style | Meaning | |----------|-------|---------| | >= 0.7 | `==>` (thick) | Strong connection | | >= 0.4 | `-->` (normal) | Medium connection | | < 0.4 | `-.->` (dotted) | Weak connection |

Integration

Works with:

• `memory-palace-architect`: visualize after palace creation
• `knowledge-locator`: display search results as graph
• `graph-analyzer`: tier-informed node sizing

Exit Criteria

• [ ] At least one of the four diagram types (palace map, entity graph,

synapse heatmap, ASCII overview) is generated without a Python exception from `PalaceRenderer`

• [ ] Mermaid diagrams are passed to

`mcp__claude_ai_Mermaid_Chart__validate_and_render_mermaid_diagram` and render successfully

• [ ] ASCII overview displays rooms with box-drawing characters and

entity counts per room

• [ ] Synapse edge styling matches strength thresholds: `==>` for

strength ≥ 0.7, `-->` for ≥ 0.4, `-.->` for < 0.4

• [ ] If the requested palace ID does not exist in the knowledge graph,

an error is reported with the palace ID that was searched