LLM으로 본문에서 자동 추출 — Claude Tool Use로 지식 그래프 채우기

const extractionTool = {
  name: "record_post_extractions",
  description: "본문에서 인용·관련 글·선수 글을 추출하여 기록한다.",
  input_schema: {
    type: "object",
    properties: {
      cites: {
        type: "array",
        description: "본문이 인용한 외부 자료(블로그 외부 URL)",
        items: {
          type: "object",
          properties: {
            url: { type: "string" },
            title: {
              type: "string",
              description: "링크 텍스트 또는 추론된 제목",
            },
            context: { type: "string", description: "인용된 문맥 한 줄" },
          },
          required: ["url", "title"],
        },
      },
      related: {
        type: "array",
        description: "본문이 언급한 같은 블로그 내 다른 글의 slug",
        items: {
          type: "object",
          properties: {
            slug: { type: "string" },
            reason: { type: "string", description: "왜 관련되는지 한 줄" },
          },
          required: ["slug", "reason"],
        },
      },
      prerequisites: {
        type: "array",
        description: "본문이 '먼저 읽으면 좋다'고 명시한 글의 slug",
        items: {
          type: "object",
          properties: {
            slug: { type: "string" },
            evidence: { type: "string", description: "원문 인용" },
          },
          required: ["slug", "evidence"],
        },
      },
    },
    required: ["cites", "related", "prerequisites"],
  },
}

import Anthropic from "@anthropic-ai/sdk"

const client = new Anthropic()

const SYSTEM_PROMPT = `당신은 블로그 글에서 그래프 관계를 추출하는 어시스턴트입니다.

규칙:
1) cites: 본문에 마크다운 링크로 등장한 외부 URL만. 블로그 자체(blog.javapark.kr)는 제외.
2) related: 본문이 명시적으로 가리킨 같은 블로그의 다른 글 slug만. 추측 금지.
3) prerequisites: "먼저 읽어라", "이전 편", "전제 지식" 같은 명시적 표현이 있을 때만.

규칙 외 항목은 절대 만들지 마세요. 빈 배열은 정상입니다.`

async function extract(post) {
  const response = await client.messages.create({
    model: "claude-sonnet-4-6",
    max_tokens: 2048,
    system: [
      {
        type: "text",
        text: SYSTEM_PROMPT,
        cache_control: { type: "ephemeral" },
      },
    ],
    tools: [extractionTool],
    tool_choice: { type: "tool", name: "record_post_extractions" },
    messages: [
      {
        role: "user",
        content: `[글 slug] ${post.slug}\n[카테고리] ${post.category}\n\n${post.body}`,
      },
    ],
  })

  const toolUse = response.content.find(b => b.type === "tool_use")
  return toolUse.input
}

async function ingestExtractions(session, post, extractions) {
  await session.executeWrite(async tx => {
    // 외부 인용
    for (const c of extractions.cites) {
      await tx.run(
        `MERGE (e:ExternalResource {url: $url})
         SET e.title = coalesce(e.title, $title)
         WITH e
         MATCH (p:Post {slug: $slug})
         MERGE (p)-[r:CITES]->(e)
         SET r.context = $context`,
        { ...c, slug: post.slug, context: c.context ?? "" }
      )
    }

    // 관련 글
    for (const r of extractions.related) {
      await tx.run(
        `MATCH (a:Post {slug: $from}), (b:Post {slug: $to})
         MERGE (a)-[rel:RELATED_TO]->(b)
         SET rel.reason = $reason`,
        { from: post.slug, to: r.slug, reason: r.reason }
      )
    }

    // 선수 글
    for (const pre of extractions.prerequisites) {
      await tx.run(
        `MATCH (a:Post {slug: $from}), (b:Post {slug: $to})
         MERGE (b)-[rel:PREREQUISITE_OF]->(a)
         SET rel.evidence = $evidence`,
        { from: post.slug, to: pre.slug, evidence: pre.evidence }
      )
    }
  })
}

for (const file of files) {
  const post = parsePost(file)
  await ingest(session, post)
  const extractions = await extract(post)
  await ingestExtractions(session, post, extractions)
  console.log(
    `✓ ${post.slug} — cites:${extractions.cites.length}, related:${extractions.related.length}, prereq:${extractions.prerequisites.length}`
  )
}

async function validateUrl(url) {
  try {
    const r = await fetch(url, { method: "HEAD", redirect: "follow" })
    return r.ok
  } catch {
    return false
  }
}

const knownSlugs = new Set(allPosts.map(p => p.slug))
extractions.related = extractions.related.filter(r => knownSlugs.has(r.slug))
extractions.prerequisites = extractions.prerequisites.filter(p =>
  knownSlugs.has(p.slug)
)