Skip to main content
skill CX Codex

knowledge-graph-builder — Claude Code skill

The knowledge-graph-builder skill guides knowledge-graph design, graph database choice, and graph-plus-vector retrieval. Use it for Graph RAG, entity resolution, and fact checks.

MIT 222 installs ★ 29 updated 2026-08-17

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add oakoss/agent-skills --skill knowledge-graph-builder -a claude-code
Open on GitHub

What knowledge-graph-builder does

knowledge-graph-builder covers the main work behind an AI-ready knowledge graph: ontology design, entity and relationship extraction, duplicate resolution, query patterns, and AI integration. Its database guidance includes Neo4j, Neptune, ArangoDB, and TigerGraph. It also explains a hybrid setup where vector search finds candidates and graph traversal adds related context.

The workflow starts with entity types, relationships, and properties before ingestion. It recommends testing core entities against target queries, then expanding the graph in stages. Relationship records should carry a confidence value from 0.0 to 1.0 together with their source. Separate reference material covers ontology design, database selection, extraction, hybrid architecture, Cypher, and AI integration.

A graph is a poor fit for simple tabular data or document search with no relationship traversal. Ontology changes become expensive after ingestion, so the model needs validation first.

What it helps with

  • design an ontology for a domain
  • extract entities and relationships from unstructured text
  • compare Neo4j, Neptune, ArangoDB, and TigerGraph
  • build hybrid graph-and-vector retrieval
  • ground AI answers in structured facts

Example prompts for the agent

  • Design an ontology for this domain and list its entity types, relationships, and properties.
  • Extract entities and relationships from these documents, merge duplicates, and attach confidence values with sources.
  • Compare Neo4j, Neptune, ArangoDB, and TigerGraph for my data volume and query patterns.

How to install knowledge-graph-builder

1Skills CLI (Vercel)

npx skills add oakoss/agent-skills --skill knowledge-graph-builder -a claude-code

2Manually: put the files in place

~/.claude/skills/knowledge-graph-builder/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/knowledge-graph-builder/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about knowledge-graph-builder

How do I install knowledge-graph-builder in Claude Code?

Run npx skills add oakoss/agent-skills --skill knowledge-graph-builder -a claude-code, then check ~/.claude/skills/knowledge-graph-builder/SKILL.md.

What does knowledge-graph-builder do?

It guides ontology design, entity and relationship extraction, graph database selection, and hybrid retrieval that combines graph traversal with vector search.

Which databases does knowledge-graph-builder cover?

The material compares Neo4j, Neptune, ArangoDB, and TigerGraph by scale, infrastructure needs, and query complexity.

Source text

SKILL.md · MIT
---
name: knowledge-graph-builder
description: >
  Implements knowledge graphs for AI-enhanced relational knowledge. Covers ontology design, graph database selection (Neo4j, Neptune, ArangoDB, TigerGraph), entity extraction, hybrid graph-vector architecture, query patterns, and AI integration.

  Use when implementing knowledge graphs, designing ontologies, extracting entities and relationships, selecting a graph database, or building hybrid graph-vector search. Use for knowledge graph, ontology design, entity resolution, graph RAG, hallucination detection. For architecture selection and governance, use the knowledge-base-manager skill. For document retrieval pipelines, use the rag-implementer skill.
license: MIT
metadata:
  author: oakoss
  version: '1.0'
---

# Knowledge Graph Builder

## Overview

Knowledge graphs make implicit relationships explicit, enabling AI systems to reason about connections, verify facts, and reduce hallucinations. They combine structured entity-relationship modeling with semantic search for powerful knowledge retrieval.

**When to use:** Complex entity relationships central to the domain, verifying AI-generated facts against structured knowledge, semantic search combined with relationship traversal, recommendation systems, fraud detection, or pattern recognition.

**When NOT to use:** Simple tabular data (use a relational database), purely document-based search with no relationships (use the `rag-implementer` skill), read-heavy workloads with no traversal needs, or when the team lacks graph modeling expertise. For KB architecture selection and governance, use the `knowledge-base-manager` skill.

## Quick Reference

| Pattern             | Approach                                                                                   | Key Points                                                          |
| ------------------- | ------------------------------------------------------------------------------------------ | ------------------------------------------------------------------- |
| Ontology first      | Define entity types, relationships, properties before ingesting data                       | Changing schema later is expensive; validate with domain experts    |
| Entity resolution   | Deduplicate aggressively during extraction                                                 | "Apple Inc" = "Apple" = "Apple Computer" must resolve to one entity |
| Confidence scoring  | Attach 0.0-1.0 score + source to every relationship                                        | Enables filtering by reliability, critical for AI grounding         |
| Hybrid architecture | Graph traversal (structured) + vector search (semantic)                                    | Vector finds candidates, graph expands context via relationships    |
| Incremental build   | Core entities first, validate against target queries, then expand                          | Avoid building the full graph before testing with real queries      |
| Database selection  | Neo4j (general), Neptune (AWS managed), ArangoDB (multi-model), TigerGraph (massive scale) | Match database to scale, infrastructure, and query complexity       |

## Common Mistakes

| Mistake                                                     | Correct Pattern                                                                              |
| ----------------------------------------------------------- | -------------------------------------------------------------------------------------------- |
| Ingesting entities before designing the ontology            | Define and validate the ontology with domain experts first; changing later is expensive      |
| Skipping entity resolution and deduplication                | Deduplicate aggressively so "Apple Inc", "Apple", and "Apple Computer" resolve to one entity |
| Omitting confidence scores on relationships                 | Attach a 0.0-1.0 confidence score and source to every relationship                           |
| Using only graph traversal without vector search            | Implement hybrid architecture combining graph traversal with semantic vector search          |
| Building the full graph before validating with real queries | Start with core entities, test against target queries, then expand incrementally             |
| Choosing a database before understanding scale requirements | Evaluate query patterns, data volume, and infrastructure constraints before selecting        |

## Delegation

- **Extract entities and relationships from unstructured text**: Use `Task` agent to run NER pipelines and build relationship triples
- **Evaluate graph database options for project requirements**: Use `Explore` agent to compare Neo4j, Neptune, ArangoDB, and TigerGraph against scale and query needs
- **Design ontology and hybrid architecture for a new domain**: Use `Plan` agent to define entity types, relationship schemas, and graph-vector integration strategy
- For hybrid KG+RAG systems, delegate to the `rag-implementer` skill
- For knowledge-graph-powered agent workflows, delegate to the `agent-patterns` skill

## References

- [Ontology Design](references/ontology-design.md) — Entity types, relationships, properties, RDF schema, validation
- [Database Selection](references/database-selection.md) — Neo4j, Neptune, ArangoDB, TigerGraph comparison and setup
- [Entity Extraction](references/entity-extraction.md) — NER pipeline, relationship extraction, LLM-based extraction
- [Hybrid Architecture](references/hybrid-architecture.md) — Graph + vector integration, hybrid search implementation
- [Query Patterns](references/query-patterns.md) — Cypher queries, API design, common traversal patterns
- [AI Integration](references/ai-integration.md) — KG-RAG, hallucination detection, grounded response generation

© oakoss · MIT · oakoss/agent-skills

Similar skills

All skills for Data and databases →

From the same set106

The whole set →
vitest-testing vitest-testing adds Vitest patterns and best practices to Claude Code. Helps write reliable unit, component, and hook tests without typical async mistakes. CX Codex +1 226installs content-humanizer content-humanizer rewrites model-written drafts so they read like a person wrote them: sentence rhythm, tone, and the hedging that gives AI text away. CX Codex +1 225installs zod-validation zod-validation guides AI coding agents through Zod v4 schema validation in TypeScript. Helps write schemas, parse incoming payloads, and generate JSON Schema definitions. CX Codex +1 222installs tanstack-form This skill guides TanStack Form v1 usage in React, covering state, validation, and submission. Use it for complex forms and changing field lists. CX Codex +1 222installs pino-logging Set up structured Pino logging in Node.js, including request context, sensitive-field redaction, transports, and framework integrations. CX Codex +1 217installs database-security database-security audits the data layer of Supabase, Postgres and Convex apps: RLS coverage, policy holes, service-role leaks, audit logging. Useful before a release or after an incident. CX Codex +1 208installs typescript-patterns Provides advanced strict-mode TypeScript patterns to enforce type safety and stop runtime errors before code runs. CX Codex +1 202installs react-patterns react-patterns is a Claude Code skill that covers React 19 patterns, state choices, data loading with use(), and reducing needless re-renders when building or reviewing components. CX Codex +1 201installs

Project sponsors

Companies that keep this analytics open