scripts/build_chunks.py

#!/usr/bin/env python3
"""Build RAG chunks from parsed turns for the Audrey Tang transcript dataset.

Reads turns.jsonl and produces embedding-ready chunks in chunks.jsonl.

Chunking strategy:
- Primary unit: each Audrey turn + the question that prompted it
- Long turns (>600 token estimate): split at paragraph boundaries with overlap
- Short turns (<50 token estimate): kept as-is (no adjacent Audrey turns to merge with)
- Question field: last non-Audrey turn before the response
- Context_before: up to 2 preceding turns for retrieval context
"""

import json
import statistics
import sys
from collections import Counter, defaultdict
from pathlib import Path

INPUT = Path(__file__).resolve().parent.parent / "data" / "turns.jsonl"
OUTPUT = Path(__file__).resolve().parent.parent / "data" / "chunks.jsonl"

# Token estimation: 1 token per 4 chars for English, 1 token per 1.5 chars for Chinese
SPLIT_THRESHOLD = 600  # token estimate above which we split
TARGET_MIN = 200       # target tokens per sub-chunk
TARGET_MAX = 500       # target tokens per sub-chunk


def token_estimate(text: str, language: str) -> int:
    if language == "zh":
        return max(1, round(len(text) / 1.5))
    else:
        return max(1, round(len(text) / 4))


def split_into_paragraphs(text: str) -> list[str]:
    """Split text into non-empty paragraphs."""
    return [p.strip() for p in text.split("\n\n") if p.strip()]


def last_sentence(text: str) -> str:
    """Extract the last sentence from text for overlap context."""
    # Handle both Chinese and English sentence endings
    for sep in ["。", ".\n", ". ", "！", "？", "!\n", "! ", "?\n", "? "]:
        parts = text.rsplit(sep, 1)
        if len(parts) == 2 and parts[1].strip():
            return parts[1].strip()
        elif len(parts) == 2:
            # Separator was at the end; try to get the last real sentence
            inner = parts[0]
            for sep2 in ["。", ". ", "！", "？", "! ", "? "]:
                inner_parts = inner.rsplit(sep2, 1)
                if len(inner_parts) == 2:
                    return inner_parts[1].strip() + sep.strip()
            return inner[-200:] if len(inner) > 200 else inner
    # No sentence boundary found; return last 200 chars
    return text[-200:] if len(text) > 200 else text


def build_sub_chunks(text: str, language: str) -> list[str]:
    """Split a long text into sub-chunks at paragraph boundaries."""
    paragraphs = split_into_paragraphs(text)
    if not paragraphs:
        return [text]

    # If a single paragraph is still too long, we keep it as-is
    # (further splitting within paragraphs would break mid-thought)
    chunks = []
    current_parts = []
    current_tokens = 0

    for para in paragraphs:
        para_tokens = token_estimate(para, language)

        # If adding this paragraph would exceed target and we have content, emit
        if current_tokens + para_tokens > TARGET_MAX and current_parts:
            chunk_text = "\n\n".join(current_parts)
            chunks.append(chunk_text)

            # 1-sentence overlap for continuity
            overlap = last_sentence(current_parts[-1])
            overlap_tokens = token_estimate(overlap, language)
            if overlap_tokens < 100:
                current_parts = [overlap]
                current_tokens = overlap_tokens
            else:
                current_parts = []
                current_tokens = 0

        current_parts.append(para)
        current_tokens += para_tokens

    # Emit remaining content
    if current_parts:
        chunk_text = "\n\n".join(current_parts)
        # If this last chunk is very small and we have previous chunks, merge it
        if chunks and token_estimate(chunk_text, language) < TARGET_MIN // 2:
            chunks[-1] = chunks[-1] + "\n\n" + chunk_text
        else:
            chunks.append(chunk_text)

    return chunks if chunks else [text]


def main():
    # Read all turns, group by source_file
    turns_by_source = defaultdict(list)
    with open(INPUT) as f:
        for line in f:
            turn = json.loads(line)
            turns_by_source[turn["source_file"]].append(turn)

    # Sort each group by turn_index
    for source in turns_by_source:
        turns_by_source[source].sort(key=lambda t: t["turn_index"])

    chunks = []

    for source_file, turns in sorted(turns_by_source.items()):
        chunk_counter = 0
        # Derive stem from source_file (remove .md extension)
        stem = source_file.rsplit(".", 1)[0] if "." in source_file else source_file

        for i, turn in enumerate(turns):
            if not turn["is_audrey"]:
                continue

            # Find question: last non-Audrey turn before this response
            question = None
            for j in range(i - 1, -1, -1):
                if not turns[j]["is_audrey"]:
                    question = turns[j]["text"]
                    break

            # Find context_before: up to 2 preceding turns (any speaker)
            context_parts = []
            for j in range(max(0, i - 2), i):
                ctx = turns[j]
                context_parts.append(f"{ctx['speaker']}: {ctx['text']}")
            context_before = "\n\n".join(context_parts) if context_parts else None

            te = token_estimate(turn["text"], turn["language"])

            if te > SPLIT_THRESHOLD:
                # Split long turn into sub-chunks
                sub_texts = build_sub_chunks(turn["text"], turn["language"])
                for k, sub_text in enumerate(sub_texts):
                    sub_te = token_estimate(sub_text, turn["language"])
                    chunk = {
                        "id": f"{stem}/chunk_{chunk_counter:03d}",
                        "date": turn["date"],
                        "title": turn["title"],
                        "language": turn["language"],
                        "speaker": turn["speaker"],
                        "question": question if k == 0 else None,
                        "text": sub_text,
                        "context_before": context_before if k == 0 else None,
                        "token_estimate": sub_te,
                        "source_file": turn["source_file"],
                    }
                    chunks.append(chunk)
                    chunk_counter += 1
            else:
                # Single chunk
                chunk = {
                    "id": f"{stem}/chunk_{chunk_counter:03d}",
                    "date": turn["date"],
                    "title": turn["title"],
                    "language": turn["language"],
                    "speaker": turn["speaker"],
                    "question": question,
                    "text": turn["text"],
                    "context_before": context_before,
                    "token_estimate": te,
                    "source_file": turn["source_file"],
                }
                chunks.append(chunk)
                chunk_counter += 1

    # Write output
    with open(OUTPUT, "w") as f:
        for chunk in chunks:
            f.write(json.dumps(chunk, ensure_ascii=False) + "\n")

    # Print statistics
    token_estimates = [c["token_estimate"] for c in chunks]
    languages = Counter(c["language"] for c in chunks)
    years = Counter(c["date"][:4] for c in chunks)
    under_100 = sum(1 for t in token_estimates if t < 100)
    over_600 = sum(1 for t in token_estimates if t > 600)

    print(f"=== RAG Chunk Statistics ===")
    print(f"Total chunks: {len(chunks):,}")
    print(f"Unique source files: {len(set(c['source_file'] for c in chunks)):,}")
    print()
    print(f"Token estimates:")
    print(f"  Mean:   {statistics.mean(token_estimates):.1f}")
    print(f"  Median: {statistics.median(token_estimates):.1f}")
    print(f"  Min:    {min(token_estimates)}")
    print(f"  Max:    {max(token_estimates)}")
    print(f"  Stdev:  {statistics.stdev(token_estimates):.1f}")
    print()
    print(f"Out-of-range chunks:")
    print(f"  Below 100 tokens: {under_100:,} ({under_100/len(chunks)*100:.1f}%)")
    print(f"  Above 600 tokens: {over_600:,} ({over_600/len(chunks)*100:.1f}%)")
    print()
    print(f"Language split:")
    for lang, count in sorted(languages.items()):
        print(f"  {lang}: {count:,} ({count/len(chunks)*100:.1f}%)")
    print()
    print(f"Chunks by year:")
    for year, count in sorted(years.items()):
        print(f"  {year}: {count:,}")
    print()
    print(f"Output written to: {OUTPUT}")
    print(f"Output size: {OUTPUT.stat().st_size / 1024 / 1024:.1f} MB")


if __name__ == "__main__":
    main()