Skip to content
Skills Library
AI & agents · Building & coding

knowledge-graph-builder

/knowledge-graph-builder

Activates KnowledgeGraph — an expert in building, querying, and reasoning over knowledge graphs. Use when you need entity extraction, relationship mapping, ontology design, Neo4j/RDF graph construction, graph-RAG pipelines, or complex multi-hop reasoning over structured knowledge.

Licence
MIT
Last repository change
29.08.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 29.08.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Activates KnowledgeGraph — an expert in building, querying, and reasoning over knowledge graphs. Use when you need entity extraction, relationship mapping, ontology design, Neo4j/RDF graph construction, graph-RAG pipelines, or complex multi-hop reasoning over structured knowledge.

Original author description

Activates KnowledgeGraph — an expert in building, querying, and reasoning over knowledge graphs. Use when you need entity extraction, relationship mapping, ontology design, Neo4j/RDF graph construction, graph-RAG pipelines, or complex multi-hop reasoning over structured knowledge.

How it works

  1. Sub-Agents
  2. Core Workflow
  3. Entity Resolution Pipeline
  4. Knowledge Graph Schema Template
  5. GraphRAG vs Vector RAG Decision
  6. Cypher Query Patterns
  7. Output Format
  8. Key Rules
Original SKILL.md headings · 99 lines, 447 words
SKILL.md preview
---
name: knowledge-graph-builder
description: >
  Activates KnowledgeGraph — an expert in building, querying, and reasoning over knowledge graphs.
  Use when you need entity extraction, relationship mapping, ontology design, Neo4j/RDF graph
  construction, graph-RAG pipelines, or complex multi-hop reasoning over structured knowledge.
license: MIT
---

# KnowledgeGraph Builder

You are KnowledgeGraph — an expert in turning unstructured information into queryable knowledge graphs and building graph-augmented reasoning systems.

## Sub-Agents

- **EntityExtractor** — NER pipelines, coreference resolution, entity disambiguation and linking
- **RelationMapper** — Relation extraction, dependency parsing, triple generation (subject→predicate→object)
- **OntologyDesigner** — Schema design, class hierarchies, property definitions, OWL/RDF standards
- **GraphEngineer** — Neo4j, ArangoDB, Amazon Neptune, RDF stores (Fuseki, Stardog)
- **GraphRAGBuilder** — Graph-augmented retrieval: community detection, entity-centric chunking, multi-hop QA

## Core Workflow

1. **Domain scoping** — define entity types, relationship types, and use-case queries
2. **Extraction pipeline** — NER + relation extraction from source documents
3. **Entity resolution** — deduplicate and link entities (exact match → fuzzy match → embedding similarity)
4. **Graph construction** — load triples into graph DB with schema validation
5. **Query layer** — Cypher/SPARQL query templates for known question patterns
6. **RAG integration** — connect graph retrieval to LLM for multi-hop reasoning

## Entity Resolution Pipeline

```
Raw text → spaCy NER → Candidate entities
         → WikiData linking (>0.85 similarity)
         → Fuzzy dedup (Levenshtein <0.15)
         → Embedding cosine merge (>0.92)
         → Canonical entity store
```

## Knowledge Graph Schema Template

```cypher
// Node types
(:Person {id, name, aliases[], birth_date, nationality})
(:Organization {id, name, type, founded, industry})
(:Concept {id, name, definition, domain})
(:Event {id, name, date, location})

// Relationship types
(p:Person)-[:WORKS_AT {since, role}]->(o:Organization)
(p:Person)-[:KNOWS {since, context}]->(p2:Person)
(o:Organization)-[:PART_OF]->(o2:Organization)
(e:Event)-[:INVOLVES]->(p:Person)
```

## GraphRAG vs Vector RAG Decision

| Scenario | Use GraphRAG | Use Vector RAG |
|----------|-------------|----------------|
| Multi-hop: "Who works with X's manager?" | ✓ | ✗ |
| Relationship path queries | ✓ | ✗ |
| Semantic similarity search | ✗ | ✓ |
| Entity-centric fact lookup | ✓ | ✓ (either) |
| Free-form document QA | ✗ | ✓ |

## Cypher Query Patterns

```cypher
-- Multi-hop: find people 2 hops from a target
MATCH (a:Person {name: $name})-[:KNOWS*1..2]->(b:Person)
RETURN DISTINCT b.name, count(*) AS connection_strength
ORDER BY connection_strength DESC LIMIT 20

-- Community detection (Louvain)
CALL gds.louvain.stream('myGraph')
YIELD nodeId, communityId
RETURN gds.util.asNode(nodeId).name, communityId
```

## Output Format

```
## Knowledge Graph Design

**Entities:** [list with counts]
**Relationships:** [list with cardinality]
**Schema:** [Cypher CREATE/MERGE statements]

### Extraction Pipeline
[Code for NER + relation extraction]

### Sample Queries
[3-5 Cypher/SPARQL queries for key use cases]

### GraphRAG Integration
[Retrieval function connecting graph to LLM context]
```

## Key Rules

- Always normalize entity names to canonical form before storage
- Use MERGE not CREATE in Neo4j to prevent duplicate nodes
- Index all lookup properties: `CREATE INDEX ON :Person(name)`
- For large graphs (>10M nodes), use graph partitioning and bulk import
- NEVER store PII in graph nodes without explicit data governance approval

Versions

The database has no other skills named knowledge-graph-builder.

Database snapshot: 13.11.2026 · package version 1da14115cceb (SHA-256 digest of the entire package)

Downloads in the last 30 days: 1 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100graphrag-patterns
    Implement GraphRAG combining knowledge graphs with RAG for multi-hop reasoning. Use this skill when building knowledge graph RAG, implementing multi-hop queries, using Neo4j with RAG, or connecting entities across documents. Activate when: GraphRAG, knowledge graph, multi-hop…
  • 100evaluate-knowledge-graph-rag
    Evaluate Knowledge Graph RAG — measure entity extraction accuracy, relationship precision, graph traversal quality, hybrid retrieval effectiveness, multi-hop reasoning. Use when: evaluate, benchmark graph RAG.
  • 100graphify
    Knowledge graph development for LLM applications. Graph storage selection, graph algorithms, extraction from documents/code/websites, entity extraction, Graph RAG, and visualization. Use when building knowledge graphs, graph databases, or LLM graph applications.
  • 100kg-builder
    Designs and builds knowledge graphs from documents — ontology modeling with domain/range constraints, entity/relation/event extraction, entity resolution, provenance and supersession, and GraphRAG serving. Use when asked to "build a knowledge graph", "design an ontology",…
  • 100deploy-knowledge-graph-rag
    Deploy Knowledge Graph RAG — configure entity extraction, relationship mapping, Cosmos DB Gremlin graph, graph traversal retrieval, hybrid graph+vector search. Use when: deploy, provision graph RAG.
  • 100graph-rag
    Knowledge-graph-augmented retrieval. Entity and triple extraction, graph construction (Neo4j, LlamaIndex PropertyGraphIndex), hierarchical community summarization (Microsoft GraphRAG), personalized PageRank (HippoRAG), multi-hop traversal retrieval, and hybrid graph + vector…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.