pkm-explore
Use when researching what the vault knows about a topic — performs graph + semantic exploration with gap analysis to map existing knowledge and find missing connections. Primarily used via the vault-explorer agent. Not for routine session-start context loading (hooks handle that).
Best use case
pkm-explore is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Use when researching what the vault knows about a topic — performs graph + semantic exploration with gap analysis to map existing knowledge and find missing connections. Primarily used via the vault-explorer agent. Not for routine session-start context loading (hooks handle that).
Teams using pkm-explore should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/pkm-explore/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How pkm-explore Compares
| Feature / Agent | pkm-explore | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Use when researching what the vault knows about a topic — performs graph + semantic exploration with gap analysis to map existing knowledge and find missing connections. Primarily used via the vault-explorer agent. Not for routine session-start context loading (hooks handle that).
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
# PKM Explore — Knowledge Discovery and Gap Analysis
Understand what the vault already knows about a topic before creating new notes or doing research. Combines graph traversal with semantic search to find both explicit connections and hidden relationships.
**When to use**: Researching vault knowledge on a topic, finding related notes, exploring a topic area before writing.
## Step 1: Identify Seed Note
Find the most relevant existing note for the topic:
```
vault_semantic_search({ query: "<topic>", limit: 5 })
```
**A note on score interpretation.** `vault_semantic_search` uses `text-embedding-3-large` (3072-dim) cosine similarity, which compresses hard. In a typical vault, even genuinely on-topic notes score around 0.45–0.65, and tangential notes that share surface tokens (e.g., "vibration" matching a "vibe coding" note) often score 0.40–0.45 too. Absolute scores cannot reliably separate "topically relevant seed" from "tangential surface match" — you must read and judge.
**Routing:**
- If a specific note path was provided, use that directly as the seed.
- Otherwise: read the top result with `vault_read` and judge whether it is topically relevant to the query (not just sharing surface tokens). If yes, use it as the seed and advance to Step 2.
- If the top result is tangential or off-topic, corroborate with one `vault_search` keyword query using a distinctive term from the topic. If `vault_search` returns zero matches AND the semantic top hits are all tangential on read, the vault has minimal coverage — report that and suggest creating a seed note using pkm-write. Do not advance into Steps 2–5 and do not synthesize from tangential matches.
If `vault_semantic_search` is unavailable (no `OPENAI_API_KEY`), use `vault_search` with key terms and `vault_query` by tags/type to locate a seed note.
## Step 2: Graph Context
Explore the structural neighborhood around the seed note:
```
vault_neighborhood({ path: "<seed-note-path>", depth: 2, direction: "both" })
```
This reveals the **intentional** knowledge structure — what someone explicitly linked. If the seed note has no links (new or isolated note), this is expected — rely on Step 3 results for connection discovery. If `vault_neighborhood` returns an error (e.g., 'File not found'), the seed note may have been deleted or the path misresolved — try the next-best result from Step 1, or verify with `vault_search`.
## Step 3: Semantic Expansion
Search for conceptually related notes that may not be in the graph:
```
vault_semantic_search({ query: "<topic>", limit: 10 })
```
If `vault_semantic_search` is unavailable (no `OPENAI_API_KEY`), use `vault_search` with multiple keyword variations and `vault_query` with relevant tags.
## Step 4: Gap Analysis
Compare the graph results (step 2) with semantic results (step 3):
| Category | Meaning | Action |
|----------|---------|--------|
| In graph AND semantic | Well-connected, established knowledge | No action needed |
| In graph but NOT semantic | Structurally linked but topically distant | May indicate weak/outdated link |
| **In semantic but NOT graph** | **Missing links** — conceptually related but unconnected | **Highest-value findings** — suggest linking |
**Note**: If Step 3 used `vault_search`/`vault_query` (no `OPENAI_API_KEY`), the gap analysis is less precise — text search misses conceptually related notes that use different terminology. Flag this reduced fidelity when presenting findings.
## Step 5: Synthesize
Return findings organized as:
1. **What exists**: Key notes on this topic with brief summaries (type, status, tags)
2. **How it's connected**: Graph structure — which notes link to which, at what depth
3. **Missing links**: Conceptually related notes not yet in the graph (candidates for linking — note reduced precision if semantic search was unavailable)
4. **Knowledge gaps**: Topics referenced but not covered by any note — candidates for new notes via pkm-write