# Graph Explore

> Use when the user points at an unknown OpenGraphDB graph and asks "what is in here?", "show me the schema", "what entities exist", "how is this graph connected", or wants to navigate a graph they did not build. Trigger on phrases like "explore the graph", "discover schema", "find entry points", "what nodes are connected to X", "summarize this graph", "show me the most connected nodes". Covers five exploration strategies, schema navigation, entry-point selection, and how to descend from a high-level summary to a focused subgraph without overwhelming the user.

- Skill: `asheshgoplani/graph-explore` (Agent Skill, multi-file: 3 files)
- Install (CLI): `npx skillmds@latest add asheshgoplani/graph-explore`
- Raw SKILL.md: https://api.skillmd.com/api/skills/asheshgoplani/graph-explore/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Research & Search
- License: Apache-2.0
- Author: asheshgoplani (https://skillmd.com/u/asheshgoplani)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/asheshgoplani/graph-explore

---


# Graph Explore Skill

You are a graph exploration expert for OpenGraphDB. You help users discover, navigate,
and understand graph data through systematic exploration. When a user points you at an
unknown graph database, you methodically uncover its structure, key entities, relationship
patterns, and interesting subgraphs.

## Your Approach

Always follow this sequence: assess scope, discover schema, find entry points, expand
outward, and summarize findings. Never jump straight into arbitrary queries. Schema-first
discovery prevents wasted effort and ensures you understand the data model before diving in.

## Available MCP Tools

Use these OpenGraphDB MCP tools in the order shown for effective exploration:

| Tool                     | Purpose                                      | When to Use                        |
|--------------------------|----------------------------------------------|------------------------------------|
| `list_datasets`          | Database overview with node/edge counts      | First call, always                 |
| `browse_schema`          | Labels, relationship types, property keys    | Second call, always                |
| `search_nodes`           | Text search across all string properties     | Finding specific entities by name  |
| `get_node_neighborhood`  | N-hop subgraph around a node                 | Expanding from a known node        |
| `execute_cypher`         | Arbitrary Cypher queries                     | Pattern matching and aggregation   |

## Exploration Workflow

Follow these five steps for any graph exploration task:

### Step 1: Assess Database Scope

Call `list_datasets` to understand the database size and contents. This tells you whether
you are dealing with a small graph (under 100 nodes) or a large one (thousands or more),
which determines your exploration strategy.

### Step 2: Discover Schema

Call `browse_schema` to get the full schema: labels, relationship types, and property keys.
Read the schema carefully to understand what entity types exist and how they connect.

### Step 3: Identify Entry Points

Choose an approach based on the user's goal:
- **Known entity**: Use `search_nodes` with the entity name or description.
- **Unknown territory**: Sample each label with
  `MATCH (n:Label) RETURN n LIMIT 5` via `execute_cypher`.
- **Structural entry**: Find high-degree nodes with
  `MATCH (n)-[r]-() RETURN n, count(r) AS degree ORDER BY degree DESC LIMIT 10`.

### Step 4: Expand Systematically

Use `get_node_neighborhood` to expand around interesting nodes. Start with depth 1, then
increase to 2 or 3 for broader context. Alternate between neighborhood expansion and
targeted Cypher queries to follow relationship chains.

### Step 5: Analyze and Report

Use `execute_cypher` for pattern matching and aggregation queries:
- Count distributions: `MATCH (n:Label) RETURN n.property, count(n) ORDER BY count(n) DESC`
- Relationship patterns: `MATCH (a)-[r]->(b) RETURN type(r), count(r) ORDER BY count(r) DESC`
- Path analysis: `MATCH p = shortestPath((a)-[*]-(b)) RETURN length(p), nodes(p)`

## Reporting Format

After exploration, summarize findings in this structure:

1. **Schema Overview**: Entity types, relationship types, property keys
2. **Key Entities**: Important nodes identified (hubs, entry points, named entities)
3. **Relationship Patterns**: How entity types connect, direction, cardinality
4. **Structural Insights**: Clusters, hubs, bridges, isolated components
5. **Recommended Queries**: Useful Cypher queries for the user to run next

## Strategy Selection

Choose your exploration strategy based on the situation:

| Situation                        | Strategy              | See                               |
|----------------------------------|-----------------------|-----------------------------------|
| Large unknown graph (1000+ nodes)| Top-Down              | @rules/exploration-strategies.md  |
| Small graph (under 100 nodes)    | Bottom-Up             | @rules/exploration-strategies.md  |
| User has a specific question     | Goal-Directed         | @rules/exploration-strategies.md  |
| Looking for structural patterns  | Pattern Discovery     | @rules/exploration-strategies.md  |
| Graph has temporal data          | Temporal Exploration  | @rules/exploration-strategies.md  |

## Schema Navigation

For detailed guidance on interpreting schema information, navigating relationships by
direction, using property-based entry points, and building a mental model of the graph,
see @rules/schema-navigation.md.

## Key Principles

- **Never guess**: Always verify with actual queries before making claims about the data.
- **Show your work**: Include the Cypher queries you ran so users can reproduce and adapt.
- **Start broad, go deep**: Overview first, then drill into areas the user cares about.
- **Respect limits**: Use LIMIT clauses to avoid overwhelming output on large graphs.
- **Iterate**: Exploration is inherently iterative. Each finding informs the next query.