지식 그래프 구축 실전 — Neo4j vs RDF, 스택 선정과 적재

services:
  neo4j:
    image: neo4j:5-community
    container_name: ontology-search-neo4j
    ports:
      - "7474:7474" # Browser
      - "7687:7687" # Bolt protocol (드라이버용)
    environment:
      - NEO4J_AUTH=neo4j/please-change-me
      - NEO4J_PLUGINS=["apoc"]
    volumes:
      - ./neo4j/data:/data
      - ./neo4j/logs:/logs

docker compose up -d

// 식별자 제약 (먼저 정의)
CREATE CONSTRAINT post_slug IF NOT EXISTS
  FOR (p:Post) REQUIRE p.slug IS UNIQUE;
CREATE CONSTRAINT tag_name IF NOT EXISTS
  FOR (t:Tag) REQUIRE t.name IS UNIQUE;
CREATE CONSTRAINT series_name IF NOT EXISTS
  FOR (s:Series) REQUIRE s.name IS UNIQUE;
CREATE CONSTRAINT category_slug IF NOT EXISTS
  FOR (c:Category) REQUIRE c.slug IS UNIQUE;
CREATE CONSTRAINT author_name IF NOT EXISTS
  FOR (a:Author) REQUIRE a.name IS UNIQUE;
CREATE CONSTRAINT external_url IF NOT EXISTS
  FOR (e:ExternalResource) REQUIRE e.url IS UNIQUE;

title: "온톨로지 기반 검색이란? — 벡터 검색만으로 부족했던 이유"
description: "..."
date: 2026-05-20 09:00
update: 2026-05-20
series: "온톨로지로 똑똑한 검색 만들기"
tags:
  - 온톨로지
  - 지식 그래프
  - GraphRAG
  - RAG
  - LLM 검색

npm install --save-dev neo4j-driver gray-matter glob

import neo4j from "neo4j-driver"
import matter from "gray-matter"
import { globSync } from "glob"
import fs from "node:fs"
import path from "node:path"

const driver = neo4j.driver(
  "bolt://localhost:7687",
  neo4j.auth.basic("neo4j", "please-change-me")
)

const AUTHOR = { name: "자바파커", url: "https://blog.javapark.kr" }

function parsePost(filePath) {
  const raw = fs.readFileSync(filePath, "utf-8")
  const { data, content } = matter(raw)

  const rel = path.relative("contents/posts", filePath)
  const segments = rel.split(path.sep)
  const category = segments[0]
  const slug = segments[1]

  return {
    slug,
    title: data.title,
    description: data.description ?? "",
    publishedAt: new Date(data.date).toISOString(),
    updatedAt: new Date(data.update ?? data.date).toISOString(),
    series: data.series ?? null,
    tags: data.tags ?? [],
    category,
    body: content,
  }
}

async function ingest(session, post) {
  await session.executeWrite(async tx => {
    // Post 노드
    await tx.run(
      `MERGE (p:Post {slug: $slug})
       SET p.title = $title, p.description = $description,
           p.publishedAt = datetime($publishedAt),
           p.updatedAt = datetime($updatedAt)`,
      post
    )

    // Author
    await tx.run(
      `MERGE (a:Author {name: $name}) SET a.url = $url
       WITH a
       MATCH (p:Post {slug: $slug})
       MERGE (p)-[:WRITTEN_BY]->(a)`,
      { ...AUTHOR, slug: post.slug }
    )

    // Category
    await tx.run(
      `MERGE (c:Category {slug: $category})
       WITH c
       MATCH (p:Post {slug: $slug})
       MERGE (p)-[:IN_CATEGORY]->(c)`,
      { category: post.category, slug: post.slug }
    )

    // Tags
    for (const name of post.tags) {
      await tx.run(
        `MERGE (t:Tag {name: $name})
         WITH t
         MATCH (p:Post {slug: $slug})
         MERGE (p)-[:HAS_TAG]->(t)`,
        { name, slug: post.slug }
      )
    }

    // Series (옵션)
    if (post.series) {
      await tx.run(
        `MERGE (s:Series {name: $series})
         WITH s
         MATCH (p:Post {slug: $slug})
         MERGE (p)-[:BELONGS_TO_SERIES]->(s)`,
        { series: post.series, slug: post.slug }
      )
    }
  })
}

const files = globSync("contents/posts/**/index.md")
const session = driver.session()

try {
  for (const file of files) {
    const post = parsePost(file)
    await ingest(session, post)
    console.log(`✓ ${post.slug}`)
  }
} finally {
  await session.close()
  await driver.close()
}

node scripts/ingest-graph.mjs

MATCH (p:Post)-[:BELONGS_TO_SERIES]->(s:Series {name: "Claude Code 사용 가이드"})
RETURN p ORDER BY p.publishedAt ASC LIMIT 1;

MATCH (p:Post)-[:HAS_TAG]->(t:Tag {name: "GraphRAG"})
WHERE p.publishedAt >= datetime("2026-04-01")
  AND p.publishedAt <  datetime("2026-05-01")
RETURN p;

MATCH (c:Category {slug: "ai"})<-[:IN_CATEGORY]-(p:Post)
RETURN p ORDER BY p.publishedAt DESC LIMIT 5;

MATCH (s:Series)<-[:BELONGS_TO_SERIES]-(p:Post)
WHERE EXISTS { (p)-[:HAS_TAG]->(:Tag {name: "Claude Code"}) }
  AND EXISTS { (p)-[:HAS_TAG]->(:Tag {name: "GraphRAG"}) }
RETURN DISTINCT s;

MERGE (p:Post {slug: $slug})
SET p.title = $title  // 매칭됐든 새로 만들었든 SET은 항상 실행됨