Data Preparation practice questions

Structure-aware splitters split on a document's own headings and keep those headings as chunk metadata.

The requirement has two parts: chunks bounded by sections, and section titles kept as metadata. HTMLHeaderTextSplitter does both for HTML. Flattening with get_text() loses the structure, the HTML language preset ignores which section a chunk sits in, and the Markdown splitter expects # markers rather than heading elements.

1. Identify the source format (HTML with heading elements).
2. Note both requirements: section-bounded chunks and header metadata.
3. Pick the splitter that understands that format's headers and records them.

Exam tip: Match the splitter to the format: HTML headings use HTMLHeaderTextSplitter, Markdown headings use MarkdownHeaderTextSplitter.

Header-based splitting uses the document's own structure as chunk boundaries.

When a document already marks its topics with headings, splitting on those headings gives coherent chunks and free metadata. Fixed character or token splitters ignore the headings, and semantic chunking guesses at boundaries the author already wrote down.

1. Spot that the documents have explicit structure (# and ## headings).
2. Note the problem: chunks cross section boundaries.
3. Use the splitter that splits on that structure and keeps the heading as metadata.

Exam tip: Documents with headings: split on the headings, not on a character count.

An embedding model truncates input past its token limit, so oversized chunks are only partly represented in the index.

The pattern (openings retrievable, endings not) is the signature of truncation at embedding time. Keeping chunks under the embedding model's limit fixes it. Raising the result count, overlap or generator context all act after embedding and cannot recover text the vectors never contained.

1. Compare chunk length with the embedding model's input limit.
2. Link the symptom (tail content never matches) to truncation.
3. Fix chunk size at the source rather than tuning retrieval or generation.

Exam tip: Chunks longer than the embedding model's limit are silently truncated: size chunks to the embedding model.

Chunk size is bounded by the embedding limit and by the generator's context budget: k x chunk size + prompt + answer must fit the window.

Here the embedding limit (8,192) is not the binding constraint; the generator is. The space left for retrieved text is 8,192 - 1,500 - 1,000 = 5,692 tokens. Five chunks of up to 1,000 tokens fit. The 1,200 x 5 and 600 x 10 options overflow, and 2,800 x 2 fits but passes too few chunks.

1. Work out the retrieval budget: context window minus prompt minus reserved answer.
2. Check each option's k x chunk size against that budget.
3. Discard options that fit but break the minimum chunk count.

Exam tip: Budget the generator's window: chunks retrieved x chunk size must leave room for the prompt and the answer.

Splitters measure length with a length function: by default characters, optionally tokens from a specific tokenizer.

Two facts combine. First, chunk_size is in characters unless you change the length function, which is why 512 produced ~120-token chunks. Second, a token limit is only guaranteed if you count with the same tokenizer the model uses; tiktoken's counts differ from bge's WordPiece. from_huggingface_tokenizer with the model's tokenizer satisfies both.

1. Recognise that the default length function counts characters, not tokens.
2. Note the limit is defined by the embedding model's own tokenizer.
3. Choose the token-based constructor that uses that same tokenizer.

Exam tip: Measure chunks in the embedding model's own tokens; characters and other tokenizers only approximate the limit.

Chunk overlap preserves context that straddles a chunk boundary.

The failure is a boundary cut: the instruction and its value land in different chunks. A modest overlap repeats the end of each chunk at the start of the next so the pair appears together. More results is a workaround that adds noise, temperature does nothing for missing context, and fixed-length splitting is the cause rather than the cure.

1. Diagnose the failure as content split across a chunk boundary.
2. Pick the chunking setting that repeats boundary text in adjacent chunks.
3. Keep overlap moderate so the index does not balloon with duplicate text.

Exam tip: Facts cut at chunk boundaries: add modest overlap between adjacent chunks.