SkillFoxx

Graph Engineering skill

With Graph Engineering, an agent designs a knowledge graph, checks relationships and prepares data for source-based retrieval.

  • 572 ★ on the repository
  • Last commit
  • MIT
Skill

Minimal access

Why this level

  • The skill supplies design instructions; the host agent separately determines data access and tool execution.
All reasons and checks

codejunkie99/graph-engineeringAuthor:codejunkie99

Install

In your terminal, with SkillFoxx CLI

npx skillfoxx add skills/graph-engineering

Detects the agents on your machine, shows the access level and pins the version.

Other ways to install

Access and checks

How we review

Minimal accessThe tool runs nothing and makes no network calls.

  • The skill supplies design instructions; the host agent separately determines data access and tool execution.

This is third-party code. Review the repository files before installing.

What it does

With Graph Engineering, the agent first checks whether a knowledge graph suits the user’s question. It chooses a representation and defines entity and relationship types. The agent then extracts facts, checks their quality, merges duplicates and prepares retrieval. In teaching mode, the agent explains stages using the user’s project and small diagrams. Separate task-graph guidance helps plan execution dependencies and independent verification.

Who it is for. Knowledge-base architects moving from scattered documents to explicit entities, relationships and evidence.

Good fit when

  • A query traverses several relationships among people, projects and events.
  • You need a minimal ontology before extracting data.
  • The same entity appears under different names across sources.
  • You want to learn with a small document set from your own project.

Not a fit when

  • A simple table lookup answers the question.
  • You want a ready graph database service without design work.
  • Fact sources cannot be retained for later verification.

Example request

Use three project documents to explain whether a graph is needed and draft a minimal entity schema with example relationships.

Limitations

The skill provides methodology, so choose storage and extraction tools for your project separately. Instructions cannot correct unreliable sources; inspect sampled entities and relationships before fusion. Each relationship needs provenance and extraction time for later verification. Materials adapt a course and agent research; their target quality thresholds are guidance, not measured performance on your own dataset.

How to disable. Remove graph-engineering from the client skill directory. Generated schemas, diagrams and project data remain.

FAQ

How do I start teaching mode?

Ask to learn graph engineering using your project; the agent explains stages in order with short exercises.

How much data should I start with?

The instruction recommends a small pilot, such as ten documents, before scaling up.

Is Neo4j required?

No. Options include property graphs, RDF and typed edges in JSON or SQLite.

What about duplicate names?

Define matching and fusion rules while retaining source links, before exposing the graph to agents.

How do I model an agent team?

Use task-graphs guidance to connect jobs by actual dependencies and separate verification.

Discussion

No questions or reviews yet.

Skills

An agent skill that builds a Neo4j knowledge graph from CSV and Excel, writes safe Cypher and adds GraphRAG vector search.

SkillExtended access581

A knowledge graph with an MCP server: the agent searches concepts by meaning and sees how well each is supported.

MCP serverExtended access131

myKG builds a confidence scored knowledge graph from mixed documents and serves it to an agent through MCP or a Claude Code skill.

CLIExtended access85

Neo4j skills for agents: Cypher queries, graph modeling, drivers, import, GraphRAG, GDS and Aura provisioning

PluginExtended access122
Official

A Neo4j MCP server and skill: the agent runs Graph Data Science algorithms on a graph, from centrality to embeddings

MCP serverExtended access99

opengis-skills gives an agent 120 skills on GIS, CAD, AI, IoT, 3D and C Sharp: GDAL, QGIS, GeoServer, PostGIS.

SkillMinimal access83

README in short

The package includes modeling, extraction and fusion references. WORKFLOWS.md provides prompt blocks for individual stages.

README badge

Original SKILL.md

---
name: graph-engineering
description: Teaches an agent graph engineering — both halves. Knowledge graphs (ontology design, entity/relation/event extraction, fusion, GraphRAG/memory serving; distilled and translated from Southeast University's graduate Knowledge Graph course, npubird/KnowledgeGraphCourse, 4.4K stars) and task graphs (agent orchestration — parallel fan-out, verifier separation, the stop rule, human gates). Use when asked to build a knowledge graph, extract entities/relations from text, design an ontology, dedupe/merge entities, add graph memory or GraphRAG to an agent, orchestrate multi-agent workflows as a graph, or LEARN graph engineering — in teaching mode the agent explains each stage with worked examples and generates visual diagram artifacts.
---

# Graph Engineering

Graph engineering is the discipline of designing the structures agents work through — not the
prompts. It has two halves:

1. **Knowledge graphs** — what agents remember. Nodes are entities and facts, edges are
   relationships with time and provenance. This file's 9-stage pipeline covers it, distilled
   from Southeast University's graduate KG course
   (https://github.com/npubird/KnowledgeGraphCourse, Prof. Peng Wang), translated to English
   and adapted for LLM-era agents.
2. **Task graphs** — how agents work. Nodes are jobs, edges are execution dependencies:
   parallel fan-out, separate verifier contexts, the stop rule, the human gate.
   Read [references/task-graphs.md](references/task-graphs.md) when the request is about
   orchestrating agents rather than building memory.

Core mental model: a knowledge graph is a **product with a schema**, not a pile of triples.
Quality comes from the pipeline order — model the domain BEFORE extracting, fuse BEFORE storing,
evaluate at every stage.

## Teaching Mode

When the user wants to LEARN graph engineering (rather than build something), teach it — do
not just execute. Rules:

1. Anchor every stage in the user's own domain: ask for one real project or dataset, then use
   it as the running example through all stages.
2. **Generate visual artifacts as you teach.** Concepts in this discipline are shapes; show
   them. For each major concept, produce a small diagram the user can keep — mermaid diagrams
   (flowchart for the pipeline and task graphs, `graph LR` for example ontologies and
   subgraphs) or a single self-contained HTML page when interactivity helps. At minimum:
   the 9-stage pipeline, a 3-type ontology drawn from the user's domain, one extracted
   subgraph (5-10 nodes) from a real sample, and the diamond pattern with the user's own jobs
   as nodes.
3. Teach in the pipeline's order, one stage per exchange, each ending with a small exercise
   ("write 3 competency questions for your project") before moving on.

Report a problem