Upload folder using huggingface_hub

README.md

@@ -1,5 +1,7 @@
 # ConceptCloud
 
+1. entity_extractor.py
+2. relationship_extractor.py
 
 ```
 pip install openai

pyproject.toml

@@ -8,4 +8,5 @@ dependencies = [
     "google-generativeai>=0.8.6",
     "openai>=2.28.0",
     "pdfplumber>=0.11.9",
+    "vllm>=0.16.0",
 ]

relationship_extractor.py

@@ -0,0 +1,744 @@
+#!/usr/bin/env python3
+"""
+relationship_extractor.py
+--------------------------
+Builds typed, directed relationship edges between entities extracted from
+a Deep Learning textbook (d2l-en.pdf + kg_nodes.jsonl from vocab_extractor_agent.py).
+
+This is Layer 1 of the AlphaManimator concept ontology — the prerequisite
+and dependency graph that drives scene planning and temporal ordering.
+
+Pipeline
+--------
+1. Load entities from kg_nodes.jsonl  (output of vocab_extractor_agent.py)
+2. Extract paragraph-level co-occurrence from PDF  →  candidate pairs
+3. Filter pairs by valid type combinations  →  prune search space
+4. Send batches to local vLLM server (Qwen2.5-72B or Llama-3.3-70B)
+   to classify relationship type
+5. Post-process: canonicalize direction, deduplicate, confidence filter
+6. Save kg_edges.jsonl  +  ontology_graph.json  +  prerequisite_order.json
+
+Output files (all in --output-dir)
+------------------------------------
+  kg_edges.jsonl          — one edge per line, Neo4j/NetworkX ready
+  ontology_graph.json     — full graph: nodes + edges merged
+  prerequisite_order.json — topological sort of REQUIRES edges (scene order)
+  relation_stats.json     — breakdown by relation type
+  session.json            — resume support (batch checkpointing)
+
+Local model setup (RTX 5090, 32GB VRAM)
+-----------------------------------------
+  pip install vllm
+  vllm serve Qwen/Qwen2.5-72B-Instruct-GPTQ-Int4 \\
+       --gpu-memory-utilization 0.90 \\
+       --max-model-len 8192
+
+  Then run:
+  python relationship_extractor.py d2l-en.pdf vocab_output/kg_nodes.jsonl
+
+  Or with Llama:
+  vllm serve meta-llama/Llama-3.3-70B-Instruct-AWQ \\
+       --gpu-memory-utilization 0.90
+  python relationship_extractor.py d2l-en.pdf vocab_output/kg_nodes.jsonl \\
+       --model meta-llama/Llama-3.3-70B-Instruct-AWQ
+
+AlphaManimator Layer 1 relation types → scene planner semantics
+----------------------------------------------------------------
+  IS_A        → zoom-in / hierarchy animation
+  USES        → head scene visually contains tail component
+  REQUIRES    → tail must be explained BEFORE head (prerequisite ordering)
+  PREVENTS    → contrastive animation: show problem, then solution
+  MEASURES    → link metric scene to task/concept scene
+  TRAINS      → optimization arc in animation
+  PRODUCES    → method → output object animation
+  EXTENDS     → "builds on" narrative bridge
+  APPLIED_TO  → domain context frame
+"""
+
+import argparse
+import json
+import re
+import sys
+import time
+from collections import defaultdict
+from itertools import combinations
+from pathlib import Path
+from typing import Optional
+
+try:
+    import pdfplumber
+except ImportError:
+    sys.exit("pip install pdfplumber")
+
+try:
+    from openai import OpenAI  # vLLM exposes OpenAI-compatible API
+except ImportError:
+    sys.exit("pip install openai")
+
+# ─────────────────────────────────────────────────────────────────
+# RELATION TYPES
+# ─────────────────────────────────────────────────────────────────
+
+RELATION_TYPES = {
+    "IS_A",       # backprop IS_A optimization_method
+    "USES",       # transformer USES attention
+    "REQUIRES",   # backprop REQUIRES chain_rule      ← KEY for scene ordering
+    "PREVENTS",   # dropout PREVENTS overfitting
+    "MEASURES",   # bleu MEASURES translation_quality
+    "TRAINS",     # sgd TRAINS mlp
+    "PRODUCES",   # softmax PRODUCES distribution
+    "EXTENDS",    # adam EXTENDS sgd
+    "APPLIED_TO", # classification APPLIED_TO imagenet
+    "NONE",       # no meaningful relationship → discard
+}
+
+# ─────────────────────────────────────────────────────────────────
+# VALID TYPE PAIR COMBINATIONS
+# Only these combinations are sent to the model.
+# Cuts the O(N²) pair space by ~80%.
+# ─────────────────────────────────────────────────────────────────
+
+VALID_TYPE_PAIRS = {
+    # (head_type, tail_type): [plausible relations]
+    ("METHOD",       "CONCEPT"):      ["USES", "REQUIRES", "PREVENTS", "PRODUCES"],
+    ("METHOD",       "MATH"):         ["USES", "REQUIRES", "PRODUCES"],
+    ("METHOD",       "METHOD"):       ["EXTENDS", "REQUIRES", "USES", "IS_A"],
+    ("ARCHITECTURE", "METHOD"):       ["USES", "REQUIRES"],
+    ("ARCHITECTURE", "CONCEPT"):      ["USES", "PRODUCES", "REQUIRES"],
+    ("ARCHITECTURE", "ARCHITECTURE"): ["EXTENDS", "USES", "IS_A"],
+    ("CONCEPT",      "CONCEPT"):      ["REQUIRES", "IS_A", "PRODUCES"],
+    ("CONCEPT",      "MATH"):         ["USES", "IS_A"],
+    ("TASK",         "ARCHITECTURE"): ["USES"],
+    ("TASK",         "DATASET"):      ["APPLIED_TO"],
+    ("TASK",         "METRIC"):       ["MEASURES"],
+    ("METRIC",       "TASK"):         ["MEASURES"],
+    ("METRIC",       "CONCEPT"):      ["MEASURES"],
+    ("METHOD",       "ARCHITECTURE"): ["TRAINS", "USES"],
+    ("TOOL",         "ARCHITECTURE"): ["TRAINS"],
+    ("TOOL",         "METHOD"):       ["USES"],
+    ("MATH",         "CONCEPT"):      ["IS_A", "PRODUCES"],
+    ("MATH",         "MATH"):         ["REQUIRES", "IS_A", "USES"],
+}
+
+# ─────────────────────────────────────────────────────────────────
+# SYSTEM PROMPT
+# ─────────────────────────────────────────────────────────────────
+
+SYSTEM_PROMPT = """You are building a concept ontology for a Deep Learning textbook.
+Your job is to classify the semantic relationship between pairs of ML/DL entities.
+
+Relationship types:
+  IS_A        — subtype or instance  (adam IS_A optimizer)
+  USES        — method/arch uses a component  (transformer USES attention)
+  REQUIRES    — strict prerequisite  (backpropagation REQUIRES chain_rule)
+  PREVENTS    — regularization or mitigation  (dropout PREVENTS overfitting)
+  MEASURES    — metric evaluates concept/task  (bleu MEASURES translation)
+  TRAINS      — optimization method trains architecture  (sgd TRAINS mlp)
+  PRODUCES    — method produces an output object  (softmax PRODUCES distribution)
+  EXTENDS     — builds upon or generalizes  (adam EXTENDS sgd)
+  APPLIED_TO  — task applied to dataset/domain  (classification APPLIED_TO imagenet)
+  NONE        — no clear meaningful relationship
+
+Rules:
+- Reply ONLY with a JSON array. No explanation, no markdown, no preamble.
+- Each element: {"h": "<head>", "r": "<RELATION>", "t": "<tail>"}
+- Direction matters: head → tail (the arrow goes from head to tail)
+- REQUIRES means: to understand head, you must first understand tail
+- Use NONE if no clear relationship exists in this domain
+- Be conservative: prefer NONE over a weak guess
+"""
+
+
+def make_batch_prompt(pairs: list[tuple[str, str]]) -> str:
+    pair_list = "\n".join(f'("{h}", "{t}")' for h, t in pairs)
+    return f"Classify the relationship for each entity pair (head, tail):\n{pair_list}"
+
+
+# ─────────────────────────────────────────────────────────────────
+# PDF CO-OCCURRENCE EXTRACTION
+# ─────────────────────────────────────────────────────────────────
+
+def extract_paragraphs(pdf_path: str, page_range: Optional[tuple] = None) -> list[str]:
+    """Extract paragraphs from PDF. A paragraph = contiguous non-empty lines."""
+    paragraphs = []
+    with pdfplumber.open(pdf_path) as pdf:
+        total = len(pdf.pages)
+        start, end = (1, total) if page_range is None else page_range
+        start, end = max(1, start), min(total, end)
+        print(f"  → Extracting paragraphs from pages {start}–{end} of {total} …")
+
+        for i, page in enumerate(pdf.pages[start - 1:end], start=start):
+            text = page.extract_text() or ""
+            # Split into paragraphs by blank lines
+            current = []
+            for line in text.split("\n"):
+                stripped = line.strip()
+                if stripped:
+                    current.append(stripped)
+                else:
+                    if current:
+                        paragraphs.append(" ".join(current))
+                        current = []
+            if current:
+                paragraphs.append(" ".join(current))
+
+            if i % 100 == 0:
+                print(f"     page {i}/{end} — {len(paragraphs)} paragraphs so far")
+
+    print(f"  → Extracted {len(paragraphs):,} paragraphs")
+    return paragraphs
+
+
+def build_cooccurrence_index(
+    paragraphs: list[str],
+    entity_set: set[str],
+    window: int = 1,  # paragraphs: entities co-occurring within ±window paragraphs
+) -> dict[frozenset, int]:
+    """
+    For each paragraph (±window), find all entity pairs that appear together.
+    Returns: {frozenset({e1, e2}): count}
+    """
+    print(f"  → Building co-occurrence index (window={window}) …")
+    cooccurrence: dict[frozenset, int] = defaultdict(int)
+
+    # Normalize entities for matching
+    entity_list = sorted(entity_set)
+    # Build a lookup: normalized form → canonical entity name
+    norm_map = {e.replace("_", " ").replace("-", " ").lower(): e for e in entity_list}
+    norm_keys = list(norm_map.keys())
+
+    def entities_in_text(text: str) -> set[str]:
+        text_lower = text.lower()
+        found = set()
+        for norm, canonical in norm_map.items():
+            # Whole-word match
+            pattern = r'\b' + re.escape(norm) + r'\b'
+            if re.search(pattern, text_lower):
+                found.add(canonical)
+        return found
+
+    n = len(paragraphs)
+    for i, para in enumerate(paragraphs):
+        # Gather entities from window around this paragraph
+        window_text = " ".join(paragraphs[max(0, i - window):min(n, i + window + 1)])
+        entities_here = entities_in_text(window_text)
+
+        if len(entities_here) >= 2:
+            for e1, e2 in combinations(sorted(entities_here), 2):
+                cooccurrence[frozenset({e1, e2})] += 1
+
+        if i % 500 == 0 and i > 0:
+            print(f"     paragraph {i}/{n}")
+
+    print(f"  → Found {len(cooccurrence):,} co-occurring pairs")
+    return cooccurrence
+
+
+# ─────────────────────────────────────────────────────────────────
+# CANDIDATE PAIR FILTERING
+# ─────────────────────────────────────────────────────────────────
+
+def generate_candidate_pairs(
+    entities: dict[str, dict],
+    cooccurrence: dict[frozenset, int],
+    min_cooccurrence: int = 2,
+    top_n_per_entity: int = 15,
+) -> list[tuple[str, str]]:
+    """
+    Filters co-occurring pairs by:
+    1. Valid type combination
+    2. Minimum co-occurrence count
+    3. Top-N most frequent co-occurrences per entity (to cap total pairs)
+
+    Returns directed pairs (head, tail) based on type combination rules.
+    """
+    print(f"  → Generating candidate pairs (min_cooccurrence={min_cooccurrence}) …")
+
+    # Index co-occurrence by entity for top-N selection
+    entity_cooc: dict[str, list[tuple[str, int]]] = defaultdict(list)
+    for pair, count in cooccurrence.items():
+        if count < min_cooccurrence:
+            continue
+        e1, e2 = tuple(pair)
+        e1_type = entities.get(e1, {}).get("type", "")
+        e2_type = entities.get(e2, {}).get("type", "")
+
+        # Check both directions for valid type pair
+        if (e1_type, e2_type) in VALID_TYPE_PAIRS:
+            entity_cooc[e1].append((e2, count))
+        if (e2_type, e1_type) in VALID_TYPE_PAIRS:
+            entity_cooc[e2].append((e1, count))
+
+    # Select top-N per entity by co-occurrence frequency
+    candidate_set: set[tuple[str, str]] = set()
+    for entity, partners in entity_cooc.items():
+        partners.sort(key=lambda x: -x[1])
+        e_type = entities.get(entity, {}).get("type", "")
+        for partner, _ in partners[:top_n_per_entity]:
+            p_type = entities.get(partner, {}).get("type", "")
+            if (e_type, p_type) in VALID_TYPE_PAIRS:
+                candidate_set.add((entity, partner))
+
+    candidates = sorted(candidate_set)
+    print(f"  → {len(candidates):,} candidate directed pairs after filtering")
+    return candidates
+
+
+# ─────────────────────────────────────────────────────────────────
+# LOCAL MODEL INFERENCE (vLLM OpenAI-compatible)
+# ─────────────────────────────────────────────────────────────────
+
+def call_local_model(
+    batch: list[tuple[str, str]],
+    client: OpenAI,
+    model: str,
+) -> list[dict]:
+    """Call local vLLM server with a batch of entity pairs."""
+    response = client.chat.completions.create(
+        model=model,
+        messages=[
+            {"role": "system", "content": SYSTEM_PROMPT},
+            {"role": "user",   "content": make_batch_prompt(batch)},
+        ],
+        temperature=0.05,
+        max_tokens=2048,
+    )
+    raw = response.choices[0].message.content
+    return parse_model_response(raw, batch)
+
+
+def parse_model_response(text: str, batch: list[tuple[str, str]]) -> list[dict]:
+    """Parse model JSON response. Falls back to NONE on failure."""
+    text = text.strip()
+    text = re.sub(r"^```(?:json)?|```$", "", text, flags=re.MULTILINE).strip()
+    try:
+        items = json.loads(text)
+        result = []
+        for item in items:
+            h = item.get("h", "").strip().lower().replace(" ", "_")
+            r = item.get("r", "NONE").strip().upper()
+            t = item.get("t", "").strip().lower().replace(" ", "_")
+            if r not in RELATION_TYPES:
+                r = "NONE"
+            result.append({"head": h, "relation": r, "tail": t})
+        return result
+    except Exception as e:
+        print(f"  ⚠  Parse error: {e} — marking batch as NONE")
+        return [{"head": h, "relation": "NONE", "tail": t} for h, t in batch]
+
+
+def run_extraction_batches(
+    candidates: list[tuple[str, str]],
+    client: OpenAI,
+    model: str,
+    batch_size: int,
+    session: dict,
+    session_path: Path,
+) -> list[dict]:
+    """
+    Run relationship extraction in batches with session checkpointing.
+    Returns list of edge dicts.
+    """
+    already_done: dict[str, dict] = session.get("edge_decisions", {})
+
+    def pair_key(h, t):
+        return f"{h}|||{t}"
+
+    todo = [(h, t) for h, t in candidates if pair_key(h, t) not in already_done]
+    print(f"\n  Model will classify {len(todo):,} pairs "
+          f"({len(already_done):,} already done from session)")
+
+    total_batches = (len(todo) + batch_size - 1) // batch_size
+
+    for i in range(0, len(todo), batch_size):
+        batch = todo[i:i + batch_size]
+        batch_num = i // batch_size + 1
+        print(f"  🤖 Batch {batch_num}/{total_batches} — {len(batch)} pairs …",
+              end=" ", flush=True)
+
+        retries = 3
+        for attempt in range(retries):
+            try:
+                results = call_local_model(batch, client, model)
+
+                # Map results back by head entity (model may reorder)
+                result_map = {(r["head"], r["tail"]): r["relation"] for r in results}
+
+                kept = 0
+                for h, t in batch:
+                    rel = result_map.get((h, t), "NONE")
+                    # Also try normalized variants
+                    if rel == "NONE":
+                        h_norm = h.replace("_", "").replace("-", "")
+                        t_norm = t.replace("_", "").replace("-", "")
+                        for (rh, rt), rrel in result_map.items():
+                            if (rh.replace("_","").replace("-","") == h_norm and
+                                rt.replace("_","").replace("-","") == t_norm):
+                                rel = rrel
+                                break
+
+                    edge = {"head": h, "relation": rel, "tail": t}
+                    already_done[pair_key(h, t)] = edge
+                    if rel != "NONE":
+                        kept += 1
+
+                print(f"done  ({kept}/{len(batch)} non-NONE)")
+                break
+
+            except Exception as e:
+                if attempt < retries - 1:
+                    wait = 2 ** attempt
+                    print(f"\n    ⚠ Error: {e}. Retrying in {wait}s …")
+                    time.sleep(wait)
+                else:
+                    print(f"\n    ✗ Failed after {retries} attempts. Marking as NONE.")
+                    for h, t in batch:
+                        already_done[pair_key(h, t)] = {"head": h, "relation": "NONE", "tail": t}
+
+        # Checkpoint after every batch
+        session["edge_decisions"] = already_done
+        with open(session_path, "w") as f:
+            json.dump(session, f, indent=2)
+
+    # Collect all non-NONE edges
+    edges = [
+        edge for edge in already_done.values()
+        if edge["relation"] != "NONE"
+    ]
+    return edges
+
+
+# ─────────────────────────────────────────────────────────────────
+# POST-PROCESSING
+# ─────────────────────────────────────────────────────────────────
+
+def postprocess_edges(
+    raw_edges: list[dict],
+    entities: dict[str, dict],
+) -> list[dict]:
+    """
+    1. Attach entity types to edges
+    2. Deduplicate: if A→B and B→A both exist, keep the one matching
+       canonical type-pair direction
+    3. Add confidence proxy (co-occurrence count enriched later)
+    """
+    print(f"  → Post-processing {len(raw_edges)} raw edges …")
+
+    # Deduplicate: keep canonical direction based on VALID_TYPE_PAIRS
+    seen: dict[frozenset, dict] = {}
+
+    for edge in raw_edges:
+        h, r, t = edge["head"], edge["relation"], edge["tail"]
+        h_type = entities.get(h, {}).get("type", "OTHER")
+        t_type = entities.get(t, {}).get("type", "OTHER")
+
+        key = frozenset({h, t})
+        enriched = {
+            "head":      h,
+            "relation":  r,
+            "tail":      t,
+            "head_type": h_type,
+            "tail_type": t_type,
+        }
+
+        if key not in seen:
+            seen[key] = enriched
+        else:
+            # Keep the edge whose direction matches VALID_TYPE_PAIRS
+            existing = seen[key]
+            existing_valid = (existing["head_type"], existing["tail_type"]) in VALID_TYPE_PAIRS
+            new_valid      = (h_type, t_type) in VALID_TYPE_PAIRS
+            if new_valid and not existing_valid:
+                seen[key] = enriched
+            # If both valid, keep both as separate edges (different relations)
+            elif new_valid and existing_valid and existing["relation"] != r:
+                # Use a different key to keep both
+                seen[frozenset({h, t, r})] = enriched
+
+    final_edges = list(seen.values())
+    print(f"  → {len(final_edges)} edges after deduplication")
+    return final_edges
+
+
+def build_prerequisite_order(edges: list[dict]) -> list[str]:
+    """
+    Topological sort of REQUIRES edges.
+    Returns concept names in the order they should be explained
+    (tail before head — prerequisite first).
+    This is the scene ordering input for AlphaManimator's proxy scorer.
+    """
+    from collections import deque
+
+    requires_edges = [(e["head"], e["tail"]) for e in edges if e["relation"] == "REQUIRES"]
+    if not requires_edges:
+        return []
+
+    # Build graph: tail → head (explain tail first)
+    graph: dict[str, list[str]] = defaultdict(list)
+    in_degree: dict[str, int] = defaultdict(int)
+    all_nodes: set[str] = set()
+
+    for head, tail in requires_edges:
+        graph[tail].append(head)
+        in_degree[head] += 1
+        all_nodes.update([head, tail])
+
+    # Kahn's algorithm
+    queue = deque([n for n in all_nodes if in_degree[n] == 0])
+    order = []
+    while queue:
+        node = queue.popleft()
+        order.append(node)
+        for neighbor in graph[node]:
+            in_degree[neighbor] -= 1
+            if in_degree[neighbor] == 0:
+                queue.append(neighbor)
+
+    # Append any nodes not in the REQUIRES subgraph (no ordering constraint)
+    remaining = all_nodes - set(order)
+    order.extend(sorted(remaining))
+
+    return order
+
+
+# ─────────────────────────────────────────────────────────────────
+# OUTPUT
+# ─────────────────────────────────────────────────────────────────
+
+def save_outputs(
+    edges: list[dict],
+    entities: dict[str, dict],
+    output_dir: Path,
+):
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # ── kg_edges.jsonl ───────────────────────────────────
+    with open(output_dir / "kg_edges.jsonl", "w") as f:
+        for edge in sorted(edges, key=lambda e: (e["relation"], e["head"])):
+            f.write(json.dumps(edge) + "\n")
+
+    # ── ontology_graph.json ──────────────────────────────
+    # Full graph: nodes (from entities) + edges merged
+    graph = {
+        "nodes": [
+            {
+                "id":   e_id,
+                "type": e_data["type"],
+                "freq": e_data.get("freq", 0),
+            }
+            for e_id, e_data in entities.items()
+        ],
+        "edges": edges,
+        "meta": {
+            "total_nodes": len(entities),
+            "total_edges": len(edges),
+            "relation_types": sorted(RELATION_TYPES - {"NONE"}),
+        }
+    }
+    with open(output_dir / "ontology_graph.json", "w") as f:
+        json.dump(graph, f, indent=2, ensure_ascii=False)
+
+    # ── prerequisite_order.json ──────────────────────────
+    prereq_order = build_prerequisite_order(edges)
+    with open(output_dir / "prerequisite_order.json", "w") as f:
+        json.dump({
+            "description": (
+                "Topological ordering of concepts via REQUIRES edges. "
+                "AlphaManimator scene planner must explain concepts in this order."
+            ),
+            "order": prereq_order,
+            "total": len(prereq_order),
+        }, f, indent=2)
+
+    # ── relation_stats.json ──────────────────────────────
+    rel_counts: dict[str, int] = defaultdict(int)
+    type_pair_counts: dict[str, int] = defaultdict(int)
+    for edge in edges:
+        rel_counts[edge["relation"]] += 1
+        pair = f"{edge['head_type']} → {edge['tail_type']}"
+        type_pair_counts[pair] += 1
+
+    stats = {
+        "total_edges": len(edges),
+        "by_relation": dict(sorted(rel_counts.items(), key=lambda x: -x[1])),
+        "by_type_pair": dict(sorted(type_pair_counts.items(), key=lambda x: -x[1])[:30]),
+        "prerequisite_chain_length": len(prereq_order),
+    }
+    with open(output_dir / "relation_stats.json", "w") as f:
+        json.dump(stats, f, indent=2)
+
+    # ── Print summary ────────────────────────────────────
+    print(f"\n  ✅ Output saved to: {output_dir}/")
+    print(f"     kg_edges.jsonl          — {len(edges)} edges (Neo4j/NetworkX ready)")
+    print(f"     ontology_graph.json     — full graph ({len(entities)} nodes + {len(edges)} edges)")
+    print(f"     prerequisite_order.json — {len(prereq_order)} concepts in scene order")
+    print(f"     relation_stats.json     — breakdown by relation type")
+    print(f"\n  Relation type breakdown:")
+    for rel, count in sorted(rel_counts.items(), key=lambda x: -x[1]):
+        bar = "█" * min(40, count)
+        print(f"    {rel:<14} {count:>5}  {bar}")
+
+    if prereq_order:
+        print(f"\n  First 10 concepts in prerequisite order (AlphaManimator scene sequence):")
+        for i, concept in enumerate(prereq_order[:10], 1):
+            print(f"    {i:>2}. {concept}")
+
+
+# ─────────────────────────────────────────────────────────────────
+# CLI
+# ─────────────────────────────────────────────────────────────────
+
+def parse_page_range(s: str):
+    parts = s.split("-")
+    if len(parts) != 2:
+        raise argparse.ArgumentTypeError("Use format like '1-100'")
+    return int(parts[0]), int(parts[1])
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description=(
+            "Build a typed relationship graph (Layer 1 concept ontology) "
+            "from d2l-en.pdf + kg_nodes.jsonl using a local vLLM model."
+        )
+    )
+    parser.add_argument("pdf",
+        help="Path to d2l-en.pdf (or any DL textbook PDF)")
+    parser.add_argument("kg_nodes",
+        help="Path to kg_nodes.jsonl from vocab_extractor_agent.py")
+    parser.add_argument("--model",
+        default="Qwen/Qwen2.5-72B-Instruct-GPTQ-Int4",
+        help="Model name served by vLLM (default: Qwen2.5-72B-Instruct-GPTQ-Int4)")
+    parser.add_argument("--vllm-url",
+        default="http://localhost:8000/v1",
+        help="vLLM server base URL (default: http://localhost:8000/v1)")
+    parser.add_argument("--pages",
+        type=parse_page_range, default=None, metavar="START-END",
+        help="Page range to extract from PDF, e.g. 1-500 (default: all)")
+    parser.add_argument("--batch-size",
+        type=int, default=20,
+        help="Entity pairs per model call (default: 20, max ~30 for reliability)")
+    parser.add_argument("--min-cooccurrence",
+        type=int, default=2,
+        help="Min paragraph co-occurrence for a pair to be considered (default: 2)")
+    parser.add_argument("--top-n-per-entity",
+        type=int, default=15,
+        help="Max candidate partners per entity, ranked by co-occurrence (default: 15)")
+    parser.add_argument("--output-dir",
+        default="ontology_output",
+        help="Output directory (default: ontology_output/)")
+    parser.add_argument("--resume",
+        action="store_true",
+        help="Resume from existing session.json in output-dir")
+    parser.add_argument("--cooccurrence-window",
+        type=int, default=1,
+        help="Paragraph window for co-occurrence (default: 1 = ±1 paragraph)")
+    args = parser.parse_args()
+
+    pdf_path      = Path(args.pdf)
+    kg_nodes_path = Path(args.kg_nodes)
+    output_dir    = Path(args.output_dir)
+    session_path  = output_dir / "session.json"
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    if not pdf_path.exists():
+        sys.exit(f"PDF not found: {pdf_path}")
+    if not kg_nodes_path.exists():
+        sys.exit(f"kg_nodes.jsonl not found: {kg_nodes_path}")
+
+    # ── Load or init session ──────────────────────────────
+    session = {}
+    if args.resume and session_path.exists():
+        with open(session_path) as f:
+            session = json.load(f)
+        print(f"  ↺  Resumed session from {session_path}")
+
+    # ── Step 1: Load entities ─────────────────────────────
+    print(f"\n[1/5] Loading entities from {kg_nodes_path} …")
+    entities: dict[str, dict] = {}
+    with open(kg_nodes_path) as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            node = json.loads(line)
+            entity_id = node.get("id") or node.get("label", "").replace(" ", "_")
+            entities[entity_id] = {
+                "type":  node.get("type", "OTHER"),
+                "freq":  node.get("freq", 0),
+                "label": node.get("label", entity_id),
+            }
+    print(f"  → Loaded {len(entities):,} entities")
+
+    entity_set = set(entities.keys())
+    # Also add label forms for matching
+    label_to_id = {v["label"]: k for k, v in entities.items()}
+
+    # ── Step 2: Extract paragraphs & co-occurrence ────────
+    print(f"\n[2/5] Extracting paragraph co-occurrence from PDF …")
+    if "cooccurrence" in session:
+        print("  Using cached co-occurrence index from session.")
+        cooccurrence = {
+            frozenset(k.split("|||")): v
+            for k, v in session["cooccurrence"].items()
+        }
+    else:
+        paragraphs   = extract_paragraphs(str(pdf_path), args.pages)
+        cooccurrence = build_cooccurrence_index(
+            paragraphs, entity_set, window=args.cooccurrence_window
+        )
+        # Serialize for session (frozenset → string key)
+        session["cooccurrence"] = {
+            "|||".join(sorted(k)): v
+            for k, v in cooccurrence.items()
+        }
+        with open(session_path, "w") as f:
+            json.dump(session, f, indent=2)
+
+    # ── Step 3: Generate candidate pairs ──────────────────
+    print(f"\n[3/5] Generating candidate pairs …")
+    candidates = generate_candidate_pairs(
+        entities,
+        cooccurrence,
+        min_cooccurrence=args.min_cooccurrence,
+        top_n_per_entity=args.top_n_per_entity,
+    )
+
+    # ── Step 4: Run local model ───────────────────────────
+    print(f"\n[4/5] Running relationship extraction via local vLLM …")
+    print(f"  Model : {args.model}")
+    print(f"  Server: {args.vllm_url}")
+    print(f"  Batch : {args.batch_size} pairs per call")
+
+    client = OpenAI(base_url=args.vllm_url, api_key="not-needed")
+
+    # Quick connectivity check
+    try:
+        models = client.models.list()
+        available = [m.id for m in models.data]
+        print(f"  ✓ vLLM server reachable. Available models: {available}")
+    except Exception as e:
+        sys.exit(
+            f"\n  ✗ Cannot reach vLLM server at {args.vllm_url}\n"
+            f"    Error: {e}\n\n"
+            f"  Start the server first:\n"
+            f"    vllm serve {args.model} --gpu-memory-utilization 0.90\n"
+        )
+
+    raw_edges = run_extraction_batches(
+        candidates,
+        client,
+        args.model,
+        args.batch_size,
+        session,
+        session_path,
+    )
+
+    # ── Step 5: Post-process & save ───────────────────────
+    print(f"\n[5/5] Post-processing and saving outputs …")
+    final_edges = postprocess_edges(raw_edges, entities)
+    save_outputs(final_edges, entities, output_dir)
+
+
+if __name__ == "__main__":
+    main()