Warum naives Chunking den Abruf verschlechtert

Chunking is the process of splitting documents into smaller pieces before embedding them into a vector store. The way you chunk determines what context is available during retrieval. Poor chunking is one of the most common and impactful causes of RAG system failures.

Imagine a document that says: 'The refund policy is 30 days from purchase. Customers must include the original receipt.' If a fixed-size splitter cuts after 'purchase.', these two sentences land in different chunks. A query about the refund policy may only retrieve the first half — making the model unable to mention the receipt requirement.

Documents often use section headers to provide meaning. Consider a table titled 'Pricing for Enterprise Plans' followed by rows of numbers. If the header and the table land in different chunks, the retrieved table chunk contains numbers with no label — the model cannot answer 'What is the Enterprise price?' correctly.

Fixed-size chunking splits text every N characters or tokens regardless of sentence boundaries. This is fast and simple but breaks mid-sentence frequently. A chunk ending with 'The model was trained on' and a following chunk starting with 'a dataset of 500 billion tokens' are each meaningless without the other.

A common fix is adding chunk overlap — repeating the last N tokens of a chunk at the start of the next. This helps with split sentences but introduces redundancy and can confuse retrievers when two highly similar chunks both get retrieved. Overlap is a band-aid, not a cure for structural chunking problems.

You can measure how often your chunking hurts retrieval by building a small golden evaluation set: a list of questions with known correct source passages. Then check how often the correct passage is in the top-k retrieved chunks. A low hit rate often reveals chunking problems before you even look at generation quality.

Code files, JSON, and tables have logical units — functions, objects, table rows — that should not be split. Splitting a Python function definition across two chunks means neither chunk is independently understandable. A retriever that finds the second chunk sees argument-less code with no context.

Research on LLMs shows the 'lost in the middle' phenomenon: when many chunks are retrieved and stuffed into a prompt, the model pays attention to content near the beginning and end but tends to ignore the middle. Poor chunking that produces many small low-quality chunks makes this worse by diluting the relevant signal.

A quick diagnostic is to print a random sample of your chunks and read them. Ask yourself: Is this chunk meaningful in isolation? If a user asked a question, could the model answer it from this chunk alone? Chunks that reference undefined pronouns ('He said that...'), incomplete code, or context-free numbers are red flags.

Very large chunks hurt retrieval precision. A 2000-token chunk about a broad topic may match many queries but deliver too much noise to the LLM. The model has to find the needle in the haystack within that chunk. Smaller, focused chunks improve precision at the cost of potentially missing surrounding context.

Better alternatives to naive fixed-size chunking include: sentence-boundary splitting that never cuts mid-sentence, semantic chunking that splits at topic boundaries, parent-child chunking that preserves broader context, and document-aware splitting that respects code functions, HTML tags, and Markdown headers. Each lesson ahead covers one of these.

Test your understanding of chunking failure modes from this lesson.

In this lesson you learned: naive fixed-size chunking breaks sentence and section boundaries, overlap is a partial fix but adds redundancy, and chunk quality directly determines retrieval hit rate. Next up we explore semantic chunking, which splits text at natural topic boundaries using embedding similarity.