feature: Graph-based story generation

[ottlseo]

Goal

Validate a flow where characters, relationships, and past events are defined as an ontology graph, then queried to generate new stories. The premise of a story is proposed by the graph rather than written by a human.

Why a graph instead of pasting a setting document into the prompt

1. Inference. Relations that were never written down are derived by rules. A loves B + B loves C yields A rival_of C automatically. Structures the author of the setting did not notice become visible.
2. Probes. Structural gaps in the graph are scored and ranked, so the machine proposes the story premise. No human instruction of the form "write a story about X".
3. Writeback. A generated story emits new nodes and edges that merge back into the graph. The next round of probes finds new gaps and the world accumulates.

Pipeline

world.json --> reason() --> find_seeds() --> ContextPack --> LLM --> story
              inference     seed ranking    subgraph serialization    |
                  ^                                                  |
                  +---------------- apply_writeback() <--------------+

Scope

• world.json schema: nodes, edges, ontology declarations, inference rules
• In-memory triple store with a fixed-point inference engine (structural: inverse / symmetric / transitive; rule-based: SPARQL-style basic graph patterns declared in JSON)
• 8 story seed probes with scoring
• Subgraph to LLM context pack serialization (characters / relations / timeline / knowledge state)
• Amazon Bedrock Converse integration and writeback payload parsing
• Demo site: graph visualization plus branching story output
• Migration to a graph database (Neo4j / Neptune)
• Writeback validation against existing canon

Ontology schema

Everything is declared in the ontology block of world.json, so the world can be changed without touching code.

Structural inference:

"child_of":   { "inverse": "parent_of" },
"sibling_of": { "symmetric": true },
"located_in": { "transitive": true }

Rule inference:

{
  "id": "leverage_by_secret",
  "when": [["?a", "knows", "?s"],
           ["?s", "concerns", "?b"],
           ["?s", "hidden_from", "?b"]],
  "where": { "neq": [["?a", "?b"]] },
  "then": ["?a", "has_leverage_over", "?b"],
  "props": { "tension": 0.9 }
}

Probes

Probe	What it looks for
secret_leverage	A secret hidden from the person it concerns. A timed bomb
love_triangle	Rivalry derived from affection. Shared form (a to c, b to c) and chain form (a to b, b to c)
unresolved_tension	High-tension relations with no event node resolving them
chekhov_object	Objects introduced but never paid off
strangers_shared_past	Two people in the same event with no explicit relation
severed_bond	Broken mentor relations with neither reconciliation nor parting recorded
dangling_consequence	Events with no outgoing caused edge. A price not yet paid
contested_goal	Multiple characters whose want points at the same target

Results so far

• 27 nodes and 52 asserted edges produce 52 derived edges at the inference fixed point, and 19 ranked story seeds.
• The demo renders 4 seeds, each expanding into 3 branches. Every branch writes a different set of edges back to the graph, so the next round of probes finds different gaps. Example: in the triangle seed, branch A breaks the jinu serves gwima edge while branch C keeps it and adds rumi drawn_to gwima instead.
• Derived edges carry provenance (derived_by), so the demo can distinguish asserted relations from inferred ones.

Known limitations

• Inference is a full join, so it slows down as the node count grows. Rules like allied_by_faction and shared_past produce O(n^2) edges. On a real graph database, query-time expansion is the right call instead of materialization.
• Probe score weights are hand-tuned. There is no feedback loop telling us which seeds actually turn into good stories.
• contested_goal string-matches free-text want fields against node names. Modeling goals as edges (a desires predicate) would remove this.
• Writeback payloads are validated for shape only, not for contradiction against existing facts.

[ottlseo]

한국어 요약

목표

캐릭터 · 관계 · 사건을 온톨로지 그래프로 정의하고, 그것을 쿼리해서 새로운 스토리를 생성하는 플로우를 검증합니다. 이야기의 전제를 사람이 쓰는 게 아니라 그래프가 제안합니다.

설정집을 프롬프트에 붙여 넣는 방식과 다른 점

1. 추론. 명시하지 않은 관계가 규칙으로 파생됩니다. A loves B + B loves C 에서 A rival_of C 가 자동으로 생깁니다. 설정을 쓴 사람도 몰랐던 구도가 드러납니다.
2. 패턴 탐지. 그래프의 구조적 결함을 점수화해서 랭킹하고, 기계가 이야기의 전제를 제안합니다. "X에 대한 이야기를 써줘" 형태의 사람 지시가 없습니다.
3. 역기입. 생성된 스토리가 새 노드와 엣지로 그래프에 돌아갑니다. 다음 회차 탐지기가 새 구멍을 찾고 세계가 누적됩니다.

파이프라인

world.json --> reason() --> find_seeds() --> ContextPack --> LLM --> story
                추론          씨앗 랭킹      서브그래프 직렬화        |
                  ^                                                  |
                  +---------------- apply_writeback() <--------------+

작업 범위

• world.json 스키마: 노드, 엣지, 온톨로지 선언, 추론 규칙
• 고정점까지 반복하는 추론 엔진을 가진 인메모리 트리플 스토어 (구조적 추론: inverse / symmetric / transitive, 규칙 추론: JSON으로 선언한 SPARQL 스타일 기본 그래프 패턴)
• 스코어링을 포함한 스토리 씨앗 패턴 탐지기 8종
• 서브그래프를 LLM 컨텍스트 팩으로 직렬화 (인물 / 관계 / 연표 / 지식 상태)
• Amazon Bedrock Converse 연동 및 역기입 페이로드 파싱
• 데모 사이트: 그래프 시각화 + 분기 스토리 출력
• 그래프 데이터베이스로 이관 (Neo4j / Neptune)
• 역기입 페이로드를 기존 정본과 대조해 검증

온톨로지 스키마

전부 world.json 의 ontology 블록에 선언되어 있어서, 코드를 고치지 않고 세계를 바꿀 수 있습니다.

구조적 추론:

"child_of":   { "inverse": "parent_of" },
"sibling_of": { "symmetric": true },
"located_in": { "transitive": true }

규칙 추론:

{
  "id": "leverage_by_secret",
  "when": [["?a", "knows", "?s"],
           ["?s", "concerns", "?b"],
           ["?s", "hidden_from", "?b"]],
  "where": { "neq": [["?a", "?b"]] },
  "then": ["?a", "has_leverage_over", "?b"],
  "props": { "tension": 0.9 }
}

패턴 탐지기

탐지기	찾는 것
secret_leverage	당사자에게만 숨겨진 비밀. 폭로 시한폭탄
love_triangle	연정에서 파생된 경쟁. 공유형(a→c, b→c)과 연쇄형(a→b, b→c)
unresolved_tension	tension이 높은데 이를 해소하는 사건 노드가 없는 관계
chekhov_object	등장했으나 회수되지 않은 사물
strangers_shared_past	같은 사건에 있었으나 서로 명시된 관계가 없는 두 사람
severed_bond	끊어졌으나 화해도 결별도 기록되지 않은 사제 관계
dangling_consequence	나가는 caused 엣지가 없는 사건. 값이 치러지지 않은 상태
contested_goal	복수 인물의 want 가 동일 대상을 가리키는 경우

현재까지 결과

• 노드 27개와 명시 엣지 52개가 추론 고정점에서 파생 엣지 52개를 만들고, 씨앗 19개가 랭킹됩니다.
• 데모는 씨앗 4개를 렌더링하고 각각 분기 3개로 펼칩니다. 분기마다 그래프로 돌아가는 엣지 집합이 다르기 때문에 다음 회차 탐지기가 다른 구멍을 찾습니다. 예: 삼각관계 씨앗의 분기 A는 jinu serves gwima 엣지를 파기하고, 분기 C는 그것을 유지한 채 rumi drawn_to gwima 를 새로 넣습니다.
• 파생 엣지가 프로버넌스(derived_by)를 들고 있어서, 데모에서 명시 관계와 추론 관계를 구분해 표시할 수 있습니다.

알려진 한계

• 추론이 전수 조인이라 노드 수가 커지면 느려집니다. allied_by_faction, shared_past 같은 규칙은 O(n^2) 엣지를 만듭니다. 실제 그래프 데이터베이스에서는 머티리얼라이즈 대신 쿼리 시 확장이 맞습니다.
• 탐지기 스코어 가중치는 손으로 정한 값입니다. 어떤 씨앗이 실제로 좋은 이야기가 되는지에 대한 피드백 루프가 없습니다.
• contested_goal 은 자유 서술인 want 필드를 노드 이름과 문자열 매칭합니다. 목표를 엣지로 모델링하면(desires 술어) 없앨 수 있습니다.
• 역기입 페이로드를 형태만 검증하고 기존 사실과의 모순은 확인하지 않습니다.